-{/if}
-
-
diff --git a/src/lib/agent-activity.test.ts b/src/lib/agent-activity.test.ts
new file mode 100644
index 0000000..359ccdc
--- /dev/null
+++ b/src/lib/agent-activity.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import {
+ claudeCodeCommand,
+ clientLabel,
+ describeActivity,
+ mcpServersJson,
+ parseAccess,
+ parseActivityLog,
+ timeAgo,
+ type AgentActivity,
+} from "./agent-activity";
+
+const entry = (over: Partial): AgentActivity => ({
+ at: 0,
+ client: "claude-code",
+ tool: "get_note",
+ kind: "read",
+ noteIds: ["n1"],
+ noteCount: 1,
+ titles: ["Groceries"],
+ space: null,
+ tag: null,
+ query: null,
+ ...over,
+});
+
+describe("agent activity", () => {
+ it("names known clients and tidies unknown ones", () => {
+ expect(clientLabel("claude-code")).toBe("Claude Code");
+ expect(clientLabel("Cursor")).toBe("Cursor");
+ expect(clientLabel("my-local_bot")).toBe("My Local Bot");
+ expect(clientLabel("")).toBe("An agent");
+ expect(clientLabel("agent")).toBe("An agent");
+ });
+
+ it("describes calls in plain words", () => {
+ expect(describeActivity(entry({}))).toBe("Reading “Groceries”");
+ expect(describeActivity(entry({ tool: "list_notes", space: "Ideas" }))).toBe(
+ "Looking through Ideas",
+ );
+ expect(describeActivity(entry({ tool: "search_notes", query: "sync" }))).toBe(
+ "Searching for “sync”",
+ );
+ expect(describeActivity(entry({ tool: "append_to_note", kind: "write" }))).toBe(
+ "Adding to “Groceries”",
+ );
+ expect(describeActivity(entry({ tool: "create_note", titles: [""] }))).toBe(
+ "Writing a new note, “Untitled”",
+ );
+ });
+
+ it("reads access defensively, defaulting to off", () => {
+ expect(parseAccess("write")).toBe("write");
+ expect(parseAccess("read")).toBe("read");
+ expect(parseAccess("everything")).toBe("off");
+ expect(parseAccess(null)).toBe("off");
+ });
+
+ it("drops malformed log entries", () => {
+ const good = entry({});
+ expect(parseActivityLog([good, { at: "x" }, null, 3])).toEqual([good]);
+ expect(parseActivityLog("nope")).toEqual([]);
+ });
+
+ it("says how long ago", () => {
+ expect(timeAgo(0, 10_000)).toBe("just now");
+ expect(timeAgo(0, 4 * 60_000)).toBe("4 min ago");
+ expect(timeAgo(0, 3 * 3_600_000)).toBe("3 h ago");
+ expect(timeAgo(0, 3 * 86_400_000)).toBe("3 d ago");
+ });
+
+ it("builds connect commands, quoting paths with spaces", () => {
+ const c = {
+ exe: "/Applications/InstantNotes.app/Contents/MacOS/instantnotes",
+ db: "/Users/me/Library/Application Support/com.instantnotes.app/instantnotes.db",
+ attachments: null,
+ };
+ expect(claudeCodeCommand(c)).toBe(
+ "claude mcp add instantnotes -- /Applications/InstantNotes.app/Contents/MacOS/instantnotes mcp --db '/Users/me/Library/Application Support/com.instantnotes.app/instantnotes.db'",
+ );
+ const json = JSON.parse(mcpServersJson({ ...c, attachments: "/a b" }));
+ expect(json.mcpServers.instantnotes.args).toEqual([
+ "mcp",
+ "--db",
+ c.db,
+ "--attachments",
+ "/a b",
+ ]);
+ });
+});
diff --git a/src/lib/agent-activity.ts b/src/lib/agent-activity.ts
new file mode 100644
index 0000000..8072619
--- /dev/null
+++ b/src/lib/agent-activity.ts
@@ -0,0 +1,166 @@
+// Agent access, the parts with no runes: the activity record the MCP server
+// writes (src-tauri/agents/src/tools.rs), how it reads in plain words, and
+// the commands that connect an agent. Shared by the agents store, the
+// sidebar's live line, and Settings > Agents.
+
+/** Settings keys, owned by the MCP server's side (tools.rs). */
+export const AGENT_ACCESS_KEY = "agents.access";
+export const AGENT_ACTIVITY_KEY = "agents.activity";
+
+export type AgentAccess = "off" | "read" | "write";
+
+/** One agent call, as the server records it. */
+export interface AgentActivity {
+ /** Epoch milliseconds. */
+ at: number;
+ /** The client's own name from the MCP handshake, e.g. "claude-code". */
+ client: string;
+ tool: string;
+ kind: "read" | "write";
+ noteIds: string[];
+ noteCount: number;
+ /** The first few touched notes' titles. */
+ titles: string[];
+ space: string | null;
+ tag: string | null;
+ query: string | null;
+}
+
+export function parseAccess(value: unknown): AgentAccess {
+ return value === "read" || value === "write" ? value : "off";
+}
+
+/** Keep only well-formed entries: the log is data another process wrote. */
+export function parseActivityLog(value: unknown): AgentActivity[] {
+ if (!Array.isArray(value)) return [];
+ return value.filter(
+ (e): e is AgentActivity =>
+ !!e &&
+ typeof e === "object" &&
+ typeof e.at === "number" &&
+ typeof e.tool === "string" &&
+ (e.kind === "read" || e.kind === "write") &&
+ Array.isArray(e.noteIds),
+ );
+}
+
+/** Whether a batch of outside writes may have changed this note. No entries
+ * means a write the log does not describe (a second copy of the app), which
+ * may have touched anything. */
+export function mayHaveWritten(entries: AgentActivity[], noteId: string): boolean {
+ return (
+ entries.length === 0 ||
+ entries.some((e) => e.kind === "write" && e.noteIds.includes(noteId))
+ );
+}
+
+const KNOWN_CLIENTS: Record = {
+ "claude-code": "Claude Code",
+ "claude-ai": "Claude",
+ "claude-desktop": "Claude",
+ codex: "Codex",
+ "codex-mcp-client": "Codex",
+ cursor: "Cursor",
+ "cursor-vscode": "Cursor",
+ "gemini-cli": "Gemini CLI",
+ hermes: "Hermes",
+ vscode: "VS Code",
+ zed: "Zed",
+};
+
+/** A client's handshake name as a person would say it. */
+export function clientLabel(raw: string): string {
+ const name = raw.trim();
+ const known = KNOWN_CLIENTS[name.toLowerCase()];
+ if (known) return known;
+ if (!name || name === "agent") return "An agent";
+ return name
+ .split(/[-_\s]+/)
+ .filter(Boolean)
+ .map((w) => w[0].toUpperCase() + w.slice(1))
+ .join(" ");
+}
+
+const quote = (s: string) => `“${s || "Untitled"}”`;
+
+/** What the call did, in words: "Reading “Groceries”". */
+export function describeActivity(e: AgentActivity): string {
+ const title = quote(e.titles[0] ?? "");
+ const more = e.noteCount > 1 ? ` and ${e.noteCount - 1} more` : "";
+ switch (e.tool) {
+ case "search_notes":
+ return `Searching for ${quote(e.query ?? "")}`;
+ case "list_notes":
+ if (e.space) return `Looking through ${e.space}`;
+ if (e.tag) return `Looking through #${e.tag}`;
+ return "Looking through your notes";
+ case "get_note":
+ return `Reading ${title}${more}`;
+ case "list_tags":
+ return "Looking at your tags";
+ case "list_spaces":
+ return "Looking at your Spaces";
+ case "create_note":
+ return `Writing a new note, ${title}`;
+ case "update_note":
+ return `Editing ${title}`;
+ case "append_to_note":
+ return `Adding to ${title}`;
+ case "tag_note":
+ return `Tagging ${title} #${e.tag ?? ""}`;
+ case "untag_note":
+ return `Removing #${e.tag ?? ""} from ${title}`;
+ case "add_to_space":
+ return `Filing ${title} in ${e.space ?? "a Space"}`;
+ case "remove_from_space":
+ return `Taking ${title} out of ${e.space ?? "a Space"}`;
+ case "trash_note":
+ return `Moving ${title} to Trash`;
+ case "restore_note":
+ return `Restoring ${title}`;
+ default:
+ return e.kind === "write" ? "Changing your notes" : "Reading your notes";
+ }
+}
+
+/** "just now", "4 min ago", "2 h ago", "3 d ago". */
+export function timeAgo(at: number, now: number): string {
+ const s = Math.max(0, Math.round((now - at) / 1000));
+ if (s < 45) return "just now";
+ const m = Math.round(s / 60);
+ if (m < 60) return `${m} min ago`;
+ const h = Math.round(m / 60);
+ if (h < 48) return `${h} h ago`;
+ return `${Math.round(h / 24)} d ago`;
+}
+
+/** Where the app and its library live, from `agent_connection`. */
+export interface AgentConnection {
+ exe: string;
+ db: string;
+ attachments: string | null;
+}
+
+function serverArgs(c: AgentConnection): string[] {
+ const args = ["mcp", "--db", c.db];
+ if (c.attachments) args.push("--attachments", c.attachments);
+ return args;
+}
+
+const shellQuote = (s: string) => (/^[\w./:@-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`);
+
+/** One line for Claude Code. */
+export function claudeCodeCommand(c: AgentConnection): string {
+ return ["claude", "mcp", "add", "instantnotes", "--", c.exe, ...serverArgs(c)]
+ .map(shellQuote)
+ .join(" ");
+}
+
+/** The `mcpServers` entry most other clients take (Claude Desktop, Cursor). */
+export function mcpServersJson(c: AgentConnection): string {
+ return JSON.stringify(
+ { mcpServers: { instantnotes: { command: c.exe, args: serverArgs(c) } } },
+ null,
+ 2,
+ );
+}
diff --git a/src/lib/agreements.svelte.ts b/src/lib/agreements.svelte.ts
new file mode 100644
index 0000000..4453cc6
--- /dev/null
+++ b/src/lib/agreements.svelte.ts
@@ -0,0 +1,108 @@
+// The Jam-Sw agreement gate for Svelte apps: the rules every platform follows
+// (installers README, "The agreement gate"), with no UI of its own. Copied
+// into the app by installers/scripts/apply.mjs, so never edit the copy.
+//
+// Render it with AgreementGate.svelte, or in the app's own way, as long as
+// nothing in the app is usable until `done` is true and every document is
+// shown with its own agreement. The texts come from agreements.json, which
+// apply.mjs writes from the same strings as LICENSE and EULA.txt.
+
+import manifest from '../../src-tauri/installer/agreements.json';
+
+export interface AgreementDocument {
+ id: string;
+ title: string;
+ /** Agreement is stored per version; a new version asks again. */
+ version: string;
+ text: string;
+}
+
+export interface AgreementCopy {
+ heading: string;
+ lead: string;
+ agree: string;
+ agreed: string;
+ decline: string;
+}
+
+/** Document id to the version agreed to. */
+export type Accepted = Record;
+
+type Versioned = Pick;
+
+function asAccepted(stored: unknown): Accepted {
+ if (!stored || typeof stored !== 'object' || Array.isArray(stored)) return {};
+ return Object.fromEntries(
+ Object.entries(stored).filter(([, v]) => typeof v === 'string'),
+ ) as Accepted;
+}
+
+/** Ids of the documents still to agree to, in manifest order. */
+export function pendingDocuments(documents: Versioned[], stored: unknown): string[] {
+ const accepted = asAccepted(stored);
+ return documents.filter((d) => accepted[d.id] !== d.version).map((d) => d.id);
+}
+
+/** What to store after agreeing to `id`: the version shown for it, the other
+ * listed documents as they were, and nothing for documents no longer listed. */
+export function withAccepted(documents: Versioned[], stored: unknown, id: string): Accepted {
+ const accepted = asAccepted(stored);
+ const next: Accepted = {};
+ for (const d of documents) {
+ if (d.id === id) next[d.id] = d.version;
+ else if (d.id in accepted) next[d.id] = accepted[d.id];
+ }
+ return next;
+}
+
+const KEY: string = manifest.storageKey;
+
+function read(): unknown {
+ try {
+ const raw = localStorage.getItem(KEY);
+ return raw ? JSON.parse(raw) : {};
+ } catch {
+ // Unreadable or unavailable: nothing counts as agreed, the safe side.
+ return {};
+ }
+}
+
+class Agreements {
+ readonly documents: AgreementDocument[] = manifest.documents;
+ readonly copy: AgreementCopy = manifest.copy;
+ #stored = $state(read());
+ readonly pending = $derived(pendingDocuments(this.documents, this.#stored));
+
+ /** True once every document is agreed to at its current version. */
+ get done(): boolean {
+ return this.pending.length === 0;
+ }
+
+ isAgreed(id: string): boolean {
+ return this.documents.some((d) => d.id === id) && !this.pending.includes(id);
+ }
+
+ agree(id: string): void {
+ const next = withAccepted(this.documents, this.#stored, id);
+ this.#stored = next;
+ try {
+ localStorage.setItem(KEY, JSON.stringify(next));
+ } catch {
+ // Not stored: the gate asks again next launch, which is the safe side.
+ }
+ }
+
+ /** Re-read what this device agreed to; another window may have agreed. */
+ refresh(): void {
+ this.#stored = read();
+ }
+}
+
+export const agreements = new Agreements();
+
+if (typeof window !== 'undefined') {
+ window.addEventListener('storage', (e) => {
+ if (e.key === KEY) agreements.refresh();
+ });
+ window.addEventListener('focus', () => agreements.refresh());
+}
diff --git a/src/lib/agreements.test.ts b/src/lib/agreements.test.ts
new file mode 100644
index 0000000..f6aebf1
--- /dev/null
+++ b/src/lib/agreements.test.ts
@@ -0,0 +1,26 @@
+// Conformance: this app's gate follows the shared rules. The cases are
+// installers/gate/conformance.json, copied next to agreements.json by
+// installers/scripts/apply.mjs; never edit the copy.
+
+import { describe, expect, it } from 'vitest';
+import conformance from '../../src-tauri/installer/agreements.conformance.json';
+import manifest from '../../src-tauri/installer/agreements.json';
+import { pendingDocuments, withAccepted } from './agreements.svelte';
+
+describe('agreement gate conformance', () => {
+ for (const c of conformance.cases) {
+ it(c.name, () => {
+ let stored: unknown = c.stored;
+ for (const id of c.accept ?? []) stored = withAccepted(conformance.documents, stored, id);
+ expect(pendingDocuments(conformance.documents, stored)).toEqual(c.pending);
+ if (c.storedAfter) expect(stored).toEqual(c.storedAfter);
+ });
+ }
+
+ it('lists every document with a title, a version, and its text', () => {
+ expect(manifest.documents.length).toBeGreaterThan(0);
+ for (const d of manifest.documents) {
+ expect(d.title && d.version && d.text).toBeTruthy();
+ }
+ });
+});
diff --git a/src/lib/api/client.ts b/src/lib/api/client.ts
index 0856bf8..d408ccc 100644
--- a/src/lib/api/client.ts
+++ b/src/lib/api/client.ts
@@ -2,28 +2,55 @@
// Every command is a typed wrapper; errors become ApiError with API.md codes.
import { invoke } from "@tauri-apps/api/core";
+import { ERROR_CODES, isErrorCode, type ErrorCode } from "./error-codes";
+import type { AgentConnection } from "$lib/agent-activity";
import type {
+ AttachmentCleanup,
+ LibraryGraph,
CaptureLatencySummary,
CreateNoteInput,
+ DashboardStats,
+ FeedbackInput,
+ ImportOutcome,
Note,
NoteFilter,
SearchResult,
+ StickyLevel,
+ StickiesScan,
Tag,
TagWithCount,
UpdateNotePatch,
+ VaultReport,
+ VaultStatus,
Workspace,
WorkspaceWithCount,
} from "./types";
export class ApiError extends Error {
- code: string;
- constructor(code: string, message: string) {
+ code: ErrorCode;
+ constructor(code: ErrorCode, message: string) {
super(message);
this.name = "ApiError";
this.code = code;
}
}
+// The one place a rejection becomes an ApiError, so an unknown code can only
+// be mishandled once. A rejection that is not the { code, message } shape
+// never left the core (a dropped IPC call, a thrown string), which is a
+// failure to complete the operation: STORAGE_ERROR.
+function asApiError(e: unknown): ApiError {
+ if (e && typeof e === "object" && "code" in e && "message" in e) {
+ const code = String(e.code);
+ const message = String(e.message);
+ if (isErrorCode(code)) return new ApiError(code, message);
+ // The backend sent a code this build does not know, so no friendly copy
+ // exists for it; keep it in the message rather than losing it.
+ return new ApiError(ERROR_CODES.STORAGE_ERROR, `${code}: ${message}`);
+ }
+ return new ApiError(ERROR_CODES.STORAGE_ERROR, String(e));
+}
+
async function call(
cmd: string,
args?: Record,
@@ -31,10 +58,7 @@ async function call(
try {
return await invoke(cmd, args);
} catch (e) {
- if (e && typeof e === "object" && "code" in e && "message" in e) {
- throw new ApiError(String(e.code), String(e.message));
- }
- throw new ApiError("STORAGE_ERROR", String(e));
+ throw asApiError(e);
}
}
@@ -50,6 +74,7 @@ export const softDeleteNote = (id: string) =>
export const restoreNote = (id: string) => call("restore_note", { id });
export const permanentlyDeleteNote = (id: string, confirm: boolean) =>
call("permanently_delete_note", { id, confirm });
+export const libraryGraph = () => call("library_graph");
export const listNotes = (filter: NoteFilter = {}) =>
call("list_notes", { filter });
export const searchNotes = (text: string, limit = 50) =>
@@ -74,8 +99,6 @@ export const destroyNotes = (ids: string[], confirm: boolean) =>
// ---- tags ----
export const listTags = () => call("list_tags");
-export const getOrCreateTag = (name: string) =>
- call("get_or_create_tag", { name });
export const updateTag = (id: string, name?: string, color?: string) =>
call("update_tag", { id, name, color });
export const deleteTag = (id: string) => call("delete_tag", { id });
@@ -143,6 +166,23 @@ export const setWindowVibrancy = (material: string | null) =>
export const setWindowTheme = (variant: "light" | "dark") =>
call("set_window_theme", { variant });
+// ---- stickies ----
+// A sticky is a note popped out into its own window, which is then that
+// note's only editor. Popping in resolves once the sticky's edits are on disk
+// and its window is gone. The level and geometry commands act on the calling
+// sticky window, never on an id the webview names.
+export const popOutNote = (id: string) => call("pop_out_note", { id });
+export const popInNote = (id: string) => call("pop_in_note", { id });
+export const listStickies = () => call("list_stickies");
+export const answerPopIn = (saved: boolean) => call("answer_pop_in", { saved });
+export const getStickyView = () =>
+ call<{ level: StickyLevel; collapsed: boolean }>("get_sticky_view");
+export const setStickyLevel = (level: StickyLevel) =>
+ call("set_sticky_level", { level });
+export const setStickyCollapsed = (collapsed: boolean) =>
+ call("set_sticky_collapsed", { collapsed });
+export const saveStickyGeometry = () => call("save_sticky_geometry");
+
// ---- theme files ----
// Byte I/O for portable .intheme.json files; the open/save dialog runs in JS.
export const exportThemeFile = (path: string, contents: string) =>
@@ -167,13 +207,55 @@ export const saveAttachment = async (
headers: { "x-attachment-ext": ext },
});
} catch (e) {
- if (e && typeof e === "object" && "code" in e && "message" in e) {
- throw new ApiError(String(e.code), String(e.message));
- }
- throw new ApiError("STORAGE_ERROR", String(e));
+ throw asApiError(e);
}
};
export const getAttachmentsDir = () => call("get_attachments_dir");
+// Copy a dialog-picked image into attachments (the "copy in" storage mode);
+// returns the stored filename. `allow` opens one existing local image to the
+// asset protocol so a linked (not copied) image can render inline.
+export const importImageFile = (path: string) =>
+ call("import_image_file", { path });
+export const allowImageFile = (path: string) =>
+ call("allow_image_file", { path });
+export const openAttachmentsFolder = () =>
+ call("open_attachments_folder");
+// Images no note references any more (older than an hour), and removing
+// them along with their unchanged copies in the live vault.
+export const unusedAttachments = () => call("unused_attachments");
+export const removeUnusedAttachments = () =>
+ call("remove_unused_attachments");
+
+// ---- vault export ----
+// Stage 1 of the portable vault (openspec/changes/feat-portable-vault-sync):
+// a one-way, read-only snapshot. SQLite stays authoritative; nothing reads
+// this folder back yet. The destination is chosen by a native folder-picker
+// dialog in JS, same trust boundary as exportNoteFile.
+export const exportVault = (dest: string) => call("export_vault", { dest });
+
+// ---- live vault mirror ----
+// Stage 2: every change is written into the chosen folder shortly after it
+// happens. SQLite stays authoritative; the folder is written, never read.
+export const getVaultStatus = () => call("get_vault_status");
+/** Start, move, or (with null) stop the mirror. */
+export const setVaultFolder = (path: string | null) =>
+ call("set_vault_folder", { path });
+export const verifyVault = () => call("verify_vault");
+
+// ---- import (Settings > Import) ----
+// The folder comes from a native folder picker, which is also what lets the
+// app read another app's data on macOS. Rust only ever reads it.
+/** Where Stickies keeps its notes, for the picker to open at; null off macOS. */
+export const stickiesLocation = () => call("stickies_location");
+export const scanStickies = (folder: string) => call("scan_stickies", { folder });
+export const importStickies = (folder: string, ids: string[], space: string | null) =>
+ call("import_stickies", { folder, ids, space });
+
+// ---- dashboard + feedback ----
+export const getLibraryStats = () => call("library_stats");
+export const submitFeedback = (input: FeedbackInput) =>
+ call("submit_feedback", { input });
+export const openFeedbackLog = () => call("open_feedback_log");
// ---- app lifecycle ----
// Answer to "app:quit-requested": pending edits are flushed, exit for real now.
@@ -183,3 +265,9 @@ export const quitApp = () => call("quit_app");
// webview has listeners attached, so an event would be lost.
export const getShortcutFailure = () =>
call("get_shortcut_failure");
+
+// ---- agents ----
+// The app executable (which is also the MCP server) and the live library, so
+// Settings > Agents prints a connect command that works as shown.
+export const getAgentConnection = () =>
+ call("agent_connection");
diff --git a/src/lib/api/contract.test.ts b/src/lib/api/contract.test.ts
new file mode 100644
index 0000000..958ddc7
--- /dev/null
+++ b/src/lib/api/contract.test.ts
@@ -0,0 +1,81 @@
+// The one test that crosses the Rust/TypeScript boundary. Types cannot reach
+// across IPC, so every fact both sides must agree on is asserted here against
+// the Rust source itself: the error codes, the event names, and the rule that
+// neither is ever written as a loose literal again.
+//
+// It reads source files rather than a generated artifact so it needs no build
+// step and cannot pass against a stale one.
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { ERROR_CODES } from "./error-codes";
+import { EVENTS } from "./events";
+
+// vitest runs from the project root (jsdom leaves import.meta.url a http URL).
+const root = `${process.cwd()}/`;
+const read = (path: string) => readFileSync(root + path, "utf8");
+
+function sourceFiles(dir: string, exts: string[]): string[] {
+ return readdirSync(root + dir).flatMap((entry) => {
+ const rel = `${dir}/${entry}`;
+ if (statSync(root + rel).isDirectory()) return sourceFiles(rel, exts);
+ return exts.some((e) => entry.endsWith(e)) ? [rel] : [];
+ });
+}
+
+describe("error codes", () => {
+ // The core's AppError::code() is the authority for the strings.
+ const core = read("src-tauri/core/src/error.rs");
+ const codeArms = core
+ .slice(core.indexOf("pub fn code("), core.indexOf("pub fn is_corruption("))
+ .matchAll(/=> "([A-Z_]+)"/g);
+ const fromCore = new Set([...codeArms].map((m) => m[1]));
+
+ it("matches the codes the core emits", () => {
+ expect(fromCore.size).toBeGreaterThan(0);
+ expect([...fromCore].sort()).toEqual(Object.keys(ERROR_CODES).sort());
+ });
+
+ it("matches the API.md table", () => {
+ const section = read("docs/API.md").split("## 14. Error codes")[1];
+ const documented = [...section.matchAll(/^\| `([A-Z_]+)` \|/gm)].map((m) => m[1]);
+ expect(documented.sort()).toEqual(Object.keys(ERROR_CODES).sort());
+ });
+
+ it("matches the Rust ErrorCode enum", () => {
+ const shell = read("src-tauri/src/error.rs");
+ const arms = [...shell.matchAll(/=> "([A-Z_]+)"/g)].map((m) => m[1]);
+ expect(arms.sort()).toEqual(Object.keys(ERROR_CODES).sort());
+ });
+
+ it("is the only way a command error names a code", () => {
+ // `code:` as a literal is how "VALIDATION" (never a real code) reached
+ // eight call sites and broke the friendly copy for every validation error.
+ const literal = new RegExp('code:\\s*"');
+ for (const file of sourceFiles("src-tauri/src", [".rs"])) {
+ expect(literal.test(read(file)), file).toBe(false);
+ }
+ });
+});
+
+describe("event names", () => {
+ const rust = read("src-tauri/src/events.rs");
+ const declared = [...rust.matchAll(/pub const [A-Z_]+: &str = "([^"]+)"/g)].map((m) => m[1]);
+
+ it("matches the Rust list exactly", () => {
+ expect(declared.length).toBe(Object.keys(EVENTS).length);
+ expect(declared.sort()).toEqual([...Object.values(EVENTS)].sort());
+ });
+
+ it("is the only way either side names an event", () => {
+ const emit = new RegExp('emit\\(\\s*"');
+ for (const file of sourceFiles("src-tauri/src", [".rs"])) {
+ expect(emit.test(read(file)), file).toBe(false);
+ }
+ const listen = new RegExp('listen\\(\\s*"');
+ for (const file of sourceFiles("src", [".ts", ".svelte"])) {
+ if (file.endsWith(".test.ts")) continue;
+ expect(listen.test(read(file)), file).toBe(false);
+ }
+ });
+});
diff --git a/src/lib/api/error-codes.ts b/src/lib/api/error-codes.ts
new file mode 100644
index 0000000..e6c3c16
--- /dev/null
+++ b/src/lib/api/error-codes.ts
@@ -0,0 +1,21 @@
+// The frontend's one definition of the error codes a command can reject with
+// (API.md §14). The authority for the strings is the core's `AppError::code()`
+// in src-tauri/core/src/error.rs; `contract.test.ts` holds this list, that
+// match, and the API.md table equal, which is the only check that can cross
+// the IPC boundary.
+
+export const ERROR_CODES = {
+ NOT_FOUND: "NOT_FOUND",
+ VALIDATION_ERROR: "VALIDATION_ERROR",
+ CONFLICT: "CONFLICT",
+ STORAGE_ERROR: "STORAGE_ERROR",
+ MIGRATION_ERROR: "MIGRATION_ERROR",
+} as const;
+
+export type ErrorCode = keyof typeof ERROR_CODES;
+
+/** Narrow a code off the wire. A string that fails this means the backend and
+ * this build disagree, which `contract.test.ts` exists to prevent. */
+export function isErrorCode(value: string): value is ErrorCode {
+ return value in ERROR_CODES;
+}
diff --git a/src/lib/api/events.ts b/src/lib/api/events.ts
new file mode 100644
index 0000000..8204c08
--- /dev/null
+++ b/src/lib/api/events.ts
@@ -0,0 +1,33 @@
+// The frontend's one definition of the event names the backend emits. The
+// Rust mirror is src-tauri/src/events.rs; `contract.test.ts` holds the two
+// lists equal, so renaming one side alone fails a test instead of silently
+// dropping a listener.
+
+export const EVENTS = {
+ NOTES_CHANGED: "notes:changed",
+ TAGS_CHANGED: "tags:changed",
+ WORKSPACES_CHANGED: "workspaces:changed",
+ SETTINGS_OPEN: "settings:open",
+ MENU_NEW_NOTE: "menu:new-note",
+ MENU_NEW_WHITEBOARD: "menu:new-whiteboard",
+ MENU_EXPORT_NOTE: "menu:export-note",
+ UPDATER_CHECK: "updater:check",
+ SHORTCUT_FAILED: "shortcut:failed",
+ VAULT_STATUS: "vault:status",
+ APP_QUIT_REQUESTED: "app:quit-requested",
+ CAPTURE_SHOWN: "capture:shown",
+ MENU_TOGGLE_STICKY: "menu:toggle-sticky",
+ STICKIES_CHANGED: "stickies:changed",
+ STICKY_CLOSE_REQUESTED: "sticky:close-requested",
+ LIBRARY_EXTERNAL_CHANGE: "library:external-change",
+} as const;
+
+export type AppEvent = (typeof EVENTS)[keyof typeof EVENTS];
+
+/** The three events that mean "the library changed, re-query it". Anything
+ * drawing the whole library (the store, the graph) listens to all three. */
+export const LIBRARY_CHANGED_EVENTS = [
+ EVENTS.NOTES_CHANGED,
+ EVENTS.TAGS_CHANGED,
+ EVENTS.WORKSPACES_CHANGED,
+] as const;
diff --git a/src/lib/api/types.ts b/src/lib/api/types.ts
index a800656..f7c9b50 100644
--- a/src/lib/api/types.ts
+++ b/src/lib/api/types.ts
@@ -1,6 +1,12 @@
// IPC contract types shared by the Svelte UI and the Rust desktop layer.
// Field names are camelCase over the wire (serde).
+import type { ErrorCode } from "./error-codes";
+import type { FeedbackCategory } from "$lib/feedback";
+
+/** A Markdown document, or a whiteboard whose text is kept in `body`. */
+export type ContentKind = "document" | "whiteboard";
+
export interface Note {
id: string;
title: string;
@@ -12,8 +18,16 @@ export interface Note {
isArchived: boolean;
isDeleted: boolean;
deletedAt?: string | null;
+ contentKind: ContentKind;
+ /** A whiteboard's canvas (JSON). Only `getNote` carries it: list rows and
+ * `updateNote`'s reply leave it out, since a board can hold images. */
+ surfaceData?: string | null;
}
+/** Where a sticky sits: above every window, as an ordinary window, or below
+ * every window like a desktop widget. */
+export type StickyLevel = "float" | "normal" | "desktop";
+
export interface Tag {
id: string;
name: string;
@@ -48,6 +62,12 @@ export interface UpdateNotePatch {
body?: string;
isPinned?: boolean;
isArchived?: boolean;
+ /** Only ever "whiteboard": converting is one-way. */
+ contentKind?: ContentKind;
+ /** A whiteboard's canvas; rejected on a document. */
+ surfaceData?: string;
+ /** Apply only if the note's updatedAt still equals this; CONFLICT if not. */
+ expectedUpdatedAt?: string;
}
export interface NoteFilter {
@@ -76,7 +96,7 @@ export interface SearchResult {
}
export interface AppErrorPayload {
- code: string;
+ code: ErrorCode;
message: string;
}
@@ -86,3 +106,94 @@ export interface CaptureLatencySummary {
medianMs: number | null;
samples: number;
}
+
+/** Aggregate library + attachment counts for the Settings dashboard. */
+export interface DashboardStats {
+ notesTotal: number;
+ notesActive: number;
+ notesPinned: number;
+ notesArchived: number;
+ notesTrashed: number;
+ tags: number;
+ spaces: number;
+ attachmentsCount: number;
+ attachmentsBytes: number;
+}
+
+/** One in-app feedback submission, persisted to the local log by the backend. */
+export interface FeedbackInput {
+ category: FeedbackCategory;
+ message: string;
+ appVersion?: string | null;
+ /** Opt-in diagnostics snapshot the user agreed to attach. */
+ diagnostics?: unknown;
+}
+
+/** The live vault mirror (API.md §12). `path` is null when mirroring is off. */
+export interface VaultStatus {
+ path: string | null;
+ /** Notes changed since their file was last written. */
+ pending: number;
+ lastError: string | null;
+ lastFlushedAt: string | null;
+}
+
+/** A read-only comparison of the vault folder with the library. Paths are
+ * relative to the vault folder. */
+export interface VaultReport {
+ checked: number;
+ /** Notes whose file is gone. */
+ missing: string[];
+ /** Files that no longer match their note (edited outside the app). */
+ diverged: string[];
+ /** Markdown files in the folder that are not notes the mirror wrote. */
+ orphans: string[];
+ pending: number;
+ manifestOk: boolean;
+}
+
+/** One Apple Sticky as Settings > Import previews it (API.md §16). */
+export interface StickyPreview {
+ id: string;
+ /** The title the note will get. */
+ title: string;
+ /** The start of the note's Markdown. */
+ text: string;
+ /** The sticky's paper, `#rrggbb`, when Stickies recorded it. */
+ color: string | null;
+ createdAt: string;
+ updatedAt: string;
+ images: number;
+ /** Imported before, and its note still exists. */
+ imported: boolean;
+}
+
+/** A Stickies folder, read. `readable` is false when macOS refused access. */
+export interface StickiesScan {
+ folder: string;
+ readable: boolean;
+ stickies: StickyPreview[];
+}
+
+export interface ImportOutcome {
+ imported: number;
+ /** Imported before, and their note still exists. */
+ skipped: number;
+ /** The Space they were filed in, when one was named and any landed. */
+ workspaceId: string | null;
+}
+
+/** What an attachment cleanup removed, or would remove. */
+export interface AttachmentCleanup {
+ count: number;
+ bytes: number;
+}
+
+/** The library as a graph: live notes, the tags and Spaces they carry, and
+ * one link per membership. Derived on every read; nothing is stored. */
+export interface LibraryGraph {
+ notes: { id: string; title: string; contentKind: ContentKind; isPinned: boolean }[];
+ tags: { id: string; name: string; color?: string | null }[];
+ spaces: { id: string; name: string }[];
+ links: { noteId: string; targetId: string; kind: "tag" | "space" }[];
+}
diff --git a/src/lib/app.css b/src/lib/app.css
index 224d370..2b6ea56 100644
--- a/src/lib/app.css
+++ b/src/lib/app.css
@@ -93,6 +93,12 @@ textarea {
line-height: var(--leading);
letter-spacing: var(--tracking);
}
+/* Paint a caret only in the focused editor. Without this, loading a note's
+ document while the editor is blurred (switching between notes) could leave a
+ stray native caret drawn at the top of the text in WKWebView. */
+.cm-editor:not(.cm-focused) .cm-content {
+ caret-color: transparent;
+}
.cm-editor .cm-line {
padding: 0 calc(16px * var(--density));
}
@@ -142,3 +148,63 @@ html[data-vibrancy] .editor-pane {
opacity: 0;
}
}
+
+/* Agent presence. What an agent connected over MCP is reading or changing
+ right now is drawn on the thing itself: a note row, a Space or tag, the
+ open note. Components only set data-agent="read" | "write" from the agents
+ store (src/lib/stores/agents.svelte.ts), which clears it a few seconds
+ after the last call; every rule for how it looks lives here. A read is a
+ light passing over; a write holds a firmer outline. */
+[data-agent] {
+ position: relative;
+}
+[data-agent]::after {
+ content: "";
+ position: absolute;
+ inset: 1px;
+ border-radius: var(--radius);
+ pointer-events: none;
+ box-shadow: inset 0 0 0 1px color-mix(in srgb, var(--accent) 55%, transparent);
+ background: linear-gradient(
+ 100deg,
+ transparent 30%,
+ color-mix(in srgb, var(--accent) 18%, transparent) 50%,
+ transparent 70%
+ );
+ background-size: 300% 100%;
+ animation:
+ agent-in 160ms ease-out,
+ agent-scan 1.6s ease-in-out infinite;
+}
+[data-agent="write"]::after {
+ box-shadow: inset 0 0 0 1.5px var(--accent);
+ background-color: color-mix(in srgb, var(--accent) 9%, transparent);
+}
+/* The open note: an outline around the page, no sweep across the text. */
+.editor-body[data-agent]::after {
+ inset: 0;
+ border-radius: 0;
+ background: none;
+ box-shadow:
+ inset 0 0 0 1px color-mix(in srgb, var(--accent) 45%, transparent),
+ inset 0 0 24px color-mix(in srgb, var(--accent) 10%, transparent);
+ animation: agent-in 160ms ease-out;
+}
+@keyframes agent-in {
+ from {
+ opacity: 0;
+ }
+}
+@keyframes agent-scan {
+ from {
+ background-position: 100% 0;
+ }
+ to {
+ background-position: 0% 0;
+ }
+}
+@media (prefers-reduced-motion: reduce) {
+ [data-agent]::after {
+ animation: none;
+ }
+}
diff --git a/src/lib/changelog.test.ts b/src/lib/changelog.test.ts
new file mode 100644
index 0000000..49389c9
--- /dev/null
+++ b/src/lib/changelog.test.ts
@@ -0,0 +1,127 @@
+import { describe, it, expect } from "vitest";
+import { parseChangelog } from "./changelog";
+import changelogRaw from "../../CHANGELOG.md?raw";
+import pkg from "../../package.json";
+
+const SAMPLE = `# Changelog
+
+## [Unreleased]
+
+## [0.8.0] - 2026-07-11
+
+### Added
+- Spaces: a place you go rather than
+ a label you hunt for.
+- Paste or drop an image into a note.
+
+### Changed
+- Markdown preview is more dependable.
+
+## [0.7.0] - 2026-06-01
+
+### Added
+- The very first thing.
+`;
+
+// 0.9.0 sits undated in the real changelog until the release is cut.
+const UNDATED = `# Changelog
+
+## [Unreleased]
+
+## [0.9.0]
+
+### Added
+- A dashboard on the Settings front page.
+
+## [0.8.0] - 2026-07-11
+
+### Added
+- Spaces.
+`;
+
+// Force CRLF whatever the input already has. On a Windows checkout the bundled
+// CHANGELOG.md arrives as CRLF, so replacing "\n" alone would make it "\r\r\n"
+// and test something no checkout produces. Template literals in this file are
+// always LF: the language normalizes line endings inside them when parsing.
+const toCRLF = (s: string) => s.replace(/\r?\n/g, "\r\n");
+
+describe("parseChangelog", () => {
+ it("extracts the section for a version with its date", () => {
+ const r = parseChangelog(SAMPLE, "0.8.0");
+ expect(r).not.toBeNull();
+ expect(r!.version).toBe("0.8.0");
+ expect(r!.date).toBe("2026-07-11");
+ expect(r!.sections.map((s) => s.heading)).toEqual(["Added", "Changed"]);
+ });
+
+ it("folds bullet continuation lines into one item", () => {
+ const r = parseChangelog(SAMPLE, "0.8.0");
+ expect(r!.sections[0].items[0]).toBe(
+ "Spaces: a place you go rather than a label you hunt for.",
+ );
+ expect(r!.sections[0].items).toHaveLength(2);
+ });
+
+ it("stops at the next release heading", () => {
+ const r = parseChangelog(SAMPLE, "0.8.0");
+ // Nothing from 0.7.0 leaks in.
+ const all = r!.sections.flatMap((s) => s.items).join(" ");
+ expect(all).not.toContain("The very first thing");
+ });
+
+ it("returns null for a version that is not present", () => {
+ expect(parseChangelog(SAMPLE, "9.9.9")).toBeNull();
+ });
+
+ it("ignores the Unreleased placeholder that has no content", () => {
+ const r = parseChangelog(SAMPLE, "Unreleased");
+ expect(r).not.toBeNull();
+ expect(r!.sections).toHaveLength(0);
+ });
+
+ // A release is undated for its whole pre-release life: the date is written
+ // when it is cut. The dashboard shows that section the entire time, so an
+ // undated heading has to parse like any other.
+ it("reads a release heading that carries no date", () => {
+ const r = parseChangelog(UNDATED, "0.9.0");
+ expect(r).not.toBeNull();
+ expect(r!.date).toBeNull();
+ expect(r!.sections).toEqual([
+ { heading: "Added", items: ["A dashboard on the Settings front page."] },
+ ]);
+ });
+
+ it("stops an undated release at the dated one below it", () => {
+ const r = parseChangelog(UNDATED, "0.9.0");
+ expect(r!.sections.flatMap((s) => s.items).join(" ")).not.toContain("Spaces");
+ });
+
+ // A Windows checkout converts the file to CRLF, so the parser sees a trailing
+ // \r on every line. `.` does not match \r and the bullet pattern has no `\s*`
+ // before its `$`, so splitting on "\n" alone dropped every item and the
+ // dashboard showed an empty "What's new" on Windows only.
+ it("parses a CRLF changelog the same as an LF one", () => {
+ const lf = parseChangelog(SAMPLE, "0.8.0");
+ const crlf = parseChangelog(toCRLF(SAMPLE), "0.8.0");
+ expect(crlf).toEqual(lf);
+ expect(crlf!.sections[0].items[0]).toBe(
+ "Spaces: a place you go rather than a label you hunt for.",
+ );
+ });
+
+ it("finds the running version's section in a CRLF copy of the bundled file", () => {
+ const r = parseChangelog(toCRLF(changelogRaw), pkg.version);
+ expect(r).not.toBeNull();
+ expect(r!.sections.length).toBeGreaterThan(0);
+ });
+
+ // The bundled file is the input the dashboard actually parses, and the
+ // version the app reports is the section it looks for. If a release is cut
+ // without a changelog entry, "What's new" silently disappears; this fails
+ // instead.
+ it("finds a section for the running version in the bundled changelog", () => {
+ const r = parseChangelog(changelogRaw, pkg.version);
+ expect(r).not.toBeNull();
+ expect(r!.sections.length).toBeGreaterThan(0);
+ });
+});
diff --git a/src/lib/changelog.ts b/src/lib/changelog.ts
new file mode 100644
index 0000000..67e6d34
--- /dev/null
+++ b/src/lib/changelog.ts
@@ -0,0 +1,90 @@
+// Pure parser for the bundled CHANGELOG.md, so the Settings dashboard can show
+// "what's new" for the installed version without a network call (the webview
+// CSP blocks external fetches). Kept free of the raw import so it stays
+// unit-testable; the component supplies the markdown via Vite's `?raw`.
+//
+// Expected shape (Keep a Changelog):
+// ## [0.8.0] - 2026-07-11
+// ### Added
+// - a bullet
+// continued onto the next line
+// ### Changed
+// - ...
+
+export interface ChangelogSection {
+ /** "Added", "Changed", "Fixed", etc. */
+ heading: string;
+ /** One entry per bullet, continuation lines folded in. */
+ items: string[];
+}
+
+export interface ChangelogRelease {
+ version: string;
+ /** The date after the version, or null when the heading carries none. */
+ date: string | null;
+ sections: ChangelogSection[];
+}
+
+const RELEASE_RE = /^##\s+\[([^\]]+)\]\s*(?:-\s*(.+))?\s*$/;
+const SECTION_RE = /^###\s+(.+?)\s*$/;
+const BULLET_RE = /^[-*]\s+(.+)$/;
+
+/**
+ * Extract the release block for `version` (matched exactly against the text in
+ * the `## [..]` heading). Returns null when that version is not present.
+ */
+export function parseChangelog(md: string, version: string): ChangelogRelease | null {
+ // Split on either ending: a Windows checkout gets CRLF, and a trailing \r is
+ // not whitespace to `.`, so a bullet's `(.+)$` would never reach the end of
+ // the line and every item would be dropped.
+ const lines = md.split(/\r?\n/);
+ let i = 0;
+
+ // Find the target release heading.
+ let release: ChangelogRelease | null = null;
+ for (; i < lines.length; i++) {
+ const m = lines[i].match(RELEASE_RE);
+ if (m && m[1].trim() === version) {
+ release = { version, date: m[2]?.trim() || null, sections: [] };
+ i++;
+ break;
+ }
+ }
+ if (!release) return null;
+
+ let section: ChangelogSection | null = null;
+ for (; i < lines.length; i++) {
+ const line = lines[i];
+ // The next release heading ends this block.
+ if (RELEASE_RE.test(line)) break;
+
+ const sec = line.match(SECTION_RE);
+ if (sec) {
+ section = { heading: sec[1], items: [] };
+ release.sections.push(section);
+ continue;
+ }
+
+ const bullet = line.match(BULLET_RE);
+ if (bullet) {
+ // Bullets before any `###` fall under an unnamed section so nothing is
+ // silently dropped.
+ if (!section) {
+ section = { heading: "", items: [] };
+ release.sections.push(section);
+ }
+ section.items.push(bullet[1].trim());
+ continue;
+ }
+
+ // A non-blank, non-bullet line indented under the current bullet is a
+ // continuation; fold it into the last item.
+ if (section && section.items.length > 0 && line.trim() !== "") {
+ section.items[section.items.length - 1] += ` ${line.trim()}`;
+ }
+ }
+
+ // Drop empty sections (a `###` with no bullets carries nothing to show).
+ release.sections = release.sections.filter((s) => s.items.length > 0);
+ return release;
+}
diff --git a/src/lib/commands.ts b/src/lib/commands.ts
index a9a6bcb..cc4ab05 100644
--- a/src/lib/commands.ts
+++ b/src/lib/commands.ts
@@ -7,9 +7,11 @@ import { library } from "$lib/stores/library.svelte";
import { sidebar } from "$lib/stores/sidebar.svelte";
import { theme } from "$lib/stores/theme.svelte";
import { contexting } from "$lib/stores/contexting.svelte";
+import { confirmConvertToWhiteboard } from "$lib/whiteboard/convert";
import { exportTheme, importTheme } from "$lib/themes/share";
import { BODY_FONTS } from "$lib/themes/fonts";
-import { modKey } from "$lib/platform";
+import { modKey, shiftKey } from "$lib/platform";
+import { isVirtualNoteId } from "$lib/update/space";
import type { Command } from "$lib/command-filter";
export type { Command } from "$lib/command-filter";
@@ -64,6 +66,19 @@ export function buildThemeCommands(): Command[] {
export function buildCommands(): Command[] {
const commands: Command[] = [
{ id: "note.new", title: "New note", group: "Notes", shortcut: `${modKey}N`, run: () => library.newNote() },
+ {
+ id: "note.newWhiteboard",
+ title: "New whiteboard",
+ group: "Notes",
+ shortcut: `${modKey}${shiftKey}N`,
+ run: () => library.newWhiteboard(),
+ },
+ {
+ id: "view.graph",
+ title: "Show graph",
+ group: "View",
+ run: () => library.selectGraph(),
+ },
{
id: "view.sidebar",
title: sidebar.collapsed ? "Show sidebar" : "Hide sidebar",
@@ -111,6 +126,27 @@ export function buildCommands(): Command[] {
},
},
);
+ if (!n.isDeleted && !isVirtualNoteId(n.id)) {
+ const out = library.isSticky(n.id);
+ commands.push({
+ id: "note.sticky",
+ title: out ? "Bring back from sticky" : "Open as sticky",
+ group: "Notes",
+ prefix: notePrefix,
+ shortcut: `${modKey}${shiftKey}O`,
+ run: () => library.toggleSticky(),
+ });
+ }
+ // One-way, so only documents offer it, and it confirms first.
+ if (!n.isDeleted && n.contentKind !== "whiteboard" && !library.isSticky(n.id)) {
+ commands.push({
+ id: "note.toWhiteboard",
+ title: "Turn into whiteboard…",
+ group: "Notes",
+ prefix: notePrefix,
+ run: () => void confirmConvertToWhiteboard(),
+ });
+ }
}
commands.push(
diff --git a/src/lib/components/ContextMenu.svelte b/src/lib/components/ContextMenu.svelte
index 59e9bd0..be9df94 100644
--- a/src/lib/components/ContextMenu.svelte
+++ b/src/lib/components/ContextMenu.svelte
@@ -4,6 +4,9 @@
// first item on open and returns to the invoker when the menu goes away.
interface MenuItem {
label: string;
+ /** Keyboard equivalent, shown dimmed on the right so the menu teaches
+ * the shortcut rather than replacing it. */
+ hint?: string;
danger?: boolean;
run: () => void;
}
@@ -12,8 +15,18 @@
x,
y,
items,
+ anchor,
onclose,
- }: { x: number; y: number; items: MenuItem[]; onclose: () => void } = $props();
+ }: {
+ x: number;
+ y: number;
+ items: MenuItem[];
+ /** The control that opened the menu, when one did. Presses on it do not
+ * count as "outside", so that control can own the toggle instead of the
+ * menu closing on press and its click reopening. */
+ anchor?: HTMLElement;
+ onclose: () => void;
+ } = $props();
let menuEl = $state();
let left = $state(-9999);
@@ -36,7 +49,8 @@
});
function onWindowEvent(e: Event) {
- if (e.target instanceof Node && menuEl?.contains(e.target)) return;
+ if (!(e.target instanceof Node)) return onclose();
+ if (menuEl?.contains(e.target) || anchor?.contains(e.target)) return;
onclose();
}
@@ -93,7 +107,8 @@
queueMicrotask(item.run);
}}
>
- {item.label}
+ {item.label}
+ {#if item.hint}{item.hint}{/if}
{/each}
@@ -112,6 +127,9 @@
box-shadow: var(--shadow-lg);
}
.item {
+ display: flex;
+ align-items: baseline;
+ gap: 18px;
text-align: left;
padding: 5px 12px;
border-radius: var(--radius);
@@ -123,6 +141,13 @@
background: var(--bg-hover);
outline: none;
}
+ .label {
+ flex: 1;
+ }
+ .hint {
+ color: var(--text-tertiary);
+ font-size: 12px;
+ }
.item.danger {
color: var(--danger);
}
diff --git a/src/lib/components/Editor.svelte b/src/lib/components/Editor.svelte
index bdc3a76..aac9d47 100644
--- a/src/lib/components/Editor.svelte
+++ b/src/lib/components/Editor.svelte
@@ -8,7 +8,7 @@
// kernel to the app: Rust APIs in, settings effects in, edits out.
import { onMount } from "svelte";
import { EditorView, keymap, placeholder as cmPlaceholder } from "@codemirror/view";
- import { EditorState } from "@codemirror/state";
+ import { EditorState, type Extension, type StateEffect } from "@codemirror/state";
import { history, defaultKeymap, historyKeymap } from "@codemirror/commands";
import { markdown, markdownLanguage } from "@codemirror/lang-markdown";
import { languages } from "@codemirror/language-data";
@@ -22,20 +22,32 @@
setPreviewMode,
setLinkPrefs,
setAttachmentsBase,
+ linkedImagePaths,
} from "$lib/editor";
import { linkPrefs } from "$lib/stores/links.svelte";
import { listIndentChanges } from "$lib/list-indent";
- import { getAttachmentsDir, openUrl, saveAttachment } from "$lib/api/client";
+ import {
+ getAttachmentsDir,
+ openUrl,
+ saveAttachment,
+ allowImageFile,
+ } from "$lib/api/client";
import { toasts } from "$lib/stores/toasts.svelte";
+ import { applyExternalEdit, externalEdit } from "$lib/external-edit";
let {
value = "",
+ docKey,
placeholder = "",
previewMode = false,
onchange,
onactive,
}: {
value?: string;
+ /** Which document `value` belongs to (the note id). A new key loads a
+ * clean state; a new value under the same key is an outside edit and
+ * lands as a change, keeping the caret and the undo history. */
+ docKey?: string;
placeholder?: string;
previewMode?: boolean;
onchange?: (v: string) => void;
@@ -45,13 +57,18 @@
let container: HTMLDivElement;
let view: EditorView | undefined;
let applyingExternal = false;
+ let loadedKey: string | undefined;
+ // Built once and reused for every note load, so each note gets a fresh state
+ // (clean selection, its own undo history) with identical behavior.
+ let extensions: Extension[] = [];
+ // Absolute attachments dir, cached once it arrives from Rust so each note
+ // load can re-seed it after setState resets the field.
+ let attachmentsBase: string | null = null;
onMount(() => {
- view = new EditorView({
- state: EditorState.create({
- doc: value,
- extensions: [
+ extensions = [
history(),
+ externalEdit,
// Formatting shortcuts take precedence over the defaults. Cmd-K is the
// command palette (handled at the window level), so link uses Cmd-Shift-K.
keymap.of([
@@ -101,29 +118,87 @@
onactive?.(activeMarks(u.state));
}
}),
- ],
- }),
+ ];
+ view = new EditorView({
+ state: EditorState.create({ doc: value, selection: { anchor: 0 }, extensions }),
parent: container,
});
+ loadedKey = docKey;
// Seed the toolbar before the first edit or selection change.
onactive?.(activeMarks(view.state));
// Attachment images can only resolve once Rust reports where they live;
- // until then they render as markdown text, then swap in.
+ // until then they render as markdown text, then swap in. Cache the dir so
+ // each later note load can re-seed it after setState resets the field.
void getAttachmentsDir()
- .then((dir) => view?.dispatch({ effects: setAttachmentsBase.of(dir) }))
+ .then((dir) => {
+ attachmentsBase = dir;
+ view?.dispatch({ effects: setAttachmentsBase.of(dir) });
+ })
.catch(() => {});
return () => view?.destroy();
});
+ // setState resets every state field to its default, so re-apply the dynamic
+ // ones (preview mode, link prefs, attachments base) whenever a note loads.
+ function seedEffects(): StateEffect[] {
+ const effects: StateEffect[] = [
+ setPreviewMode.of(previewMode),
+ setLinkPrefs.of(linkPrefs.snapshot()),
+ ];
+ if (attachmentsBase !== null) {
+ effects.push(setAttachmentsBase.of(attachmentsBase));
+ }
+ return effects;
+ }
+
+ // Load a note's body with a CLEAN state: a fresh selection at the top and its
+ // own undo history. This is the fix for the stray caret that used to linger
+ // in notes being switched between, and it stops an undo from reaching back
+ // into the previously open note. Linked (absolute-path) images are permitted
+ // into the asset scope before the state renders so they load on first paint.
+ async function loadDoc(next: string, key: string | undefined): Promise {
+ // Guard edit echoes to the OUTGOING note across the (possible) async gap
+ // while linked images are permitted, and across the state swap itself.
+ applyingExternal = true;
+ try {
+ const linked = linkedImagePaths(next);
+ if (linked.length > 0) {
+ await Promise.all(linked.map((p) => allowImageFile(p).catch(() => {})));
+ // A newer note may have been requested while we awaited; let its own
+ // effect run apply it instead of clobbering with a stale body.
+ if (value !== next) return;
+ }
+ if (!view) return;
+ view.setState(
+ EditorState.create({ doc: next, selection: { anchor: 0 }, extensions }),
+ );
+ loadedKey = key;
+ view.dispatch({ effects: seedEffects() });
+ onactive?.(activeMarks(view.state));
+ } finally {
+ applyingExternal = false;
+ }
+ }
+
$effect(() => {
- // Sync external value changes (note switching) into the editor.
+ // Sync external value changes into the editor. Another note loads a clean
+ // state, even when its text happens to match the last one's; the same
+ // note changed from outside (an agent's edit) lands as a change.
const next = value;
- if (view && next !== view.state.doc.toString()) {
+ const key = docKey;
+ if (!view) return;
+ const changed = next !== view.state.doc.toString();
+ if (key !== undefined && key === loadedKey) {
+ if (!changed) return;
applyingExternal = true;
- view.dispatch({
- changes: { from: 0, to: view.state.doc.length, insert: next },
- });
- applyingExternal = false;
+ try {
+ applyExternalEdit(view, next);
+ } finally {
+ applyingExternal = false;
+ }
+ } else if (changed || key !== loadedKey) {
+ // Without a key, any new text is a new document, as before keys.
+ void loadDoc(next, key);
}
});
@@ -148,6 +223,19 @@
view?.focus();
}
+ // Insert text at the current selection (replacing it), then focus. Flows out
+ // through onchange like any edit, so it auto-saves and is undoable. Used by
+ // the "Insert image..." action for a dialog-picked file.
+ export function insertText(text: string) {
+ if (!view) return;
+ const { from, to } = view.state.selection.main;
+ view.dispatch({
+ changes: { from, to, insert: text },
+ selection: { anchor: from + text.length },
+ });
+ view.focus();
+ }
+
// Apply a formatting action to the current selection. Flows out through
// onchange like any user edit, so it stays undoable and auto-saved.
export function applyFormat(kind: FormatKind) {
diff --git a/src/lib/components/Editor.test.ts b/src/lib/components/Editor.test.ts
new file mode 100644
index 0000000..dd38aaf
--- /dev/null
+++ b/src/lib/components/Editor.test.ts
@@ -0,0 +1,99 @@
+// @vitest-environment jsdom
+//
+// Regression coverage for the per-note state isolation fix (loadDoc,
+// Editor.svelte): each note used to share one CodeMirror state, so undo could
+// reach into a previously open note and the caret could carry over. Neither
+// existing suite exercises this — library.svelte.test.ts's "undo" coverage is
+// workspace-delete undo, and kernel.test.ts's "caret" coverage is fold
+// behavior over a headless EditorState, not a mounted view switching notes.
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { render, cleanup } from "@testing-library/svelte";
+import { EditorView } from "@codemirror/view";
+import { undo } from "@codemirror/commands";
+import Editor from "./Editor.svelte";
+
+vi.mock("$lib/api/client", () => ({
+ getAttachmentsDir: vi.fn().mockResolvedValue("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/data/attachments"),
+ openUrl: vi.fn().mockResolvedValue(undefined),
+ saveAttachment: vi.fn().mockResolvedValue("x.png"),
+ allowImageFile: vi.fn().mockResolvedValue(undefined),
+ getSetting: vi.fn().mockResolvedValue(undefined),
+ setSetting: vi.fn().mockResolvedValue(undefined),
+}));
+
+afterEach(cleanup);
+
+interface EditorHandle {
+ insertText: (t: string) => void;
+}
+
+/** Recover the mounted EditorView from the DOM, the way findFromDOM is meant
+ * to be used: Editor.svelte deliberately exposes no view of its own. */
+function findView(container: HTMLElement): EditorView {
+ const dom = container.querySelector(".cm-content");
+ if (!dom) throw new Error("CodeMirror content DOM not found");
+ const view = EditorView.findFromDOM(dom as HTMLElement);
+ if (!view) throw new Error("EditorView not found from DOM");
+ return view;
+}
+
+describe("Editor per-note state isolation", () => {
+ it("undo after switching notes never reaches the previous note's edit", async () => {
+ const noteA = "Note A original";
+ const noteB = "Note B original";
+ const { component, container, rerender } = render(Editor, { value: noteA }) as unknown as {
+ component: EditorHandle;
+ container: HTMLElement;
+ rerender: (props: Record) => Promise;
+ };
+
+ // Simulate typing in note A: move the caret to the end (insertText
+ // inserts at the current selection), then make an edit CM6's history
+ // tracks like any other.
+ const view = findView(container);
+ view.dispatch({ selection: { anchor: noteA.length } });
+ component.insertText(" plus a typed addition");
+ expect(view.state.doc.toString()).toBe("Note A original plus a typed addition");
+
+ // Switch to note B on the SAME component instance by changing the `value`
+ // prop, exactly like the library selecting a different note — a fresh
+ // render() would mount a brand new EditorView and trivially pass this
+ // test regardless of whether loadDoc's isolation actually works.
+ await rerender({ value: noteB });
+ // loadDoc is async (it awaits linkedImagePaths/allowImageFile before
+ // calling setState); let its microtasks flush.
+ await Promise.resolve();
+ await Promise.resolve();
+
+ const viewAfterSwitch = findView(container);
+ // Undo must be a no-op on B's fresh history, not a reach back into A.
+ undo(viewAfterSwitch);
+ const doc = viewAfterSwitch.state.doc.toString();
+ expect(doc).toBe(noteB);
+ expect(doc).not.toContain("typed addition");
+ expect(doc).not.toContain("Note A");
+ });
+
+ it("the caret resets to the start when switching notes, not carried over", async () => {
+ const noteA = "Note A original text";
+ const noteB = "Note B original text";
+ const { container, rerender } = render(Editor, { value: noteA }) as unknown as {
+ container: HTMLElement;
+ rerender: (props: Record) => Promise;
+ };
+
+ const view = findView(container);
+ // Move the caret away from the start, as if the user clicked into the
+ // middle of note A.
+ view.dispatch({ selection: { anchor: 10 } });
+ expect(view.state.selection.main.anchor).toBe(10);
+
+ await rerender({ value: noteB });
+ await Promise.resolve();
+ await Promise.resolve();
+
+ const viewAfterSwitch = findView(container);
+ expect(viewAfterSwitch.state.selection.main.anchor).toBe(0);
+ expect(viewAfterSwitch.state.selection.main.head).toBe(0);
+ });
+});
diff --git a/src/lib/components/GraphView.svelte b/src/lib/components/GraphView.svelte
new file mode 100644
index 0000000..d1aa8be
--- /dev/null
+++ b/src/lib/components/GraphView.svelte
@@ -0,0 +1,411 @@
+
+
+
+
+
The graph couldn't load. Your notes are fine; try again in a moment.
+ {:else if graph && graph.nodes.length === 0}
+
+ Nothing to draw yet. Tag notes or add them to Spaces, and they appear here, linked by
+ what they share.
+
+ {:else if graph}
+
+ {/if}
+
+
+ {#if graph && graph.unconnectedNotes > 0}
+
+ {plural(graph.unconnectedNotes, "note", "notes")} with no tags or Spaces
+ {graph.unconnectedNotes === 1 ? "isn't" : "aren't"} shown.
+ This feature is a W.I.P.
+
+ Connect Claude Code, Codex, Cursor, or any agent that speaks the Model
+ Context Protocol. It works through the same search and the same rules you
+ do, and whatever it reads or changes lights up in your library while it
+ does it.
+
+ The agent runs InstantNotes itself in the background to reach your notes,
+ so it works whether or not this window is open. Access applies to every
+ agent, and turning it off takes effect on their next request.
+
+
+
diff --git a/src/lib/components/settings/SettingsEditor.test.ts b/src/lib/components/settings/SettingsEditor.test.ts
new file mode 100644
index 0000000..ee19404
--- /dev/null
+++ b/src/lib/components/settings/SettingsEditor.test.ts
@@ -0,0 +1,59 @@
+// @vitest-environment jsdom
+// `editorPrefs.init()`'s read-from-settings path (and the touched-field race
+// guard) is covered directly in stores/editor.svelte.test.ts; this file only
+// covers what the page renders and persists, following SettingsImages.test.ts's
+// convention of resetting the singleton's $state fields directly per test.
+import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { render, fireEvent, cleanup } from "@testing-library/svelte";
+import SettingsEditor from "./SettingsEditor.svelte";
+import { editorPrefs } from "$lib/stores/editor.svelte";
+import { setSetting } from "$lib/api/client";
+
+vi.mock("$lib/api/client", () => ({
+ getSetting: vi.fn().mockResolvedValue(undefined),
+ setSetting: vi.fn().mockResolvedValue(undefined),
+}));
+
+afterEach(cleanup);
+
+beforeEach(() => {
+ editorPrefs.showExactTime = false;
+ editorPrefs.toolbarOpen = false;
+ vi.mocked(setSetting).mockClear();
+});
+
+describe("SettingsEditor", () => {
+ it("shows Show exact save time off by default", async () => {
+ const { findByRole } = render(SettingsEditor);
+ const sw = await findByRole("switch", { name: "Show exact save time" });
+ expect(sw.getAttribute("aria-checked")).toBe("false");
+ });
+
+ it("toggling Show exact save time persists the setting", async () => {
+ const { findByRole } = render(SettingsEditor);
+ const sw = await findByRole("switch", { name: "Show exact save time" });
+ await fireEvent.click(sw);
+ expect(sw.getAttribute("aria-checked")).toBe("true");
+ expect(vi.mocked(setSetting)).toHaveBeenCalledWith("editor.showExactTime", true);
+ });
+
+ it("reflects an already-on showExactTime from the store", async () => {
+ editorPrefs.showExactTime = true;
+ const { findByRole } = render(SettingsEditor);
+ const sw = await findByRole("switch", { name: "Show exact save time" });
+ expect(sw.getAttribute("aria-checked")).toBe("true");
+ });
+
+ it("toggling the formatting toolbar default persists separately from the timestamp toggle", async () => {
+ const { findByRole } = render(SettingsEditor);
+ const sw = await findByRole("switch", { name: "Open the formatting toolbar by default" });
+ await fireEvent.click(sw);
+ expect(vi.mocked(setSetting)).toHaveBeenCalledWith("editor.toolbarOpen", true);
+ // The other toggle must not have moved.
+ expect(
+ (await findByRole("switch", { name: "Show exact save time" })).getAttribute(
+ "aria-checked",
+ ),
+ ).toBe("false");
+ });
+});
diff --git a/src/lib/components/settings/SettingsFeedback.svelte b/src/lib/components/settings/SettingsFeedback.svelte
new file mode 100644
index 0000000..d438fd3
--- /dev/null
+++ b/src/lib/components/settings/SettingsFeedback.svelte
@@ -0,0 +1,225 @@
+
+
+
+
Feedback
+
+ Found a bug or have an idea? Send it straight from here. It is saved on this
+ machine and opens a prefilled GitHub issue so it reaches the project.
+
+ Screenshots and drawings you paste, drop, or insert into notes. How they are
+ stored, how large they preview, and where they live.
+
+
+ Storage
+ imagePrefs.setStorage(v)}
+ />
+
+ {#if imagePrefs.storage === "copy"}
+ Images are copied into the attachments folder, so exported markdown stays
+ self-contained. This is the safe default.
+ {:else}
+ A picked file is referenced by its path and read from where it sits.
+ Pasted or dropped screenshots have no original file, so they are always
+ copied in regardless of this setting.
+ {/if}
+
+ Your notes as plain Markdown files, with their tags and Spaces, in a folder
+ you choose. Readable and editable in any editor, with InstantNotes closed,
+ on any device.
+
+ InstantNotes writes these files; it does not read them back yet. An edit
+ made in the folder is replaced the next time that note changes here, and
+ Check vault lists any file that no longer matches.
+