@cad0p/napkin 0.8.1-20260601.0

package/src/commands/bases.ts

@@ -0,0 +1,174 @@
+import type { BaseQueryResult } from "../core/bases.js";
+import { Napkin } from "../sdk.js";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import {
+  bold,
+  dim,
+  error,
+  type OutputOptions,
+  output,
+  success,
+} from "../utils/output.js";
+
+export async function bases(opts: OutputOptions & { vault?: string }) {
+  const n = new Napkin(opts.vault || process.cwd());
+  const files = n.bases();
+
+  output(opts, {
+    json: () => ({ bases: files }),
+    human: () => {
+      if (files.length === 0) {
+        console.log("No .base files found");
+      } else {
+        for (const f of files) console.log(f);
+      }
+    },
+  });
+}
+
+export async function baseViews(
+  opts: OutputOptions & { vault?: string; file?: string; path?: string },
+) {
+  const n = new Napkin(opts.vault || process.cwd());
+  let views: { name: string; type: string }[];
+  try {
+    views = n.baseViews(opts);
+  } catch (e: unknown) {
+    error((e as Error).message);
+    process.exit(EXIT_USER_ERROR);
+  }
+
+  output(opts, {
+    json: () => ({ views }),
+    human: () => {
+      for (const view of views) {
+        console.log(`${bold(view.name)}  ${dim(view.type)}`);
+      }
+    },
+  });
+}
+
+export async function baseQuery(
+  opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    path?: string;
+    view?: string;
+    format?: string;
+  },
+) {
+  const n = new Napkin(opts.vault || process.cwd());
+  let result: BaseQueryResult;
+  try {
+    result = await n.baseQuery(opts, opts.view);
+  } catch (e: unknown) {
+    error((e as Error).message);
+    process.exit(EXIT_USER_ERROR);
+  }
+  const fmt = opts.format || "json";
+
+  const displayCols = result.columns.map((c) => result.displayNames?.[c] || c);
+
+  output(opts, {
+    json: () => {
+      if (fmt === "paths") {
+        const pathIdx = result.columns.indexOf("path");
+        return { paths: result.rows.map((r) => r[pathIdx]) };
+      }
+      // Convert to array of objects
+      const rows = result.rows.map((row) => {
+        const obj: Record<string, unknown> = {};
+        for (let i = 0; i < result.columns.length; i++) {
+          obj[result.columns[i]] = row[i];
+        }
+        return obj;
+      });
+      const out: Record<string, unknown> = { columns: result.columns, rows };
+      if (result.displayNames && Object.keys(result.displayNames).length > 0) {
+        out.displayNames = result.displayNames;
+      }
+      if (result.groups) {
+        out.groups = result.groups.map((g) => ({
+          key: g.key,
+          rows: g.rows.map((row) => {
+            const obj: Record<string, unknown> = {};
+            for (let i = 0; i < result.columns.length; i++) {
+              obj[result.columns[i]] = row[i];
+            }
+            return obj;
+          }),
+        }));
+      }
+      if (result.summaries) out.summaries = result.summaries;
+      return out;
+    },
+    human: () => {
+      if (result.rows.length === 0) {
+        console.log("No results");
+        return;
+      }
+
+      if (fmt === "paths") {
+        const pathIdx = result.columns.indexOf("path");
+        for (const row of result.rows) console.log(row[pathIdx]);
+        return;
+      }
+
+      if (fmt === "csv" || fmt === "tsv") {
+        const sep = fmt === "csv" ? "," : "\t";
+        console.log(displayCols.join(sep));
+        for (const row of result.rows) {
+          console.log(row.map((v) => (v === null ? "" : String(v))).join(sep));
+        }
+        return;
+      }
+
+      if (fmt === "md") {
+        console.log(`| ${displayCols.join(" | ")} |`);
+        console.log(`| ${displayCols.map(() => "---").join(" | ")} |`);
+        for (const row of result.rows) {
+          console.log(
+            `| ${row.map((v) => (v === null ? "" : String(v))).join(" | ")} |`,
+          );
+        }
+        return;
+      }
+
+      // Default: table-like
+      for (const row of result.rows) {
+        const obj: Record<string, unknown> = {};
+        for (let i = 0; i < result.columns.length; i++) {
+          if (row[i] !== null) obj[result.columns[i]] = row[i];
+        }
+        console.log(JSON.stringify(obj));
+      }
+    },
+  });
+}
+
+export async function baseCreate(
+  opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    path?: string;
+    name?: string;
+    content?: string;
+  },
+) {
+  const n = new Napkin(opts.vault || process.cwd());
+  if (!opts.name) {
+    error("No name specified. Use --name <name>");
+    process.exit(EXIT_USER_ERROR);
+  }
+
+  const result = n.baseCreate({
+    name: opts.name,
+    path: opts.path,
+    content: opts.content,
+  });
+
+  output(opts, {
+    json: () => result,
+    human: () => success(`Created ${result.path}`),
+  });
+}

package/src/commands/bookmarks.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createTempVault } from "../utils/test-helpers.js";
+import { bookmark, bookmarks } from "./bookmarks.js";
+
+let v: { path: string; vaultPath: string; cleanup: () => void };
+
+async function captureJson(
+  fn: () => Promise<void>,
+): Promise<Record<string, unknown>> {
+  const orig = console.log;
+  const logs: string[] = [];
+  console.log = (...args: unknown[]) => logs.push(args.map(String).join(" "));
+  await fn();
+  console.log = orig;
+  return JSON.parse(logs.join(""));
+}
+
+beforeEach(() => {
+  v = createTempVault({});
+  // Write initial bookmarks
+  fs.writeFileSync(
+    path.join(v.vaultPath, ".obsidian", "bookmarks.json"),
+    JSON.stringify([
+      { type: "file", path: "note.md", title: "My Note" },
+      { type: "search", query: "TODO" },
+    ]),
+  );
+});
+
+afterEach(() => {
+  v.cleanup();
+});
+
+describe("bookmarks", () => {
+  test("lists bookmarks", async () => {
+    const data = await captureJson(() =>
+      bookmarks({ json: true, vault: v.path }),
+    );
+    const b = data.bookmarks as { type: string }[];
+    expect(b.length).toBe(2);
+    expect(b[0].type).toBe("file");
+    expect(b[1].type).toBe("search");
+  });
+
+  test("returns total", async () => {
+    const data = await captureJson(() =>
+      bookmarks({ json: true, vault: v.path, total: true }),
+    );
+    expect(data.total).toBe(2);
+  });
+
+  test("returns empty when no bookmarks file", async () => {
+    fs.unlinkSync(path.join(v.vaultPath, ".obsidian", "bookmarks.json"));
+    const data = await captureJson(() =>
+      bookmarks({ json: true, vault: v.path }),
+    );
+    expect((data.bookmarks as unknown[]).length).toBe(0);
+  });
+});
+
+describe("bookmark", () => {
+  test("adds a file bookmark", async () => {
+    await captureJson(() =>
+      bookmark({ json: true, vault: v.path, file: "new.md", title: "New" }),
+    );
+    const raw = fs.readFileSync(
+      path.join(v.vaultPath, ".obsidian", "bookmarks.json"),
+      "utf-8",
+    );
+    const items = JSON.parse(raw);
+    expect(items.length).toBe(3);
+    expect(items[2].type).toBe("file");
+    expect(items[2].path).toBe("new.md");
+  });
+
+  test("adds a search bookmark", async () => {
+    await captureJson(() =>
+      bookmark({ json: true, vault: v.path, search: "FIXME" }),
+    );
+    const raw = fs.readFileSync(
+      path.join(v.vaultPath, ".obsidian", "bookmarks.json"),
+      "utf-8",
+    );
+    const items = JSON.parse(raw);
+    expect(items[2].type).toBe("search");
+    expect(items[2].query).toBe("FIXME");
+  });
+
+  test("adds a URL bookmark", async () => {
+    await captureJson(() =>
+      bookmark({ json: true, vault: v.path, url: "https://example.com" }),
+    );
+    const raw = fs.readFileSync(
+      path.join(v.vaultPath, ".obsidian", "bookmarks.json"),
+      "utf-8",
+    );
+    const items = JSON.parse(raw);
+    expect(items[2].type).toBe("url");
+    expect(items[2].url).toBe("https://example.com");
+  });
+});

package/src/commands/bookmarks.ts

@@ -0,0 +1,78 @@
+import type { Bookmark } from "../core/bookmarks.js";
+import { Napkin } from "../sdk.js";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import {
+  dim,
+  error,
+  type OutputOptions,
+  output,
+  success,
+} from "../utils/output.js";
+
+export async function bookmarks(
+  opts: OutputOptions & {
+    vault?: string;
+    total?: boolean;
+    verbose?: boolean;
+  },
+) {
+  const n = new Napkin(opts.vault || process.cwd());
+  const flat = n.bookmarks();
+
+  output(opts, {
+    json: () => (opts.total ? { total: flat.length } : { bookmarks: flat }),
+    human: () => {
+      if (opts.total) {
+        console.log(flat.length);
+      } else {
+        for (const b of flat) {
+          const label = b.title || b.path || b.query || b.url || "(untitled)";
+          console.log(opts.verbose ? `${label}\t${dim(b.type)}` : label);
+        }
+      }
+    },
+  });
+}
+
+export async function bookmark(
+  opts: OutputOptions & {
+    vault?: string;
+    file?: string;
+    subpath?: string;
+    folder?: string;
+    search?: string;
+    url?: string;
+    title?: string;
+  },
+) {
+  const n = new Napkin(opts.vault || process.cwd());
+
+  let entry: Bookmark;
+  if (opts.file) {
+    entry = {
+      type: "file",
+      path: opts.file,
+      title: opts.title,
+      subpath: opts.subpath,
+    };
+  } else if (opts.folder) {
+    entry = { type: "folder", path: opts.folder, title: opts.title };
+  } else if (opts.search) {
+    entry = { type: "search", query: opts.search, title: opts.title };
+  } else if (opts.url) {
+    entry = { type: "url", url: opts.url, title: opts.title };
+  } else {
+    error("Specify --file, --folder, --search, or --url to bookmark");
+    process.exit(EXIT_USER_ERROR);
+  }
+
+  const result = n.bookmarkAdd(entry);
+
+  output(opts, {
+    json: () => result,
+    human: () =>
+      success(
+        `Bookmarked ${result.added.path || result.added.query || result.added.url}`,
+      ),
+  });
+}

package/src/commands/canvas.test.ts

@@ -0,0 +1,257 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createTempVault } from "../utils/test-helpers.js";
+import {
+  canvasAddEdge,
+  canvasAddNode,
+  canvasCreate,
+  canvases,
+  canvasNodes,
+  canvasRead,
+  canvasRemoveNode,
+} from "./canvas.js";
+
+let v: { path: string; vaultPath: string; cleanup: () => void };
+
+async function captureJson(
+  fn: () => Promise<void>,
+): Promise<Record<string, unknown>> {
+  const orig = console.log;
+  const logs: string[] = [];
+  console.log = (...args: unknown[]) => logs.push(args.map(String).join(" "));
+  await fn();
+  console.log = orig;
+  return JSON.parse(logs.join(""));
+}
+
+beforeEach(() => {
+  v = createTempVault({
+    "board.canvas": JSON.stringify({
+      nodes: [
+        {
+          id: "aabb11223344",
+          type: "text",
+          x: 0,
+          y: 0,
+          width: 300,
+          height: 150,
+          text: "# Hello\nWorld",
+        },
+        {
+          id: "ccdd55667788",
+          type: "file",
+          x: 400,
+          y: 0,
+          width: 300,
+          height: 200,
+          file: "Notes/note.md",
+        },
+        {
+          id: "eeff99001122",
+          type: "group",
+          x: -50,
+          y: -50,
+          width: 800,
+          height: 400,
+          label: "My Group",
+        },
+      ],
+      edges: [
+        {
+          id: "edge00112233",
+          fromNode: "aabb11223344",
+          fromSide: "right",
+          toNode: "ccdd55667788",
+          toSide: "left",
+          label: "links to",
+        },
+      ],
+    }),
+    "Notes/note.md": "# Note\nSome content",
+  });
+});
+
+afterEach(() => {
+  v.cleanup();
+});
+
+describe("canvases", () => {
+  test("lists canvas files", async () => {
+    const data = await captureJson(() =>
+      canvases({ json: true, vault: v.path }),
+    );
+    expect(data.canvases).toContain("board.canvas");
+  });
+
+  test("returns total", async () => {
+    const data = await captureJson(() =>
+      canvases({ json: true, vault: v.path, total: true }),
+    );
+    expect(data.total).toBe(1);
+  });
+});
+
+describe("canvasRead", () => {
+  test("reads canvas with nodes and edges", async () => {
+    const data = await captureJson(() =>
+      canvasRead({ json: true, vault: v.path, file: "board" }),
+    );
+    expect((data.nodes as unknown[]).length).toBe(3);
+    expect((data.edges as unknown[]).length).toBe(1);
+  });
+});
+
+describe("canvasNodes", () => {
+  test("lists all nodes", async () => {
+    const data = await captureJson(() =>
+      canvasNodes({ json: true, vault: v.path, file: "board" }),
+    );
+    expect((data.nodes as unknown[]).length).toBe(3);
+  });
+
+  test("filters by type", async () => {
+    const data = await captureJson(() =>
+      canvasNodes({ json: true, vault: v.path, file: "board", type: "text" }),
+    );
+    expect((data.nodes as unknown[]).length).toBe(1);
+  });
+});
+
+describe("canvasCreate", () => {
+  test("creates empty canvas", async () => {
+    const data = await captureJson(() =>
+      canvasCreate({ json: true, vault: v.path, file: "new-board" }),
+    );
+    expect(data.created).toBe(true);
+    const content = JSON.parse(
+      fs.readFileSync(path.join(v.vaultPath, "new-board.canvas"), "utf-8"),
+    );
+    expect(content.nodes).toEqual([]);
+    expect(content.edges).toEqual([]);
+  });
+});
+
+describe("canvasAddNode", () => {
+  test("adds a text node", async () => {
+    const data = await captureJson(() =>
+      canvasAddNode({
+        json: true,
+        vault: v.path,
+        file: "board",
+        type: "text",
+        text: "New node",
+      }),
+    );
+    expect(data.added).toBe(true);
+    expect(data.type).toBe("text");
+
+    const content = JSON.parse(
+      fs.readFileSync(path.join(v.vaultPath, "board.canvas"), "utf-8"),
+    );
+    expect(content.nodes.length).toBe(4);
+    const newNode = content.nodes[3];
+    expect(newNode.text).toBe("New node");
+  });
+
+  test("adds a file node", async () => {
+    const data = await captureJson(() =>
+      canvasAddNode({
+        json: true,
+        vault: v.path,
+        file: "board",
+        type: "file",
+        noteFile: "Notes/note.md",
+      }),
+    );
+    expect(data.type).toBe("file");
+  });
+
+  test("adds a link node", async () => {
+    const data = await captureJson(() =>
+      canvasAddNode({
+        json: true,
+        vault: v.path,
+        file: "board",
+        type: "link",
+        url: "https://example.com",
+      }),
+    );
+    expect(data.type).toBe("link");
+  });
+
+  test("auto-positions new nodes", async () => {
+    await canvasAddNode({
+      json: true,
+      vault: v.path,
+      file: "board",
+      type: "text",
+      text: "Auto",
+    });
+    const content = JSON.parse(
+      fs.readFileSync(path.join(v.vaultPath, "board.canvas"), "utf-8"),
+    );
+    const newNode = content.nodes[content.nodes.length - 1];
+    // Should be placed after the rightmost existing node (group at x:-50 + width:800 = 750, +50 gap)
+    expect(newNode.x).toBe(800);
+  });
+});
+
+describe("canvasAddEdge", () => {
+  test("adds an edge between nodes", async () => {
+    const data = await captureJson(() =>
+      canvasAddEdge({
+        json: true,
+        vault: v.path,
+        file: "board",
+        from: "aabb",
+        to: "eeff",
+        label: "belongs to",
+      }),
+    );
+    expect(data.added).toBe(true);
+
+    const content = JSON.parse(
+      fs.readFileSync(path.join(v.vaultPath, "board.canvas"), "utf-8"),
+    );
+    expect(content.edges.length).toBe(2);
+    const newEdge = content.edges[1];
+    expect(newEdge.fromNode).toBe("aabb11223344");
+    expect(newEdge.toNode).toBe("eeff99001122");
+    expect(newEdge.label).toBe("belongs to");
+  });
+
+  test("matches node IDs by prefix", async () => {
+    const data = await captureJson(() =>
+      canvasAddEdge({
+        json: true,
+        vault: v.path,
+        file: "board",
+        from: "ccdd",
+        to: "eeff",
+      }),
+    );
+    expect(data.from).toBe("ccdd55667788");
+    expect(data.to).toBe("eeff99001122");
+  });
+});
+
+describe("canvasRemoveNode", () => {
+  test("removes node and connected edges", async () => {
+    const data = await captureJson(() =>
+      canvasRemoveNode({
+        json: true,
+        vault: v.path,
+        file: "board",
+        id: "aabb",
+      }),
+    );
+    expect(data.removed).toBe(true);
+
+    const content = JSON.parse(
+      fs.readFileSync(path.join(v.vaultPath, "board.canvas"), "utf-8"),
+    );
+    expect(content.nodes.length).toBe(2);
+    expect(content.edges.length).toBe(0); // Edge connected to removed node also gone
+  });
+});