sensemaking 0.4.0 → 0.6.0

package/README.md

@@ -59,14 +59,16 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 | verb | does |
 |---|---|
 | `map` | doc count, frontmatter field coverage, top hubs by link rank, recent changes |
-| `find "<terms>" [--where "<sql>"] [--k n]` | BM25 + link-graph expansion, fused; `via` marks each row `match`, `link`, or `match+link` |
+| `find "<terms>" [--where "<sql>"] [--k n] [--semantic]` | BM25 + link-graph expansion, fused; `via` marks each row `match`, `link`, or `match+link` |
 | `peek <path>` | frontmatter + heading outline (`[L143-162, ~380t]`) + links both ways, capped at 20 per list |
 | `query "<sql>" [params...]` | ad-hoc SQL over all four tables; `?` binds positional args |
 
 `find` seeds a personalized-PageRank walk with the BM25 matches, so a note that never contains
 the terms but is linked from ones that do still surfaces. Terms pass verbatim to FTS5 `MATCH`
 (bare words AND-join; operators are yours to write). `--where` takes a frontmatter condition
-against alias `f`.
+against alias `f`. On trees with the `embed` feature, `--semantic` additionally expands by
+meaning — explicit per query, never silent; rows it adds are labeled `via: vector` and carry a
+`lines` column pointing at the best-matching section.
 `--format json` on any verb returns structured output.
 
 ## Config
@@ -91,10 +93,18 @@ goes BM25-only without `links`, `map` drops hubs without `rank`, `peek` drops th
 without `sections`). Toggling rebuilds the cache. Older config versions auto-migrate on load,
 noted on stderr.
 
+`embed` is the one opt-in feature (absent = off; most trees don't need vectors): `"embed": true`
+uses the built-in static model (downloaded to `~/.cache/sensemaking` on first use, never in the
+package), or `{ "model", "type": "static"|"api", "url", "key" }` points at any Model2Vec model,
+local path, or OpenAI-compatible endpoint (Ollama, LM Studio, hosted). With it on, vectors stay
+fresh at reconcile and `find --semantic` uses them; default `find` results are unchanged.
+
 ## Reference
 
 - `has(field, value)` — the one custom SQL function: array membership on JSON-array fields,
-  substring on strings, false on missing keys.
+  substring on strings (so `has(f.status, 'active')` also matches `inactive`), false on missing
+  keys. Exact matches: `=` for scalars, `EXISTS (SELECT 1 FROM json_each(f.tags) WHERE value = ?)`
+  for array members.
 - Reserved frontmatter keys (dropped with a warning): `path`, `_mtime`, `_size`, `_rank`,
   `content`, `links`, `sections`.
 - FTS5 syntax in `MATCH`: `a OR b`, `"phrase"`, `pref*`, `NEAR(a b, 5)`, `summary: term`.
@@ -138,10 +148,9 @@ The skill teaches the descent: `map` to orient, `find` to locate, `peek` before
   query it headless.
 - **Index-on-build tools (MarkdownDB)** — query a snapshot; `sense` reconciles on every query.
 - **Note CLIs (zk)** — fixed schema; `sense` filters on arbitrary frontmatter.
-- **RAG / vector stores** — similarity can't express `WHERE status = 'active'`. Vector recall is
-  planned as an optional `embed` feature (pure-JS provider package, fused into `find`) — not
-  blocked (`node:sqlite` can load extensions since Node 22.13), just deferred until BM25 + links
-  measurably miss.
+- **RAG / vector stores** — similarity can't express `WHERE status = 'active'`. Here vectors are
+  the optional `embed` feature: same SQLite file, filters compose, expansion is explicit per
+  query (`find --semantic`) and labeled — no second store, no daemon, no native builds.
 
 Dependencies: [yaml](https://github.com/eemeli/yaml),
 [remove-markdown](https://github.com/zuchka/remove-markdown),

package/dist/cjs/cli.js

@@ -226,7 +226,7 @@ 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]\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, " rebuild\n") + "       ".concat(name, " --version");
 }
 function cli(argv, name) {
     return _async_to_generator(function() {
@@ -252,6 +252,10 @@ function cli(argv, name) {
                                 k: {
                                     type: 'string'
                                 },
+                                semantic: {
+                                    type: 'boolean',
+                                    default: false
+                                },
                                 list: {
                                     type: 'boolean',
                                     default: false

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]\\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        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      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","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","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 './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      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","usageError","Object","keys","queries","sort","COMMANDS"],"mappings":"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"}

package/dist/cjs/commands/find.js

@@ -19,6 +19,35 @@ function _array_like_to_array(arr, len) {
 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 _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -57,17 +86,151 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
+function _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 findCmd = function findCmd(ctx) {
-    var _ctx_rest = _sliced_to_array(ctx.rest, 1), terms = _ctx_rest[0];
-    if (!terms) ctx.usageError("usage: ".concat(ctx.name, ' find "<terms>" [--where "<sql>"] [--k n]'));
-    var k = ctx.values.k === undefined ? undefined : Number.parseInt(ctx.values.k, 10);
-    if (ctx.values.k !== undefined && !Number.isInteger(k)) ctx.usageError('--k expects an integer, got "'.concat(ctx.values.k, '"'));
-    (0, _sharedts.withDb)(ctx, function(db, cfg) {
-        return (0, _outputts.printRows)((0, _verbsts.find)(db, cfg, terms, {
-            k: k,
-            where: ctx.values.where
-        }), ctx.format);
-    });
+    return _async_to_generator(function() {
+        var _ctx_rest, terms, k;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _ctx_rest = _sliced_to_array(ctx.rest, 1), terms = _ctx_rest[0];
+                    if (!terms) ctx.usageError("usage: ".concat(ctx.name, ' find "<terms>" [--where "<sql>"] [--k n] [--semantic]'));
+                    k = ctx.values.k === undefined ? undefined : Number.parseInt(ctx.values.k, 10);
+                    if (ctx.values.k !== undefined && !Number.isInteger(k)) ctx.usageError('--k expects an integer, got "'.concat(ctx.values.k, '"'));
+                    return [
+                        4,
+                        (0, _sharedts.withDb)(ctx, function(db, cfg) {
+                            return _async_to_generator(function() {
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            return [
+                                                4,
+                                                (0, _verbsts.find)(db, cfg, terms, {
+                                                    k: k,
+                                                    where: ctx.values.where,
+                                                    semantic: ctx.values.semantic
+                                                })
+                                            ];
+                                        case 1:
+                                            return [
+                                                2,
+                                                _outputts.printRows.apply(void 0, [
+                                                    _state.sent(),
+                                                    ctx.format
+                                                ])
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
 };
 var _default = findCmd;
 /* 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/commands/find.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/find.ts"],"sourcesContent":["import { printRows } from '../output.ts';\nimport { find } from '../verbs.ts';\nimport { withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst findCmd: Command = (ctx) => {\n  const [terms] = ctx.rest;\n  if (!terms) ctx.usageError(`usage: ${ctx.name} find \"<terms>\" [--where \"<sql>\"] [--k n]`);\n  const k = ctx.values.k === undefined ? undefined : Number.parseInt(ctx.values.k, 10);\n  if (ctx.values.k !== undefined && !Number.isInteger(k)) ctx.usageError(`--k expects an integer, got \"${ctx.values.k}\"`);\n  withDb(ctx, (db, cfg) => printRows(find(db, cfg, terms, { k, where: ctx.values.where }), ctx.format));\n};\nexport default findCmd;\n"],"names":["findCmd","ctx","rest","terms","usageError","name","k","values","undefined","Number","parseInt","isInteger","withDb","db","cfg","printRows","find","where","format"],"mappings":";;;;+BAYA;;;eAAA;;;wBAZ0B;uBACL;wBACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,IAAMA,UAAmB,iBAACC;IACxB,IAAgBA,6BAAAA,IAAIC,IAAI,MAAjBC,QAASF;IAChB,IAAI,CAACE,OAAOF,IAAIG,UAAU,CAAC,AAAC,UAAkB,OAATH,IAAII,IAAI,EAAC;IAC9C,IAAMC,IAAIL,IAAIM,MAAM,CAACD,CAAC,KAAKE,YAAYA,YAAYC,OAAOC,QAAQ,CAACT,IAAIM,MAAM,CAACD,CAAC,EAAE;IACjF,IAAIL,IAAIM,MAAM,CAACD,CAAC,KAAKE,aAAa,CAACC,OAAOE,SAAS,CAACL,IAAIL,IAAIG,UAAU,CAAC,AAAC,gCAA4C,OAAbH,IAAIM,MAAM,CAACD,CAAC,EAAC;IACpHM,IAAAA,gBAAM,EAACX,KAAK,SAACY,IAAIC;eAAQC,IAAAA,mBAAS,EAACC,IAAAA,aAAI,EAACH,IAAIC,KAAKX,OAAO;YAAEG,GAAAA;YAAGW,OAAOhB,IAAIM,MAAM,CAACU,KAAK;QAAC,IAAIhB,IAAIiB,MAAM;;AACrG;IACA,WAAelB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/find.ts"],"sourcesContent":["import { printRows } from '../output.ts';\nimport { find } from '../verbs.ts';\nimport { withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst findCmd: Command = async (ctx) => {\n  const [terms] = ctx.rest;\n  if (!terms) ctx.usageError(`usage: ${ctx.name} find \"<terms>\" [--where \"<sql>\"] [--k n] [--semantic]`);\n  const k = ctx.values.k === undefined ? undefined : Number.parseInt(ctx.values.k, 10);\n  if (ctx.values.k !== undefined && !Number.isInteger(k)) ctx.usageError(`--k expects an integer, got \"${ctx.values.k}\"`);\n  await withDb(ctx, async (db, cfg) => printRows(await find(db, cfg, terms, { k, where: ctx.values.where, semantic: ctx.values.semantic }), ctx.format));\n};\nexport default findCmd;\n"],"names":["findCmd","ctx","terms","k","rest","usageError","name","values","undefined","Number","parseInt","isInteger","withDb","db","cfg","find","where","semantic","printRows","format"],"mappings":";;;;+BAYA;;;eAAA;;;wBAZ0B;uBACL;wBACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,IAAMA,UAAmB,iBAAOC;;YACdA,WAATC,OAEDC;;;;oBAFUF,6BAAAA,IAAIG,IAAI,MAAjBF,QAASD;oBAChB,IAAI,CAACC,OAAOD,IAAII,UAAU,CAAC,AAAC,UAAkB,OAATJ,IAAIK,IAAI,EAAC;oBACxCH,IAAIF,IAAIM,MAAM,CAACJ,CAAC,KAAKK,YAAYA,YAAYC,OAAOC,QAAQ,CAACT,IAAIM,MAAM,CAACJ,CAAC,EAAE;oBACjF,IAAIF,IAAIM,MAAM,CAACJ,CAAC,KAAKK,aAAa,CAACC,OAAOE,SAAS,CAACR,IAAIF,IAAII,UAAU,CAAC,AAAC,gCAA4C,OAAbJ,IAAIM,MAAM,CAACJ,CAAC,EAAC;oBACpH;;wBAAMS,IAAAA,gBAAM,EAACX,KAAK,SAAOY,IAAIC;;;;;4CAAkB;;gDAAMC,IAAAA,aAAI,EAACF,IAAIC,KAAKZ,OAAO;oDAAEC,GAAAA;oDAAGa,OAAOf,IAAIM,MAAM,CAACS,KAAK;oDAAEC,UAAUhB,IAAIM,MAAM,CAACU,QAAQ;gDAAC;;;;;gDAAjGC,mBAAS;oDAAC;oDAA2FjB,IAAIkB,MAAM;;;;;;;;;oBAApJ;;;;;;IACF;;IACA,WAAenB"}

package/dist/cjs/commands/map.js

@@ -12,7 +12,7 @@ var _outputts = require("../output.js");
 var _verbsts = require("../verbs.js");
 var _sharedts = require("./shared.js");
 var map = function map(ctx) {
-    (0, _sharedts.withDb)(ctx, function(db, cfg) {
+    return (0, _sharedts.withDb)(ctx, function(db, cfg) {
         var result = (0, _verbsts.mapTree)(db, cfg);
         console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderMap)(result));
     });

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/map.ts"],"sourcesContent":["import { renderMap } from '../output.ts';\nimport { mapTree } from '../verbs.ts';\nimport { withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst map: Command = (ctx) => {\n  withDb(ctx, (db, cfg) => {\n    const result = mapTree(db, cfg);\n    console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : renderMap(result));\n  });\n};\nexport default map;\n"],"names":["map","ctx","withDb","db","cfg","result","mapTree","console","log","format","JSON","stringify","renderMap"],"mappings":";;;;+BAWA;;;eAAA;;;wBAX0B;uBACF;wBACD;AAGvB,IAAMA,MAAe,aAACC;IACpBC,IAAAA,gBAAM,EAACD,KAAK,SAACE,IAAIC;QACf,IAAMC,SAASC,IAAAA,gBAAO,EAACH,IAAIC;QAC3BG,QAAQC,GAAG,CAACP,IAAIQ,MAAM,KAAK,SAASC,KAAKC,SAAS,CAACN,QAAQ,MAAM,KAAKO,IAAAA,mBAAS,EAACP;IAClF;AACF;IACA,WAAeL"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/map.ts"],"sourcesContent":["import { renderMap } from '../output.ts';\nimport { mapTree } from '../verbs.ts';\nimport { withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst map: Command = (ctx) =>\n  withDb(ctx, (db, cfg) => {\n    const result = mapTree(db, cfg);\n    console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : renderMap(result));\n  });\nexport default map;\n"],"names":["map","ctx","withDb","db","cfg","result","mapTree","console","log","format","JSON","stringify","renderMap"],"mappings":";;;;+BAUA;;;eAAA;;;wBAV0B;uBACF;wBACD;AAGvB,IAAMA,MAAe,aAACC;WACpBC,IAAAA,gBAAM,EAACD,KAAK,SAACE,IAAIC;QACf,IAAMC,SAASC,IAAAA,gBAAO,EAACH,IAAIC;QAC3BG,QAAQC,GAAG,CAACP,IAAIQ,MAAM,KAAK,SAASC,KAAKC,SAAS,CAACN,QAAQ,MAAM,KAAKO,IAAAA,mBAAS,EAACP;IAClF;;IACF,WAAeL"}

package/dist/cjs/commands/peek.js

@@ -60,7 +60,7 @@ function _unsupported_iterable_to_array(o, minLen) {
 var peekCmd = function peekCmd(ctx) {
     var _ctx_rest = _sliced_to_array(ctx.rest, 1), pathArg = _ctx_rest[0];
     if (!pathArg) ctx.usageError("usage: ".concat(ctx.name, " peek <path>"));
-    (0, _sharedts.withDb)(ctx, function(db, cfg) {
+    return (0, _sharedts.withDb)(ctx, function(db, cfg) {
         var result = (0, _verbsts.peek)(db, cfg, pathArg);
         console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderPeek)(result));
     });

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/peek.ts"],"sourcesContent":["import { renderPeek } from '../output.ts';\nimport { peek } from '../verbs.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  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;;;wBAb2B;uBACN;wBACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGvB,IAAMA,UAAmB,iBAACC;IACxB,IAAkBA,6BAAAA,IAAIC,IAAI,MAAnBC,UAAWF;IAClB,IAAI,CAACE,SAASF,IAAIG,UAAU,CAAC,AAAC,UAAkB,OAATH,IAAII,IAAI,EAAC;IAChDC,IAAAA,gBAAM,EAACL,KAAK,SAACM,IAAIC;QACf,IAAMC,SAASC,IAAAA,aAAI,EAACH,IAAIC,KAAKL;QAC7BQ,QAAQC,GAAG,CAACX,IAAIY,MAAM,KAAK,SAASC,KAAKC,SAAS,CAACN,QAAQ,MAAM,KAAKO,IAAAA,oBAAU,EAACP;IACnF;AACF;IACA,WAAeT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/peek.ts"],"sourcesContent":["import { renderPeek } from '../output.ts';\nimport { peek } from '../verbs.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;;;wBAb2B;uBACN;wBACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,aAAI,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/commands/shared.d.cts

@@ -2,5 +2,5 @@ import type { ResolvedConfig } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
 export declare function printWarnings(warnings: string[]): void;
-export declare function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void): 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/shared.d.ts

@@ -2,5 +2,5 @@ import type { ResolvedConfig } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
 export declare function printWarnings(warnings: string[]): void;
-export declare function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void): 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/shared.js

@@ -29,6 +29,35 @@ function _array_like_to_array(arr, len) {
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(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 _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
@@ -46,6 +75,105 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
+function _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 printWarnings(warnings) {
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
@@ -69,14 +197,44 @@ function printWarnings(warnings) {
     }
 }
 function withDb(ctx, fn) {
-    var cfg = ctx.resolveConfig();
-    var _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
-    printWarnings(warnings);
-    try {
-        fn(db, cfg);
-    } finally{
-        db.close();
-    }
+    return _async_to_generator(function() {
+        var cfg, _open, db, warnings;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    cfg = ctx.resolveConfig();
+                    _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
+                    printWarnings(warnings);
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        ,
+                        3,
+                        4
+                    ]);
+                    return [
+                        4,
+                        fn(db, cfg)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        3,
+                        4
+                    ];
+                case 3:
+                    db.close();
+                    return [
+                        7
+                    ];
+                case 4:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
 }
 function runSql(cfg, sql, params, format, label) {
     var _db_prepare;

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/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 type { Ctx } from './types.ts';\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 function withDb(ctx: Ctx, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void): void {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    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  printRows(db.prepare(sql).all(...params) as Row[], format);\n  db.close();\n}\n"],"names":["printWarnings","runSql","withDb","warnings","w","console","warn","ctx","fn","cfg","resolveConfig","open","db","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","printRows","prepare","all"],"mappings":";;;;;;;;;;;QASgBA;eAAAA;;QAgBAC;eAAAA;;QAZAC;eAAAA;;;oBAXK;wBAEK;;;;;;;;;;;;;;;;;;;;;;;;;;AAKnB,SAASF,cAAcG,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,SAASF,OAAOK,GAAQ,EAAEC,EAAuD;IACtF,IAAMC,MAAMF,IAAIG,aAAa;IAC7B,IAAyBC,QAAAA,IAAAA,UAAI,EAACF,MAAtBG,KAAiBD,MAAjBC,IAAIT,WAAaQ,MAAbR;IACZH,cAAcG;IACd,IAAI;QACFK,GAAGI,IAAIH;IACT,SAAU;QACRG,GAAGC,KAAK;IACV;AACF;AAGO,SAASZ,OAAOQ,GAAmB,EAAEK,GAAW,EAAEC,MAAgB,EAAEC,MAAwB,EAAEC,KAAa;QAQtGL;QAPgBE;IAA1B,IAAMI,mBAAmB,EAACJ,aAAAA,IAAIK,KAAK,CAAC,oBAAVL,wBAAAA,aAAoB,EAAE,EAAEM,MAAM;IACxD,IAAIL,OAAOK,MAAM,KAAKF,kBAAkB;QACtCb,QAAQgB,KAAK,CAAC,AAAC,GAAmBH,OAAjBD,OAAM,aAAiDF,OAAtCG,kBAAiB,uBAAmC,OAAdH,OAAOK,MAAM;QACrFE,QAAQC,IAAI,CAAC;IACf;IACA,IAAyBZ,QAAAA,IAAAA,UAAI,EAACF,MAAtBG,KAAiBD,MAAjBC,IAAIT,WAAaQ,MAAbR;IACZH,cAAcG;IACdqB,IAAAA,mBAAS,EAACZ,CAAAA,cAAAA,GAAGa,OAAO,CAACX,MAAKY,GAAG,OAAnBd,aAAoB,qBAAGG,UAAkBC;IACnDJ,GAAGC,KAAK;AACV"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/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 type { Ctx } from './types.ts';\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  printRows(db.prepare(sql).all(...params) as Row[], format);\n  db.close();\n}\n"],"names":["printWarnings","runSql","withDb","warnings","w","console","warn","ctx","fn","cfg","open","db","resolveConfig","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","printRows","prepare","all"],"mappings":";;;;;;;;;;;QASgBA;eAAAA;;QAgBAC;eAAAA;;QAZMC;eAAAA;;;oBAXD;wBAEK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKnB,SAASF,cAAcG,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,SAAeF,OAAOK,GAAQ,EAAEC,EAAuE;;YACtGC,KACmBC,OAAjBC,IAAIR;;;;oBADNM,MAAMF,IAAIK,aAAa;oBACJF,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIR,WAAaO,MAAbP;oBACZH,cAAcG;;;;;;;;;oBAEZ;;wBAAMK,GAAGG,IAAIF;;;oBAAb;;;;;;oBAEAE,GAAGE,KAAK;;;;;;;;;;IAEZ;;AAGO,SAASZ,OAAOQ,GAAmB,EAAEK,GAAW,EAAEC,MAAgB,EAAEC,MAAwB,EAAEC,KAAa;QAQtGN;QAPgBG;IAA1B,IAAMI,mBAAmB,EAACJ,aAAAA,IAAIK,KAAK,CAAC,oBAAVL,wBAAAA,aAAoB,EAAE,EAAEM,MAAM;IACxD,IAAIL,OAAOK,MAAM,KAAKF,kBAAkB;QACtCb,QAAQgB,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,IAAIR,WAAaO,MAAbP;IACZH,cAAcG;IACdqB,IAAAA,mBAAS,EAACb,CAAAA,cAAAA,GAAGc,OAAO,CAACX,MAAKY,GAAG,OAAnBf,aAAoB,qBAAGI,UAAkBC;IACnDL,GAAGE,KAAK;AACV"}

package/dist/cjs/commands/status.js

@@ -8,13 +8,22 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+var _configts = require("../config.js");
 var _dbts = require("../db.js");
 var _sharedts = require("./shared.js");
 var status = function status(ctx) {
-    var _open = (0, _dbts.open)(ctx.resolveConfig()), db = _open.db, dbPath = _open.dbPath, warnings = _open.warnings;
+    var cfg = ctx.resolveConfig();
+    var _open = (0, _dbts.open)(cfg), db = _open.db, dbPath = _open.dbPath, warnings = _open.warnings;
     (0, _sharedts.printWarnings)(warnings);
     console.log("db: ".concat(dbPath));
     console.log("docs: ".concat((0, _dbts.docCount)(db)));
+    var features = (0, _configts.featureStates)(cfg);
+    var off = features.off.length > 0 ? " \xb7 off: ".concat(features.off.map(function(name) {
+        return "".concat(name, " (features.").concat(name, ")");
+    }).join(', ')) : '';
+    console.log("features: ".concat(features.on.join(', ')).concat(off));
+    var e = (0, _configts.embedConfig)(cfg);
+    if (e) console.log("embed: ".concat(e.type, " ").concat(e.model));
     var heartbeat = (0, _dbts.getMeta)(db, 'watch_heartbeat');
     if (heartbeat) console.log("watcher: last heartbeat ".concat(Math.round((Date.now() - Date.parse(heartbeat)) / 1000), "s ago"));
     else console.log('watcher: no watcher');

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/status.ts"],"sourcesContent":["import { docCount, getMeta, open } from '../db.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst status: Command = (ctx) => {\n  const { db, dbPath, warnings } = open(ctx.resolveConfig());\n  printWarnings(warnings);\n  console.log(`db: ${dbPath}`);\n  console.log(`docs: ${docCount(db)}`);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  if (heartbeat) console.log(`watcher: last heartbeat ${Math.round((Date.now() - Date.parse(heartbeat)) / 1000)}s ago`);\n  else console.log('watcher: no watcher');\n  db.close();\n};\nexport default status;\n"],"names":["status","ctx","open","resolveConfig","db","dbPath","warnings","printWarnings","console","log","docCount","heartbeat","getMeta","Math","round","Date","now","parse","close"],"mappings":";;;;+BAcA;;;eAAA;;;oBAdwC;wBACV;AAG9B,IAAMA,SAAkB,gBAACC;IACvB,IAAiCC,QAAAA,IAAAA,UAAI,EAACD,IAAIE,aAAa,KAA/CC,KAAyBF,MAAzBE,IAAIC,SAAqBH,MAArBG,QAAQC,WAAaJ,MAAbI;IACpBC,IAAAA,uBAAa,EAACD;IACdE,QAAQC,GAAG,CAAC,AAAC,OAAa,OAAPJ;IACnBG,QAAQC,GAAG,CAAC,AAAC,SAAqB,OAAbC,IAAAA,cAAQ,EAACN;IAC9B,IAAMO,YAAYC,IAAAA,aAAO,EAACR,IAAI;IAC9B,IAAIO,WAAWH,QAAQC,GAAG,CAAC,AAAC,2BAAkF,OAAxDI,KAAKC,KAAK,CAAC,AAACC,CAAAA,KAAKC,GAAG,KAAKD,KAAKE,KAAK,CAACN,UAAS,IAAK,OAAM;SACzGH,QAAQC,GAAG,CAAC;IACjBL,GAAGc,KAAK;AACV;IACA,WAAelB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/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\nconst status: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n  console.log(`db: ${dbPath}`);\n  console.log(`docs: ${docCount(db)}`);\n  const features = featureStates(cfg);\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  const e = embedConfig(cfg);\n  if (e) console.log(`embed: ${e.type} ${e.model}`);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  if (heartbeat) console.log(`watcher: last heartbeat ${Math.round((Date.now() - Date.parse(heartbeat)) / 1000)}s ago`);\n  else console.log('watcher: no watcher');\n  db.close();\n};\nexport default status;\n"],"names":["status","ctx","cfg","resolveConfig","open","db","dbPath","warnings","printWarnings","console","log","docCount","features","featureStates","off","length","map","name","join","on","e","embedConfig","type","model","heartbeat","getMeta","Math","round","Date","now","parse","close"],"mappings":";;;;+BAqBA;;;eAAA;;;wBArB2C;oBACH;wBACV;AAG9B,IAAMA,SAAkB,gBAACC;IACvB,IAAMC,MAAMD,IAAIE,aAAa;IAC7B,IAAiCC,QAAAA,IAAAA,UAAI,EAACF,MAA9BG,KAAyBD,MAAzBC,IAAIC,SAAqBF,MAArBE,QAAQC,WAAaH,MAAbG;IACpBC,IAAAA,uBAAa,EAACD;IACdE,QAAQC,GAAG,CAAC,AAAC,OAAa,OAAPJ;IACnBG,QAAQC,GAAG,CAAC,AAAC,SAAqB,OAAbC,IAAAA,cAAQ,EAACN;IAC9B,IAAMO,WAAWC,IAAAA,uBAAa,EAACX;IAC/B,IAAMY,MAAMF,SAASE,GAAG,CAACC,MAAM,GAAG,IAAI,AAAC,cAA8E,OAApEH,SAASE,GAAG,CAACE,GAAG,CAAC,SAACC;eAAS,AAAC,GAAoBA,OAAlBA,MAAK,eAAkB,OAALA,MAAK;OAAIC,IAAI,CAAC,SAAU;IACzHT,QAAQC,GAAG,CAAC,AAAC,aAAqCI,OAAzBF,SAASO,EAAE,CAACD,IAAI,CAAC,OAAY,OAAJJ;IAClD,IAAMM,IAAIC,IAAAA,qBAAW,EAACnB;IACtB,IAAIkB,GAAGX,QAAQC,GAAG,CAAC,AAAC,UAAmBU,OAAVA,EAAEE,IAAI,EAAC,KAAW,OAARF,EAAEG,KAAK;IAC9C,IAAMC,YAAYC,IAAAA,aAAO,EAACpB,IAAI;IAC9B,IAAImB,WAAWf,QAAQC,GAAG,CAAC,AAAC,2BAAkF,OAAxDgB,KAAKC,KAAK,CAAC,AAACC,CAAAA,KAAKC,GAAG,KAAKD,KAAKE,KAAK,CAACN,UAAS,IAAK,OAAM;SACzGf,QAAQC,GAAG,CAAC;IACjBL,GAAG0B,KAAK;AACV;IACA,WAAe/B"}