sensemaking 0.17.0 → 0.18.0

package/dist/esm/store/sql-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sql-functions.ts"],"sourcesContent":["import posix from 'node:path/posix';\n\n// has(field, value) / basename(path, suffix): the two sense-supplied SQL functions with no\n// engine-specific pieces, shared by sqlite/sql-functions.ts and duckdb/sql-functions.ts so each\n// store registers the identical implementation instead of a hand-copied one (DRY).\n\n// JSON-array field -> membership, string field -> substring, NULL -> false.\nexport function hasImpl(field: unknown, value: unknown): number {\n  if (field === null || field === undefined) return 0;\n  const needle = String(value);\n  if (typeof field === 'string') {\n    if (field.startsWith('[')) {\n      try {\n        const parsed = JSON.parse(field);\n        if (Array.isArray(parsed)) return parsed.some((item) => String(item) === needle) ? 1 : 0;\n      } catch {}\n    }\n    return field.includes(needle) ? 1 : 0;\n  }\n  return String(field).includes(needle) ? 1 : 0;\n}\n\n// Unix basename(path, suffix?): the filename, minus suffix when it ends with one. Neither\n// engine has a filename function of its own, and LIKE tricks that fake one also match folder\n// names.\nexport function basenameImpl(path: unknown, suffix?: unknown): string | null {\n  if (path === null || path === undefined) return null;\n  const name = posix.basename(String(path));\n  const tail = suffix === null || suffix === undefined ? '' : String(suffix);\n  // POSIX: a suffix identical to the whole name is not removed (node's own basename strips it).\n  return tail !== '' && tail !== name && name.endsWith(tail) ? name.slice(0, -tail.length) : name;\n}\n"],"names":["posix","hasImpl","field","value","undefined","needle","String","startsWith","parsed","JSON","parse","Array","isArray","some","item","includes","basenameImpl","path","suffix","name","basename","tail","endsWith","slice","length"],"mappings":"AAAA,OAAOA,WAAW,kBAAkB;AAEpC,2FAA2F;AAC3F,gGAAgG;AAChG,mFAAmF;AAEnF,4EAA4E;AAC5E,OAAO,SAASC,QAAQC,KAAc,EAAEC,KAAc;IACpD,IAAID,UAAU,QAAQA,UAAUE,WAAW,OAAO;IAClD,MAAMC,SAASC,OAAOH;IACtB,IAAI,OAAOD,UAAU,UAAU;QAC7B,IAAIA,MAAMK,UAAU,CAAC,MAAM;YACzB,IAAI;gBACF,MAAMC,SAASC,KAAKC,KAAK,CAACR;gBAC1B,IAAIS,MAAMC,OAAO,CAACJ,SAAS,OAAOA,OAAOK,IAAI,CAAC,CAACC,OAASR,OAAOQ,UAAUT,UAAU,IAAI;YACzF,EAAE,OAAM,CAAC;QACX;QACA,OAAOH,MAAMa,QAAQ,CAACV,UAAU,IAAI;IACtC;IACA,OAAOC,OAAOJ,OAAOa,QAAQ,CAACV,UAAU,IAAI;AAC9C;AAEA,0FAA0F;AAC1F,6FAA6F;AAC7F,SAAS;AACT,OAAO,SAASW,aAAaC,IAAa,EAAEC,MAAgB;IAC1D,IAAID,SAAS,QAAQA,SAASb,WAAW,OAAO;IAChD,MAAMe,OAAOnB,MAAMoB,QAAQ,CAACd,OAAOW;IACnC,MAAMI,OAAOH,WAAW,QAAQA,WAAWd,YAAY,KAAKE,OAAOY;IACnE,8FAA8F;IAC9F,OAAOG,SAAS,MAAMA,SAASF,QAAQA,KAAKG,QAAQ,CAACD,QAAQF,KAAKI,KAAK,CAAC,GAAG,CAACF,KAAKG,MAAM,IAAIL;AAC7F"}

package/dist/esm/store/sqlite/connection.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { Connection } from '../types.js';
+export declare function createConnection(db: DatabaseSync): Connection;

package/dist/esm/store/sqlite/connection.js

@@ -0,0 +1,50 @@
+import { withTransaction } from '../transaction.js';
+// Wraps node:sqlite's synchronous DatabaseSync in the async Connection/Statement shape every
+// store presents. Every method below does its real work synchronously and returns an already-
+// resolved promise, so reconcile's loop, the feature hooks, and runBatch never actually cross
+// an async boundary internally -- no regression against the pre-Store synchronous code.
+let SqliteStatement = class SqliteStatement {
+    async run(...params) {
+        return this.stmt.run(...params);
+    }
+    async get(...params) {
+        return this.stmt.get(...params);
+    }
+    async all(...params) {
+        return this.stmt.all(...params);
+    }
+    async *iterate(...params) {
+        yield* this.stmt.iterate(...params);
+    }
+    columns() {
+        return this.stmt.columns();
+    }
+    setReadBigInts(enabled) {
+        this.stmt.setReadBigInts(enabled);
+    }
+    constructor(stmt){
+        this.stmt = stmt;
+    }
+};
+export function createConnection(db) {
+    const conn = {
+        async exec (sql) {
+            db.exec(sql);
+        },
+        async prepare (sql) {
+            return new SqliteStatement(db.prepare(sql));
+        },
+        // Prepares once and loops synchronously: today's code, unchanged, wrapped as one async call
+        // so features share one Connection contract with DuckDB. Joins the caller's transaction when
+        // there is one (reconcile); otherwise opens its own, so a standalone batch (a vector write
+        // outside any Store.transaction()) stays atomic and commits once, not once per row.
+        async runBatch (sql, paramRows) {
+            if (paramRows.length === 0) return;
+            await withTransaction(conn, async ()=>{
+                const stmt = db.prepare(sql);
+                for (const row of paramRows)stmt.run(...row);
+            });
+        }
+    };
+    return conn;
+}

package/dist/esm/store/sqlite/connection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/connection.ts"],"sourcesContent":["import type { DatabaseSync, StatementSync } from 'node:sqlite';\nimport { withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\n\n// Wraps node:sqlite's synchronous DatabaseSync in the async Connection/Statement shape every\n// store presents. Every method below does its real work synchronously and returns an already-\n// resolved promise, so reconcile's loop, the feature hooks, and runBatch never actually cross\n// an async boundary internally -- no regression against the pre-Store synchronous code.\nclass SqliteStatement implements Statement {\n  private stmt: StatementSync;\n\n  constructor(stmt: StatementSync) {\n    this.stmt = stmt;\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.stmt.run(...(params as Parameters<StatementSync['run']>));\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.stmt.get(...(params as Parameters<StatementSync['get']>));\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.stmt.all(...(params as Parameters<StatementSync['all']>));\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    yield* this.stmt.iterate(...(params as Parameters<StatementSync['iterate']>));\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.stmt.columns();\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.stmt.setReadBigInts(enabled);\n  }\n}\n\nexport function createConnection(db: DatabaseSync): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return new SqliteStatement(db.prepare(sql));\n    },\n    // Prepares once and loops synchronously: today's code, unchanged, wrapped as one async call\n    // so features share one Connection contract with DuckDB. Joins the caller's transaction when\n    // there is one (reconcile); otherwise opens its own, so a standalone batch (a vector write\n    // outside any Store.transaction()) stays atomic and commits once, not once per row.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(conn, async () => {\n        const stmt = db.prepare(sql);\n        for (const row of paramRows) stmt.run(...(row as Parameters<StatementSync['run']>));\n      });\n    },\n  };\n  return conn;\n}\n"],"names":["withTransaction","SqliteStatement","run","params","stmt","get","all","iterate","columns","setReadBigInts","enabled","createConnection","db","conn","exec","sql","prepare","runBatch","paramRows","length","row"],"mappings":"AACA,SAASA,eAAe,QAAQ,oBAAoB;AAGpD,6FAA6F;AAC7F,8FAA8F;AAC9F,8FAA8F;AAC9F,wFAAwF;AACxF,IAAA,AAAMC,kBAAN,MAAMA;IAOJ,MAAMC,IAAI,GAAGC,MAAiB,EAAsB;QAClD,OAAO,IAAI,CAACC,IAAI,CAACF,GAAG,IAAKC;IAC3B;IAEA,MAAME,IAAI,GAAGF,MAAiB,EAAoB;QAChD,OAAO,IAAI,CAACC,IAAI,CAACC,GAAG,IAAKF;IAC3B;IAEA,MAAMG,IAAI,GAAGH,MAAiB,EAAsB;QAClD,OAAO,IAAI,CAACC,IAAI,CAACE,GAAG,IAAKH;IAC3B;IAEA,OAAOI,QAAQ,GAAGJ,MAAiB,EAA0B;QAC3D,OAAO,IAAI,CAACC,IAAI,CAACG,OAAO,IAAKJ;IAC/B;IAEAK,UAAmC;QACjC,OAAO,IAAI,CAACJ,IAAI,CAACI,OAAO;IAC1B;IAEAC,eAAeC,OAAgB,EAAQ;QACrC,IAAI,CAACN,IAAI,CAACK,cAAc,CAACC;IAC3B;IA1BA,YAAYN,IAAmB,CAAE;QAC/B,IAAI,CAACA,IAAI,GAAGA;IACd;AAyBF;AAEA,OAAO,SAASO,iBAAiBC,EAAgB;IAC/C,MAAMC,OAAmB;QACvB,MAAMC,MAAKC,GAAW;YACpBH,GAAGE,IAAI,CAACC;QACV;QACA,MAAMC,SAAQD,GAAW;YACvB,OAAO,IAAId,gBAAgBW,GAAGI,OAAO,CAACD;QACxC;QACA,4FAA4F;QAC5F,6FAA6F;QAC7F,2FAA2F;QAC3F,oFAAoF;QACpF,MAAME,UAASF,GAAW,EAAEG,SAAsB;YAChD,IAAIA,UAAUC,MAAM,KAAK,GAAG;YAC5B,MAAMnB,gBAAgBa,MAAM;gBAC1B,MAAMT,OAAOQ,GAAGI,OAAO,CAACD;gBACxB,KAAK,MAAMK,OAAOF,UAAWd,KAAKF,GAAG,IAAKkB;YAC5C;QACF;IACF;IACA,OAAOP;AACT"}

package/dist/esm/store/sqlite/lexical.d.ts

@@ -0,0 +1,2 @@
+import type { Connection, LexicalHit, LexicalQueryOptions } from '../types.js';
+export declare function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, segmenting: boolean): Promise<LexicalHit[]>;

package/dist/esm/store/sqlite/lexical.js

@@ -0,0 +1,21 @@
+import { segmentMatch } from '../../text/segment.js';
+// snippet() re-tokenizes each candidate doc, superlinearly: ~10s for one 1MB doc
+// (benchmark/reports/2026-08-23-hub-release-battery.md). Past this bound, hit stays NULL for
+// the caller's JS excerpt fallback.
+const SNIPPET_BOUND = 16384;
+const WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';
+// Ranked BM25 word-match query with excerpt, scoped by the caller-built SQL fragments.
+// `segmenting` mirrors the predicate that decided whether the `_seg` sidecars were populated
+// (contentTokenize(cfg) === undefined, see sqlite/store.ts): an unspaced-script run in `terms`
+// becomes a quoted grapheme phrase against those sidecars only when they exist.
+export async function queryLexical(conn, terms, opts, segmenting) {
+    const { whereJoin, whereCond, scopeCond, limit } = opts;
+    const query = segmenting ? segmentMatch(terms) : terms;
+    // A run of pure unspaced-script punctuation segments to nothing searchable (segmentField
+    // drops empty groups the same way): an empty MATCH string is an FTS5 syntax error, not zero
+    // rows, so this returns the zero rows directly rather than issuing it.
+    if (query.trim() === '') return [];
+    const sql = `SELECT content.path AS path, CASE WHEN length(content.text) <= ${SNIPPET_BOUND} THEN snippet(content, 2, '«', '»', '…', 10) ELSE NULL END AS hit FROM content ${whereJoin} WHERE content MATCH ? ${whereCond} ${scopeCond} ORDER BY ${WEIGHTED_BM25} LIMIT ${limit}`;
+    const stmt = await conn.prepare(sql);
+    return await stmt.all(query);
+}

package/dist/esm/store/sqlite/lexical.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/lexical.ts"],"sourcesContent":["import { segmentMatch } from '../../text/segment.ts';\nimport type { Connection, LexicalHit, LexicalQueryOptions } from '../types.ts';\n\n// snippet() re-tokenizes each candidate doc, superlinearly: ~10s for one 1MB doc\n// (benchmark/reports/2026-08-23-hub-release-battery.md). Past this bound, hit stays NULL for\n// the caller's JS excerpt fallback.\nconst SNIPPET_BOUND = 16_384;\nconst WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';\n\n// Ranked BM25 word-match query with excerpt, scoped by the caller-built SQL fragments.\n// `segmenting` mirrors the predicate that decided whether the `_seg` sidecars were populated\n// (contentTokenize(cfg) === undefined, see sqlite/store.ts): an unspaced-script run in `terms`\n// becomes a quoted grapheme phrase against those sidecars only when they exist.\nexport async function queryLexical(conn: Connection, terms: string, opts: LexicalQueryOptions, segmenting: boolean): Promise<LexicalHit[]> {\n  const { whereJoin, whereCond, scopeCond, limit } = opts;\n  const query = segmenting ? segmentMatch(terms) : terms;\n  // A run of pure unspaced-script punctuation segments to nothing searchable (segmentField\n  // drops empty groups the same way): an empty MATCH string is an FTS5 syntax error, not zero\n  // rows, so this returns the zero rows directly rather than issuing it.\n  if (query.trim() === '') return [];\n  const sql = `SELECT content.path AS path, CASE WHEN length(content.text) <= ${SNIPPET_BOUND} THEN snippet(content, 2, '«', '»', '…', 10) ELSE NULL END AS hit FROM content ${whereJoin} WHERE content MATCH ? ${whereCond} ${scopeCond} ORDER BY ${WEIGHTED_BM25} LIMIT ${limit}`;\n  const stmt = await conn.prepare(sql);\n  return (await stmt.all(query)) as unknown as LexicalHit[];\n}\n"],"names":["segmentMatch","SNIPPET_BOUND","WEIGHTED_BM25","queryLexical","conn","terms","opts","segmenting","whereJoin","whereCond","scopeCond","limit","query","trim","sql","stmt","prepare","all"],"mappings":"AAAA,SAASA,YAAY,QAAQ,wBAAwB;AAGrD,iFAAiF;AACjF,6FAA6F;AAC7F,oCAAoC;AACpC,MAAMC,gBAAgB;AACtB,MAAMC,gBAAgB;AAEtB,uFAAuF;AACvF,6FAA6F;AAC7F,+FAA+F;AAC/F,gFAAgF;AAChF,OAAO,eAAeC,aAAaC,IAAgB,EAAEC,KAAa,EAAEC,IAAyB,EAAEC,UAAmB;IAChH,MAAM,EAAEC,SAAS,EAAEC,SAAS,EAAEC,SAAS,EAAEC,KAAK,EAAE,GAAGL;IACnD,MAAMM,QAAQL,aAAaP,aAAaK,SAASA;IACjD,yFAAyF;IACzF,4FAA4F;IAC5F,uEAAuE;IACvE,IAAIO,MAAMC,IAAI,OAAO,IAAI,OAAO,EAAE;IAClC,MAAMC,MAAM,CAAC,+DAA+D,EAAEb,cAAc,+EAA+E,EAAEO,UAAU,uBAAuB,EAAEC,UAAU,CAAC,EAAEC,UAAU,UAAU,EAAER,cAAc,OAAO,EAAES,OAAO;IACjR,MAAMI,OAAO,MAAMX,KAAKY,OAAO,CAACF;IAChC,OAAQ,MAAMC,KAAKE,GAAG,CAACL;AACzB"}

package/dist/esm/{db → store/sqlite}/open.d.ts

@@ -1,14 +1,14 @@
-import { DatabaseSync } from 'node:sqlite';
-import type { ResolvedConfig } from '../config/index.js';
+import type { ResolvedConfig } from '../../config/index.js';
+import type { Store } from '../types.js';
 export declare const DB_FILENAME = "cache.db";
 export declare const SCHEMA_VERSION = "18";
 export interface OpenResult {
-    db: DatabaseSync;
+    store: Store;
     cfg: ResolvedConfig;
     dbPath: string;
     parsed: number;
     warnings: string[];
 }
-export declare function docCount(db: DatabaseSync): number;
-export declare function open(cfg: ResolvedConfig): OpenResult;
+export declare function openSqlite(cfg: ResolvedConfig): Promise<OpenResult>;
+export declare function docCount(store: Store): Promise<number>;
 export declare function clearCache(cfg: ResolvedConfig): void;

package/dist/esm/store/sqlite/open.js

@@ -0,0 +1,193 @@
+// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with
+// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { contentTokenize, featureSignature, STATE_DIR } from '../../config/index.js';
+import { SenseError } from '../../errors.js';
+import { activeFeatures, FEATURES } from '../../features/index.js';
+import { getMeta, setMeta } from '../shared.js';
+import { createConnection } from './connection.js';
+import { changedSignatureKeys, embedIdentityAdopted, rebuildContentTable, reconcile, signatureDiff } from './reconcile.js';
+import { registerFunctions } from './sql-functions.js';
+import { createStore } from './store.js';
+export const DB_FILENAME = 'cache.db';
+// Cache shape version, independent of the config's own `version`. Bumping it rebuilds
+// existing trees on first query.
+export const SCHEMA_VERSION = '18';
+// Stemming is English-only, but the segmentation underneath it is what decides coverage:
+// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)
+// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how
+// such a tree picks trigram instead.
+const DEFAULT_TOKENIZE = 'porter unicode61';
+// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a
+// configured value has to be concatenated. Probing a throwaway table is what makes that safe
+// and is also the whole validation: anything the linked SQLite accepts passes, anything else
+// fails here with SQLite's own message rather than against the real table. It means no table
+// of which version added which tokenizer has to be maintained.
+function resolveTokenize(db, cfg) {
+    const configured = contentTokenize(cfg);
+    if (configured === undefined) return DEFAULT_TOKENIZE;
+    const literal = configured.replace(/'/g, "''");
+    try {
+        db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');
+        db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);
+        db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');
+    } catch (err) {
+        throw new SenseError('CONFIG_INVALID', `content.tokenize "${configured}" is not a tokenizer this SQLite accepts (${err.message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);
+    }
+    return literal;
+}
+// The tokenizer the content table was actually built with, from its own DDL -- the one
+// record that cannot desynchronize from the table. NULL when the table does not exist yet.
+function storedTokenize(db) {
+    const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get();
+    if (!row) return null;
+    const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);
+    return m ? m[1] : null;
+}
+// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`
+// can't dump file text into context. Features add their own tables after the core ones.
+async function ensureSchema(conn, cfg, tokenize) {
+    await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter ("path" TEXT PRIMARY KEY, "_mtime" REAL, "_ctime" REAL, "_size" INTEGER, "_parse_error" TEXT)`);
+    // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL
+    // against the resolved tokenizer before this runs, so a stale table is already gone by now.
+    // The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and
+    // snippet(content, 2, ...) are documented against the first three columns and keep working
+    // (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced
+    // runs for text that needs it, and an empty string for text that does not.
+    await conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);
+    // Coverage, not ownership: a path can appear under several presets. path leads the PK so the
+    // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.
+    await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files ("path" TEXT, preset TEXT, PRIMARY KEY ("path", preset))`);
+    await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');
+    for (const feature of activeFeatures(cfg))await feature.schema(conn);
+    if (await getMeta(conn, 'schema_version') === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);
+    if (await getMeta(conn, 'features') === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));
+}
+async function connect(cfg) {
+    const stateDir = join(cfg.baseDir, STATE_DIR);
+    mkdirSync(stateDir, {
+        recursive: true
+    });
+    const dbPath = join(stateDir, DB_FILENAME);
+    const db = new DatabaseSync(dbPath);
+    // A throw below (tokenizer probe, schema, reconcile's COLUMN_LIMIT) must release this handle,
+    // or on Windows the leaked WAL db is undeletable and scratch cleanup fails with EPERM/EBUSY.
+    // closed marks the rebuild branches that close-and-recurse, so the catch never double-closes.
+    let closed = false;
+    try {
+        var _ref;
+        db.exec('PRAGMA journal_mode = WAL');
+        // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query
+        // that outwaits it still fails loudly.
+        db.exec('PRAGMA busy_timeout = 30000');
+        registerFunctions(db, contentTokenize(cfg) === undefined);
+        const conn = createConnection(db);
+        db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');
+        // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd
+        // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.
+        const tokenize = resolveTokenize(db, cfg);
+        // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an
+        // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).
+        const version = await getMeta(conn, 'schema_version');
+        const features = await getMeta(conn, 'features');
+        const wantFeatures = featureSignature(cfg, FEATURES);
+        let tokenizeOnlyRebuild = false;
+        if (version !== null && version !== SCHEMA_VERSION || features !== null && features !== wantFeatures) {
+            // Indexing derives from presets, so a config edit rebuilding the cache must say so and
+            // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.
+            if (version !== null && version !== SCHEMA_VERSION) {
+                console.error('sense: cache format changed (new sensemaking version); rebuilding the index');
+                closed = true;
+                db.close();
+                clearCache(cfg);
+                return connect(cfg);
+            }
+            const changedKeys = changedSignatureKeys(features !== null && features !== void 0 ? features : '', wantFeatures);
+            // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived
+            // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset
+            // edit, an embed model change -- still takes the full clear/reopen below.
+            if (changedKeys.size === 1 && changedKeys.has('tokenize')) {
+                console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');
+                db.exec('DROP TABLE content');
+                tokenizeOnlyRebuild = true;
+            } else if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(features !== null && features !== void 0 ? features : '', wantFeatures)) {
+                // First sight of a resolved weight identity: the model itself hasn't changed, so
+                // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.
+                console.error("sense: recorded the embedding model's resolved identity; vectors are unaffected");
+                await setMeta(conn, 'features', wantFeatures);
+            } else {
+                const changed = signatureDiff(features !== null && features !== void 0 ? features : '', wantFeatures);
+                console.error(`sense: config change (${changed}) rebuilds the index`);
+                closed = true;
+                db.close();
+                clearCache(cfg);
+                return connect(cfg);
+            }
+        }
+        // Meta can lie after a crash between table creation and the signature write; the table's
+        // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild
+        // just dropped content above, so storedTokenize sees no table and this guard is skipped
+        // naturally rather than needing its own case.
+        const stored = storedTokenize(db);
+        if (stored !== null && stored !== tokenize) {
+            console.error('sense: cache was built with a different content tokenizer; rebuilding the index');
+            closed = true;
+            db.close();
+            clearCache(cfg);
+            return connect(cfg);
+        }
+        await ensureSchema(conn, cfg, tokenize);
+        let rebuildWarnings = [];
+        if (tokenizeOnlyRebuild) {
+            rebuildWarnings = await rebuildContentTable(conn, cfg, cfg.baseDir);
+            await setMeta(conn, 'features', wantFeatures);
+        }
+        // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.
+        // Installed before reconcile() -- that call is the one that races a watcher's transaction.
+        const recordedMaxMs = Number((_ref = await getMeta(conn, 'reconcile_max_ms')) !== null && _ref !== void 0 ? _ref : '0');
+        db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600000)}`);
+        const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);
+        return {
+            db,
+            conn,
+            cfg,
+            dbPath,
+            parsed,
+            warnings: [
+                ...rebuildWarnings,
+                ...warnings
+            ]
+        };
+    } catch (err) {
+        if (!closed) db.close();
+        throw err;
+    }
+}
+// The sqlite store's open: connects synchronously (see connect() above), then wraps the
+// resulting connection in the async Store interface.
+export async function openSqlite(cfg) {
+    const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);
+    return {
+        store: createStore(db, conn, resolvedCfg, resolvedCfg.baseDir),
+        cfg: resolvedCfg,
+        dbPath,
+        parsed,
+        warnings
+    };
+}
+export async function docCount(store) {
+    const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');
+    return (await stmt.get()).n;
+}
+// Deletes the cache directory, and only that. The rebuild is not this function's job: the next
+// open() reconciles, which is what running any command already does, so a verb that bundled the
+// two described the half that was not its own. Manual reset for a doubted cache; the schema and
+// config-signature mismatches below reset themselves.
+export function clearCache(cfg) {
+    rmSync(join(cfg.baseDir, STATE_DIR), {
+        recursive: true,
+        force: true
+    });
+}

package/dist/esm/store/sqlite/open.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/open.ts"],"sourcesContent":["// The Node floor (>=22.20) is explained here and nowhere else: 22.20 is the first release with\n// both FTS5 and row-returning INSERT ... RETURNING. Raise it only for a load-bearing capability.\nimport { mkdirSync, rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from '../../config/index.ts';\nimport { contentTokenize, featureSignature, STATE_DIR } from '../../config/index.ts';\nimport { SenseError } from '../../errors.ts';\nimport { activeFeatures, FEATURES } from '../../features/index.ts';\nimport { getMeta, setMeta } from '../shared.ts';\nimport type { Connection, Store } from '../types.ts';\nimport { createConnection } from './connection.ts';\nimport { changedSignatureKeys, embedIdentityAdopted, rebuildContentTable, reconcile, signatureDiff } from './reconcile.ts';\nimport { registerFunctions } from './sql-functions.ts';\nimport { createStore } from './store.ts';\n\nexport const DB_FILENAME = 'cache.db';\n// Cache shape version, independent of the config's own `version`. Bumping it rebuilds\n// existing trees on first query.\nexport const SCHEMA_VERSION = '18';\n\ninterface ConnectResult {\n  db: DatabaseSync;\n  conn: Connection;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\nexport interface OpenResult {\n  store: Store;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  parsed: number;\n  warnings: string[];\n}\n\n// Stemming is English-only, but the segmentation underneath it is what decides coverage:\n// unicode61 splits on spaces, so a language written without them (Chinese, Japanese, Thai)\n// indexes a whole run as one token and word search finds nothing. `content.tokenize` is how\n// such a tree picks trigram instead.\nconst DEFAULT_TOKENIZE = 'porter unicode61';\n\n// FTS5 takes its tokenizer as a string literal inside DDL, where nothing can bind, so a\n// configured value has to be concatenated. Probing a throwaway table is what makes that safe\n// and is also the whole validation: anything the linked SQLite accepts passes, anything else\n// fails here with SQLite's own message rather than against the real table. It means no table\n// of which version added which tokenizer has to be maintained.\nfunction resolveTokenize(db: DatabaseSync, cfg: Config): string {\n  const configured = contentTokenize(cfg);\n  if (configured === undefined) return DEFAULT_TOKENIZE;\n  const literal = configured.replace(/'/g, \"''\");\n  try {\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n    db.exec(`CREATE VIRTUAL TABLE temp.sense_tokenize_probe USING fts5(x, tokenize = '${literal}')`);\n    db.exec('DROP TABLE IF EXISTS temp.sense_tokenize_probe');\n  } catch (err) {\n    throw new SenseError('CONFIG_INVALID', `content.tokenize \"${configured}\" is not a tokenizer this SQLite accepts (${(err as Error).message}); the built-in choices are unicode61, ascii, porter, and trigram, each with their own options`);\n  }\n  return literal;\n}\n\n// The tokenizer the content table was actually built with, from its own DDL -- the one\n// record that cannot desynchronize from the table. NULL when the table does not exist yet.\nfunction storedTokenize(db: DatabaseSync): string | null {\n  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE name = 'content'`).get() as { sql: string } | undefined;\n  if (!row) return null;\n  const m = row.sql.match(/tokenize = '((?:[^']|'')*)'/);\n  return m ? m[1] : null;\n}\n\n// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`\n// can't dump file text into context. Features add their own tables after the core ones.\nasync function ensureSchema(conn: Connection, cfg: Config, tokenize: string): Promise<void> {\n  await conn.exec(`CREATE TABLE IF NOT EXISTS frontmatter (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_ctime\" REAL, \"_size\" INTEGER, \"_parse_error\" TEXT)`);\n  // IF NOT EXISTS is safe against a tokenizer change: open() compares the table's own DDL\n  // against the resolved tokenizer before this runs, so a stale table is already gone by now.\n  // The three `_seg` sidecars are appended after path, never inserted: bm25(content, ...) and\n  // snippet(content, 2, ...) are documented against the first three columns and keep working\n  // (FTS5 defaults the weights it was not given). Each carries its field's exploded unspaced\n  // runs for text that needs it, and an empty string for text that does not.\n  await conn.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, title_seg, summary_seg, text_seg, tokenize = '${tokenize}')`);\n  // Coverage, not ownership: a path can appear under several presets. path leads the PK so the\n  // per-doc delete is an index hit -- keyed the other way, cold builds went quadratic.\n  await conn.exec(`CREATE TABLE IF NOT EXISTS preset_files (\"path\" TEXT, preset TEXT, PRIMARY KEY (\"path\", preset))`);\n  await conn.exec('CREATE INDEX IF NOT EXISTS preset_files_preset ON preset_files(preset)');\n  for (const feature of activeFeatures(cfg)) await feature.schema(conn);\n  if ((await getMeta(conn, 'schema_version')) === null) await setMeta(conn, 'schema_version', SCHEMA_VERSION);\n  if ((await getMeta(conn, 'features')) === null) await setMeta(conn, 'features', featureSignature(cfg, FEATURES));\n}\n\nasync function connect(cfg: ResolvedConfig): Promise<ConnectResult> {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  // A throw below (tokenizer probe, schema, reconcile's COLUMN_LIMIT) must release this handle,\n  // or on Windows the leaked WAL db is undeletable and scratch cleanup fails with EPERM/EBUSY.\n  // closed marks the rebuild branches that close-and-recurse, so the catch never double-closes.\n  let closed = false;\n  try {\n    db.exec('PRAGMA journal_mode = WAL');\n    // Covers a concurrent watcher's bulk reconcile (~5s for 500 files at 26k notes). A query\n    // that outwaits it still fails loudly.\n    db.exec('PRAGMA busy_timeout = 30000');\n    registerFunctions(db, contentTokenize(cfg) === undefined);\n    const conn = createConnection(db);\n\n    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n\n    // Before the rebuild branch below, never after: that branch deletes the cache, so a typo'd\n    // tokenizer validated later would cost a full re-index (and re-embed) to reach its own error.\n    const tokenize = resolveTokenize(db, cfg);\n\n    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an\n    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).\n    const version = await getMeta(conn, 'schema_version');\n    const features = await getMeta(conn, 'features');\n    const wantFeatures = featureSignature(cfg, FEATURES);\n    let tokenizeOnlyRebuild = false;\n    if ((version !== null && version !== SCHEMA_VERSION) || (features !== null && features !== wantFeatures)) {\n      // Indexing derives from presets, so a config edit rebuilding the cache must say so and\n      // name what changed -- silent rebuilds make derived indexing look like a hang or a bug.\n      if (version !== null && version !== SCHEMA_VERSION) {\n        console.error('sense: cache format changed (new sensemaking version); rebuilding the index');\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n      const changedKeys = changedSignatureKeys(features ?? '', wantFeatures);\n      // Only the tokenizer moved: frontmatter, links, sections, and embeddings are file-derived\n      // and tokenizer-independent, so they don't need re-deriving. Everything else -- a preset\n      // edit, an embed model change -- still takes the full clear/reopen below.\n      if (changedKeys.size === 1 && changedKeys.has('tokenize')) {\n        console.error('sense: config change (content tokenizer) rebuilds the text index; vectors, links, and sections are kept');\n        db.exec('DROP TABLE content');\n        tokenizeOnlyRebuild = true;\n      } else if (changedKeys.size === 1 && changedKeys.has('embed') && embedIdentityAdopted(features ?? '', wantFeatures)) {\n        // First sight of a resolved weight identity: the model itself hasn't changed, so\n        // adopt it into meta with no rebuild and no re-embed, mirroring the tokenize precedent.\n        console.error(\"sense: recorded the embedding model's resolved identity; vectors are unaffected\");\n        await setMeta(conn, 'features', wantFeatures);\n      } else {\n        const changed = signatureDiff(features ?? '', wantFeatures);\n        console.error(`sense: config change (${changed}) rebuilds the index`);\n        closed = true;\n        db.close();\n        clearCache(cfg);\n        return connect(cfg);\n      }\n    }\n\n    // Meta can lie after a crash between table creation and the signature write; the table's\n    // own DDL cannot. A mismatch here rebuilds no matter what meta says. A tokenize-only rebuild\n    // just dropped content above, so storedTokenize sees no table and this guard is skipped\n    // naturally rather than needing its own case.\n    const stored = storedTokenize(db);\n    if (stored !== null && stored !== tokenize) {\n      console.error('sense: cache was built with a different content tokenizer; rebuilding the index');\n      closed = true;\n      db.close();\n      clearCache(cfg);\n      return connect(cfg);\n    }\n\n    await ensureSchema(conn, cfg, tokenize);\n\n    let rebuildWarnings: string[] = [];\n    if (tokenizeOnlyRebuild) {\n      rebuildWarnings = await rebuildContentTable(conn, cfg, cfg.baseDir);\n      await setMeta(conn, 'features', wantFeatures);\n    }\n\n    // 3x the largest reconcile this cache has recorded, floored at 30s and capped at 10min.\n    // Installed before reconcile() -- that call is the one that races a watcher's transaction.\n    const recordedMaxMs = Number((await getMeta(conn, 'reconcile_max_ms')) ?? '0');\n    db.exec(`PRAGMA busy_timeout = ${Math.min(Math.max(30000, 3 * recordedMaxMs), 600_000)}`);\n\n    const { parsed, warnings } = await reconcile(conn, cfg, cfg.baseDir);\n\n    return { db, conn, cfg, dbPath, parsed, warnings: [...rebuildWarnings, ...warnings] };\n  } catch (err) {\n    if (!closed) db.close();\n    throw err;\n  }\n}\n\n// The sqlite store's open: connects synchronously (see connect() above), then wraps the\n// resulting connection in the async Store interface.\nexport async function openSqlite(cfg: ResolvedConfig): Promise<OpenResult> {\n  const { db, conn, cfg: resolvedCfg, dbPath, parsed, warnings } = await connect(cfg);\n  return { store: createStore(db, conn, resolvedCfg, resolvedCfg.baseDir), cfg: resolvedCfg, dbPath, parsed, warnings };\n}\n\nexport async function docCount(store: Store): Promise<number> {\n  const stmt = await store.prepare('SELECT COUNT(*) AS n FROM frontmatter');\n  return ((await stmt.get()) as { n: number }).n;\n}\n\n// Deletes the cache directory, and only that. The rebuild is not this function's job: the next\n// open() reconciles, which is what running any command already does, so a verb that bundled the\n// two described the half that was not its own. Manual reset for a doubted cache; the schema and\n// config-signature mismatches below reset themselves.\nexport function clearCache(cfg: ResolvedConfig): void {\n  rmSync(join(cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n}\n"],"names":["mkdirSync","rmSync","join","DatabaseSync","contentTokenize","featureSignature","STATE_DIR","SenseError","activeFeatures","FEATURES","getMeta","setMeta","createConnection","changedSignatureKeys","embedIdentityAdopted","rebuildContentTable","reconcile","signatureDiff","registerFunctions","createStore","DB_FILENAME","SCHEMA_VERSION","DEFAULT_TOKENIZE","resolveTokenize","db","cfg","configured","undefined","literal","replace","exec","err","message","storedTokenize","row","prepare","get","m","sql","match","ensureSchema","conn","tokenize","feature","schema","connect","stateDir","baseDir","recursive","dbPath","closed","version","features","wantFeatures","tokenizeOnlyRebuild","console","error","close","clearCache","changedKeys","size","has","changed","stored","rebuildWarnings","recordedMaxMs","Number","Math","min","max","parsed","warnings","openSqlite","resolvedCfg","store","docCount","stmt","n","force"],"mappings":"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"}

package/dist/esm/store/sqlite/reconcile.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../../config/index.js';
+import type { Connection } from '../types.js';
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string): Promise<{
+    parsed: number;
+    warnings: string[];
+}>;
+export declare function changedSignatureKeys(before: string, after: string): Set<string>;
+export declare function embedIdentityAdopted(before: string, after: string): boolean;
+export declare function signatureDiff(before: string, after: string): string;
+export declare function rebuildContentTable(conn: Connection, cfg: Config, baseDir: string): Promise<string[]>;