sensemaking 0.6.0 → 0.7.1

package/dist/cjs/cli.js

@@ -304,6 +304,9 @@ function cli(argv, name) {
                             if (cfg.migratedFrom !== undefined) {
                                 console.warn("".concat(name, ": migrated ").concat(cfg.configPath, " from config version ").concat(cfg.migratedFrom, " to ").concat(_configts.SUPPORTED_CONFIG_VERSION));
                             }
+                            if (cfg.unknownKeys !== undefined) {
+                                console.warn("".concat(name, ": ").concat(cfg.configPath, " sets ").concat(cfg.unknownKeys.join(', '), ", which this build does not read (no effect); see schema.json for the keys it does"));
+                            }
                             return cfg;
                         },
                         usageError: function usageError(message) {

package/dist/cjs/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS } from './commands/index.ts';\nimport type { Ctx } from './commands/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/commands/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} find \"<terms>\" [--where \"<sql>\"] [--k n] [--semantic]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  let values: Record<string, string | boolean | undefined>;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: {\n        format: { type: 'string', default: 'table' },\n        config: { type: 'string' },\n        where: { type: 'string' },\n        k: { type: 'string' },\n        semantic: { type: 'boolean', default: false },\n        list: { type: 'boolean', default: false },\n        force: { type: 'boolean', default: false },\n        version: { type: 'boolean', default: false, short: 'v' },\n        help: { type: 'boolean', default: false, short: 'h' },\n      },\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  if (values.version) {\n    console.log(`v${packageVersion()}`);\n    return;\n  }\n  if (values.help) {\n    console.log(usage(name));\n    return;\n  }\n\n  const ctx: Ctx = {\n    name,\n    rest: positionals.slice(1),\n    format: values.format === 'json' ? 'json' : 'table',\n    values: values as Ctx['values'],\n    resolveConfig() {\n      const cfg = loadConfig(values.config as string | undefined);\n      if (cfg.migratedFrom !== undefined) {\n        console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\n      }\n      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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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS } from './commands/index.ts';\nimport type { Ctx } from './commands/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/commands/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} find \"<terms>\" [--where \"<sql>\"] [--k n] [--semantic]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  let values: Record<string, string | boolean | undefined>;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: {\n        format: { type: 'string', default: 'table' },\n        config: { type: 'string' },\n        where: { type: 'string' },\n        k: { type: 'string' },\n        semantic: { type: 'boolean', default: false },\n        list: { type: 'boolean', default: false },\n        force: { type: 'boolean', default: false },\n        version: { type: 'boolean', default: false, short: 'v' },\n        help: { type: 'boolean', default: false, short: 'h' },\n      },\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  if (values.version) {\n    console.log(`v${packageVersion()}`);\n    return;\n  }\n  if (values.help) {\n    console.log(usage(name));\n    return;\n  }\n\n  const ctx: Ctx = {\n    name,\n    rest: positionals.slice(1),\n    format: values.format === 'json' ? 'json' : 'table',\n    values: values as Ctx['values'],\n    resolveConfig() {\n      const cfg = loadConfig(values.config as string | undefined);\n      if (cfg.migratedFrom !== undefined) {\n        console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\n      }\n      if (cfg.unknownKeys !== undefined) {\n        console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n      }\n      return cfg;\n    },\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    if (values.list) {\n      for (const queryName of Object.keys(ctx.resolveConfig().queries).sort()) console.log(queryName);\n      return;\n    }\n\n    const [first, ...params] = positionals;\n    if (!first) {\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else (await import('./commands/named.ts')).default(ctx, first, params);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","argv","values","positionals","ctx","queryName","first","params","err","parseArgs","args","options","format","type","default","config","where","k","semantic","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","unknownKeys","join","usageError","Object","keys","queries","sort","COMMANDS"],"mappings":"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"}

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

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

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

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

package/dist/cjs/commands/check.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _dbts = require("../db.js");
+var _outputts = require("../output.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 _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 _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);
+}
+// A saved query that returns zero rows looks identical to a true empty result, so a broken
+// one can sit unnoticed -- one field report had `WHERE flag = 'true'` against a numeric
+// column reading as "nothing tagged yet" for hours. Preparing each query catches syntax and
+// unknown-column errors without executing it; queries that take no parameters are also run
+// for a row count. Parameterised queries are validated but not counted: inventing arguments
+// would report a count for a query nobody ran.
+var check = function check(ctx) {
+    var _cfg_queries;
+    var cfg = ctx.resolveConfig();
+    var _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
+    (0, _sharedts.printWarnings)(warnings);
+    var rows = [];
+    var failed = 0;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries((_cfg_queries = cfg.queries) !== null && _cfg_queries !== void 0 ? _cfg_queries : {})[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], sql = _step_value[1];
+            var _sql_match;
+            var _cfg_checks;
+            var params = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
+            var expectEmpty = ((_cfg_checks = cfg.checks) === null || _cfg_checks === void 0 ? void 0 : _cfg_checks[name]) === 'empty';
+            try {
+                var statement = db.prepare(sql);
+                if (params > 0) {
+                    rows.push({
+                        query: name,
+                        params: params,
+                        rows: '—',
+                        status: 'ok (not run: needs parameters)'
+                    });
+                    continue;
+                }
+                var count = statement.all().length;
+                if (expectEmpty) {
+                    // An invariant query: rows are violations, so 0 is the pass, anything else fails.
+                    if (count > 0) failed++;
+                    rows.push({
+                        query: name,
+                        params: params,
+                        rows: count,
+                        status: count === 0 ? 'ok (empty, as asserted)' : "FAILED: expected empty, returned ".concat(count, " row(s)")
+                    });
+                } else {
+                    rows.push({
+                        query: name,
+                        params: params,
+                        rows: count,
+                        status: count === 0 ? 'ok, but returns 0 rows' : 'ok'
+                    });
+                }
+            } catch (err) {
+                failed++;
+                rows.push({
+                    query: name,
+                    params: params,
+                    rows: '—',
+                    status: "FAILED: ".concat(err.message)
+                });
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    db.close();
+    if (rows.length === 0) {
+        console.log('no saved queries in config');
+        return;
+    }
+    (0, _outputts.printRows)(rows, ctx.format);
+    if (failed > 0) process.exit(1);
+};
+var _default = check;
+/* 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/check.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/check.ts"],"sourcesContent":["import { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// A saved query that returns zero rows looks identical to a true empty result, so a broken\n// one can sit unnoticed -- one field report had `WHERE flag = 'true'` against a numeric\n// column reading as \"nothing tagged yet\" for hours. Preparing each query catches syntax and\n// unknown-column errors without executing it; queries that take no parameters are also run\n// for a row count. Parameterised queries are validated but not counted: inventing arguments\n// would report a count for a query nobody ran.\nconst check: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const rows: Row[] = [];\n  let failed = 0;\n  for (const [name, sql] of Object.entries(cfg.queries ?? {})) {\n    const params = (sql.match(/\\?/g) ?? []).length;\n    const expectEmpty = cfg.checks?.[name] === 'empty';\n    try {\n      const statement = db.prepare(sql);\n      if (params > 0) {\n        rows.push({ query: name, params, rows: '—', status: 'ok (not run: needs parameters)' });\n        continue;\n      }\n      const count = (statement.all() as unknown[]).length;\n      if (expectEmpty) {\n        // An invariant query: rows are violations, so 0 is the pass, anything else fails.\n        if (count > 0) failed++;\n        rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok (empty, as asserted)' : `FAILED: expected empty, returned ${count} row(s)` });\n      } else {\n        rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\n      }\n    } catch (err) {\n      failed++;\n      rows.push({ query: name, params, rows: '—', status: `FAILED: ${(err as Error).message}` });\n    }\n  }\n\n  db.close();\n  if (rows.length === 0) {\n    console.log('no saved queries in config');\n    return;\n  }\n  printRows(rows, ctx.format);\n  if (failed > 0) process.exit(1);\n};\nexport default check;\n"],"names":["check","ctx","cfg","resolveConfig","open","db","warnings","printWarnings","rows","failed","Object","entries","queries","name","sql","params","match","length","expectEmpty","checks","statement","prepare","push","query","status","count","all","err","message","close","console","log","printRows","format","process","exit"],"mappings":";;;;+BAkDA;;;eAAA;;;oBAlDqB;wBAEK;wBACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,2FAA2F;AAC3F,wFAAwF;AACxF,4FAA4F;AAC5F,2FAA2F;AAC3F,4FAA4F;AAC5F,+CAA+C;AAC/C,IAAMA,QAAiB,eAACC;QAOmBC;IANzC,IAAMA,MAAMD,IAAIE,aAAa;IAC7B,IAAyBC,QAAAA,IAAAA,UAAI,EAACF,MAAtBG,KAAiBD,MAAjBC,IAAIC,WAAaF,MAAbE;IACZC,IAAAA,uBAAa,EAACD;IAEd,IAAME,OAAc,EAAE;IACtB,IAAIC,SAAS;QACR,kCAAA,2BAAA;;QAAL,QAAK,YAAqBC,OAAOC,OAAO,EAACT,eAAAA,IAAIU,OAAO,cAAXV,0BAAAA,eAAe,CAAC,uBAApD,SAAA,6BAAA,QAAA,yBAAA,iCAAwD;YAAxD,mCAAA,iBAAOW,uBAAMC;gBACAA;gBACIZ;YADpB,IAAMa,SAAS,EAACD,aAAAA,IAAIE,KAAK,CAAC,oBAAVF,wBAAAA,aAAoB,EAAE,EAAEG,MAAM;YAC9C,IAAMC,cAAchB,EAAAA,cAAAA,IAAIiB,MAAM,cAAVjB,kCAAAA,WAAY,CAACW,KAAK,MAAK;YAC3C,IAAI;gBACF,IAAMO,YAAYf,GAAGgB,OAAO,CAACP;gBAC7B,IAAIC,SAAS,GAAG;oBACdP,KAAKc,IAAI,CAAC;wBAAEC,OAAOV;wBAAME,QAAAA;wBAAQP,MAAM;wBAAKgB,QAAQ;oBAAiC;oBACrF;gBACF;gBACA,IAAMC,QAAQ,AAACL,UAAUM,GAAG,GAAiBT,MAAM;gBACnD,IAAIC,aAAa;oBACf,kFAAkF;oBAClF,IAAIO,QAAQ,GAAGhB;oBACfD,KAAKc,IAAI,CAAC;wBAAEC,OAAOV;wBAAME,QAAAA;wBAAQP,MAAMiB;wBAAOD,QAAQC,UAAU,IAAI,4BAA4B,AAAC,oCAAyC,OAANA,OAAM;oBAAS;gBACrJ,OAAO;oBACLjB,KAAKc,IAAI,CAAC;wBAAEC,OAAOV;wBAAME,QAAAA;wBAAQP,MAAMiB;wBAAOD,QAAQC,UAAU,IAAI,2BAA2B;oBAAK;gBACtG;YACF,EAAE,OAAOE,KAAK;gBACZlB;gBACAD,KAAKc,IAAI,CAAC;oBAAEC,OAAOV;oBAAME,QAAAA;oBAAQP,MAAM;oBAAKgB,QAAQ,AAAC,WAAiC,OAAvB,AAACG,IAAcC,OAAO;gBAAG;YAC1F;QACF;;QArBK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAuBLvB,GAAGwB,KAAK;IACR,IAAIrB,KAAKS,MAAM,KAAK,GAAG;QACrBa,QAAQC,GAAG,CAAC;QACZ;IACF;IACAC,IAAAA,mBAAS,EAACxB,MAAMP,IAAIgC,MAAM;IAC1B,IAAIxB,SAAS,GAAGyB,QAAQC,IAAI,CAAC;AAC/B;IACA,WAAenC"}

package/dist/cjs/commands/index.js

@@ -65,6 +65,11 @@ var COMMANDS = {
             return /*#__PURE__*/ _interop_require_wildcard(require("./status.js"));
         });
     },
+    check: function check() {
+        return Promise.resolve().then(function() {
+            return /*#__PURE__*/ _interop_require_wildcard(require("./check.js"));
+        });
+    },
     rebuild: function rebuild() {
         return Promise.resolve().then(function() {
             return /*#__PURE__*/ _interop_require_wildcard(require("./rebuild.js"));

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/index.ts"],"sourcesContent":["import type { Command } from './types.ts';\n\n// Lazy registry: a command's imports load only when it runs, so a heavy dependency in one\n// command never taxes the others (or --version/--help). These names are reserved: a named\n// query in config can never shadow them.\nexport const COMMANDS: Record<string, () => Promise<{ default: Command }>> = {\n  init: () => import('./init.ts'),\n  watch: () => import('./watch.ts'),\n  status: () => import('./status.ts'),\n  rebuild: () => import('./rebuild.ts'),\n  query: () => import('./query.ts'),\n  find: () => import('./find.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["COMMANDS","init","watch","status","rebuild","query","find","map","peek"],"mappings":";;;;+BAKaA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAMA,WAAgE;IAC3EC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,SAAS,SAATA;eAAe;2DAAA,QAAO;;;IACtBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;AACrB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/index.ts"],"sourcesContent":["import type { Command } from './types.ts';\n\n// Lazy registry: a command's imports load only when it runs, so a heavy dependency in one\n// command never taxes the others (or --version/--help). These names are reserved: a named\n// query in config can never shadow them.\nexport const COMMANDS: Record<string, () => Promise<{ default: Command }>> = {\n  init: () => import('./init.ts'),\n  watch: () => import('./watch.ts'),\n  status: () => import('./status.ts'),\n  check: () => import('./check.ts'),\n  rebuild: () => import('./rebuild.ts'),\n  query: () => import('./query.ts'),\n  find: () => import('./find.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["COMMANDS","init","watch","status","check","rebuild","query","find","map","peek"],"mappings":";;;;+BAKaA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAMA,WAAgE;IAC3EC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,SAAS,SAATA;eAAe;2DAAA,QAAO;;;IACtBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;AACrB"}

package/dist/cjs/commands/shared.js

@@ -21,6 +21,7 @@ _export(exports, {
 });
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
+var _searcherrorts = require("../search-error.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];
@@ -237,7 +238,6 @@ function withDb(ctx, fn) {
     })();
 }
 function runSql(cfg, sql, params, format, label) {
-    var _db_prepare;
     var _sql_match;
     var placeholderCount = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
     if (params.length !== placeholderCount) {
@@ -246,7 +246,19 @@ function runSql(cfg, sql, params, format, label) {
     }
     var _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
     printWarnings(warnings);
-    (0, _outputts.printRows)((_db_prepare = db.prepare(sql)).all.apply(_db_prepare, _to_consumable_array(params)), format);
+    var rows;
+    try {
+        var _db_prepare;
+        rows = (_db_prepare = db.prepare(sql)).all.apply(_db_prepare, _to_consumable_array(params));
+    } catch (err) {
+        db.close();
+        // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5
+        // punctuation trap applies -- the bound parameters are the search terms there. SQL
+        // without MATCH gets its error verbatim; search advice on a plain typo would mislead.
+        if (/\bMATCH\b/i.test(sql)) throw (0, _searcherrorts.searchError)(err, params.join(' '));
+        throw err;
+    }
+    (0, _outputts.printRows)(rows, format);
     db.close();
 }
 /* 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/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 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"}
+{"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 { searchError } from '../search-error.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  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":["printWarnings","runSql","withDb","warnings","w","console","warn","ctx","fn","cfg","open","db","resolveConfig","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","rows","prepare","all","err","test","searchError","join","printRows"],"mappings":";;;;;;;;;;;QAUgBA;eAAAA;;QAgBAC;eAAAA;;QAZMC;eAAAA;;;oBAZD;wBAEK;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKrB,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;QACtFH;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;IACd,IAAIqB;IACJ,IAAI;YACKb;QAAPa,OAAOb,CAAAA,cAAAA,GAAGc,OAAO,CAACX,MAAKY,GAAG,OAAnBf,aAAoB,qBAAGI;IAChC,EAAE,OAAOY,KAAK;QACZhB,GAAGE,KAAK;QACR,gFAAgF;QAChF,mFAAmF;QACnF,sFAAsF;QACtF,IAAI,aAAae,IAAI,CAACd,MAAM,MAAMe,IAAAA,0BAAW,EAACF,KAAcZ,OAAOe,IAAI,CAAC;QACxE,MAAMH;IACR;IACAI,IAAAA,mBAAS,EAACP,MAAMR;IAChBL,GAAGE,KAAK;AACV"}

package/dist/cjs/commands/status.js

@@ -11,22 +11,80 @@ Object.defineProperty(exports, "default", {
 var _configts = require("../config.js");
 var _dbts = require("../db.js");
 var _sharedts = require("./shared.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+// Vectors are computed on the first semantic query, not at reconcile, so a tree can be
+// embed-enabled with nothing embedded yet -- reported here because a fast `rebuild` on an
+// embed tree otherwise reads as "the feature isn't on".
+function vectorState(db) {
+    try {
+        var row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get();
+        return row;
+    } catch (unused) {
+        return null;
+    }
+}
 var status = function status(ctx) {
+    var _ref;
+    var _cfg_defaults_find, _cfg_defaults;
     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 vectors = e ? vectorState(db) : null;
     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');
+    var result = {
+        db: dbPath,
+        docs: (0, _dbts.docCount)(db),
+        features: features.on,
+        featuresOff: features.off,
+        embed: e ? _object_spread({
+            type: e.type,
+            model: e.model
+        }, vectors !== null && vectors !== void 0 ? vectors : {}) : null,
+        findDefaultWhere: (_ref = (_cfg_defaults = cfg.defaults) === null || _cfg_defaults === void 0 ? void 0 : (_cfg_defaults_find = _cfg_defaults.find) === null || _cfg_defaults_find === void 0 ? void 0 : _cfg_defaults_find.where) !== null && _ref !== void 0 ? _ref : null,
+        watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null
+    };
+    if (ctx.format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+    } else {
+        console.log("db: ".concat(result.db));
+        console.log("docs: ".concat(result.docs));
+        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));
+        if (e) console.log("embed: ".concat(e.type, " ").concat(e.model).concat(vectors ? " (vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending — embedded on first --semantic query)") : ''));
+        if (result.findDefaultWhere) console.log("find default scope: ".concat(result.findDefaultWhere, " (--where replaces it)"));
+        console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : "watcher: last heartbeat ".concat(result.watcherHeartbeatSecondsAgo, "s ago"));
+    }
     db.close();
 };
 var _default = status;

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

@@ -1 +1 @@
-{"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"}
+{"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\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can be\n// embed-enabled with nothing embedded yet -- reported here because a fast `rebuild` on an\n// embed tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    findDefaultWhere: cfg.defaults?.find?.where ?? null,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n  };\n\n  if (ctx.format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    const off = features.off.length > 0 ? ` · off: ${features.off.map((name) => `${name} (features.${name})`).join(', ')}` : '';\n    console.log(`features: ${features.on.join(', ')}${off}`);\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on first --semantic query)` : ''}`);\n    if (result.findDefaultWhere) console.log(`find default scope: ${result.findDefaultWhere} (--where replaces it)`);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","cfg","resolveConfig","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","heartbeat","getMeta","result","docs","docCount","on","featuresOff","off","embed","type","model","findDefaultWhere","defaults","find","where","watcherHeartbeatSecondsAgo","Math","round","Date","now","parse","format","console","log","JSON","stringify","length","map","name","join","embedded","pending","close"],"mappings":";;;;+BAiDA;;;eAAA;;;wBAjD2C;oBACH;wBACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,uFAAuF;AACvF,0FAA0F;AAC1F,wDAAwD;AACxD,SAASA,YAAYC,EAAiC;IACpD,IAAI;QACF,IAAMC,MAAMD,GAAGE,OAAO,CAAC,yFAAyFC,GAAG;QACnH,OAAOF;IACT,EAAE,eAAM;QACN,OAAO;IACT;AACF;AAEA,IAAMG,SAAkB,gBAACC;;QAeHC,oBAAAA;IAdpB,IAAMA,MAAMD,IAAIE,aAAa;IAC7B,IAAiCC,QAAAA,IAAAA,UAAI,EAACF,MAA9BN,KAAyBQ,MAAzBR,IAAIS,SAAqBD,MAArBC,QAAQC,WAAaF,MAAbE;IACpBC,IAAAA,uBAAa,EAACD;IAEd,IAAME,WAAWC,IAAAA,uBAAa,EAACP;IAC/B,IAAMQ,IAAIC,IAAAA,qBAAW,EAACT;IACtB,IAAMU,UAAUF,IAAIf,YAAYC,MAAM;IACtC,IAAMiB,YAAYC,IAAAA,aAAO,EAAClB,IAAI;IAC9B,IAAMmB,SAAS;QACbnB,IAAIS;QACJW,MAAMC,IAAAA,cAAQ,EAACrB;QACfY,UAAUA,SAASU,EAAE;QACrBC,aAAaX,SAASY,GAAG;QACzBC,OAAOX,IAAI;YAAEY,MAAMZ,EAAEY,IAAI;YAAEC,OAAOb,EAAEa,KAAK;WAAMX,oBAAAA,qBAAAA,UAAW,CAAC,KAAO;QAClEY,gBAAgB,WAAEtB,gBAAAA,IAAIuB,QAAQ,cAAZvB,qCAAAA,qBAAAA,cAAcwB,IAAI,cAAlBxB,yCAAAA,mBAAoByB,KAAK,uCAAI;QAC/CC,4BAA4Bf,YAAYgB,KAAKC,KAAK,CAAC,AAACC,CAAAA,KAAKC,GAAG,KAAKD,KAAKE,KAAK,CAACpB,UAAS,IAAK,QAAQ;IACpG;IAEA,IAAIZ,IAAIiC,MAAM,KAAK,QAAQ;QACzBC,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACvB,QAAQ,MAAM;IAC3C,OAAO;QACLoB,QAAQC,GAAG,CAAC,AAAC,OAAgB,OAAVrB,OAAOnB,EAAE;QAC5BuC,QAAQC,GAAG,CAAC,AAAC,SAAoB,OAAZrB,OAAOC,IAAI;QAChC,IAAMI,MAAMZ,SAASY,GAAG,CAACmB,MAAM,GAAG,IAAI,AAAC,cAA8E,OAApE/B,SAASY,GAAG,CAACoB,GAAG,CAAC,SAACC;mBAAS,AAAC,GAAoBA,OAAlBA,MAAK,eAAkB,OAALA,MAAK;WAAIC,IAAI,CAAC,SAAU;QACzHP,QAAQC,GAAG,CAAC,AAAC,aAAqChB,OAAzBZ,SAASU,EAAE,CAACwB,IAAI,CAAC,OAAY,OAAJtB;QAClD,IAAIV,GAAGyB,QAAQC,GAAG,CAAC,AAAC,UAAmB1B,OAAVA,EAAEY,IAAI,EAAC,KAAaV,OAAVF,EAAEa,KAAK,EAA8H,OAA3HX,UAAU,AAAC,cAA2CA,OAA9BA,QAAQ+B,QAAQ,EAAC,eAA6B,OAAhB/B,QAAQgC,OAAO,EAAC,oDAAkD;QACzK,IAAI7B,OAAOS,gBAAgB,EAAEW,QAAQC,GAAG,CAAC,AAAC,uBAA8C,OAAxBrB,OAAOS,gBAAgB,EAAC;QACxFW,QAAQC,GAAG,CAACrB,OAAOa,0BAA0B,KAAK,OAAO,wBAAwB,AAAC,2BAA4D,OAAlCb,OAAOa,0BAA0B,EAAC;IAChJ;IACAhC,GAAGiD,KAAK;AACV;IACA,WAAe7C"}

package/dist/cjs/config.d.cts

@@ -22,11 +22,18 @@ export interface Config {
         rank?: boolean;
         embed?: boolean | EmbedConfig;
     };
+    defaults?: {
+        find?: {
+            where?: string;
+        };
+    };
+    checks?: Record<string, 'empty'>;
     queries: Record<string, string>;
 }
 export interface ResolvedConfig extends Config {
     baseDir: string;
     configPath: string | null;
+    unknownKeys?: string[];
     migratedFrom?: number;
 }
 export declare function featureEnabled(cfg: Config, name: FeatureName): boolean;

package/dist/cjs/config.d.ts

@@ -22,11 +22,18 @@ export interface Config {
         rank?: boolean;
         embed?: boolean | EmbedConfig;
     };
+    defaults?: {
+        find?: {
+            where?: string;
+        };
+    };
+    checks?: Record<string, 'empty'>;
     queries: Record<string, string>;
 }
 export interface ResolvedConfig extends Config {
     baseDir: string;
     configPath: string | null;
+    unknownKeys?: string[];
     migratedFrom?: number;
 }
 export declare function featureEnabled(cfg: Config, name: FeatureName): boolean;

package/dist/cjs/config.js

@@ -60,6 +60,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -73,6 +76,9 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -100,6 +106,9 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread 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] : {};
@@ -142,6 +151,9 @@ function _object_spread_props(target, source) {
 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 _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;
@@ -282,8 +294,51 @@ function findConfigPath(startDir) {
 // Shape check for hand-edited files: a typo'd config fails with a named error, not a
 // TypeError from whatever code touched the missing field first. `queries` is optional
 // on disk (absent = none); `scan.include` has no usable default.
+// Keys each block actually reads. A key outside these sets is accepted and ignored, which
+// looks identical to working -- one field report set `scan.exclude`, saw no change in doc
+// count and no warning, and reasonably concluded the filter had applied. Reported as a
+// warning rather than an error so a config carrying an unknown key still runs.
+var KNOWN_KEYS = new Set([
+    '$schema',
+    'version',
+    'scan',
+    'features',
+    'defaults',
+    'checks',
+    'queries'
+]);
+var KNOWN_SCAN_KEYS = new Set([
+    'include'
+]);
+function unknownConfigKeys(cfg) {
+    var unknown = Object.keys(cfg).filter(function(k) {
+        return !KNOWN_KEYS.has(k);
+    }).map(function(k) {
+        return k;
+    });
+    var scan = cfg.scan;
+    if (scan && (typeof scan === "undefined" ? "undefined" : _type_of(scan)) === 'object' && !Array.isArray(scan)) {
+        var _unknown;
+        (_unknown = unknown).push.apply(_unknown, _to_consumable_array(Object.keys(scan).filter(function(k) {
+            return !KNOWN_SCAN_KEYS.has(k);
+        }).map(function(k) {
+            return "scan.".concat(k);
+        })));
+    }
+    var features = cfg.features;
+    if (features && (typeof features === "undefined" ? "undefined" : _type_of(features)) === 'object' && !Array.isArray(features)) {
+        var _unknown1;
+        (_unknown1 = unknown).push.apply(_unknown1, _to_consumable_array(Object.keys(features).filter(function(k) {
+            return !FEATURE_NAMES.includes(k);
+        }).map(function(k) {
+            return "features.".concat(k);
+        })));
+    }
+    return unknown;
+}
 function validateConfig(parsed, configPath) {
     var _cfg_features;
+    var _defaults_find;
     if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) !== 'object' || parsed === null || Array.isArray(parsed)) {
         throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ": config must be a JSON object"));
     }
@@ -300,13 +355,47 @@ function validateConfig(parsed, configPath) {
     })) {
         throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ": queries must be an object of name -> SQL string"));
     }
+    var defaults = cfg.defaults;
+    if (defaults !== undefined && ((typeof defaults === "undefined" ? "undefined" : _type_of(defaults)) !== 'object' || defaults === null || Array.isArray(defaults) || defaults.find !== undefined && typeof ((_defaults_find = defaults.find) === null || _defaults_find === void 0 ? void 0 : _defaults_find.where) !== 'string')) {
+        throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ": defaults.find.where must be a SQL condition string"));
+    }
+    var checks = cfg.checks;
+    if (checks !== undefined) {
+        var _cfg_queries;
+        if ((typeof checks === "undefined" ? "undefined" : _type_of(checks)) !== 'object' || checks === null || Array.isArray(checks) || !Object.values(checks).every(function(v) {
+            return v === 'empty';
+        })) {
+            throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ': checks must be an object of query name -> "empty"'));
+        }
+        var queries = (_cfg_queries = cfg.queries) !== null && _cfg_queries !== void 0 ? _cfg_queries : {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.keys(checks)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var name = _step.value;
+                if (queries[name] === undefined) throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ': checks names "').concat(name, '", which is not a saved query'));
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
     if (cfg.features !== undefined && (_type_of(cfg.features) !== 'object' || cfg.features === null || Array.isArray(cfg.features))) {
         throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ": features must be an object of name -> boolean"));
     }
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
     try {
         var _loop = function() {
-            var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], value = _step_value[1];
+            var _step_value = _sliced_to_array(_step1.value, 2), name = _step_value[0], value = _step_value[1];
             if (typeof value === 'boolean') return "continue";
             // embed alone takes an object form: { model?, type?: static|api, url?, key? }.
             var embed = value;
@@ -321,18 +410,18 @@ function validateConfig(parsed, configPath) {
                 throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ": features.").concat(name, " must be a boolean").concat(name === 'embed' ? ' or { model?, type?: "static"|"api", url?, key? }' : ''));
             }
         };
-        for(var _iterator = Object.entries((_cfg_features = cfg.features) !== null && _cfg_features !== void 0 ? _cfg_features : {})[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        for(var _iterator1 = Object.entries((_cfg_features = cfg.features) !== null && _cfg_features !== void 0 ? _cfg_features : {})[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true)_loop();
     } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
+        _didIteratorError1 = true;
+        _iteratorError1 = err;
     } finally{
         try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
+            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                _iterator1.return();
             }
         } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
+            if (_didIteratorError1) {
+                throw _iteratorError1;
             }
         }
     }
@@ -366,10 +455,12 @@ function loadConfig(explicitPath) {
         migratedFrom = result.from;
         (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(cfg, null, 2), "\n"));
     }
+    var unknownKeys = unknownConfigKeys(cfg);
     return _object_spread_props(_object_spread({}, cfg), {
         baseDir: (0, _nodepath.dirname)(configPath),
         configPath: configPath,
-        migratedFrom: migratedFrom
+        migratedFrom: migratedFrom,
+        unknownKeys: unknownKeys.length > 0 ? unknownKeys : undefined
     });
 }
 /* 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; }