sensemaking 0.26.0 → 0.27.1

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/path.ts"],"sourcesContent":["import { findPath } from '../commands/path.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// --max-depth must be a positive integer, mirroring shared.ts's parseK.\nfunction parseMaxDepth(depth: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (depth === undefined) return undefined;\n  const parsed = Number(depth);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--max-depth expects a positive integer, got \"${depth}\"`);\n  return parsed;\n}\n\nconst pathCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.path}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, 'max-depth': { type: 'string' } });\n  const [a, b] = positionals;\n  if (!a || !b) ctx.usageError(usage);\n  const maxDepth = parseMaxDepth(values['max-depth'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const hops = await findPath(store, cfg, a, b, { ...scopeOf(values), maxDepth });\n\n    if (format === 'json') {\n      console.log(JSON.stringify(hops));\n      return;\n    }\n    if (hops === null) {\n      console.log(maxDepth ? `no path within ${maxDepth} hops` : 'no path');\n      return;\n    }\n    const rows: Row[] = hops.map((p, step) => ({ step, path: p }));\n    printRows(rows, format);\n  });\n};\nexport default pathCmd;\n"],"names":["parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","USAGE","name","path","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","type","values","positionals","a","b","maxDepth","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","hops","rows","findPath","scopeOf","console","log","JSON","stringify","map","p","step","printRows"],"mappings":";;;;+BAsCA;;;eAAA;;;sBAtCyB;wBAEC;uBAEJ;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,wEAAwE;AACxE,SAASA,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,gDAAqD,OAAND,OAAM;IAC/G,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,aAAa;YAAEC,MAAM;QAAS;SAA5HC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAeA,gCAAAA,iBAARC,IAAQD,iBAALE,IAAKF;IACf,IAAI,CAACC,KAAK,CAACC,GAAGf,IAAIN,UAAU,CAACO;IAC7B,IAAMe,WAAWxB,cAAcoB,MAAM,CAAC,YAAY,EAAwBZ,IAAIN,UAAU;IACxF,IAAMuB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAACnB,KAAKY,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,MAUAC;;;;wBAVO;;4BAAMC,IAAAA,gBAAQ,EAACJ,OAAOC,KAAKX,GAAGC,GAAG,wCAAKc,IAAAA,iBAAO,EAACjB;gCAASI,UAAAA;;;;wBAA9DU,OAAO;wBAEb,IAAIT,WAAW,QAAQ;4BACrBa,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACP;4BAC3B;;;wBACF;wBACA,IAAIA,SAAS,MAAM;4BACjBI,QAAQC,GAAG,CAACf,WAAW,AAAC,kBAA0B,OAATA,UAAS,WAAS;4BAC3D;;;wBACF;wBACMW,OAAcD,KAAKQ,GAAG,CAAC,SAACC,GAAGC;mCAAU;gCAAEA,MAAAA;gCAAMhC,MAAM+B;4BAAE;;wBAC3DE,IAAAA,mBAAS,EAACV,MAAMV;;;;;;QAClB;;AACF;IACA,WAAelB"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/path.ts"],"sourcesContent":["import { findPath } from '../commands/path.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// --max-depth must be a positive integer, mirroring shared.ts's parseK.\nfunction parseMaxDepth(depth: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (depth === undefined) return undefined;\n  const parsed = Number(depth);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--max-depth expects a positive integer, got \"${depth}\"`);\n  return parsed;\n}\n\nconst pathCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.path}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, 'max-depth': { type: 'string' } });\n  const [a, b] = positionals;\n  if (!a || !b) ctx.usageError(usage);\n  const maxDepth = parseMaxDepth(values['max-depth'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const hops = await findPath(store, cfg, a, b, { ...scopeOf(values), maxDepth });\n\n    if (format === 'json') {\n      console.log(JSON.stringify(hops));\n      return;\n    }\n    if (hops === null) {\n      console.log(maxDepth ? `no path within ${maxDepth} hops` : 'no path');\n      return;\n    }\n    const rows: Row[] = hops.map((p, step) => ({ step, path: p }));\n    printRows(rows, format);\n  });\n};\nexport default pathCmd;\n"],"names":["parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","USAGE","name","path","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","type","values","positionals","a","b","maxDepth","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","hops","rows","findPath","scopeOf","console","log","JSON","stringify","map","p","step","printRows"],"mappings":";;;;+BAsCA;;;eAAA;;;sBAtCyB;wBAEC;uBAEJ;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,wEAAwE;AACxE,SAASA,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,gDAAqD,OAAND,OAAM;IAC/G,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,aAAa;YAAEC,MAAM;QAAS;SAA5HC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAeA,gCAAAA,iBAARC,IAAQD,iBAALE,IAAKF;IACf,IAAI,CAACC,KAAK,CAACC,GAAGf,IAAIN,UAAU,CAACO;IAC7B,IAAMe,WAAWxB,cAAcoB,MAAM,CAAC,YAAY,EAAwBZ,IAAIN,UAAU;IACxF,IAAMuB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAACnB,KAAKY,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,MAUAC;;;;wBAVO;;4BAAMC,IAAAA,gBAAQ,EAACJ,OAAOC,KAAKX,GAAGC,GAAG,wCAAKc,IAAAA,iBAAO,EAACjB;gCAASI,UAAAA;;;;wBAA9DU,OAAO;wBAEb,IAAIT,WAAW,QAAQ;4BACrBa,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACP;4BAC3B;;;wBACF;wBACA,IAAIA,SAAS,MAAM;4BACjBI,QAAQC,GAAG,CAACf,WAAW,AAAC,kBAA0B,OAATA,UAAS,WAAS;4BAC3D;;;wBACF;wBACMW,OAAcD,KAAKQ,GAAG,CAAC,SAACC,GAAGC;mCAAU;gCAAEA,MAAAA;gCAAMhC,MAAM+B;4BAAE;;wBAC3DE,IAAAA,mBAAS,EAACV,MAAMV;;;;;;QAClB;;AACF;IACA,WAAelB"}

package/dist/cjs/cli/peek.js

@@ -99,6 +99,29 @@ function _object_spread(target) {
     }
     return target;
 }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
@@ -209,11 +232,26 @@ 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);
 }
+function parseCountLimit(name, value, usageError) {
+    if (value === undefined) return undefined;
+    var parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) usageError("--".concat(name, ' expects a positive safe integer, got "').concat(value, '"'));
+    return parsed;
+}
 var peekCmd = function peekCmd(ctx) {
     var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.peek);
-    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SCOPE, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SCOPE, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG), {
+        'section-count-limit': {
+            type: 'string'
+        },
+        'link-count-limit': {
+            type: 'string'
+        }
+    })), values = _parse.values, positionals = _parse.positionals;
     var _positionals = _sliced_to_array(positionals, 1), pathArg = _positionals[0];
     if (!pathArg) ctx.usageError(usage);
+    var sectionCountLimit = parseCountLimit('section-count-limit', values['section-count-limit'], ctx.usageError);
+    var linkCountLimit = parseCountLimit('link-count-limit', values['link-count-limit'], ctx.usageError);
     var format = (0, _sharedts.formatOf)(values);
     return (0, _sharedts.withDb)(ctx, values.config, {
         noBuild: values['no-build'] === true,
@@ -226,7 +264,10 @@ var peekCmd = function peekCmd(ctx) {
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
-                        overrides = (0, _sharedts.scopeOf)(values);
+                        overrides = _object_spread_props(_object_spread({}, (0, _sharedts.scopeOf)(values)), {
+                            sectionCountLimit: sectionCountLimit,
+                            linkCountLimit: linkCountLimit
+                        });
                         return [
                             4,
                             (0, _peekts.peek)(store, cfg, pathArg, overrides)

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/peek.ts"],"sourcesContent":["import { peek } from '../commands/peek.ts';\nimport { renderPeek, stringifyJson } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst peekCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.peek}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const overrides = scopeOf(values);\n    const result = await peek(store, cfg, pathArg, overrides);\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderPeek(result));\n  });\n};\nexport default peekCmd;\n"],"names":["peekCmd","ctx","usage","USAGE","name","peek","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","values","positionals","pathArg","usageError","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","overrides","result","scopeOf","console","log","stringifyJson","renderPeek"],"mappings":";;;;+BAmBA;;;eAAA;;;sBAnBqB;wBACqB;uBAEpB;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,IAAMA,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,mBAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM,IAA5FC,SAAwBN,OAAxBM,QAAQC,cAAgBP,OAAhBO;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASb,IAAIc,UAAU,CAACb;IAC7B,IAAMc,SAASC,IAAAA,kBAAQ,EAACL;IACxB,OAAOM,IAAAA,gBAAM,EAACjB,KAAKW,OAAOO,MAAM,EAAwB;QAAEC,SAASR,MAAM,CAAC,WAAW,KAAK;QAAMS,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,WACAC;;;;wBADAD,YAAYE,IAAAA,iBAAO,EAACf;wBACX;;4BAAMP,IAAAA,YAAI,EAACkB,OAAOC,KAAKV,SAASW;;;wBAAzCC,SAAS;wBACfE,QAAQC,GAAG,CAACb,WAAW,SAASc,IAAAA,uBAAa,EAACJ,QAAQ,KAAKK,IAAAA,oBAAU,EAACL;;;;;;QACxE;;AACF;IACA,WAAe1B"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/peek.ts"],"sourcesContent":["import { peek } from '../commands/peek.ts';\nimport { renderPeek, stringifyJson } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nfunction parseCountLimit(name: string, value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isSafeInteger(parsed) || parsed <= 0) usageError(`--${name} expects a positive safe integer, got \"${value}\"`);\n  return parsed;\n}\n\nconst peekCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.peek}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, 'section-count-limit': { type: 'string' }, 'link-count-limit': { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const sectionCountLimit = parseCountLimit('section-count-limit', values['section-count-limit'] as string | undefined, ctx.usageError);\n  const linkCountLimit = parseCountLimit('link-count-limit', values['link-count-limit'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const overrides = { ...scopeOf(values), sectionCountLimit, linkCountLimit };\n    const result = await peek(store, cfg, pathArg, overrides);\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderPeek(result));\n  });\n};\nexport default peekCmd;\n"],"names":["parseCountLimit","name","value","usageError","undefined","parsed","Number","isSafeInteger","peekCmd","ctx","usage","USAGE","peek","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","type","values","positionals","pathArg","sectionCountLimit","linkCountLimit","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","overrides","result","scopeOf","console","log","stringifyJson","renderPeek"],"mappings":";;;;+BA4BA;;;eAAA;;;sBA5BqB;wBACqB;uBAEpB;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,SAASA,gBAAgBC,IAAY,EAAEC,KAAyB,EAAEC,UAAsC;IACtG,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,aAAa,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,KAAkDD,OAA9CD,MAAK,2CAA+C,OAANC,OAAM;IACtH,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIR,IAAI,EAAC,KAAc,OAAXU,cAAK,CAACC,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACJ,IAAIK,IAAI,EAAEJ,OAAO,wCAAKK,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,uBAAuB;YAAEC,MAAM;QAAS;QAAG,oBAAoB;YAAEA,MAAM;QAAS;SAA9KC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASb,IAAIN,UAAU,CAACO;IAC7B,IAAMa,oBAAoBvB,gBAAgB,uBAAuBoB,MAAM,CAAC,sBAAsB,EAAwBX,IAAIN,UAAU;IACpI,IAAMqB,iBAAiBxB,gBAAgB,oBAAoBoB,MAAM,CAAC,mBAAmB,EAAwBX,IAAIN,UAAU;IAC3H,IAAMsB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAAClB,KAAKW,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,WACAC;;;;wBADAD,YAAY,wCAAKE,IAAAA,iBAAO,EAAChB;4BAASG,mBAAAA;4BAAmBC,gBAAAA;;wBAC5C;;4BAAMZ,IAAAA,YAAI,EAACoB,OAAOC,KAAKX,SAASY;;;wBAAzCC,SAAS;wBACfE,QAAQC,GAAG,CAACb,WAAW,SAASc,IAAAA,uBAAa,EAACJ,QAAQ,KAAKK,IAAAA,oBAAU,EAACL;;;;;;QACxE;;AACF;IACA,WAAe3B"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { RELATED_DEFAULT_K, relatedNotes, resolveRelatedSeed } from '../commands/related.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, k: { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? RELATED_DEFAULT_K;\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  return withDb(ctx, values.config as string | undefined, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg, build) => {\n    const overrides = scopeOf(values);\n    if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n      const path = await resolveRelatedSeed(store, pathArg);\n      const allowed = await scopedPaths(store, cfg, overrides);\n      await prepareDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    }\n    printRows(await relatedNotes(store, cfg, pathArg, { ...overrides, k }), format);\n  });\n};\nexport default relatedCmd;\n"],"names":["relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","RELATED_DEFAULT_K","format","rowFormatOf","noBuild","withDb","config","requirements","Set","store","cfg","build","overrides","path","allowed","scopeOf","resolveSearch","signals","vectors","undefined","resolveRelatedSeed","scopedPaths","prepareDocumentEmbeddings","relatedNotes","printRows"],"mappings":";;;;+BA2BA;;;eAAA;;;yBA3BoE;uBACxC;uBACE;wBACJ;sBACuC;wBAC3C;wBACuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7F,IAAMA,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,eAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAAlHC,SAAwBR,OAAxBQ,QAAQC,cAAgBT,OAAhBS;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAAShB,IAAIiB,UAAU,CAACf;IAC7B,IAAMU,KAAIX,UAAAA,IAAAA,gBAAM,EAACa,OAAOF,CAAC,EAAwBZ,IAAIiB,UAAU,eAArDhB,qBAAAA,UAA0DiB,4BAAiB;IACrF,IAAMC,SAASC,IAAAA,qBAAW,EAACN;IAC3B,IAAMO,UAAUP,MAAM,CAAC,WAAW,KAAK;IACvC,OAAOQ,IAAAA,gBAAM,EAACtB,KAAKc,OAAOS,MAAM,EAAwB;QAAEF,SAAAA;QAASG,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC,KAAKC;;gBACnIC,WAEEC,MACAC;;;;wBAHFF,YAAYG,IAAAA,iBAAO,EAAClB;6BACtBc,CAAAA,SAASK,IAAAA,sBAAa,EAACN,KAAKE,WAAWK,OAAO,CAACC,OAAO,KAAKC,SAAQ,GAAnER;;;;wBACW;;4BAAMS,IAAAA,6BAAkB,EAACX,OAAOV;;;wBAAvCc,OAAO;wBACG;;4BAAMQ,IAAAA,oBAAW,EAACZ,OAAOC,KAAKE;;;wBAAxCE,UAAU;wBAChB;;4BAAMQ,IAAAA,iCAAyB,EAACb,OAAOC,KAAK,IAAIF,IAAI,AAAC,qBAAGM;gCAASD;;;;wBAAjE;;;wBAEQ;;4BAAMU,IAAAA,uBAAY,EAACd,OAAOC,KAAKX,SAAS,wCAAKa;gCAAWjB,GAAAA;;;;wBAAlE6B,mBAAS;4BAAC;4BAA8DtB;;;;;;;QAC1E;;AACF;IACA,WAAepB"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { RELATED_DEFAULT_K, relatedNotes, resolveRelatedSeed } from '../commands/related.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, k: { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? RELATED_DEFAULT_K;\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  return withDb(ctx, values.config as string | undefined, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg, build) => {\n    const overrides = scopeOf(values);\n    if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n      const path = await resolveRelatedSeed(store, pathArg);\n      const allowed = await scopedPaths(store, cfg, overrides);\n      await prepareDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    }\n    printRows(await relatedNotes(store, cfg, pathArg, { ...overrides, k }), format);\n  });\n};\nexport default relatedCmd;\n"],"names":["relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","RELATED_DEFAULT_K","format","rowFormatOf","noBuild","withDb","config","requirements","Set","store","cfg","build","overrides","path","allowed","scopeOf","resolveSearch","signals","vectors","undefined","resolveRelatedSeed","scopedPaths","prepareDocumentEmbeddings","relatedNotes","printRows"],"mappings":";;;;+BA2BA;;;eAAA;;;yBA3BoE;uBACxC;uBACE;wBACJ;sBACuC;wBAC3C;wBACuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7F,IAAMA,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,eAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAAlHC,SAAwBR,OAAxBQ,QAAQC,cAAgBT,OAAhBS;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAAShB,IAAIiB,UAAU,CAACf;IAC7B,IAAMU,KAAIX,UAAAA,IAAAA,gBAAM,EAACa,OAAOF,CAAC,EAAwBZ,IAAIiB,UAAU,eAArDhB,qBAAAA,UAA0DiB,4BAAiB;IACrF,IAAMC,SAASC,IAAAA,qBAAW,EAACN;IAC3B,IAAMO,UAAUP,MAAM,CAAC,WAAW,KAAK;IACvC,OAAOQ,IAAAA,gBAAM,EAACtB,KAAKc,OAAOS,MAAM,EAAwB;QAAEF,SAAAA;QAASG,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC,KAAKC;;gBACnIC,WAEEC,MACAC;;;;wBAHFF,YAAYG,IAAAA,iBAAO,EAAClB;6BACtBc,CAAAA,SAASK,IAAAA,sBAAa,EAACN,KAAKE,WAAWK,OAAO,CAACC,OAAO,KAAKC,SAAQ,GAAnER;;;;wBACW;;4BAAMS,IAAAA,6BAAkB,EAACX,OAAOV;;;wBAAvCc,OAAO;wBACG;;4BAAMQ,IAAAA,oBAAW,EAACZ,OAAOC,KAAKE;;;wBAAxCE,UAAU;wBAChB;;4BAAMQ,IAAAA,iCAAyB,EAACb,OAAOC,KAAK,IAAIF,IAAI,AAAC,qBAAGM;gCAASD;;;;wBAAjE;;;wBAEQ;;4BAAMU,IAAAA,uBAAY,EAACd,OAAOC,KAAKX,SAAS,wCAAKa;gCAAWjB,GAAAA;;;;wBAAlE6B,mBAAS;4BAAC;4BAA8DtB;;;;;;;QAC1E;;AACF;IACA,WAAepB"}

package/dist/cjs/cli/search.js

@@ -102,6 +102,29 @@ function _object_spread(target) {
     }
     return target;
 }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
@@ -219,7 +242,11 @@ var searchCmd = function searchCmd(ctx) {
             switch(_state.label){
                 case 0:
                     usage = "usage: ".concat(ctx.name, " ").concat(_indexts1.USAGE.search);
-                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG), {
+                        explain: {
+                            type: 'boolean'
+                        }
+                    })), values = _parse.values, positionals = _parse.positionals;
                     _positionals = _sliced_to_array(positionals, 1), terms = _positionals[0];
                     if (!terms) ctx.usageError(usage);
                     k = (0, _sharedts.parseK)(values.k, ctx.usageError);
@@ -228,6 +255,7 @@ var searchCmd = function searchCmd(ctx) {
                     format = (0, _sharedts.rowFormatOf)(values);
                     overrides = _object_spread({
                         k: k,
+                        explain: values.explain === true,
                         snippetCharLimit: snippetCharLimit,
                         snippetCountLimit: snippetCountLimit
                     }, (0, _sharedts.scopeOf)(values));
@@ -246,7 +274,7 @@ var searchCmd = function searchCmd(ctx) {
                             }
                         }, function(store, cfg, build) {
                             return _async_to_generator(function() {
-                                var _tmp;
+                                var _tmp, rows, rendered;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
@@ -278,10 +306,14 @@ var searchCmd = function searchCmd(ctx) {
                                                 (0, _searchts.search)(store, cfg, terms, overrides)
                                             ];
                                         case 4:
-                                            _outputts.printRows.apply(void 0, [
-                                                _state.sent(),
-                                                format
-                                            ]);
+                                            rows = _state.sent();
+                                            // Table cells use the shared renderer's width clipping; JSON retains the complete explanation.
+                                            rendered = overrides.explain && format !== 'json' ? rows.map(function(row) {
+                                                return _object_spread_props(_object_spread({}, row), {
+                                                    explanation: JSON.stringify(row.explanation)
+                                                });
+                                            }) : rows;
+                                            (0, _outputts.printRows)(rendered, format);
                                             return [
                                                 2
                                             ];

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/search.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 } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, SEARCH_FLAGS, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst searchCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.search}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const [terms] = positionals;\n  if (!terms) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError);\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 format = rowFormatOf(values);\n  const overrides = { k, snippetCharLimit, snippetCountLimit, ...scopeOf(values) };\n  const noBuild = values['no-build'] === true;\n  await withDb(\n    ctx,\n    values.config as string | undefined,\n    {\n      noBuild,\n      requirements: (cfg) => {\n        const signals = resolveSearch(cfg, 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, cfg, build) => {\n      if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n        await prepareDocumentEmbeddings(store, cfg, await scopedPaths(store, cfg, overrides));\n      }\n      printRows(await search(store, cfg, terms, overrides), format);\n    }\n  );\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","usage","parse","values","positionals","terms","k","snippetCharLimit","snippetCountLimit","format","overrides","noBuild","USAGE","name","search","argv","SEARCH_FLAGS","NO_BUILD","FORMAT","CONFIG","usageError","parseK","parseSnippetCharLimit","parseSnippetCountLimit","rowFormatOf","scopeOf","withDb","config","requirements","cfg","signals","resolveSearch","Set","words","undefined","add","store","build","vectors","scopedPaths","prepareDocumentEmbeddings","printRows"],"mappings":";;;;+BAwCA;;;eAAA;;;uBAxC4B;wBACL;uBACO;wBACJ;sBACuC;wBAC3C;wBAC6H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGnJ,IAAMA,YAAqB,mBAAOC;;YAC1BC,OAC0BC,QAAxBC,QAAQC,aACAA,cAATC,OAEDC,GACAC,kBACAC,mBACAC,QACAC,WACAC;;;;oBATAV,QAAQ,AAAC,UAAqBW,OAAZZ,IAAIa,IAAI,EAAC,KAAgB,OAAbD,eAAK,CAACE,MAAM;oBAChBZ,SAAAA,IAAAA,eAAK,EAACF,IAAIe,IAAI,EAAEd,OAAO,mBAAKe,sBAAY,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM,IAAnGhB,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACAA,gCAAAA,iBAATC,QAASD;oBAChB,IAAI,CAACC,OAAOL,IAAIoB,UAAU,CAACnB;oBACrBK,IAAIe,IAAAA,gBAAM,EAAClB,OAAOG,CAAC,EAAwBN,IAAIoB,UAAU;oBACzDb,mBAAmBe,IAAAA,+BAAqB,EAACnB,MAAM,CAAC,qBAAqB,EAAwBH,IAAIoB,UAAU;oBAC3GZ,oBAAoBe,IAAAA,gCAAsB,EAACpB,MAAM,CAAC,sBAAsB,EAAwBH,IAAIoB,UAAU;oBAC9GX,SAASe,IAAAA,qBAAW,EAACrB;oBACrBO,YAAY;wBAAEJ,GAAAA;wBAAGC,kBAAAA;wBAAkBC,mBAAAA;uBAAsBiB,IAAAA,iBAAO,EAACtB;oBACjEQ,UAAUR,MAAM,CAAC,WAAW,KAAK;oBACvC;;wBAAMuB,IAAAA,gBAAM,EACV1B,KACAG,OAAOwB,MAAM,EACb;4BACEhB,SAAAA;4BACAiB,cAAc,SAAdA,aAAeC;gCACb,IAAMC,UAAUC,IAAAA,sBAAa,EAACF,KAAKnB,WAAWoB,OAAO;gCACrD,IAAMF,eAAe,IAAII,IAAsB;oCAAC;iCAAO;gCACvD,IAAIF,QAAQG,KAAK,KAAKC,WAAWN,aAAaO,GAAG,CAAC;gCAClD,OAAOP;4BACT;wBACF,GACA,SAAOQ,OAAOP,KAAKQ;;;;;;iDACbA,CAAAA,SAASN,IAAAA,sBAAa,EAACF,KAAKnB,WAAWoB,OAAO,CAACQ,OAAO,KAAKJ,SAAQ,GAAnEG;;;;;gDAC8BD;gDAAOP;;4CAAK;;gDAAMU,IAAAA,oBAAW,EAACH,OAAOP,KAAKnB;;;4CAA1E;;gDAAM8B,iCAAyB;oDAAa;;;;4CAA5C;;;4CAEQ;;gDAAM1B,IAAAA,gBAAM,EAACsB,OAAOP,KAAKxB,OAAOK;;;4CAA1C+B,mBAAS;gDAAC;gDAA4ChC;;;;;;;4BACxD;;;;oBAjBF;;;;;;IAmBF;;IACA,WAAeV"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/search.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 } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, SEARCH_FLAGS, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst searchCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.search}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...NO_BUILD, ...FORMAT, ...CONFIG, explain: { type: 'boolean' } });\n  const [terms] = positionals;\n  if (!terms) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError);\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 format = rowFormatOf(values);\n  const overrides = { k, explain: values.explain === true, snippetCharLimit, snippetCountLimit, ...scopeOf(values) };\n  const noBuild = values['no-build'] === true;\n  await withDb(\n    ctx,\n    values.config as string | undefined,\n    {\n      noBuild,\n      requirements: (cfg) => {\n        const signals = resolveSearch(cfg, 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, cfg, build) => {\n      if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n        await prepareDocumentEmbeddings(store, cfg, await scopedPaths(store, cfg, overrides));\n      }\n      const rows = await search(store, cfg, terms, overrides);\n      // Table cells use the shared renderer's width clipping; JSON retains the complete explanation.\n      const rendered = overrides.explain && format !== 'json' ? rows.map((row) => ({ ...row, explanation: JSON.stringify(row.explanation) })) : rows;\n      printRows(rendered, format);\n    }\n  );\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","usage","parse","values","positionals","terms","k","snippetCharLimit","snippetCountLimit","format","overrides","noBuild","USAGE","name","search","argv","SEARCH_FLAGS","NO_BUILD","FORMAT","CONFIG","explain","type","usageError","parseK","parseSnippetCharLimit","parseSnippetCountLimit","rowFormatOf","scopeOf","withDb","config","requirements","cfg","signals","resolveSearch","Set","words","undefined","add","store","build","rows","rendered","vectors","scopedPaths","prepareDocumentEmbeddings","map","row","explanation","JSON","stringify","printRows"],"mappings":";;;;+BA2CA;;;eAAA;;;uBA3C4B;wBACL;uBACO;wBACJ;sBACuC;wBAC3C;wBAC6H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGnJ,IAAMA,YAAqB,mBAAOC;;YAC1BC,OAC0BC,QAAxBC,QAAQC,aACAA,cAATC,OAEDC,GACAC,kBACAC,mBACAC,QACAC,WACAC;;;;oBATAV,QAAQ,AAAC,UAAqBW,OAAZZ,IAAIa,IAAI,EAAC,KAAgB,OAAbD,eAAK,CAACE,MAAM;oBAChBZ,SAAAA,IAAAA,eAAK,EAACF,IAAIe,IAAI,EAAEd,OAAO,wCAAKe,sBAAY,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;wBAAEC,SAAS;4BAAEC,MAAM;wBAAU;yBAAhIlB,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACAA,gCAAAA,iBAATC,QAASD;oBAChB,IAAI,CAACC,OAAOL,IAAIsB,UAAU,CAACrB;oBACrBK,IAAIiB,IAAAA,gBAAM,EAACpB,OAAOG,CAAC,EAAwBN,IAAIsB,UAAU;oBACzDf,mBAAmBiB,IAAAA,+BAAqB,EAACrB,MAAM,CAAC,qBAAqB,EAAwBH,IAAIsB,UAAU;oBAC3Gd,oBAAoBiB,IAAAA,gCAAsB,EAACtB,MAAM,CAAC,sBAAsB,EAAwBH,IAAIsB,UAAU;oBAC9Gb,SAASiB,IAAAA,qBAAW,EAACvB;oBACrBO,YAAY;wBAAEJ,GAAAA;wBAAGc,SAASjB,OAAOiB,OAAO,KAAK;wBAAMb,kBAAAA;wBAAkBC,mBAAAA;uBAAsBmB,IAAAA,iBAAO,EAACxB;oBACnGQ,UAAUR,MAAM,CAAC,WAAW,KAAK;oBACvC;;wBAAMyB,IAAAA,gBAAM,EACV5B,KACAG,OAAO0B,MAAM,EACb;4BACElB,SAAAA;4BACAmB,cAAc,SAAdA,aAAeC;gCACb,IAAMC,UAAUC,IAAAA,sBAAa,EAACF,KAAKrB,WAAWsB,OAAO;gCACrD,IAAMF,eAAe,IAAII,IAAsB;oCAAC;iCAAO;gCACvD,IAAIF,QAAQG,KAAK,KAAKC,WAAWN,aAAaO,GAAG,CAAC;gCAClD,OAAOP;4BACT;wBACF,GACA,SAAOQ,OAAOP,KAAKQ;;0CAIXC,MAEAC;;;;iDALFF,CAAAA,SAASN,IAAAA,sBAAa,EAACF,KAAKrB,WAAWsB,OAAO,CAACU,OAAO,KAAKN,SAAQ,GAAnEG;;;;;gDAC8BD;gDAAOP;;4CAAK;;gDAAMY,IAAAA,oBAAW,EAACL,OAAOP,KAAKrB;;;4CAA1E;;gDAAMkC,iCAAyB;oDAAa;;;;4CAA5C;;;4CAEW;;gDAAM9B,IAAAA,gBAAM,EAACwB,OAAOP,KAAK1B,OAAOK;;;4CAAvC8B,OAAO;4CACb,+FAA+F;4CACzFC,WAAW/B,UAAUU,OAAO,IAAIX,WAAW,SAAS+B,KAAKK,GAAG,CAAC,SAACC;uDAAS,wCAAKA;oDAAKC,aAAaC,KAAKC,SAAS,CAACH,IAAIC,WAAW;;iDAAQP;4CAC1IU,IAAAA,mBAAS,EAACT,UAAUhC;;;;;;4BACtB;;;;oBApBF;;;;;;IAsBF;;IACA,WAAeV"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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 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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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/sql.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, rowFormatOf, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst sqlCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.sql}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...NO_BUILD, ...FORMAT, ...CONFIG, preset: { type: 'string' } });\n  const [sql, ...params] = positionals;\n  if (!sql) ctx.usageError(usage);\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  const cfg = ctx.resolveConfig(values.config as string | undefined, { writeMigration: !noBuild, query: true });\n  await runSql(cfg, sql, params, format, 'ad-hoc statement', noBuild, values.preset as string | undefined);\n};\nexport default sqlCmd;\n"],"names":["sqlCmd","ctx","usage","parse","values","positionals","sql","params","format","noBuild","cfg","USAGE","name","argv","NO_BUILD","FORMAT","CONFIG","preset","type","usageError","rowFormatOf","resolveConfig","config","writeMigration","query","runSql"],"mappings":";;;;+BAcA;;;eAAA;;;uBAdsB;wBAC+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGrE,IAAMA,SAAkB,gBAAOC;;YACvBC,OAC0BC,QAAxBC,QAAQC,aACSA,cAAlBC,KAAQC,QAETC,QACAC,SACAC;;;;oBANAR,QAAQ,AAAC,UAAqBS,OAAZV,IAAIW,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACL,GAAG;oBACbH,SAAAA,IAAAA,eAAK,EAACF,IAAIY,IAAI,EAAEX,OAAO,wCAAKY,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;wBAAEC,QAAQ;4BAAEC,MAAM;wBAAS;yBAA7Gd,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACSA,yBAAAA,cAAlBC,MAAkBD,iBAAVE,SAAUF,mBAAb;oBACZ,IAAI,CAACC,KAAKL,IAAIkB,UAAU,CAACjB;oBACnBM,SAASY,IAAAA,qBAAW,EAAChB;oBACrBK,UAAUL,MAAM,CAAC,WAAW,KAAK;oBACjCM,MAAMT,IAAIoB,aAAa,CAACjB,OAAOkB,MAAM,EAAwB;wBAAEC,gBAAgB,CAACd;wBAASe,OAAO;oBAAK;oBAC3G;;wBAAMC,IAAAA,gBAAM,EAACf,KAAKJ,KAAKC,QAAQC,QAAQ,oBAAoBC,SAASL,OAAOa,MAAM;;;oBAAjF;;;;;;IACF;;IACA,WAAejB"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/sql.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, rowFormatOf, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst sqlCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.sql}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...NO_BUILD, ...FORMAT, ...CONFIG, preset: { type: 'string' } });\n  const [sql, ...params] = positionals;\n  if (!sql) ctx.usageError(usage);\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  const cfg = ctx.resolveConfig(values.config as string | undefined, { writeMigration: !noBuild, query: true });\n  await runSql(cfg, sql, params, format, 'ad-hoc statement', noBuild, values.preset as string | undefined);\n};\nexport default sqlCmd;\n"],"names":["sqlCmd","ctx","usage","parse","values","positionals","sql","params","format","noBuild","cfg","USAGE","name","argv","NO_BUILD","FORMAT","CONFIG","preset","type","usageError","rowFormatOf","resolveConfig","config","writeMigration","query","runSql"],"mappings":";;;;+BAcA;;;eAAA;;;uBAdsB;wBAC+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGrE,IAAMA,SAAkB,gBAAOC;;YACvBC,OAC0BC,QAAxBC,QAAQC,aACSA,cAAlBC,KAAQC,QAETC,QACAC,SACAC;;;;oBANAR,QAAQ,AAAC,UAAqBS,OAAZV,IAAIW,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACL,GAAG;oBACbH,SAAAA,IAAAA,eAAK,EAACF,IAAIY,IAAI,EAAEX,OAAO,wCAAKY,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;wBAAEC,QAAQ;4BAAEC,MAAM;wBAAS;yBAA7Gd,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACSA,yBAAAA,cAAlBC,MAAkBD,iBAAVE,SAAUF,mBAAb;oBACZ,IAAI,CAACC,KAAKL,IAAIkB,UAAU,CAACjB;oBACnBM,SAASY,IAAAA,qBAAW,EAAChB;oBACrBK,UAAUL,MAAM,CAAC,WAAW,KAAK;oBACjCM,MAAMT,IAAIoB,aAAa,CAACjB,OAAOkB,MAAM,EAAwB;wBAAEC,gBAAgB,CAACd;wBAASe,OAAO;oBAAK;oBAC3G;;wBAAMC,IAAAA,gBAAM,EAACf,KAAKJ,KAAKC,QAAQC,QAAQ,oBAAoBC,SAASL,OAAOa,MAAM;;;oBAAjF;;;;;;IACF;;IACA,WAAejB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { dirname, join } from 'node:path';\nimport { presetCoverage } from '../commands/status.ts';\nimport { embedConfig, featureStates, STATE_DIR, SUPPORTED_CONFIG_VERSION } from '../config/index.ts';\nimport { languageDistribution } from '../embed/distribution.ts';\nimport { probeReachable } from '../embed/http.ts';\nimport { isDownloadable, MODEL_FILENAMES, modelDir, modelPresent, readLanguages } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { featuresLine, presetsLines, stringifyJson } from '../output/output.ts';\nimport type { OpenResult } from '../store/index.ts';\nimport { docCount, getMeta, lexicalReadiness, openStore, storeFilename } from '../store/index.ts';\nimport type { Store } from '../store/types.ts';\nimport { readWatchClaim } from '../watch-claim.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// status names what you cannot read off the config file: locations sense chose, values it derived, state it stored. Config content itself is not echoed, since duplicating its globs here would create two places that disagree after an edit.\n// The exception is the embed block's url and key, whose effect is remote and otherwise invisible.\n\n// A failed or interrupted vector preparation can leave core and lexical state usable. Status is\n// observational, so it reports that pending capability instead of repairing it.\nasync function vectorState(store: Store): Promise<{ embedded: number; pending: number } | null> {\n  try {\n    const stmt = await store.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings');\n    return (await stmt.get()) as { embedded: number; pending: number };\n  } catch {\n    return null;\n  }\n}\n\nasync function parseErrorCount(store: Store): Promise<number> {\n  const stmt = await store.prepare(`SELECT COUNT(*) AS n FROM frontmatter WHERE \"_parse_error\" IS NOT NULL`);\n  return ((await stmt.get()) as { n: number }).n;\n}\n\n// A URL can carry credentials in its userinfo (https://user:pass@host/v1). status output gets\n// pasted into issues and transcripts, so it is always safe to paste.\nexport function redactUrl(url: string): string {\n  try {\n    const parsed = new URL(url);\n    if (!parsed.username && !parsed.password) return url;\n    parsed.username = '';\n    parsed.password = '';\n    return `${parsed.toString().replace(/\\/$/, '')} (credentials redacted)`;\n  } catch {\n    return url;\n  }\n}\n\n// A stopped Ollama/LM Studio/Cohere endpoint prints identically to a running one otherwise; any\n// HTTP response counts as reachable (probeReachable), so this only distinguishes up from down.\nasync function embedReachable(e: { provider: string; url?: string }): Promise<boolean | null> {\n  if (e.provider === 'static' || (e.provider === 'openai' && !e.url)) return null;\n  const base = (e.url ?? 'https://api.cohere.com').replace(/\\/+$/, '');\n  return probeReachable(e.provider === 'openai' ? `${base}/models` : base);\n}\n\ntype LanguagesState = 'declared' | 'none' | 'unresolved' | null;\n\n// Config-declared languages win over the model card, for every provider, as registry.ts does.\n// A local-path model has no card by design, so it is never \"unresolved\": that means an HF id.\nfunction languagesInfo(e: NonNullable<ReturnType<typeof embedConfig>>): { languages: string[] | null; state: LanguagesState; source: 'config' | 'card' | null } {\n  if (e.languages) return { languages: e.languages, state: 'declared', source: 'config' };\n  if (e.provider !== 'static' || !isDownloadable(e.model)) return { languages: null, state: null, source: null };\n  const cardLanguages = readLanguages(e.model);\n  if (cardLanguages === undefined) return { languages: null, state: 'unresolved', source: null };\n  if (cardLanguages.length === 0) return { languages: null, state: 'none', source: null };\n  return { languages: cardLanguages, state: 'declared', source: 'card' };\n}\n\nconst status: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.status}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined, { writeMigration: false });\n  const lexical = await lexicalReadiness(cfg);\n  let opened: OpenResult;\n  try {\n    opened = await openStore(cfg, { build: false });\n  } catch (err) {\n    if (!(err instanceof SenseError) || err.code !== 'INDEX_NOT_READY') throw err;\n    const configDir = cfg.configDir ?? cfg.rootDir ?? cfg.baseDir;\n    const dbPath = join(configDir, STATE_DIR, storeFilename(cfg));\n    const watcher = readWatchClaim(configDir);\n    const result = {\n      config: cfg.configPath,\n      configVersion: SUPPORTED_CONFIG_VERSION,\n      migratedFrom: cfg.migratedFrom ?? null,\n      unknownConfigKeys: cfg.unknownKeys ?? null,\n      tree: cfg.rootDir ?? cfg.baseDir,\n      treeRoot: cfg.rootDir ?? cfg.baseDir,\n      configDir,\n      cache: dirname(dbPath),\n      db: dbPath,\n      indexReady: false,\n      indexError: err.message,\n      lexicalReady: lexical.ready,\n      lexicalError: lexical.error,\n      watcherPid: watcher ? String(watcher.pid) : null,\n      watcherHeartbeatSecondsAgo: watcher ? Math.round((Date.now() - watcher.heartbeatMs) / 1000) : null,\n    };\n    if (format === 'json') {\n      console.log(stringifyJson(result, 2));\n    } else {\n      const migrated = cfg.migratedFrom !== undefined ? `, migration from v${cfg.migratedFrom} pending` : '';\n      console.log(`config:   ${result.config} (v${SUPPORTED_CONFIG_VERSION}${migrated})`);\n      console.log(`tree root: ${result.treeRoot}`);\n      console.log(`configDir: ${result.configDir}`);\n      console.log(`cache:    ${result.cache}`);\n      console.log(`index:    not ready (${result.indexError})`);\n      console.log(`lexical:  ${result.lexicalReady ? 'ready' : `not ready (${result.lexicalError})`}`);\n      const pid = result.watcherPid ? `pid ${result.watcherPid}, ` : '';\n      console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher:  none' : `watcher:  ${pid}last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    }\n    return;\n  }\n  const { store, dbPath, warnings } = opened;\n  try {\n    printWarnings(warnings);\n\n    const features = featureStates(cfg);\n    const e = embedConfig(cfg);\n    const hasModel = e ? modelPresent(cfg) : false;\n    const reachable = e ? await embedReachable(e) : null;\n    const vectors = e ? await vectorState(store) : null;\n    const presets = await presetCoverage(store, cfg);\n    const { languages: declaredLanguages, state: languagesState, source: languagesSource } = e ? languagesInfo(e) : { languages: null, state: null, source: null };\n    const detectedLanguages = (await languageDistribution(store)) ?? null;\n    // This is the compatible cache's stored version. Observational open refuses a mismatch rather\n    // than rebuilding it before this read.\n    const cacheSchema = await getMeta(store, 'schema_version');\n    // Each store owns what it reports and how it is worded (Store.engineStatus); this command\n    // prints entries generically, without branching on any store's name.\n    const engine = await store.engineStatus();\n    const watcher = readWatchClaim(cfg.configDir ?? cfg.rootDir ?? cfg.baseDir);\n    // The env var holds the token; only its name and whether it is set are ever reported.\n    const keyEnv = e?.key ? { name: e.key, set: (process.env[e.key] ?? '') !== '' } : null;\n    const result = {\n      config: cfg.configPath,\n      configVersion: SUPPORTED_CONFIG_VERSION,\n      migratedFrom: cfg.migratedFrom ?? null,\n      unknownConfigKeys: cfg.unknownKeys ?? null,\n      tree: cfg.rootDir ?? cfg.baseDir,\n      treeRoot: cfg.rootDir ?? cfg.baseDir,\n      configDir: cfg.configDir ?? cfg.baseDir,\n      cache: dirname(dbPath),\n      db: dbPath,\n      indexReady: true,\n      indexError: null,\n      lexicalReady: lexical.ready,\n      lexicalError: lexical.error,\n      cacheSchema,\n      docs: await docCount(store),\n      unparseableFrontmatter: await parseErrorCount(store),\n      features: features.on,\n      featuresOff: features.off,\n      embed: e ? { provider: e.provider, model: e.model, dir: e.provider === 'static' ? modelDir(e.model) : null, url: e.url ? redactUrl(e.url) : null, reachable, keyEnv, downloaded: hasModel, languages: declaredLanguages, languagesState, detectedLanguages, ...(vectors ?? {}) } : null,\n      presets,\n      queries: Object.keys(cfg.queries ?? {}).length,\n      watcherPid: watcher ? String(watcher.pid) : null,\n      watcherHeartbeatSecondsAgo: watcher ? Math.round((Date.now() - watcher.heartbeatMs) / 1000) : null,\n      engine,\n    };\n\n    if (format === 'json') {\n      console.log(stringifyJson(result, 2));\n    } else {\n      const migrated = cfg.migratedFrom !== undefined ? `, migration from v${cfg.migratedFrom} applied in memory` : '';\n      console.log(`config:   ${result.config} (v${SUPPORTED_CONFIG_VERSION}${migrated})`);\n      // A load-time stderr warning has scrolled away by the time anyone looks here.\n      if (cfg.unknownKeys) console.log(`          unknown keys, ignored: ${cfg.unknownKeys.join(', ')}`);\n      console.log(`tree root: ${result.treeRoot}`);\n      console.log(`configDir: ${result.configDir}`);\n      console.log(`cache:    ${result.cache} (schema ${result.cacheSchema}; ${ctx.name} build --force to recreate)`);\n      console.log(`lexical:  ${result.lexicalReady ? 'ready' : `not ready (${result.lexicalError})`}`);\n      console.log(`docs:     ${result.docs}${result.unparseableFrontmatter > 0 ? `  (${result.unparseableFrontmatter} with unparseable frontmatter: WHERE _parse_error IS NOT NULL)` : ''}`);\n      console.log('');\n      console.log(featuresLine(features));\n      // One authoritative block, off states included: an absent model reads as a degraded search,\n      // not as an empty corpus.\n      if (!e) console.log('embed:    off (no preset asks for vectors)');\n      else {\n        console.log(`embed:    ${e.provider} ${e.model}`);\n        if (e.provider === 'static') console.log(`          model:   ${modelDir(e.model)} (${hasModel ? 'present' : `missing, ${isDownloadable(e.model) ? `fetches when build, watch, or a vector query needs it; run \\`${ctx.name} download\\` to prefetch` : `no ${MODEL_FILENAMES} in that directory`}`})`);\n        if (declaredLanguages && languagesSource === 'config') console.log(`          languages: ${declaredLanguages.join(', ')} (declared in embed.languages)`);\n        else if (declaredLanguages && languagesSource === 'card') console.log(`          languages: ${declaredLanguages.join(', ')} (declared by the model card)`);\n        else if (languagesState === 'none') console.log('          languages: none declared by the model card');\n        else if (languagesState === 'unresolved') console.log(`          languages: unresolved (model card unreachable; run \\`${ctx.name} download\\`)`);\n        // Cohere defaults to api.cohere.com with no url in the config; show it anyway so the\n        // reachability probe below has something to name.\n        if (e.url || reachable !== null) {\n          const shown = e.url ? redactUrl(e.url) : 'https://api.cohere.com (default)';\n          console.log(`          url:     ${shown}${reachable === null ? '' : reachable ? ' (reachable)' : ' (unreachable)'}`);\n        }\n        if (keyEnv) console.log(`          key:     env ${keyEnv.name} (${keyEnv.set ? 'set' : 'NOT SET'})`);\n        if (!hasModel) console.log('          vectors: unavailable until the model is present; semantic queries fail, while lexical-only presets remain usable');\n        else if (vectors) console.log(`          vectors: ${vectors.embedded} embedded, ${vectors.pending} pending${vectors.pending > 0 ? ` (run \\`${ctx.name} build\\` to prepare all configured vectors)` : ''}`);\n        if (detectedLanguages) {\n          const total = Object.values(detectedLanguages).reduce((a, b) => a + b, 0);\n          const breakdown = Object.entries(detectedLanguages)\n            .sort((a, b) => b[1] - a[1])\n            .map(([code, n]) => `${code} ${Math.round((n / total) * 100)}%`)\n            .join(', ');\n          console.log(`          detected: ${breakdown} (${total} chunks classified)`);\n        }\n      }\n      console.log('');\n      for (const line of presetsLines(presets)) console.log(line);\n      console.log('');\n      console.log(`queries:  ${result.queries} saved (${ctx.name} --list)`);\n      const pid = result.watcherPid ? `pid ${result.watcherPid}, ` : '';\n      console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher:  none' : `watcher:  ${pid}last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n      for (const [key, value] of Object.entries(result.engine)) console.log(`${`${store.name}:`.padEnd(10)}${key} ${value}`);\n    }\n  } finally {\n    await store.close();\n  }\n};\nexport default status;\n"],"names":["redactUrl","vectorState","store","stmt","prepare","get","parseErrorCount","n","url","parsed","URL","username","password","toString","replace","embedReachable","e","base","provider","probeReachable","languagesInfo","languages","state","source","isDownloadable","model","cardLanguages","readLanguages","undefined","length","status","ctx","values","format","cfg","lexical","opened","err","configDir","dbPath","watcher","result","migrated","pid","warnings","process","features","hasModel","reachable","vectors","presets","declaredLanguages","languagesState","languagesSource","detectedLanguages","cacheSchema","engine","keyEnv","shown","total","breakdown","line","key","value","parse","argv","USAGE","name","FORMAT","CONFIG","formatOf","resolveConfig","config","writeMigration","lexicalReadiness","openStore","build","SenseError","code","rootDir","baseDir","join","STATE_DIR","storeFilename","readWatchClaim","configPath","configVersion","SUPPORTED_CONFIG_VERSION","migratedFrom","unknownConfigKeys","unknownKeys","tree","treeRoot","cache","dirname","db","indexReady","indexError","message","lexicalReady","ready","lexicalError","error","watcherPid","String","watcherHeartbeatSecondsAgo","Math","round","Date","now","heartbeatMs","console","log","stringifyJson","printWarnings","featureStates","embedConfig","modelPresent","presetCoverage","languageDistribution","getMeta","engineStatus","set","env","docCount","docs","unparseableFrontmatter","on","featuresOff","off","embed","dir","modelDir","downloaded","queries","Object","keys","featuresLine","MODEL_FILENAMES","embedded","pending","reduce","a","b","entries","sort","map","presetsLines","padEnd","close"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { dirname, join } from 'node:path';\nimport { presetCoverage } from '../commands/status.ts';\nimport { embedConfig, featureStates, STATE_DIR, SUPPORTED_CONFIG_VERSION } from '../config/index.ts';\nimport { languageDistribution } from '../embed/distribution.ts';\nimport { probeReachable } from '../embed/http.ts';\nimport { isDownloadable, MODEL_FILENAMES, modelDir, modelPresent, readLanguages } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { featuresLine, presetsLines, stringifyJson } from '../output/output.ts';\nimport type { OpenResult } from '../store/index.ts';\nimport { docCount, getMeta, lexicalReadiness, openStore, storeFilename } from '../store/index.ts';\nimport type { Store } from '../store/types.ts';\nimport { readWatchClaim } from '../watch-claim.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// status names what you cannot read off the config file: locations sense chose, values it derived, state it stored. Config content itself is not echoed, since duplicating its globs here would create two places that disagree after an edit.\n// The exception is the embed block's url and key, whose effect is remote and otherwise invisible.\n\n// A failed or interrupted vector preparation can leave core and lexical state usable. Status is\n// observational, so it reports that pending capability instead of repairing it.\nasync function vectorState(store: Store): Promise<{ embedded: number; pending: number } | null> {\n  try {\n    const stmt = await store.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings');\n    return (await stmt.get()) as { embedded: number; pending: number };\n  } catch {\n    return null;\n  }\n}\n\nasync function parseErrorCount(store: Store): Promise<number> {\n  const stmt = await store.prepare(`SELECT COUNT(*) AS n FROM frontmatter WHERE \"_parse_error\" IS NOT NULL`);\n  return ((await stmt.get()) as { n: number }).n;\n}\n\n// A URL can carry credentials in its userinfo (https://user:pass@host/v1). status output gets\n// pasted into issues and transcripts, so it is always safe to paste.\nexport function redactUrl(url: string): string {\n  try {\n    const parsed = new URL(url);\n    if (!parsed.username && !parsed.password) return url;\n    parsed.username = '';\n    parsed.password = '';\n    return `${parsed.toString().replace(/\\/$/, '')} (credentials redacted)`;\n  } catch {\n    return url;\n  }\n}\n\n// A stopped Ollama/LM Studio/Cohere endpoint prints identically to a running one otherwise; any\n// HTTP response counts as reachable (probeReachable), so this only distinguishes up from down.\nasync function embedReachable(e: { provider: string; url?: string }): Promise<boolean | null> {\n  if (e.provider === 'static' || (e.provider === 'openai' && !e.url)) return null;\n  const base = (e.url ?? 'https://api.cohere.com').replace(/\\/+$/, '');\n  return probeReachable(e.provider === 'openai' ? `${base}/models` : base);\n}\n\ntype LanguagesState = 'declared' | 'none' | 'unresolved' | null;\n\n// Config-declared languages win over the model card, for every provider, as registry.ts does.\n// A local-path model has no card by design, so it is never \"unresolved\": that means an HF id.\nfunction languagesInfo(e: NonNullable<ReturnType<typeof embedConfig>>): { languages: string[] | null; state: LanguagesState; source: 'config' | 'card' | null } {\n  if (e.languages) return { languages: e.languages, state: 'declared', source: 'config' };\n  if (e.provider !== 'static' || !isDownloadable(e.model)) return { languages: null, state: null, source: null };\n  const cardLanguages = readLanguages(e.model);\n  if (cardLanguages === undefined) return { languages: null, state: 'unresolved', source: null };\n  if (cardLanguages.length === 0) return { languages: null, state: 'none', source: null };\n  return { languages: cardLanguages, state: 'declared', source: 'card' };\n}\n\nconst status: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.status}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined, { writeMigration: false });\n  const lexical = await lexicalReadiness(cfg);\n  let opened: OpenResult;\n  try {\n    opened = await openStore(cfg, { build: false });\n  } catch (err) {\n    if (!(err instanceof SenseError) || err.code !== 'INDEX_NOT_READY') throw err;\n    const configDir = cfg.configDir ?? cfg.rootDir ?? cfg.baseDir;\n    const dbPath = join(configDir, STATE_DIR, storeFilename(cfg));\n    const watcher = readWatchClaim(configDir);\n    const result = {\n      config: cfg.configPath,\n      configVersion: SUPPORTED_CONFIG_VERSION,\n      migratedFrom: cfg.migratedFrom ?? null,\n      unknownConfigKeys: cfg.unknownKeys ?? null,\n      tree: cfg.rootDir ?? cfg.baseDir,\n      treeRoot: cfg.rootDir ?? cfg.baseDir,\n      configDir,\n      cache: dirname(dbPath),\n      db: dbPath,\n      indexReady: false,\n      indexError: err.message,\n      lexicalReady: lexical.ready,\n      lexicalError: lexical.error,\n      watcherPid: watcher ? String(watcher.pid) : null,\n      watcherHeartbeatSecondsAgo: watcher ? Math.round((Date.now() - watcher.heartbeatMs) / 1000) : null,\n    };\n    if (format === 'json') {\n      console.log(stringifyJson(result, 2));\n    } else {\n      const migrated = cfg.migratedFrom !== undefined ? `, migration from v${cfg.migratedFrom} pending` : '';\n      console.log(`config:   ${result.config} (v${SUPPORTED_CONFIG_VERSION}${migrated})`);\n      console.log(`tree root: ${result.treeRoot}`);\n      console.log(`configDir: ${result.configDir}`);\n      console.log(`cache:    ${result.cache}`);\n      console.log(`index:    not ready (${result.indexError})`);\n      console.log(`lexical:  ${result.lexicalReady ? 'ready' : `not ready (${result.lexicalError})`}`);\n      const pid = result.watcherPid ? `pid ${result.watcherPid}, ` : '';\n      console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher:  none' : `watcher:  ${pid}last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    }\n    return;\n  }\n  const { store, dbPath, warnings } = opened;\n  try {\n    printWarnings(warnings);\n\n    const features = featureStates(cfg);\n    const e = embedConfig(cfg);\n    const hasModel = e ? modelPresent(cfg) : false;\n    const reachable = e ? await embedReachable(e) : null;\n    const vectors = e ? await vectorState(store) : null;\n    const presets = await presetCoverage(store, cfg);\n    const { languages: declaredLanguages, state: languagesState, source: languagesSource } = e ? languagesInfo(e) : { languages: null, state: null, source: null };\n    const detectedLanguages = (await languageDistribution(store)) ?? null;\n    // This is the compatible cache's stored version. Observational open refuses a mismatch rather\n    // than rebuilding it before this read.\n    const cacheSchema = await getMeta(store, 'schema_version');\n    // Each store owns what it reports and how it is worded (Store.engineStatus); this command\n    // prints entries generically, without branching on any store's name.\n    const engine = await store.engineStatus();\n    const watcher = readWatchClaim(cfg.configDir ?? cfg.rootDir ?? cfg.baseDir);\n    // The env var holds the token; only its name and whether it is set are ever reported.\n    const keyEnv = e?.key ? { name: e.key, set: (process.env[e.key] ?? '') !== '' } : null;\n    const result = {\n      config: cfg.configPath,\n      configVersion: SUPPORTED_CONFIG_VERSION,\n      migratedFrom: cfg.migratedFrom ?? null,\n      unknownConfigKeys: cfg.unknownKeys ?? null,\n      tree: cfg.rootDir ?? cfg.baseDir,\n      treeRoot: cfg.rootDir ?? cfg.baseDir,\n      configDir: cfg.configDir ?? cfg.baseDir,\n      cache: dirname(dbPath),\n      db: dbPath,\n      indexReady: true,\n      indexError: null,\n      lexicalReady: lexical.ready,\n      lexicalError: lexical.error,\n      cacheSchema,\n      docs: await docCount(store),\n      unparseableFrontmatter: await parseErrorCount(store),\n      features: features.on,\n      featuresOff: features.off,\n      embed: e ? { provider: e.provider, model: e.model, dir: e.provider === 'static' ? modelDir(e.model) : null, url: e.url ? redactUrl(e.url) : null, reachable, keyEnv, downloaded: hasModel, languages: declaredLanguages, languagesState, detectedLanguages, ...(vectors ?? {}) } : null,\n      presets,\n      queries: Object.keys(cfg.queries ?? {}).length,\n      watcherPid: watcher ? String(watcher.pid) : null,\n      watcherHeartbeatSecondsAgo: watcher ? Math.round((Date.now() - watcher.heartbeatMs) / 1000) : null,\n      engine,\n    };\n\n    if (format === 'json') {\n      console.log(stringifyJson(result, 2));\n    } else {\n      const migrated = cfg.migratedFrom !== undefined ? `, migration from v${cfg.migratedFrom} applied in memory` : '';\n      console.log(`config:   ${result.config} (v${SUPPORTED_CONFIG_VERSION}${migrated})`);\n      // A load-time stderr warning has scrolled away by the time anyone looks here.\n      if (cfg.unknownKeys) console.log(`          unknown keys, ignored: ${cfg.unknownKeys.join(', ')}`);\n      console.log(`tree root: ${result.treeRoot}`);\n      console.log(`configDir: ${result.configDir}`);\n      console.log(`cache:    ${result.cache} (schema ${result.cacheSchema}; ${ctx.name} build --force to recreate)`);\n      console.log(`lexical:  ${result.lexicalReady ? 'ready' : `not ready (${result.lexicalError})`}`);\n      console.log(`docs:     ${result.docs}${result.unparseableFrontmatter > 0 ? `  (${result.unparseableFrontmatter} with unparseable frontmatter: WHERE _parse_error IS NOT NULL)` : ''}`);\n      console.log('');\n      console.log(featuresLine(features));\n      // One authoritative block, off states included: an absent model reads as a degraded search,\n      // not as an empty corpus.\n      if (!e) console.log('embed:    off (no preset asks for vectors)');\n      else {\n        console.log(`embed:    ${e.provider} ${e.model}`);\n        if (e.provider === 'static') console.log(`          model:   ${modelDir(e.model)} (${hasModel ? 'present' : `missing, ${isDownloadable(e.model) ? `fetches when build, watch, or a vector query needs it; run \\`${ctx.name} download\\` to prefetch` : `no ${MODEL_FILENAMES} in that directory`}`})`);\n        if (declaredLanguages && languagesSource === 'config') console.log(`          languages: ${declaredLanguages.join(', ')} (declared in embed.languages)`);\n        else if (declaredLanguages && languagesSource === 'card') console.log(`          languages: ${declaredLanguages.join(', ')} (declared by the model card)`);\n        else if (languagesState === 'none') console.log('          languages: none declared by the model card');\n        else if (languagesState === 'unresolved') console.log(`          languages: unresolved (model card unreachable; run \\`${ctx.name} download\\`)`);\n        // Cohere defaults to api.cohere.com with no url in the config; show it anyway so the\n        // reachability probe below has something to name.\n        if (e.url || reachable !== null) {\n          const shown = e.url ? redactUrl(e.url) : 'https://api.cohere.com (default)';\n          console.log(`          url:     ${shown}${reachable === null ? '' : reachable ? ' (reachable)' : ' (unreachable)'}`);\n        }\n        if (keyEnv) console.log(`          key:     env ${keyEnv.name} (${keyEnv.set ? 'set' : 'NOT SET'})`);\n        if (!hasModel) console.log('          vectors: unavailable until the model is present; semantic queries fail, while lexical-only presets remain usable');\n        else if (vectors) console.log(`          vectors: ${vectors.embedded} embedded, ${vectors.pending} pending${vectors.pending > 0 ? ` (run \\`${ctx.name} build\\` to prepare all configured vectors)` : ''}`);\n        if (detectedLanguages) {\n          const total = Object.values(detectedLanguages).reduce((a, b) => a + b, 0);\n          const breakdown = Object.entries(detectedLanguages)\n            .sort((a, b) => b[1] - a[1])\n            .map(([code, n]) => `${code} ${Math.round((n / total) * 100)}%`)\n            .join(', ');\n          console.log(`          detected: ${breakdown} (${total} chunks classified)`);\n        }\n      }\n      console.log('');\n      for (const line of presetsLines(presets)) console.log(line);\n      console.log('');\n      console.log(`queries:  ${result.queries} saved (${ctx.name} --list)`);\n      const pid = result.watcherPid ? `pid ${result.watcherPid}, ` : '';\n      console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher:  none' : `watcher:  ${pid}last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n      for (const [key, value] of Object.entries(result.engine)) console.log(`${`${store.name}:`.padEnd(10)}${key} ${value}`);\n    }\n  } finally {\n    await store.close();\n  }\n};\nexport default status;\n"],"names":["redactUrl","vectorState","store","stmt","prepare","get","parseErrorCount","n","url","parsed","URL","username","password","toString","replace","embedReachable","e","base","provider","probeReachable","languagesInfo","languages","state","source","isDownloadable","model","cardLanguages","readLanguages","undefined","length","status","ctx","values","format","cfg","lexical","opened","err","configDir","dbPath","watcher","result","migrated","pid","warnings","process","features","hasModel","reachable","vectors","presets","declaredLanguages","languagesState","languagesSource","detectedLanguages","cacheSchema","engine","keyEnv","shown","total","breakdown","line","key","value","parse","argv","USAGE","name","FORMAT","CONFIG","formatOf","resolveConfig","config","writeMigration","lexicalReadiness","openStore","build","SenseError","code","rootDir","baseDir","join","STATE_DIR","storeFilename","readWatchClaim","configPath","configVersion","SUPPORTED_CONFIG_VERSION","migratedFrom","unknownConfigKeys","unknownKeys","tree","treeRoot","cache","dirname","db","indexReady","indexError","message","lexicalReady","ready","lexicalError","error","watcherPid","String","watcherHeartbeatSecondsAgo","Math","round","Date","now","heartbeatMs","console","log","stringifyJson","printWarnings","featureStates","embedConfig","modelPresent","presetCoverage","languageDistribution","getMeta","engineStatus","set","env","docCount","docs","unparseableFrontmatter","on","featuresOff","off","embed","dir","modelDir","downloaded","queries","Object","keys","featuresLine","MODEL_FILENAMES","embedded","pending","reduce","a","b","entries","sort","map","presetsLines","padEnd","close"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/watch.ts"],"sourcesContent":["import type { WatchEvent } from '../watch.ts';\nimport { runWatch } from '../watch.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst watch: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.watch}`, { force: { type: 'boolean', default: false }, ...CONFIG });\n  await runWatch(ctx.resolveConfig(values.config as string | undefined), {\n    force: values.force as boolean,\n    onEvent: (event: WatchEvent) => {\n      if (event.type === 'started') {\n        console.log(`${ctx.name} watch: watching ${event.rootDir}`);\n        console.log(`${ctx.name} watch: db ${event.dbPath}`);\n      } else if (event.type === 'reconciled') {\n        printWarnings(event.warnings);\n        if (event.parsed > 0) console.log(`${ctx.name} watch: reconciled, ${event.parsed} file(s) reparsed (${event.total} total)`);\n      } else {\n        console.error(`${ctx.name} watch: reconcile error: ${event.message}`);\n      }\n    },\n  });\n};\nexport default watch;\n"],"names":["watch","ctx","values","parse","argv","USAGE","name","force","type","default","CONFIG","runWatch","resolveConfig","config","onEvent","event","console","log","rootDir","dbPath","printWarnings","warnings","parsed","total","error","message"],"mappings":";;;;+BAuBA;;;eAAA;;;uBAtByB;uBACH;wBACuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7C,IAAMA,QAAiB,eAAOC;;YACpBC;;;;oBAAAA,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAe,OAAZD,cAAK,CAACL,KAAK,GAAI;wBAAEO,OAAO;4BAAEC,MAAM;4BAAWC,SAAS;wBAAM;uBAAMC,gBAAM,GAAvHR;oBACR;;wBAAMS,IAAAA,iBAAQ,EAACV,IAAIW,aAAa,CAACV,OAAOW,MAAM,GAAyB;4BACrEN,OAAOL,OAAOK,KAAK;4BACnBO,SAAS,SAATA,QAAUC;gCACR,IAAIA,MAAMP,IAAI,KAAK,WAAW;oCAC5BQ,QAAQC,GAAG,CAAC,AAAC,GAA8BF,OAA5Bd,IAAIK,IAAI,EAAC,qBAAiC,OAAdS,MAAMG,OAAO;oCACxDF,QAAQC,GAAG,CAAC,AAAC,GAAwBF,OAAtBd,IAAIK,IAAI,EAAC,eAA0B,OAAbS,MAAMI,MAAM;gCACnD,OAAO,IAAIJ,MAAMP,IAAI,KAAK,cAAc;oCACtCY,IAAAA,uBAAa,EAACL,MAAMM,QAAQ;oCAC5B,IAAIN,MAAMO,MAAM,GAAG,GAAGN,QAAQC,GAAG,CAAC,AAAC,GAAiCF,OAA/Bd,IAAIK,IAAI,EAAC,wBAAwDS,OAAlCA,MAAMO,MAAM,EAAC,uBAAiC,OAAZP,MAAMQ,KAAK,EAAC;gCACpH,OAAO;oCACLP,QAAQQ,KAAK,CAAC,AAAC,GAAsCT,OAApCd,IAAIK,IAAI,EAAC,6BAAyC,OAAdS,MAAMU,OAAO;gCACpE;4BACF;wBACF;;;oBAbA;;;;;;IAcF;;IACA,WAAezB"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/cli/watch.ts"],"sourcesContent":["import type { WatchEvent } from '../watch.ts';\nimport { runWatch } from '../watch.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst watch: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.watch}`, { force: { type: 'boolean', default: false }, ...CONFIG });\n  await runWatch(ctx.resolveConfig(values.config as string | undefined), {\n    force: values.force as boolean,\n    onEvent: (event: WatchEvent) => {\n      if (event.type === 'started') {\n        console.log(`${ctx.name} watch: watching ${event.rootDir}`);\n        console.log(`${ctx.name} watch: db ${event.dbPath}`);\n      } else if (event.type === 'reconciled') {\n        printWarnings(event.warnings);\n        if (event.parsed > 0) console.log(`${ctx.name} watch: reconciled, ${event.parsed} file(s) reparsed (${event.total} total)`);\n      } else {\n        console.error(`${ctx.name} watch: reconcile error: ${event.message}`);\n      }\n    },\n  });\n};\nexport default watch;\n"],"names":["watch","ctx","values","parse","argv","USAGE","name","force","type","default","CONFIG","runWatch","resolveConfig","config","onEvent","event","console","log","rootDir","dbPath","printWarnings","warnings","parsed","total","error","message"],"mappings":";;;;+BAuBA;;;eAAA;;;uBAtByB;uBACH;wBACuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7C,IAAMA,QAAiB,eAAOC;;YACpBC;;;;oBAAAA,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAe,OAAZD,cAAK,CAACL,KAAK,GAAI;wBAAEO,OAAO;4BAAEC,MAAM;4BAAWC,SAAS;wBAAM;uBAAMC,gBAAM,GAAvHR;oBACR;;wBAAMS,IAAAA,iBAAQ,EAACV,IAAIW,aAAa,CAACV,OAAOW,MAAM,GAAyB;4BACrEN,OAAOL,OAAOK,KAAK;4BACnBO,SAAS,SAATA,QAAUC;gCACR,IAAIA,MAAMP,IAAI,KAAK,WAAW;oCAC5BQ,QAAQC,GAAG,CAAC,AAAC,GAA8BF,OAA5Bd,IAAIK,IAAI,EAAC,qBAAiC,OAAdS,MAAMG,OAAO;oCACxDF,QAAQC,GAAG,CAAC,AAAC,GAAwBF,OAAtBd,IAAIK,IAAI,EAAC,eAA0B,OAAbS,MAAMI,MAAM;gCACnD,OAAO,IAAIJ,MAAMP,IAAI,KAAK,cAAc;oCACtCY,IAAAA,uBAAa,EAACL,MAAMM,QAAQ;oCAC5B,IAAIN,MAAMO,MAAM,GAAG,GAAGN,QAAQC,GAAG,CAAC,AAAC,GAAiCF,OAA/Bd,IAAIK,IAAI,EAAC,wBAAwDS,OAAlCA,MAAMO,MAAM,EAAC,uBAAiC,OAAZP,MAAMQ,KAAK,EAAC;gCACpH,OAAO;oCACLP,QAAQQ,KAAK,CAAC,AAAC,GAAsCT,OAApCd,IAAIK,IAAI,EAAC,6BAAyC,OAAdS,MAAMU,OAAO;gCACpE;4BACF;wBACF;;;oBAbA;;;;;;IAcF;;IACA,WAAezB"}

package/dist/cjs/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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 { 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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"}

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

@@ -2,12 +2,12 @@ export type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.js'
 export { mapTree } from './map.js';
 export type { PathOptions } from './path.js';
 export { findPath } from './path.js';
-export type { Peek, PeekSection } from './peek.js';
+export type { Peek, PeekOptions, PeekSection } from './peek.js';
 export { peek, resolveNote } from './peek.js';
 export type { RelatedOptions, RelatedResult } from './related.js';
 export { relatedNotes } from './related.js';
 export { scopedPaths } from './scope.js';
-export type { SearchOptions, SearchResult, SearchResultVia } from './search.js';
+export type { SearchOptions, SearchResult, SearchResultVia, SearchSignalContribution } from './search.js';
 export { search } from './search.js';
 export type { PresetCoverage } from './status.js';
 export { presetCoverage } from './status.js';

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

@@ -2,12 +2,12 @@ export type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.js'
 export { mapTree } from './map.js';
 export type { PathOptions } from './path.js';
 export { findPath } from './path.js';
-export type { Peek, PeekSection } from './peek.js';
+export type { Peek, PeekOptions, PeekSection } from './peek.js';
 export { peek, resolveNote } from './peek.js';
 export type { RelatedOptions, RelatedResult } from './related.js';
 export { relatedNotes } from './related.js';
 export { scopedPaths } from './scope.js';
-export type { SearchOptions, SearchResult, SearchResultVia } from './search.js';
+export type { SearchOptions, SearchResult, SearchResultVia, SearchSignalContribution } from './search.js';
 export { search } from './search.js';
 export type { PresetCoverage } from './status.js';
 export { presetCoverage } from './status.js';

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/index.ts"],"sourcesContent":["// The three commands: mapTree (orient), search (locate), peek (structure).\n// Each returns data; cli.ts renders. All of them degrade when a feature is off.\n\nexport type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.ts';\nexport { mapTree } from './map.ts';\nexport type { PathOptions } from './path.ts';\nexport { findPath } from './path.ts';\nexport type { Peek, PeekSection } from './peek.ts';\nexport { peek, resolveNote } from './peek.ts';\nexport type { RelatedOptions, RelatedResult } from './related.ts';\nexport { relatedNotes } from './related.ts';\nexport { scopedPaths } from './scope.ts';\nexport type { SearchOptions, SearchResult, SearchResultVia } from './search.ts';\nexport { search } from './search.ts';\nexport type { PresetCoverage } from './status.ts';\nexport { presetCoverage } from './status.ts';\n"],"names":["findPath","mapTree","peek","presetCoverage","relatedNotes","resolveNote","scopedPaths","search"],"mappings":"AAAA,2EAA2E;AAC3E,gFAAgF;;;;;;;;;;;;QAKvEA;eAAAA,gBAAQ;;QAFRC;eAAAA,cAAO;;QAIPC;eAAAA,YAAI;;QAOJC;eAAAA,wBAAc;;QALdC;eAAAA,uBAAY;;QAFNC;eAAAA,mBAAW;;QAGjBC;eAAAA,oBAAW;;QAEXC;eAAAA,gBAAM;;;qBATS;sBAEC;sBAES;yBAEL;uBACD;wBAEL;wBAEQ"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/index.ts"],"sourcesContent":["// The three commands: mapTree (orient), search (locate), peek (structure).\n// Each returns data; cli.ts renders. All of them degrade when a feature is off.\n\nexport type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.ts';\nexport { mapTree } from './map.ts';\nexport type { PathOptions } from './path.ts';\nexport { findPath } from './path.ts';\nexport type { Peek, PeekOptions, PeekSection } from './peek.ts';\nexport { peek, resolveNote } from './peek.ts';\nexport type { RelatedOptions, RelatedResult } from './related.ts';\nexport { relatedNotes } from './related.ts';\nexport { scopedPaths } from './scope.ts';\nexport type { SearchOptions, SearchResult, SearchResultVia, SearchSignalContribution } from './search.ts';\nexport { search } from './search.ts';\nexport type { PresetCoverage } from './status.ts';\nexport { presetCoverage } from './status.ts';\n"],"names":["findPath","mapTree","peek","presetCoverage","relatedNotes","resolveNote","scopedPaths","search"],"mappings":"AAAA,2EAA2E;AAC3E,gFAAgF;;;;;;;;;;;;QAKvEA;eAAAA,gBAAQ;;QAFRC;eAAAA,cAAO;;QAIPC;eAAAA,YAAI;;QAOJC;eAAAA,wBAAc;;QALdC;eAAAA,uBAAY;;QAFNC;eAAAA,mBAAW;;QAGjBC;eAAAA,oBAAW;;QAEXC;eAAAA,gBAAM;;;qBATS;sBAEC;sBAES;yBAEL;uBACD;wBAEL;wBAEQ"}