@gorajing/zuun 0.1.1

package/dist/commands/capture-commit.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureCommit = captureCommit;
+const child_process_1 = require("child_process");
+const db_1 = require("../lib/db");
+const store_1 = require("../lib/store");
+const entry_io_1 = require("../lib/entry-io");
+const id_1 = require("../lib/id");
+const tags_1 = require("../lib/tags");
+const dedup_1 = require("../lib/dedup");
+const log_1 = require("../lib/log");
+function kindFromMessage(msg) {
+    const prefix = msg.trim().split(/[:(\s]/, 1)[0]?.toLowerCase() ?? "";
+    if (prefix === "feat")
+        return "pattern";
+    if (prefix === "fix")
+        return "observation";
+    if (prefix === "chore" || prefix === "refactor")
+        return "decision";
+    if (prefix === "docs" || prefix === "test")
+        return "reference";
+    return "observation";
+}
+function gitSafe(args) {
+    try {
+        return (0, child_process_1.execFileSync)("git", args, {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function captureCommit(_args) {
+    const sha = gitSafe(["rev-parse", "HEAD"]);
+    if (!sha)
+        return 0;
+    const msg = gitSafe(["log", "-1", "--pretty=%B"]) ?? "";
+    if (msg.trim().length === 0)
+        return 0;
+    const branch = gitSafe(["rev-parse", "--abbrev-ref", "HEAD"]) ?? "unknown";
+    const files = gitSafe(["diff-tree", "--no-commit-id", "--name-only", "-r", "--root", sha]) ?? "";
+    const repoRoot = gitSafe(["rev-parse", "--show-toplevel"]);
+    const body = `${msg.trim()}\n\nFiles changed:\n${files}`;
+    const now = new Date();
+    const db = (0, db_1.openDb)();
+    try {
+        const existing = (0, dedup_1.findRecentDuplicate)(db, body, now);
+        if (existing) {
+            (0, log_1.appendLog)("capture_commit.dedup", { sha, id: existing });
+            return 0;
+        }
+        const id = (0, id_1.newEntryId)(body, now);
+        const entry = {
+            id,
+            created: now.toISOString(),
+            body,
+            kind: kindFromMessage(msg),
+            source: "git",
+            tags: (0, tags_1.normalizeTags)([branch]),
+            related: [],
+            origin: sha,
+            project: repoRoot ?? undefined,
+        };
+        (0, entry_io_1.writeEntry)(entry);
+        (0, store_1.upsertEntry)(db, entry);
+        (0, log_1.appendLog)("capture_commit", { id, sha, kind: entry.kind, project: entry.project });
+        process.stdout.write(`${id}\n`);
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/commands/edit.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.edit = edit;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const db_1 = require("../lib/db");
+const entry_io_1 = require("../lib/entry-io");
+const store_1 = require("../lib/store");
+const paths_1 = require("../lib/paths");
+const log_1 = require("../lib/log");
+async function edit(args) {
+    const [id] = args;
+    if (!id) {
+        process.stderr.write("usage: zuun edit <id>\n");
+        return 1;
+    }
+    const db = (0, db_1.openDb)();
+    try {
+        if (!(0, store_1.getEntry)(db, id)) {
+            process.stderr.write(`edit: no entry with id ${id}\n`);
+            return 1;
+        }
+        const file = path.join((0, paths_1.entriesDir)(), `${id}.md`);
+        if (!fs.existsSync(file)) {
+            process.stderr.write(`edit: file missing on disk: ${file}\n`);
+            return 1;
+        }
+        const editor = process.env.EDITOR ?? "vi";
+        const result = (0, child_process_1.spawnSync)(editor, [file], { stdio: "inherit" });
+        if (result.status !== 0) {
+            process.stderr.write(`edit: editor exited with status ${result.status}\n`);
+            return 1;
+        }
+        try {
+            const parsed = (0, entry_io_1.readEntry)(id);
+            (0, store_1.upsertEntry)(db, parsed);
+            (0, log_1.appendLog)("edit", { id });
+            process.stdout.write(`updated ${id}\n`);
+            return 0;
+        }
+        catch (err) {
+            process.stderr.write(`edit: file fails schema after edit — db row left unchanged\n  ${err.message}\n`);
+            return 1;
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/commands/explain.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explain = explain;
+const db_1 = require("../lib/db");
+const search_1 = require("../lib/search");
+const embed_provider_1 = require("../lib/embed-provider");
+async function explain(args) {
+    const query = args.join(" ");
+    if (!query) {
+        process.stderr.write("usage: zuun explain <query>\n");
+        return 1;
+    }
+    const db = (0, db_1.openDb)();
+    try {
+        const qVec = await embed_provider_1.defaultProvider.embed(query);
+        const results = (0, search_1.search)(db, { query, queryVec: qVec ?? undefined, limit: 10 });
+        if (results.length === 0) {
+            process.stdout.write("no results\n");
+            return 0;
+        }
+        for (const r of results) {
+            process.stdout.write(`${r.entry.id} · ${r.entry.kind} · ${r.entry.created}\n` +
+                `  fts: ${r.parts.fts.toFixed(3)}  vec: ${r.parts.vec.toFixed(3)}  recency: ${r.parts.recency.toFixed(3)}  →  score: ${r.score.toFixed(3)}\n` +
+                `  ${r.entry.body.replace(/\n/g, " ")}\n\n`);
+        }
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/commands/forget.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forget = forget;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const db_1 = require("../lib/db");
+const store_1 = require("../lib/store");
+const paths_1 = require("../lib/paths");
+const log_1 = require("../lib/log");
+async function forget(args) {
+    const [id] = args;
+    if (!id) {
+        process.stderr.write("usage: zuun forget <id>\n");
+        return 1;
+    }
+    const db = (0, db_1.openDb)();
+    try {
+        const entry = (0, store_1.getEntry)(db, id);
+        if (!entry) {
+            process.stderr.write(`forget: no entry with id ${id}\n`);
+            return 1;
+        }
+        // Order matters: unlink the markdown file FIRST, then delete the DB row.
+        // Rationale: if we crash between steps, "file first" is self-healing via reindex
+        // (file missing → DB row will be dropped on next reindex). The reverse order
+        // would resurrect the entry — DB row gone, file present → next reindex re-reads
+        // the file and re-inserts the row. "Forget" must not be un-forgotten.
+        const file = path.join((0, paths_1.entriesDir)(), `${id}.md`);
+        if (fs.existsSync(file))
+            fs.rmSync(file);
+        (0, store_1.deleteEntry)(db, id);
+        (0, log_1.appendLog)("forget", { id });
+        process.stdout.write(`forgot ${id}\n`);
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/commands/install-git-hook.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installGitHook = installGitHook;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ZUUN_MARKER = "# zuun:post-commit";
+const SHEBANG = "#!/usr/bin/env sh\n";
+/**
+ * Absolute path to the zuun.js we want the installed hook to invoke.
+ * Git hooks run outside Claude Code, so they cannot rely on PATH or CLAUDE_PLUGIN_ROOT
+ * at fire time. We resolve the plugin's install location NOW and embed it literally
+ * in the hook content. Resolution order:
+ *
+ *   1. ZUUN_BIN — set by bin/zuun.js when it spawns the tsx child (dev path).
+ *      Authoritative in normal use.
+ *   2. CLAUDE_PLUGIN_ROOT — set by Claude Code when loaded as a plugin.
+ *   3. Walk up from process.argv[1] when it is src/cli.ts to find bin/zuun.js
+ *      next door. Covers `tsx src/cli.ts install-git-hook` invocations.
+ *   4. Last resort: literal argv[1] — only correct when argv[1] is bin/zuun.js
+ *      itself (compiled/direct-node path).
+ */
+function resolveZuunBinPath() {
+    if (process.env.ZUUN_BIN)
+        return path.resolve(process.env.ZUUN_BIN);
+    const pluginRoot = process.env.CLAUDE_PLUGIN_ROOT;
+    if (pluginRoot)
+        return path.resolve(pluginRoot, "bin", "zuun.js");
+    const argv1 = process.argv[1];
+    if (argv1?.endsWith(".ts")) {
+        return path.resolve(path.dirname(argv1), "..", "bin", "zuun.js");
+    }
+    if (argv1)
+        return path.resolve(argv1);
+    throw new Error("install-git-hook: cannot resolve absolute path to zuun.js");
+}
+/** Resolve .git/hooks/post-commit honoring core.hooksPath and worktrees. */
+function resolveHookPath() {
+    try {
+        const rel = (0, child_process_1.execFileSync)("git", ["rev-parse", "--git-path", "hooks/post-commit"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return path.resolve(process.cwd(), rel);
+    }
+    catch {
+        return null;
+    }
+}
+async function installGitHook(_args) {
+    const hookPath = resolveHookPath();
+    if (!hookPath) {
+        process.stderr.write("install-git-hook: not inside a git repository\n");
+        return 1;
+    }
+    let zuunBin;
+    try {
+        zuunBin = resolveZuunBinPath();
+    }
+    catch (err) {
+        process.stderr.write(`install-git-hook: ${err.message}\n`);
+        return 1;
+    }
+    const zuunLine = `${ZUUN_MARKER}\nnode ${JSON.stringify(zuunBin)} capture-commit >/dev/null 2>&1 || true\n`;
+    fs.mkdirSync(path.dirname(hookPath), { recursive: true });
+    let content;
+    if (fs.existsSync(hookPath)) {
+        content = fs.readFileSync(hookPath, "utf8");
+        if (content.includes(ZUUN_MARKER)) {
+            process.stdout.write("post-commit hook already installed\n");
+            return 0;
+        }
+        if (!content.endsWith("\n"))
+            content += "\n";
+        content += "\n" + zuunLine;
+    }
+    else {
+        content = SHEBANG + zuunLine;
+    }
+    fs.writeFileSync(hookPath, content);
+    fs.chmodSync(hookPath, 0o755);
+    process.stdout.write(`installed post-commit hook at ${hookPath}\n  invoking: ${zuunBin}\n`);
+    return 0;
+}

package/dist/hook-scripts/session-start.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSessionStart = runSessionStart;
+const db_1 = require("../lib/db");
+const store_1 = require("../lib/store");
+const project_1 = require("../lib/project");
+const log_1 = require("../lib/log");
+const MAX_CHARS = 2000;
+const TOP_K = 3;
+/**
+ * SessionStart only surfaces high-signal kinds. Observations get skipped because
+ * they're the noisy category — yesterday's debugging crumbs would drown out
+ * today's planning session if we included them. Decisions, patterns, commitments,
+ * and references are semantically stable across sessions and worth eager display.
+ */
+const HIGH_SIGNAL_KINDS = ["decision", "pattern", "commitment", "reference"];
+function entryInProject(entry, project) {
+    const p = entry.project;
+    // Entries with no project are global — included in every session's SessionStart.
+    if (!p)
+        return true;
+    return p === project || p.startsWith(project + "/") || project.startsWith(p + "/");
+}
+function relAge(ms) {
+    const d = Math.floor(ms / 86_400_000);
+    if (d < 1)
+        return "today";
+    if (d < 2)
+        return "yesterday";
+    if (d < 14)
+        return `${d}d ago`;
+    if (d < 60)
+        return `${Math.floor(d / 7)}w ago`;
+    return `${Math.floor(d / 30)}mo ago`;
+}
+async function runSessionStart(input) {
+    try {
+        const project = (0, project_1.resolveProject)(input.cwd);
+        if (!project) {
+            (0, log_1.appendLog)("session_start.miss", { cwd: input.cwd, reason: "no-project" });
+            return;
+        }
+        const db = (0, db_1.openDb)();
+        try {
+            // listEntries returns sorted by created DESC. Filter by project + kind, then take TOP_K.
+            const scoped = (0, store_1.listEntries)(db)
+                .filter((e) => HIGH_SIGNAL_KINDS.includes(e.kind))
+                .filter((e) => entryInProject(e, project))
+                .slice(0, TOP_K);
+            if (scoped.length === 0) {
+                (0, log_1.appendLog)("session_start.miss", { project, reason: "no-entries" });
+                return;
+            }
+            const now = Date.now();
+            const lines = ["Prior relevant context from Zuun:\n\n"];
+            for (const e of scoped) {
+                const body = e.body.replace(/\n/g, " ");
+                const age = relAge(now - new Date(e.created).getTime());
+                lines.push(`- ${e.id} (${e.kind}, ${age}): ${body}\n`);
+            }
+            let text = lines.join("");
+            if (text.length > MAX_CHARS)
+                text = text.slice(0, MAX_CHARS - 1) + "…";
+            const payload = {
+                hookSpecificOutput: {
+                    hookEventName: "SessionStart",
+                    additionalContext: text,
+                },
+            };
+            process.stdout.write(JSON.stringify(payload));
+            (0, log_1.appendLog)("session_start.inject", { project, hits: scoped.length, chars: text.length });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        (0, log_1.appendLog)("session_start.miss", { cwd: input.cwd, reason: "error", err: err.message });
+        process.stderr.write(`zuun session-start hook: ${err.message}\n`);
+    }
+}

package/dist/lib/db.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_VERSION = void 0;
+exports.openDb = openDb;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const sqliteVec = __importStar(require("sqlite-vec"));
+const fs = __importStar(require("fs"));
+const paths_1 = require("./paths");
+exports.SCHEMA_VERSION = 2;
+const DDL_STATEMENTS = [
+    `CREATE TABLE IF NOT EXISTS meta (
+     key   TEXT PRIMARY KEY,
+     value TEXT NOT NULL
+   )`,
+    `CREATE TABLE IF NOT EXISTS entries (
+     id         TEXT PRIMARY KEY,
+     body       TEXT NOT NULL,
+     kind       TEXT NOT NULL,
+     source     TEXT NOT NULL,
+     created    TEXT NOT NULL,
+     stance     TEXT,
+     origin     TEXT,
+     project    TEXT,
+     tags       TEXT NOT NULL DEFAULT '[]',
+     related    TEXT NOT NULL DEFAULT '[]',
+     confidence TEXT
+   )`,
+    `CREATE VIRTUAL TABLE IF NOT EXISTS entries_fts USING fts5(
+     id UNINDEXED,
+     body,
+     tokenize = "unicode61 tokenchars '_-'"
+   )`,
+    `CREATE VIRTUAL TABLE IF NOT EXISTS entries_vec USING vec0(
+     id TEXT PRIMARY KEY,
+     embedding FLOAT[768]
+   )`,
+];
+function openDb() {
+    fs.mkdirSync((0, paths_1.storeRoot)(), { recursive: true });
+    const db = new better_sqlite3_1.default((0, paths_1.dbPath)());
+    sqliteVec.load(db);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    for (const sql of DDL_STATEMENTS)
+        db.prepare(sql).run();
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    if (!row) {
+        db.prepare("INSERT INTO meta (key, value) VALUES ('schema_version', ?)").run(String(exports.SCHEMA_VERSION));
+        return db;
+    }
+    if (row.value !== String(exports.SCHEMA_VERSION)) {
+        db.close();
+        throw new Error(`zuun: index schema_version is ${row.value}, code expects ${exports.SCHEMA_VERSION}. ` +
+            `Run 'zuun reindex' to rebuild the index from your markdown files.`);
+    }
+    return db;
+}

package/dist/lib/dedup.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bodyHash = bodyHash;
+exports.findRecentDuplicate = findRecentDuplicate;
+const crypto = __importStar(require("crypto"));
+function bodyHash(body) {
+    return crypto.createHash("sha256").update(body.trim()).digest("hex");
+}
+function findRecentDuplicate(db, body, now, windowMinutes = 10) {
+    const cutoff = new Date(now.getTime() - windowMinutes * 60_000).toISOString();
+    const target = bodyHash(body);
+    const rows = db
+        .prepare("SELECT id, body FROM entries WHERE created >= ? ORDER BY created DESC")
+        .all(cutoff);
+    for (const row of rows) {
+        if (bodyHash(row.body) === target)
+            return row.id;
+    }
+    return null;
+}

package/dist/lib/doctor.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const db_1 = require("./db");
+const entry_io_1 = require("./entry-io");
+const store_1 = require("./store");
+const embed_provider_1 = require("./embed-provider");
+const log_1 = require("./log");
+async function runDoctor() {
+    const db = (0, db_1.openDb)();
+    const lines = [];
+    let healthy = true;
+    try {
+        const onDisk = (0, entry_io_1.listEntryIds)();
+        const inDb = (0, store_1.listEntries)(db);
+        lines.push(`schema_version: ${db_1.SCHEMA_VERSION}`);
+        lines.push(`entries on disk: ${onDisk.length}`);
+        lines.push(`entries in db: ${inDb.length}`);
+        if (onDisk.length !== inDb.length) {
+            healthy = false;
+            lines.push("WARN: drift between disk and db — run 'zuun reindex'");
+        }
+        const ids = new Set(inDb.map((e) => e.id));
+        let broken = 0;
+        for (const e of inDb) {
+            for (const r of e.related) {
+                if (!ids.has(r))
+                    broken++;
+            }
+        }
+        lines.push(`broken related refs: ${broken}`);
+        const vec = await embed_provider_1.defaultProvider.embed("doctor-check");
+        lines.push(`ollama: ${vec ? "up" : "down"}`);
+        if (!vec)
+            lines.push("  note: embeddings are optional; FTS still works");
+        const tail = (0, log_1.tailLog)(5);
+        if (tail.length > 0) {
+            lines.push("recent log:");
+            for (const l of tail)
+                lines.push(`  ${l.at} ${l.event} ${JSON.stringify(l.payload)}`);
+        }
+    }
+    finally {
+        db.close();
+    }
+    return { healthy, text: lines.join("\n") + "\n" };
+}