sensemaking 0.9.4 → 0.10.0

package/dist/cjs/cli/related.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _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;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _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;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+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 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();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    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 _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
+        };
+    }
+}
+var RELATED_DEFAULT_K = 5;
+var relatedCmd = function relatedCmd(ctx) {
+    var _parseK;
+    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.related);
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SCOPE, _sharedts.FORMAT, _sharedts.CONFIG), {
+        k: {
+            type: 'string'
+        }
+    })), values = _parse.values, positionals = _parse.positionals;
+    var _positionals = _sliced_to_array(positionals, 1), pathArg = _positionals[0];
+    if (!pathArg) ctx.usageError(usage);
+    var k = (_parseK = (0, _sharedts.parseK)(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : RELATED_DEFAULT_K;
+    var format = (0, _sharedts.formatOf)(values);
+    return (0, _sharedts.withDb)(ctx, values.config, function(db, cfg) {
+        return _async_to_generator(function() {
+            var overrides;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        overrides = (0, _sharedts.scopeOf)(values);
+                        return [
+                            4,
+                            (0, _commandsts.relatedNotes)(db, cfg, pathArg, overrides, k)
+                        ];
+                    case 1:
+                        _outputts.printRows.apply(void 0, [
+                            _state.sent(),
+                            format
+                        ]);
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+};
+var _default = relatedCmd;
+/* 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/related.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { relatedNotes } from '../commands.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, parseK, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst RELATED_DEFAULT_K = 5;\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...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 = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, async (db, cfg) => {\n    const overrides = scopeOf(values);\n    printRows((await relatedNotes(db, cfg, pathArg, overrides, k)) as Row[], format);\n  });\n};\nexport default relatedCmd;\n"],"names":["RELATED_DEFAULT_K","relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","format","formatOf","withDb","config","db","cfg","overrides","scopeOf","relatedNotes","printRows"],"mappings":";;;;+BAqBA;;;eAAA;;;0BArB6B;wBAEH;uBACJ;wBAC0D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGhF,IAAMA,oBAAoB;AAE1B,IAAMC,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,cAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAArGC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASf,IAAIgB,UAAU,CAACd;IAC7B,IAAMS,KAAIV,UAAAA,IAAAA,gBAAM,EAACY,OAAOF,CAAC,EAAwBX,IAAIgB,UAAU,eAArDf,qBAAAA,UAA0DH;IACpE,IAAMmB,SAASC,IAAAA,kBAAQ,EAACL;IACxB,OAAOM,IAAAA,gBAAM,EAACnB,KAAKa,OAAOO,MAAM,EAAwB,SAAOC,IAAIC;;gBAC3DC;;;;wBAAAA,YAAYC,IAAAA,iBAAO,EAACX;wBACf;;4BAAMY,IAAAA,wBAAY,EAACJ,IAAIC,KAAKP,SAASQ,WAAWZ;;;wBAA3De,mBAAS;4BAAE;4BAA8DT;;;;;;;QAC3E;;AACF;IACA,WAAelB"}

package/dist/cjs/cli/search.js

@@ -235,13 +235,9 @@ var searchCmd = function searchCmd(ctx) {
                                         case 0:
                                             return [
                                                 4,
-                                                (0, _commandsts.search)(db, cfg, terms, {
-                                                    k: k,
-                                                    where: values.where,
-                                                    preset: values.preset,
-                                                    include: values.include,
-                                                    semantic: values.lexical ? false : undefined
-                                                })
+                                                (0, _commandsts.search)(db, cfg, terms, _object_spread({
+                                                    k: k
+                                                }, (0, _sharedts.scopeOf)(values)))
                                             ];
                                         case 1:
                                             return [

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 { 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"}
+{"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, 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, ...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, ...scopeOf(values) }), 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","scopeOf","printRows"],"mappings":";;;;+BAeA;;;eAAA;;;0BAfuB;wBACG;uBACJ;wBACiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvF,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;mDAAMgB,IAAAA,iBAAO,EAACnB;;;;;gDAAvDoB,mBAAS;oDAAC;oDAAyDhB;;;;;;;;;oBAA7I;;;;;;IACF;;IACA,WAAeR"}

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

@@ -1,11 +1,13 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
-import type { ResolvedConfig } from '../config.js';
+import type { ResolvedConfig, SearchOverrides } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
 export declare const FORMAT: ParseArgsOptionsConfig;
 export declare const CONFIG: ParseArgsOptionsConfig;
+export declare const SCOPE: ParseArgsOptionsConfig;
 export declare const SEARCH_FLAGS: ParseArgsOptionsConfig;
 type Values = Record<string, string | boolean | string[] | undefined>;
+export declare function scopeOf(values: Values): SearchOverrides;
 export declare function formatOf(values: Values): 'table' | 'json';
 export declare function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): {
     values: Values;

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

@@ -1,11 +1,13 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
-import type { ResolvedConfig } from '../config.js';
+import type { ResolvedConfig, SearchOverrides } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
 export declare const FORMAT: ParseArgsOptionsConfig;
 export declare const CONFIG: ParseArgsOptionsConfig;
+export declare const SCOPE: ParseArgsOptionsConfig;
 export declare const SEARCH_FLAGS: ParseArgsOptionsConfig;
 type Values = Record<string, string | boolean | string[] | undefined>;
+export declare function scopeOf(values: Values): SearchOverrides;
 export declare function formatOf(values: Values): 'table' | 'json';
 export declare function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): {
     values: Values;

package/dist/cjs/cli/shared.js

@@ -15,6 +15,9 @@ _export(exports, {
     get FORMAT () {
         return FORMAT;
     },
+    get SCOPE () {
+        return SCOPE;
+    },
     get SEARCH_FLAGS () {
         return SEARCH_FLAGS;
     },
@@ -33,6 +36,9 @@ _export(exports, {
     get runSql () {
         return runSql;
     },
+    get scopeOf () {
+        return scopeOf;
+    },
     get withDb () {
         return withDb;
     }
@@ -257,13 +263,10 @@ var CONFIG = {
         type: 'string'
     }
 };
-var SEARCH_FLAGS = {
+var SCOPE = {
     where: {
         type: 'string'
     },
-    k: {
-        type: 'string'
-    },
     preset: {
         type: 'string'
     },
@@ -271,11 +274,31 @@ var SEARCH_FLAGS = {
         type: 'string',
         multiple: true
     },
-    lexical: {
+    exclude: {
+        type: 'string',
+        multiple: true
+    },
+    // Widening, which no other flag can express: --include and --exclude each override their
+    // own side of the preset, so neither can drop an exclusion the preset declares.
+    'no-exclude': {
         type: 'boolean',
         default: false
     }
 };
+var SEARCH_FLAGS = _object_spread_props(_object_spread({}, SCOPE), {
+    k: {
+        type: 'string'
+    }
+});
+function scopeOf(values) {
+    return {
+        preset: values.preset,
+        include: values.include,
+        exclude: values.exclude,
+        where: values.where,
+        noExclude: values['no-exclude'] === true
+    };
+}
 function formatOf(values) {
     return values.format === 'json' ? 'json' : 'table';
 }

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 } 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// 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 SEARCH_FLAGS: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  k: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  lexical: { type: 'boolean', default: false },\n};\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return values.format === 'json' ? 'json' : 'table';\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\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// 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// 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, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\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":["CONFIG","FORMAT","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","runSql","withDb","format","type","default","config","where","k","preset","include","multiple","lexical","values","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","console","error","message","process","exit","log","usageError","undefined","parsed","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","sql","params","label","placeholderCount","match","length","rows","prepare","all","test","searchError","join","printRows"],"mappings":"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"}
+{"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.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// 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' } };\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' } };\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. One\n// place to read them, so a new scope field is added to the fragment and here, not in each\n// command's call.\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\nexport function formatOf(values: Values): 'table' | 'json' {\n  return values.format === 'json' ? 'json' : 'table';\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\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// 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// 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, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\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":["CONFIG","FORMAT","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","runSql","scopeOf","withDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","console","error","message","process","exit","log","usageError","undefined","parsed","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","sql","params","label","placeholderCount","match","length","rows","prepare","all","test","searchError","join","printRows"],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+import type { Command } from './types.js';
+declare const sqlCmd: Command;
+export default sqlCmd;

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

@@ -0,0 +1,3 @@
+import type { Command } from './types.js';
+declare const sqlCmd: Command;
+export default sqlCmd;

package/dist/cjs/cli/{query.js → sql.js}

@@ -63,13 +63,13 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-var query = function query(ctx) {
-    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.query);
+var sqlCmd = function sqlCmd(ctx) {
+    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.sql);
     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');
+    (0, _sharedts.runSql)(ctx.resolveConfig(values.config), sql, params, format, 'ad-hoc statement');
 };
-var _default = query;
+var _default = sqlCmd;
 /* 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/sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/sql.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst sqlCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.sql}`;\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 statement');\n};\nexport default sqlCmd;\n"],"names":["sqlCmd","ctx","usage","USAGE","name","sql","parse","argv","FORMAT","CONFIG","values","positionals","params","usageError","format","formatOf","runSql","resolveConfig","config"],"mappings":";;;;+BAYA;;;eAAA;;;uBAZsB;wBACkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxD,IAAMA,SAAkB,gBAACC;IACvB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACE,GAAG;IAC7C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,mBAAKM,gBAAM,EAAKC,gBAAM,IAArEC,SAAwBJ,OAAxBI,QAAQC,cAAgBL,OAAhBK;IAChB,IAAyBA,yBAAAA,cAAlBN,MAAkBM,iBAAb,AAAGC,SAAUD,mBAAb;IACZ,IAAI,CAACN,KAAKJ,IAAIY,UAAU,CAACX;IACzB,IAAMY,SAASC,IAAAA,kBAAQ,EAACL;IACxBM,IAAAA,gBAAM,EAACf,IAAIgB,aAAa,CAACP,OAAOQ,MAAM,GAAyBb,KAAKO,QAAQE,QAAQ;AACtF;IACA,WAAed"}

package/dist/cjs/cli/status.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "default", {
 var _commandsts = require("../commands.js");
 var _configts = require("../config.js");
 var _dbts = require("../db.js");
+var _embedts = require("../features/embed.js");
 var _outputts = require("../output.js");
 var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
@@ -61,6 +62,7 @@ var status = function status(ctx) {
     (0, _sharedts.printWarnings)(warnings);
     var features = (0, _configts.featureStates)(cfg);
     var e = (0, _configts.embedConfig)(cfg);
+    var hasModel = e ? (0, _embedts.modelPresent)(cfg) : false;
     var vectors = e ? vectorState(db) : null;
     var presets = (0, _commandsts.presetCoverage)(db, cfg);
     var heartbeat = (0, _dbts.getMeta)(db, 'watch_heartbeat');
@@ -75,7 +77,8 @@ var status = function status(ctx) {
         featuresOff: features.off,
         embed: e ? _object_spread({
             type: e.type,
-            model: e.model
+            model: e.model,
+            downloaded: hasModel
         }, vectors !== null && vectors !== void 0 ? vectors : {}) : null,
         presets: presets,
         watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,
@@ -87,7 +90,11 @@ var status = function status(ctx) {
         console.log("db: ".concat(result.db));
         console.log("docs: ".concat(result.docs));
         console.log((0, _outputts.featuresLine)(features));
-        if (e) console.log("embed: ".concat(e.type, " ").concat(e.model).concat(vectors ? " (vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending — embedded on the first semantic search)") : ''));
+        // One authoritative line, off states included: an absent model reads as a degraded
+        // search, not as an empty corpus.
+        if (!e) console.log('embed: off (no preset asks for vectors)');
+        else if (!hasModel) console.log("embed: ".concat(e.type, " ").concat(e.model, " — unavailable, so search runs on words and links only (").concat((0, _embedts.isDownloadable)(e.model) ? "run `".concat(ctx.name, " download`") : "no ".concat(_embedts.MODEL_FILENAMES, " in that directory"), ")"));
+        else console.log("embed: ".concat(e.type, " ").concat(e.model).concat(vectors ? " (vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending — embedded on the first semantic search)") : ''));
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             for(var _iterator = (0, _outputts.presetsLines)(presets)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, 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 have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on\n// such a 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 { 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);\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 presets = presetCoverage(db, cfg);\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    presets,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (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    console.log(featuresLine(features));\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on the first semantic search)` : ''}`);\n    for (const line of presetsLines(presets)) console.log(line);\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","values","parse","argv","USAGE","name","FORMAT","CONFIG","format","formatOf","cfg","resolveConfig","config","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","watcherHeartbeatSecondsAgo","Math","round","Date","now","console","log","JSON","stringify","featuresLine","embedded","pending","presetsLines","line","close"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { isDownloadable, MODEL_FILENAMES, modelPresent } from '../features/embed.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, 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 have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on\n// such a 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 { 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);\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const hasModel = e ? modelPresent(cfg) : false;\n  const vectors = e ? vectorState(db) : null;\n  const presets = presetCoverage(db, cfg);\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, downloaded: hasModel, ...(vectors ?? {}) } : null,\n    presets,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (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    console.log(featuresLine(features));\n    // One authoritative line, off states included: an absent model reads as a degraded\n    // search, not as an empty corpus.\n    if (!e) console.log('embed: off (no preset asks for vectors)');\n    else if (!hasModel) console.log(`embed: ${e.type} ${e.model} — unavailable, so search runs on words and links only (${isDownloadable(e.model) ? `run \\`${ctx.name} download\\`` : `no ${MODEL_FILENAMES} in that directory`})`);\n    else console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on the first semantic search)` : ''}`);\n    for (const line of presetsLines(presets)) console.log(line);\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","values","parse","argv","USAGE","name","FORMAT","CONFIG","format","formatOf","cfg","resolveConfig","config","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","hasModel","modelPresent","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","downloaded","watcherHeartbeatSecondsAgo","Math","round","Date","now","console","log","JSON","stringify","featuresLine","isDownloadable","MODEL_FILENAMES","embedded","pending","presetsLines","line","close"],"mappings":"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"}

package/dist/cjs/cli.js

@@ -100,10 +100,6 @@ function _non_iterable_spread() {
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -211,10 +207,8 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-// 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. Flags parse
-// per command (each command's own parse() call); this file only handles the bare top-level
-// flags (--version/--help/--list/--config) and dispatch.
+// Parsing and dispatch only; commands lazy-load from src/cli/, so nothing heavy is imported
+// here. Flags parse per command -- this file handles only --version/--help/--list/--config.
 // Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.
 function packageVersion() {
     var load = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
@@ -254,7 +248,7 @@ function resolveConfigFor(name, configPath) {
 }
 function cli(argv, name) {
     return _async_to_generator(function() {
-        var first, values, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, entry, isSavedSearch, ctx, load, err;
+        var first, values, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, RENAMED, ctx, load, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -310,9 +304,9 @@ function cli(argv, name) {
                                 try {
                                     for(_iterator = Object.keys(queries).sort()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                                         queryName = _step.value;
-                                        entry = queries[queryName];
-                                        isSavedSearch = (typeof entry === "undefined" ? "undefined" : _type_of(entry)) === 'object' && entry !== null && 'search' in entry;
-                                        console.log(isSavedSearch ? "".concat(queryName, "  (search)") : queryName);
+                                        // Every entry names its verb, so --list can label both kinds rather than only
+                                        // marking the exception.
+                                        console.log("".concat(queryName, "  (").concat('search' in queries[queryName] ? 'search' : 'sql', ")"));
                                     }
                                 } catch (err) {
                                     _didIteratorError = true;
@@ -339,9 +333,14 @@ function cli(argv, name) {
                         console.error(usage(name));
                         process.exit(2);
                     }
-                    // find -> search (breaking rename): one release of a pointer instead of "unknown query".
-                    if (first === 'find') {
-                        console.error("".concat(name, ": find is now search"));
+                    // Breaking renames get one release of a pointer instead of an "unknown" error: find ->
+                    // search, and query -> sql (which took its name back from the search sense of "query").
+                    RENAMED = {
+                        find: 'search',
+                        query: 'sql'
+                    };
+                    if (RENAMED[first]) {
+                        console.error("".concat(name, ": ").concat(first, " is now ").concat(RENAMED[first]));
                         console.error(usage(name));
                         process.exit(2);
                     }