sensemaking 0.27.1 → 0.28.0

package/bin/cli.js

@@ -1,12 +1,21 @@
 #!/usr/bin/env node
 
+const ERROR_CODE = 4;
+
 // exitCode (not exit()) lets Node flush queued stdout writes from the streaming sql path before
 // exiting; the unref'd timer only force-exits if a stray handle would otherwise hang the process.
+function handleError(err) {
+  console.error(err);
+  process.exitCode = ERROR_CODE;
+  setTimeout(() => process.exit(ERROR_CODE), 2000).unref();
+}
+
 // biome-ignore lint/security/noGlobalEval: dual esm and cjs
-if (typeof require === 'undefined') eval("import('../dist/esm/cli.js').then((cli) => cli.default(process.argv.slice(2), 'sense')).catch((err) => { console.error(err); process.exitCode = 1; setTimeout(() => process.exit(1), 2000).unref(); });");
-else
-  require('../dist/cjs/cli.js')(process.argv.slice(2), 'sense').catch((err) => {
-    console.error(err);
-    process.exitCode = 1;
-    setTimeout(() => process.exit(1), 2000).unref();
-  });
+if (typeof require === 'undefined') eval("import('../dist/esm/cli.js').then((cli) => cli.default(process.argv.slice(2), 'sense')).catch(handleError);");
+else {
+  try {
+    require('../dist/cjs/cli.js')(process.argv.slice(2), 'sense').catch(handleError);
+  } catch (err) {
+    handleError(err);
+  }
+}

package/dist/cjs/cli/constants.d.cts

@@ -0,0 +1,2 @@
+export declare const ERROR_CODE = 4;
+export declare const USAGE_CODE = 6;

package/dist/cjs/cli/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const ERROR_CODE = 4;
+export declare const USAGE_CODE = 6;

package/dist/cjs/cli/constants.js

@@ -0,0 +1,21 @@
+"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 ERROR_CODE () {
+        return ERROR_CODE;
+    },
+    get USAGE_CODE () {
+        return USAGE_CODE;
+    }
+});
+var ERROR_CODE = 4;
+var USAGE_CODE = 6;
+/* 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/cli/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/constants.ts"],"sourcesContent":["export const ERROR_CODE = 4;\nexport const USAGE_CODE = 6;\n"],"names":["ERROR_CODE","USAGE_CODE"],"mappings":";;;;;;;;;;;QAAaA;eAAAA;;QACAC;eAAAA;;;AADN,IAAMD,aAAa;AACnB,IAAMC,aAAa"}

package/dist/cjs/cli/named.js

@@ -15,6 +15,7 @@ var _searchts = require("../commands/search.js");
 var _indexts = require("../config/index.js");
 var _outputts = require("../output/output.js");
 var _opents = require("../store/open.js");
+var _constantsts = require("./constants.js");
 var _sharedts = require("./shared.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -186,7 +187,7 @@ function named(ctx, queryName) {
                     if (entry === undefined) {
                         console.error('unknown command or saved entry: "'.concat(queryName, '"'));
                         console.error("saved queries: ".concat(Object.keys(cfg.queries).sort().join(', ')));
-                        process.exit(2);
+                        process.exit(_constantsts.USAGE_CODE);
                     }
                     if (!('sql' in entry)) return [
                         3,

package/dist/cjs/cli/named.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { scopedPaths } from '../commands/scope.ts';\nimport { search } from '../commands/search.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, runSql, SEARCH_FLAGS, withResolvedDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a saved query, { sql } or { search }.\n// SEARCH_FLAGS override a saved search's fields the same way they override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json|csv] [--config path] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--no-build]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const format = rowFormatOf(values);\n  const configPath = values.config as string | undefined;\n  const noBuild = values['no-build'] === true;\n\n  const cfg = ctx.resolveConfig(configPath, { writeMigration: !noBuild, query: true });\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown command or saved entry: \"${queryName}\"`);\n    console.error(`saved queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(2);\n  }\n\n  if ('sql' in entry) {\n    // A saved statement written against `scope` is preset-agnostic, so the same entry can be\n    // re-pointed at another layer from the command line instead of being copied per preset.\n    await runSql(cfg, entry.sql, params, format, `query \"${queryName}\"`, noBuild, values.preset as string | undefined);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved search and takes no positional parameters; edit its \"search\" in sense.config.json, or use \"${ctx.name} search\" directly`);\n  }\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const snippetCharLimit = parseSnippetCharLimit(values['snippet-char-limit'] as string | undefined, ctx.usageError);\n  const snippetCountLimit = parseSnippetCountLimit(values['snippet-count-limit'] as string | undefined, ctx.usageError);\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? entry.include;\n  const exclude = (values.exclude as string[] | undefined) ?? entry.exclude;\n  const noExclude = values['no-exclude'] === true;\n  const overrides = { k, snippetCharLimit, snippetCountLimit, where, preset, include, exclude, noExclude };\n  await withResolvedDb(\n    cfg,\n    {\n      noBuild,\n      requirements: (resolvedCfg) => {\n        const signals = resolveSearch(resolvedCfg, overrides).signals;\n        const requirements = new Set<BuildRequirement>(['core']);\n        if (signals.words !== undefined) requirements.add('lexical');\n        return requirements;\n      },\n    },\n    async (store, resolvedCfg, build) => {\n      if (build && resolveSearch(resolvedCfg, overrides).signals.vectors !== undefined) {\n        await prepareDocumentEmbeddings(store, resolvedCfg, await scopedPaths(store, resolvedCfg, overrides));\n      }\n      printRows(await search(store, resolvedCfg, entry.search, overrides), format);\n    }\n  );\n}\n"],"names":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","noBuild","cfg","entry","k","snippetCharLimit","snippetCountLimit","where","preset","include","exclude","noExclude","overrides","name","argv","SEARCH_FLAGS","NO_BUILD","FORMAT","CONFIG","positionals","rowFormatOf","config","resolveConfig","writeMigration","query","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","sql","length","usageError","parseSnippetCharLimit","parseSnippetCountLimit","withResolvedDb","requirements","resolvedCfg","signals","resolveSearch","Set","words","add","store","build","vectors","scopedPaths","prepareDocumentEmbeddings","search","printRows"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { scopedPaths } from '../commands/scope.ts';\nimport { search } from '../commands/search.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { USAGE_CODE } from './constants.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, runSql, SEARCH_FLAGS, withResolvedDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a saved query, { sql } or { search }.\n// SEARCH_FLAGS override a saved search's fields the same way they override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json|csv] [--config path] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--no-build]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const format = rowFormatOf(values);\n  const configPath = values.config as string | undefined;\n  const noBuild = values['no-build'] === true;\n\n  const cfg = ctx.resolveConfig(configPath, { writeMigration: !noBuild, query: true });\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown command or saved entry: \"${queryName}\"`);\n    console.error(`saved queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(USAGE_CODE);\n  }\n\n  if ('sql' in entry) {\n    // A saved statement written against `scope` is preset-agnostic, so the same entry can be\n    // re-pointed at another layer from the command line instead of being copied per preset.\n    await runSql(cfg, entry.sql, params, format, `query \"${queryName}\"`, noBuild, values.preset as string | undefined);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved search and takes no positional parameters; edit its \"search\" in sense.config.json, or use \"${ctx.name} search\" directly`);\n  }\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const snippetCharLimit = parseSnippetCharLimit(values['snippet-char-limit'] as string | undefined, ctx.usageError);\n  const snippetCountLimit = parseSnippetCountLimit(values['snippet-count-limit'] as string | undefined, ctx.usageError);\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? entry.include;\n  const exclude = (values.exclude as string[] | undefined) ?? entry.exclude;\n  const noExclude = values['no-exclude'] === true;\n  const overrides = { k, snippetCharLimit, snippetCountLimit, where, preset, include, exclude, noExclude };\n  await withResolvedDb(\n    cfg,\n    {\n      noBuild,\n      requirements: (resolvedCfg) => {\n        const signals = resolveSearch(resolvedCfg, overrides).signals;\n        const requirements = new Set<BuildRequirement>(['core']);\n        if (signals.words !== undefined) requirements.add('lexical');\n        return requirements;\n      },\n    },\n    async (store, resolvedCfg, build) => {\n      if (build && resolveSearch(resolvedCfg, overrides).signals.vectors !== undefined) {\n        await prepareDocumentEmbeddings(store, resolvedCfg, await scopedPaths(store, resolvedCfg, overrides));\n      }\n      printRows(await search(store, resolvedCfg, entry.search, overrides), format);\n    }\n  );\n}\n"],"names":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","noBuild","cfg","entry","k","snippetCharLimit","snippetCountLimit","where","preset","include","exclude","noExclude","overrides","name","argv","SEARCH_FLAGS","NO_BUILD","FORMAT","CONFIG","positionals","rowFormatOf","config","resolveConfig","writeMigration","query","queries","undefined","console","error","Object","keys","sort","join","process","exit","USAGE_CODE","runSql","sql","length","usageError","parseSnippetCharLimit","parseSnippetCountLimit","withResolvedDb","requirements","resolvedCfg","signals","resolveSearch","Set","words","add","store","build","vectors","scopedPaths","prepareDocumentEmbeddings","search","printRows"],"mappings":";;;;+BASA,6FAA6F;AAC7F,uFAAuF;AACvF;;;eAA8BA;;;uBAXF;wBACL;uBACO;wBACJ;sBACuC;2BACtC;wBAC+H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAK3I,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB;;YA0BnDC,SAGKC,eACCA,gBACCA,iBACAA,iBA/BXC,OACkCC,QAAhCF,QAAqBG,QACvBC,QACAC,YACAC,SAEAC,KACAC,OAkBAC,GACAC,kBACAC,mBACAC,OACAC,QACAC,SACAC,SACAC,WACAC;;;;oBAjCAhB,QAAQ,AAAC,UAAqBH,OAAZD,IAAIqB,IAAI,EAAC,KAAa,OAAVpB,WAAU;oBACNI,SAAAA,IAAAA,eAAK,EAACL,IAAIsB,IAAI,EAAElB,OAAO,mBAAKmB,sBAAY,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM,IAA3GvB,SAAgCE,OAAhCF,QAAqBG,SAAWD,OAAxBsB;oBACVpB,SAASqB,IAAAA,qBAAW,EAACzB;oBACrBK,aAAaL,OAAO0B,MAAM;oBAC1BpB,UAAUN,MAAM,CAAC,WAAW,KAAK;oBAEjCO,MAAMV,IAAI8B,aAAa,CAACtB,YAAY;wBAAEuB,gBAAgB,CAACtB;wBAASuB,OAAO;oBAAK;oBAC5ErB,QAAQD,IAAIuB,OAAO,CAAChC,UAAU;oBACpC,IAAIU,UAAUuB,WAAW;wBACvBC,QAAQC,KAAK,CAAC,AAAC,oCAA6C,OAAVnC,WAAU;wBAC5DkC,QAAQC,KAAK,CAAC,AAAC,kBAA4D,OAA3CC,OAAOC,IAAI,CAAC5B,IAAIuB,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC;wBACrEC,QAAQC,IAAI,CAACC,uBAAU;oBACzB;yBAEI,CAAA,SAAShC,KAAI,GAAb;;;;oBACF,yFAAyF;oBACzF,wFAAwF;oBACxF;;wBAAMiC,IAAAA,gBAAM,EAAClC,KAAKC,MAAMkC,GAAG,EAAEvC,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU,MAAIQ,SAASN,OAAOa,MAAM;;;oBAA3F;oBACA;;;;oBAGF,uFAAuF;oBACvF,IAAIV,OAAOwC,MAAM,GAAG,GAAG;wBACrB9C,IAAI+C,UAAU,CAAC,AAAC,IAAuH/C,OAApHC,WAAU,4GAAmH,OAATD,IAAIqB,IAAI,EAAC;oBAClJ;oBACMT,KAAIV,UAAAA,IAAAA,gBAAM,EAACC,OAAOS,CAAC,EAAwBZ,IAAI+C,UAAU,eAArD7C,qBAAAA,UAA0DS,MAAMC,CAAC;oBACrEC,mBAAmBmC,IAAAA,+BAAqB,EAAC7C,MAAM,CAAC,qBAAqB,EAAwBH,IAAI+C,UAAU;oBAC3GjC,oBAAoBmC,IAAAA,gCAAsB,EAAC9C,MAAM,CAAC,sBAAsB,EAAwBH,IAAI+C,UAAU;oBAC9GhC,SAASZ,gBAAAA,OAAOY,KAAK,cAAZZ,2BAAAA,gBAAuCQ,MAAMI,KAAK;oBAC3DC,UAAUb,iBAAAA,OAAOa,MAAM,cAAbb,4BAAAA,iBAAwCQ,MAAMK,MAAM;oBAC9DC,WAAWd,kBAAAA,OAAOc,OAAO,cAAdd,6BAAAA,kBAA2CQ,MAAMM,OAAO;oBACnEC,WAAWf,kBAAAA,OAAOe,OAAO,cAAdf,6BAAAA,kBAA2CQ,MAAMO,OAAO;oBACnEC,YAAYhB,MAAM,CAAC,aAAa,KAAK;oBACrCiB,YAAY;wBAAER,GAAAA;wBAAGC,kBAAAA;wBAAkBC,mBAAAA;wBAAmBC,OAAAA;wBAAOC,QAAAA;wBAAQC,SAAAA;wBAASC,SAAAA;wBAASC,WAAAA;oBAAU;oBACvG;;wBAAM+B,IAAAA,wBAAc,EAClBxC,KACA;4BACED,SAAAA;4BACA0C,cAAc,SAAdA,aAAeC;gCACb,IAAMC,UAAUC,IAAAA,sBAAa,EAACF,aAAahC,WAAWiC,OAAO;gCAC7D,IAAMF,eAAe,IAAII,IAAsB;oCAAC;iCAAO;gCACvD,IAAIF,QAAQG,KAAK,KAAKtB,WAAWiB,aAAaM,GAAG,CAAC;gCAClD,OAAON;4BACT;wBACF,GACA,SAAOO,OAAON,aAAaO;;;;;;iDACrBA,CAAAA,SAASL,IAAAA,sBAAa,EAACF,aAAahC,WAAWiC,OAAO,CAACO,OAAO,KAAK1B,SAAQ,GAA3EyB;;;;;gDAC8BD;gDAAON;;4CAAa;;gDAAMS,IAAAA,oBAAW,EAACH,OAAON,aAAahC;;;4CAA1F;;gDAAM0C,iCAAyB;oDAAqB;;;;4CAApD;;;4CAEQ;;gDAAMC,IAAAA,gBAAM,EAACL,OAAON,aAAazC,MAAMoD,MAAM,EAAE3C;;;4CAAzD4C,mBAAS;gDAAC;gDAA2DzD;;;;;;;4BACvE;;;;oBAhBF;;;;;;IAkBF"}

package/dist/cjs/cli/shared.js

@@ -64,6 +64,7 @@ var _columnhintts = require("../output/column-hint.js");
 var _outputts = require("../output/output.js");
 var _searcherrorts = require("../output/search-error.js");
 var _indexts1 = require("../store/index.js");
+var _constantsts = require("./constants.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];
@@ -330,7 +331,7 @@ function pickFormat(values, allowed) {
     var format = String(values.format);
     if (allowed.includes(format)) return format;
     console.error('unknown --format "'.concat(format, '"; expected ').concat(allowed.join(', ')));
-    process.exit(2);
+    process.exit(_constantsts.USAGE_CODE);
 }
 function formatOf(values) {
     return pickFormat(values, [
@@ -365,7 +366,7 @@ function parse(argv, usage, options) {
     } catch (err) {
         console.error(err.message);
         console.error(usage);
-        process.exit(2);
+        process.exit(_constantsts.USAGE_CODE);
     }
     if (values.help) {
         console.log(usage);
@@ -534,14 +535,14 @@ function runSql(cfg, sql, params, format, label, noBuild, preset) {
                     placeholderCount = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
                     if (params.length !== placeholderCount) {
                         console.error("".concat(label, " expects ").concat(placeholderCount, " parameter(s), got ").concat(params.length));
-                        process.exit(2);
+                        process.exit(_constantsts.USAGE_CODE);
                     }
                     // Naming a preset and never joining it would return the whole index while reading as scoped,
                     // which is the one hazard of binding rather than applying. Refuse instead.
                     if (preset !== undefined && !/\bscope\b/i.test(sql)) {
                         console.error('--preset binds a temporary "scope" table of the preset\'s paths, and '.concat(label, " never joins it, so the preset would have no effect"));
                         console.error('add: JOIN scope ON scope."path" = <table>."path"');
-                        process.exit(2);
+                        process.exit(_constantsts.USAGE_CODE);
                     }
                     return [
                         4,

package/dist/cjs/cli/shared.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolvePreset } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Row, RowFormat } from '../output/output.ts';\nimport { printRowStream } from '../output/output.ts';\nimport { searchError } from '../output/search-error.ts';\nimport { openStoreFor } from '../store/index.ts';\nimport type { BuildRequirement, OpenResult } from '../store/open.ts';\nimport type { Store } from '../store/types.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\nexport const NO_BUILD: ParseArgsOptionsConfig = { 'no-build': { type: 'boolean', default: false } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' }, 'snippet-char-limit': { type: 'string' }, 'snippet-count-limit': { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down.\n// One place to read them: a new scope field is added to the fragment and here, not per-command.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\n// parseArgs is strict about flag names; this applies the same strictness to the value.\n// An unrecognised --format is a usage error, not a silent fallback to `table`.\nfunction pickFormat<T extends string>(values: Values, allowed: readonly T[]): T {\n  const format = String(values.format);\n  if ((allowed as readonly string[]).includes(format)) return format as T;\n  console.error(`unknown --format \"${format}\"; expected ${allowed.join(', ')}`);\n  process.exit(2);\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return pickFormat(values, ['table', 'json'] as const);\n}\n\n// csv is a row set rendered as rows; map, peek, status, and path render structures instead,\n// and take formatOf.\nexport function rowFormatOf(values: Values): RowFormat {\n  return pickFormat(values, ['table', 'json', 'csv'] as const);\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as \"nothing\", and parseInt would silently truncate \"5.9\".\n// All three are caller mistakes worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Same positive-integer rule as --k, beside it since both flags come from SEARCH_FLAGS.\nexport function parseSnippetCharLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-char-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\nexport function parseSnippetCountLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-count-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport interface DbOpenOptions {\n  noBuild: boolean;\n  requirements: ReadonlySet<BuildRequirement> | ((cfg: ResolvedConfig) => ReadonlySet<BuildRequirement>);\n}\n\nexport async function withResolvedDb(cfg: ResolvedConfig, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void> {\n  const requirements = typeof options.requirements === 'function' ? options.requirements(cfg) : options.requirements;\n  const build = !options.noBuild && cfg.build !== false;\n  const { store, warnings } = await openStoreFor(cfg, {\n    build,\n    requirements,\n  });\n  printWarnings(warnings);\n  try {\n    await fn(store, cfg, build);\n  } finally {\n    await store.close();\n  }\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath, { writeMigration: !options.noBuild, query: true });\n  return withResolvedDb(cfg, options, fn);\n}\n\n// `--preset` on SQL binds a temp `scope` table rather than transparently filtering: temp views shadowing the base tables can't cover `content`, since FTS5 MATCH treats the table name as a hidden column.\n// A flag that silently scoped three tables of four would look scoped and not be.\nasync function bindScope(store: Store, cfg: ResolvedConfig, preset: string): Promise<void> {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  await store.exec('DROP TABLE IF EXISTS temp.scope');\n  await store.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  const insert = await store.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?');\n  await insert.run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport async function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, noBuild: boolean, preset?: string): Promise<void> {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(2);\n  }\n  await withResolvedDb(cfg, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store) => {\n    if (preset !== undefined) await bindScope(store, cfg, preset);\n    // Streamed, not collected: `sql`'s result size is the caller's business, not ours. columns() reads the statement's own metadata, so a 0-row csv gets a header too.\n    // A mid-stream SQLite error (e.g. SQLITE_BUSY outlasting busy_timeout) may leave partial output; the nonzero exit code is the failure signal, not a completeness guarantee.\n    try {\n      const statement = await store.raw.prepare(sql);\n      const columns = statement.columns().map((c) => c.name);\n      await printRowStream(statement.iterate(...params) as AsyncIterable<Row>, format, columns);\n    } catch (err) {\n      const hinted = columnHint(await store.docs.columns(), err as Error); // columns read while the store is still open\n      // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5 punctuation trap applies to its bound parameters.\n      // SQL without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n      if (/\\bMATCH\\b/i.test(sql)) throw searchError(hinted, params.join(' '));\n      throw hinted;\n    }\n  });\n}\n"],"names":["CONFIG","FORMAT","NO_BUILD","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","parseSnippetCharLimit","parseSnippetCountLimit","printWarnings","rowFormatOf","runSql","scopeOf","withDb","withResolvedDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","pickFormat","allowed","String","includes","console","error","join","process","exit","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","message","log","usageError","undefined","parsed","Number","isInteger","value","warnings","w","warn","cfg","fn","requirements","build","store","noBuild","openStoreFor","close","ctx","configPath","resolveConfig","writeMigration","query","bindScope","name","insert","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","match","length","test","Set","statement","columns","hinted","raw","map","c","printRowStream","iterate","docs","columnHint","searchError"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolvePreset } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Row, RowFormat } from '../output/output.ts';\nimport { printRowStream } from '../output/output.ts';\nimport { searchError } from '../output/search-error.ts';\nimport { openStoreFor } from '../store/index.ts';\nimport type { BuildRequirement, OpenResult } from '../store/open.ts';\nimport type { Store } from '../store/types.ts';\nimport { USAGE_CODE } from './constants.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\nexport const NO_BUILD: ParseArgsOptionsConfig = { 'no-build': { type: 'boolean', default: false } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' }, 'snippet-char-limit': { type: 'string' }, 'snippet-count-limit': { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down.\n// One place to read them: a new scope field is added to the fragment and here, not per-command.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\n// parseArgs is strict about flag names; this applies the same strictness to the value.\n// An unrecognised --format is a usage error, not a silent fallback to `table`.\nfunction pickFormat<T extends string>(values: Values, allowed: readonly T[]): T {\n  const format = String(values.format);\n  if ((allowed as readonly string[]).includes(format)) return format as T;\n  console.error(`unknown --format \"${format}\"; expected ${allowed.join(', ')}`);\n  process.exit(USAGE_CODE);\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return pickFormat(values, ['table', 'json'] as const);\n}\n\n// csv is a row set rendered as rows; map, peek, status, and path render structures instead,\n// and take formatOf.\nexport function rowFormatOf(values: Values): RowFormat {\n  return pickFormat(values, ['table', 'json', 'csv'] as const);\n}\n\n// Per-command parseArgs rejects foreign flags as usage errors; every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(USAGE_CODE);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as \"nothing\", and parseInt would silently truncate \"5.9\".\n// All three are caller mistakes worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Same positive-integer rule as --k, beside it since both flags come from SEARCH_FLAGS.\nexport function parseSnippetCharLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-char-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\nexport function parseSnippetCountLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-count-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport interface DbOpenOptions {\n  noBuild: boolean;\n  requirements: ReadonlySet<BuildRequirement> | ((cfg: ResolvedConfig) => ReadonlySet<BuildRequirement>);\n}\n\nexport async function withResolvedDb(cfg: ResolvedConfig, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void> {\n  const requirements = typeof options.requirements === 'function' ? options.requirements(cfg) : options.requirements;\n  const build = !options.noBuild && cfg.build !== false;\n  const { store, warnings } = await openStoreFor(cfg, {\n    build,\n    requirements,\n  });\n  printWarnings(warnings);\n  try {\n    await fn(store, cfg, build);\n  } finally {\n    await store.close();\n  }\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath, { writeMigration: !options.noBuild, query: true });\n  return withResolvedDb(cfg, options, fn);\n}\n\n// `--preset` on SQL binds a temp `scope` table rather than transparently filtering: temp views shadowing the base tables can't cover `content`, since FTS5 MATCH treats the table name as a hidden column.\n// A flag that silently scoped three tables of four would look scoped and not be.\nasync function bindScope(store: Store, cfg: ResolvedConfig, preset: string): Promise<void> {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  await store.exec('DROP TABLE IF EXISTS temp.scope');\n  await store.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  const insert = await store.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?');\n  await insert.run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport async function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, noBuild: boolean, preset?: string): Promise<void> {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(USAGE_CODE);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(USAGE_CODE);\n  }\n  await withResolvedDb(cfg, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store) => {\n    if (preset !== undefined) await bindScope(store, cfg, preset);\n    // Streamed, not collected: `sql`'s result size is the caller's business, not ours. columns() reads the statement's own metadata, so a 0-row csv gets a header too.\n    // A mid-stream SQLite error (e.g. SQLITE_BUSY outlasting busy_timeout) may leave partial output; the nonzero exit code is the failure signal, not a completeness guarantee.\n    try {\n      const statement = await store.raw.prepare(sql);\n      const columns = statement.columns().map((c) => c.name);\n      await printRowStream(statement.iterate(...params) as AsyncIterable<Row>, format, columns);\n    } catch (err) {\n      const hinted = columnHint(await store.docs.columns(), err as Error); // columns read while the store is still open\n      // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5 punctuation trap applies to its bound parameters.\n      // SQL without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n      if (/\\bMATCH\\b/i.test(sql)) throw searchError(hinted, params.join(' '));\n      throw hinted;\n    }\n  });\n}\n"],"names":["CONFIG","FORMAT","NO_BUILD","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","parseSnippetCharLimit","parseSnippetCountLimit","printWarnings","rowFormatOf","runSql","scopeOf","withDb","withResolvedDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","pickFormat","allowed","String","includes","console","error","join","process","exit","USAGE_CODE","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","message","log","usageError","undefined","parsed","Number","isInteger","value","warnings","w","warn","cfg","fn","requirements","build","store","noBuild","openStoreFor","close","ctx","configPath","resolveConfig","writeMigration","query","bindScope","name","insert","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","match","length","test","Set","statement","columns","hinted","raw","map","c","printRowStream","iterate","docs","columnHint","searchError"],"mappings":"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"}

package/dist/cjs/cli.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, // Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.
+Object.defineProperty(exports, // Thrown errors exit with ERROR_CODE and the message verbatim; usage errors exit with USAGE_CODE.
 "default", {
     enumerable: true,
     get: function() {
@@ -11,6 +11,7 @@ Object.defineProperty(exports, // Thrown errors -> exit 1 with the message verba
 });
 var _nodemodule = require("node:module");
 var _nodeutil = require("node:util");
+var _constantsts = require("./cli/constants.js");
 var _indexts = require("./cli/index.js");
 var _indexts1 = require("./config/index.js");
 function _array_like_to_array(arr, len) {
@@ -251,7 +252,7 @@ function cli(argv, name) {
                     process.stdout.on('error', function(err) {
                         if (err.code === 'EPIPE') return;
                         console.error("sense: ".concat(err.message));
-                        process.exitCode = 1;
+                        process.exitCode = _constantsts.ERROR_CODE;
                     });
                     first = argv[0];
                     // No command word, or the first token looks like a flag: the only flags this level knows.
@@ -284,7 +285,7 @@ function cli(argv, name) {
                         } catch (err) {
                             console.error(err.message);
                             console.error(usage(name));
-                            process.exit(2);
+                            process.exit(_constantsts.USAGE_CODE);
                         }
                         try {
                             if (values.version) {
@@ -329,12 +330,12 @@ function cli(argv, name) {
                             }
                         } catch (err) {
                             console.error(err.message);
-                            process.exit(1);
+                            process.exit(_constantsts.ERROR_CODE);
                         }
                         console.error(usage(name));
-                        process.exit(2);
+                        process.exit(_constantsts.USAGE_CODE);
                     }
-                    // Breaking renames get one release of a pointer instead of an "unknown" error: find ->
+                    // Renamed verbs get a pointer to their current name instead of the unknown-entry error: find ->
                     // search, and query -> sql (which took its name back from the search sense of "query").
                     RENAMED = {
                         find: 'search',
@@ -343,7 +344,7 @@ function cli(argv, name) {
                     if (RENAMED[first]) {
                         console.error("".concat(name, ": ").concat(first, " is now ").concat(RENAMED[first]));
                         console.error(usage(name));
-                        process.exit(2);
+                        process.exit(_constantsts.USAGE_CODE);
                     }
                     ctx = {
                         name: name,
@@ -353,7 +354,7 @@ function cli(argv, name) {
                         },
                         usageError: function usageError(message) {
                             console.error(message);
-                            process.exit(2);
+                            process.exit(_constantsts.USAGE_CODE);
                         }
                     };
                     _state.label = 1;
@@ -407,7 +408,7 @@ function cli(argv, name) {
                 case 8:
                     err = _state.sent();
                     console.error(err.message);
-                    process.exit(1);
+                    process.exit(_constantsts.ERROR_CODE);
                     return [
                         3,
                         9

package/dist/cjs/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS, USAGE } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport type { LoadConfigOptions } from './config/index.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config/index.ts';\n\n// Parsing and dispatch only; commands lazy-load from src/cli/, so nothing heavy is imported\n// here. Flags parse per command -- this file handles only --version/--help/--list/--config.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  const lines = Object.values(USAGE).map((u) => `       ${name} ${u}`);\n  return [`usage: ${name} <name> [params...] [--format table|json|csv] [--config path]`, ...lines, `       ${name} --list`, `       ${name} --version`].join('\\n');\n}\n\nfunction resolveConfigFor(name: string, configPath: string | undefined, options: LoadConfigOptions & { query?: boolean } = {}) {\n  // Read the query policy before allowing a migration to write configuration state.\n  let cfg = loadConfig(configPath, options.query ? { writeMigration: false } : options);\n  const writeMigration = options.writeMigration !== false && (!options.query || cfg.build !== false);\n  if (options.query && writeMigration && cfg.migratedFrom !== undefined) cfg = loadConfig(configPath);\n  if (cfg.migratedFrom !== undefined) {\n    console.warn(\n      !writeMigration\n        ? `${name}: ${cfg.configPath} needs migration from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}; using the migrated form in memory only (run ${name} build to update the file)`\n        : `${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`\n    );\n  }\n  if (cfg.unknownKeys !== undefined) {\n    console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n  }\n  return cfg;\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  // A closed pipe reader's EPIPE arrives async, after the write loop returns: console.log absorbs it, process.stdout.write (streaming formats) does not, so an unhandled listener kills the process.\n  // A throw here is uncaught (async); process.exit() would skip `sense watch`'s cleanup, leaving a heartbeat behind that makes a dead watcher look alive.\n  process.stdout.on('error', (err: NodeJS.ErrnoException) => {\n    if (err.code === 'EPIPE') return;\n    console.error(`sense: ${err.message}`);\n    process.exitCode = 1;\n  });\n\n  const first = argv[0];\n\n  // No command word, or the first token looks like a flag: the only flags this level knows.\n  if (!first || first.startsWith('-')) {\n    let values: Record<string, string | boolean | undefined>;\n    try {\n      ({ values } = parseArgs({\n        args: argv,\n        options: {\n          version: { type: 'boolean', default: false, short: 'v' },\n          help: { type: 'boolean', default: false, short: 'h' },\n          list: { type: 'boolean', default: false },\n          config: { type: 'string' },\n        },\n        allowPositionals: true,\n      }));\n    } catch (err) {\n      console.error((err as Error).message);\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    try {\n      if (values.version) {\n        console.log(packageVersion());\n        return;\n      }\n      if (values.help) {\n        console.log(usage(name));\n        return;\n      }\n      if (values.list) {\n        const queries = resolveConfigFor(name, values.config as string | undefined).queries;\n        for (const queryName of Object.keys(queries).sort()) {\n          // Every entry names its verb, so --list can label both kinds rather than only\n          // marking the exception.\n          console.log(`${queryName}  (${'search' in queries[queryName] ? 'search' : 'sql'})`);\n        }\n        return;\n      }\n    } catch (err) {\n      console.error((err as Error).message);\n      process.exit(1);\n    }\n\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  // Breaking renames get one release of a pointer instead of an \"unknown\" error: find ->\n  // search, and query -> sql (which took its name back from the search sense of \"query\").\n  const RENAMED: Record<string, string> = { find: 'search', query: 'sql' };\n  if (RENAMED[first]) {\n    console.error(`${name}: ${first} is now ${RENAMED[first]}`);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  const ctx: Ctx = {\n    name,\n    argv: argv.slice(1),\n    resolveConfig: (configPath, options) => resolveConfigFor(name, configPath, options),\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","lines","Object","values","USAGE","map","u","join","resolveConfigFor","configPath","options","cfg","loadConfig","query","writeMigration","build","migratedFrom","undefined","console","warn","SUPPORTED_CONFIG_VERSION","unknownKeys","argv","first","queries","queryName","RENAMED","ctx","err","process","stdout","on","code","error","message","exitCode","startsWith","parseArgs","args","type","default","short","help","list","config","allowPositionals","exit","log","keys","sort","find","slice","resolveConfig","usageError","COMMANDS"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { ERROR_CODE, USAGE_CODE } from './cli/constants.ts';\nimport { COMMANDS, USAGE } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport type { LoadConfigOptions } from './config/index.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config/index.ts';\n\n// Parsing and dispatch only; commands lazy-load from src/cli/, so nothing heavy is imported\n// here. Flags parse per command -- this file handles only --version/--help/--list/--config.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  const lines = Object.values(USAGE).map((u) => `       ${name} ${u}`);\n  return [`usage: ${name} <name> [params...] [--format table|json|csv] [--config path]`, ...lines, `       ${name} --list`, `       ${name} --version`].join('\\n');\n}\n\nfunction resolveConfigFor(name: string, configPath: string | undefined, options: LoadConfigOptions & { query?: boolean } = {}) {\n  // Read the query policy before allowing a migration to write configuration state.\n  let cfg = loadConfig(configPath, options.query ? { writeMigration: false } : options);\n  const writeMigration = options.writeMigration !== false && (!options.query || cfg.build !== false);\n  if (options.query && writeMigration && cfg.migratedFrom !== undefined) cfg = loadConfig(configPath);\n  if (cfg.migratedFrom !== undefined) {\n    console.warn(\n      !writeMigration\n        ? `${name}: ${cfg.configPath} needs migration from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}; using the migrated form in memory only (run ${name} build to update the file)`\n        : `${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`\n    );\n  }\n  if (cfg.unknownKeys !== undefined) {\n    console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n  }\n  return cfg;\n}\n\n// Thrown errors exit with ERROR_CODE and the message verbatim; usage errors exit with USAGE_CODE.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  // A closed pipe reader's EPIPE arrives async, after the write loop returns: console.log absorbs it, process.stdout.write (streaming formats) does not, so an unhandled listener kills the process.\n  // A throw here is uncaught (async); process.exit() would skip `sense watch`'s cleanup, leaving a heartbeat behind that makes a dead watcher look alive.\n  process.stdout.on('error', (err: NodeJS.ErrnoException) => {\n    if (err.code === 'EPIPE') return;\n    console.error(`sense: ${err.message}`);\n    process.exitCode = ERROR_CODE;\n  });\n\n  const first = argv[0];\n\n  // No command word, or the first token looks like a flag: the only flags this level knows.\n  if (!first || first.startsWith('-')) {\n    let values: Record<string, string | boolean | undefined>;\n    try {\n      ({ values } = parseArgs({\n        args: argv,\n        options: {\n          version: { type: 'boolean', default: false, short: 'v' },\n          help: { type: 'boolean', default: false, short: 'h' },\n          list: { type: 'boolean', default: false },\n          config: { type: 'string' },\n        },\n        allowPositionals: true,\n      }));\n    } catch (err) {\n      console.error((err as Error).message);\n      console.error(usage(name));\n      process.exit(USAGE_CODE);\n    }\n\n    try {\n      if (values.version) {\n        console.log(packageVersion());\n        return;\n      }\n      if (values.help) {\n        console.log(usage(name));\n        return;\n      }\n      if (values.list) {\n        const queries = resolveConfigFor(name, values.config as string | undefined).queries;\n        for (const queryName of Object.keys(queries).sort()) {\n          // Every entry names its verb, so --list can label both kinds rather than only\n          // marking the exception.\n          console.log(`${queryName}  (${'search' in queries[queryName] ? 'search' : 'sql'})`);\n        }\n        return;\n      }\n    } catch (err) {\n      console.error((err as Error).message);\n      process.exit(ERROR_CODE);\n    }\n\n    console.error(usage(name));\n    process.exit(USAGE_CODE);\n  }\n\n  // Renamed verbs get a pointer to their current name instead of the unknown-entry error: find ->\n  // search, and query -> sql (which took its name back from the search sense of \"query\").\n  const RENAMED: Record<string, string> = { find: 'search', query: 'sql' };\n  if (RENAMED[first]) {\n    console.error(`${name}: ${first} is now ${RENAMED[first]}`);\n    console.error(usage(name));\n    process.exit(USAGE_CODE);\n  }\n\n  const ctx: Ctx = {\n    name,\n    argv: argv.slice(1),\n    resolveConfig: (configPath, options) => resolveConfigFor(name, configPath, options),\n    usageError(message) {\n      console.error(message);\n      process.exit(USAGE_CODE);\n    },\n  };\n\n  try {\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(ERROR_CODE);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","lines","Object","values","USAGE","map","u","join","resolveConfigFor","configPath","options","cfg","loadConfig","query","writeMigration","build","migratedFrom","undefined","console","warn","SUPPORTED_CONFIG_VERSION","unknownKeys","argv","first","queries","queryName","RENAMED","ctx","err","process","stdout","on","code","error","message","exitCode","ERROR_CODE","startsWith","parseArgs","args","type","default","short","help","list","config","allowPositionals","exit","USAGE_CODE","log","keys","sort","find","slice","resolveConfig","usageError","COMMANDS"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/embed/query.ts"],"sourcesContent":["import { type Config, featureSignature, type ResolvedConfig } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport type { Chunk } from '../features/embed.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { progress } from '../output/progress.ts';\nimport { parseSource } from '../scan/index.ts';\nimport { FEATURE_SIGNATURE_META_KEY } from '../store/readiness.ts';\nimport { getMeta } from '../store/shared.ts';\nimport { embeddingSignatureCompatible } from '../store/signature.ts';\nimport type { Store, VectorCandidate, VectorSimilar } from '../store/types.ts';\nimport { identifyChunkText, takeChunkText } from './handoff.ts';\nimport { checkLanguageFit } from './langfit.ts';\nimport { getProvider } from './registry.ts';\nimport { type EmbedCallOptions, STORE_DIMS } from './types.ts';\n\n// Slice + re-normalize (Matryoshka); optionally round through int8 storage. Exported for\n// benchmark/lib/embed.mjs, which scores the same lever math offline.\nexport function toStore(full: Float32Array, dims: number, int8: boolean): { v: Float32Array; scale: number } {\n  const v = new Float32Array(dims);\n  let norm = 0;\n  for (let d = 0; d < dims; d++) norm += full[d] * full[d];\n  norm = Math.sqrt(norm) + 1e-32;\n  for (let d = 0; d < dims; d++) v[d] = full[d] / norm;\n  if (!int8) return { v, scale: 1 };\n  let max = 0;\n  for (let d = 0; d < dims; d++) max = Math.max(max, Math.abs(v[d]));\n  return { v, scale: max / 127 || 1 };\n}\n\n// Embed rows whose vector is NULL. Reconcile hands its chunk text over in memory when it ran in\n// this process (handoff.ts); a row left pending by an earlier command re-derives from the exact\n// source string persisted with that indexed generation.\nfunction staleEmbeddingWork(reason: string): SenseError {\n  return new SenseError('INDEX_NOT_READY', `${reason}; run \\`sense build\\` (or library build(config)) again to prepare the current index generation`);\n}\n\n// expectedSignature is captured by open() before provider work. Direct internal callers omit it\n// and capture the durable value here, before selecting chunks or constructing a provider.\nexport async function embedPending(store: Store, cfg: Config, allowed?: ReadonlySet<string>, expectedSignature?: string | null, options: EmbedCallOptions = {}): Promise<void> {\n  options.signal?.throwIfAborted();\n  const expectedDurableSignature = expectedSignature === undefined ? await getMeta(store, FEATURE_SIGNATURE_META_KEY) : expectedSignature;\n  options.signal?.throwIfAborted();\n  if (!embeddingSignatureCompatible(expectedDurableSignature, featureSignature(cfg, FEATURES))) {\n    throw staleEmbeddingWork('the index configuration changed before vectors could be prepared');\n  }\n\n  const pendingStmt = await store.prepare('SELECT \"path\", chunk, content_identity FROM embeddings WHERE vector IS NULL ORDER BY \"path\", chunk');\n  const dirty = ((await pendingStmt.all()) as Array<{ path: string; chunk: number; content_identity: string }>).filter((row) => allowed?.has(row.path) ?? true);\n  options.signal?.throwIfAborted();\n  if (dirty.length === 0) return;\n\n  const provider = await getProvider(cfg, options);\n  options.signal?.throwIfAborted();\n  const submittedSignature = featureSignature(cfg, FEATURES);\n  if (!embeddingSignatureCompatible(expectedDurableSignature, submittedSignature)) {\n    throw staleEmbeddingWork('the index configuration changed while the embedding provider was being prepared');\n  }\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n\n  const byPath = new Map<string, typeof dirty>();\n  for (const row of dirty) {\n    const list = byPath.get(row.path) ?? [];\n    list.push(row);\n    byPath.set(row.path, list);\n  }\n\n  const textByPath = takeChunkText(store) ?? new Map();\n  const sourceStmt = await store.prepare('SELECT text FROM indexed_sources WHERE \"path\" = ?');\n\n  const jobs: Array<{ path: string; chunk: number; text: string; identity: string }> = [];\n  for (const [path, pending] of byPath) {\n    const texts = textByPath.get(path);\n    if (texts && pending.every((row) => texts[row.chunk]?.identity === row.content_identity)) {\n      for (const row of pending) jobs.push({ path, chunk: row.chunk, ...texts[row.chunk] });\n      continue;\n    }\n    // A prior process may have reconciled the row, so its in-memory handoff is gone. Re-derive\n    // from that indexed generation's stored source, never from a newer live file.\n    const source = (await sourceStmt.get(path)) as { text: string } | undefined;\n    options.signal?.throwIfAborted();\n    if (!source) throw new SenseError('INDEX_NOT_READY', `indexed source text is missing for ${path}; run \\`sense build --force\\` (or library build(config, { force: true })) before preparing vectors`);\n    const chunks = parseSource({ relPath: path, absPath: path, mtimeMs: 0, ctimeMs: 0, size: Buffer.byteLength(source.text), presets: [], embed: true }, source.text, [embed], cfg).doc.extracted.embed as Chunk[];\n    for (const row of pending) {\n      const chunk = chunks[row.chunk];\n      if (!chunk) throw new SenseError('INDEX_NOT_READY', `indexed vector metadata for ${path} does not match its indexed source; run \\`sense build --force\\` (or library build(config, { force: true }))`);\n      const identified = identifyChunkText(chunk.text);\n      if (identified.identity !== row.content_identity) throw staleEmbeddingWork(`indexed chunk ${path}#${row.chunk} changed before vectors could be prepared`);\n      jobs.push({ path, chunk: row.chunk, ...identified });\n    }\n  }\n\n  // Over the exact texts about to be embedded, before any of them are: a mismatch fails\n  // this run loudly instead of quietly storing vectors from the wrong model.\n  options.signal?.throwIfAborted();\n  await checkLanguageFit(\n    store,\n    provider,\n    jobs.map((j) => j.text)\n  );\n  options.signal?.throwIfAborted();\n\n  // Preparing a large configured scope can take long enough to look stalled, so report each\n  // completed provider batch.\n  const report = progress('embedding chunks', jobs.length);\n  for (let i = 0; i < jobs.length; i += provider.batchCap) {\n    const batch = jobs.slice(i, i + provider.batchCap);\n    options.signal?.throwIfAborted();\n    if (featureSignature(cfg, FEATURES) !== submittedSignature) throw staleEmbeddingWork('the embedding configuration changed before a provider batch was submitted');\n    const vectors = await provider.embedDocuments(\n      batch.map((j) => j.text),\n      options\n    );\n    options.signal?.throwIfAborted();\n    if (featureSignature(cfg, FEATURES) !== submittedSignature) throw staleEmbeddingWork('the embedding configuration changed while a provider batch was running');\n    const writes = batch.map((job, j) => {\n      const { v, scale } = toStore(vectors[j], storeDims, true);\n      const q = new Int8Array(storeDims);\n      for (let d = 0; d < storeDims; d++) q[d] = Math.round(v[d] / scale);\n      return { path: job.path, chunk: job.chunk, scale, vector: Buffer.from(q.buffer) };\n    });\n    options.signal?.throwIfAborted();\n    await store.transaction(async () => {\n      // Write first so SQLite owns the write lock before the fence reads. Any mismatch throws\n      // inside this transaction and rolls every row in the provider batch back together.\n      options.signal?.throwIfAborted();\n      await store.vectors.writeVectors(writes);\n      options.signal?.throwIfAborted();\n      if ((await getMeta(store, FEATURE_SIGNATURE_META_KEY)) !== expectedDurableSignature) throw staleEmbeddingWork('the durable embedding configuration changed while a provider batch was running');\n      const currentStmt = await store.prepare(`SELECT \"path\", chunk, content_identity FROM embeddings WHERE ${batch.map(() => '(\"path\" = ? AND chunk = ?)').join(' OR ')}`);\n      const current = (await currentStmt.all(...batch.flatMap((job) => [job.path, job.chunk]))) as Array<{ path: string; chunk: number; content_identity: string }>;\n      const identities = new Map(current.map((row) => [`${row.path}\\0${Number(row.chunk)}`, row.content_identity]));\n      if (batch.some((job) => identities.get(`${job.path}\\0${job.chunk}`) !== job.identity)) throw staleEmbeddingWork('indexed chunks changed while a provider batch was running');\n      options.signal?.throwIfAborted();\n    });\n    report.tick(Math.min(i + provider.batchCap, jobs.length));\n  }\n  report.finish();\n}\n\nexport async function ensureDocumentEmbeddings(store: Store, _cfg: Config, allowed: ReadonlySet<string>): Promise<void> {\n  const pending = (await store.vectors.pending()).filter((row) => allowed.has(row.path));\n  if (pending.length > 0) {\n    throw new SenseError('INDEX_NOT_READY', `${pending.length} indexed chunk(s) in the requested scope still need vectors; run \\`sense build\\` (or library build(config)) before querying with build disabled`);\n  }\n}\n\nexport interface PreparedSemanticQuery {\n  readonly vector: Float32Array;\n  readonly storeDims: number;\n}\n\n// Provider/model work is independent of the index snapshot. FTS5 operators are stripped as\n// lexical syntax before the query is embedded, matching the prior semantic query behavior.\nexport async function prepareSemanticQuery(cfg: Config, terms: string, options: EmbedCallOptions = {}): Promise<PreparedSemanticQuery> {\n  const rootDir = (cfg as Partial<ResolvedConfig>).rootDir ?? (cfg as Partial<ResolvedConfig>).baseDir;\n  if (!rootDir) throw new SenseError('EMBED_MODEL', 'semantic expansion needs a resolved config (use loadConfig/open)');\n  const text = (terms.match(/[\\p{L}\\p{N}]+/gu) ?? []).filter((t) => !['AND', 'OR', 'NOT', 'NEAR'].includes(t)).join(' ');\n  options.signal?.throwIfAborted();\n  const provider = await getProvider(cfg, options);\n  options.signal?.throwIfAborted();\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n  const queryVector = await provider.embedQuery(text, options);\n  options.signal?.throwIfAborted();\n  const { v: qv } = toStore(queryVector, storeDims, false);\n  return { vector: qv, storeDims };\n}\n\n// Best chunk per file by cosine, its line range riding along. The caller owns the read snapshot\n// and the prepared vector, so this performs no provider work and only delegates to the store.\nexport function semanticCandidates(store: Store, prepared: PreparedSemanticQuery, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]> {\n  return store.vectors.candidates(prepared.vector, prepared.storeDims, fetch, allowed);\n}\n\n// Whether a note has any chunk with a vector. Distinguishes \"nothing is near this note\" from\n// \"this note has no text\", which look the same in an empty result.\nexport async function hasEmbedding(store: Store, path: string): Promise<boolean> {\n  return store.vectors.hasVector(path);\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors.\nexport async function similarNotes(store: Store, _cfg: Config, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]> {\n  return store.vectors.similar(path, opts);\n}\n"],"names":["embedPending","ensureDocumentEmbeddings","hasEmbedding","prepareSemanticQuery","semanticCandidates","similarNotes","toStore","full","dims","int8","v","Float32Array","norm","d","Math","sqrt","scale","max","abs","staleEmbeddingWork","reason","SenseError","store","cfg","allowed","expectedSignature","options","takeChunkText","expectedDurableSignature","pendingStmt","dirty","provider","submittedSignature","storeDims","byPath","row","list","textByPath","sourceStmt","jobs","report","i","batch","vectors","writes","slice","batchCap","signal","throwIfAborted","featureSignature","FEATURES","embedDocuments","map","j","text","job","q","Int8Array","round","path","chunk","vector","Buffer","from","buffer","transaction","currentStmt","current","identities","writeVectors","getMeta","FEATURE_SIGNATURE_META_KEY","prepare","join","all","flatMap","Map","Number","content_identity","some","get","identity","tick","min","length","undefined","embeddingSignatureCompatible","filter","has","getProvider","STORE_DIMS","push","set","pending","texts","source","chunks","identified","every","parseSource","relPath","absPath","mtimeMs","ctimeMs","size","byteLength","presets","embed","doc","extracted","identifyChunkText","checkLanguageFit","progress","finish","_cfg","terms","rootDir","queryVector","qv","baseDir","match","t","includes","embedQuery","prepared","fetch","candidates","hasVector","opts","similar"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/embed/query.ts"],"sourcesContent":["import { type Config, featureSignature, type ResolvedConfig } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport type { Chunk } from '../features/embed.ts';\nimport { embed } from '../features/embed.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { progress } from '../output/progress.ts';\nimport { parseSource } from '../scan/index.ts';\nimport { FEATURE_SIGNATURE_META_KEY } from '../store/readiness.ts';\nimport { getMeta } from '../store/shared.ts';\nimport { embeddingSignatureCompatible } from '../store/signature.ts';\nimport type { Store, VectorCandidate, VectorSimilar } from '../store/types.ts';\nimport { identifyChunkText, takeChunkText } from './handoff.ts';\nimport { checkLanguageFit } from './langfit.ts';\nimport { getProvider } from './registry.ts';\nimport { type EmbedCallOptions, STORE_DIMS } from './types.ts';\n\n// Slice + re-normalize (Matryoshka); optionally round through int8 storage. Exported for\n// benchmark/lib/embed.ts, which scores the same lever math offline.\nexport function toStore(full: Float32Array, dims: number, int8: boolean): { v: Float32Array; scale: number } {\n  const v = new Float32Array(dims);\n  let norm = 0;\n  for (let d = 0; d < dims; d++) norm += full[d] * full[d];\n  norm = Math.sqrt(norm) + 1e-32;\n  for (let d = 0; d < dims; d++) v[d] = full[d] / norm;\n  if (!int8) return { v, scale: 1 };\n  let max = 0;\n  for (let d = 0; d < dims; d++) max = Math.max(max, Math.abs(v[d]));\n  return { v, scale: max / 127 || 1 };\n}\n\n// Embed rows whose vector is NULL. Reconcile hands its chunk text over in memory when it ran in\n// this process (handoff.ts); a row left pending by an earlier command re-derives from the exact\n// source string persisted with that indexed generation.\nfunction staleEmbeddingWork(reason: string): SenseError {\n  return new SenseError('INDEX_NOT_READY', `${reason}; run \\`sense build\\` (or library build(config)) again to prepare the current index generation`);\n}\n\n// expectedSignature is captured by open() before provider work. Direct internal callers omit it\n// and capture the durable value here, before selecting chunks or constructing a provider.\nexport async function embedPending(store: Store, cfg: Config, allowed?: ReadonlySet<string>, expectedSignature?: string | null, options: EmbedCallOptions = {}): Promise<void> {\n  options.signal?.throwIfAborted();\n  const expectedDurableSignature = expectedSignature === undefined ? await getMeta(store, FEATURE_SIGNATURE_META_KEY) : expectedSignature;\n  options.signal?.throwIfAborted();\n  if (!embeddingSignatureCompatible(expectedDurableSignature, featureSignature(cfg, FEATURES))) {\n    throw staleEmbeddingWork('the index configuration changed before vectors could be prepared');\n  }\n\n  const pendingStmt = await store.prepare('SELECT \"path\", chunk, content_identity FROM embeddings WHERE vector IS NULL ORDER BY \"path\", chunk');\n  const dirty = ((await pendingStmt.all()) as Array<{ path: string; chunk: number; content_identity: string }>).filter((row) => allowed?.has(row.path) ?? true);\n  options.signal?.throwIfAborted();\n  if (dirty.length === 0) return;\n\n  const provider = await getProvider(cfg, options);\n  options.signal?.throwIfAborted();\n  const submittedSignature = featureSignature(cfg, FEATURES);\n  if (!embeddingSignatureCompatible(expectedDurableSignature, submittedSignature)) {\n    throw staleEmbeddingWork('the index configuration changed while the embedding provider was being prepared');\n  }\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n\n  const byPath = new Map<string, typeof dirty>();\n  for (const row of dirty) {\n    const list = byPath.get(row.path) ?? [];\n    list.push(row);\n    byPath.set(row.path, list);\n  }\n\n  const textByPath = takeChunkText(store) ?? new Map();\n  const sourceStmt = await store.prepare('SELECT text FROM indexed_sources WHERE \"path\" = ?');\n\n  const jobs: Array<{ path: string; chunk: number; text: string; identity: string }> = [];\n  for (const [path, pending] of byPath) {\n    const texts = textByPath.get(path);\n    if (texts && pending.every((row) => texts[row.chunk]?.identity === row.content_identity)) {\n      for (const row of pending) jobs.push({ path, chunk: row.chunk, ...texts[row.chunk] });\n      continue;\n    }\n    // A prior process may have reconciled the row, so its in-memory handoff is gone. Re-derive\n    // from that indexed generation's stored source, never from a newer live file.\n    const source = (await sourceStmt.get(path)) as { text: string } | undefined;\n    options.signal?.throwIfAborted();\n    if (!source) throw new SenseError('INDEX_NOT_READY', `indexed source text is missing for ${path}; run \\`sense build --force\\` (or library build(config, { force: true })) before preparing vectors`);\n    const chunks = parseSource({ relPath: path, absPath: path, mtimeMs: 0, ctimeMs: 0, size: Buffer.byteLength(source.text), presets: [], embed: true }, source.text, [embed], cfg).doc.extracted.embed as Chunk[];\n    for (const row of pending) {\n      const chunk = chunks[row.chunk];\n      if (!chunk) throw new SenseError('INDEX_NOT_READY', `indexed vector metadata for ${path} does not match its indexed source; run \\`sense build --force\\` (or library build(config, { force: true }))`);\n      const identified = identifyChunkText(chunk.text);\n      if (identified.identity !== row.content_identity) throw staleEmbeddingWork(`indexed chunk ${path}#${row.chunk} changed before vectors could be prepared`);\n      jobs.push({ path, chunk: row.chunk, ...identified });\n    }\n  }\n\n  // Over the exact texts about to be embedded, before any of them are: a mismatch fails\n  // this run loudly instead of quietly storing vectors from the wrong model.\n  options.signal?.throwIfAborted();\n  await checkLanguageFit(\n    store,\n    provider,\n    jobs.map((j) => j.text)\n  );\n  options.signal?.throwIfAborted();\n\n  // Preparing a large configured scope can take long enough to look stalled, so report each\n  // completed provider batch.\n  const report = progress('embedding chunks', jobs.length);\n  for (let i = 0; i < jobs.length; i += provider.batchCap) {\n    const batch = jobs.slice(i, i + provider.batchCap);\n    options.signal?.throwIfAborted();\n    if (featureSignature(cfg, FEATURES) !== submittedSignature) throw staleEmbeddingWork('the embedding configuration changed before a provider batch was submitted');\n    const vectors = await provider.embedDocuments(\n      batch.map((j) => j.text),\n      options\n    );\n    options.signal?.throwIfAborted();\n    if (featureSignature(cfg, FEATURES) !== submittedSignature) throw staleEmbeddingWork('the embedding configuration changed while a provider batch was running');\n    const writes = batch.map((job, j) => {\n      const { v, scale } = toStore(vectors[j], storeDims, true);\n      const q = new Int8Array(storeDims);\n      for (let d = 0; d < storeDims; d++) q[d] = Math.round(v[d] / scale);\n      return { path: job.path, chunk: job.chunk, scale, vector: Buffer.from(q.buffer) };\n    });\n    options.signal?.throwIfAborted();\n    await store.transaction(async () => {\n      // Write first so SQLite owns the write lock before the fence reads. Any mismatch throws\n      // inside this transaction and rolls every row in the provider batch back together.\n      options.signal?.throwIfAborted();\n      await store.vectors.writeVectors(writes);\n      options.signal?.throwIfAborted();\n      if ((await getMeta(store, FEATURE_SIGNATURE_META_KEY)) !== expectedDurableSignature) throw staleEmbeddingWork('the durable embedding configuration changed while a provider batch was running');\n      const currentStmt = await store.prepare(`SELECT \"path\", chunk, content_identity FROM embeddings WHERE ${batch.map(() => '(\"path\" = ? AND chunk = ?)').join(' OR ')}`);\n      const current = (await currentStmt.all(...batch.flatMap((job) => [job.path, job.chunk]))) as Array<{ path: string; chunk: number; content_identity: string }>;\n      const identities = new Map(current.map((row) => [`${row.path}\\0${Number(row.chunk)}`, row.content_identity]));\n      if (batch.some((job) => identities.get(`${job.path}\\0${job.chunk}`) !== job.identity)) throw staleEmbeddingWork('indexed chunks changed while a provider batch was running');\n      options.signal?.throwIfAborted();\n    });\n    report.tick(Math.min(i + provider.batchCap, jobs.length));\n  }\n  report.finish();\n}\n\nexport async function ensureDocumentEmbeddings(store: Store, _cfg: Config, allowed: ReadonlySet<string>): Promise<void> {\n  const pending = (await store.vectors.pending()).filter((row) => allowed.has(row.path));\n  if (pending.length > 0) {\n    throw new SenseError('INDEX_NOT_READY', `${pending.length} indexed chunk(s) in the requested scope still need vectors; run \\`sense build\\` (or library build(config)) before querying with build disabled`);\n  }\n}\n\nexport interface PreparedSemanticQuery {\n  readonly vector: Float32Array;\n  readonly storeDims: number;\n}\n\n// Provider/model work is independent of the index snapshot. FTS5 operators are stripped as\n// lexical syntax before the query is embedded, matching the prior semantic query behavior.\nexport async function prepareSemanticQuery(cfg: Config, terms: string, options: EmbedCallOptions = {}): Promise<PreparedSemanticQuery> {\n  const rootDir = (cfg as Partial<ResolvedConfig>).rootDir ?? (cfg as Partial<ResolvedConfig>).baseDir;\n  if (!rootDir) throw new SenseError('EMBED_MODEL', 'semantic expansion needs a resolved config (use loadConfig/open)');\n  const text = (terms.match(/[\\p{L}\\p{N}]+/gu) ?? []).filter((t) => !['AND', 'OR', 'NOT', 'NEAR'].includes(t)).join(' ');\n  options.signal?.throwIfAborted();\n  const provider = await getProvider(cfg, options);\n  options.signal?.throwIfAborted();\n  const storeDims = Math.min(STORE_DIMS, provider.dims);\n  const queryVector = await provider.embedQuery(text, options);\n  options.signal?.throwIfAborted();\n  const { v: qv } = toStore(queryVector, storeDims, false);\n  return { vector: qv, storeDims };\n}\n\n// Best chunk per file by cosine, its line range riding along. The caller owns the read snapshot\n// and the prepared vector, so this performs no provider work and only delegates to the store.\nexport function semanticCandidates(store: Store, prepared: PreparedSemanticQuery, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]> {\n  return store.vectors.candidates(prepared.vector, prepared.storeDims, fetch, allowed);\n}\n\n// Whether a note has any chunk with a vector. Distinguishes \"nothing is near this note\" from\n// \"this note has no text\", which look the same in an empty result.\nexport async function hasEmbedding(store: Store, path: string): Promise<boolean> {\n  return store.vectors.hasVector(path);\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors.\nexport async function similarNotes(store: Store, _cfg: Config, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]> {\n  return store.vectors.similar(path, opts);\n}\n"],"names":["embedPending","ensureDocumentEmbeddings","hasEmbedding","prepareSemanticQuery","semanticCandidates","similarNotes","toStore","full","dims","int8","v","Float32Array","norm","d","Math","sqrt","scale","max","abs","staleEmbeddingWork","reason","SenseError","store","cfg","allowed","expectedSignature","options","takeChunkText","expectedDurableSignature","pendingStmt","dirty","provider","submittedSignature","storeDims","byPath","row","list","textByPath","sourceStmt","jobs","report","i","batch","vectors","writes","slice","batchCap","signal","throwIfAborted","featureSignature","FEATURES","embedDocuments","map","j","text","job","q","Int8Array","round","path","chunk","vector","Buffer","from","buffer","transaction","currentStmt","current","identities","writeVectors","getMeta","FEATURE_SIGNATURE_META_KEY","prepare","join","all","flatMap","Map","Number","content_identity","some","get","identity","tick","min","length","undefined","embeddingSignatureCompatible","filter","has","getProvider","STORE_DIMS","push","set","pending","texts","source","chunks","identified","every","parseSource","relPath","absPath","mtimeMs","ctimeMs","size","byteLength","presets","embed","doc","extracted","identifyChunkText","checkLanguageFit","progress","finish","_cfg","terms","rootDir","queryVector","qv","baseDir","match","t","includes","embedQuery","prepared","fetch","candidates","hasVector","opts","similar"],"mappings":"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"}

package/dist/cjs/store/duckdb/engine.d.cts

@@ -0,0 +1,11 @@
+import { type EnginePatch } from '../engine.js';
+export declare const FTS_STEMMER = "porter";
+export interface DuckdbFtsBuilders {
+    createIndex(): string;
+    queryTerms(): string;
+    termScore(field: string): string;
+    conjunctiveGate(): string;
+}
+export declare const DUCKDB_FTS_BUILDERS: DuckdbFtsBuilders;
+export declare const DUCKDB_PATCHES: readonly EnginePatch<DuckdbFtsBuilders>[];
+export declare function duckdbFts(): Promise<DuckdbFtsBuilders>;

package/dist/cjs/store/duckdb/engine.d.ts

@@ -0,0 +1,11 @@
+import { type EnginePatch } from '../engine.js';
+export declare const FTS_STEMMER = "porter";
+export interface DuckdbFtsBuilders {
+    createIndex(): string;
+    queryTerms(): string;
+    termScore(field: string): string;
+    conjunctiveGate(): string;
+}
+export declare const DUCKDB_FTS_BUILDERS: DuckdbFtsBuilders;
+export declare const DUCKDB_PATCHES: readonly EnginePatch<DuckdbFtsBuilders>[];
+export declare function duckdbFts(): Promise<DuckdbFtsBuilders>;