sensemaking 0.17.0 → 0.18.0

package/dist/cjs/commands/signals.d.ts

@@ -1,18 +1,12 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../config/index.js';
+import type { LexicalHit, Store } from '../store/types.js';
 export type Candidates = Map<string, {
     score: number;
     via: string;
 }>;
-export declare function wordsCandidates(db: DatabaseSync, candidates: Candidates, query: string, whereJoin: string, whereCond: string, scopeCond: string, fetch: number, weight: number): Array<{
-    path: string;
-    hit: string | null;
-}>;
-export declare function linksCandidates(db: DatabaseSync, candidates: Candidates, matchRows: Array<{
-    path: string;
-    hit: string | null;
-}>, allPaths: string[], allowedPaths: Set<string>, fetch: number, weight: number): void;
-export declare function vectorsCandidates(db: DatabaseSync, cfg: ResolvedConfig, candidates: Candidates, terms: string, fetch: number, allowedPaths: Set<string>, weight: number): Promise<{
+export declare function wordsCandidates(store: Store, candidates: Candidates, query: string, whereJoin: string, whereCond: string, scopeCond: string, fetch: number, weight: number): Promise<LexicalHit[]>;
+export declare function linksCandidates(store: Store, candidates: Candidates, matchRows: LexicalHit[], allPaths: string[], allowedPaths: Set<string>, fetch: number, weight: number): Promise<void>;
+export declare function vectorsCandidates(store: Store, cfg: ResolvedConfig, candidates: Candidates, terms: string, fetch: number, allowedPaths: Set<string>, weight: number): Promise<{
     chunkLines: Map<string, string>;
     chunkSimilarity: Map<string, number>;
 }>;

package/dist/cjs/commands/signals.js

@@ -210,53 +210,99 @@ function _unsupported_iterable_to_array(o, minLen) {
 // RRF composes whatever the preset declares; the constant lives here since it belongs to
 // the fusion these three functions share, not to search() itself.
 var RRF_K = 60;
-function wordsCandidates(db, candidates, query, whereJoin, whereCond, scopeCond, fetch, weight) {
-    var WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';
-    var SNIPPET_BOUND = 16384;
-    var matchSql = "SELECT content.path AS path, CASE WHEN length(content.text) <= ".concat(SNIPPET_BOUND, " THEN snippet(content, 2, '\xab', '\xbb', '…', 10) ELSE NULL END AS hit FROM content ").concat(whereJoin, " WHERE content MATCH ? ").concat(whereCond, " ").concat(scopeCond, " ORDER BY ").concat(WEIGHTED_BM25, " LIMIT ").concat(fetch);
-    var matchRows = db.prepare(matchSql).all(query);
-    matchRows.forEach(function(r, i) {
-        candidates.set(r.path, {
-            score: weight / (RRF_K + i),
-            via: 'match'
+function wordsCandidates(store, candidates, query, whereJoin, whereCond, scopeCond, fetch, weight) {
+    return _async_to_generator(function() {
+        var matchRows;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        store.lexical.query(query, {
+                            whereJoin: whereJoin,
+                            whereCond: whereCond,
+                            scopeCond: scopeCond,
+                            limit: fetch
+                        })
+                    ];
+                case 1:
+                    matchRows = _state.sent();
+                    matchRows.forEach(function(r, i) {
+                        candidates.set(r.path, {
+                            score: weight / (RRF_K + i),
+                            via: 'match'
+                        });
+                    });
+                    return [
+                        2,
+                        matchRows
+                    ];
+            }
         });
-    });
-    return matchRows;
+    })();
 }
-function linksCandidates(db, candidates, matchRows, allPaths, allowedPaths, fetch, weight) {
-    if (matchRows.length === 0) return;
-    var edges = (0, _indexts.linkEdges)(db);
-    if (edges.length === 0) return;
-    // Gates the label only, not the score: restart mass ranks every seed without an incident
-    // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).
-    var linked = new Set(edges.flat());
-    var seeds = new Map(matchRows.map(function(r, i) {
-        return [
-            r.path,
-            1 / (i + 1)
-        ];
-    }));
-    var ranked = _to_consumable_array((0, _graphts.personalizedRank)(allPaths, edges, seeds)).filter(function(param) {
-        var _param = _sliced_to_array(param, 2), path = _param[0], score = _param[1];
-        return score > 1e-9 && allowedPaths.has(path);
-    }).sort(function(a, b) {
-        return b[1] - a[1];
-    }).slice(0, fetch);
-    ranked.forEach(function(param, i) {
-        var _param = _sliced_to_array(param, 1), path = _param[0];
-        var existing = candidates.get(path);
-        if (existing) {
-            existing.score += weight / (RRF_K + i);
-            if (linked.has(path)) existing.via = 'match+link';
-        } else {
-            candidates.set(path, {
-                score: weight / (RRF_K + i),
-                via: 'link'
-            });
-        }
-    });
+function linksCandidates(store, candidates, matchRows, allPaths, allowedPaths, fetch, weight) {
+    return _async_to_generator(function() {
+        var stmt, edges, linked, seeds, ranked;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (matchRows.length === 0) return [
+                        2
+                    ];
+                    return [
+                        4,
+                        store.prepare(_indexts.LINK_EDGES_SQL)
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all()
+                    ];
+                case 2:
+                    edges = _indexts.toEdges.apply(void 0, [
+                        _state.sent()
+                    ]);
+                    if (edges.length === 0) return [
+                        2
+                    ];
+                    // Gates the label only, not the score: restart mass ranks every seed without an incident
+                    // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).
+                    linked = new Set(edges.flat());
+                    seeds = new Map(matchRows.map(function(r, i) {
+                        return [
+                            r.path,
+                            1 / (i + 1)
+                        ];
+                    }));
+                    ranked = _to_consumable_array((0, _graphts.personalizedRank)(allPaths, edges, seeds)).filter(function(param) {
+                        var _param = _sliced_to_array(param, 2), path = _param[0], score = _param[1];
+                        return score > 1e-9 && allowedPaths.has(path);
+                    }).sort(function(a, b) {
+                        return b[1] - a[1];
+                    }).slice(0, fetch);
+                    ranked.forEach(function(param, i) {
+                        var _param = _sliced_to_array(param, 1), path = _param[0];
+                        var existing = candidates.get(path);
+                        if (existing) {
+                            existing.score += weight / (RRF_K + i);
+                            if (linked.has(path)) existing.via = 'match+link';
+                        } else {
+                            candidates.set(path, {
+                                score: weight / (RRF_K + i),
+                                via: 'link'
+                            });
+                        }
+                    });
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
 }
-function vectorsCandidates(db, cfg, candidates, terms, fetch, allowedPaths, weight) {
+function vectorsCandidates(store, cfg, candidates, terms, fetch, allowedPaths, weight) {
     return _async_to_generator(function() {
         var chunkLines, chunkSimilarity, vec;
         return _ts_generator(this, function(_state) {
@@ -266,7 +312,7 @@ function vectorsCandidates(db, cfg, candidates, terms, fetch, allowedPaths, weig
                     chunkSimilarity = new Map();
                     return [
                         4,
-                        (0, _queryts.semanticCandidates)(db, cfg, terms, fetch, allowedPaths)
+                        (0, _queryts.semanticCandidates)(store, cfg, terms, fetch, allowedPaths)
                     ];
                 case 1:
                     vec = _state.sent();

package/dist/cjs/commands/signals.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/signals.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport type { ResolvedConfig } from '../config/index.ts';\nimport { semanticCandidates } from '../embed/query.ts';\nimport { linkEdges } from '../features/index.ts';\nimport { personalizedRank } from '../graph/graph.ts';\n\n// RRF composes whatever the preset declares; the constant lives here since it belongs to\n// the fusion these three functions share, not to search() itself.\nconst RRF_K = 60;\n\nexport type Candidates = Map<string, { score: number; via: string }>;\n\n// BM25 match rows, folded into `candidates` by reciprocal rank scaled by the preset's declared\n// weight for this signal (default 1, bit-identical to the unweighted score). Every other signal\n// is seeded from its output, so search() runs this one first when \"words\" is declared.\nexport function wordsCandidates(db: DatabaseSync, candidates: Candidates, query: string, whereJoin: string, whereCond: string, scopeCond: string, fetch: number, weight: number): Array<{ path: string; hit: string | null }> {\n  const WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0, 0, 10.0, 5.0, 1.0)';\n  const SNIPPET_BOUND = 16_384;\n  const matchSql = `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 ${fetch}`;\n  const matchRows = db.prepare(matchSql).all(query) as Array<{ path: string; hit: string | null }>;\n  matchRows.forEach((r, i) => {\n    candidates.set(r.path, { score: weight / (RRF_K + i), via: 'match' });\n  });\n  return matchRows;\n}\n\n// Personalized-PageRank expansion from the word-match seeds, folded into `candidates` at this\n// signal's weight. A no-op when there is nothing to seed from (matchRows empty), same as before\n// this was a signal.\nexport function linksCandidates(db: DatabaseSync, candidates: Candidates, matchRows: Array<{ path: string; hit: string | null }>, allPaths: string[], allowedPaths: Set<string>, fetch: number, weight: number): void {\n  if (matchRows.length === 0) return;\n  const edges = linkEdges(db);\n  if (edges.length === 0) return;\n  // Gates the label only, not the score: restart mass ranks every seed without an incident\n  // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).\n  const linked = new Set(edges.flat());\n  const seeds = new Map(matchRows.map((r, i) => [r.path, 1 / (i + 1)]));\n  const ranked = [...personalizedRank(allPaths, edges, seeds)]\n    .filter(([path, score]) => score > 1e-9 && allowedPaths.has(path))\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, fetch);\n  ranked.forEach(([path], i) => {\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += weight / (RRF_K + i);\n      if (linked.has(path)) existing.via = 'match+link';\n    } else {\n      candidates.set(path, { score: weight / (RRF_K + i), via: 'link' });\n    }\n  });\n}\n\n// Vector expansion at the swept flat-region constants (pool = fetch), folded into `candidates`\n// at this signal's weight. Each row also carries its best chunk's line range and similarity,\n// for the caller.\nexport async function vectorsCandidates(db: DatabaseSync, cfg: ResolvedConfig, candidates: Candidates, terms: string, fetch: number, allowedPaths: Set<string>, weight: number): Promise<{ chunkLines: Map<string, string>; chunkSimilarity: Map<string, number> }> {\n  const chunkLines = new Map<string, string>();\n  const chunkSimilarity = new Map<string, number>();\n  const vec = await semanticCandidates(db, cfg, terms, fetch, allowedPaths);\n  vec.forEach(({ path, lines, similarity }, i) => {\n    chunkLines.set(path, lines);\n    chunkSimilarity.set(path, similarity);\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += weight / (RRF_K + i);\n      existing.via = `${existing.via}+vector`;\n    } else {\n      candidates.set(path, { score: weight / (RRF_K + i), via: 'vector' });\n    }\n  });\n  return { chunkLines, chunkSimilarity };\n}\n"],"names":["linksCandidates","vectorsCandidates","wordsCandidates","RRF_K","db","candidates","query","whereJoin","whereCond","scopeCond","fetch","weight","WEIGHTED_BM25","SNIPPET_BOUND","matchSql","matchRows","prepare","all","forEach","r","i","set","path","score","via","allPaths","allowedPaths","length","edges","linkEdges","linked","Set","flat","seeds","Map","map","ranked","personalizedRank","filter","has","sort","a","b","slice","existing","get","cfg","terms","chunkLines","chunkSimilarity","vec","semanticCandidates","lines","similarity"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/signals.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config/index.ts';\nimport { semanticCandidates } from '../embed/query.ts';\nimport { LINK_EDGES_SQL, toEdges } from '../features/index.ts';\nimport { personalizedRank } from '../graph/graph.ts';\nimport type { LexicalHit, Store } from '../store/types.ts';\n\n// RRF composes whatever the preset declares; the constant lives here since it belongs to\n// the fusion these three functions share, not to search() itself.\nconst RRF_K = 60;\n\nexport type Candidates = Map<string, { score: number; via: string }>;\n\n// BM25 match rows (store.lexical.query), folded into `candidates` by reciprocal rank scaled by\n// the preset's declared weight for this signal (default 1, bit-identical to the unweighted\n// score). Every other signal is seeded from its output, so search() runs this one first when\n// \"words\" is declared.\nexport async function wordsCandidates(store: Store, candidates: Candidates, query: string, whereJoin: string, whereCond: string, scopeCond: string, fetch: number, weight: number): Promise<LexicalHit[]> {\n  const matchRows = await store.lexical.query(query, { whereJoin, whereCond, scopeCond, limit: fetch });\n  matchRows.forEach((r, i) => {\n    candidates.set(r.path, { score: weight / (RRF_K + i), via: 'match' });\n  });\n  return matchRows;\n}\n\n// Personalized-PageRank expansion from the word-match seeds, folded into `candidates` at this\n// signal's weight. A no-op when there is nothing to seed from (matchRows empty), same as before\n// this was a signal.\nexport async function linksCandidates(store: Store, candidates: Candidates, matchRows: LexicalHit[], allPaths: string[], allowedPaths: Set<string>, fetch: number, weight: number): Promise<void> {\n  if (matchRows.length === 0) return;\n  const stmt = await store.prepare(LINK_EDGES_SQL);\n  const edges = toEdges((await stmt.all()) as Array<{ src: string; dst: string }>);\n  if (edges.length === 0) return;\n  // Gates the label only, not the score: restart mass ranks every seed without an incident\n  // edge, but dropping it from the score reweights fusion (FEVER hit@10 0.997 -> 0.907).\n  const linked = new Set(edges.flat());\n  const seeds = new Map(matchRows.map((r, i) => [r.path, 1 / (i + 1)]));\n  const ranked = [...personalizedRank(allPaths, edges, seeds)]\n    .filter(([path, score]) => score > 1e-9 && allowedPaths.has(path))\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, fetch);\n  ranked.forEach(([path], i) => {\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += weight / (RRF_K + i);\n      if (linked.has(path)) existing.via = 'match+link';\n    } else {\n      candidates.set(path, { score: weight / (RRF_K + i), via: 'link' });\n    }\n  });\n}\n\n// Vector expansion at the swept flat-region constants (pool = fetch), folded into `candidates`\n// at this signal's weight. Each row also carries its best chunk's line range and similarity,\n// for the caller.\nexport async function vectorsCandidates(store: Store, cfg: ResolvedConfig, candidates: Candidates, terms: string, fetch: number, allowedPaths: Set<string>, weight: number): Promise<{ chunkLines: Map<string, string>; chunkSimilarity: Map<string, number> }> {\n  const chunkLines = new Map<string, string>();\n  const chunkSimilarity = new Map<string, number>();\n  const vec = await semanticCandidates(store, cfg, terms, fetch, allowedPaths);\n  vec.forEach(({ path, lines, similarity }, i) => {\n    chunkLines.set(path, lines);\n    chunkSimilarity.set(path, similarity);\n    const existing = candidates.get(path);\n    if (existing) {\n      existing.score += weight / (RRF_K + i);\n      existing.via = `${existing.via}+vector`;\n    } else {\n      candidates.set(path, { score: weight / (RRF_K + i), via: 'vector' });\n    }\n  });\n  return { chunkLines, chunkSimilarity };\n}\n"],"names":["linksCandidates","vectorsCandidates","wordsCandidates","RRF_K","store","candidates","query","whereJoin","whereCond","scopeCond","fetch","weight","matchRows","lexical","limit","forEach","r","i","set","path","score","via","allPaths","allowedPaths","stmt","edges","linked","seeds","ranked","length","prepare","LINK_EDGES_SQL","all","toEdges","Set","flat","Map","map","personalizedRank","filter","has","sort","a","b","slice","existing","get","cfg","terms","chunkLines","chunkSimilarity","vec","semanticCandidates","lines","similarity"],"mappings":"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"}

package/dist/cjs/commands/status.d.cts

@@ -1,9 +1,9 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig, SignalWeights } from '../config/index.js';
+import type { Store } from '../store/types.js';
 export interface PresetCoverage {
     name: string;
     files: number;
     embedded: number;
     signals: SignalWeights;
 }
-export declare function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[];
+export declare function presetCoverage(store: Store, cfg: ResolvedConfig): Promise<PresetCoverage[]>;

package/dist/cjs/commands/status.d.ts

@@ -1,9 +1,9 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig, SignalWeights } from '../config/index.js';
+import type { Store } from '../store/types.js';
 export interface PresetCoverage {
     name: string;
     files: number;
     embedded: number;
     signals: SignalWeights;
 }
-export declare function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[];
+export declare function presetCoverage(store: Store, cfg: ResolvedConfig): Promise<PresetCoverage[]>;

package/dist/cjs/commands/status.js

@@ -9,17 +9,254 @@ Object.defineProperty(exports, "presetCoverage", {
     }
 });
 var _indexts = require("../config/index.js");
-function presetCoverage(db, cfg) {
-    var embedActive = (0, _indexts.anyPresetEmbeds)(cfg);
-    return (0, _indexts.presetNames)(cfg).map(function(name) {
-        var files = db.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?').get(name).n;
-        var embedded = embedActive ? db.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e."path" = pf."path" AND e.vector IS NOT NULL)').get(name).n : 0;
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
         return {
-            name: name,
-            files: files,
-            embedded: embedded,
-            signals: (0, _indexts.presetSignals)(cfg, name)
+            value: op[0] ? op[1] : void 0,
+            done: true
         };
-    });
+    }
+}
+function presetCoverage(store, cfg) {
+    return _async_to_generator(function() {
+        var embedActive, filesStmt, embeddedStmt, _tmp, rows, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, name, files, embedded, _tmp1, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    embedActive = (0, _indexts.anyPresetEmbeds)(cfg);
+                    return [
+                        4,
+                        store.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?')
+                    ];
+                case 1:
+                    filesStmt = _state.sent();
+                    if (!embedActive) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        store.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e."path" = pf."path" AND e.vector IS NOT NULL)')
+                    ];
+                case 2:
+                    _tmp = _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    _tmp = null;
+                    _state.label = 4;
+                case 4:
+                    embeddedStmt = _tmp;
+                    // Sequential, not Promise.all: both statements are reused across presets, and a store's
+                    // prepared statement is not safe to bind/run concurrently with itself.
+                    rows = [];
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 5;
+                case 5:
+                    _state.trys.push([
+                        5,
+                        13,
+                        14,
+                        15
+                    ]);
+                    _iterator = (0, _indexts.presetNames)(cfg)[Symbol.iterator]();
+                    _state.label = 6;
+                case 6:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        12
+                    ];
+                    name = _step.value;
+                    return [
+                        4,
+                        filesStmt.get(name)
+                    ];
+                case 7:
+                    files = _state.sent().n;
+                    if (!embeddedStmt) return [
+                        3,
+                        9
+                    ];
+                    return [
+                        4,
+                        embeddedStmt.get(name)
+                    ];
+                case 8:
+                    _tmp1 = _state.sent().n;
+                    return [
+                        3,
+                        10
+                    ];
+                case 9:
+                    _tmp1 = 0;
+                    _state.label = 10;
+                case 10:
+                    embedded = _tmp1;
+                    rows.push({
+                        name: name,
+                        files: files,
+                        embedded: embedded,
+                        signals: (0, _indexts.presetSignals)(cfg, name)
+                    });
+                    _state.label = 11;
+                case 11:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        6
+                    ];
+                case 12:
+                    return [
+                        3,
+                        15
+                    ];
+                case 13:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        15
+                    ];
+                case 14:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 15:
+                    return [
+                        2,
+                        rows
+                    ];
+            }
+        });
+    })();
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/commands/status.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/status.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport type { ResolvedConfig, SignalWeights } from '../config/index.ts';\nimport { anyPresetEmbeds, presetNames, presetSignals } from '../config/index.ts';\n\nexport interface PresetCoverage {\n  name: string;\n  files: number;\n  embedded: number;\n  // Reported so 0 embedded reads as \"this scope declined vectors\" rather than \"not yet built\".\n  signals: SignalWeights;\n}\n\n// Indexing derives from presets, so the derivation stays visible. Read from preset_files, not\n// recomputed from globs, so it reflects the cache rather than the config.\nexport function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[] {\n  const embedActive = anyPresetEmbeds(cfg);\n  return presetNames(cfg).map((name) => {\n    const files = (db.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?').get(name) as { n: number }).n;\n    const embedded = embedActive ? (db.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e.\"path\" = pf.\"path\" AND e.vector IS NOT NULL)').get(name) as { n: number }).n : 0;\n    return { name, files, embedded, signals: presetSignals(cfg, name) };\n  });\n}\n"],"names":["presetCoverage","db","cfg","embedActive","anyPresetEmbeds","presetNames","map","name","files","prepare","get","n","embedded","signals","presetSignals"],"mappings":";;;;+BAcgBA;;;eAAAA;;;uBAZ4C;AAYrD,SAASA,eAAeC,EAAgB,EAAEC,GAAmB;IAClE,IAAMC,cAAcC,IAAAA,wBAAe,EAACF;IACpC,OAAOG,IAAAA,oBAAW,EAACH,KAAKI,GAAG,CAAC,SAACC;QAC3B,IAAMC,QAAQ,AAACP,GAAGQ,OAAO,CAAC,2DAA2DC,GAAG,CAACH,MAAwBI,CAAC;QAClH,IAAMC,WAAWT,cAAc,AAACF,GAAGQ,OAAO,CAAC,6JAA6JC,GAAG,CAACH,MAAwBI,CAAC,GAAG;QACxO,OAAO;YAAEJ,MAAAA;YAAMC,OAAAA;YAAOI,UAAAA;YAAUC,SAASC,IAAAA,sBAAa,EAACZ,KAAKK;QAAM;IACpE;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/status.ts"],"sourcesContent":["import type { ResolvedConfig, SignalWeights } from '../config/index.ts';\nimport { anyPresetEmbeds, presetNames, presetSignals } from '../config/index.ts';\nimport type { Store } from '../store/types.ts';\n\nexport interface PresetCoverage {\n  name: string;\n  files: number;\n  embedded: number;\n  // Reported so 0 embedded reads as \"this scope declined vectors\" rather than \"not yet built\".\n  signals: SignalWeights;\n}\n\n// Indexing derives from presets, so the derivation stays visible. Read from preset_files, not\n// recomputed from globs, so it reflects the cache rather than the config.\nexport async function presetCoverage(store: Store, cfg: ResolvedConfig): Promise<PresetCoverage[]> {\n  const embedActive = anyPresetEmbeds(cfg);\n  const filesStmt = await store.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?');\n  const embeddedStmt = embedActive ? await store.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e.\"path\" = pf.\"path\" AND e.vector IS NOT NULL)') : null;\n  // Sequential, not Promise.all: both statements are reused across presets, and a store's\n  // prepared statement is not safe to bind/run concurrently with itself.\n  const rows: PresetCoverage[] = [];\n  for (const name of presetNames(cfg)) {\n    const files = ((await filesStmt.get(name)) as { n: number }).n;\n    const embedded = embeddedStmt ? ((await embeddedStmt.get(name)) as { n: number }).n : 0;\n    rows.push({ name, files, embedded, signals: presetSignals(cfg, name) });\n  }\n  return rows;\n}\n"],"names":["presetCoverage","store","cfg","embedActive","filesStmt","embeddedStmt","rows","name","files","embedded","anyPresetEmbeds","prepare","presetNames","get","n","push","signals","presetSignals"],"mappings":";;;;+BAcsBA;;;eAAAA;;;uBAbsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAarD,SAAeA,eAAeC,KAAY,EAAEC,GAAmB;;YAC9DC,aACAC,WACAC,oBAGAC,MACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMC,MACHC,OACAC;;;;oBARFN,cAAcO,IAAAA,wBAAe,EAACR;oBAClB;;wBAAMD,MAAMU,OAAO,CAAC;;;oBAAhCP,YAAY;yBACGD,aAAAA;;;;oBAAc;;wBAAMF,MAAMU,OAAO,CAAC;;;2BAApB;;;;;;2BAAmL;;;oBAAhNN;oBACN,wFAAwF;oBACxF,uEAAuE;oBACjEC;oBACD,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAcM,IAAAA,oBAAW,EAACV;;;2BAA1B,6BAAA,QAAA;;;;oBAAMK,OAAN;oBACa;;wBAAMH,UAAUS,GAAG,CAACN;;;oBAA9BC,QAAQ,AAAE,cAA6CM,CAAC;yBAC7CT,cAAAA;;;;oBAAiB;;wBAAMA,aAAaQ,GAAG,CAACN;;;4BAAzB,AAAE,cAAgDO,CAAC;;;;;;4BAAG;;;oBAAhFL;oBACNH,KAAKS,IAAI,CAAC;wBAAER,MAAAA;wBAAMC,OAAAA;wBAAOC,UAAAA;wBAAUO,SAASC,IAAAA,sBAAa,EAACf,KAAKK;oBAAM;;;oBAHlE;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBAKL;;wBAAOD;;;;IACT"}

package/dist/cjs/config/access.d.cts

@@ -2,6 +2,7 @@ import type { Feature } from '../features/types.js';
 import type { SignalName, SignalWeights } from './signals.js';
 import { type Config, type FeatureName } from './types.js';
 export declare function presetNames(cfg: Config): string[];
+export declare function storeName(cfg: Config): 'sqlite' | 'duckdb';
 export declare function embedEnabled(cfg: Config): boolean;
 export declare function presetSignals(cfg: Config, name: string): SignalWeights;
 export declare function presetHasSignal(cfg: Config, name: string, signal: SignalName): boolean;

package/dist/cjs/config/access.d.ts

@@ -2,6 +2,7 @@ import type { Feature } from '../features/types.js';
 import type { SignalName, SignalWeights } from './signals.js';
 import { type Config, type FeatureName } from './types.js';
 export declare function presetNames(cfg: Config): string[];
+export declare function storeName(cfg: Config): 'sqlite' | 'duckdb';
 export declare function embedEnabled(cfg: Config): boolean;
 export declare function presetSignals(cfg: Config, name: string): SignalWeights;
 export declare function presetHasSignal(cfg: Config, name: string, signal: SignalName): boolean;

package/dist/cjs/config/access.js

@@ -41,6 +41,9 @@ _export(exports, {
     },
     get presetSignals () {
         return presetSignals;
+    },
+    get storeName () {
+        return storeName;
     }
 });
 var _typests = require("./types.js");
@@ -74,6 +77,10 @@ function _unsupported_iterable_to_array(o, minLen) {
 function presetNames(cfg) {
     return Object.keys(cfg.presets);
 }
+function storeName(cfg) {
+    var _cfg_store;
+    return (_cfg_store = cfg.store) !== null && _cfg_store !== void 0 ? _cfg_store : 'sqlite';
+}
 function embedEnabled(cfg) {
     var _cfg_embed;
     return typeof ((_cfg_embed = cfg.embed) === null || _cfg_embed === void 0 ? void 0 : _cfg_embed.model) === 'string' && cfg.embed.model.length > 0;

package/dist/cjs/config/access.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/access.ts"],"sourcesContent":["import type { Feature } from '../features/types.ts';\nimport type { SignalName, SignalWeights } from './signals.ts';\nimport { type Config, type EmbedConfig, FEATURE_NAMES, type FeatureName } from './types.ts';\n\nexport function presetNames(cfg: Config): string[] {\n  return Object.keys(cfg.presets);\n}\n\n// Whether the tree names a model at all.\nexport function embedEnabled(cfg: Config): boolean {\n  return typeof cfg.embed?.model === 'string' && cfg.embed.model.length > 0;\n}\n\n// A preset's effective signal weights: declared exhaustively when `signals` is present;\n// otherwise every signal whose prerequisite holds, each at weight 1 -- words always, links when\n// the feature is on, vectors when the tree names a model. Single source search() and status/map\n// read.\nexport function presetSignals(cfg: Config, name: string): SignalWeights {\n  const declared = cfg.presets[name]?.signals;\n  if (declared) return declared;\n  const signals: SignalWeights = { words: 1 };\n  if (cfg.features?.links !== false) signals.links = 1;\n  if (embedEnabled(cfg)) signals.vectors = 1;\n  return signals;\n}\n\nexport function presetHasSignal(cfg: Config, name: string, signal: SignalName): boolean {\n  return presetSignals(cfg, name)[signal] !== undefined;\n}\n\n// Whether embedding needs to run: a model is named AND some preset's effective signals include vectors.\nexport function anyPresetEmbeds(cfg: Config): boolean {\n  return presetNames(cfg).some((name) => presetHasSignal(cfg, name, 'vectors'));\n}\n\n// Opt-out features (default on): absent block or key means enabled. `rank` additionally\n// requires `links`. `embed` is derived, not a features-block member: on iff some preset's\n// effective signals include vectors.\nexport function featureEnabled(cfg: Config, name: FeatureName): boolean {\n  if (name === 'embed') return anyPresetEmbeds(cfg);\n  const enabled = cfg.features?.[name] !== false;\n  if (name === 'rank') return enabled && featureEnabled(cfg, 'links');\n  return enabled;\n}\n\nexport function enabledFeatures(cfg: Config): FeatureName[] {\n  return FEATURE_NAMES.filter((name) => featureEnabled(cfg, name));\n}\n\n// Feature states, so \"off\" and \"empty\" stay distinguishable in output. `embed` is excluded:\n// it is not a features-block toggle, and `status` reports it on its own line.\nexport function featureStates(cfg: Config): { on: FeatureName[]; off: FeatureName[] } {\n  const reported = FEATURE_NAMES.filter((name) => name !== 'embed');\n  return {\n    on: reported.filter((name) => featureEnabled(cfg, name)),\n    off: reported.filter((name) => !featureEnabled(cfg, name)),\n  };\n}\n\n// Resolved embed provider settings, or null when the config names no model. There is no\n// fallback to DEFAULT_EMBED_MODEL: that constant is a template `init` and the v4 migration\n// write into the file, never an implicit runtime default.\nexport function embedConfig(cfg: Config): { model: string; provider: 'static' | 'openai' | 'cohere'; url?: string; key?: string; languages?: string[]; chunkTokens?: number } | null {\n  if (!embedEnabled(cfg)) return null;\n  const e = cfg.embed as EmbedConfig;\n  return { model: e.model as string, provider: e.provider ?? 'static', url: e.url, key: e.key, languages: e.languages, chunkTokens: e.chunkTokens };\n}\n\n// The configured FTS5 tokenizer, or undefined for the built-in default. Undefined rather than\n// the default string so featureSignature can leave the segment off entirely for trees that\n// never set it, which is what keeps existing indexes from rebuilding on upgrade.\nexport function contentTokenize(cfg: Config): string | undefined {\n  const tokenize = cfg.content?.tokenize;\n  return tokenize === undefined || tokenize.trim() === '' ? undefined : tokenize.trim();\n}\n\n// Cache key over everything indexing derives from, so any change to those inputs rebuilds.\n// Segment order is fixed (features list, then `features` in registry order, then tokenize, then presets) since reordering alone would fire a spurious rebuild; tokenize/presets stay here because no Feature module owns either.\nexport function featureSignature(cfg: Config, features: Feature[]): string {\n  const globalPart = enabledFeatures(cfg)\n    .filter((name) => name !== 'embed')\n    .join(',');\n  const featureParts = features.map((feature) => feature.signature?.(cfg)).filter((part): part is string => part !== undefined);\n  // One keyed segment per preset so a rebuild notice can name exactly which preset moved.\n  const presetsPart = [...presetNames(cfg)]\n    .sort()\n    .map((name) => {\n      const p = cfg.presets[name];\n      const include = [...p.include].sort().join('+');\n      const exclude = [...(p.exclude ?? [])].sort().join('+');\n      return `preset:${name}:${include}:${exclude}:${presetHasSignal(cfg, name, 'vectors') ? 'on' : 'off'}`;\n    })\n    .join('|');\n  const tokenize = contentTokenize(cfg);\n  const parts = [`features:${globalPart}`, ...featureParts];\n  if (tokenize !== undefined) parts.push(`tokenize:${tokenize}`);\n  parts.push(presetsPart);\n  return parts.join('|');\n}\n"],"names":["anyPresetEmbeds","contentTokenize","embedConfig","embedEnabled","enabledFeatures","featureEnabled","featureSignature","featureStates","presetHasSignal","presetNames","presetSignals","cfg","Object","keys","presets","embed","model","length","name","declared","signals","words","features","links","vectors","signal","undefined","some","enabled","FEATURE_NAMES","filter","reported","on","off","e","provider","url","key","languages","chunkTokens","tokenize","content","trim","globalPart","join","featureParts","map","feature","signature","part","presetsPart","sort","p","include","exclude","parts","push"],"mappings":";;;;;;;;;;;QA+BgBA;eAAAA;;QAwCAC;eAAAA;;QATAC;eAAAA;;QArDAC;eAAAA;;QAoCAC;eAAAA;;QAPAC;eAAAA;;QAwCAC;eAAAA;;QA3BAC;eAAAA;;QAzBAC;eAAAA;;QAtBAC;eAAAA;;QAaAC;eAAAA;;;uBAf+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAExE,SAASD,YAAYE,GAAW;IACrC,OAAOC,OAAOC,IAAI,CAACF,IAAIG,OAAO;AAChC;AAGO,SAASX,aAAaQ,GAAW;QACxBA;IAAd,OAAO,SAAOA,aAAAA,IAAII,KAAK,cAATJ,iCAAAA,WAAWK,KAAK,MAAK,YAAYL,IAAII,KAAK,CAACC,KAAK,CAACC,MAAM,GAAG;AAC1E;AAMO,SAASP,cAAcC,GAAW,EAAEO,IAAY;QACpCP,mBAGbA;IAHJ,IAAMQ,YAAWR,oBAAAA,IAAIG,OAAO,CAACI,KAAK,cAAjBP,wCAAAA,kBAAmBS,OAAO;IAC3C,IAAID,UAAU,OAAOA;IACrB,IAAMC,UAAyB;QAAEC,OAAO;IAAE;IAC1C,IAAIV,EAAAA,gBAAAA,IAAIW,QAAQ,cAAZX,oCAAAA,cAAcY,KAAK,MAAK,OAAOH,QAAQG,KAAK,GAAG;IACnD,IAAIpB,aAAaQ,MAAMS,QAAQI,OAAO,GAAG;IACzC,OAAOJ;AACT;AAEO,SAASZ,gBAAgBG,GAAW,EAAEO,IAAY,EAAEO,MAAkB;IAC3E,OAAOf,cAAcC,KAAKO,KAAK,CAACO,OAAO,KAAKC;AAC9C;AAGO,SAAS1B,gBAAgBW,GAAW;IACzC,OAAOF,YAAYE,KAAKgB,IAAI,CAAC,SAACT;eAASV,gBAAgBG,KAAKO,MAAM;;AACpE;AAKO,SAASb,eAAeM,GAAW,EAAEO,IAAiB;QAE3CP;IADhB,IAAIO,SAAS,SAAS,OAAOlB,gBAAgBW;IAC7C,IAAMiB,UAAUjB,EAAAA,gBAAAA,IAAIW,QAAQ,cAAZX,oCAAAA,aAAc,CAACO,KAAK,MAAK;IACzC,IAAIA,SAAS,QAAQ,OAAOU,WAAWvB,eAAeM,KAAK;IAC3D,OAAOiB;AACT;AAEO,SAASxB,gBAAgBO,GAAW;IACzC,OAAOkB,sBAAa,CAACC,MAAM,CAAC,SAACZ;eAASb,eAAeM,KAAKO;;AAC5D;AAIO,SAASX,cAAcI,GAAW;IACvC,IAAMoB,WAAWF,sBAAa,CAACC,MAAM,CAAC,SAACZ;eAASA,SAAS;;IACzD,OAAO;QACLc,IAAID,SAASD,MAAM,CAAC,SAACZ;mBAASb,eAAeM,KAAKO;;QAClDe,KAAKF,SAASD,MAAM,CAAC,SAACZ;mBAAS,CAACb,eAAeM,KAAKO;;IACtD;AACF;AAKO,SAAShB,YAAYS,GAAW;QAGQuB;IAF7C,IAAI,CAAC/B,aAAaQ,MAAM,OAAO;IAC/B,IAAMuB,IAAIvB,IAAII,KAAK;IACnB,OAAO;QAAEC,OAAOkB,EAAElB,KAAK;QAAYmB,QAAQ,GAAED,cAAAA,EAAEC,QAAQ,cAAVD,yBAAAA,cAAc;QAAUE,KAAKF,EAAEE,GAAG;QAAEC,KAAKH,EAAEG,GAAG;QAAEC,WAAWJ,EAAEI,SAAS;QAAEC,aAAaL,EAAEK,WAAW;IAAC;AAClJ;AAKO,SAAStC,gBAAgBU,GAAW;QACxBA;IAAjB,IAAM6B,YAAW7B,eAAAA,IAAI8B,OAAO,cAAX9B,mCAAAA,aAAa6B,QAAQ;IACtC,OAAOA,aAAad,aAAac,SAASE,IAAI,OAAO,KAAKhB,YAAYc,SAASE,IAAI;AACrF;AAIO,SAASpC,iBAAiBK,GAAW,EAAEW,QAAmB;IAC/D,IAAMqB,aAAavC,gBAAgBO,KAChCmB,MAAM,CAAC,SAACZ;eAASA,SAAS;OAC1B0B,IAAI,CAAC;IACR,IAAMC,eAAevB,SAASwB,GAAG,CAAC,SAACC;YAAYA;gBAAAA,qBAAAA,QAAQC,SAAS,cAAjBD,yCAAAA,wBAAAA,SAAoBpC;OAAMmB,MAAM,CAAC,SAACmB;eAAyBA,SAASvB;;IACnH,wFAAwF;IACxF,IAAMwB,cAAc,AAAC,qBAAGzC,YAAYE,MACjCwC,IAAI,GACJL,GAAG,CAAC,SAAC5B;YAGiBkC;QAFrB,IAAMA,IAAIzC,IAAIG,OAAO,CAACI,KAAK;QAC3B,IAAMmC,UAAU,AAAC,qBAAGD,EAAEC,OAAO,EAAEF,IAAI,GAAGP,IAAI,CAAC;QAC3C,IAAMU,UAAU,AAAC,sBAAIF,aAAAA,EAAEE,OAAO,cAATF,wBAAAA,aAAa,EAAE,EAAGD,IAAI,GAAGP,IAAI,CAAC;QACnD,OAAO,AAAC,UAAiBS,OAARnC,MAAK,KAAcoC,OAAXD,SAAQ,KAAc7C,OAAX8C,SAAQ,KAAwD,OAArD9C,gBAAgBG,KAAKO,MAAM,aAAa,OAAO;IAChG,GACC0B,IAAI,CAAC;IACR,IAAMJ,WAAWvC,gBAAgBU;IACjC,IAAM4C,QAAQ;QAAE,YAAsB,OAAXZ;KAA8B,CAA3C,OAA2B,qBAAGE;IAC5C,IAAIL,aAAad,WAAW6B,MAAMC,IAAI,CAAC,AAAC,YAAoB,OAAThB;IACnDe,MAAMC,IAAI,CAACN;IACX,OAAOK,MAAMX,IAAI,CAAC;AACpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/access.ts"],"sourcesContent":["import type { Feature } from '../features/types.ts';\nimport type { SignalName, SignalWeights } from './signals.ts';\nimport { type Config, type EmbedConfig, FEATURE_NAMES, type FeatureName } from './types.ts';\n\nexport function presetNames(cfg: Config): string[] {\n  return Object.keys(cfg.presets);\n}\n\n// The backing store engine this tree uses; absent means the default.\nexport function storeName(cfg: Config): 'sqlite' | 'duckdb' {\n  return cfg.store ?? 'sqlite';\n}\n\n// Whether the tree names a model at all.\nexport function embedEnabled(cfg: Config): boolean {\n  return typeof cfg.embed?.model === 'string' && cfg.embed.model.length > 0;\n}\n\n// A preset's effective signal weights: declared exhaustively when `signals` is present;\n// otherwise every signal whose prerequisite holds, each at weight 1 -- words always, links when\n// the feature is on, vectors when the tree names a model. Single source search() and status/map\n// read.\nexport function presetSignals(cfg: Config, name: string): SignalWeights {\n  const declared = cfg.presets[name]?.signals;\n  if (declared) return declared;\n  const signals: SignalWeights = { words: 1 };\n  if (cfg.features?.links !== false) signals.links = 1;\n  if (embedEnabled(cfg)) signals.vectors = 1;\n  return signals;\n}\n\nexport function presetHasSignal(cfg: Config, name: string, signal: SignalName): boolean {\n  return presetSignals(cfg, name)[signal] !== undefined;\n}\n\n// Whether embedding needs to run: a model is named AND some preset's effective signals include vectors.\nexport function anyPresetEmbeds(cfg: Config): boolean {\n  return presetNames(cfg).some((name) => presetHasSignal(cfg, name, 'vectors'));\n}\n\n// Opt-out features (default on): absent block or key means enabled. `rank` additionally\n// requires `links`. `embed` is derived, not a features-block member: on iff some preset's\n// effective signals include vectors.\nexport function featureEnabled(cfg: Config, name: FeatureName): boolean {\n  if (name === 'embed') return anyPresetEmbeds(cfg);\n  const enabled = cfg.features?.[name] !== false;\n  if (name === 'rank') return enabled && featureEnabled(cfg, 'links');\n  return enabled;\n}\n\nexport function enabledFeatures(cfg: Config): FeatureName[] {\n  return FEATURE_NAMES.filter((name) => featureEnabled(cfg, name));\n}\n\n// Feature states, so \"off\" and \"empty\" stay distinguishable in output. `embed` is excluded:\n// it is not a features-block toggle, and `status` reports it on its own line.\nexport function featureStates(cfg: Config): { on: FeatureName[]; off: FeatureName[] } {\n  const reported = FEATURE_NAMES.filter((name) => name !== 'embed');\n  return {\n    on: reported.filter((name) => featureEnabled(cfg, name)),\n    off: reported.filter((name) => !featureEnabled(cfg, name)),\n  };\n}\n\n// Resolved embed provider settings, or null when the config names no model. There is no\n// fallback to DEFAULT_EMBED_MODEL: that constant is a template `init` and the v4 migration\n// write into the file, never an implicit runtime default.\nexport function embedConfig(cfg: Config): { model: string; provider: 'static' | 'openai' | 'cohere'; url?: string; key?: string; languages?: string[]; chunkTokens?: number } | null {\n  if (!embedEnabled(cfg)) return null;\n  const e = cfg.embed as EmbedConfig;\n  return { model: e.model as string, provider: e.provider ?? 'static', url: e.url, key: e.key, languages: e.languages, chunkTokens: e.chunkTokens };\n}\n\n// The configured FTS5 tokenizer, or undefined for the built-in default. Undefined rather than\n// the default string so featureSignature can leave the segment off entirely for trees that\n// never set it, which is what keeps existing indexes from rebuilding on upgrade.\nexport function contentTokenize(cfg: Config): string | undefined {\n  const tokenize = cfg.content?.tokenize;\n  return tokenize === undefined || tokenize.trim() === '' ? undefined : tokenize.trim();\n}\n\n// Cache key over everything indexing derives from, so any change to those inputs rebuilds.\n// Segment order is fixed (features list, then `features` in registry order, then tokenize, then presets) since reordering alone would fire a spurious rebuild; tokenize/presets stay here because no Feature module owns either.\nexport function featureSignature(cfg: Config, features: Feature[]): string {\n  const globalPart = enabledFeatures(cfg)\n    .filter((name) => name !== 'embed')\n    .join(',');\n  const featureParts = features.map((feature) => feature.signature?.(cfg)).filter((part): part is string => part !== undefined);\n  // One keyed segment per preset so a rebuild notice can name exactly which preset moved.\n  const presetsPart = [...presetNames(cfg)]\n    .sort()\n    .map((name) => {\n      const p = cfg.presets[name];\n      const include = [...p.include].sort().join('+');\n      const exclude = [...(p.exclude ?? [])].sort().join('+');\n      return `preset:${name}:${include}:${exclude}:${presetHasSignal(cfg, name, 'vectors') ? 'on' : 'off'}`;\n    })\n    .join('|');\n  const tokenize = contentTokenize(cfg);\n  const parts = [`features:${globalPart}`, ...featureParts];\n  if (tokenize !== undefined) parts.push(`tokenize:${tokenize}`);\n  parts.push(presetsPart);\n  return parts.join('|');\n}\n"],"names":["anyPresetEmbeds","contentTokenize","embedConfig","embedEnabled","enabledFeatures","featureEnabled","featureSignature","featureStates","presetHasSignal","presetNames","presetSignals","storeName","cfg","Object","keys","presets","store","embed","model","length","name","declared","signals","words","features","links","vectors","signal","undefined","some","enabled","FEATURE_NAMES","filter","reported","on","off","e","provider","url","key","languages","chunkTokens","tokenize","content","trim","globalPart","join","featureParts","map","feature","signature","part","presetsPart","sort","p","include","exclude","parts","push"],"mappings":"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"}

package/dist/cjs/config/index.d.cts

@@ -1,4 +1,4 @@
-export { anyPresetEmbeds, contentTokenize, embedConfig, embedEnabled, enabledFeatures, featureEnabled, featureSignature, featureStates, presetHasSignal, presetNames, presetSignals } from './access.js';
+export { anyPresetEmbeds, contentTokenize, embedConfig, embedEnabled, enabledFeatures, featureEnabled, featureSignature, featureStates, presetHasSignal, presetNames, presetSignals, storeName } from './access.js';
 export type { InitOverrides } from './load.js';
 export { findConfigPath, initConfig, loadConfig, migrateConfig } from './load.js';
 export { resolvePreset, resolveSearch } from './resolve.js';