sensemaking 0.17.0 → 0.18.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/related.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { embedConfig, embedEnabled, resolveSearch } from '../config/index.ts';\nimport { embedPending, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings } from './scope.ts';\n\n// Notes most similar by cosine, excluding self and everything already linked either way.\n// Its own command, not a peek section: a full embeddings scan is ~480ms at 26k notes.\nexport async function relatedNotes(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{ path: string; similarity: number }>> {\n  const paths = (db.prepare('SELECT \"path\" FROM frontmatter').all() as Array<{ path: string }>).map((r) => r.path);\n  const path = resolveNote(paths, pathArg);\n\n  const outbound = (db.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src').all(path) as Array<{ dst: string }>).map((r) => r.dst);\n  const backlinks = (db.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst').all(path) as Array<{ src: string }>).map((r) => r.src);\n  const exclude = new Set([path, ...outbound, ...backlinks]);\n\n  // Vectors are the only signal `related` has, so every way of not having them is an error\n  // naming the cause. An empty table then means one thing: nothing near in meaning that this\n  // note does not already link to, which is a real answer.\n  const effective = resolveSearch(cfg, overrides);\n  if (!embedEnabled(cfg)) {\n    throw new SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an \"embed\" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');\n  }\n  // search gates on the same signal (see wantsVectors above); reading it here too keeps a\n  // preset's declared signals meaning one thing. Without this, an overlapping vectors-on\n  // preset's vectors would answer for a scope that declined them.\n  if (effective.signals.vectors === undefined) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n  }\n  // A downloadable HF id proceeds -- embedPending's getProvider call fetches it lazily on\n  // consent. Only a local path with missing files can never fetch itself.\n  const e = embedConfig(cfg); // embedEnabled(cfg) above guarantees this is set\n  if (localModelMissing(e)) {\n    throw new SenseError('EMBED_MODEL_MISSING', `related ranks notes by meaning, so it needs the embedding model, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them (search still works without it, on words and links)`);\n  }\n  const allowed = scopedPaths(db, cfg, overrides);\n  // Top up pending rows before the seed check, or a fresh index reports every note as\n  // having no indexed text until some search has run.\n  await embedPending(db, cfg, cfg.baseDir);\n  if (!hasEmbedding(db, path)) {\n    throw new SenseError('NOTE_NOT_EMBEDDED', `${path} has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning`);\n  }\n  if (!scopeHasEmbeddings(db, cfg, allowed)) return [];\n  return similarNotes(db, cfg, path, { exclude, allowed, k });\n}\n"],"names":["relatedNotes","db","cfg","pathArg","overrides","k","paths","path","outbound","backlinks","exclude","effective","e","allowed","prepare","all","map","r","resolveNote","dst","src","Set","resolveSearch","embedEnabled","SenseError","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","scopedPaths","embedPending","baseDir","hasEmbedding","scopeHasEmbeddings","similarNotes"],"mappings":";;;;+BAWsBA;;;eAAAA;;;uBATmC;uBACA;uBACN;wBACxB;sBACC;uBACoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzC,SAAeA,aAAaC,EAAgB,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,SAA0B,EAAEC,CAAS;;YACxHC,OACAC,MAEAC,UACAC,WACAC,SAKAC,WAYAC,GAIAC;;;;oBA1BAP,QAAQ,AAACL,GAAGa,OAAO,CAAC,kCAAkCC,GAAG,GAA+BC,GAAG,CAAC,SAACC;+BAAMA,EAAEV,IAAI;;oBACzGA,OAAOW,IAAAA,mBAAW,EAACZ,OAAOH;oBAE1BK,WAAW,AAACP,GAAGa,OAAO,CAAC,mFAAmFC,GAAG,CAACR,MAAiCS,GAAG,CAAC,SAACC;+BAAMA,EAAEE,GAAG;;oBAC/JV,YAAY,AAACR,GAAGa,OAAO,CAAC,+DAA+DC,GAAG,CAACR,MAAiCS,GAAG,CAAC,SAACC;+BAAMA,EAAEG,GAAG;;oBAC5IV,UAAU,IAAIW,IAAI;wBAACd;sBAAD,OAAO,qBAAGC,WAAU,qBAAGC;oBAE/C,yFAAyF;oBACzF,2FAA2F;oBAC3F,yDAAyD;oBACnDE,YAAYW,IAAAA,sBAAa,EAACpB,KAAKE;oBACrC,IAAI,CAACmB,IAAAA,qBAAY,EAACrB,MAAM;wBACtB,MAAM,IAAIsB,oBAAU,CAAC,kBAAkB;oBACzC;oBACA,wFAAwF;oBACxF,uFAAuF;oBACvF,gEAAgE;oBAChE,IAAIb,UAAUc,OAAO,CAACC,OAAO,KAAKC,WAAW;wBAC3C,MAAM,IAAIH,oBAAU,CAAC,uBAAuB,AAAC,WAA+B,OAArBb,UAAUiB,UAAU,EAAC;oBAC9E;oBACA,wFAAwF;oBACxF,wEAAwE;oBAClEhB,IAAIiB,IAAAA,oBAAW,EAAC3B,MAAM,iDAAiD;oBAC7E,IAAI4B,IAAAA,0BAAiB,EAAClB,IAAI;wBACxB,MAAM,IAAIY,oBAAU,CAAC,uBAAuB,AAAC,8FAAoHO,OAAvBnB,EAAEoB,KAAK,EAAC,iBAA+B,OAAhBD,wBAAe,EAAC;oBACnL;oBACMlB,UAAUoB,IAAAA,oBAAW,EAAChC,IAAIC,KAAKE;oBACrC,oFAAoF;oBACpF,oDAAoD;oBACpD;;wBAAM8B,IAAAA,qBAAY,EAACjC,IAAIC,KAAKA,IAAIiC,OAAO;;;oBAAvC;oBACA,IAAI,CAACC,IAAAA,qBAAY,EAACnC,IAAIM,OAAO;wBAC3B,MAAM,IAAIiB,oBAAU,CAAC,qBAAqB,AAAC,GAAO,OAALjB,MAAK;oBACpD;oBACA,IAAI,CAAC8B,IAAAA,2BAAkB,EAACpC,IAAIC,KAAKW,UAAU;;;;oBAC3C;;wBAAOyB,IAAAA,qBAAY,EAACrC,IAAIC,KAAKK,MAAM;4BAAEG,SAAAA;4BAASG,SAAAA;4BAASR,GAAAA;wBAAE;;;;IAC3D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/related.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { embedConfig, embedEnabled, resolveSearch } from '../config/index.ts';\nimport { embedPending, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings } from './scope.ts';\n\n// Notes most similar by cosine, excluding self and everything already linked either way.\n// Its own command, not a peek section: a full embeddings scan is ~480ms at 26k notes.\nexport async function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{ path: string; similarity: number }>> {\n  const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n  const path = resolveNote(paths, pathArg);\n\n  const outbound = ((await (await store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')).all(path)) as Array<{ dst: string }>).map((r) => r.dst);\n  const backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')).all(path)) as Array<{ src: string }>).map((r) => r.src);\n  const exclude = new Set([path, ...outbound, ...backlinks]);\n\n  // Vectors are the only signal `related` has, so every way of not having them is an error\n  // naming the cause. An empty table then means one thing: nothing near in meaning that this\n  // note does not already link to, which is a real answer.\n  const effective = resolveSearch(cfg, overrides);\n  if (!embedEnabled(cfg)) {\n    throw new SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an \"embed\" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');\n  }\n  // search gates on the same signal (see wantsVectors above); reading it here too keeps a\n  // preset's declared signals meaning one thing. Without this, an overlapping vectors-on\n  // preset's vectors would answer for a scope that declined them.\n  if (effective.signals.vectors === undefined) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n  }\n  // A downloadable HF id proceeds -- embedPending's getProvider call fetches it lazily on\n  // consent. Only a local path with missing files can never fetch itself.\n  const e = embedConfig(cfg); // embedEnabled(cfg) above guarantees this is set\n  if (localModelMissing(e)) {\n    throw new SenseError('EMBED_MODEL_MISSING', `related ranks notes by meaning, so it needs the embedding model, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them (search still works without it, on words and links)`);\n  }\n  const allowed = await scopedPaths(store, cfg, overrides);\n  // Top up pending rows before the seed check, or a fresh index reports every note as\n  // having no indexed text until some search has run.\n  await embedPending(store, cfg, cfg.baseDir);\n  if (!(await hasEmbedding(store, path))) {\n    throw new SenseError('NOTE_NOT_EMBEDDED', `${path} has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning`);\n  }\n  if (!(await scopeHasEmbeddings(store, cfg, allowed))) return [];\n  return similarNotes(store, cfg, path, { exclude, allowed, k });\n}\n"],"names":["relatedNotes","store","cfg","pathArg","overrides","k","paths","path","outbound","backlinks","exclude","effective","e","allowed","prepare","all","map","r","resolveNote","dst","src","Set","resolveSearch","embedEnabled","SenseError","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","scopedPaths","embedPending","baseDir","hasEmbedding","scopeHasEmbeddings","similarNotes"],"mappings":";;;;+BAWsBA;;;eAAAA;;;uBAVmC;uBACA;uBACN;wBACxB;sBAEC;uBACoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzC,SAAeA,aAAaC,KAAY,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,SAA0B,EAAEC,CAAS;;YACpHC,OACAC,MAEAC,UACAC,WACAC,SAKAC,WAYAC,GAIAC;;;;oBA1BiB;;wBAAMZ,MAAMa,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAuDC,GAAG;;;oBAA3ET,QAAQ,AAAE,cAAiGU,GAAG,CAAC,SAACC;+BAAMA,EAAEV,IAAI;;oBAC5HA,OAAOW,IAAAA,mBAAW,EAACZ,OAAOH;oBAEN;;wBAAMF,MAAMa,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAwGC,GAAG,CAACR;;;oBAAhIC,WAAW,AAAE,cAAqJQ,GAAG,CAAC,SAACC;+BAAMA,EAAEE,GAAG;;oBAC7J;;wBAAMlB,MAAMa,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAoFC,GAAG,CAACR;;;oBAA7GE,YAAY,AAAE,cAAiIO,GAAG,CAAC,SAACC;+BAAMA,EAAEG,GAAG;;oBAC/JV,UAAU,IAAIW,IAAI;wBAACd;sBAAD,OAAO,qBAAGC,WAAU,qBAAGC;oBAE/C,yFAAyF;oBACzF,2FAA2F;oBAC3F,yDAAyD;oBACnDE,YAAYW,IAAAA,sBAAa,EAACpB,KAAKE;oBACrC,IAAI,CAACmB,IAAAA,qBAAY,EAACrB,MAAM;wBACtB,MAAM,IAAIsB,oBAAU,CAAC,kBAAkB;oBACzC;oBACA,wFAAwF;oBACxF,uFAAuF;oBACvF,gEAAgE;oBAChE,IAAIb,UAAUc,OAAO,CAACC,OAAO,KAAKC,WAAW;wBAC3C,MAAM,IAAIH,oBAAU,CAAC,uBAAuB,AAAC,WAA+B,OAArBb,UAAUiB,UAAU,EAAC;oBAC9E;oBACA,wFAAwF;oBACxF,wEAAwE;oBAClEhB,IAAIiB,IAAAA,oBAAW,EAAC3B,MAAM,iDAAiD;oBAC7E,IAAI4B,IAAAA,0BAAiB,EAAClB,IAAI;wBACxB,MAAM,IAAIY,oBAAU,CAAC,uBAAuB,AAAC,8FAAoHO,OAAvBnB,EAAEoB,KAAK,EAAC,iBAA+B,OAAhBD,wBAAe,EAAC;oBACnL;oBACgB;;wBAAME,IAAAA,oBAAW,EAAChC,OAAOC,KAAKE;;;oBAAxCS,UAAU;oBAChB,oFAAoF;oBACpF,oDAAoD;oBACpD;;wBAAMqB,IAAAA,qBAAY,EAACjC,OAAOC,KAAKA,IAAIiC,OAAO;;;oBAA1C;oBACM;;wBAAMC,IAAAA,qBAAY,EAACnC,OAAOM;;;oBAAhC,IAAI,CAAE,eAAkC;wBACtC,MAAM,IAAIiB,oBAAU,CAAC,qBAAqB,AAAC,GAAO,OAALjB,MAAK;oBACpD;oBACM;;wBAAM8B,IAAAA,2BAAkB,EAACpC,OAAOC,KAAKW;;;oBAA3C,IAAI,CAAE,eAAgD;;;;oBACtD;;wBAAOyB,IAAAA,qBAAY,EAACrC,OAAOC,KAAKK,MAAM;4BAAEG,SAAAA;4BAASG,SAAAA;4BAASR,GAAAA;wBAAE;;;;IAC9D"}

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

@@ -1,10 +1,10 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
+import type { Store } from '../store/types.js';
 export declare const INTERNAL_COLUMNS: Set<string>;
 export declare function inScope(path: string, include: string[], exclude?: string[]): boolean;
-export declare function scopeHasEmbeddings(db: DatabaseSync, cfg: ResolvedConfig, scopedPaths: Set<string>): boolean;
-export declare function rawScope(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Set<string>;
-export declare function narrowByWhere(db: DatabaseSync, paths: Set<string>, where: string | undefined): Set<string>;
-export declare function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string>;
-export declare function materializeScope(db: DatabaseSync, table: string, paths: Set<string>): void;
-export declare function setupMapScope(db: DatabaseSync, paths: Set<string>): void;
+export declare function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean>;
+export declare function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>>;
+export declare function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>>;
+export declare function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>>;
+export declare function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void>;
+export declare function setupMapScope(store: Store, paths: Set<string>): Promise<void>;

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

@@ -1,10 +1,10 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
+import type { Store } from '../store/types.js';
 export declare const INTERNAL_COLUMNS: Set<string>;
 export declare function inScope(path: string, include: string[], exclude?: string[]): boolean;
-export declare function scopeHasEmbeddings(db: DatabaseSync, cfg: ResolvedConfig, scopedPaths: Set<string>): boolean;
-export declare function rawScope(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Set<string>;
-export declare function narrowByWhere(db: DatabaseSync, paths: Set<string>, where: string | undefined): Set<string>;
-export declare function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string>;
-export declare function materializeScope(db: DatabaseSync, table: string, paths: Set<string>): void;
-export declare function setupMapScope(db: DatabaseSync, paths: Set<string>): void;
+export declare function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean>;
+export declare function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>>;
+export declare function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>>;
+export declare function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>>;
+export declare function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void>;
+export declare function setupMapScope(store: Store, paths: Set<string>): Promise<void>;

package/dist/cjs/commands/scope.js

@@ -45,6 +45,32 @@ function _array_like_to_array(arr, len) {
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
+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 _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
         return Array.from(iter);
@@ -56,6 +82,105 @@ function _non_iterable_spread() {
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
+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 {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -81,52 +206,264 @@ function inScope(path, include, exclude) {
     })) return false;
     return true;
 }
-function scopeHasEmbeddings(db, cfg, scopedPaths) {
-    if (!(0, _indexts.anyPresetEmbeds)(cfg)) return false; // the embeddings table doesn't exist at all in this case
-    var rows = db.prepare('SELECT DISTINCT "path" FROM embeddings').all();
-    return rows.some(function(r) {
-        return scopedPaths.has(r.path);
-    });
+function scopeHasEmbeddings(store, cfg, scopedPaths) {
+    return _async_to_generator(function() {
+        var stmt, rows;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!(0, _indexts.anyPresetEmbeds)(cfg)) return [
+                        2,
+                        false
+                    ]; // the embeddings table doesn't exist at all in this case
+                    return [
+                        4,
+                        store.prepare('SELECT DISTINCT "path" FROM embeddings')
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all()
+                    ];
+                case 2:
+                    rows = _state.sent();
+                    return [
+                        2,
+                        rows.some(function(r) {
+                            return scopedPaths.has(r.path);
+                        })
+                    ];
+            }
+        });
+    })();
 }
-function rawScope(db, cfg, overrides, allPaths) {
-    var effective = (0, _indexts.resolveSearch)(cfg, overrides);
-    var include = effective.include, exclude = effective.exclude;
-    var adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;
-    if (!adHocScope) return new Set(db.prepare('SELECT "path" FROM preset_files WHERE preset = ?').all(effective.presetName).map(function(r) {
-        return r.path;
-    }));
-    var paths = allPaths !== null && allPaths !== void 0 ? allPaths : db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
-        return r.path;
-    });
-    return new Set(paths.filter(function(p) {
-        return inScope(p, include, exclude);
-    }));
+function rawScope(store, cfg, overrides, allPaths) {
+    return _async_to_generator(function() {
+        var effective, include, exclude, adHocScope, stmt, _, paths, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    effective = (0, _indexts.resolveSearch)(cfg, overrides);
+                    include = effective.include, exclude = effective.exclude;
+                    adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;
+                    if (!!adHocScope) return [
+                        3,
+                        3
+                    ];
+                    return [
+                        4,
+                        store.prepare('SELECT "path" FROM preset_files WHERE preset = ?')
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    _ = Set.bind;
+                    return [
+                        4,
+                        stmt.all(effective.presetName)
+                    ];
+                case 2:
+                    return [
+                        2,
+                        new (_.apply(Set, [
+                            void 0,
+                            _state.sent().map(function(r) {
+                                return r.path;
+                            })
+                        ]))
+                    ];
+                case 3:
+                    if (!(allPaths !== null && allPaths !== void 0)) return [
+                        3,
+                        4
+                    ];
+                    _tmp = allPaths;
+                    return [
+                        3,
+                        6
+                    ];
+                case 4:
+                    return [
+                        4,
+                        allFrontmatterPaths(store)
+                    ];
+                case 5:
+                    _tmp = _state.sent();
+                    _state.label = 6;
+                case 6:
+                    paths = _tmp;
+                    return [
+                        2,
+                        new Set(paths.filter(function(p) {
+                            return inScope(p, include, exclude);
+                        }))
+                    ];
+            }
+        });
+    })();
 }
-function narrowByWhere(db, paths, where) {
-    if (!where) return paths;
-    var whereRows;
-    try {
-        whereRows = db.prepare('SELECT "path" FROM frontmatter f WHERE ('.concat(where, ")")).all();
-    } catch (err) {
-        throw (0, _columnhintts.columnHint)(db, err);
-    }
-    var wherePaths = new Set(whereRows.map(function(r) {
-        return r.path;
-    }));
-    return new Set(_to_consumable_array(paths).filter(function(p) {
-        return wherePaths.has(p);
-    }));
-}
-function scopedPaths(db, cfg, overrides) {
-    var effective = (0, _indexts.resolveSearch)(cfg, overrides);
-    return narrowByWhere(db, rawScope(db, cfg, overrides), effective.where);
-}
-function materializeScope(db, table, paths) {
-    db.exec("DROP TABLE IF EXISTS ".concat(table));
-    db.exec("CREATE TEMP TABLE ".concat(table, ' ("path" TEXT PRIMARY KEY)'));
-    db.prepare("INSERT INTO ".concat(table, " SELECT DISTINCT value FROM json_each(?1)")).run(JSON.stringify(_to_consumable_array(paths)));
-}
-function setupMapScope(db, paths) {
-    materializeScope(db, '_map_scope', paths);
+function allFrontmatterPaths(store) {
+    return _async_to_generator(function() {
+        var stmt;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        store.prepare('SELECT "path" FROM frontmatter')
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all()
+                    ];
+                case 2:
+                    return [
+                        2,
+                        _state.sent().map(function(r) {
+                            return r.path;
+                        })
+                    ];
+            }
+        });
+    })();
+}
+function narrowByWhere(store, paths, where) {
+    return _async_to_generator(function() {
+        var whereRows, stmt, err, wherePaths;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!where) return [
+                        2,
+                        paths
+                    ];
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        4,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        store.prepare('SELECT "path" FROM frontmatter f WHERE ('.concat(where, ")"))
+                    ];
+                case 2:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all()
+                    ];
+                case 3:
+                    whereRows = _state.sent();
+                    return [
+                        3,
+                        6
+                    ];
+                case 4:
+                    err = _state.sent();
+                    return [
+                        4,
+                        store.docs.columns()
+                    ];
+                case 5:
+                    throw _columnhintts.columnHint.apply(void 0, [
+                        _state.sent(),
+                        err
+                    ]);
+                case 6:
+                    wherePaths = new Set(whereRows.map(function(r) {
+                        return r.path;
+                    }));
+                    return [
+                        2,
+                        new Set(_to_consumable_array(paths).filter(function(p) {
+                            return wherePaths.has(p);
+                        }))
+                    ];
+            }
+        });
+    })();
+}
+function scopedPaths(store, cfg, overrides) {
+    return _async_to_generator(function() {
+        var effective, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    effective = (0, _indexts.resolveSearch)(cfg, overrides);
+                    _tmp = [
+                        store
+                    ];
+                    return [
+                        4,
+                        rawScope(store, cfg, overrides)
+                    ];
+                case 1:
+                    return [
+                        2,
+                        narrowByWhere.apply(void 0, _tmp.concat([
+                            _state.sent(),
+                            effective.where
+                        ]))
+                    ];
+            }
+        });
+    })();
+}
+function materializeScope(store, table, paths) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        store.exec("DROP TABLE IF EXISTS ".concat(table))
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        4,
+                        store.exec("CREATE TEMP TABLE ".concat(table, ' ("path" TEXT PRIMARY KEY)'))
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        store.runBatch("INSERT INTO ".concat(table, ' ("path") VALUES (?)'), _to_consumable_array(paths).map(function(p) {
+                            return [
+                                p
+                            ];
+                        }))
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function setupMapScope(store, paths) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        materializeScope(store, '_map_scope', paths)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
 }
 /* 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/scope.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { DatabaseSync } from 'node:sqlite';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\n\nexport const INTERNAL_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_rank', '_parse_error']);\n\n// node:path's matchesGlob is experimental (stable behind an unstable-API flag) as of the\n// engines floor (Node >=22.20); scope filtering only ever needs single-pattern matching, so\n// it's used here in JS rather than running a directory walk in the query path.\nexport function inScope(path: string, include: string[], exclude?: string[]): boolean {\n  if (!include.some((g) => matchesGlob(path, g))) return false;\n  if (exclude?.some((g) => matchesGlob(path, g))) return false;\n  return true;\n}\n\nexport function scopeHasEmbeddings(db: DatabaseSync, cfg: ResolvedConfig, scopedPaths: Set<string>): boolean {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const rows = db.prepare('SELECT DISTINCT \"path\" FROM embeddings').all() as Array<{ path: string }>;\n  return rows.some((r) => scopedPaths.has(r.path));\n}\n\n// Scope only (no --where): preset_files for a named preset, JS glob matching for an ad hoc\n// include/exclude override. Shared by scopedPaths() and search(), which also needs the\n// pre-where set to size the candidate-pool filter.\nexport function rawScope(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Set<string> {\n  const effective = resolveSearch(cfg, overrides);\n  const { include, exclude } = effective;\n  const adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;\n  if (!adHocScope) return new Set((db.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?').all(effective.presetName) as Array<{ path: string }>).map((r) => r.path));\n  const paths = allPaths ?? (db.prepare('SELECT \"path\" FROM frontmatter').all() as Array<{ path: string }>).map((r) => r.path);\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nexport function narrowByWhere(db: DatabaseSync, paths: Set<string>, where: string | undefined): Set<string> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    whereRows = db.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`).all() as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(db, err as Error);\n  }\n  const wherePaths = new Set(whereRows.map((r) => r.path));\n  return new Set([...paths].filter((p) => wherePaths.has(p)));\n}\n\n// The scope resolver for non-search commands (path, peek, map): same coverage rule search()\n// applies, then narrowed by the resolved `where`.\nexport function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(db, rawScope(db, cfg, overrides), effective.where);\n}\n\n// Materializes a path set into a named temp table (same shape as traverse.ts's allowed_nodes)\n// so a query can join/filter against it cheaply instead of binding a parameter per path.\nexport function materializeScope(db: DatabaseSync, table: string, paths: Set<string>): void {\n  db.exec(`DROP TABLE IF EXISTS ${table}`);\n  db.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  db.prepare(`INSERT INTO ${table} SELECT DISTINCT value FROM json_each(?1)`).run(JSON.stringify([...paths]));\n}\n\nexport function setupMapScope(db: DatabaseSync, paths: Set<string>): void {\n  materializeScope(db, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","Set","path","include","exclude","some","g","matchesGlob","db","cfg","anyPresetEmbeds","rows","prepare","all","r","has","overrides","allPaths","effective","resolveSearch","adHocScope","undefined","noExclude","presetName","map","paths","filter","p","where","whereRows","err","columnHint","wherePaths","table","exec","run","JSON","stringify"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Store } from '../store/types.ts';\n\nexport const INTERNAL_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_rank', '_parse_error']);\n\n// node:path's matchesGlob is experimental (stable behind an unstable-API flag) as of the\n// engines floor (Node >=22.20); scope filtering only ever needs single-pattern matching, so\n// it's used here in JS rather than running a directory walk in the query path.\nexport function inScope(path: string, include: string[], exclude?: string[]): boolean {\n  if (!include.some((g) => matchesGlob(path, g))) return false;\n  if (exclude?.some((g) => matchesGlob(path, g))) return false;\n  return true;\n}\n\nexport async function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean> {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const stmt = await store.prepare('SELECT DISTINCT \"path\" FROM embeddings');\n  const rows = (await stmt.all()) as Array<{ path: string }>;\n  return rows.some((r) => scopedPaths.has(r.path));\n}\n\n// Scope only (no --where): preset_files for a named preset, JS glob matching for an ad hoc\n// include/exclude override. Shared by scopedPaths() and search(), which also needs the\n// pre-where set to size the candidate-pool filter.\nexport async function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  const { include, exclude } = effective;\n  const adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;\n  if (!adHocScope) {\n    const stmt = await store.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?');\n    return new Set(((await stmt.all(effective.presetName)) as Array<{ path: string }>).map((r) => r.path));\n  }\n  const paths = allPaths ?? (await allFrontmatterPaths(store));\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nasync function allFrontmatterPaths(store: Store): Promise<string[]> {\n  const stmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n  return ((await stmt.all()) as Array<{ path: string }>).map((r) => r.path);\n}\n\nexport async function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    const stmt = await store.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`);\n    whereRows = (await stmt.all()) as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(await store.docs.columns(), err as Error);\n  }\n  const wherePaths = new Set(whereRows.map((r) => r.path));\n  return new Set([...paths].filter((p) => wherePaths.has(p)));\n}\n\n// The scope resolver for non-search commands (path, peek, map): same coverage rule search()\n// applies, then narrowed by the resolved `where`.\nexport async function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(store, await rawScope(store, cfg, overrides), effective.where);\n}\n\n// Materializes a path set into a named temp table (same shape as traverse.ts's allowed_nodes)\n// so a query can join/filter against it cheaply instead of binding a parameter per path.\nexport async function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void> {\n  await store.exec(`DROP TABLE IF EXISTS ${table}`);\n  await store.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  await store.runBatch(\n    `INSERT INTO ${table} (\"path\") VALUES (?)`,\n    [...paths].map((p) => [p])\n  );\n}\n\nexport async function setupMapScope(store: Store, paths: Set<string>): Promise<void> {\n  await materializeScope(store, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","Set","path","include","exclude","some","g","matchesGlob","store","cfg","stmt","rows","anyPresetEmbeds","prepare","all","r","has","overrides","allPaths","effective","adHocScope","paths","resolveSearch","undefined","noExclude","presetName","map","allFrontmatterPaths","filter","p","where","whereRows","err","wherePaths","docs","columns","columnHint","table","exec","runBatch"],"mappings":"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"}

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

@@ -1,6 +1,6 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../config/index.js';
 import type { Row } from '../output/output.js';
+import type { Store } from '../store/types.js';
 export interface SearchOptions {
     k?: number;
     where?: string;
@@ -9,4 +9,4 @@ export interface SearchOptions {
     exclude?: string[];
     noExclude?: boolean;
 }
-export declare function search(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export declare function search(store: Store, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;

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

@@ -1,6 +1,6 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { ResolvedConfig } from '../config/index.js';
 import type { Row } from '../output/output.js';
+import type { Store } from '../store/types.js';
 export interface SearchOptions {
     k?: number;
     where?: string;
@@ -9,4 +9,4 @@ export interface SearchOptions {
     exclude?: string[];
     noExclude?: boolean;
 }
-export declare function search(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export declare function search(store: Store, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;