sensemaking 0.7.1 → 0.8.0

package/dist/cjs/{commands → cli}/named.d.ts

@@ -1,2 +1,2 @@
 import type { Ctx } from './types.js';
-export default function named(ctx: Ctx, queryName: string, params: string[]): void;
+export default function named(ctx: Ctx, queryName: string, params: string[]): Promise<void>;

package/dist/cjs/cli/named.js

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, // Fallback when the first positional is not a command: a named query from config, either a
+// SQL string (run as-is) or a saved find (run through the `find` command's own machinery).
+"default", {
+    enumerable: true,
+    get: function() {
+        return named;
+    }
+});
+var _commandsts = require("../commands.js");
+var _outputts = require("../output.js");
+var _sharedts = require("./shared.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function named(ctx, queryName, params) {
+    return _async_to_generator(function() {
+        var _parseK, _ctx_values_where, cfg, entry, k, where, semantic;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    cfg = ctx.resolveConfig();
+                    entry = cfg.queries[queryName];
+                    if (entry === undefined) {
+                        console.error('unknown query: "'.concat(queryName, '"'));
+                        console.error("valid queries: ".concat(Object.keys(cfg.queries).sort().join(', ')));
+                        process.exit(2);
+                    }
+                    if (typeof entry === 'string') {
+                        (0, _sharedts.runSql)(cfg, entry, params, ctx.format, 'query "'.concat(queryName, '"'));
+                        return [
+                            2
+                        ];
+                    }
+                    // A saved find's terms are fixed in config; there is nowhere for a positional to bind.
+                    if (params.length > 0) {
+                        ctx.usageError('"'.concat(queryName, '" is a saved find and takes no positional parameters; edit its "find" in sense.config.json, or use "').concat(ctx.name, ' find" directly'));
+                    }
+                    k = (_parseK = (0, _sharedts.parseK)(ctx)) !== null && _parseK !== void 0 ? _parseK : entry.k;
+                    where = (_ctx_values_where = ctx.values.where) !== null && _ctx_values_where !== void 0 ? _ctx_values_where : entry.where;
+                    // --semantic upgrades a saved find the same way --where/--k override; absent means the
+                    // saved value (the flag has no default, so absent is distinguishable from false).
+                    semantic = ctx.values.semantic === true || entry.semantic;
+                    return [
+                        4,
+                        (0, _sharedts.withDb)(ctx, function(db, resolvedCfg) {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                (0, _commandsts.find)(db, resolvedCfg, entry.find, {
+                                                    k: k,
+                                                    where: where,
+                                                    semantic: semantic
+                                                })
+                                            ];
+                                        case 1:
+                                            return [
+                                                2,
+                                                _outputts.printRows.apply(void 0, [
+                                                    _state.sent(),
+                                                    ctx.format
+                                                ])
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+/* 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/named.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { find } 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 find (run through the `find` 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\n  // A saved find's terms are fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved find and takes no positional parameters; edit its \"find\" in sense.config.json, or use \"${ctx.name} find\" directly`);\n  }\n  const k = parseK(ctx) ?? entry.k;\n  const where = ctx.values.where ?? entry.where;\n  // --semantic upgrades a saved find the same way --where/--k override; absent means the\n  // saved value (the flag has no default, so absent is distinguishable from false).\n  const semantic = ctx.values.semantic === true || entry.semantic;\n  await withDb(ctx, async (db, resolvedCfg) => printRows(await find(db, resolvedCfg, entry.find, { k, where, semantic }), ctx.format));\n}\n"],"names":["named","ctx","queryName","params","parseK","cfg","entry","k","where","semantic","resolveConfig","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","format","length","usageError","name","values","withDb","db","resolvedCfg","find","printRows"],"mappings":";;;;+BAKA,2FAA2F;AAC3F,2FAA2F;AAC3F;;;eAA8BA;;;0BAPT;wBACK;wBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKxB,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB,EAAEC,MAAgB;;YAkBrEC,SACIH,mBAlBRI,KACAC,OAgBAC,GACAC,OAGAC;;;;oBArBAJ,MAAMJ,IAAIS,aAAa;oBACvBJ,QAAQD,IAAIM,OAAO,CAACT,UAAU;oBACpC,IAAII,UAAUM,WAAW;wBACvBC,QAAQC,KAAK,CAAC,AAAC,mBAA4B,OAAVZ,WAAU;wBAC3CW,QAAQC,KAAK,CAAC,AAAC,kBAA4D,OAA3CC,OAAOC,IAAI,CAACX,IAAIM,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC;wBACrEC,QAAQC,IAAI,CAAC;oBACf;oBAEA,IAAI,OAAOd,UAAU,UAAU;wBAC7Be,IAAAA,gBAAM,EAAChB,KAAKC,OAAOH,QAAQF,IAAIqB,MAAM,EAAE,AAAC,UAAmB,OAAVpB,WAAU;wBAC3D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIC,OAAOoB,MAAM,GAAG,GAAG;wBACrBtB,IAAIuB,UAAU,CAAC,AAAC,IAAmHvB,OAAhHC,WAAU,wGAA+G,OAATD,IAAIwB,IAAI,EAAC;oBAC9I;oBACMlB,KAAIH,UAAAA,IAAAA,gBAAM,EAACH,kBAAPG,qBAAAA,UAAeE,MAAMC,CAAC;oBAC1BC,SAAQP,oBAAAA,IAAIyB,MAAM,CAAClB,KAAK,cAAhBP,+BAAAA,oBAAoBK,MAAME,KAAK;oBAC7C,uFAAuF;oBACvF,kFAAkF;oBAC5EC,WAAWR,IAAIyB,MAAM,CAACjB,QAAQ,KAAK,QAAQH,MAAMG,QAAQ;oBAC/D;;wBAAMkB,IAAAA,gBAAM,EAAC1B,KAAK,SAAO2B,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,gBAAI,EAACF,IAAIC,aAAavB,MAAMwB,IAAI,EAAE;oDAAEvB,GAAAA;oDAAGC,OAAAA;oDAAOC,UAAAA;gDAAS;;;;;gDAAvEsB,mBAAS;oDAAC;oDAAiE9B,IAAIqB,MAAM;;;;;;;;;oBAAlI;;;;;;IACF"}

package/dist/cjs/{commands → cli}/peek.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+var _commandsts = require("../commands.js");
 var _outputts = require("../output.js");
-var _verbsts = require("../verbs.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -61,7 +61,7 @@ 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 result = (0, _verbsts.peek)(db, cfg, pathArg);
+        var result = (0, _commandsts.peek)(db, cfg, pathArg);
         console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderPeek)(result));
     });
 };

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

@@ -0,0 +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"}

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

@@ -0,0 +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"}

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

@@ -0,0 +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"}

package/dist/cjs/{commands → cli}/shared.d.cts

@@ -1,6 +1,7 @@
 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 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 runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void;

package/dist/{esm/commands → cjs/cli}/shared.d.ts

@@ -1,6 +1,7 @@
 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 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 runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void;

package/dist/cjs/{commands → cli}/shared.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get parseK () {
+        return parseK;
+    },
     get printWarnings () {
         return printWarnings;
     },
@@ -175,6 +178,12 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+function parseK(ctx) {
+    if (ctx.values.k === undefined) return undefined;
+    var k = Number(ctx.values.k);
+    if (!Number.isInteger(k) || k <= 0) ctx.usageError('--k expects a positive integer, got "'.concat(ctx.values.k, '"'));
+    return k;
+}
 function printWarnings(warnings) {
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config.ts';\nimport type { OpenResult } from '../db.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedFind validation.\nexport function parseK(ctx: Ctx): number | undefined {\n  if (ctx.values.k === undefined) return undefined;\n  const k = Number(ctx.values.k);\n  if (!Number.isInteger(k) || k <= 0) ctx.usageError(`--k expects a positive integer, got \"${ctx.values.k}\"`);\n  return k;\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 async function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): 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  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["parseK","printWarnings","runSql","withDb","ctx","values","k","undefined","Number","isInteger","usageError","warnings","w","console","warn","fn","cfg","open","db","resolveConfig","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","rows","prepare","all","err","test","searchError","join","printRows"],"mappings":";;;;;;;;;;;QAWgBA;eAAAA;;QASAC;eAAAA;;QAgBAC;eAAAA;;QAZMC;eAAAA;;;oBAtBD;wBAEK;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMrB,SAASH,OAAOI,GAAQ;IAC7B,IAAIA,IAAIC,MAAM,CAACC,CAAC,KAAKC,WAAW,OAAOA;IACvC,IAAMD,IAAIE,OAAOJ,IAAIC,MAAM,CAACC,CAAC;IAC7B,IAAI,CAACE,OAAOC,SAAS,CAACH,MAAMA,KAAK,GAAGF,IAAIM,UAAU,CAAC,AAAC,wCAAoD,OAAbN,IAAIC,MAAM,CAACC,CAAC,EAAC;IACxG,OAAOA;AACT;AAIO,SAASL,cAAcU,QAAkB;QACzC,kCAAA,2BAAA;;QAAL,QAAK,YAAWA,6BAAX,SAAA,6BAAA,QAAA,yBAAA;YAAA,IAAMC,IAAN;YAAqBC,QAAQC,IAAI,CAACF;;;QAAlC;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;AACP;AAEO,SAAeT,OAAOC,GAAQ,EAAEW,EAAuE;;YACtGC,KACmBC,OAAjBC,IAAIP;;;;oBADNK,MAAMZ,IAAIe,aAAa;oBACJF,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;oBACZV,cAAcU;;;;;;;;;oBAEZ;;wBAAMI,GAAGG,IAAIF;;;oBAAb;;;;;;oBAEAE,GAAGE,KAAK;;;;;;;;;;IAEZ;;AAGO,SAASlB,OAAOc,GAAmB,EAAEK,GAAW,EAAEC,MAAgB,EAAEC,MAAwB,EAAEC,KAAa;QACtFH;IAA1B,IAAMI,mBAAmB,EAACJ,aAAAA,IAAIK,KAAK,CAAC,oBAAVL,wBAAAA,aAAoB,EAAE,EAAEM,MAAM;IACxD,IAAIL,OAAOK,MAAM,KAAKF,kBAAkB;QACtCZ,QAAQe,KAAK,CAAC,AAAC,GAAmBH,OAAjBD,OAAM,aAAiDF,OAAtCG,kBAAiB,uBAAmC,OAAdH,OAAOK,MAAM;QACrFE,QAAQC,IAAI,CAAC;IACf;IACA,IAAyBb,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;IACZV,cAAcU;IACd,IAAIoB;IACJ,IAAI;YACKb;QAAPa,OAAOb,CAAAA,cAAAA,GAAGc,OAAO,CAACX,MAAKY,GAAG,OAAnBf,aAAoB,qBAAGI;IAChC,EAAE,OAAOY,KAAK;QACZhB,GAAGE,KAAK;QACR,gFAAgF;QAChF,mFAAmF;QACnF,sFAAsF;QACtF,IAAI,aAAae,IAAI,CAACd,MAAM,MAAMe,IAAAA,0BAAW,EAACF,KAAcZ,OAAOe,IAAI,CAAC;QACxE,MAAMH;IACR;IACAI,IAAAA,mBAAS,EAACP,MAAMR;IAChBL,GAAGE,KAAK;AACV"}

package/dist/cjs/{commands → cli}/status.js

@@ -60,6 +60,10 @@ var status = function status(ctx) {
     var e = (0, _configts.embedConfig)(cfg);
     var vectors = e ? vectorState(db) : null;
     var heartbeat = (0, _dbts.getMeta)(db, 'watch_heartbeat');
+    // Derived at open() (F): 3x the largest reconcile this cache has ever held its write
+    // transaction for, floored at 30s -- read back from the connection rather than
+    // recomputed here, so this always reports what open() actually set.
+    var busyTimeoutMs = db.prepare('PRAGMA busy_timeout').get().timeout;
     var result = {
         db: dbPath,
         docs: (0, _dbts.docCount)(db),
@@ -70,7 +74,8 @@ var status = function status(ctx) {
             model: e.model
         }, vectors !== null && vectors !== void 0 ? vectors : {}) : null,
         findDefaultWhere: (_ref = (_cfg_defaults = cfg.defaults) === null || _cfg_defaults === void 0 ? void 0 : (_cfg_defaults_find = _cfg_defaults.find) === null || _cfg_defaults_find === void 0 ? void 0 : _cfg_defaults_find.where) !== null && _ref !== void 0 ? _ref : null,
-        watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null
+        watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,
+        busyTimeoutMs: busyTimeoutMs
     };
     if (ctx.format === 'json') {
         console.log(JSON.stringify(result, null, 2));
@@ -84,6 +89,7 @@ var status = function status(ctx) {
         if (e) console.log("embed: ".concat(e.type, " ").concat(e.model).concat(vectors ? " (vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending — embedded on first --semantic query)") : ''));
         if (result.findDefaultWhere) console.log("find default scope: ".concat(result.findDefaultWhere, " (--where replaces it)"));
         console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : "watcher: last heartbeat ".concat(result.watcherHeartbeatSecondsAgo, "s ago"));
+        console.log("busy_timeout: ".concat(result.busyTimeoutMs, "ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)"));
     }
     db.close();
 };

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can be\n// embed-enabled with nothing embedded yet -- reported here because a fast `rebuild` on an\n// embed tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    findDefaultWhere: cfg.defaults?.find?.where ?? null,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (ctx.format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    const off = features.off.length > 0 ? ` · off: ${features.off.map((name) => `${name} (features.${name})`).join(', ')}` : '';\n    console.log(`features: ${features.on.join(', ')}${off}`);\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on first --semantic query)` : ''}`);\n    if (result.findDefaultWhere) console.log(`find default scope: ${result.findDefaultWhere} (--where replaces it)`);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`busy_timeout: ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","cfg","resolveConfig","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","findDefaultWhere","defaults","find","where","watcherHeartbeatSecondsAgo","Math","round","Date","now","parse","format","console","log","JSON","stringify","length","map","name","join","embedded","pending","close"],"mappings":"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"}

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

@@ -0,0 +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 { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst watch: Command = async (ctx) => {\n  await runWatch(ctx.resolveConfig(), {\n    force: ctx.values.force,\n    onEvent: (event: WatchEvent) => {\n      if (event.type === 'started') {\n        console.log(`${ctx.name} watch: watching ${event.baseDir}`);\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","runWatch","resolveConfig","force","values","onEvent","event","type","console","log","name","baseDir","dbPath","printWarnings","warnings","parsed","total","error","message"],"mappings":";;;;+BAqBA;;;eAAA;;;uBApByB;wBACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,IAAMA,QAAiB,eAAOC;;;;;oBAC5B;;wBAAMC,IAAAA,iBAAQ,EAACD,IAAIE,aAAa,IAAI;4BAClCC,OAAOH,IAAII,MAAM,CAACD,KAAK;4BACvBE,SAAS,SAATA,QAAUC;gCACR,IAAIA,MAAMC,IAAI,KAAK,WAAW;oCAC5BC,QAAQC,GAAG,CAAC,AAAC,GAA8BH,OAA5BN,IAAIU,IAAI,EAAC,qBAAiC,OAAdJ,MAAMK,OAAO;oCACxDH,QAAQC,GAAG,CAAC,AAAC,GAAwBH,OAAtBN,IAAIU,IAAI,EAAC,eAA0B,OAAbJ,MAAMM,MAAM;gCACnD,OAAO,IAAIN,MAAMC,IAAI,KAAK,cAAc;oCACtCM,IAAAA,uBAAa,EAACP,MAAMQ,QAAQ;oCAC5B,IAAIR,MAAMS,MAAM,GAAG,GAAGP,QAAQC,GAAG,CAAC,AAAC,GAAiCH,OAA/BN,IAAIU,IAAI,EAAC,wBAAwDJ,OAAlCA,MAAMS,MAAM,EAAC,uBAAiC,OAAZT,MAAMU,KAAK,EAAC;gCACpH,OAAO;oCACLR,QAAQS,KAAK,CAAC,AAAC,GAAsCX,OAApCN,IAAIU,IAAI,EAAC,6BAAyC,OAAdJ,MAAMY,OAAO;gCACpE;4BACF;wBACF;;;oBAbA;;;;;;IAcF;;IACA,WAAenB"}

package/dist/cjs/cli.js

@@ -11,7 +11,7 @@ Object.defineProperty(exports, // Thrown errors -> exit 1 with the message verba
 });
 var _nodemodule = require("node:module");
 var _nodeutil = require("node:util");
-var _indexts = require("./commands/index.js");
+var _indexts = require("./cli/index.js");
 var _configts = require("./config.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -207,7 +207,7 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-// Parsing and dispatch only. Commands live in src/commands/, one file each, lazy-loaded --
+// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --
 // nothing tree- or dependency-heavy may be imported at the top of this file.
 // Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.
 function packageVersion() {
@@ -226,11 +226,11 @@ function packageVersion() {
     return 'unknown';
 }
 function usage(name) {
-    return "usage: ".concat(name, " <name> [params...] [--format table|json] [--config path]\n") + "       ".concat(name, ' query "<sql>" [params...]\n') + "       ".concat(name, ' find "<terms>" [--where "<sql>"] [--k n] [--semantic]\n') + "       ".concat(name, " map\n") + "       ".concat(name, " peek <path>\n") + "       ".concat(name, " --list\n") + "       ".concat(name, " init\n") + "       ".concat(name, " watch [--force]\n") + "       ".concat(name, " status\n") + "       ".concat(name, " rebuild\n") + "       ".concat(name, " --version");
+    return "usage: ".concat(name, " <name> [params...] [--format table|json] [--config path]\n") + "       ".concat(name, ' query "<sql>" [params...]\n') + "       ".concat(name, ' find "<terms>" [--where "<sql>"] [--k n] [--semantic]\n') + "       ".concat(name, " map\n") + "       ".concat(name, " peek <path>\n") + "       ".concat(name, " --list\n") + "       ".concat(name, " init\n") + "       ".concat(name, " watch [--force]\n") + "       ".concat(name, " status\n") + "       ".concat(name, " check\n") + "       ".concat(name, " rebuild\n") + "       ".concat(name, " --version");
 }
 function cli(argv, name) {
     return _async_to_generator(function() {
-        var values, positionals, ref, ctx, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, _positionals, first, params, load, err;
+        var values, positionals, ref, ctx, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, _positionals, first, params, load, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -253,8 +253,7 @@ function cli(argv, name) {
                                     type: 'string'
                                 },
                                 semantic: {
-                                    type: 'boolean',
-                                    default: false
+                                    type: 'boolean'
                                 },
                                 list: {
                                     type: 'boolean',
@@ -318,16 +317,17 @@ function cli(argv, name) {
                 case 1:
                     _state.trys.push([
                         1,
-                        7,
+                        8,
                         ,
-                        8
+                        9
                     ]);
                     if (values.list) {
+                        queries = ctx.resolveConfig().queries;
                         _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                         try {
-                            for(_iterator = Object.keys(ctx.resolveConfig().queries).sort()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            for(_iterator = Object.keys(queries).sort()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                                 queryName = _step.value;
-                                console.log(queryName);
+                                console.log(typeof queries[queryName] === 'string' ? queryName : "".concat(queryName, "  (find)"));
                             }
                         } catch (err) {
                             _didIteratorError = true;
@@ -370,32 +370,37 @@ function cli(argv, name) {
                     _state.sent();
                     return [
                         3,
-                        6
+                        7
                     ];
                 case 4:
                     return [
                         4,
                         Promise.resolve().then(function() {
-                            return /*#__PURE__*/ _interop_require_wildcard(require("./commands/named.js"));
+                            return /*#__PURE__*/ _interop_require_wildcard(require("./cli/named.js"));
                         })
                     ];
                 case 5:
-                    _state.sent().default(ctx, first, params);
-                    _state.label = 6;
+                    return [
+                        4,
+                        _state.sent().default(ctx, first, params)
+                    ];
                 case 6:
+                    _state.sent();
+                    _state.label = 7;
+                case 7:
                     return [
                         3,
-                        8
+                        9
                     ];
-                case 7:
+                case 8:
                     err = _state.sent();
                     console.error(err.message);
                     process.exit(1);
                     return [
                         3,
-                        8
+                        9
                     ];
-                case 8:
+                case 9:
                     return [
                         2
                     ];

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 } from './commands/index.ts';\nimport type { Ctx } from './commands/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/commands/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\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  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} find \"<terms>\" [--where \"<sql>\"] [--k n] [--semantic]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\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  let values: Record<string, string | boolean | undefined>;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: {\n        format: { type: 'string', default: 'table' },\n        config: { type: 'string' },\n        where: { type: 'string' },\n        k: { type: 'string' },\n        semantic: { type: 'boolean', default: false },\n        list: { type: 'boolean', default: false },\n        force: { type: 'boolean', default: false },\n        version: { type: 'boolean', default: false, short: 'v' },\n        help: { type: 'boolean', default: false, short: 'h' },\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  if (values.version) {\n    console.log(`v${packageVersion()}`);\n    return;\n  }\n  if (values.help) {\n    console.log(usage(name));\n    return;\n  }\n\n  const ctx: Ctx = {\n    name,\n    rest: positionals.slice(1),\n    format: values.format === 'json' ? 'json' : 'table',\n    values: values as Ctx['values'],\n    resolveConfig() {\n      const cfg = loadConfig(values.config as string | undefined);\n      if (cfg.migratedFrom !== undefined) {\n        console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\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    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    if (values.list) {\n      for (const queryName of Object.keys(ctx.resolveConfig().queries).sort()) console.log(queryName);\n      return;\n    }\n\n    const [first, ...params] = positionals;\n    if (!first) {\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else (await import('./commands/named.ts')).default(ctx, first, params);\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","argv","values","positionals","ctx","queryName","first","params","err","parseArgs","args","options","format","type","default","config","where","k","semantic","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","unknownKeys","join","usageError","Object","keys","queries","sort","COMMANDS"],"mappings":"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"}
+{"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 } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\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  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} find \"<terms>\" [--where \"<sql>\"] [--k n] [--semantic]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} check\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\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  let values: Record<string, string | boolean | undefined>;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: {\n        format: { type: 'string', default: 'table' },\n        config: { type: 'string' },\n        where: { type: 'string' },\n        k: { type: 'string' },\n        semantic: { type: 'boolean' },\n        list: { type: 'boolean', default: false },\n        force: { type: 'boolean', default: false },\n        version: { type: 'boolean', default: false, short: 'v' },\n        help: { type: 'boolean', default: false, short: 'h' },\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  if (values.version) {\n    console.log(`v${packageVersion()}`);\n    return;\n  }\n  if (values.help) {\n    console.log(usage(name));\n    return;\n  }\n\n  const ctx: Ctx = {\n    name,\n    rest: positionals.slice(1),\n    format: values.format === 'json' ? 'json' : 'table',\n    values: values as Ctx['values'],\n    resolveConfig() {\n      const cfg = loadConfig(values.config as string | undefined);\n      if (cfg.migratedFrom !== undefined) {\n        console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\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    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    if (values.list) {\n      const queries = ctx.resolveConfig().queries;\n      for (const queryName of Object.keys(queries).sort()) {\n        console.log(typeof queries[queryName] === 'string' ? queryName : `${queryName}  (find)`);\n      }\n      return;\n    }\n\n    const [first, ...params] = positionals;\n    if (!first) {\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first, params);\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","argv","values","positionals","ctx","queries","queryName","first","params","err","parseArgs","args","options","format","type","default","config","where","k","semantic","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","unknownKeys","join","usageError","Object","keys","sort","COMMANDS"],"mappings":"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"}

package/dist/{esm/verbs.d.ts → cjs/commands.d.cts}

@@ -1,12 +1,12 @@
 import type { DatabaseSync } from 'node:sqlite';
-import type { Config, FeatureName } from './config.js';
+import type { FeatureName, ResolvedConfig } from './config.js';
 import type { Row } from './output.js';
 export interface FindOptions {
     k?: number;
     where?: string;
     semantic?: boolean;
 }
-export declare function find(db: DatabaseSync, cfg: Config, terms: string, opts?: FindOptions): Promise<Row[]>;
+export declare function find(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: FindOptions): Promise<Row[]>;
 export interface TreeMap {
     docs: {
         count: number;
@@ -21,7 +21,7 @@ export interface TreeMap {
     hubs: Row[];
     recent: Row[];
 }
-export declare function mapTree(db: DatabaseSync, cfg: Config): TreeMap;
+export declare function mapTree(db: DatabaseSync, cfg: ResolvedConfig): TreeMap;
 export interface Peek {
     path: string;
     tokens: number;
@@ -30,9 +30,10 @@ export interface Peek {
     outbound: string[];
     backlinks: string[];
     unresolved: string[];
+    sectionsTotal: number;
     outboundTotal: number;
     backlinksTotal: number;
     unresolvedTotal: number;
     off: FeatureName[];
 }
-export declare function peek(db: DatabaseSync, cfg: Config, pathArg: string): Peek;
+export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string): Peek;

package/dist/cjs/{verbs.d.cts → commands.d.ts}

@@ -1,12 +1,12 @@
 import type { DatabaseSync } from 'node:sqlite';
-import type { Config, FeatureName } from './config.js';
+import type { FeatureName, ResolvedConfig } from './config.js';
 import type { Row } from './output.js';
 export interface FindOptions {
     k?: number;
     where?: string;
     semantic?: boolean;
 }
-export declare function find(db: DatabaseSync, cfg: Config, terms: string, opts?: FindOptions): Promise<Row[]>;
+export declare function find(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: FindOptions): Promise<Row[]>;
 export interface TreeMap {
     docs: {
         count: number;
@@ -21,7 +21,7 @@ export interface TreeMap {
     hubs: Row[];
     recent: Row[];
 }
-export declare function mapTree(db: DatabaseSync, cfg: Config): TreeMap;
+export declare function mapTree(db: DatabaseSync, cfg: ResolvedConfig): TreeMap;
 export interface Peek {
     path: string;
     tokens: number;
@@ -30,9 +30,10 @@ export interface Peek {
     outbound: string[];
     backlinks: string[];
     unresolved: string[];
+    sectionsTotal: number;
     outboundTotal: number;
     backlinksTotal: number;
     unresolvedTotal: number;
     off: FeatureName[];
 }
-export declare function peek(db: DatabaseSync, cfg: Config, pathArg: string): Peek;
+export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string): Peek;