sensemaking 0.9.1 → 0.9.3

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { parseK, runSql, withDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a named query from config, either a\n// SQL string (run as-is) or a saved search (run through the `search` command's own machinery).\nexport default async function named(ctx: Ctx, queryName: string, params: string[]): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown query: \"${queryName}\"`);\n    console.error(`valid queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(2);\n  }\n\n  if (typeof entry === 'string') {\n    runSql(cfg, entry, params, ctx.format, `query \"${queryName}\"`);\n    return;\n  }\n  if ('sql' in entry) {\n    runSql(cfg, entry.sql, params, ctx.format, `query \"${queryName}\"`);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved search and takes no positional parameters; edit its \"search\" in sense.config.json, or use \"${ctx.name} search\" directly`);\n  }\n  const k = parseK(ctx) ?? entry.k;\n  const where = ctx.values.where ?? entry.where;\n  const preset = ctx.values.preset ?? entry.preset;\n  const include = ctx.values.include ?? entry.include;\n  // --lexical upgrades a saved search's semantic behavior the same way --where/--k\n  // override; absent means the saved value (the flag has no default false override).\n  const semantic = ctx.values.lexical ? false : entry.semantic;\n  await withDb(ctx, async (db, resolvedCfg) => printRows(await search(db, resolvedCfg, entry.search, { k, where, preset, include, semantic }), ctx.format));\n}\n"],"names":["named","ctx","queryName","params","parseK","cfg","entry","k","where","preset","include","semantic","resolveConfig","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","format","sql","length","usageError","name","values","lexical","withDb","db","resolvedCfg","search","printRows"],"mappings":";;;;+BAKA,2FAA2F;AAC3F,+FAA+F;AAC/F;;;eAA8BA;;;0BAPP;wBACG;wBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKxB,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB,EAAEC,MAAgB;;YAsBrEC,SACIH,mBACCA,oBACCA,qBAxBVI,KACAC,OAoBAC,GACAC,OACAC,QACAC,SAGAC;;;;oBA3BAN,MAAMJ,IAAIW,aAAa;oBACvBN,QAAQD,IAAIQ,OAAO,CAACX,UAAU;oBACpC,IAAII,UAAUQ,WAAW;wBACvBC,QAAQC,KAAK,CAAC,AAAC,mBAA4B,OAAVd,WAAU;wBAC3Ca,QAAQC,KAAK,CAAC,AAAC,kBAA4D,OAA3CC,OAAOC,IAAI,CAACb,IAAIQ,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC;wBACrEC,QAAQC,IAAI,CAAC;oBACf;oBAEA,IAAI,OAAOhB,UAAU,UAAU;wBAC7BiB,IAAAA,gBAAM,EAAClB,KAAKC,OAAOH,QAAQF,IAAIuB,MAAM,EAAE,AAAC,UAAmB,OAAVtB,WAAU;wBAC3D;;;oBACF;oBACA,IAAI,SAASI,OAAO;wBAClBiB,IAAAA,gBAAM,EAAClB,KAAKC,MAAMmB,GAAG,EAAEtB,QAAQF,IAAIuB,MAAM,EAAE,AAAC,UAAmB,OAAVtB,WAAU;wBAC/D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIC,OAAOuB,MAAM,GAAG,GAAG;wBACrBzB,IAAI0B,UAAU,CAAC,AAAC,IAAuH1B,OAApHC,WAAU,4GAAmH,OAATD,IAAI2B,IAAI,EAAC;oBAClJ;oBACMrB,KAAIH,UAAAA,IAAAA,gBAAM,EAACH,kBAAPG,qBAAAA,UAAeE,MAAMC,CAAC;oBAC1BC,SAAQP,oBAAAA,IAAI4B,MAAM,CAACrB,KAAK,cAAhBP,+BAAAA,oBAAoBK,MAAME,KAAK;oBACvCC,UAASR,qBAAAA,IAAI4B,MAAM,CAACpB,MAAM,cAAjBR,gCAAAA,qBAAqBK,MAAMG,MAAM;oBAC1CC,WAAUT,sBAAAA,IAAI4B,MAAM,CAACnB,OAAO,cAAlBT,iCAAAA,sBAAsBK,MAAMI,OAAO;oBACnD,iFAAiF;oBACjF,mFAAmF;oBAC7EC,WAAWV,IAAI4B,MAAM,CAACC,OAAO,GAAG,QAAQxB,MAAMK,QAAQ;oBAC5D;;wBAAMoB,IAAAA,gBAAM,EAAC9B,KAAK,SAAO+B,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,aAAa3B,MAAM4B,MAAM,EAAE;oDAAE3B,GAAAA;oDAAGC,OAAAA;oDAAOC,QAAAA;oDAAQC,SAAAA;oDAASC,UAAAA;gDAAS;;;;;gDAA5FwB,mBAAS;oDAAC;oDAAsFlC,IAAIuB,MAAM;;;;;;;;;oBAAvJ;;;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { usageError } from './exit.ts';\nimport { CONFIG, FORMAT, formatOf, parse, parseK, runSql, SEARCH_FLAGS, withDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a named query from config, either a\n// SQL string (run as-is) or a saved search (run through the `search` command's own machinery).\n// Flags cover both shapes -- SEARCH_FLAGS override a saved search's fields the same way they\n// override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json] [--config path] [--where \"<sql>\"] [--k n] [--preset name] [--include glob ...] [--lexical]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const configPath = values.config as string | undefined;\n\n  const cfg = ctx.resolveConfig(configPath);\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) usageError(`unknown query: \"${queryName}\"`, `valid queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n\n  if (typeof entry === 'string') {\n    runSql(cfg, entry, params, format, `query \"${queryName}\"`);\n    return;\n  }\n  if ('sql' in entry) {\n    runSql(cfg, entry.sql, params, format, `query \"${queryName}\"`);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved search and takes no positional parameters; edit its \"search\" in sense.config.json, or use \"${ctx.name} search\" directly`);\n  }\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? entry.include;\n  // --lexical upgrades a saved search's semantic behavior the same way --where/--k\n  // override; absent means the saved value (the flag has no default false override).\n  const semantic = values.lexical ? false : entry.semantic;\n  await withDb(ctx, configPath, async (db, resolvedCfg) => printRows(await search(db, resolvedCfg, entry.search, { k, where, preset, include, semantic }), format));\n}\n"],"names":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","cfg","entry","k","where","preset","include","semantic","name","argv","SEARCH_FLAGS","FORMAT","CONFIG","positionals","formatOf","config","resolveConfig","queries","undefined","usageError","Object","keys","sort","join","runSql","sql","length","lexical","withDb","db","resolvedCfg","search","printRows"],"mappings":";;;;+BAMA,2FAA2F;AAC3F,+FAA+F;AAC/F,6FAA6F;AAC7F,uBAAuB;AACvB;;;eAA8BA;;;0BAVP;wBACG;sBACC;wBAC2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOvE,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB;;YAuBnDC,SACKC,eACCA,gBACCA,iBAzBXC,OACkCC,QAAhCF,QAAqBG,QACvBC,QACAC,YAEAC,KACAC,OAgBAC,GACAC,OACAC,QACAC,SAGAC;;;;oBA5BAX,QAAQ,AAAC,UAAqBH,OAAZD,IAAIgB,IAAI,EAAC,KAAa,OAAVf,WAAU;oBACNI,SAAAA,IAAAA,eAAK,EAACL,IAAIiB,IAAI,EAAEb,OAAO,mBAAKc,sBAAY,EAAKC,gBAAM,EAAKC,gBAAM,IAA9FjB,SAAgCE,OAAhCF,QAAqBG,SAAWD,OAAxBgB;oBACVd,SAASe,IAAAA,kBAAQ,EAACnB;oBAClBK,aAAaL,OAAOoB,MAAM;oBAE1Bd,MAAMT,IAAIwB,aAAa,CAAChB;oBACxBE,QAAQD,IAAIgB,OAAO,CAACxB,UAAU;oBACpC,IAAIS,UAAUgB,WAAWC,IAAAA,kBAAU,EAAC,AAAC,mBAA4B,OAAV1B,WAAU,MAAI,AAAC,kBAA4D,OAA3C2B,OAAOC,IAAI,CAACpB,IAAIgB,OAAO,EAAEK,IAAI,GAAGC,IAAI,CAAC;oBAE5H,IAAI,OAAOrB,UAAU,UAAU;wBAC7BsB,IAAAA,gBAAM,EAACvB,KAAKC,OAAOJ,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU;wBACvD;;;oBACF;oBACA,IAAI,SAASS,OAAO;wBAClBsB,IAAAA,gBAAM,EAACvB,KAAKC,MAAMuB,GAAG,EAAE3B,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU;wBAC3D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIK,OAAO4B,MAAM,GAAG,GAAG;wBACrBlC,IAAI2B,UAAU,CAAC,AAAC,IAAuH3B,OAApHC,WAAU,4GAAmH,OAATD,IAAIgB,IAAI,EAAC;oBAClJ;oBACML,KAAIT,UAAAA,IAAAA,gBAAM,EAACC,OAAOQ,CAAC,EAAwBX,IAAI2B,UAAU,eAArDzB,qBAAAA,UAA0DQ,MAAMC,CAAC;oBACrEC,SAAST,gBAAAA,OAAOS,KAAK,cAAZT,2BAAAA,gBAAuCO,MAAME,KAAK;oBAC3DC,UAAUV,iBAAAA,OAAOU,MAAM,cAAbV,4BAAAA,iBAAwCO,MAAMG,MAAM;oBAC9DC,WAAWX,kBAAAA,OAAOW,OAAO,cAAdX,6BAAAA,kBAA2CO,MAAMI,OAAO;oBACzE,iFAAiF;oBACjF,mFAAmF;oBAC7EC,WAAWZ,OAAOgC,OAAO,GAAG,QAAQzB,MAAMK,QAAQ;oBACxD;;wBAAMqB,IAAAA,gBAAM,EAACpC,KAAKQ,YAAY,SAAO6B,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,aAAa5B,MAAM6B,MAAM,EAAE;oDAAE5B,GAAAA;oDAAGC,OAAAA;oDAAOC,QAAAA;oDAAQC,SAAAA;oDAASC,UAAAA;gDAAS;;;;;gDAA5FyB,mBAAS;oDAAC;oDAAsFjC;;;;;;;;;oBAAzJ;;;;;;IACF"}

package/dist/cjs/cli/peek.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "default", {
 });
 var _commandsts = require("../commands.js");
 var _outputts = require("../output.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -19,6 +20,19 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -46,6 +60,21 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, 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();
 }
@@ -58,11 +87,14 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var peekCmd = function peekCmd(ctx) {
-    var _ctx_rest = _sliced_to_array(ctx.rest, 1), pathArg = _ctx_rest[0];
-    if (!pathArg) ctx.usageError("usage: ".concat(ctx.name, " peek <path>"));
-    return (0, _sharedts.withDb)(ctx, function(db, cfg) {
+    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.peek);
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+    var _positionals = _sliced_to_array(positionals, 1), pathArg = _positionals[0];
+    if (!pathArg) ctx.usageError(usage);
+    var format = (0, _sharedts.formatOf)(values);
+    return (0, _sharedts.withDb)(ctx, values.config, function(db, cfg) {
         var result = (0, _commandsts.peek)(db, cfg, pathArg);
-        console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderPeek)(result));
+        console.log(format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderPeek)(result));
     });
 };
 var _default = peekCmd;

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.ts';\nimport { renderPeek } from '../output.ts';\nimport { withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst peekCmd: Command = (ctx) => {\n  const [pathArg] = ctx.rest;\n  if (!pathArg) ctx.usageError(`usage: ${ctx.name} peek <path>`);\n  return withDb(ctx, (db, cfg) => {\n    const result = peek(db, cfg, pathArg);\n    console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : renderPeek(result));\n  });\n};\nexport default peekCmd;\n"],"names":["peekCmd","ctx","rest","pathArg","usageError","name","withDb","db","cfg","result","peek","console","log","format","JSON","stringify","renderPeek"],"mappings":";;;;+BAaA;;;eAAA;;;0BAbqB;wBACM;wBACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,IAAMA,UAAmB,iBAACC;IACxB,IAAkBA,6BAAAA,IAAIC,IAAI,MAAnBC,UAAWF;IAClB,IAAI,CAACE,SAASF,IAAIG,UAAU,CAAC,AAAC,UAAkB,OAATH,IAAII,IAAI,EAAC;IAChD,OAAOC,IAAAA,gBAAM,EAACL,KAAK,SAACM,IAAIC;QACtB,IAAMC,SAASC,IAAAA,gBAAI,EAACH,IAAIC,KAAKL;QAC7BQ,QAAQC,GAAG,CAACX,IAAIY,MAAM,KAAK,SAASC,KAAKC,SAAS,CAACN,QAAQ,MAAM,KAAKO,IAAAA,oBAAU,EAACP;IACnF;AACF;IACA,WAAeT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/peek.ts"],"sourcesContent":["import { peek } from '../commands.ts';\nimport { renderPeek } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, 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, { ...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, (db, cfg) => {\n    const result = peek(db, cfg, pathArg);\n    console.log(format === 'json' ? JSON.stringify(result, null, 2) : renderPeek(result));\n  });\n};\nexport default peekCmd;\n"],"names":["peekCmd","ctx","usage","USAGE","name","peek","parse","argv","FORMAT","CONFIG","values","positionals","pathArg","usageError","format","formatOf","withDb","config","db","cfg","result","console","log","JSON","stringify","renderPeek"],"mappings":";;;;+BAiBA;;;eAAA;;;0BAjBqB;wBACM;uBACL;wBACkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxD,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,gBAAM,EAAKC,gBAAM,IAArEC,SAAwBJ,OAAxBI,QAAQC,cAAgBL,OAAhBK;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASX,IAAIY,UAAU,CAACX;IAC7B,IAAMY,SAASC,IAAAA,kBAAQ,EAACL;IACxB,OAAOM,IAAAA,gBAAM,EAACf,KAAKS,OAAOO,MAAM,EAAwB,SAACC,IAAIC;QAC3D,IAAMC,SAASf,IAAAA,gBAAI,EAACa,IAAIC,KAAKP;QAC7BS,QAAQC,GAAG,CAACR,WAAW,SAASS,KAAKC,SAAS,CAACJ,QAAQ,MAAM,KAAKK,IAAAA,oBAAU,EAACL;IAC/E;AACF;IACA,WAAepB"}

package/dist/cjs/cli/query.js

@@ -8,6 +8,7 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -17,12 +18,40 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 function _to_array(arr) {
     return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
 }
@@ -35,9 +64,12 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var query = function query(ctx) {
-    var _ctx_rest = _to_array(ctx.rest), sql = _ctx_rest[0], params = _ctx_rest.slice(1);
-    if (!sql) ctx.usageError("usage: ".concat(ctx.name, ' query "<sql>" [params...]'));
-    (0, _sharedts.runSql)(ctx.resolveConfig(), sql, params, ctx.format, 'ad-hoc query');
+    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.query);
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+    var _positionals = _to_array(positionals), sql = _positionals[0], params = _positionals.slice(1);
+    if (!sql) ctx.usageError(usage);
+    var format = (0, _sharedts.formatOf)(values);
+    (0, _sharedts.runSql)(ctx.resolveConfig(values.config), sql, params, format, 'ad-hoc query');
 };
 var _default = query;
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/query.ts"],"sourcesContent":["import { runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst query: Command = (ctx) => {\n  const [sql, ...params] = ctx.rest;\n  if (!sql) ctx.usageError(`usage: ${ctx.name} query \"<sql>\" [params...]`);\n  runSql(ctx.resolveConfig(), sql, params, ctx.format, 'ad-hoc query');\n};\nexport default query;\n"],"names":["query","ctx","rest","sql","params","usageError","name","runSql","resolveConfig","format"],"mappings":";;;;+BAQA;;;eAAA;;;wBARuB;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,IAAMA,QAAiB,eAACC;IACtB,IAAyBA,sBAAAA,IAAIC,IAAI,GAA1BC,MAAkBF,cAAb,AAAGG,SAAUH,gBAAb;IACZ,IAAI,CAACE,KAAKF,IAAII,UAAU,CAAC,AAAC,UAAkB,OAATJ,IAAIK,IAAI,EAAC;IAC5CC,IAAAA,gBAAM,EAACN,IAAIO,aAAa,IAAIL,KAAKC,QAAQH,IAAIQ,MAAM,EAAE;AACvD;IACA,WAAeT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/query.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst query: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.query}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...FORMAT, ...CONFIG });\n  const [sql, ...params] = positionals;\n  if (!sql) ctx.usageError(usage);\n  const format = formatOf(values);\n  runSql(ctx.resolveConfig(values.config as string | undefined), sql, params, format, 'ad-hoc query');\n};\nexport default query;\n"],"names":["query","ctx","usage","USAGE","name","parse","argv","FORMAT","CONFIG","values","positionals","sql","params","usageError","format","formatOf","runSql","resolveConfig","config"],"mappings":";;;;+BAYA;;;eAAA;;;uBAZsB;wBACkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxD,IAAMA,QAAiB,eAACC;IACtB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAe,OAAZD,cAAK,CAACH,KAAK;IAC/C,IAAgCK,SAAAA,IAAAA,eAAK,EAACJ,IAAIK,IAAI,EAAEJ,OAAO,mBAAKK,gBAAM,EAAKC,gBAAM,IAArEC,SAAwBJ,OAAxBI,QAAQC,cAAgBL,OAAhBK;IAChB,IAAyBA,yBAAAA,cAAlBC,MAAkBD,iBAAb,AAAGE,SAAUF,mBAAb;IACZ,IAAI,CAACC,KAAKV,IAAIY,UAAU,CAACX;IACzB,IAAMY,SAASC,IAAAA,kBAAQ,EAACN;IACxBO,IAAAA,gBAAM,EAACf,IAAIgB,aAAa,CAACR,OAAOS,MAAM,GAAyBP,KAAKC,QAAQE,QAAQ;AACtF;IACA,WAAed"}

package/dist/cjs/cli/rebuild.js

@@ -9,9 +9,39 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _dbts = require("../db.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 var rebuildCmd = function rebuildCmd(ctx) {
-    var result = (0, _dbts.rebuild)(ctx.resolveConfig());
+    var values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.rebuild), _object_spread({}, _sharedts.CONFIG)).values;
+    var result = (0, _dbts.rebuild)(ctx.resolveConfig(values.config));
     (0, _sharedts.printWarnings)(result.warnings);
     console.log("rebuilt: ".concat((0, _dbts.docCount)(result.db), " docs"));
     result.db.close();

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/rebuild.ts"],"sourcesContent":["import { docCount, rebuild } from '../db.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst rebuildCmd: Command = (ctx) => {\n  const result = rebuild(ctx.resolveConfig());\n  printWarnings(result.warnings);\n  console.log(`rebuilt: ${docCount(result.db)} docs`);\n  result.db.close();\n};\nexport default rebuildCmd;\n"],"names":["rebuildCmd","ctx","result","rebuild","resolveConfig","printWarnings","warnings","console","log","docCount","db","close"],"mappings":";;;;+BAUA;;;eAAA;;;oBAVkC;wBACJ;AAG9B,IAAMA,aAAsB,oBAACC;IAC3B,IAAMC,SAASC,IAAAA,aAAO,EAACF,IAAIG,aAAa;IACxCC,IAAAA,uBAAa,EAACH,OAAOI,QAAQ;IAC7BC,QAAQC,GAAG,CAAC,AAAC,YAA+B,OAApBC,IAAAA,cAAQ,EAACP,OAAOQ,EAAE,GAAE;IAC5CR,OAAOQ,EAAE,CAACC,KAAK;AACjB;IACA,WAAeX"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/rebuild.ts"],"sourcesContent":["import { docCount, rebuild } from '../db.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst rebuildCmd: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.rebuild}`, { ...CONFIG });\n  const result = rebuild(ctx.resolveConfig(values.config as string | undefined));\n  printWarnings(result.warnings);\n  console.log(`rebuilt: ${docCount(result.db)} docs`);\n  result.db.close();\n};\nexport default rebuildCmd;\n"],"names":["rebuildCmd","ctx","values","parse","argv","USAGE","name","rebuild","CONFIG","result","resolveConfig","config","printWarnings","warnings","console","log","docCount","db","close"],"mappings":";;;;+BAYA;;;eAAA;;;oBAZkC;uBACZ;wBACuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7C,IAAMA,aAAsB,oBAACC;IAC3B,IAAM,AAAEC,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAiB,OAAdD,cAAK,CAACE,OAAO,GAAI,mBAAKC,gBAAM,GAA7EN;IACR,IAAMO,SAASF,IAAAA,aAAO,EAACN,IAAIS,aAAa,CAACR,OAAOS,MAAM;IACtDC,IAAAA,uBAAa,EAACH,OAAOI,QAAQ;IAC7BC,QAAQC,GAAG,CAAC,AAAC,YAA+B,OAApBC,IAAAA,cAAQ,EAACP,OAAOQ,EAAE,GAAE;IAC5CR,OAAOQ,EAAE,CAACC,KAAK;AACjB;IACA,WAAelB"}

package/dist/cjs/cli/search.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "default", {
 });
 var _commandsts = require("../commands.js");
 var _outputts = require("../output.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -48,6 +49,19 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -75,6 +89,21 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, 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();
 }
@@ -187,16 +216,19 @@ function _ts_generator(thisArg, body) {
 }
 var searchCmd = function searchCmd(ctx) {
     return _async_to_generator(function() {
-        var _ctx_rest, terms, k;
+        var usage, _parse, values, positionals, _positionals, terms, k, format;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    _ctx_rest = _sliced_to_array(ctx.rest, 1), terms = _ctx_rest[0];
-                    if (!terms) ctx.usageError("usage: ".concat(ctx.name, ' search "<terms>" [--preset name] [--include glob ...] [--where "<sql>"] [--k n] [--lexical]'));
-                    k = (0, _sharedts.parseK)(ctx);
+                    usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.search);
+                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.FORMAT, _sharedts.CONFIG)), 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);
+                    format = (0, _sharedts.formatOf)(values);
                     return [
                         4,
-                        (0, _sharedts.withDb)(ctx, function(db, cfg) {
+                        (0, _sharedts.withDb)(ctx, values.config, function(db, cfg) {
                             return _async_to_generator(function() {
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
@@ -205,10 +237,10 @@ var searchCmd = function searchCmd(ctx) {
                                                 4,
                                                 (0, _commandsts.search)(db, cfg, terms, {
                                                     k: k,
-                                                    where: ctx.values.where,
-                                                    preset: ctx.values.preset,
-                                                    include: ctx.values.include,
-                                                    semantic: ctx.values.lexical ? false : undefined
+                                                    where: values.where,
+                                                    preset: values.preset,
+                                                    include: values.include,
+                                                    semantic: values.lexical ? false : undefined
                                                 })
                                             ];
                                         case 1:
@@ -216,7 +248,7 @@ var searchCmd = function searchCmd(ctx) {
                                                 2,
                                                 _outputts.printRows.apply(void 0, [
                                                     _state.sent(),
-                                                    ctx.format
+                                                    format
                                                 ])
                                             ];
                                     }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/search.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { parseK, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst searchCmd: Command = async (ctx) => {\n  const [terms] = ctx.rest;\n  if (!terms) ctx.usageError(`usage: ${ctx.name} search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical]`);\n  const k = parseK(ctx);\n  await withDb(ctx, async (db, cfg) => printRows(await search(db, cfg, terms, { k, where: ctx.values.where, preset: ctx.values.preset, include: ctx.values.include, semantic: ctx.values.lexical ? false : undefined }), ctx.format));\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","terms","k","rest","usageError","name","parseK","withDb","db","cfg","search","where","values","preset","include","semantic","lexical","undefined","printRows","format"],"mappings":";;;;+BAWA;;;eAAA;;;0BAXuB;wBACG;wBACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG/B,IAAMA,YAAqB,mBAAOC;;YAChBA,WAATC,OAEDC;;;;oBAFUF,6BAAAA,IAAIG,IAAI,MAAjBF,QAASD;oBAChB,IAAI,CAACC,OAAOD,IAAII,UAAU,CAAC,AAAC,UAAkB,OAATJ,IAAIK,IAAI,EAAC;oBACxCH,IAAII,IAAAA,gBAAM,EAACN;oBACjB;;wBAAMO,IAAAA,gBAAM,EAACP,KAAK,SAAOQ,IAAIC;;;;;4CAAkB;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,KAAKR,OAAO;oDAAEC,GAAAA;oDAAGS,OAAOX,IAAIY,MAAM,CAACD,KAAK;oDAAEE,QAAQb,IAAIY,MAAM,CAACC,MAAM;oDAAEC,SAASd,IAAIY,MAAM,CAACE,OAAO;oDAAEC,UAAUf,IAAIY,MAAM,CAACI,OAAO,GAAG,QAAQC;gDAAU;;;;;gDAA9KC,mBAAS;oDAAC;oDAAwKlB,IAAImB,MAAM;;;;;;;;;oBAAjO;;;;;;IACF;;IACA,WAAepB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/search.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, parseK, SEARCH_FLAGS, 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, ...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 format = formatOf(values);\n  await withDb(ctx, values.config as string | undefined, async (db, cfg) => printRows(await search(db, cfg, terms, { k, where: values.where as string | undefined, preset: values.preset as string | undefined, include: values.include as string[] | undefined, semantic: values.lexical ? false : undefined }), format));\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","usage","parse","values","positionals","terms","k","format","USAGE","name","search","argv","SEARCH_FLAGS","FORMAT","CONFIG","usageError","parseK","formatOf","withDb","config","db","cfg","where","preset","include","semantic","lexical","undefined","printRows"],"mappings":";;;;+BAeA;;;eAAA;;;0BAfuB;wBACG;uBACJ;wBACwD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9E,IAAMA,YAAqB,mBAAOC;;YAC1BC,OAC0BC,QAAxBC,QAAQC,aACAA,cAATC,OAEDC,GACAC;;;;oBALAN,QAAQ,AAAC,UAAqBO,OAAZR,IAAIS,IAAI,EAAC,KAAgB,OAAbD,cAAK,CAACE,MAAM;oBAChBR,SAAAA,IAAAA,eAAK,EAACF,IAAIW,IAAI,EAAEV,OAAO,mBAAKW,sBAAY,EAAKC,gBAAM,EAAKC,gBAAM,IAAtFX,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACAA,gCAAAA,iBAATC,QAASD;oBAChB,IAAI,CAACC,OAAOL,IAAIe,UAAU,CAACd;oBACrBK,IAAIU,IAAAA,gBAAM,EAACb,OAAOG,CAAC,EAAwBN,IAAIe,UAAU;oBACzDR,SAASU,IAAAA,kBAAQ,EAACd;oBACxB;;wBAAMe,IAAAA,gBAAM,EAAClB,KAAKG,OAAOgB,MAAM,EAAwB,SAAOC,IAAIC;;;;;4CAAkB;;gDAAMX,IAAAA,kBAAM,EAACU,IAAIC,KAAKhB,OAAO;oDAAEC,GAAAA;oDAAGgB,OAAOnB,OAAOmB,KAAK;oDAAwBC,QAAQpB,OAAOoB,MAAM;oDAAwBC,SAASrB,OAAOqB,OAAO;oDAA0BC,UAAUtB,OAAOuB,OAAO,GAAG,QAAQC;gDAAU;;;;;gDAAlOC,mBAAS;oDAAC;oDAA4NrB;;;;;;;;;oBAAhT;;;;;;IACF;;IACA,WAAeR"}

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

@@ -1,7 +1,23 @@
 import type { ResolvedConfig } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
-export declare function parseK(ctx: Ctx): number | undefined;
+export interface Flag {
+    type: 'string' | 'boolean';
+    default?: string | boolean;
+    multiple?: boolean;
+    short?: string;
+}
+export type Flags = Record<string, Flag>;
+export declare const FORMAT: Flags;
+export declare const CONFIG: Flags;
+export declare const SEARCH_FLAGS: Flags;
+export type Values = Record<string, string | boolean | string[] | undefined>;
+export declare function formatOf(values: Values): 'table' | 'json';
+export declare function parse(argv: string[], usage: string, flags?: Flags): {
+    values: Values;
+    positionals: string[];
+};
+export declare function parseK(k: string | undefined, usageErrorFn: (message: string) => never): number | undefined;
 export declare function printWarnings(warnings: string[]): void;
-export declare function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
+export declare function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
 export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void;

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

@@ -1,7 +1,23 @@
 import type { ResolvedConfig } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
-export declare function parseK(ctx: Ctx): number | undefined;
+export interface Flag {
+    type: 'string' | 'boolean';
+    default?: string | boolean;
+    multiple?: boolean;
+    short?: string;
+}
+export type Flags = Record<string, Flag>;
+export declare const FORMAT: Flags;
+export declare const CONFIG: Flags;
+export declare const SEARCH_FLAGS: Flags;
+export type Values = Record<string, string | boolean | string[] | undefined>;
+export declare function formatOf(values: Values): 'table' | 'json';
+export declare function parse(argv: string[], usage: string, flags?: Flags): {
+    values: Values;
+    positionals: string[];
+};
+export declare function parseK(k: string | undefined, usageErrorFn: (message: string) => never): number | undefined;
 export declare function printWarnings(warnings: string[]): void;
-export declare function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
+export declare function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
 export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void;