@gorajing/zuun 0.1.1

package/dist/lib/embed-provider.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultProvider = exports.OllamaProvider = exports.EMBED_DIM = void 0;
+const log_1 = require("./log");
+exports.EMBED_DIM = 768;
+const MAX_INPUT_CHARS = 8000;
+function l2Normalize(v) {
+    const norm = Math.sqrt(v.reduce((s, x) => s + x * x, 0));
+    return norm === 0 ? v : v.map((x) => x / norm);
+}
+class OllamaProvider {
+    url;
+    model;
+    constructor(url = process.env.OLLAMA_URL ?? "http://127.0.0.1:11434", model = process.env.ZUUN_EMBED_MODEL ?? "nomic-embed-text") {
+        this.url = url;
+        this.model = model;
+    }
+    async embed(text) {
+        const prompt = text.length > MAX_INPUT_CHARS ? text.slice(0, MAX_INPUT_CHARS) : text;
+        if (prompt.length < text.length) {
+            (0, log_1.appendLog)("embed.truncate", { from: text.length, to: prompt.length });
+        }
+        try {
+            const res = await fetch(`${this.url}/api/embeddings`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ model: this.model, prompt }),
+            });
+            if (!res.ok)
+                return null;
+            const data = (await res.json());
+            if (!data.embedding || data.embedding.length !== exports.EMBED_DIM)
+                return null;
+            return l2Normalize(data.embedding);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.OllamaProvider = OllamaProvider;
+exports.defaultProvider = new OllamaProvider();

package/dist/lib/embed.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setEmbedding = setEmbedding;
+exports.hasEmbedding = hasEmbedding;
+exports.embedMissing = embedMissing;
+const embed_provider_1 = require("./embed-provider");
+function setEmbedding(db, id, vec) {
+    if (vec.length !== embed_provider_1.EMBED_DIM) {
+        throw new Error(`embed: expected ${embed_provider_1.EMBED_DIM}-dim, got ${vec.length}`);
+    }
+    const tx = db.transaction(() => {
+        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
+        db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(id, new Float32Array(vec));
+    });
+    tx();
+}
+function hasEmbedding(db, id) {
+    return db.prepare("SELECT 1 FROM entries_vec WHERE id = ?").get(id) !== undefined;
+}
+async function embedMissing(db, provider) {
+    const rows = db
+        .prepare("SELECT e.id, e.body FROM entries e LEFT JOIN entries_vec v ON v.id = e.id WHERE v.id IS NULL")
+        .all();
+    let embedded = 0;
+    let skipped = 0;
+    for (const row of rows) {
+        const vec = await provider.embed(row.body);
+        if (vec === null) {
+            skipped++;
+            continue;
+        }
+        setEmbedding(db, row.id, vec);
+        embedded++;
+    }
+    return { embedded, skipped };
+}

package/dist/lib/entry-io.js

@@ -0,0 +1,82 @@
+"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.writeEntry = writeEntry;
+exports.readEntry = readEntry;
+exports.listEntryIds = listEntryIds;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const gray_matter_1 = __importDefault(require("gray-matter"));
+const entry_1 = require("./entry");
+const paths_1 = require("./paths");
+function entryPath(id) {
+    return path.join((0, paths_1.entriesDir)(), `${id}.md`);
+}
+function writeEntry(entry) {
+    entry_1.EntrySchema.parse(entry);
+    fs.mkdirSync((0, paths_1.entriesDir)(), { recursive: true });
+    const { body, ...rest } = entry;
+    // js-yaml cannot serialize `undefined` — strip optional fields that weren't set.
+    // Keeping `undefined` keys in frontmatter (e.g., stance: undefined from a caller
+    // that explicitly sets it) would throw "unacceptable kind of an object to dump".
+    const frontmatter = {};
+    for (const [key, value] of Object.entries(rest)) {
+        if (value !== undefined)
+            frontmatter[key] = value;
+    }
+    const file = gray_matter_1.default.stringify(body, frontmatter);
+    const final = entryPath(entry.id);
+    const tmp = `${final}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, file);
+    fs.renameSync(tmp, final);
+}
+function readEntry(id) {
+    const raw = fs.readFileSync(entryPath(id), "utf8");
+    const parsed = (0, gray_matter_1.default)(raw);
+    // Do NOT .trim() — body is canonical as written (with trailing newline).
+    return entry_1.EntrySchema.parse({ ...parsed.data, body: parsed.content });
+}
+function listEntryIds() {
+    const dir = (0, paths_1.entriesDir)();
+    if (!fs.existsSync(dir))
+        return [];
+    return fs
+        .readdirSync(dir)
+        .filter((f) => !f.startsWith(".") && f.endsWith(".md"))
+        .map((f) => f.slice(0, -3));
+}

package/dist/lib/entry.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntrySchema = exports.Confidence = exports.EntrySource = exports.EntryKind = exports.ENTRY_ID_REGEX = void 0;
+const zod_1 = require("zod");
+/**
+ * An Entry is anything worth remembering from your work.
+ *
+ * This schema is load-bearing. It sets:
+ *   - the ceiling on retrieval quality (what fields exist to rank/filter by),
+ *   - the floor on capture success (what fields a capture must produce).
+ *
+ * Design bias: small required set, rich optional set. Auto-capture from
+ * Claude Code sessions cannot reliably produce a stance, so stance is
+ * optional. But capture can always produce body, kind, and source.
+ *
+ * If required vs. optional is wrong, it's easy to migrate early. It gets
+ * hard once there are thousands of entries. Think hard before changing.
+ */
+// ID format: ENT-YYMMDD-XXXX where XXXX is 4 hex chars.
+exports.ENTRY_ID_REGEX = /^ENT-\d{6}-[A-F0-9]{4}$/;
+exports.EntryKind = zod_1.z.enum([
+    "decision", // a choice made, with reasoning
+    "observation", // something noticed about how the world works
+    "pattern", // a reusable approach or shape
+    "commitment", // a promise made to future-self
+    "reference", // a piece of context worth preserving (snippet, link, spec)
+]);
+exports.EntrySource = zod_1.z.enum([
+    "claude-code", // auto-captured from a Claude Code session
+    "cursor", // auto-captured from Cursor
+    "git", // captured from a commit / PR / diff
+    "manual", // user typed it in via remember() or CLI
+    "import", // bulk-imported from another system
+]);
+exports.Confidence = zod_1.z.preprocess(
+// case-insensitive accept; avoids the silent-drop bug from Zuhn's review
+(v) => (typeof v === "string" ? v.toLowerCase() : v), zod_1.z.enum(["low", "medium", "high"]));
+exports.EntrySchema = zod_1.z.object({
+    // --- required ---
+    id: zod_1.z.string().regex(exports.ENTRY_ID_REGEX),
+    created: zod_1.z.string().datetime(),
+    body: zod_1.z.string().min(1),
+    kind: exports.EntryKind,
+    source: exports.EntrySource,
+    // --- optional, but the retrieval layer leans on these ---
+    /** One-line directional claim, assertable as true or false. */
+    stance: zod_1.z.string().optional(),
+    /** Freeform tags. No ontology, no hierarchy. Retrieval handles grouping. */
+    tags: zod_1.z.array(zod_1.z.string()).default([]),
+    /** Advisory links to other entry IDs. Not validated; broken refs are fine. */
+    related: zod_1.z.array(zod_1.z.string()).default([]),
+    /** Self-assessed confidence in the entry's claim. */
+    confidence: exports.Confidence.optional(),
+    /** Where this came from — git sha, session id, URL, file path, etc. */
+    origin: zod_1.z.string().optional(),
+    /** Absolute path to the project/repo this entry came from. Used by SessionStart + context_for for scoped retrieval. */
+    project: zod_1.z.string().optional(),
+});

package/dist/lib/id.js

@@ -0,0 +1,49 @@
+"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.newEntryId = newEntryId;
+const crypto = __importStar(require("crypto"));
+function newEntryId(body, at = new Date()) {
+    const yy = String(at.getUTCFullYear()).slice(-2);
+    const mm = String(at.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(at.getUTCDate()).padStart(2, "0");
+    const hash = crypto
+        .createHash("sha256")
+        .update(`${body}|${at.getTime()}`)
+        .digest("hex")
+        .slice(0, 4)
+        .toUpperCase();
+    return `ENT-${yy}${mm}${dd}-${hash}`;
+}

package/dist/lib/log.js

@@ -0,0 +1,66 @@
+"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.appendLog = appendLog;
+exports.tailLog = tailLog;
+const fs = __importStar(require("fs"));
+const paths_1 = require("./paths");
+function appendLog(event, payload) {
+    try {
+        fs.mkdirSync((0, paths_1.storeRoot)(), { recursive: true });
+        const line = { at: new Date().toISOString(), event, payload };
+        fs.appendFileSync((0, paths_1.logPath)(), JSON.stringify(line) + "\n");
+    }
+    catch {
+        // Logging must never break the caller. Swallow.
+    }
+}
+function tailLog(n) {
+    const p = (0, paths_1.logPath)();
+    if (!fs.existsSync(p))
+        return [];
+    const raw = fs.readFileSync(p, "utf8");
+    const lines = raw.split("\n").filter((l) => l.length > 0);
+    return lines
+        .slice(-n)
+        .flatMap((l) => {
+        try {
+            return [JSON.parse(l)];
+        }
+        catch {
+            return [];
+        }
+    });
+}

package/dist/lib/paths.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.storeRoot = storeRoot;
+exports.entriesDir = entriesDir;
+exports.dbPath = dbPath;
+exports.logPath = logPath;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+function storeRoot() {
+    return process.env.ZUUN_HOME ?? path.join(os.homedir(), ".zuun");
+}
+function entriesDir() {
+    return path.join(storeRoot(), "entries");
+}
+function dbPath() {
+    return path.join(storeRoot(), "index.db");
+}
+function logPath() {
+    return path.join(storeRoot(), "log.jsonl");
+}

package/dist/lib/project.js

@@ -0,0 +1,67 @@
+"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.resolveProject = resolveProject;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+/**
+ * Resolve an absolute project path for the given working directory.
+ *
+ * Returns the enclosing git repo's toplevel if cwd is inside a git repo.
+ * Returns `undefined` if the cwd is NOT inside a git repo — treated as a
+ * "global" capture in zuun's semantics (applies to every project).
+ *
+ * Also returns undefined if the cwd doesn't exist.
+ */
+function resolveProject(cwd = process.cwd()) {
+    try {
+        const real = fs.realpathSync(cwd);
+        try {
+            const root = (0, child_process_1.execFileSync)("git", ["rev-parse", "--show-toplevel"], {
+                cwd: real,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+            return fs.realpathSync(root);
+        }
+        catch {
+            // Not inside a git repo — treat as global (return undefined).
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/search.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWeights = parseWeights;
+exports.search = search;
+const store_1 = require("./store");
+function parseWeights(raw) {
+    const def = { fts: 0.45, vec: 0.45, recency: 0.1 };
+    if (!raw)
+        return def;
+    const parts = raw.split(",").map((s) => Number(s.trim()));
+    if (parts.length !== 3 || parts.some((n) => !Number.isFinite(n)))
+        return def;
+    const sum = parts[0] + parts[1] + parts[2];
+    if (sum <= 0)
+        return def;
+    return { fts: parts[0] / sum, vec: parts[1] / sum, recency: parts[2] / sum };
+}
+function sanitizeFts(q) {
+    return q
+        .replace(/["*]/g, " ")
+        .split(/\s+/)
+        .filter((t) => t.length > 0)
+        .map((t) => `"${t.replace(/"/g, "")}"`)
+        .join(" OR ");
+}
+function minMax(scores) {
+    if (scores.size === 0)
+        return scores;
+    const values = [...scores.values()];
+    const min = Math.min(...values);
+    const max = Math.max(...values);
+    if (max === min) {
+        const uniform = new Map();
+        for (const k of scores.keys())
+            uniform.set(k, 1);
+        return uniform;
+    }
+    const out = new Map();
+    for (const [k, v] of scores)
+        out.set(k, (v - min) / (max - min));
+    return out;
+}
+function recencyScore(createdIso, now) {
+    const ageMs = now - new Date(createdIso).getTime();
+    const ageDays = Math.max(0, ageMs / 86_400_000);
+    return Math.exp(-ageDays / 30);
+}
+function passesFilters(entry, opts) {
+    if (opts.kind && entry.kind !== opts.kind)
+        return false;
+    if (opts.since && entry.created < opts.since)
+        return false;
+    if (opts.tags && opts.tags.length > 0) {
+        const have = new Set(entry.tags);
+        for (const t of opts.tags)
+            if (!have.has(t))
+                return false;
+    }
+    if (opts.project) {
+        const p = entry.project;
+        if (p) {
+            if (!(p === opts.project || p.startsWith(opts.project + "/") || opts.project.startsWith(p + "/"))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function search(db, opts) {
+    const limit = opts.limit ?? 10;
+    if (opts.query.trim().length === 0)
+        return [];
+    const envWeights = parseWeights(process.env.ZUUN_SEARCH_BLEND);
+    const weights = opts.queryVec
+        ? envWeights
+        : { fts: envWeights.fts + envWeights.vec, vec: 0, recency: envWeights.recency };
+    const ftsQuery = sanitizeFts(opts.query);
+    const ftsScores = new Map();
+    if (ftsQuery.length > 0) {
+        try {
+            const rows = db
+                .prepare("SELECT id, bm25(entries_fts) AS score FROM entries_fts WHERE entries_fts MATCH ? ORDER BY score LIMIT ?")
+                .all(ftsQuery, limit * 8);
+            for (const r of rows)
+                ftsScores.set(r.id, -r.score);
+        }
+        catch {
+            // fall through
+        }
+    }
+    const vecScores = new Map();
+    if (opts.queryVec) {
+        const rows = db
+            .prepare("SELECT id, distance FROM entries_vec WHERE embedding MATCH ? AND k = ? ORDER BY distance")
+            .all(new Float32Array(opts.queryVec), limit * 8);
+        for (const r of rows)
+            vecScores.set(r.id, 1 - r.distance);
+    }
+    const normFts = minMax(ftsScores);
+    const normVec = minMax(vecScores);
+    const candidateIds = new Set([...normFts.keys(), ...normVec.keys()]);
+    const now = Date.now();
+    const scored = [];
+    for (const id of candidateIds) {
+        const entry = (0, store_1.getEntry)(db, id);
+        if (!entry || !passesFilters(entry, opts))
+            continue;
+        const f = normFts.get(id) ?? 0;
+        const v = normVec.get(id) ?? 0;
+        const r = recencyScore(entry.created, now);
+        const score = weights.fts * f + weights.vec * v + weights.recency * r;
+        scored.push({ id, score, parts: { fts: f, vec: v, recency: r }, entry });
+    }
+    scored.sort((x, y) => y.score - x.score);
+    return scored.slice(0, limit).map((s) => ({
+        id: s.id,
+        score: s.score,
+        entry: s.entry,
+        parts: s.parts,
+    }));
+}

package/dist/lib/store.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertEntry = upsertEntry;
+exports.deleteEntry = deleteEntry;
+exports.getEntry = getEntry;
+exports.listEntries = listEntries;
+const entry_1 = require("./entry");
+function rowToEntry(row) {
+    return entry_1.EntrySchema.parse({
+        ...row,
+        tags: JSON.parse(row.tags),
+        related: JSON.parse(row.related),
+        stance: row.stance ?? undefined,
+        origin: row.origin ?? undefined,
+        project: row.project ?? undefined,
+        confidence: row.confidence ?? undefined,
+    });
+}
+function upsertEntry(db, entry) {
+    entry_1.EntrySchema.parse(entry);
+    const tx = db.transaction(() => {
+        db.prepare(`INSERT INTO entries (id, body, kind, source, created, stance, origin, project, tags, related, confidence)
+       VALUES (@id, @body, @kind, @source, @created, @stance, @origin, @project, @tags, @related, @confidence)
+       ON CONFLICT(id) DO UPDATE SET
+         body=excluded.body, kind=excluded.kind, source=excluded.source,
+         created=excluded.created, stance=excluded.stance, origin=excluded.origin,
+         project=excluded.project,
+         tags=excluded.tags, related=excluded.related, confidence=excluded.confidence`).run({
+            id: entry.id,
+            body: entry.body,
+            kind: entry.kind,
+            source: entry.source,
+            created: entry.created,
+            stance: entry.stance ?? null,
+            origin: entry.origin ?? null,
+            project: entry.project ?? null,
+            tags: JSON.stringify(entry.tags),
+            related: JSON.stringify(entry.related),
+            confidence: entry.confidence ?? null,
+        });
+        // Regular-content FTS5 supports plain DELETE + INSERT.
+        db.prepare("DELETE FROM entries_fts WHERE id = ?").run(entry.id);
+        db.prepare("INSERT INTO entries_fts (id, body) VALUES (?, ?)").run(entry.id, entry.body);
+    });
+    tx();
+}
+function deleteEntry(db, id) {
+    const tx = db.transaction(() => {
+        db.prepare("DELETE FROM entries WHERE id = ?").run(id);
+        db.prepare("DELETE FROM entries_fts WHERE id = ?").run(id);
+        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
+    });
+    tx();
+}
+function getEntry(db, id) {
+    const row = db.prepare("SELECT * FROM entries WHERE id = ?").get(id);
+    return row ? rowToEntry(row) : null;
+}
+function listEntries(db) {
+    const rows = db
+        .prepare("SELECT * FROM entries ORDER BY created DESC")
+        .all();
+    return rows.map(rowToEntry);
+}

package/dist/lib/tags.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTag = normalizeTag;
+exports.normalizeTags = normalizeTags;
+function normalizeTag(raw) {
+    return raw.trim().toLowerCase().replace(/\s+/g, "-");
+}
+function normalizeTags(raws) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of raws) {
+        const t = normalizeTag(raw);
+        if (t.length === 0 || seen.has(t))
+            continue;
+        seen.add(t);
+        out.push(t);
+    }
+    return out;
+}