@rikaidev/yomi 0.2.6

package/dist/search/scope.js

@@ -0,0 +1,142 @@
+/**
+ * Yomi conversation scoping — a DENYLIST of chats excluded from capture.
+ *
+ * Default behavior is capture-everything: every conversation is indexed by
+ * ../search/collector.ts unless its chatId appears in the `excluded_chats`
+ * table this module owns. Excluding a chat does two things, not one:
+ *   1. Blocks future capture — collectMessages drops excluded chatIds
+ *      before fetching (see ../search/collector.ts).
+ *   2. Purges past capture — deleteMessagesForChats removes that chat's
+ *      already-indexed messages AND their embeddings, so excluding a
+ *      conversation actually removes what was already learned about it
+ *      rather than just freezing the index in place. A denylist that only
+ *      blocked future capture while leaving old data behind would be fake
+ *      privacy.
+ *
+ * Shares the same node:sqlite connection as ../search/store.ts via the
+ * exported getDb(), so this table lives in the same search-index.db file
+ * rather than a second database.
+ */
+import { getDb } from './store.js';
+let tableEnsured = false;
+/**
+ * Create the `excluded_chats` table if it does not already exist. Memoized
+ * per process (mirrors getDb()'s own memoization) so every public function
+ * in this module can safely call it without repeating the DDL on every
+ * invocation.
+ */
+function ensureExcludedTable() {
+    if (tableEnsured) {
+        return;
+    }
+    const handle = getDb();
+    handle.exec(`
+    CREATE TABLE IF NOT EXISTS excluded_chats (
+      chatId TEXT PRIMARY KEY NOT NULL
+    );
+  `);
+    tableEnsured = true;
+}
+/**
+ * Build a `(?, ?, ...)` placeholder group sized to `values.length`, for use
+ * in an `IN (...)` clause. Callers must pass `values` itself (in the same
+ * order) as the bound parameters — this never string-interpolates the
+ * values themselves, only the `?` count.
+ *
+ * @param values - Values the IN-clause will be matched against.
+ * @returns Placeholder group, e.g. `(?, ?, ?)`.
+ */
+function buildPlaceholders(values) {
+    return `(${values.map(() => '?').join(', ')})`;
+}
+/**
+ * List every chatId currently on the exclusion denylist.
+ *
+ * @returns Set of excluded chatIds (empty when the denylist is empty).
+ */
+export function getExcludedChatIds() {
+    ensureExcludedTable();
+    const handle = getDb();
+    const rows = handle
+        .prepare('SELECT chatId FROM excluded_chats;')
+        .all();
+    return new Set(rows.map((row) => row.chatId));
+}
+/**
+ * Add chatIds to the exclusion denylist. Idempotent: chatIds already
+ * present are silently skipped (INSERT OR IGNORE), never duplicated or
+ * erroring.
+ *
+ * @param chatIds - Chat MIDs to exclude from future capture.
+ * @returns Number of chatIds now covered by this call (rows inserted or
+ *   already present among the input).
+ */
+export function addExcludedChatIds(chatIds) {
+    if (chatIds.length === 0) {
+        return 0;
+    }
+    ensureExcludedTable();
+    const handle = getDb();
+    const stmt = handle.prepare('INSERT OR IGNORE INTO excluded_chats (chatId) VALUES (?);');
+    const insertAll = handle.transaction((ids) => {
+        for (const id of ids) {
+            stmt.run(id);
+        }
+    });
+    insertAll(chatIds);
+    return chatIds.length;
+}
+/**
+ * Remove chatIds from the exclusion denylist, re-allowing future capture.
+ * Does NOT re-fetch or re-index anything that was previously purged — the
+ * next `collect_messages`/`search_messages` auto-collect will pick the
+ * chat back up.
+ *
+ * @param chatIds - Chat MIDs to remove from the denylist.
+ * @returns Number of rows actually removed.
+ */
+export function removeExcludedChatIds(chatIds) {
+    if (chatIds.length === 0) {
+        return 0;
+    }
+    ensureExcludedTable();
+    const handle = getDb();
+    const placeholders = buildPlaceholders(chatIds);
+    const result = handle
+        .prepare(`DELETE FROM excluded_chats WHERE chatId IN ${placeholders};`)
+        .run(...chatIds);
+    return result.changes;
+}
+/**
+ * Purge already-indexed data for the given chats: their embeddings, then
+ * their messages, in one transaction. This is what makes exclusion an
+ * actual privacy action rather than just a future-capture filter — a chat
+ * that gets excluded loses what was already learned about it, not just
+ * what would have been learned next. The `messages_fts` external-content
+ * index stays in sync automatically via the AFTER DELETE trigger on
+ * `messages` (see ../search/store.ts), so it is never touched directly
+ * here.
+ *
+ * @param chatIds - Chat MIDs whose indexed messages + embeddings should be deleted.
+ * @returns Number of `messages` rows deleted.
+ */
+export function deleteMessagesForChats(chatIds) {
+    if (chatIds.length === 0) {
+        return 0;
+    }
+    const handle = getDb();
+    const placeholders = buildPlaceholders(chatIds);
+    const purge = handle.transaction((ids) => {
+        // Count the target rows FIRST: the DELETE's own `.changes` on `messages`
+        // is inflated by the AFTER DELETE trigger that maintains messages_fts
+        // (one fts write per deleted row), so it cannot serve as the purged
+        // count. An explicit COUNT is trigger-independent and honest.
+        const counted = handle
+            .prepare(`SELECT COUNT(*) as c FROM messages WHERE chatId IN ${placeholders};`)
+            .get(...ids);
+        handle.exec(`DELETE FROM embeddings WHERE messageId IN (SELECT messageId FROM messages WHERE chatId IN ${placeholders});`, ids);
+        handle.exec(`DELETE FROM messages WHERE chatId IN ${placeholders};`, ids);
+        return counted?.c ?? 0;
+    });
+    return purge(chatIds);
+}

package/dist/search/sqlite.js

@@ -0,0 +1,141 @@
+/**
+ * Runtime-agnostic SQLite wrapper — uses bun:sqlite in bun, node:sqlite in node.
+ *
+ * The APIs differ:
+ *   - bun: Database  → .run(sql, params?)  .query(sql).get(params?)  .query(sql).all(params?)  .transaction(fn)
+ *   - node: DatabaseSync → .exec(sql)  .prepare(sql).get(params?)  .prepare(sql).all(params?)  (no .transaction)
+ *
+ * This module exports a unified `Database` class that normalizes both to the
+ * same surface, so the rest of the codebase never cares which runtime it's on.
+ */
+import { createRequire } from 'node:module';
+const isBun = typeof process.versions.bun !== 'undefined';
+// The sqlite binding has to be picked at runtime, not import time: `bun:sqlite`
+// does not exist under node and vice versa, so a static import would fail on
+// whichever runtime is not running. That means a require — but this package is
+// `"type": "module"`, and a bare `require` in ESM only works because bun allows
+// it as an extension. Under node it is a ReferenceError, which is why every
+// index-backed tool (search, scope, capture, policy) died with
+// "require is not defined" once the server ran on node rather than bun.
+// createRequire gives ESM a real require that both runtimes honor.
+const runtimeRequire = createRequire(import.meta.url);
+function wrapBunDb(raw) {
+    return {
+        exec(sql) {
+            raw.run(sql);
+        },
+        prepare(sql) {
+            const q = raw.query(sql);
+            return {
+                run(...params) {
+                    return q.get(...params);
+                },
+                get(...params) {
+                    return q.get(...params);
+                },
+                all(...params) {
+                    return q.all(...params);
+                },
+            };
+        },
+        transaction: raw.transaction.bind(raw),
+        close() {
+            raw.close();
+        },
+    };
+}
+function wrapNodeDb(raw) {
+    return {
+        exec(sql, params) {
+            if (params && params.length > 0) {
+                const stmt = raw.prepare(sql);
+                stmt.run(...params);
+            }
+            else {
+                raw.exec(sql);
+            }
+        },
+        prepare(sql) {
+            const stmt = raw.prepare(sql);
+            return {
+                run(...params) {
+                    return stmt.run(...params);
+                },
+                get(...params) {
+                    return stmt.get(...params);
+                },
+                all(...params) {
+                    return stmt.all(...params);
+                },
+            };
+        },
+        transaction(fn) {
+            const wrapped = (...args) => {
+                raw.exec('BEGIN');
+                try {
+                    const result = fn(...args);
+                    raw.exec('COMMIT');
+                    return result;
+                }
+                catch (e) {
+                    raw.exec('ROLLBACK');
+                    throw e;
+                }
+            };
+            return wrapped;
+        },
+        close() {
+            raw.close();
+        },
+    };
+}
+/**
+ * Node versions carrying an unflagged `node:sqlite`.
+ *
+ * It was unflagged in 22.13.0 and 23.4.0 (nodejs/node#55890), so the 23 line
+ * splits: 23.0–23.3 are NEWER than 22.13 yet still lack it, which a plain
+ * `>=22.13.0` floor would wrongly admit. Keep this in step with
+ * package.json's `engines.node`.
+ */
+const NODE_SQLITE_REQUIREMENT = '22.13+ (or 23.4+ on the 23.x line)';
+/** Thrown when the running runtime has no SQLite module at all. */
+export class SqliteUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SqliteUnavailableError';
+    }
+}
+/**
+ * Open a SQLite database at the given path. Creates the file if it doesn't exist.
+ *
+ * @param path - Database file path.
+ * @returns Runtime-agnostic database handle.
+ * @throws SqliteUnavailableError when the runtime predates `node:sqlite`.
+ */
+export function openDatabase(path) {
+    if (isBun) {
+        const mod = runtimeRequire('bun:sqlite');
+        return wrapBunDb(new mod.Database(path));
+    }
+    let mod;
+    try {
+        mod = runtimeRequire('node:sqlite');
+    }
+    catch (error) {
+        // Runtimes without it throw "No such built-in module: node:sqlite", which
+        // tells a user nothing about what to change. `engines` does not help: npm
+        // only warns at install time, and npx ignores it entirely.
+        //
+        // The trap worth naming is that the node running this is often not the one
+        // the user configured. An MCP client launches the server through `npx`,
+        // whose `#!/usr/bin/env node` resolves against the CLIENT's PATH — so the
+        // runtime can be any node on that PATH regardless of which npx was named.
+        // Report the actual execPath rather than assume the user can guess it.
+        throw new SqliteUnavailableError(`This Node cannot open Yomi's message index: ${process.version} has no built-in \`node:sqlite\` (needs ${NODE_SQLITE_REQUIREMENT}). ` +
+            `Live tools still work; search, scope and capture do not. ` +
+            `The runtime is ${process.execPath} — an MCP client resolves \`node\` from its own PATH, so this may not be the node you expect. ` +
+            `Point the client at a supported node and restart it. ` +
+            `Original error: ${error?.message ?? String(error)}`);
+    }
+    return wrapNodeDb(new mod.DatabaseSync(path));
+}