@creator-notes/cnotes 0.16.11

package/dist/commands/notes.js

@@ -0,0 +1,706 @@
+import { select } from "@inquirer/prompts";
+import { ApiClient } from "../lib/api-client.js";
+import { resolveConfig } from "../lib/config.js";
+import { handleError, NotFoundError, ValidationError } from "../lib/errors.js";
+import { readFileSafe } from "../lib/fs-utils.js";
+import { outputJson, outputTable, outputQuiet, timeAgo, truncate } from "../lib/output.js";
+import { resolveNoteId } from "../lib/resolve-note.js";
+export function registerNotesCommands(program) {
+    const notes = program
+        .command("notes")
+        .alias("n")
+        .description("Manage notes");
+    notes
+        .command("list")
+        .description("List notes in the current workspace")
+        .option("--search <query>", "Full-text search")
+        .option("--type <type>", "Filter by note type")
+        .option("--tags <tags>", "Filter by tags (comma-separated)")
+        .option("--pinned", "Only show pinned notes")
+        .option("--limit <n>", "Maximum number of results", "20")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes list --type Insight --limit 5
+  $ cnotes notes list --search "auth flow" --json
+  $ cnotes notes list --fields displayId,title,type --json
+`)
+        .action(async (opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const params = {
+                workspaceId: cfg.workspaceId,
+                search: opts.search,
+                types: opts.type,
+                tags: opts.tags,
+                onlyPinned: opts.pinned ? "true" : undefined,
+                excludeDrafts: "true",
+                excludeContent: "true",
+            };
+            const notesList = await api.get("/api/notes", params);
+            // The server caps results (and ignores `limit` when a search/type
+            // filter is active), so apply the requested limit here. This also
+            // fixes the JSON path, which previously emitted the entire result
+            // set regardless of --limit.
+            const limit = parseInt(opts.limit, 10);
+            const all = Array.isArray(notesList) ? notesList : [];
+            if (cfg.json) {
+                const shown = all.slice(0, limit);
+                if (all.length > shown.length) {
+                    // stderr keeps stdout valid JSON while still signalling to the
+                    // caller (often an agent) that the list was truncated.
+                    console.error(`Showing ${shown.length} of ${all.length} — raise --limit to see more.`);
+                }
+                outputJson(shown, cfg.fields);
+                return;
+            }
+            await displayNotesList(all, limit, cfg, api, "notes found — select to view:");
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("get")
+        .description("Get one or more notes by display ID. Always returns an array, in input order, " +
+        "in a single round-trip. Pass one ID for one note, or many IDs to batch-fetch.")
+        .argument("<ids...>", "One or more display IDs (e.g. MEETING-12 PRD-3 IDEA-7)")
+        .option("--all-versions", "Include all versions")
+        .option("--content-only", "Print only the raw markdown content (no metadata, no JSON envelope). " +
+        "Best for reading large notes/transcripts without a giant clipped JSON line.")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes get MEETING-12
+  $ cnotes notes get MEETING-12 PRD-3 IDEA-7 --json
+  $ cnotes notes get TRANSCRIPT-1 --content-only      # raw markdown, no JSON to parse
+`)
+        .action(async (ids, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const notesList = await api.get(`/api/notes`, {
+                workspaceId: cfg.workspaceId,
+                includeVersions: opts.allVersions ? "true" : undefined,
+                exact_ids: ids.join(","),
+                format: "markdown",
+            });
+            const found = Array.isArray(notesList) ? notesList : [];
+            const byDisplayId = new Map();
+            for (const n of found) {
+                if (typeof n.displayId === "string")
+                    byDisplayId.set(n.displayId, n);
+            }
+            const missing = ids.filter((id) => !byDisplayId.has(id));
+            if (missing.length > 0) {
+                throw new NotFoundError(`Notes not found: ${missing.join(", ")}`, "Run `cnotes notes list` to see valid display IDs in this workspace.");
+            }
+            // Preserve input order so callers can index by position.
+            const ordered = ids.map((id) => byDisplayId.get(id));
+            if (opts.contentOnly) {
+                // Raw markdown only — no JSON envelope, no chrome. When several notes
+                // are requested, delimit each with an HTML comment (valid markdown,
+                // renders to nothing) so the stream stays parseable.
+                const parts = ordered.map((note) => {
+                    // Mirror printNote's resolution: the API populates top-level
+                    // `content`, but fall back to latestVersion in case a shape only
+                    // carries it there.
+                    const raw = note.content ?? note.latestVersion?.content;
+                    const content = typeof raw === "string" ? raw : "";
+                    return ordered.length > 1
+                        ? `<!-- ${String(note.displayId)} -->\n${content}`
+                        : content;
+                });
+                process.stdout.write(parts.join("\n\n") + "\n");
+            }
+            else if (cfg.json) {
+                outputJson(ordered, cfg.fields);
+            }
+            else {
+                ordered.forEach((note) => printNote(note));
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("delete")
+        .description("Delete (archive) a note")
+        .argument("<id>", "Note display ID or Convex ID")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes delete MEETING-12
+`)
+        .action(async (id) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const noteId = await resolveNoteId(api, cfg.workspaceId, id);
+            const data = await api.delete(`/api/notes/${noteId}`);
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Deleted note ${id}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("update")
+        .description("Update note metadata (type, tags, pin/archive status). For content edits, use `cnotes versions create`.")
+        .argument("<id>", "Note display ID or Convex ID")
+        .option("--type <type>", "New note type (e.g. Insight, Painpoint)")
+        .option("--tags <tags>", "Replace tags (comma-separated). Use --tags '' to clear.")
+        .option("--pin", "Pin the note")
+        .option("--unpin", "Unpin the note")
+        .option("--archive", "Archive the note")
+        .option("--unarchive", "Unarchive the note")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes update MEETING-12 --type Insight
+  $ cnotes notes update MEETING-12 --tags "auth,security" --pin
+`)
+        .action(async (id, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            if (opts.pin && opts.unpin) {
+                throw new ValidationError("--pin and --unpin are mutually exclusive");
+            }
+            if (opts.archive && opts.unarchive) {
+                throw new ValidationError("--archive and --unarchive are mutually exclusive");
+            }
+            const body = {};
+            if (opts.type !== undefined)
+                body.type = opts.type;
+            if (opts.tags !== undefined) {
+                body.tags = opts.tags === ""
+                    ? []
+                    : opts.tags.split(",").map((t) => t.trim()).filter(Boolean);
+            }
+            if (opts.pin)
+                body.isPinned = true;
+            if (opts.unpin)
+                body.isPinned = false;
+            if (opts.archive)
+                body.isArchived = true;
+            if (opts.unarchive)
+                body.isArchived = false;
+            if (Object.keys(body).length === 0) {
+                throw new ValidationError("At least one of --type, --tags, --pin, --unpin, --archive, or --unarchive is required");
+            }
+            const noteId = await resolveNoteId(api, cfg.workspaceId, id);
+            const data = await api.patch(`/api/notes/${noteId}`, body);
+            const note = data.note ?? {};
+            if (cfg.quiet) {
+                outputQuiet(String(note.displayId || note.id || ""));
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Updated note: ${note.displayId || note.id || id}`);
+                if (body.type !== undefined)
+                    console.log(`Type: ${body.type}`);
+                if (body.tags !== undefined)
+                    console.log(`Tags: ${body.tags.join(", ") || "(none)"}`);
+                if (body.isPinned !== undefined)
+                    console.log(`Pinned: ${body.isPinned}`);
+                if (body.isArchived !== undefined)
+                    console.log(`Archived: ${body.isArchived}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("bulk-archive")
+        .description("Archive or unarchive multiple notes in one operation")
+        .requiredOption("--ids <json>", "JSON array of note display IDs or Convex IDs, e.g. '[\"MEETING-1\",\"PRD-3\"]'")
+        .option("--unarchive", "Unarchive instead of archive")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes bulk-archive --ids '["MEETING-1","PRD-3","IDEA-7"]'
+  $ cnotes notes bulk-archive --ids '["NOTE-9"]' --unarchive
+`)
+        .action(async (opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            let ids;
+            try {
+                ids = JSON.parse(opts.ids);
+            }
+            catch {
+                throw new ValidationError("--ids must be valid JSON array, e.g. '[\"MEETING-1\",\"PRD-3\"]'");
+            }
+            if (!Array.isArray(ids) || ids.length === 0) {
+                throw new ValidationError("--ids must be a non-empty JSON array of strings");
+            }
+            // Resolve display IDs to Convex IDs
+            const noteIds = await Promise.all(ids.map((id) => resolveNoteId(api, cfg.workspaceId, String(id))));
+            const isArchived = !opts.unarchive;
+            const data = await api.post("/api/notes/bulk", {
+                action: "bulkArchive",
+                noteIds,
+                isArchived,
+            });
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const results = (data.results || []);
+                const verb = isArchived ? "Archived" : "Unarchived";
+                const successStatus = isArchived ? "archived" : "unarchived";
+                const succeeded = results.filter((r) => r.status === successStatus).length;
+                const failed = results.filter((r) => r.status === "error").length;
+                console.log(`${verb} ${succeeded} notes${failed > 0 ? ` (${failed} failed)` : ""}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("create")
+        .description("Create one or more interlinked notes in a single transaction.\n" +
+        "  Pass --notes either as an array of items or a single item object.\n" +
+        "  Relationship link syntax (use inside markdown):\n" +
+        "    [@<key>: Title](relationship:references)    → batch placeholder; @<key> is\n" +
+        "                                                  replaced with the new note's\n" +
+        "                                                  display ID after creation.\n" +
+        "    [NOTE-12: Title](relationship:references)   → existing-note reference.\n" +
+        "  Always include the `: Title` part — the title-less form `[NOTE-12](relationship:references)`\n" +
+        "  produces a chip with `title: null`, which renders as \"Untitled\" in the UI.\n" +
+        "  The relationship name is free-form (e.g. references, supports, triggers); use\n" +
+        "  `references` if unsure.")
+        .requiredOption("--notes <json>", "JSON for items to create — pass a single item object (treated as a\n" +
+        "  one-item batch) or an array of {key, type, markdown|markdownFile, tags?}.\n" +
+        "  Examples:\n" +
+        "    '{\"key\":\"A\",\"type\":\"Insight\",\"markdown\":\"# Solo note\"}'\n" +
+        "    '[{\"key\":\"PARENT\",\"type\":\"Insight\",\"markdown\":\"# Parent\\nSee [@CHILD: Child](relationship:references).\"},\n" +
+        "      {\"key\":\"CHILD\",\"type\":\"Insight\",\"markdown\":\"# Child\\nRelated to [@PARENT: Parent](relationship:references).\"}]'")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes create --notes '{"key":"A","type":"Insight","markdown":"# Solo note"}'
+  $ cnotes notes create --notes '[{"key":"P","type":"Insight","markdown":"# Parent\\nSee [@C: Child](relationship:references)."},{"key":"C","type":"Insight","markdown":"# Child"}]'
+
+Output (--json):
+  Returns an object, not an array. Created notes are under the "results" key
+  (not "notes"/"ok"); each carries displayId + title. Read them with:
+    cnotes notes create --json --notes '…' | jq -r '.results[].displayId'
+  Success is the exit code (0). Do NOT re-run on a missing key; a re-run
+  duplicates the batch. A non-zero exit prints { error, code, exitCode, hint }.
+`)
+        .action(async (opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            let parsed;
+            try {
+                parsed = JSON.parse(opts.notes);
+            }
+            catch {
+                throw new ValidationError("--notes must be valid JSON (an item object or an array of item objects)");
+            }
+            // Auto-wrap a single object into a one-item array.
+            const items = Array.isArray(parsed)
+                ? parsed
+                : parsed && typeof parsed === "object"
+                    ? [parsed]
+                    : [];
+            if (items.length === 0) {
+                throw new ValidationError("--notes must contain at least one item (object or non-empty array)");
+            }
+            const localErrors = [];
+            const notes = [];
+            items.forEach((raw, index) => {
+                if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+                    localErrors.push({ index, field: "item", message: "Item must be a JSON object" });
+                    return;
+                }
+                const obj = raw;
+                const key = typeof obj.key === "string" ? obj.key.trim() : "";
+                const type = typeof obj.type === "string" ? obj.type.trim() : "";
+                const markdownInline = typeof obj.markdown === "string" ? obj.markdown : undefined;
+                const markdownFile = typeof obj.markdownFile === "string" ? obj.markdownFile : undefined;
+                if (!key) {
+                    localErrors.push({ index, field: "key", message: "key is required (non-empty string used to cross-reference items in this batch)" });
+                }
+                if (!type) {
+                    localErrors.push({ index, key: key || undefined, field: "type", message: "type is required (e.g. \"Insight\", \"Meeting\")" });
+                }
+                let markdown = markdownInline;
+                if (!markdown && markdownFile) {
+                    try {
+                        markdown = readFileSafe(markdownFile);
+                    }
+                    catch (e) {
+                        const reason = e instanceof Error ? e.message : "could not read file";
+                        localErrors.push({ index, key: key || undefined, field: "markdownFile", message: reason });
+                    }
+                }
+                if (!markdown) {
+                    localErrors.push({ index, key: key || undefined, field: "markdown", message: "markdown or markdownFile is required" });
+                }
+                let tags;
+                if (obj.tags !== undefined && obj.tags !== null) {
+                    if (!Array.isArray(obj.tags) || !obj.tags.every((t) => typeof t === "string")) {
+                        localErrors.push({ index, key: key || undefined, field: "tags", message: "tags must be an array of strings" });
+                    }
+                    else {
+                        tags = obj.tags;
+                    }
+                }
+                if (key && type && markdown) {
+                    notes.push({ key, type, markdown, tags });
+                }
+            });
+            if (localErrors.length > 0) {
+                const summary = `${localErrors.length} of ${items.length} item${items.length === 1 ? "" : "s"} invalid`;
+                const lines = localErrors.map((e) => `  - item ${e.index} (${e.key ?? "?"}): ${e.field}: ${e.message}`);
+                throw new ValidationError(`${summary}\n${lines.join("\n")}`);
+            }
+            const data = await api.post("/api/notes/bulk", {
+                action: "bulkCreate",
+                workspaceId: cfg.workspaceId,
+                notes,
+            });
+            if (cfg.quiet) {
+                const results = (data.results || []);
+                results.forEach((r) => outputQuiet(String(r.displayId || r.noteId || "")));
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                const results = (data.results || []);
+                const relCount = data.relationshipsCreated || 0;
+                const newTypes = (data.relationshipTypesCreated || []);
+                const noun = results.length === 1 ? "note" : "notes";
+                console.log(`Created ${results.length} ${noun} (${relCount} relationships)`);
+                if (newTypes.length > 0) {
+                    console.log(`  + created ${newTypes.length} new relationship type${newTypes.length === 1 ? "" : "s"}: ${newTypes.join(", ")}`);
+                }
+                for (const r of results) {
+                    console.log(`  ${r.displayId}: ${r.title || "(untitled)"}`);
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("search")
+        .description("Search notes by text")
+        .argument("<query>", "Search query")
+        .option("--type <type>", "Filter by note type")
+        .option("--limit <n>", "Maximum results", "10")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes search "rate limit"
+  $ cnotes notes search "onboarding" --type Insight --json
+`)
+        .action(async (query, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const notesList = await api.get("/api/notes", {
+                workspaceId: cfg.workspaceId,
+                search: query,
+                types: opts.type,
+                excludeContent: "true",
+            });
+            const limit = parseInt(opts.limit, 10);
+            const all = Array.isArray(notesList) ? notesList : [];
+            if (cfg.json) {
+                const shown = all.slice(0, limit);
+                if (all.length > shown.length) {
+                    console.error(`Showing ${shown.length} of ${all.length} — raise --limit to see more.`);
+                }
+                outputJson(shown, cfg.fields);
+                return;
+            }
+            await displayNotesList(all, limit, cfg, api, "results — select to view:");
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("retype")
+        .description("Change a note's type (atomic: creates new note, archives old one, cross-links both)")
+        .argument("<displayId>", "Display ID of the note to retype (e.g., NOTE-1)")
+        .requiredOption("--type <type>", "Target type name (must be an existing supertag)")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes retype NOTE-1 --type Insight
+`)
+        .action(async (displayId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            const data = await api.post("/api/notes/retype", {
+                workspaceId: cfg.workspaceId,
+                noteId: displayId,
+                targetType: opts.type,
+            });
+            if (cfg.quiet) {
+                outputQuiet(data.newNote.displayId);
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Retyped ${displayId} → ${data.newNote.displayId}`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("bulk-retype")
+        .description("Retype multiple notes to a new type in one operation")
+        .requiredOption("--ids <json>", "JSON array of note display IDs or Convex IDs, e.g. '[\"NOTE-1\",\"NOTE-3\"]'")
+        .requiredOption("--type <type>", "Target type name (must be an existing supertag)")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes bulk-retype --ids '["NOTE-1","NOTE-3"]' --type Insight
+`)
+        .action(async (opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        try {
+            let ids;
+            try {
+                ids = JSON.parse(opts.ids);
+            }
+            catch {
+                throw new ValidationError("--ids must be valid JSON array, e.g. '[\"NOTE-1\",\"NOTE-3\"]'");
+            }
+            if (!Array.isArray(ids) || ids.length === 0) {
+                throw new ValidationError("--ids must be a non-empty JSON array of strings");
+            }
+            const data = await api.post("/api/notes/bulk", {
+                action: "bulkRetype",
+                workspaceId: cfg.workspaceId,
+                noteIds: ids,
+                targetType: opts.type,
+            });
+            if (cfg.json) {
+                outputJson(data);
+                return;
+            }
+            const results = (data.results || []);
+            const succeeded = results.filter((r) => r.status === "retyped").length;
+            const failed = results.filter((r) => r.status === "error").length;
+            if (cfg.quiet) {
+                results
+                    .filter((r) => r.status === "retyped")
+                    .forEach((r) => outputQuiet(String(r.newDisplayId || "")));
+                return;
+            }
+            console.log(`Retyped ${succeeded} notes → ${opts.type}${failed > 0 ? ` (${failed} failed)` : ""}`);
+            for (const r of results) {
+                if (r.status === "retyped") {
+                    console.log(`  ${r.displayId} → ${r.newDisplayId}`);
+                }
+                else {
+                    console.log(`  ${r.displayId}: error — ${r.error}`);
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+    notes
+        .command("move")
+        .description("Move a note to another workspace (atomic: copies content to the target, archives the source, cross-links both)")
+        .argument("<displayId>", "Display ID of the note to move (e.g., NOTE-1)")
+        .requiredOption("--to <workspaceId>", "Target workspace ID to move the note into")
+        .option("--type <type>", "Target type name in the destination workspace (auto-created from the source type if missing; defaults to the source note's type)")
+        .addHelpText("after", `
+Examples:
+  $ cnotes notes move NOTE-1 --to pd72y6fyhj9mway3y647bv02r183xk5j
+  $ cnotes notes move INS-7 --to <workspaceId> --type Insight
+`)
+        .action(async (displayId, opts) => {
+        const cfg = resolveConfig(program.opts());
+        const api = new ApiClient(cfg.serverUrl, cfg.token);
+        if (opts.to === cfg.workspaceId) {
+            handleError(new ValidationError("Source and target workspaces are the same — use `cnotes notes retype` to change type within a workspace"), cfg.json);
+            return;
+        }
+        try {
+            const data = await api.post("/api/notes/move", {
+                workspaceId: cfg.workspaceId,
+                noteId: displayId,
+                targetWorkspaceId: opts.to,
+                targetType: opts.type,
+            });
+            if (cfg.quiet) {
+                outputQuiet(data.newNote.displayId);
+                return;
+            }
+            if (cfg.json) {
+                outputJson(data);
+            }
+            else {
+                console.log(`Moved ${displayId} → ${data.newNote.displayId} in ${opts.to} (source archived)`);
+            }
+        }
+        catch (error) {
+            handleError(error, cfg.json);
+        }
+    });
+}
+/**
+ * Display a list of notes with interactive selection or plain table.
+ */
+async function displayNotesList(notesList, limit, cfg, api, message) {
+    const sliced = Array.isArray(notesList) ? notesList.slice(0, limit) : [];
+    if (sliced.length === 0) {
+        console.log("No notes found.");
+        return;
+    }
+    if (process.stdout.isTTY) {
+        const chosenIndex = await select({
+            message: `${sliced.length} ${message}`,
+            choices: sliced.map((n, i) => ({
+                name: `${String(n.displayId || "").padEnd(14)} ${truncate(String(n.title || "(untitled)"), 52).padEnd(54)} ${n.updatedAt ? timeAgo(n.updatedAt) : ""}`,
+                value: i,
+            })),
+            loop: true,
+        });
+        const selected = sliced[chosenIndex];
+        const displayId = String(selected.displayId || "");
+        if (displayId) {
+            await viewNoteInteractive(api, cfg.workspaceId, displayId);
+        }
+        return;
+    }
+    const rows = sliced.map((n) => [
+        String(n.displayId || ""),
+        truncate(String(n.title || "(untitled)"), 50),
+        n.updatedAt ? timeAgo(n.updatedAt) : "",
+    ]);
+    outputTable(["ID", "TITLE", "UPDATED"], rows);
+    if (notesList.length > sliced.length) {
+        console.log(`\nShowing ${sliced.length} of ${notesList.length} — raise --limit to see more.`);
+    }
+}
+/**
+ * Interactive note viewer: fetch note, then let user choose TLDR or Full Content.
+ * TLDR is pre-selected so double-enter from list goes straight to summary.
+ */
+async function viewNoteInteractive(api, workspaceId, displayId) {
+    const noteData = await fetchNoteData(api, workspaceId, displayId);
+    if (!noteData) {
+        console.log("Could not fetch note.");
+        return;
+    }
+    const { note, latestVersion } = noteData;
+    // Print note header
+    console.log(`\n${note.displayId || note._id || note.id}`);
+    console.log(`Title: ${note.title || "(untitled)"}`);
+    console.log(`Type:  ${note.type || "Note"}`);
+    if (note.tags && Array.isArray(note.tags) && note.tags.length > 0) {
+        console.log(`Tags:  ${note.tags.join(", ")}`);
+    }
+    if (note.updatedAt) {
+        console.log(`Updated: ${timeAgo(note.updatedAt)}`);
+    }
+    const hasSummary = latestVersion?.searchContent || latestVersion?.summary;
+    const markdown = (latestVersion?.content || note.content);
+    if (!hasSummary && !markdown) {
+        console.log("\n(no content)");
+        return;
+    }
+    const viewMode = await select({
+        message: "View:",
+        choices: [
+            { name: "TLDR", value: "tldr" },
+            { name: "Full Content", value: "full" },
+        ],
+    });
+    if (viewMode === "tldr") {
+        if (latestVersion?.summary) {
+            console.log(`\n${latestVersion.summary}`);
+        }
+        else if (markdown) {
+            // No AI summary — show first ~8 lines of markdown as preview
+            const lines = markdown.split("\n").filter(Boolean);
+            console.log(`\n${lines.slice(0, 8).join("\n")}${lines.length > 8 ? "\n\n..." : ""}`);
+        }
+        else {
+            console.log("\n(no summary available)");
+        }
+    }
+    else {
+        if (markdown) {
+            console.log(`\n${markdown}`);
+        }
+    }
+}
+/**
+ * Fetch note data (metadata + latest version) by display ID.
+ */
+async function fetchNoteData(api, workspaceId, displayId) {
+    try {
+        const notesList = await api.get("/api/notes", {
+            workspaceId,
+            exact_id: displayId,
+            format: "markdown",
+        });
+        const note = (Array.isArray(notesList) ? notesList : []).find((n) => n.displayId === displayId) || (Array.isArray(notesList) ? notesList[0] : null);
+        if (!note)
+            return null;
+        // latestVersion may be a nested object (cookie auth) or content may be top-level (CLI auth)
+        const lv = note.latestVersion || null;
+        return {
+            note,
+            latestVersion: lv || (note.content ? { content: note.content } : null),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function printNote(note, version) {
+    console.log(`\n${note.displayId || note._id || note.id}`);
+    console.log(`Title: ${note.title || "(untitled)"}`);
+    console.log(`Type:  ${note.type || "Note"}`);
+    if (note.tags && Array.isArray(note.tags) && note.tags.length > 0) {
+        console.log(`Tags:  ${note.tags.join(", ")}`);
+    }
+    if (note.isPinned)
+        console.log("Pinned: yes");
+    if (note.isArchived) {
+        const archivedAt = note.archivedAt;
+        console.log(`Archived: ${archivedAt ? timeAgo(archivedAt) : "yes"}`);
+    }
+    if (note.updatedAt) {
+        console.log(`Updated: ${timeAgo(note.updatedAt)}`);
+    }
+    // Content arrives as a markdown string (server renders TipTap → markdown for ?format=markdown).
+    const markdown = (version?.content || note.latestVersion?.content || note.content);
+    if (typeof markdown === "string" && markdown.length > 0) {
+        console.log(`\n${markdown}`);
+        return;
+    }
+    const searchContent = note.latestVersion?.searchContent || version?.searchContent;
+    if (searchContent) {
+        console.log(`\n${searchContent}`);
+    }
+}
+//# sourceMappingURL=notes.js.map