sensemaking 0.9.1 → 0.9.3

package/README.md

@@ -21,6 +21,9 @@ npm install -g sensemaking
 cd your-notes && sense init
 ```
 
+Needs Node 22.16 or newer: that is the first release whose built-in SQLite carries FTS5, which
+`sense search` indexes prose with.
+
 ```bash
 sense map                                        # orient: fields, hub notes, recent changes
 sense search "revenue OR earnings" --k 10        # locate: words + links + meaning, one ranked list
@@ -78,7 +81,7 @@ and vector similarity — fused into one list. `via` labels each row's evidence
 `lines` points at the section that earned the row — a direct read range. Rows that only
 vectors produced are the "these words aren't in the tree, this is what's near in meaning"
 signal. `--preset` picks a named settings bundle from the config, `--lexical` skips vectors
-for one command, `--where` filters on frontmatter. `--format json` on any command returns
+for one command, `--where` filters on frontmatter. `--format json` on any reporting command returns
 structured output; `--version` and `--help` do what they say.
 
 ## Config
@@ -182,7 +185,9 @@ features, frontmatter conventions, and note size are decisions with consequences
 Dependencies: [yaml](https://github.com/eemeli/yaml),
 [remove-markdown](https://github.com/zuchka/remove-markdown),
 [fast-glob](https://github.com/mrmlnc/fast-glob),
-[@huggingface/tokenizers](https://github.com/huggingface/tokenizers.js) (pure JS), and Node's
+[@huggingface/tokenizers](https://github.com/huggingface/tokenizers.js) (pure JS),
+[getopts-compat](https://github.com/kmalakoff/getopts) and
+[exit-compat](https://github.com/kmalakoff/exit-compat) for the CLI, and Node's
 built-in SQLite. No native builds.
 
 ## License

package/bin/cli.js

@@ -2,4 +2,8 @@
 
 // biome-ignore lint/security/noGlobalEval: dual esm and cjs
 if (typeof require === 'undefined') eval("import('../dist/esm/cli.js').then((cli) => cli.default(process.argv.slice(2), 'sense')).catch((err) => { console.error(err); process.exit(-1); });");
-else require('../dist/cjs/cli.js')(process.argv.slice(2), 'sense');
+else
+  require('../dist/cjs/cli.js')(process.argv.slice(2), 'sense').catch((err) => {
+    console.error(err);
+    process.exit(-1);
+  });

package/dist/cjs/cli/check.js

@@ -11,6 +11,8 @@ Object.defineProperty(exports, "default", {
 var _commandsts = require("../commands.js");
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
+var _exitts = require("./exit.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -49,6 +51,19 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -76,6 +91,21 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
@@ -202,11 +232,13 @@ function _ts_generator(thisArg, body) {
 // result being empty is good or bad is the reader's judgment -- there is no assertion path.
 var check = function check(ctx) {
     return _async_to_generator(function() {
-        var _cfg_queries, cfg, _open, db, warnings, rows, failed, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, entry, _sql_match, count, err, sql, params, statement, count1, err1;
+        var _cfg_queries, values, format, cfg, _open, db, warnings, rows, failed, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, entry, _sql_match, count, err, sql, params, statement, count1, err1;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    cfg = ctx.resolveConfig();
+                    values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.check), _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)).values;
+                    format = (0, _sharedts.formatOf)(values);
+                    cfg = ctx.resolveConfig(values.config);
                     _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
                     (0, _sharedts.printWarnings)(warnings);
                     rows = [];
@@ -354,8 +386,8 @@ var check = function check(ctx) {
                             2
                         ];
                     }
-                    (0, _outputts.printRows)(rows, ctx.format);
-                    if (failed > 0) process.exit(1);
+                    (0, _outputts.printRows)(rows, format);
+                    if (failed > 0) throw new _exitts.ExitError(1);
                     return [
                         2
                     ];

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/check.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { 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. Saved searches run lexically with k=1 -- that\n// validates the `where` fragment, the FTS5 terms, and the `preset` name (resolveSearch throws\n// on an unknown one, the same breakage class prepare() catches for SQL strings) -- but never\n// semantically (a semantic pass costs model time and, on api trees, network). Whether a\n// result being empty is good or bad is the reader's judgment -- there is no assertion path.\nconst check: Command = async (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, entry] of Object.entries(cfg.queries ?? {})) {\n    if (typeof entry === 'object' && entry !== null && 'search' in entry) {\n      try {\n        const count = (await search(db, cfg, entry.search, { k: 1, where: entry.where, preset: entry.preset, include: entry.include, semantic: false })).length;\n        rows.push({ query: name, params: '—', rows: '—', status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : 'ok (probe run with k=1)' });\n      } catch (err) {\n        failed++;\n        rows.push({ query: name, params: '—', rows: '—', status: `FAILED: ${(err as Error).message}` });\n      }\n      continue;\n    }\n    const sql = typeof entry === 'string' ? entry : entry.sql;\n    const params = (sql.match(/\\?/g) ?? []).length;\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      rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\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","open","db","warnings","rows","failed","name","entry","sql","count","err","params","statement","resolveConfig","printWarnings","Object","entries","queries","search","k","where","preset","include","semantic","length","push","query","status","message","match","prepare","all","close","console","log","printRows","format","process","exit"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/check.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { ExitError } from './exit.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, 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. Saved searches run lexically with k=1 -- that\n// validates the `where` fragment, the FTS5 terms, and the `preset` name (resolveSearch throws\n// on an unknown one, the same breakage class prepare() catches for SQL strings) -- but never\n// semantically (a semantic pass costs model time and, on api trees, network). Whether a\n// result being empty is good or bad is the reader's judgment -- there is no assertion path.\nconst check: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.check}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const rows: Row[] = [];\n  let failed = 0;\n  for (const [name, entry] of Object.entries(cfg.queries ?? {})) {\n    if (typeof entry === 'object' && entry !== null && 'search' in entry) {\n      try {\n        const count = (await search(db, cfg, entry.search, { k: 1, where: entry.where, preset: entry.preset, include: entry.include, semantic: false })).length;\n        rows.push({ query: name, params: '—', rows: '—', status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : 'ok (probe run with k=1)' });\n      } catch (err) {\n        failed++;\n        rows.push({ query: name, params: '—', rows: '—', status: `FAILED: ${(err as Error).message}` });\n      }\n      continue;\n    }\n    const sql = typeof entry === 'string' ? entry : entry.sql;\n    const params = (sql.match(/\\?/g) ?? []).length;\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      rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\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, format);\n  if (failed > 0) throw new ExitError(1);\n};\nexport default check;\n"],"names":["check","ctx","cfg","values","format","open","db","warnings","rows","failed","name","entry","sql","count","err","params","statement","parse","argv","USAGE","FORMAT","CONFIG","formatOf","resolveConfig","config","printWarnings","Object","entries","queries","search","k","where","preset","include","semantic","length","push","query","status","message","match","prepare","all","close","console","log","printRows","ExitError"],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+export declare class ExitError extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+export declare function usageError(message: string, usage?: string): never;

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

@@ -0,0 +1,5 @@
+export declare class ExitError extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+export declare function usageError(message: string, usage?: string): never;

package/dist/cjs/cli/exit.js

@@ -0,0 +1,147 @@
+// Commands never end the process themselves: they throw this, and cli.ts -- the one place
+// that owns the exit -- drains stdio through exit-compat and returns. Neither alternative
+// works here: a direct process.exit() races a pending write, and a bare return would let a
+// command body run on after --help had already printed its usage.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get ExitError () {
+        return ExitError;
+    },
+    get usageError () {
+        return usageError;
+    }
+});
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var ExitError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(ExitError, Error1);
+    function ExitError(code) {
+        _class_call_check(this, ExitError);
+        var _this;
+        _this = _call_super(this, ExitError, [
+            "exit ".concat(code)
+        ]);
+        _this.code = code;
+        return _this;
+    }
+    return ExitError;
+}(_wrap_native_super(Error));
+function usageError(message, usage) {
+    console.error(message);
+    if (usage !== undefined) console.error(usage);
+    throw new ExitError(2);
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/exit.ts"],"sourcesContent":["// Commands never end the process themselves: they throw this, and cli.ts -- the one place\n// that owns the exit -- drains stdio through exit-compat and returns. Neither alternative\n// works here: a direct process.exit() races a pending write, and a bare return would let a\n// command body run on after --help had already printed its usage.\nexport class ExitError extends Error {\n  readonly code: number;\n  constructor(code: number) {\n    super(`exit ${code}`);\n    this.code = code;\n  }\n}\n\nexport function usageError(message: string, usage?: string): never {\n  console.error(message);\n  if (usage !== undefined) console.error(usage);\n  throw new ExitError(2);\n}\n"],"names":["ExitError","usageError","code","Error","message","usage","console","error","undefined"],"mappings":"AAAA,0FAA0F;AAC1F,0FAA0F;AAC1F,2FAA2F;AAC3F,kEAAkE;;;;;;;;;;;;QACrDA;eAAAA;;QAQGC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AART,IAAA,AAAMD,0BAAN;;cAAMA;aAAAA,UAECE,IAAY;gCAFbF;;gBAGT,kBAHSA;YAGF,QAAY,OAALE;;QACd,MAAKA,IAAI,GAAGA;;;WAJHF;qBAAkBG;AAQxB,SAASF,WAAWG,OAAe,EAAEC,KAAc;IACxDC,QAAQC,KAAK,CAACH;IACd,IAAIC,UAAUG,WAAWF,QAAQC,KAAK,CAACF;IACvC,MAAM,IAAIL,UAAU;AACtB"}

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

@@ -1,4 +1,15 @@
 import type { Command } from './types.js';
+export declare const USAGE: {
+    readonly init: "init";
+    readonly watch: "watch [--force] [--config path]";
+    readonly status: "status [--format table|json] [--config path]";
+    readonly check: "check [--format table|json] [--config path]";
+    readonly rebuild: "rebuild [--config path]";
+    readonly query: "query \"<sql>\" [params...] [--format table|json] [--config path]";
+    readonly search: "search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical] [--format table|json] [--config path]";
+    readonly map: "map [--format table|json] [--config path]";
+    readonly peek: "peek <path> [--format table|json] [--config path]";
+};
 export declare const COMMANDS: Record<string, () => Promise<{
     default: Command;
 }>>;

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

@@ -1,4 +1,15 @@
 import type { Command } from './types.js';
+export declare const USAGE: {
+    readonly init: "init";
+    readonly watch: "watch [--force] [--config path]";
+    readonly status: "status [--format table|json] [--config path]";
+    readonly check: "check [--format table|json] [--config path]";
+    readonly rebuild: "rebuild [--config path]";
+    readonly query: "query \"<sql>\" [params...] [--format table|json] [--config path]";
+    readonly search: "search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical] [--format table|json] [--config path]";
+    readonly map: "map [--format table|json] [--config path]";
+    readonly peek: "peek <path> [--format table|json] [--config path]";
+};
 export declare const COMMANDS: Record<string, () => Promise<{
     default: Command;
 }>>;

package/dist/cjs/cli/index.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "COMMANDS", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get COMMANDS () {
         return COMMANDS;
+    },
+    get USAGE () {
+        return USAGE;
     }
 });
 function _getRequireWildcardCache(nodeInterop) {
@@ -49,6 +57,17 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
+var USAGE = {
+    init: 'init',
+    watch: 'watch [--force] [--config path]',
+    status: 'status [--format table|json] [--config path]',
+    check: 'check [--format table|json] [--config path]',
+    rebuild: 'rebuild [--config path]',
+    query: 'query "<sql>" [params...] [--format table|json] [--config path]',
+    search: 'search "<terms>" [--preset name] [--include glob ...] [--where "<sql>"] [--k n] [--lexical] [--format table|json] [--config path]',
+    map: 'map [--format table|json] [--config path]',
+    peek: 'peek <path> [--format table|json] [--config path]'
+};
 var COMMANDS = {
     init: function init() {
         return Promise.resolve().then(function() {

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/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  search: () => import('./search.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","search","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,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;AACrB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/index.ts"],"sourcesContent":["import type { Command } from './types.ts';\n\n// Each command's usage line, minus the leading \"usage: <name> \" -- shared by cli.ts's\n// top-level usage() and the command's own parse() error/--help output, so there is one\n// copy of each line, not two that can drift.\nexport const USAGE = {\n  init: 'init',\n  watch: 'watch [--force] [--config path]',\n  status: 'status [--format table|json] [--config path]',\n  check: 'check [--format table|json] [--config path]',\n  rebuild: 'rebuild [--config path]',\n  query: 'query \"<sql>\" [params...] [--format table|json] [--config path]',\n  search: 'search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical] [--format table|json] [--config path]',\n  map: 'map [--format table|json] [--config path]',\n  peek: 'peek <path> [--format table|json] [--config path]',\n} as const;\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  search: () => import('./search.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["COMMANDS","USAGE","init","watch","status","check","rebuild","query","search","map","peek"],"mappings":";;;;;;;;;;;QAoBaA;eAAAA;;QAfAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,QAAQ;IACRC,OAAO;IACPC,SAAS;IACTC,OAAO;IACPC,QAAQ;IACRC,KAAK;IACLC,MAAM;AACR;AAKO,IAAMV,WAAgE;IAC3EE,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,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;AACrB"}

package/dist/cjs/cli/init.js

@@ -9,7 +9,10 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _configts = require("../config.js");
+var _indexts = require("./index.js");
+var _sharedts = require("./shared.js");
 var init = function init(ctx) {
+    (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.init), {});
     var configPath = (0, _configts.initConfig)(process.cwd());
     console.log("created ".concat(configPath));
     console.log("query away: ".concat(ctx.name, ' query "SELECT path FROM frontmatter LIMIT 10"'));

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/init.ts"],"sourcesContent":["import { initConfig } from '../config.ts';\nimport type { Command } from './types.ts';\n\nconst init: Command = (ctx) => {\n  const configPath = initConfig(process.cwd());\n  console.log(`created ${configPath}`);\n  console.log(`query away: ${ctx.name} query \"SELECT path FROM frontmatter LIMIT 10\"`);\n  // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not\n  // in this output; name both places that hold them, since an agent may have neither.\n  console.log('features and tree design: the sense-setup skill, or schema.json');\n};\nexport default init;\n"],"names":["init","ctx","configPath","initConfig","process","cwd","console","log","name"],"mappings":";;;;+BAWA;;;eAAA;;;wBAX2B;AAG3B,IAAMA,OAAgB,cAACC;IACrB,IAAMC,aAAaC,IAAAA,oBAAU,EAACC,QAAQC,GAAG;IACzCC,QAAQC,GAAG,CAAC,AAAC,WAAqB,OAAXL;IACvBI,QAAQC,GAAG,CAAC,AAAC,eAAuB,OAATN,IAAIO,IAAI,EAAC;IACpC,4FAA4F;IAC5F,oFAAoF;IACpFF,QAAQC,GAAG,CAAC;AACd;IACA,WAAeP"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/init.ts"],"sourcesContent":["import { initConfig } from '../config.ts';\nimport { USAGE } from './index.ts';\nimport { parse } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst init: Command = (ctx) => {\n  parse(ctx.argv, `usage: ${ctx.name} ${USAGE.init}`, {});\n  const configPath = initConfig(process.cwd());\n  console.log(`created ${configPath}`);\n  console.log(`query away: ${ctx.name} query \"SELECT path FROM frontmatter LIMIT 10\"`);\n  // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not\n  // in this output; name both places that hold them, since an agent may have neither.\n  console.log('features and tree design: the sense-setup skill, or schema.json');\n};\nexport default init;\n"],"names":["init","ctx","parse","argv","USAGE","name","configPath","initConfig","process","cwd","console","log"],"mappings":";;;;+BAcA;;;eAAA;;;wBAd2B;uBACL;wBACA;AAGtB,IAAMA,OAAgB,cAACC;IACrBC,IAAAA,eAAK,EAACD,IAAIE,IAAI,EAAE,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACJ,IAAI,GAAI,CAAC;IACrD,IAAMM,aAAaC,IAAAA,oBAAU,EAACC,QAAQC,GAAG;IACzCC,QAAQC,GAAG,CAAC,AAAC,WAAqB,OAAXL;IACvBI,QAAQC,GAAG,CAAC,AAAC,eAAuB,OAATV,IAAII,IAAI,EAAC;IACpC,4FAA4F;IAC5F,oFAAoF;IACpFK,QAAQC,GAAG,CAAC;AACd;IACA,WAAeX"}

package/dist/cjs/cli/map.js

@@ -10,11 +10,42 @@ Object.defineProperty(exports, "default", {
 });
 var _commandsts = require("../commands.js");
 var _outputts = require("../output.js");
+var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 var map = function map(ctx) {
-    return (0, _sharedts.withDb)(ctx, function(db, cfg) {
+    var values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.map), _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)).values;
+    var format = (0, _sharedts.formatOf)(values);
+    return (0, _sharedts.withDb)(ctx, values.config, function(db, cfg) {
         var result = (0, _commandsts.mapTree)(db, cfg);
-        console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderMap)(result));
+        console.log(format === 'json' ? JSON.stringify(result, null, 2) : (0, _outputts.renderMap)(result));
     });
 };
 var _default = map;

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/map.ts"],"sourcesContent":["import { mapTree } from '../commands.ts';\nimport { renderMap } from '../output.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;;;0BAVwB;wBACE;wBACH;AAGvB,IAAMA,MAAe,aAACC;WACpBC,IAAAA,gBAAM,EAACD,KAAK,SAACE,IAAIC;QACf,IAAMC,SAASC,IAAAA,mBAAO,EAACH,IAAIC;QAC3BG,QAAQC,GAAG,CAACP,IAAIQ,MAAM,KAAK,SAASC,KAAKC,SAAS,CAACN,QAAQ,MAAM,KAAKO,IAAAA,mBAAS,EAACP;IAClF;;IACF,WAAeL"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/map.ts"],"sourcesContent":["import { mapTree } from '../commands.ts';\nimport { renderMap } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst map: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, (db, cfg) => {\n    const result = mapTree(db, cfg);\n    console.log(format === 'json' ? JSON.stringify(result, null, 2) : renderMap(result));\n  });\n};\nexport default map;\n"],"names":["map","ctx","values","parse","argv","USAGE","name","FORMAT","CONFIG","format","formatOf","withDb","config","db","cfg","result","mapTree","console","log","JSON","stringify","renderMap"],"mappings":";;;;+BAcA;;;eAAA;;;0BAdwB;wBACE;uBACJ;wBACkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxD,IAAMA,MAAe,aAACC;IACpB,IAAM,AAAEC,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACL,GAAG,GAAI,mBAAKO,gBAAM,EAAKC,gBAAM,GAApFN;IACR,IAAMO,SAASC,IAAAA,kBAAQ,EAACR;IACxB,OAAOS,IAAAA,gBAAM,EAACV,KAAKC,OAAOU,MAAM,EAAwB,SAACC,IAAIC;QAC3D,IAAMC,SAASC,IAAAA,mBAAO,EAACH,IAAIC;QAC3BG,QAAQC,GAAG,CAACT,WAAW,SAASU,KAAKC,SAAS,CAACL,QAAQ,MAAM,KAAKM,IAAAA,mBAAS,EAACN;IAC9E;AACF;IACA,WAAef"}

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

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

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

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

package/dist/cjs/cli/named.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, // Fallback when the first positional is not a command: a named query from config, either a
 // SQL string (run as-is) or a saved search (run through the `search` command's own machinery).
+// Flags cover both shapes -- SEARCH_FLAGS override a saved search's fields the same way they
+// override a preset's.
 "default", {
     enumerable: true,
     get: function() {
@@ -12,6 +14,7 @@ Object.defineProperty(exports, // Fallback when the first positional is not a co
 });
 var _commandsts = require("../commands.js");
 var _outputts = require("../output.js");
+var _exitts = require("./exit.js");
 var _sharedts = require("./shared.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -42,6 +45,34 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -141,27 +172,27 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-function named(ctx, queryName, params) {
+function named(ctx, queryName) {
     return _async_to_generator(function() {
-        var _parseK, _ctx_values_where, _ctx_values_preset, _ctx_values_include, cfg, entry, k, where, preset, include, semantic;
+        var _parseK, _values_where, _values_preset, _values_include, usage, _parse, values, params, format, configPath, cfg, entry, k, where, preset, include, semantic;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    cfg = ctx.resolveConfig();
+                    usage = "usage: ".concat(ctx.name, " ").concat(queryName, ' [params...] [--format table|json] [--config path] [--where "<sql>"] [--k n] [--preset name] [--include glob ...] [--lexical]');
+                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, params = _parse.positionals;
+                    format = (0, _sharedts.formatOf)(values);
+                    configPath = values.config;
+                    cfg = ctx.resolveConfig(configPath);
                     entry = cfg.queries[queryName];
-                    if (entry === undefined) {
-                        console.error('unknown query: "'.concat(queryName, '"'));
-                        console.error("valid queries: ".concat(Object.keys(cfg.queries).sort().join(', ')));
-                        process.exit(2);
-                    }
+                    if (entry === undefined) (0, _exitts.usageError)('unknown query: "'.concat(queryName, '"'), "valid queries: ".concat(Object.keys(cfg.queries).sort().join(', ')));
                     if (typeof entry === 'string') {
-                        (0, _sharedts.runSql)(cfg, entry, params, ctx.format, 'query "'.concat(queryName, '"'));
+                        (0, _sharedts.runSql)(cfg, entry, params, format, 'query "'.concat(queryName, '"'));
                         return [
                             2
                         ];
                     }
                     if ('sql' in entry) {
-                        (0, _sharedts.runSql)(cfg, entry.sql, params, ctx.format, 'query "'.concat(queryName, '"'));
+                        (0, _sharedts.runSql)(cfg, entry.sql, params, format, 'query "'.concat(queryName, '"'));
                         return [
                             2
                         ];
@@ -170,16 +201,16 @@ function named(ctx, queryName, params) {
                     if (params.length > 0) {
                         ctx.usageError('"'.concat(queryName, '" is a saved search and takes no positional parameters; edit its "search" in sense.config.json, or use "').concat(ctx.name, ' search" directly'));
                     }
-                    k = (_parseK = (0, _sharedts.parseK)(ctx)) !== null && _parseK !== void 0 ? _parseK : entry.k;
-                    where = (_ctx_values_where = ctx.values.where) !== null && _ctx_values_where !== void 0 ? _ctx_values_where : entry.where;
-                    preset = (_ctx_values_preset = ctx.values.preset) !== null && _ctx_values_preset !== void 0 ? _ctx_values_preset : entry.preset;
-                    include = (_ctx_values_include = ctx.values.include) !== null && _ctx_values_include !== void 0 ? _ctx_values_include : entry.include;
+                    k = (_parseK = (0, _sharedts.parseK)(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : entry.k;
+                    where = (_values_where = values.where) !== null && _values_where !== void 0 ? _values_where : entry.where;
+                    preset = (_values_preset = values.preset) !== null && _values_preset !== void 0 ? _values_preset : entry.preset;
+                    include = (_values_include = values.include) !== null && _values_include !== void 0 ? _values_include : entry.include;
                     // --lexical upgrades a saved search's semantic behavior the same way --where/--k
                     // override; absent means the saved value (the flag has no default false override).
-                    semantic = ctx.values.lexical ? false : entry.semantic;
+                    semantic = values.lexical ? false : entry.semantic;
                     return [
                         4,
-                        (0, _sharedts.withDb)(ctx, function(db, resolvedCfg) {
+                        (0, _sharedts.withDb)(ctx, configPath, function(db, resolvedCfg) {
                             return _async_to_generator(function() {
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
@@ -199,7 +230,7 @@ function named(ctx, queryName, params) {
                                                 2,
                                                 _outputts.printRows.apply(void 0, [
                                                     _state.sent(),
-                                                    ctx.format
+                                                    format
                                                 ])
                                             ];
                                     }