@llmnesia/mcp 0.1.0

package/dist/chunk-OBJD6H4A.js

@@ -0,0 +1,883 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/config.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var CORPUS_FORMAT_VERSION = 1;
+function nativeHostConfigPath() {
+  return join(homedir(), ".llmnesia", "config.json");
+}
+function readNativeHostCorpusRoot() {
+  try {
+    const parsed = JSON.parse(readFileSync(nativeHostConfigPath(), "utf8"));
+    return typeof parsed.corpusRoot === "string" ? parsed.corpusRoot : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveCorpusDir(explicit) {
+  const raw = explicit ?? process.env.LLMNESIA_CORPUS_DIR ?? readNativeHostCorpusRoot() ?? "~/.llmnesia/corpus";
+  return expandHome(raw);
+}
+function expandHome(p) {
+  if (p === "~") {
+    return homedir();
+  }
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return resolve(homedir(), p.slice(2));
+  }
+  return resolve(p);
+}
+
+// src/corpus.ts
+import { promises as fs } from "fs";
+import { dirname, join as join3 } from "path";
+
+// src/paths.ts
+import { join as join2 } from "path";
+import { createHash } from "crypto";
+var CorpusPaths = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  get metaFile() {
+    return join2(this.root, "meta.json");
+  }
+  get inboxDir() {
+    return join2(this.root, "inbox");
+  }
+  get processedDir() {
+    return join2(this.inboxDir, "processed");
+  }
+  get conversationsDir() {
+    return join2(this.root, "conversations");
+  }
+  get indexDir() {
+    return join2(this.root, "index");
+  }
+  get indexDbFile() {
+    return join2(this.indexDir, "llmnesia.db");
+  }
+  /** Directory holding a platform's conversation JSON files. */
+  platformDir(platform) {
+    return join2(this.conversationsDir, safeSegment(platform));
+  }
+  /** Absolute path to the JSON file backing a given docId. */
+  conversationFile(platform, docId) {
+    return join2(this.platformDir(platform), `${slugifyDocId(docId)}.json`);
+  }
+};
+var SLUG_MAX = 120;
+function slugifyDocId(docId) {
+  const lossless = docId.length > 0 && docId.length <= SLUG_MAX && /^[a-zA-Z0-9._-]+$/.test(docId);
+  if (lossless) {
+    return docId;
+  }
+  const hash = createHash("sha1").update(docId).digest("hex").slice(0, 12);
+  const readable = docId.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, SLUG_MAX - 13);
+  return readable.length > 0 ? `${readable}-${hash}` : hash;
+}
+function safeSegment(value) {
+  const cleaned = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[.-]+|[.-]+$/g, "");
+  return cleaned.length > 0 ? cleaned : "unknown";
+}
+
+// src/serialize.ts
+function canonicalizeConversation(record) {
+  return {
+    conversation: canonicalConversationDoc(record.conversation),
+    messages: [...record.messages].sort((a, b) => a.msgIndex - b.msgIndex).map(canonicalMessageDoc)
+  };
+}
+function canonicalConversationDoc(c) {
+  const out = {
+    docId: c.docId,
+    platform: c.platform,
+    title: c.title,
+    url: c.url,
+    createdAt: c.createdAt,
+    contentUpdatedAt: c.contentUpdatedAt,
+    indexedAt: c.indexedAt,
+    updatedAt: c.updatedAt,
+    lastSeenAt: c.lastSeenAt,
+    messageCount: c.messageCount,
+    preview: c.preview,
+    hasImages: c.hasImages,
+    pinned: c.pinned,
+    indexLevel: c.indexLevel,
+    estimatedBytes: c.estimatedBytes
+  };
+  assignIfDefined(out, "searchDocLength", c.searchDocLength);
+  assignIfDefined(out, "contentHash", c.contentHash);
+  assignIfDefined(out, "truncated", c.truncated);
+  assignIfDefined(out, "kind", c.kind);
+  assignIfDefined(out, "sourceId", c.sourceId);
+  assignIfDefined(out, "baseUrl", c.baseUrl);
+  assignIfDefined(out, "isDeeplinkable", c.isDeeplinkable);
+  assignIfDefined(out, "origin", c.origin);
+  assignIfDefined(out, "accountId", c.accountId);
+  assignIfDefined(out, "accountLabel", c.accountLabel);
+  if (c.summary) {
+    out.summary = {
+      text: c.summary.text,
+      recipe: c.summary.recipe,
+      method: c.summary.method,
+      createdAt: c.summary.createdAt
+    };
+  }
+  return out;
+}
+function canonicalMessageDoc(m) {
+  const out = {
+    msgKey: m.msgKey,
+    docId: m.docId,
+    msgIndex: m.msgIndex,
+    role: m.role,
+    text: m.text
+  };
+  assignIfDefined(out, "formattedText", m.formattedText);
+  out.createdAt = m.createdAt;
+  out.updatedAt = m.updatedAt;
+  out.contentHash = m.contentHash;
+  assignIfDefined(out, "platformMessageId", m.platformMessageId);
+  return out;
+}
+function assignIfDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+
+// src/corpus.ts
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var Corpus = class {
+  paths;
+  // Serialize writes within this process so concurrent upserts (inbox drain +
+  // MCP save_conversation) don't interleave. Cross-process safety relies on the
+  // attended, single-companion v1 model (see PLAN-MCP.md open question 3).
+  writeChain = Promise.resolve();
+  constructor(root) {
+    this.paths = new CorpusPaths(root);
+  }
+  /** Create the directory skeleton and meta.json if absent. Idempotent. */
+  async init() {
+    await fs.mkdir(this.paths.conversationsDir, { recursive: true, mode: DIR_MODE });
+    await fs.mkdir(this.paths.processedDir, { recursive: true, mode: DIR_MODE });
+    await fs.mkdir(this.paths.indexDir, { recursive: true, mode: DIR_MODE });
+    await hardenDir(this.paths.root);
+    await hardenDir(this.paths.conversationsDir);
+    await hardenDir(this.paths.inboxDir);
+    await hardenDir(this.paths.processedDir);
+    await hardenDir(this.paths.indexDir);
+    try {
+      await fs.access(this.paths.metaFile);
+    } catch {
+      const meta = {
+        formatVersion: CORPUS_FORMAT_VERSION,
+        createdAt: Date.now(),
+        lastIngestAt: null,
+        conversationCount: 0
+      };
+      await writeFileAtomic(this.paths.metaFile, `${JSON.stringify(meta, null, 2)}
+`);
+    }
+  }
+  async readMeta() {
+    try {
+      const raw = await fs.readFile(this.paths.metaFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async writeMeta(patch) {
+    const current = await this.readMeta() ?? {
+      formatVersion: CORPUS_FORMAT_VERSION,
+      createdAt: Date.now(),
+      lastIngestAt: null,
+      conversationCount: 0
+    };
+    const next = { ...current, ...patch };
+    await writeFileAtomic(this.paths.metaFile, `${JSON.stringify(next, null, 2)}
+`);
+  }
+  /**
+   * Insert or replace a conversation, keyed on docId with last-write-wins by
+   * `conversation.updatedAt`. A stale write (older updatedAt than what's on
+   * disk) is a no-op. Re-writing identical content produces byte-identical
+   * output, so replaying a delta is safe.
+   */
+  async upsert(record) {
+    return this.enqueueWrite(async () => {
+      const canonical = canonicalizeConversation(record);
+      const { conversation } = canonical;
+      const file = this.paths.conversationFile(conversation.platform, conversation.docId);
+      const existing = await readJsonIfExists(file);
+      if (existing) {
+        const existingUpdatedAt = existing.conversation.updatedAt ?? 0;
+        const incomingUpdatedAt = conversation.updatedAt ?? 0;
+        if (incomingUpdatedAt < existingUpdatedAt) {
+          return { docId: conversation.docId, outcome: "skipped" };
+        }
+      }
+      const serialized = `${JSON.stringify(canonical, null, 2)}
+`;
+      if (existing) {
+        const existingSerialized = `${JSON.stringify(canonicalizeConversation(existing), null, 2)}
+`;
+        if (existingSerialized === serialized) {
+          return { docId: conversation.docId, outcome: "skipped" };
+        }
+      }
+      await fs.mkdir(dirname(file), { recursive: true, mode: DIR_MODE });
+      await writeFileAtomic(file, serialized);
+      return { docId: conversation.docId, outcome: existing ? "updated" : "created" };
+    });
+  }
+  /** Read a conversation by docId, scanning platform dirs for the slug file. */
+  async get(docId) {
+    const filename = `${slugifyDocId(docId)}.json`;
+    for (const platform of await this.listPlatforms()) {
+      const candidate = join3(this.paths.platformDir(platform), filename);
+      const record = await readJsonIfExists(candidate);
+      if (record && record.conversation.docId === docId) {
+        return record;
+      }
+    }
+    return null;
+  }
+  /** Platform subdirectory names under conversations/. */
+  async listPlatforms() {
+    try {
+      const entries = await fs.readdir(this.paths.conversationsDir, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+  /** Async-iterate every stored conversation (used by reindex + stats). */
+  async *iterate() {
+    for (const platform of await this.listPlatforms()) {
+      const dir = this.paths.platformDir(platform);
+      let files;
+      try {
+        files = await fs.readdir(dir);
+      } catch {
+        continue;
+      }
+      for (const name of files) {
+        if (!name.endsWith(".json")) {
+          continue;
+        }
+        const record = await readJsonIfExists(join3(dir, name));
+        if (record) {
+          yield record;
+        }
+      }
+    }
+  }
+  async stats() {
+    const byPlatform = {};
+    let conversationCount = 0;
+    let messageCount = 0;
+    for await (const record of this.iterate()) {
+      conversationCount += 1;
+      messageCount += record.messages.length;
+      const platform = safeSegment(record.conversation.platform);
+      byPlatform[platform] = (byPlatform[platform] ?? 0) + 1;
+    }
+    return { conversationCount, messageCount, byPlatform };
+  }
+  /** Refresh meta.json's conversationCount / lastIngestAt after an ingest run. */
+  async touchIngestMeta() {
+    const { conversationCount } = await this.stats();
+    await this.writeMeta({ lastIngestAt: Date.now(), conversationCount });
+  }
+  enqueueWrite(fn) {
+    const run = this.writeChain.then(fn, fn);
+    this.writeChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+};
+async function readJsonIfExists(file) {
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeFileAtomic(file, contents) {
+  const tmp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  await fs.writeFile(tmp, contents, { encoding: "utf8", mode: FILE_MODE });
+  await fs.rename(tmp, file);
+}
+async function hardenDir(dir) {
+  try {
+    await fs.chmod(dir, DIR_MODE);
+  } catch {
+  }
+}
+
+// src/ingest.ts
+import { promises as fs2, createReadStream } from "fs";
+import { join as join4 } from "path";
+import { createInterface } from "readline";
+import { createGunzip } from "zlib";
+var EMPTY_REPORT = {
+  conversations: 0,
+  created: 0,
+  updated: 0,
+  skipped: 0,
+  messages: 0,
+  malformedLines: 0
+};
+async function ingestFile(corpus, file, index) {
+  const report = { ...EMPTY_REPORT };
+  let current = null;
+  let buffered = [];
+  const flush = async () => {
+    if (!current) {
+      return;
+    }
+    const record = { conversation: current, messages: buffered };
+    const result = await corpus.upsert(record);
+    tally(report, result);
+    if (index && result.outcome !== "skipped") {
+      index.upsertConversation(record);
+    }
+    report.conversations += 1;
+    report.messages += buffered.length;
+    current = null;
+    buffered = [];
+  };
+  const rl = createInterface({ input: openLineSource(file), crlfDelay: Infinity });
+  for await (const raw of rl) {
+    const line = raw.trim();
+    if (!line) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      report.malformedLines += 1;
+      continue;
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      report.malformedLines += 1;
+      continue;
+    }
+    const record = parsed;
+    const type = record.type;
+    if (type === "meta") {
+      continue;
+    }
+    if (type === "conversation") {
+      await flush();
+      current = coerceConversation(record.conversation);
+      buffered = [];
+      if (!current) {
+        report.malformedLines += 1;
+      }
+      continue;
+    }
+    if (type === "message" && current) {
+      const docId = typeof record.docId === "string" ? record.docId : "";
+      if (docId !== current.docId) {
+        report.malformedLines += 1;
+        continue;
+      }
+      const message = coerceMessage(current.docId, record.message);
+      if (message) {
+        buffered.push(message);
+      } else {
+        report.malformedLines += 1;
+      }
+    }
+  }
+  await flush();
+  return report;
+}
+async function pendingInboxFiles(corpus) {
+  try {
+    return (await fs2.readdir(corpus.paths.inboxDir, { withFileTypes: true })).filter((e) => e.isFile() && isNdjson(e.name)).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+async function drainInbox(corpus, index, options = {}) {
+  await corpus.init();
+  const inbox = corpus.paths.inboxDir;
+  const entries = await pendingInboxFiles(corpus);
+  const total = { ...EMPTY_REPORT, files: 0, failed: 0 };
+  for (const name of entries) {
+    const src = join4(inbox, name);
+    try {
+      const report = await ingestFile(corpus, src, index);
+      accumulate(total, report);
+      total.files += 1;
+      await moveToProcessed(corpus, src, name);
+    } catch (error) {
+      if (await stillPending(src)) {
+        total.failed += 1;
+        options.onFileError?.(name, error);
+      }
+    }
+  }
+  if (total.files > 0) {
+    await corpus.touchIngestMeta();
+  }
+  return total;
+}
+async function stillPending(src) {
+  try {
+    await fs2.access(src);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function moveToProcessed(corpus, src, name) {
+  const dest = join4(corpus.paths.processedDir, name);
+  try {
+    await fs2.rename(src, dest);
+  } catch {
+    const alt = join4(corpus.paths.processedDir, `${Date.now()}-${name}`);
+    await fs2.copyFile(src, alt);
+    await fs2.unlink(src);
+  }
+}
+function isNdjson(name) {
+  const lower = name.toLowerCase();
+  return lower.endsWith(".jsonl") || lower.endsWith(".ndjson") || lower.endsWith(".jsonl.gz") || lower.endsWith(".ndjson.gz");
+}
+function openLineSource(file) {
+  const stream = createReadStream(file);
+  if (file.toLowerCase().endsWith(".gz")) {
+    return stream.pipe(createGunzip());
+  }
+  return stream;
+}
+function coerceConversation(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const c = value;
+  if (typeof c.docId !== "string" || !c.docId) {
+    return null;
+  }
+  const conversation = { ...c };
+  if (typeof conversation.updatedAt !== "number") {
+    conversation.updatedAt = typeof conversation.contentUpdatedAt === "number" ? conversation.contentUpdatedAt : 0;
+  }
+  return conversation;
+}
+function coerceMessage(docId, value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const m = value;
+  const text = typeof m.text === "string" ? m.text : "";
+  if (!text.trim()) {
+    return null;
+  }
+  const msgIndex = typeof m.msgIndex === "number" ? m.msgIndex : 0;
+  const message = {
+    // The backup line omits msgKey; reconstruct the extension's convention.
+    msgKey: `${docId}:${msgIndex}`,
+    docId,
+    msgIndex,
+    role: coerceRole(m.role),
+    text,
+    createdAt: typeof m.createdAt === "number" ? m.createdAt : 0,
+    updatedAt: typeof m.updatedAt === "number" ? m.updatedAt : 0,
+    contentHash: typeof m.contentHash === "string" ? m.contentHash : ""
+  };
+  if (typeof m.formattedText === "string") {
+    message.formattedText = m.formattedText;
+  }
+  if (typeof m.platformMessageId === "string") {
+    message.platformMessageId = m.platformMessageId;
+  } else if (m.platformMessageId === null) {
+    message.platformMessageId = null;
+  }
+  return message;
+}
+function coerceRole(value) {
+  return value === "assistant" || value === "user" || value === "system" || value === "unknown" ? value : "unknown";
+}
+function tally(report, result) {
+  if (result.outcome === "created") {
+    report.created += 1;
+  } else if (result.outcome === "updated") {
+    report.updated += 1;
+  } else {
+    report.skipped += 1;
+  }
+}
+function accumulate(total, report) {
+  total.conversations += report.conversations;
+  total.created += report.created;
+  total.updated += report.updated;
+  total.skipped += report.skipped;
+  total.messages += report.messages;
+  total.malformedLines += report.malformedLines;
+}
+
+// src/searchIndex.ts
+import { promises as fs3, chmodSync, closeSync, openSync } from "fs";
+import { createRequire } from "module";
+
+// src/sqliteWarning.ts
+var INSTALLED = /* @__PURE__ */ Symbol.for("llmnesia.sqliteWarningFilterInstalled");
+function isSqliteExperimentalWarning(warning) {
+  return warning.name === "ExperimentalWarning" && /\bSQLite\b/i.test(warning.message);
+}
+function install() {
+  const flagged = globalThis;
+  if (flagged[INSTALLED]) {
+    return;
+  }
+  flagged[INSTALLED] = true;
+  const previous = process.listeners("warning");
+  process.removeAllListeners("warning");
+  process.on("warning", (warning) => {
+    if (isSqliteExperimentalWarning(warning)) {
+      return;
+    }
+    for (const listener of previous) {
+      listener.call(process, warning);
+    }
+  });
+}
+install();
+
+// src/searchIndex.ts
+var nodeRequire = createRequire(import.meta.url);
+var sqlite;
+function loadSqlite() {
+  return sqlite ??= nodeRequire("node:sqlite");
+}
+var DB_FILE_MODE = 384;
+function hardenDbFile(dbPath) {
+  try {
+    closeSync(openSync(dbPath, "a", DB_FILE_MODE));
+    chmodSync(dbPath, DB_FILE_MODE);
+  } catch {
+  }
+}
+var INDEX_FORMAT_VERSION = 1;
+var TITLE_ROW_INDEX = -1;
+var TITLE_ROLE = "title";
+var DEFAULT_LIMIT = 10;
+var SNIPPET_TOKENS = 12;
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS index_meta (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS conversations (
+  docId TEXT PRIMARY KEY,
+  platform TEXT NOT NULL,
+  title TEXT NOT NULL,
+  url TEXT NOT NULL,
+  createdAt INTEGER NOT NULL,
+  updatedAt INTEGER NOT NULL,
+  messageCount INTEGER NOT NULL,
+  preview TEXT NOT NULL,
+  pinned INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_conversations_platform ON conversations(platform);
+CREATE INDEX IF NOT EXISTS idx_conversations_createdAt ON conversations(createdAt);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  docId UNINDEXED,
+  msgIndex UNINDEXED,
+  role UNINDEXED,
+  text,
+  tokenize = 'porter unicode61'
+);
+`;
+var SearchIndex = class {
+  db;
+  stmts;
+  constructor(dbPath) {
+    hardenDbFile(dbPath);
+    this.db = new (loadSqlite()).DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = OFF");
+    this.db.exec(SCHEMA_SQL);
+    this.setMeta("format_version", String(INDEX_FORMAT_VERSION));
+    this.stmts = {
+      deleteFts: this.db.prepare("DELETE FROM messages_fts WHERE docId = ?"),
+      insertFts: this.db.prepare(
+        "INSERT INTO messages_fts (docId, msgIndex, role, text) VALUES (?, ?, ?, ?)"
+      ),
+      deleteConversation: this.db.prepare("DELETE FROM conversations WHERE docId = ?"),
+      insertConversation: this.db.prepare(
+        `INSERT INTO conversations
+           (docId, platform, title, url, createdAt, updatedAt, messageCount, preview, pinned)
+         VALUES (@docId, @platform, @title, @url, @createdAt, @updatedAt, @messageCount, @preview, @pinned)`
+      )
+    };
+  }
+  /** True when the stored format version is missing or stale — caller rebuilds. */
+  needsRebuild() {
+    const stored = this.getMeta("format_version");
+    return stored !== String(INDEX_FORMAT_VERSION);
+  }
+  /** Number of indexed conversations. */
+  count() {
+    const row = this.db.prepare("SELECT COUNT(*) AS n FROM conversations").get();
+    return row.n;
+  }
+  /** Most-recently-updated conversations (metadata only), newest first. */
+  listRecent(n) {
+    const limit = Math.max(1, n);
+    const rows = this.db.prepare(
+      `SELECT docId, platform, title, url, createdAt, updatedAt, messageCount, preview, pinned
+         FROM conversations ORDER BY updatedAt DESC, createdAt DESC LIMIT ?`
+    ).all(limit);
+    return rows.map((r) => ({ ...r, pinned: r.pinned === 1 }));
+  }
+  /**
+   * Run `fn` inside a transaction, rolling back if it throws. node:sqlite has
+   * no transaction() wrapper, so this is the one place BEGIN/COMMIT/ROLLBACK
+   * lives for synchronous writes; {@link rebuildFrom} spells it out separately
+   * because its body is async and cannot be expressed as a sync callback.
+   */
+  transaction(fn) {
+    this.db.exec("BEGIN");
+    try {
+      const result = fn();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (err) {
+      this.db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+  upsertConversation(record) {
+    this.transaction(() => this.writeRecord(record));
+  }
+  removeConversation(docId) {
+    this.transaction(() => {
+      this.stmts.deleteFts.run(docId);
+      this.stmts.deleteConversation.run(docId);
+    });
+  }
+  /**
+   * Clear the index and repopulate it from the corpus — proving the corpus is
+   * the source of truth. Uses one manual transaction spanning the async file
+   * reads, which the sync {@link transaction} helper cannot hold.
+   */
+  async rebuildFrom(corpus) {
+    this.db.exec("DELETE FROM messages_fts; DELETE FROM conversations;");
+    let conversations = 0;
+    this.db.exec("BEGIN");
+    try {
+      for await (const record of corpus.iterate()) {
+        this.writeRecord(record);
+        conversations += 1;
+      }
+      this.db.exec("COMMIT");
+    } catch (err) {
+      this.db.exec("ROLLBACK");
+      throw err;
+    }
+    return { conversations };
+  }
+  // Replace a conversation's index rows. Caller supplies the transaction (the
+  // transaction() helper for single upserts, or rebuildFrom's manual one).
+  writeRecord(rec) {
+    const { conversation, messages } = rec;
+    this.stmts.deleteFts.run(conversation.docId);
+    this.stmts.deleteConversation.run(conversation.docId);
+    const titleText = [conversation.title, conversation.preview].filter(Boolean).join("\n");
+    if (titleText.trim()) {
+      this.stmts.insertFts.run(conversation.docId, TITLE_ROW_INDEX, TITLE_ROLE, titleText);
+    }
+    for (const message of messages) {
+      if (message.text.trim()) {
+        this.stmts.insertFts.run(conversation.docId, message.msgIndex, message.role, message.text);
+      }
+    }
+    this.stmts.insertConversation.run({
+      docId: conversation.docId,
+      platform: conversation.platform,
+      title: conversation.title,
+      url: conversation.url,
+      createdAt: conversation.createdAt,
+      updatedAt: conversation.updatedAt ?? conversation.contentUpdatedAt ?? 0,
+      messageCount: conversation.messageCount ?? messages.length,
+      preview: conversation.preview ?? "",
+      pinned: conversation.pinned ? 1 : 0
+    });
+  }
+  search(query, filters = {}) {
+    const match = toMatchQuery(query, filters.matchMode);
+    if (!match) {
+      return [];
+    }
+    const limit = Math.max(1, filters.limit ?? DEFAULT_LIMIT);
+    const clauses = ["messages_fts MATCH @match"];
+    const params = { match };
+    if (filters.platform) {
+      clauses.push("c.platform = @platform");
+      params.platform = filters.platform;
+    }
+    if (filters.title) {
+      clauses.push("c.title LIKE @title ESCAPE '\\'");
+      params.title = `%${escapeLike(filters.title)}%`;
+    }
+    if (typeof filters.dateFrom === "number") {
+      clauses.push("c.createdAt >= @dateFrom");
+      params.dateFrom = filters.dateFrom;
+    }
+    if (typeof filters.dateTo === "number") {
+      clauses.push("c.createdAt <= @dateTo");
+      params.dateTo = filters.dateTo;
+    }
+    const scanCap = Math.min(2e3, Math.max(200, limit * 40));
+    const sql = `
+      SELECT
+        c.docId, c.platform, c.title, c.url, c.createdAt, c.updatedAt,
+        c.messageCount, c.preview, c.pinned,
+        m.msgIndex AS msgIndex, m.role AS role,
+        snippet(messages_fts, 3, '[', ']', '\u2026', ${SNIPPET_TOKENS}) AS snippet,
+        bm25(messages_fts) AS bm25
+      FROM messages_fts m
+      JOIN conversations c ON c.docId = m.docId
+      WHERE ${clauses.join(" AND ")}
+      ORDER BY bm25
+      LIMIT @scanCap
+    `;
+    const rows = this.db.prepare(sql).all({ ...params, scanCap });
+    const seen = /* @__PURE__ */ new Set();
+    const hits = [];
+    for (const row of rows) {
+      if (seen.has(row.docId)) {
+        continue;
+      }
+      seen.add(row.docId);
+      hits.push({
+        docId: row.docId,
+        platform: row.platform,
+        title: row.title,
+        url: row.url,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+        messageCount: row.messageCount,
+        preview: row.preview,
+        pinned: row.pinned === 1,
+        // BM25 is negative (more negative = better); expose a positive relevance.
+        score: -row.bm25,
+        snippet: row.snippet,
+        matchRole: normalizeMatchRole(row.role),
+        matchMsgIndex: row.msgIndex
+      });
+      if (hits.length >= limit) {
+        break;
+      }
+    }
+    return hits;
+  }
+  close() {
+    this.db.close();
+  }
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key);
+    return row ? row.value : null;
+  }
+  setMeta(key, value) {
+    this.db.prepare("INSERT INTO index_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
+};
+async function openSearchIndex(corpus, options = {}) {
+  await corpus.init();
+  const index = new SearchIndex(corpus.paths.indexDbFile);
+  if (options.autoBuild !== false && (index.needsRebuild() || index.count() === 0)) {
+    await index.rebuildFrom(corpus);
+  }
+  return index;
+}
+async function deleteIndexDb(dbFile) {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    await fs3.rm(`${dbFile}${suffix}`, { force: true });
+  }
+}
+function toMatchQuery(query, mode = "any") {
+  const terms = query.split(/[^\p{L}\p{N}]+/u).filter((t) => t.length > 0);
+  if (terms.length === 0) {
+    return null;
+  }
+  if (mode === "phrase") {
+    return `"${terms.join(" ")}"`;
+  }
+  return terms.map((t) => `"${t}"`).join(mode === "all" ? " AND " : " OR ");
+}
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, "\\$&");
+}
+function normalizeMatchRole(role) {
+  if (role === "title") {
+    return "title";
+  }
+  return role === "assistant" || role === "user" || role === "system" ? role : "unknown";
+}
+
+// src/version.ts
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+export {
+  __commonJS,
+  __export,
+  __toESM,
+  resolveCorpusDir,
+  Corpus,
+  ingestFile,
+  pendingInboxFiles,
+  drainInbox,
+  SearchIndex,
+  openSearchIndex,
+  deleteIndexDb,
+  VERSION
+};
+//# sourceMappingURL=chunk-OBJD6H4A.js.map