sensemaking 0.17.0 → 0.18.0

package/dist/cjs/embed/langfit.js

@@ -2,23 +2,15 @@
 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 checkLanguageFit () {
+Object.defineProperty(exports, "checkLanguageFit", {
+    enumerable: true,
+    get: function() {
         return checkLanguageFit;
-    },
-    get languageDistribution () {
-        return languageDistribution;
     }
 });
-var _francmin = require("franc-min");
-var _sharedts = require("../db/shared.js");
+var _nodemodule = /*#__PURE__*/ _interop_require_default(require("node:module"));
 var _errorsts = require("../errors.js");
+var _distributionts = require("./distribution.js");
 var _languagests = require("./languages.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -65,6 +57,11 @@ function _define_property(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -217,69 +214,82 @@ function _unsupported_iterable_to_array(o, minLen) {
     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 META_KEY = 'embed_languages';
 // franc's own reliability floor is a handful of characters; this is a cheap upper bound, not a
 // per-chunk minimum -- a short chunk is simply more likely to come back 'und' (unclassified).
 var SAMPLE_CHARS = 300;
 // A majority computed over a handful of chunks is noise, not a corpus signal; the decision rule
 // never fires below this many classified chunks, declared languages or not.
 var MIN_CLASSIFIED = 10;
-function languageDistribution(db) {
-    var raw = (0, _sharedts.getMeta)(db, META_KEY);
-    return raw ? JSON.parse(raw) : undefined;
-}
-function classify(text) {
-    var code = (0, _francmin.franc)(text.slice(0, SAMPLE_CHARS));
+// franc-min is a 148K static import; a top-level import put it on every command's module graph
+// regardless of whether the semantic path ran, shipped as the 0.17.0 regression. Deferred to a
+// synchronous require inside checkLanguageFit so only the embed path pays for it.
+var _require = typeof require === 'undefined' ? _nodemodule.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
+function classify(franc, text) {
+    var code = franc(text.slice(0, SAMPLE_CHARS));
     return code === 'und' ? undefined : code;
 }
-function checkLanguageFit(db, provider, texts) {
+function checkLanguageFit(store, provider, texts) {
     return _async_to_generator(function() {
-        var _languageDistribution, persisted, merged, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, text, _merged_code, code, total, declared, _Object_entries_sort_, majorityLang, majorityCount, pct;
+        var _ref, franc, persisted, merged, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, text, _merged_code, code, total, declared, _Object_entries_sort_, majorityLang, majorityCount, pct;
         return _ts_generator(this, function(_state) {
-            if (texts.length === 0) return [
-                2
-            ];
-            persisted = (_languageDistribution = languageDistribution(db)) !== null && _languageDistribution !== void 0 ? _languageDistribution : {};
-            merged = _object_spread({}, persisted);
-            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(_iterator = texts[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    text = _step.value;
-                    ;
-                    code = classify(text);
-                    if (code) merged[code] = ((_merged_code = merged[code]) !== null && _merged_code !== void 0 ? _merged_code : 0) + 1;
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
+            switch(_state.label){
+                case 0:
+                    if (texts.length === 0) return [
+                        2
+                    ];
+                    franc = _require('franc-min').franc;
+                    return [
+                        4,
+                        (0, _distributionts.languageDistribution)(store)
+                    ];
+                case 1:
+                    persisted = (_ref = _state.sent()) !== null && _ref !== void 0 ? _ref : {};
+                    merged = _object_spread({}, persisted);
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = texts[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            text = _step.value;
+                            ;
+                            code = classify(franc, text);
+                            if (code) merged[code] = ((_merged_code = merged[code]) !== null && _merged_code !== void 0 ? _merged_code : 0) + 1;
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
                     }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
+                    total = Object.values(merged).reduce(function(a, b) {
+                        return a + b;
+                    }, 0);
+                    if (provider.languages && provider.languages.length > 0 && total >= MIN_CLASSIFIED) {
+                        declared = new Set(provider.languages.map(_languagests.toIso3));
+                        _Object_entries_sort_ = _sliced_to_array(Object.entries(merged).sort(function(a, b) {
+                            return b[1] - a[1];
+                        })[0], 2), majorityLang = _Object_entries_sort_[0], majorityCount = _Object_entries_sort_[1];
+                        if (majorityCount / total >= 0.5 && !declared.has(majorityLang)) {
+                            pct = Math.round(majorityCount / total * 100);
+                            throw new _errorsts.SenseError('EMBED_MODEL_MISMATCH', "embed model ".concat(provider.id, " declares languages [").concat(provider.languages.join(', '), "], but ").concat(pct, "% of this tree's classified text is \"").concat(majorityLang, "\" (ISO 639-3), which is not among them; choose a model for this tree's languages: `sense init --model ...`, see the sense-setup skill or INTEGRATIONS.md"));
+                        }
                     }
-                }
-            }
-            total = Object.values(merged).reduce(function(a, b) {
-                return a + b;
-            }, 0);
-            if (provider.languages && provider.languages.length > 0 && total >= MIN_CLASSIFIED) {
-                declared = new Set(provider.languages.map(_languagests.toIso3));
-                _Object_entries_sort_ = _sliced_to_array(Object.entries(merged).sort(function(a, b) {
-                    return b[1] - a[1];
-                })[0], 2), majorityLang = _Object_entries_sort_[0], majorityCount = _Object_entries_sort_[1];
-                if (majorityCount / total >= 0.5 && !declared.has(majorityLang)) {
-                    pct = Math.round(majorityCount / total * 100);
-                    throw new _errorsts.SenseError('EMBED_MODEL_MISMATCH', "embed model ".concat(provider.id, " declares languages [").concat(provider.languages.join(', '), "], but ").concat(pct, "% of this tree's classified text is \"").concat(majorityLang, "\" (ISO 639-3), which is not among them; choose a model for this tree's languages: `sense init --model ...`, see the sense-setup skill or INTEGRATIONS.md"));
-                }
+                    return [
+                        4,
+                        (0, _distributionts.saveLanguageDistribution)(store, merged)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        2
+                    ];
             }
-            (0, _sharedts.setMeta)(db, META_KEY, JSON.stringify(merged));
-            return [
-                2
-            ];
         });
     })();
 }

package/dist/cjs/embed/langfit.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/langfit.ts"],"sourcesContent":["import type { DatabaseSync } from 'node:sqlite';\nimport { franc } from 'franc-min';\nimport { getMeta, setMeta } from '../db/shared.ts';\nimport { SenseError } from '../errors.ts';\nimport { toIso3 } from './languages.ts';\nimport type { EmbedProvider } from './types.ts';\n\nconst META_KEY = 'embed_languages';\n// franc's own reliability floor is a handful of characters; this is a cheap upper bound, not a\n// per-chunk minimum -- a short chunk is simply more likely to come back 'und' (unclassified).\nconst SAMPLE_CHARS = 300;\n// A majority computed over a handful of chunks is noise, not a corpus signal; the decision rule\n// never fires below this many classified chunks, declared languages or not.\nconst MIN_CLASSIFIED = 10;\n\ntype LangCounts = Record<string, number>;\n\nexport function languageDistribution(db: DatabaseSync): LangCounts | undefined {\n  const raw = getMeta(db, META_KEY);\n  return raw ? JSON.parse(raw) : undefined;\n}\n\nfunction classify(text: string): string | undefined {\n  const code = franc(text.slice(0, SAMPLE_CHARS));\n  return code === 'und' ? undefined : code;\n}\n\n// Merges chunk texts into the persisted distribution; throws (without persisting) if the model\n// declares languages and a clear majority classified so far is not among them.\nexport async function checkLanguageFit(db: DatabaseSync, provider: EmbedProvider, texts: string[]): Promise<void> {\n  if (texts.length === 0) return;\n  const persisted = languageDistribution(db) ?? {};\n  const merged = { ...persisted };\n  for (const text of texts) {\n    const code = classify(text);\n    if (code) merged[code] = (merged[code] ?? 0) + 1;\n  }\n\n  const total = Object.values(merged).reduce((a, b) => a + b, 0);\n  if (provider.languages && provider.languages.length > 0 && total >= MIN_CLASSIFIED) {\n    const declared = new Set(provider.languages.map(toIso3));\n    const [majorityLang, majorityCount] = Object.entries(merged).sort((a, b) => b[1] - a[1])[0];\n    if (majorityCount / total >= 0.5 && !declared.has(majorityLang)) {\n      const pct = Math.round((majorityCount / total) * 100);\n      throw new SenseError(\n        'EMBED_MODEL_MISMATCH',\n        `embed model ${provider.id} declares languages [${provider.languages.join(', ')}], but ${pct}% of this tree's classified text is \"${majorityLang}\" (ISO 639-3), which is not among them; choose a model for this tree's languages: \\`sense init --model ...\\`, see the sense-setup skill or INTEGRATIONS.md`\n      );\n    }\n  }\n  setMeta(db, META_KEY, JSON.stringify(merged));\n}\n"],"names":["checkLanguageFit","languageDistribution","META_KEY","SAMPLE_CHARS","MIN_CLASSIFIED","db","raw","getMeta","JSON","parse","undefined","classify","text","code","franc","slice","provider","texts","persisted","merged","total","declared","Object","majorityLang","majorityCount","pct","length","values","reduce","a","b","languages","Set","map","toIso3","entries","sort","has","Math","round","SenseError","id","join","setMeta","stringify"],"mappings":";;;;;;;;;;;QA6BsBA;eAAAA;;QAZNC;eAAAA;;;wBAhBM;wBACW;wBACN;2BACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,IAAMC,WAAW;AACjB,+FAA+F;AAC/F,8FAA8F;AAC9F,IAAMC,eAAe;AACrB,gGAAgG;AAChG,4EAA4E;AAC5E,IAAMC,iBAAiB;AAIhB,SAASH,qBAAqBI,EAAgB;IACnD,IAAMC,MAAMC,IAAAA,iBAAO,EAACF,IAAIH;IACxB,OAAOI,MAAME,KAAKC,KAAK,CAACH,OAAOI;AACjC;AAEA,SAASC,SAASC,IAAY;IAC5B,IAAMC,OAAOC,IAAAA,eAAK,EAACF,KAAKG,KAAK,CAAC,GAAGZ;IACjC,OAAOU,SAAS,QAAQH,YAAYG;AACtC;AAIO,SAAeb,iBAAiBK,EAAgB,EAAEW,QAAuB,EAAEC,KAAe;;YAE7EhB,uBAAZiB,WACAC,QACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMP,MAEiBO,cADpBN,MAIFO,OAEEC,UACgCC,uBAA/BC,cAAcC,eAEbC;;YAbV,IAAIR,MAAMS,MAAM,KAAK,GAAG;;;YAClBR,aAAYjB,wBAAAA,qBAAqBI,iBAArBJ,mCAAAA,wBAA4B,CAAC;YACzCkB,SAAS,mBAAKD;YACf,kCAAA,2BAAA;;gBAAL,IAAK,YAAcD,4BAAd,6BAAA,QAAA,yBAAA,iCAAqB;oBAAfL,OAAN;;oBACGC,OAAOF,SAASC;oBACtB,IAAIC,MAAMM,MAAM,CAACN,KAAK,GAAG,EAACM,eAAAA,MAAM,CAACN,KAAK,cAAZM,0BAAAA,eAAgB,KAAK;gBACjD;;gBAHK;gBAAA;;;yBAAA,6BAAA;wBAAA;;;wBAAA;8BAAA;;;;YAKCC,QAAQE,OAAOK,MAAM,CAACR,QAAQS,MAAM,CAAC,SAACC,GAAGC;uBAAMD,IAAIC;eAAG;YAC5D,IAAId,SAASe,SAAS,IAAIf,SAASe,SAAS,CAACL,MAAM,GAAG,KAAKN,SAAShB,gBAAgB;gBAC5EiB,WAAW,IAAIW,IAAIhB,SAASe,SAAS,CAACE,GAAG,CAACC,mBAAM;gBAChBZ,yCAAAA,OAAOa,OAAO,CAAChB,QAAQiB,IAAI,CAAC,SAACP,GAAGC;2BAAMA,CAAC,CAAC,EAAE,GAAGD,CAAC,CAAC,EAAE;kBAAC,CAAC,EAAE,MAApFN,eAA+BD,0BAAjBE,gBAAiBF;gBACtC,IAAIE,gBAAgBJ,SAAS,OAAO,CAACC,SAASgB,GAAG,CAACd,eAAe;oBACzDE,MAAMa,KAAKC,KAAK,CAAC,AAACf,gBAAgBJ,QAAS;oBACjD,MAAM,IAAIoB,oBAAU,CAClB,wBACA,AAAC,eAAiDxB,OAAnCA,SAASyB,EAAE,EAAC,yBAA8DhB,OAAvCT,SAASe,SAAS,CAACW,IAAI,CAAC,OAAM,WAAoDnB,OAA3CE,KAAI,0CAAoD,OAAbF,cAAa;gBAErJ;YACF;YACAoB,IAAAA,iBAAO,EAACtC,IAAIH,UAAUM,KAAKoC,SAAS,CAACzB;;;;;IACvC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/langfit.ts"],"sourcesContent":["import Module from 'node:module';\nimport { SenseError } from '../errors.ts';\nimport type { Store } from '../store/types.ts';\nimport { languageDistribution, saveLanguageDistribution } from './distribution.ts';\nimport { toIso3 } from './languages.ts';\nimport type { EmbedProvider } from './types.ts';\n\n// franc's own reliability floor is a handful of characters; this is a cheap upper bound, not a\n// per-chunk minimum -- a short chunk is simply more likely to come back 'und' (unclassified).\nconst SAMPLE_CHARS = 300;\n// A majority computed over a handful of chunks is noise, not a corpus signal; the decision rule\n// never fires below this many classified chunks, declared languages or not.\nconst MIN_CLASSIFIED = 10;\n\n// franc-min is a 148K static import; a top-level import put it on every command's module graph\n// regardless of whether the semantic path ran, shipped as the 0.17.0 regression. Deferred to a\n// synchronous require inside checkLanguageFit so only the embed path pays for it.\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\nfunction classify(franc: typeof import('franc-min')['franc'], text: string): string | undefined {\n  const code = franc(text.slice(0, SAMPLE_CHARS));\n  return code === 'und' ? undefined : code;\n}\n\n// Merges chunk texts into the persisted distribution; throws (without persisting) if the model\n// declares languages and a clear majority classified so far is not among them.\nexport async function checkLanguageFit(store: Store, provider: EmbedProvider, texts: string[]): Promise<void> {\n  if (texts.length === 0) return;\n  const { franc } = _require('franc-min') as typeof import('franc-min');\n  const persisted = (await languageDistribution(store)) ?? {};\n  const merged = { ...persisted };\n  for (const text of texts) {\n    const code = classify(franc, text);\n    if (code) merged[code] = (merged[code] ?? 0) + 1;\n  }\n\n  const total = Object.values(merged).reduce((a, b) => a + b, 0);\n  if (provider.languages && provider.languages.length > 0 && total >= MIN_CLASSIFIED) {\n    const declared = new Set(provider.languages.map(toIso3));\n    const [majorityLang, majorityCount] = Object.entries(merged).sort((a, b) => b[1] - a[1])[0];\n    if (majorityCount / total >= 0.5 && !declared.has(majorityLang)) {\n      const pct = Math.round((majorityCount / total) * 100);\n      throw new SenseError(\n        'EMBED_MODEL_MISMATCH',\n        `embed model ${provider.id} declares languages [${provider.languages.join(', ')}], but ${pct}% of this tree's classified text is \"${majorityLang}\" (ISO 639-3), which is not among them; choose a model for this tree's languages: \\`sense init --model ...\\`, see the sense-setup skill or INTEGRATIONS.md`\n      );\n    }\n  }\n  await saveLanguageDistribution(store, merged);\n}\n"],"names":["checkLanguageFit","SAMPLE_CHARS","MIN_CLASSIFIED","_require","require","Module","createRequire","classify","franc","text","code","slice","undefined","store","provider","texts","persisted","merged","total","declared","Object","majorityLang","majorityCount","pct","length","languageDistribution","values","reduce","a","b","languages","Set","map","toIso3","entries","sort","has","Math","round","SenseError","id","join","saveLanguageDistribution"],"mappings":";;;;+BA0BsBA;;;eAAAA;;;iEA1BH;wBACQ;8BAEoC;2BACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,+FAA+F;AAC/F,8FAA8F;AAC9F,IAAMC,eAAe;AACrB,gGAAgG;AAChG,4EAA4E;AAC5E,IAAMC,iBAAiB;AAEvB,+FAA+F;AAC/F,+FAA+F;AAC/F,kFAAkF;AAClF,IAAMC,WAAW,OAAOC,YAAY,cAAcC,mBAAM,CAACC,aAAa,CAAC,uDAAmBF;AAE1F,SAASG,SAASC,KAA0C,EAAEC,IAAY;IACxE,IAAMC,OAAOF,MAAMC,KAAKE,KAAK,CAAC,GAAGV;IACjC,OAAOS,SAAS,QAAQE,YAAYF;AACtC;AAIO,SAAeV,iBAAiBa,KAAY,EAAEC,QAAuB,EAAEC,KAAe;;YAGxE,MADXP,OACFQ,WACAC,QACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMR,MAEiBQ,cADpBP,MAIFQ,OAEEC,UACgCC,uBAA/BC,cAAcC,eAEbC;;;;oBAdV,IAAIR,MAAMS,MAAM,KAAK,GAAG;;;oBAChBhB,QAAUL,SAAS,aAAnBK;oBACW;;wBAAMiB,IAAAA,oCAAoB,EAACZ;;;oBAAxCG,aAAa,OAAA,2BAAA,kBAAA,OAAsC,CAAC;oBACpDC,SAAS,mBAAKD;oBACf,kCAAA,2BAAA;;wBAAL,IAAK,YAAcD,4BAAd,6BAAA,QAAA,yBAAA,iCAAqB;4BAAfN,OAAN;;4BACGC,OAAOH,SAASC,OAAOC;4BAC7B,IAAIC,MAAMO,MAAM,CAACP,KAAK,GAAG,EAACO,eAAAA,MAAM,CAACP,KAAK,cAAZO,0BAAAA,eAAgB,KAAK;wBACjD;;wBAHK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAKCC,QAAQE,OAAOM,MAAM,CAACT,QAAQU,MAAM,CAAC,SAACC,GAAGC;+BAAMD,IAAIC;uBAAG;oBAC5D,IAAIf,SAASgB,SAAS,IAAIhB,SAASgB,SAAS,CAACN,MAAM,GAAG,KAAKN,SAAShB,gBAAgB;wBAC5EiB,WAAW,IAAIY,IAAIjB,SAASgB,SAAS,CAACE,GAAG,CAACC,mBAAM;wBAChBb,yCAAAA,OAAOc,OAAO,CAACjB,QAAQkB,IAAI,CAAC,SAACP,GAAGC;mCAAMA,CAAC,CAAC,EAAE,GAAGD,CAAC,CAAC,EAAE;0BAAC,CAAC,EAAE,MAApFP,eAA+BD,0BAAjBE,gBAAiBF;wBACtC,IAAIE,gBAAgBJ,SAAS,OAAO,CAACC,SAASiB,GAAG,CAACf,eAAe;4BACzDE,MAAMc,KAAKC,KAAK,CAAC,AAAChB,gBAAgBJ,QAAS;4BACjD,MAAM,IAAIqB,oBAAU,CAClB,wBACA,AAAC,eAAiDzB,OAAnCA,SAAS0B,EAAE,EAAC,yBAA8DjB,OAAvCT,SAASgB,SAAS,CAACW,IAAI,CAAC,OAAM,WAAoDpB,OAA3CE,KAAI,0CAAoD,OAAbF,cAAa;wBAErJ;oBACF;oBACA;;wBAAMqB,IAAAA,wCAAwB,EAAC7B,OAAOI;;;oBAAtC;;;;;;IACF"}

package/dist/cjs/embed/query.d.cts

@@ -1,21 +1,14 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { Config } from '../config/index.js';
+import type { Store, VectorCandidate, VectorSimilar } from '../store/types.js';
 export declare function toStore(full: Float32Array, dims: number, int8: boolean): {
     v: Float32Array;
     scale: number;
 };
-export declare function embedPending(db: DatabaseSync, cfg: Config, baseDir: string): Promise<void>;
-export declare function semanticCandidates(db: DatabaseSync, cfg: Config, terms: string, fetch: number, allowed?: Set<string>): Promise<Array<{
-    path: string;
-    lines: string;
-    similarity: number;
-}>>;
-export declare function hasEmbedding(db: DatabaseSync, path: string): boolean;
-export declare function similarNotes(db: DatabaseSync, _cfg: Config, path: string, opts: {
+export declare function embedPending(store: Store, cfg: Config, baseDir: string): Promise<void>;
+export declare function semanticCandidates(store: Store, cfg: Config, terms: string, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
+export declare function hasEmbedding(store: Store, path: string): Promise<boolean>;
+export declare function similarNotes(store: Store, _cfg: Config, path: string, opts: {
     exclude: Set<string>;
     allowed?: Set<string>;
     k: number;
-}): Array<{
-    path: string;
-    similarity: number;
-}>;
+}): Promise<VectorSimilar[]>;

package/dist/cjs/embed/query.d.ts

@@ -1,21 +1,14 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { Config } from '../config/index.js';
+import type { Store, VectorCandidate, VectorSimilar } from '../store/types.js';
 export declare function toStore(full: Float32Array, dims: number, int8: boolean): {
     v: Float32Array;
     scale: number;
 };
-export declare function embedPending(db: DatabaseSync, cfg: Config, baseDir: string): Promise<void>;
-export declare function semanticCandidates(db: DatabaseSync, cfg: Config, terms: string, fetch: number, allowed?: Set<string>): Promise<Array<{
-    path: string;
-    lines: string;
-    similarity: number;
-}>>;
-export declare function hasEmbedding(db: DatabaseSync, path: string): boolean;
-export declare function similarNotes(db: DatabaseSync, _cfg: Config, path: string, opts: {
+export declare function embedPending(store: Store, cfg: Config, baseDir: string): Promise<void>;
+export declare function semanticCandidates(store: Store, cfg: Config, terms: string, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
+export declare function hasEmbedding(store: Store, path: string): Promise<boolean>;
+export declare function similarNotes(store: Store, _cfg: Config, path: string, opts: {
     exclude: Set<string>;
     allowed?: Set<string>;
     k: number;
-}): Array<{
-    path: string;
-    similarity: number;
-}>;
+}): Promise<VectorSimilar[]>;