@aprimediet/codewalker 1.1.0 → 1.3.0

package/src/libs/resolve.test.ts

@@ -0,0 +1,218 @@
+/**
+ * Tests for libs/resolve.ts — library dependency discovery.
+ *
+ * Covers:
+ * - PURE parseDependencies (deps / deps+devDeps)
+ * - PURE resolveTypesEntry (types → typings → index.d.ts → main)
+ * - Integration locateLibrary over a fixture node_modules
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { parseDependencies, resolveTypesEntry, locateLibrary } from "./resolve.ts";
+
+// ── PURE: parseDependencies ────────────────────────────────────
+describe("parseDependencies", () => {
+  it("returns names from `dependencies`", () => {
+    const pkg = { dependencies: { express: "^4.0.0", lodash: "^4.17.0" } };
+    const result = parseDependencies(pkg);
+    expect(result).toEqual(["express", "lodash"]);
+  });
+
+  it("returns empty array when no dependencies", () => {
+    expect(parseDependencies({})).toEqual([]);
+  });
+
+  it("ignores devDependencies by default", () => {
+    const pkg = {
+      dependencies: { express: "^4.0.0" },
+      devDependencies: { vitest: "^1.0.0" },
+    };
+    expect(parseDependencies(pkg)).toEqual(["express"]);
+  });
+
+  it("includes devDependencies when includeDev=true", () => {
+    const pkg = {
+      dependencies: { express: "^4.0.0" },
+      devDependencies: { vitest: "^1.0.0", typescript: "^5.0.0" },
+    };
+    const result = parseDependencies(pkg, true);
+    expect(result).toContain("express");
+    expect(result).toContain("vitest");
+    expect(result).toContain("typescript");
+    expect(result).toHaveLength(3);
+  });
+
+  it("ignores peerDependencies and optionalDependencies", () => {
+    const pkg = {
+      dependencies: { express: "^4.0.0" },
+      peerDependencies: { react: "^18.0.0" },
+      optionalDependencies: { fsevents: "^2.0.0" },
+    };
+    expect(parseDependencies(pkg)).toEqual(["express"]);
+  });
+
+  it("returns empty array for null/undefined input", () => {
+    expect(parseDependencies(null as any)).toEqual([]);
+    expect(parseDependencies(undefined as any)).toEqual([]);
+  });
+});
+
+// ── PURE: resolveTypesEntry ────────────────────────────────────
+describe("resolveTypesEntry", () => {
+  it("prefers `types` field", () => {
+    const pkg = { types: "dist/index.d.ts", typings: "lib/index.d.ts" };
+    expect(resolveTypesEntry(pkg)).toBe("dist/index.d.ts");
+  });
+
+  it("falls back to `typings` field", () => {
+    const pkg = { typings: "lib/index.d.ts" };
+    expect(resolveTypesEntry(pkg)).toBe("lib/index.d.ts");
+  });
+
+  it("falls back to `index.d.ts`", () => {
+    const pkg = {};
+    expect(resolveTypesEntry(pkg)).toBe("index.d.ts");
+  });
+
+  it("derives from `main` by swapping .js for .d.ts", () => {
+    const pkg = { main: "dist/main.js" };
+    expect(resolveTypesEntry(pkg)).toBe("dist/main.d.ts");
+  });
+
+  it("handles main with no extension by appending .d.ts", () => {
+    const pkg = { main: "dist/main" };
+    expect(resolveTypesEntry(pkg)).toBe("dist/main.d.ts");
+  });
+
+  it("returns index.d.ts when main is not present", () => {
+    const pkg = {};
+    expect(resolveTypesEntry(pkg)).toBe("index.d.ts");
+  });
+});
+
+// ── Integration: locateLibrary ─────────────────────────────────
+describe("locateLibrary", () => {
+  let tmpDir: string;
+  let projectRoot: string;
+  let nodeModulesDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "cw-resolve-"));
+    projectRoot = path.join(tmpDir, "my-project");
+    nodeModulesDir = path.join(projectRoot, "node_modules");
+    fs.mkdirSync(nodeModulesDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns version, dtsPath, and readmePath for a typed package", () => {
+    // Create a typed package
+    const pkgDir = path.join(nodeModulesDir, "typed-pkg");
+    fs.mkdirSync(path.join(pkgDir, "dist"), { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: "typed-pkg",
+        version: "2.1.0",
+        types: "dist/index.d.ts",
+        main: "dist/index.js",
+      }),
+    );
+
+    fs.writeFileSync(
+      path.join(pkgDir, "dist", "index.d.ts"),
+      "export declare function hello(): void;\n",
+    );
+
+    fs.writeFileSync(
+      path.join(pkgDir, "README.md"),
+      "# typed-pkg\nA typed package.\n",
+    );
+
+    const result = locateLibrary(projectRoot, "typed-pkg");
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe("2.1.0");
+    expect(result!.dtsPath).toBe(path.join(pkgDir, "dist", "index.d.ts"));
+    expect(result!.readmePath).toBe(path.join(pkgDir, "README.md"));
+  });
+
+  it("returns null for a non-existent package", () => {
+    const result = locateLibrary(projectRoot, "non-existent-pkg");
+    expect(result).toBeNull();
+  });
+
+  it("returns null when node_modules does not exist", () => {
+    const noNodeModules = path.join(tmpDir, "empty-project");
+    fs.mkdirSync(noNodeModules);
+    const result = locateLibrary(noNodeModules, "anything");
+    expect(result).toBeNull();
+  });
+
+  it("returns dtsPath=null for a package with no .d.ts file", () => {
+    // JS-only package, no types
+    const pkgDir = path.join(nodeModulesDir, "js-only");
+    fs.mkdirSync(pkgDir);
+
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({
+        name: "js-only",
+        version: "0.5.0",
+        main: "index.js",
+      }),
+    );
+
+    // Create the JS file but no .d.ts
+    fs.writeFileSync(path.join(pkgDir, "index.js"), "module.exports = {};\n");
+
+    // Also no README
+    const result = locateLibrary(projectRoot, "js-only");
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe("0.5.0");
+    expect(result!.dtsPath).toBeNull();
+    expect(result!.readmePath).toBeNull();
+  });
+
+  it("finds README.md case-insensitively (README.md or readme.md)", () => {
+    const pkgDir = path.join(nodeModulesDir, "readme-case");
+    fs.mkdirSync(path.join(pkgDir, "dist"), { recursive: true });
+
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({ name: "readme-case", version: "1.0.0" }),
+    );
+
+    // Only readme.md (lowercase)
+    fs.writeFileSync(path.join(pkgDir, "readme.md"), "# Lowercase readme\n");
+
+    // Need index.d.ts so it doesn't return null
+    fs.writeFileSync(path.join(pkgDir, "index.d.ts"), "export const foo: number;\n");
+
+    const result = locateLibrary(projectRoot, "readme-case");
+    expect(result).not.toBeNull();
+    expect(result!.readmePath).toBe(path.join(pkgDir, "readme.md"));
+  });
+
+  it("resolves package.json even without types field (uses index.d.ts fallback)", () => {
+    const pkgDir = path.join(nodeModulesDir, "no-types-field");
+    fs.mkdirSync(pkgDir);
+
+    fs.writeFileSync(
+      path.join(pkgDir, "package.json"),
+      JSON.stringify({ name: "no-types-field", version: "3.0.0" }),
+    );
+
+    fs.writeFileSync(path.join(pkgDir, "index.d.ts"), "export const bar: boolean;\n");
+
+    const result = locateLibrary(projectRoot, "no-types-field");
+    expect(result).not.toBeNull();
+    expect(result!.version).toBe("3.0.0");
+    expect(result!.dtsPath).toBe(path.join(pkgDir, "index.d.ts"));
+  });
+});

package/src/libs/resolve.ts

@@ -0,0 +1,120 @@
+/**
+ * Library dependency discovery for codewalker v1.2.
+ *
+ * - `parseDependencies(pkgJson, includeDev?)`: PURE — extract dep names from package.json.
+ * - `resolveTypesEntry(pkgJson)`: PURE — find the .d.ts entry point.
+ * - `locateLibrary(projectRoot, name)`: integration — read the installed package info.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface LocateResult {
+  version: string;
+  dtsPath: string | null;
+  readmePath: string | null;
+}
+
+/**
+ * Extract dependency names from a package.json object.
+ * By default returns only `dependencies`; set `includeDev=true` to add `devDependencies`.
+ * Ignores peerDependencies and optionalDependencies.
+ * PURE — no I/O.
+ */
+export function parseDependencies(
+  pkgJson: Record<string, any> | null | undefined,
+  includeDev = false,
+): string[] {
+  if (!pkgJson) return [];
+
+  const deps: string[] = [];
+
+  if (pkgJson.dependencies) {
+    deps.push(...Object.keys(pkgJson.dependencies));
+  }
+
+  if (includeDev && pkgJson.devDependencies) {
+    deps.push(...Object.keys(pkgJson.devDependencies));
+  }
+
+  return deps;
+}
+
+/**
+ * Resolve the `.d.ts` entry point for a package.
+ * Priority: `types` → `typings` → `index.d.ts` → derive from `main` (swap .js for .d.ts).
+ * Returns a relative path string.
+ * PURE — no I/O.
+ */
+export function resolveTypesEntry(
+  pkgJson: Record<string, any> | null | undefined,
+): string {
+  if (!pkgJson) return "index.d.ts";
+
+  if (pkgJson.types) return pkgJson.types;
+  if (pkgJson.typings) return pkgJson.typings;
+
+  // Derive from `main` if present
+  if (pkgJson.main) {
+    const main = pkgJson.main as string;
+    // Swap .js|.mjs|.cjs endings for .d.ts; otherwise append .d.ts
+    if (/\.(js|mjs|cjs)$/.test(main)) {
+      return main.replace(/\.(js|mjs|cjs)$/, ".d.ts");
+    }
+    return main + ".d.ts";
+  }
+
+  return "index.d.ts";
+}
+
+/**
+ * Locate an installed library in `node_modules/<name>`.
+ * Returns null if the package or its directory does not exist.
+ * Integration — reads the filesystem.
+ */
+export function locateLibrary(
+  projectRoot: string,
+  name: string,
+): LocateResult | null {
+  const nmDir = path.join(projectRoot, "node_modules");
+  if (!fs.existsSync(nmDir)) return null;
+
+  const pkgDir = path.join(nmDir, name);
+  const pkgJsonPath = path.join(pkgDir, "package.json");
+
+  if (!fs.existsSync(pkgJsonPath)) return null;
+
+  let pkgJson: Record<string, any>;
+  try {
+    pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  } catch {
+    return null;
+  }
+
+  const version = pkgJson.version ?? "unknown";
+
+  // Resolve .d.ts path
+  const typesRel = resolveTypesEntry(pkgJson);
+  let dtsPath: string | null = path.join(pkgDir, typesRel);
+  if (!fs.existsSync(dtsPath)) {
+    // Try common alternative locations
+    const altDts = path.join(pkgDir, "index.d.ts");
+    if (fs.existsSync(altDts)) {
+      dtsPath = altDts;
+    } else {
+      dtsPath = null;
+    }
+  }
+
+  // Find README (case-insensitive)
+  let readmePath: string | null = null;
+  for (const name of ["README.md", "readme.md", "Readme.md"]) {
+    const candidate = path.join(pkgDir, name);
+    if (fs.existsSync(candidate)) {
+      readmePath = candidate;
+      break;
+    }
+  }
+
+  return { version, dtsPath, readmePath };
+}

package/src/notes-cards.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { renderNoteCard, parseNoteCard } from './notes-cards.ts';
+import type { Note } from './types.ts';
+
+function makeNote(overrides: Partial<Note> = {}): Note {
+  return {
+    note_kind: 'glossary',
+    title: 'Idempotency Key',
+    body: 'A client-supplied key that makes a retried POST safe to replay.',
+    tags: 'api, payments',
+    related: 'createCharge, charge.ts:88-140',
+    card_path: '',
+    ...overrides,
+  };
+}
+
+describe('renderNoteCard', () => {
+  it('renders a glossary note with frontmatter head', () => {
+    const note = makeNote();
+    const md = renderNoteCard(note);
+
+    expect(md).toContain('---');
+    expect(md).toContain('note_kind: glossary');
+    expect(md).toContain('title: Idempotency Key');
+    expect(md).toContain('tags: api, payments');
+    expect(md).toContain('related: createCharge, charge.ts:88-140');
+    expect(md).toContain('summary: A client-supplied key that makes a retried POST safe to replay.');
+
+    // Body
+    expect(md).toContain('# Idempotency Key');
+    expect(md).toContain(note.body);
+  });
+
+  it('renders a decision note', () => {
+    const note = makeNote({
+      note_kind: 'decision',
+      title: 'Use SQLite over ChromaDB',
+      body: 'We chose SQLite+FTS5 because the agent can expand queries itself.',
+      tags: 'tech-decision, database',
+      related: 'docs/tech-decision.md',
+    });
+    const md = renderNoteCard(note);
+    expect(md).toContain('note_kind: decision');
+    expect(md).toContain('title: Use SQLite over ChromaDB');
+    expect(md).toContain('tags: tech-decision, database');
+    expect(md).toContain('related: docs/tech-decision.md');
+    expect(md).toContain('# Use SQLite over ChromaDB');
+    expect(md).toContain(note.body);
+  });
+
+  it('sanitizes newlines in head fields', () => {
+    const note = makeNote({
+      title: 'Multi\nline',
+    });
+
+    const md = renderNoteCard(note);
+    // title should not have raw newlines in frontmatter
+    const fmMatch = md.match(/^title: (.+)$/m);
+    expect(fmMatch).not.toBeNull();
+    expect(fmMatch![1]!).not.toContain('\n');
+  });
+
+  it('uses body first line as summary', () => {
+    const note = makeNote();
+    const md = renderNoteCard(note);
+    // The first line of body should appear as summary
+    expect(md).toContain('summary: A client-supplied key that makes a retried POST safe to replay.');
+  });
+});
+
+describe('parseNoteCard', () => {
+  it('round-trips renderNoteCard -> parseNoteCard preserving head fields', () => {
+    const note = makeNote();
+    const md = renderNoteCard(note);
+    const parsed = parseNoteCard(md);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.note_kind).toBe('glossary');
+    expect(parsed!.title).toBe('Idempotency Key');
+    expect(parsed!.tags).toBe('api, payments');
+    expect(parsed!.related).toBe('createCharge, charge.ts:88-140');
+    // summary from body first line
+    expect(parsed!.summary).toBeTruthy();
+  });
+
+  it('returns null for invalid markdown', () => {
+    expect(parseNoteCard('no frontmatter')).toBeNull();
+    expect(parseNoteCard('')).toBeNull();
+  });
+
+  it('returns null for card without note_kind in frontmatter', () => {
+    const md = `---
+name: foo
+kind: function
+---
+# foo
+`;
+    expect(parseNoteCard(md)).toBeNull();
+  });
+});

package/src/notes-cards.ts

@@ -0,0 +1,92 @@
+/**
+ * Note (glossary/decision) card rendering and parsing for codewalker v1.3.
+ *
+ * PURE module — no I/O. Renders a Note into a markdown card
+ * with frontmatter head (note_kind, title, tags, related, summary) and body.
+ *
+ * Cards live at entries/glossary/<slug>.md and entries/decisions/<slug>.md.
+ */
+
+import type { Note, NoteKind } from "./types.ts";
+
+/**
+ * Render a Note (glossary term or decision) into a markdown card string.
+ *
+ * Frontmatter head includes note_kind, title, tags, related, summary.
+ * Body starts with `# <title>` and contains the full body text.
+ * Summary is the first line of the body.
+ */
+export function renderNoteCard(note: Note): string {
+  const lines: string[] = ["---"];
+
+  addNoteHeadField(lines, "note_kind", note.note_kind);
+  addNoteHeadField(lines, "title", note.title);
+  if (note.tags) addNoteHeadField(lines, "tags", note.tags);
+  if (note.related) addNoteHeadField(lines, "related", note.related);
+
+  // Summary = first line of body
+  const summary = note.body.split("\n")[0]?.trim() || note.title;
+  addNoteHeadField(lines, "summary", summary);
+
+  lines.push("---");
+  lines.push("");
+
+  // Body
+  lines.push(`# ${note.title}`);
+  lines.push("");
+
+  if (note.body) {
+    lines.push(note.body);
+  }
+
+  return lines.join("\n") + "\n";
+}
+
+/**
+ * Parse a note card from a markdown string.
+ * Returns null if the card is invalid or not a note card.
+ */
+export function parseNoteCard(text: string): {
+  note_kind: NoteKind;
+  title: string;
+  tags: string;
+  related: string;
+  summary: string;
+} | null {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("---")) return null;
+
+  const endOfFm = trimmed.indexOf("\n---", 3);
+  if (endOfFm === -1) return null;
+
+  const fmRaw = trimmed.slice(3, endOfFm).trim();
+
+  // Parse frontmatter lines into a record
+  const fm: Record<string, string> = {};
+  for (const line of fmRaw.split("\n")) {
+    const sep = line.indexOf(":");
+    if (sep > 0) {
+      const key = line.slice(0, sep).trim();
+      const value = line.slice(sep + 1).trim();
+      fm[key] = value;
+    }
+  }
+
+  const noteKind = fm["note_kind"];
+  if (noteKind !== "glossary" && noteKind !== "decision") return null;
+  if (!fm["title"]) return null;
+
+  return {
+    note_kind: noteKind as NoteKind,
+    title: fm["title"] ?? "",
+    tags: fm["tags"] ?? "",
+    related: fm["related"] ?? "",
+    summary: fm["summary"] ?? "",
+  };
+}
+
+/** Add a key:value line to the frontmatter, sanitizing newlines. */
+function addNoteHeadField(lines: string[], key: string, value: string): void {
+  const safe = value.replace(/\n/g, " ").trim();
+  lines.push(`${key}: ${safe}`);
+}

package/src/notes.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { openDb, searchNotes } from './db.ts';
+import { addNote, rebuildNotesDbFromCards } from './notes.ts';
+
+describe('notes.ts', () => {
+  let tmpDir: string;
+  let glossaryDir: string;
+  let decisionsDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cw-notes-'));
+    glossaryDir = path.join(tmpDir, 'glossary');
+    decisionsDir = path.join(tmpDir, 'decisions');
+    dbPath = path.join(tmpDir, 'test.db');
+    fs.mkdirSync(glossaryDir, { recursive: true });
+    fs.mkdirSync(decisionsDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('addNote', () => {
+    it('writes a glossary card and inserts a DB row', () => {
+      addNote(dbPath, {
+        note_kind: 'glossary',
+        title: 'Idempotency Key',
+        body: 'A client-supplied key that makes retries safe.',
+        tags: 'api,payments',
+        related: 'createCharge',
+        card_path: '',
+      }, glossaryDir);
+
+      // Card file exists under glossary dir
+      const files = fs.readdirSync(glossaryDir);
+      expect(files.length).toBeGreaterThan(0);
+      const cardFile = files.find((f) => f.endsWith('.md'));
+      expect(cardFile).toBeDefined();
+
+      // Card content has frontmatter
+      const cardContent = fs.readFileSync(path.join(glossaryDir, cardFile!), 'utf-8');
+      expect(cardContent).toContain('note_kind: glossary');
+      expect(cardContent).toContain('title: Idempotency Key');
+
+      // DB row exists
+      const db = openDb(dbPath);
+      const results = searchNotes(db, 'Idempotency');
+      expect(results).toHaveLength(1);
+      expect(results[0]!.name).toBe('Idempotency Key');
+      expect(results[0]!.note_kind).toBe('glossary');
+      db.close();
+    });
+
+    it('writes a decision card under decisions dir', () => {
+      addNote(dbPath, {
+        note_kind: 'decision',
+        title: 'Use SQLite over ChromaDB',
+        body: 'Chosen for zero-infra approach.',
+        tags: 'tech-decision',
+        related: '',
+        card_path: '',
+      }, decisionsDir);
+
+      const files = fs.readdirSync(decisionsDir);
+      const cardFile = files.find((f) => f.endsWith('.md'));
+      expect(cardFile).toBeDefined();
+
+      const cardContent = fs.readFileSync(path.join(decisionsDir, cardFile!), 'utf-8');
+      expect(cardContent).toContain('note_kind: decision');
+      expect(cardContent).toContain('title: Use SQLite over ChromaDB');
+    });
+
+    it('is idempotent — re-adding same note updates in place', () => {
+      addNote(dbPath, {
+        note_kind: 'glossary', title: 'Term',
+        body: 'Version 1', tags: '', related: '',
+        card_path: '',
+      }, glossaryDir);
+
+      addNote(dbPath, {
+        note_kind: 'glossary', title: 'Term',
+        body: 'Version 2 updated', tags: 'v2', related: '',
+        card_path: '',
+      }, glossaryDir);
+
+      // Single card file
+      const files = fs.readdirSync(glossaryDir).filter((f) => f.endsWith('.md'));
+      expect(files).toHaveLength(1);
+
+      // DB has single row with updated body
+      const db = openDb(dbPath);
+      const results = searchNotes(db, '');
+      expect(results).toHaveLength(1);
+      expect(results[0]!.summary).toContain('updated');
+      db.close();
+    });
+  });
+
+  describe('rebuildNotesDbFromCards', () => {
+    it('reconstructs DB rows from glossary + decisions cards alone', () => {
+      // Add two notes
+      addNote(dbPath, {
+        note_kind: 'glossary', title: 'Cache Stampede',
+        body: 'When many requests miss cache simultaneously.', tags: 'cache',
+        related: 'getOrCreate',
+        card_path: '',
+      }, glossaryDir);
+      addNote(dbPath, {
+        note_kind: 'decision', title: 'Use triggers for FTS',
+        body: 'FTS triggers prevent index corruption.', tags: 'sqlite',
+        related: 'db.ts',
+        card_path: '',
+      }, decisionsDir);
+
+      // Delete the DB to simulate disposable-index property
+      fs.rmSync(dbPath, { force: true });
+
+      // Rebuild from cards
+      rebuildNotesDbFromCards(dbPath, glossaryDir, decisionsDir);
+
+      // Query should find both
+      const db = openDb(dbPath);
+      const results = searchNotes(db, '');
+      expect(results).toHaveLength(2);
+
+      const glossaryHits = results.filter((r) => r.note_kind === 'glossary');
+      const decisionHits = results.filter((r) => r.note_kind === 'decision');
+      expect(glossaryHits).toHaveLength(1);
+      expect(decisionHits).toHaveLength(1);
+      expect(glossaryHits[0]!.name).toBe('Cache Stampede');
+      expect(decisionHits[0]!.name).toBe('Use triggers for FTS');
+
+      db.close();
+    });
+
+    it('handles empty directories gracefully', () => {
+      // No cards added — should not throw
+      fs.rmSync(dbPath, { force: true });
+      rebuildNotesDbFromCards(dbPath, glossaryDir, decisionsDir);
+      const db = openDb(dbPath);
+      const results = searchNotes(db, '');
+      expect(results).toHaveLength(0);
+      db.close();
+    });
+
+    it('preserves card_path in rebuilt rows', () => {
+      addNote(dbPath, {
+        note_kind: 'glossary', title: 'Idempotency Key',
+        body: 'Retry-safe POST key.', tags: '', related: '',
+        card_path: '',
+      }, glossaryDir);
+
+      // Get the card path
+      const files = fs.readdirSync(glossaryDir).filter((f) => f.endsWith('.md'));
+      const cardPath = path.join(glossaryDir, files[0]!);
+
+      fs.rmSync(dbPath, { force: true });
+      rebuildNotesDbFromCards(dbPath, glossaryDir, decisionsDir);
+
+      const db = openDb(dbPath);
+      const row = db.prepare("SELECT card_path FROM notes WHERE title = ?").get('Idempotency Key') as any;
+      expect(row).not.toBeUndefined();
+      // card_path might be absolute or relative depending on how we stored it
+      expect(row.card_path).toBeTruthy();
+      db.close();
+    });
+  });
+});