sensemaking 0.12.2 → 0.13.0

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

@@ -0,0 +1,6 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
+export declare function relatedNotes(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{
+    path: string;
+    similarity: number;
+}>>;

package/dist/cjs/commands/related.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "relatedNotes", {
+    enumerable: true,
+    get: function() {
+        return relatedNotes;
+    }
+});
+var _indexts = require("../config/index.js");
+var _errorsts = require("../errors.js");
+var _embedts = require("../features/embed.js");
+var _peekts = require("./peek.js");
+var _scopets = require("./scope.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+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);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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 relatedNotes(db, cfg, pathArg, overrides, k) {
+    return _async_to_generator(function() {
+        var paths, path, outbound, backlinks, exclude, effective, allowed;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    paths = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
+                        return r.path;
+                    });
+                    path = (0, _peekts.resolveNote)(paths, pathArg);
+                    outbound = db.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL').all(path).map(function(r) {
+                        return r.dst;
+                    });
+                    backlinks = db.prepare('SELECT DISTINCT src FROM links WHERE dst = ?').all(path).map(function(r) {
+                        return r.src;
+                    });
+                    exclude = new Set([
+                        path
+                    ].concat(_to_consumable_array(outbound), _to_consumable_array(backlinks)));
+                    // Vectors are the only signal `related` has, so every way of not having them is an error
+                    // naming the cause. An empty table then means one thing: nothing near in meaning that this
+                    // note does not already link to, which is a real answer.
+                    effective = (0, _indexts.resolveSearch)(cfg, overrides);
+                    if (!(0, _indexts.embedEnabled)(cfg)) {
+                        throw new _errorsts.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, then run `sense download` (search works without it, on words and links)');
+                    }
+                    // search gates on the same flag (see wantsVectors above); reading it here too keeps
+                    // `semantic: false` meaning one thing. Without this, an overlapping semantic-on preset's
+                    // vectors would answer for a scope that declined them.
+                    if (!effective.semantic) {
+                        throw new _errorsts.SenseError('PRESET_NOT_SEMANTIC', 'preset "'.concat(effective.presetName, '" sets "semantic": false, so this scope has no vectors and related has no other signal; search it instead (words and links), or set semantic back on for that preset'));
+                    }
+                    if (!(0, _embedts.modelPresent)(cfg)) {
+                        throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'related ranks notes by meaning, so it needs the embedding model, which is not downloaded; run `sense download` (search still works without it, on words and links)');
+                    }
+                    allowed = (0, _scopets.scopedPaths)(db, cfg, overrides);
+                    // Top up pending rows before the seed check, or a fresh index reports every note as
+                    // having no indexed text until some search has run.
+                    return [
+                        4,
+                        (0, _embedts.embedPending)(db, cfg, cfg.baseDir)
+                    ];
+                case 1:
+                    _state.sent();
+                    if (!(0, _embedts.hasEmbedding)(db, path)) {
+                        throw new _errorsts.SenseError('NOTE_NOT_EMBEDDED', "".concat(path, " has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning"));
+                    }
+                    if (!(0, _scopets.scopeHasEmbeddings)(db, cfg, allowed)) return [
+                        2,
+                        []
+                    ];
+                    return [
+                        2,
+                        (0, _embedts.similarNotes)(db, cfg, path, {
+                            exclude: exclude,
+                            allowed: allowed,
+                            k: k
+                        })
+                    ];
+            }
+        });
+    })();
+}
+/* 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/related.js.map

@@ -0,0 +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 { embedEnabled, resolveSearch } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { embedPending, hasEmbedding, modelPresent, similarNotes } from '../features/embed.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').all(path) as Array<{ dst: string }>).map((r) => r.dst);\n  const backlinks = (db.prepare('SELECT DISTINCT src FROM links WHERE 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, then run `sense download` (search works without it, on words and links)');\n  }\n  // search gates on the same flag (see wantsVectors above); reading it here too keeps\n  // `semantic: false` meaning one thing. Without this, an overlapping semantic-on preset's\n  // vectors would answer for a scope that declined them.\n  if (!effective.semantic) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" sets \"semantic\": false, so this scope has no vectors and related has no other signal; search it instead (words and links), or set semantic back on for that preset`);\n  }\n  if (!modelPresent(cfg)) {\n    throw new SenseError('EMBED_MODEL_MISSING', 'related ranks notes by meaning, so it needs the embedding model, which is not downloaded; run `sense download` (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","allowed","prepare","all","map","r","resolveNote","dst","src","Set","resolveSearch","embedEnabled","SenseError","semantic","presetName","modelPresent","scopedPaths","embedPending","baseDir","hasEmbedding","scopeHasEmbeddings","similarNotes"],"mappings":";;;;+BAUsBA;;;eAAAA;;;uBARsB;wBACjB;uBAC4C;sBAC3C;uBACoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzC,SAAeA,aAAaC,EAAgB,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,SAA0B,EAAEC,CAAS;;YACxHC,OACAC,MAEAC,UACAC,WACAC,SAKAC,WAaAC;;;;oBAvBAN,QAAQ,AAACL,GAAGY,OAAO,CAAC,kCAAkCC,GAAG,GAA+BC,GAAG,CAAC,SAACC;+BAAMA,EAAET,IAAI;;oBACzGA,OAAOU,IAAAA,mBAAW,EAACX,OAAOH;oBAE1BK,WAAW,AAACP,GAAGY,OAAO,CAAC,oEAAoEC,GAAG,CAACP,MAAiCQ,GAAG,CAAC,SAACC;+BAAMA,EAAEE,GAAG;;oBAChJT,YAAY,AAACR,GAAGY,OAAO,CAAC,gDAAgDC,GAAG,CAACP,MAAiCQ,GAAG,CAAC,SAACC;+BAAMA,EAAEG,GAAG;;oBAC7HT,UAAU,IAAIU,IAAI;wBAACb;sBAAD,OAAO,qBAAGC,WAAU,qBAAGC;oBAE/C,yFAAyF;oBACzF,2FAA2F;oBAC3F,yDAAyD;oBACnDE,YAAYU,IAAAA,sBAAa,EAACnB,KAAKE;oBACrC,IAAI,CAACkB,IAAAA,qBAAY,EAACpB,MAAM;wBACtB,MAAM,IAAIqB,oBAAU,CAAC,kBAAkB;oBACzC;oBACA,oFAAoF;oBACpF,yFAAyF;oBACzF,uDAAuD;oBACvD,IAAI,CAACZ,UAAUa,QAAQ,EAAE;wBACvB,MAAM,IAAID,oBAAU,CAAC,uBAAuB,AAAC,WAA+B,OAArBZ,UAAUc,UAAU,EAAC;oBAC9E;oBACA,IAAI,CAACC,IAAAA,qBAAY,EAACxB,MAAM;wBACtB,MAAM,IAAIqB,oBAAU,CAAC,uBAAuB;oBAC9C;oBACMX,UAAUe,IAAAA,oBAAW,EAAC1B,IAAIC,KAAKE;oBACrC,oFAAoF;oBACpF,oDAAoD;oBACpD;;wBAAMwB,IAAAA,qBAAY,EAAC3B,IAAIC,KAAKA,IAAI2B,OAAO;;;oBAAvC;oBACA,IAAI,CAACC,IAAAA,qBAAY,EAAC7B,IAAIM,OAAO;wBAC3B,MAAM,IAAIgB,oBAAU,CAAC,qBAAqB,AAAC,GAAO,OAALhB,MAAK;oBACpD;oBACA,IAAI,CAACwB,IAAAA,2BAAkB,EAAC9B,IAAIC,KAAKU,UAAU;;;;oBAC3C;;wBAAOoB,IAAAA,qBAAY,EAAC/B,IAAIC,KAAKK,MAAM;4BAAEG,SAAAA;4BAASE,SAAAA;4BAASP,GAAAA;wBAAE;;;;IAC3D"}

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

@@ -0,0 +1,10 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ResolvedConfig, SearchOverrides } from '../config/index.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;

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

@@ -0,0 +1,10 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ResolvedConfig, SearchOverrides } from '../config/index.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;

package/dist/cjs/commands/scope.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get INTERNAL_COLUMNS () {
+        return INTERNAL_COLUMNS;
+    },
+    get inScope () {
+        return inScope;
+    },
+    get materializeScope () {
+        return materializeScope;
+    },
+    get narrowByWhere () {
+        return narrowByWhere;
+    },
+    get rawScope () {
+        return rawScope;
+    },
+    get scopeHasEmbeddings () {
+        return scopeHasEmbeddings;
+    },
+    get scopedPaths () {
+        return scopedPaths;
+    },
+    get setupMapScope () {
+        return setupMapScope;
+    }
+});
+var _nodepath = require("node:path");
+var _indexts = require("../config/index.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var INTERNAL_COLUMNS = new Set([
+    'path',
+    '_mtime',
+    '_ctime',
+    '_size',
+    '_rank',
+    '_parse_error'
+]);
+function inScope(path, include, exclude) {
+    if (!include.some(function(g) {
+        return (0, _nodepath.matchesGlob)(path, g);
+    })) return false;
+    if (exclude === null || exclude === void 0 ? void 0 : exclude.some(function(g) {
+        return (0, _nodepath.matchesGlob)(path, g);
+    })) 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 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 narrowByWhere(db, paths, where) {
+    if (!where) return paths;
+    var whereRows = db.prepare('SELECT "path" FROM frontmatter f WHERE ('.concat(where, ")")).all();
+    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);
+}
+/* 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

@@ -0,0 +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';\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  const whereRows = db.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`).all() as Array<{ path: string }>;\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","wherePaths","table","exec","run","JSON","stringify"],"mappings":";;;;;;;;;;;QAKaA;eAAAA;;QAKGC;eAAAA;;QAwCAC;eAAAA;;QAhBAC;eAAAA;;QATAC;eAAAA;;QATAC;eAAAA;;QA2BAC;eAAAA;;QAaAC;eAAAA;;;wBAxDY;uBAGmB;;;;;;;;;;;;;;;;;;;;;;;;;;AAExC,IAAMP,mBAAmB,IAAIQ,IAAI;IAAC;IAAQ;IAAU;IAAU;IAAS;IAAS;CAAe;AAK/F,SAASP,QAAQQ,IAAY,EAAEC,OAAiB,EAAEC,OAAkB;IACzE,IAAI,CAACD,QAAQE,IAAI,CAAC,SAACC;eAAMC,IAAAA,qBAAW,EAACL,MAAMI;QAAK,OAAO;IACvD,IAAIF,oBAAAA,8BAAAA,QAASC,IAAI,CAAC,SAACC;eAAMC,IAAAA,qBAAW,EAACL,MAAMI;QAAK,OAAO;IACvD,OAAO;AACT;AAEO,SAASR,mBAAmBU,EAAgB,EAAEC,GAAmB,EAAEV,WAAwB;IAChG,IAAI,CAACW,IAAAA,wBAAe,EAACD,MAAM,OAAO,OAAO,yDAAyD;IAClG,IAAME,OAAOH,GAAGI,OAAO,CAAC,0CAA0CC,GAAG;IACrE,OAAOF,KAAKN,IAAI,CAAC,SAACS;eAAMf,YAAYgB,GAAG,CAACD,EAAEZ,IAAI;;AAChD;AAKO,SAASL,SAASW,EAAgB,EAAEC,GAAmB,EAAEO,SAA0B,EAAEC,QAAmB;IAC7G,IAAMC,YAAYC,IAAAA,sBAAa,EAACV,KAAKO;IACrC,IAAQb,UAAqBe,UAArBf,SAASC,UAAYc,UAAZd;IACjB,IAAMgB,aAAaJ,UAAUb,OAAO,KAAKkB,aAAaL,UAAUZ,OAAO,KAAKiB,aAAaL,UAAUM,SAAS,KAAK;IACjH,IAAI,CAACF,YAAY,OAAO,IAAInB,IAAI,AAACO,GAAGI,OAAO,CAAC,oDAAoDC,GAAG,CAACK,UAAUK,UAAU,EAA8BC,GAAG,CAAC,SAACV;eAAMA,EAAEZ,IAAI;;IACvK,IAAMuB,QAAQR,qBAAAA,sBAAAA,WAAY,AAACT,GAAGI,OAAO,CAAC,kCAAkCC,GAAG,GAA+BW,GAAG,CAAC,SAACV;eAAMA,EAAEZ,IAAI;;IAC3H,OAAO,IAAID,IAAIwB,MAAMC,MAAM,CAAC,SAACC;eAAMjC,QAAQiC,GAAGxB,SAASC;;AACzD;AAEO,SAASR,cAAcY,EAAgB,EAAEiB,KAAkB,EAAEG,KAAyB;IAC3F,IAAI,CAACA,OAAO,OAAOH;IACnB,IAAMI,YAAYrB,GAAGI,OAAO,CAAC,AAAC,2CAAgD,OAANgB,OAAM,MAAIf,GAAG;IACrF,IAAMiB,aAAa,IAAI7B,IAAI4B,UAAUL,GAAG,CAAC,SAACV;eAAMA,EAAEZ,IAAI;;IACtD,OAAO,IAAID,IAAI,AAAC,qBAAGwB,OAAOC,MAAM,CAAC,SAACC;eAAMG,WAAWf,GAAG,CAACY;;AACzD;AAIO,SAAS5B,YAAYS,EAAgB,EAAEC,GAAmB,EAAEO,SAA0B;IAC3F,IAAME,YAAYC,IAAAA,sBAAa,EAACV,KAAKO;IACrC,OAAOpB,cAAcY,IAAIX,SAASW,IAAIC,KAAKO,YAAYE,UAAUU,KAAK;AACxE;AAIO,SAASjC,iBAAiBa,EAAgB,EAAEuB,KAAa,EAAEN,KAAkB;IAClFjB,GAAGwB,IAAI,CAAC,AAAC,wBAA6B,OAAND;IAChCvB,GAAGwB,IAAI,CAAC,AAAC,qBAA0B,OAAND,OAAM;IACnCvB,GAAGI,OAAO,CAAC,AAAC,eAAoB,OAANmB,OAAM,8CAA4CE,GAAG,CAACC,KAAKC,SAAS,CAAE,qBAAGV;AACrG;AAEO,SAASzB,cAAcQ,EAAgB,EAAEiB,KAAkB;IAChE9B,iBAAiBa,IAAI,cAAciB;AACrC"}

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

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

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

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