sensemaking 0.9.1 → 0.9.2

package/dist/cjs/cli.js

@@ -18,8 +18,8 @@ function _array_like_to_array(arr, len) {
     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 _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -94,11 +94,11 @@ function _interop_require_wildcard(obj, nodeInterop) {
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-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 _to_array(arr) {
-    return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _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";
@@ -212,7 +212,9 @@ function _ts_generator(thisArg, body) {
     }
 }
 // Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --
-// nothing tree- or dependency-heavy may be imported at the top of this file.
+// nothing tree- or dependency-heavy may be imported at the top of this file. Flags parse
+// per command (each command's own parse() call); this file only handles the bare top-level
+// flags (--version/--help/--list/--config) and dispatch.
 // Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.
 function packageVersion() {
     var load = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
@@ -230,95 +232,124 @@ function packageVersion() {
     return 'unknown';
 }
 function usage(name) {
-    return "usage: ".concat(name, " <name> [params...] [--format table|json] [--config path]\n") + "       ".concat(name, ' query "<sql>" [params...]\n') + "       ".concat(name, ' search "<terms>" [--preset name] [--include glob ...] [--where "<sql>"] [--k n] [--lexical]\n') + "       ".concat(name, " map\n") + "       ".concat(name, " peek <path>\n") + "       ".concat(name, " --list\n") + "       ".concat(name, " init\n") + "       ".concat(name, " watch [--force]\n") + "       ".concat(name, " status\n") + "       ".concat(name, " check\n") + "       ".concat(name, " rebuild\n") + "       ".concat(name, " --version");
+    var lines = Object.values(_indexts.USAGE).map(function(u) {
+        return "       ".concat(name, " ").concat(u);
+    });
+    return [
+        "usage: ".concat(name, " <name> [params...] [--format table|json] [--config path]")
+    ].concat(_to_consumable_array(lines), [
+        "       ".concat(name, " --list"),
+        "       ".concat(name, " --version")
+    ]).join('\n');
+}
+function resolveConfigFor(name, configPath) {
+    var cfg = (0, _configts.loadConfig)(configPath);
+    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;
 }
 function cli(argv, name) {
     return _async_to_generator(function() {
-        var values, positionals, ref, ctx, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, entry, isSavedSearch, _positionals, first, params, load, err;
+        var first, values, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, entry, isSavedSearch, ctx, load, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    try {
+                    first = argv[0];
+                    // No command word, or the first token looks like a flag: the only flags this level knows.
+                    if (!first || first.startsWith('-')) {
                         ;
-                        ref = (0, _nodeutil.parseArgs)({
-                            args: argv,
-                            options: {
-                                format: {
-                                    type: 'string',
-                                    default: 'table'
-                                },
-                                config: {
-                                    type: 'string'
-                                },
-                                where: {
-                                    type: 'string'
-                                },
-                                k: {
-                                    type: 'string'
-                                },
-                                preset: {
-                                    type: 'string'
-                                },
-                                include: {
-                                    type: 'string',
-                                    multiple: true
-                                },
-                                lexical: {
-                                    type: 'boolean',
-                                    default: false
-                                },
-                                list: {
-                                    type: 'boolean',
-                                    default: false
-                                },
-                                force: {
-                                    type: 'boolean',
-                                    default: false
-                                },
-                                version: {
-                                    type: 'boolean',
-                                    default: false,
-                                    short: 'v'
+                        try {
+                            values = (0, _nodeutil.parseArgs)({
+                                args: argv,
+                                options: {
+                                    version: {
+                                        type: 'boolean',
+                                        default: false,
+                                        short: 'v'
+                                    },
+                                    help: {
+                                        type: 'boolean',
+                                        default: false,
+                                        short: 'h'
+                                    },
+                                    list: {
+                                        type: 'boolean',
+                                        default: false
+                                    },
+                                    config: {
+                                        type: 'string'
+                                    }
                                 },
-                                help: {
-                                    type: 'boolean',
-                                    default: false,
-                                    short: 'h'
+                                allowPositionals: true
+                            }).values;
+                        } catch (err) {
+                            console.error(err.message);
+                            console.error(usage(name));
+                            process.exit(2);
+                        }
+                        try {
+                            if (values.version) {
+                                console.log("v".concat(packageVersion()));
+                                return [
+                                    2
+                                ];
+                            }
+                            if (values.help) {
+                                console.log(usage(name));
+                                return [
+                                    2
+                                ];
+                            }
+                            if (values.list) {
+                                queries = resolveConfigFor(name, values.config).queries;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = Object.keys(queries).sort()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        queryName = _step.value;
+                                        entry = queries[queryName];
+                                        isSavedSearch = (typeof entry === "undefined" ? "undefined" : _type_of(entry)) === 'object' && entry !== null && 'search' in entry;
+                                        console.log(isSavedSearch ? "".concat(queryName, "  (search)") : queryName);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
                                 }
-                            },
-                            allowPositionals: true
-                        }), values = ref.values, positionals = ref.positionals, ref;
-                    } catch (err) {
-                        console.error(err.message);
+                                return [
+                                    2
+                                ];
+                            }
+                        } catch (err) {
+                            console.error(err.message);
+                            process.exit(1);
+                        }
                         console.error(usage(name));
                         process.exit(2);
                     }
-                    if (values.version) {
-                        console.log("v".concat(packageVersion()));
-                        return [
-                            2
-                        ];
-                    }
-                    if (values.help) {
-                        console.log(usage(name));
-                        return [
-                            2
-                        ];
+                    // find -> search (breaking rename): one release of a pointer instead of "unknown query".
+                    if (first === 'find') {
+                        console.error("".concat(name, ": find is now search"));
+                        console.error(usage(name));
+                        process.exit(2);
                     }
                     ctx = {
                         name: name,
-                        rest: positionals.slice(1),
-                        format: values.format === 'json' ? 'json' : 'table',
-                        values: values,
-                        resolveConfig: function resolveConfig() {
-                            var cfg = (0, _configts.loadConfig)(values.config);
-                            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;
+                        argv: argv.slice(1),
+                        resolveConfig: function resolveConfig(configPath) {
+                            return resolveConfigFor(name, configPath);
                         },
                         usageError: function usageError(message) {
                             console.error(message);
@@ -333,45 +364,6 @@ function cli(argv, name) {
                         ,
                         9
                     ]);
-                    if (values.list) {
-                        queries = ctx.resolveConfig().queries;
-                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                        try {
-                            for(_iterator = Object.keys(queries).sort()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                                queryName = _step.value;
-                                entry = queries[queryName];
-                                isSavedSearch = (typeof entry === "undefined" ? "undefined" : _type_of(entry)) === 'object' && entry !== null && 'search' in entry;
-                                console.log(isSavedSearch ? "".concat(queryName, "  (search)") : queryName);
-                            }
-                        } catch (err) {
-                            _didIteratorError = true;
-                            _iteratorError = err;
-                        } finally{
-                            try {
-                                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                                    _iterator.return();
-                                }
-                            } finally{
-                                if (_didIteratorError) {
-                                    throw _iteratorError;
-                                }
-                            }
-                        }
-                        return [
-                            2
-                        ];
-                    }
-                    _positionals = _to_array(positionals), first = _positionals[0], params = _positionals.slice(1);
-                    if (!first) {
-                        console.error(usage(name));
-                        process.exit(2);
-                    }
-                    // find -> search (breaking rename): one release of a pointer instead of "unknown query".
-                    if (first === 'find') {
-                        console.error("".concat(name, ": find is now search"));
-                        console.error(usage(name));
-                        process.exit(2);
-                    }
                     load = _indexts.COMMANDS[first];
                     if (!load) return [
                         3,
@@ -402,7 +394,7 @@ function cli(argv, name) {
                 case 5:
                     return [
                         4,
-                        _state.sent().default(ctx, first, params)
+                        _state.sent().default(ctx, first)
                     ];
                 case 6:
                     _state.sent();

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 './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} check\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  let values: Record<string, string | boolean | string[] | 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        preset: { type: 'string' },\n        include: { type: 'string', multiple: true },\n        lexical: { 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      const queries = ctx.resolveConfig().queries;\n      for (const queryName of Object.keys(queries).sort()) {\n        const entry = queries[queryName];\n        const isSavedSearch = typeof entry === 'object' && entry !== null && 'search' in entry;\n        console.log(isSavedSearch ? `${queryName}  (search)` : queryName);\n      }\n      return;\n    }\n\n    const [first, ...params] = positionals;\n    if (!first) {\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    // find -> search (breaking rename): one release of a pointer instead of \"unknown query\".\n    if (first === 'find') {\n      console.error(`${name}: find is now search`);\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first, params);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","argv","values","positionals","ctx","queries","queryName","entry","isSavedSearch","first","params","err","parseArgs","args","options","format","type","default","config","where","k","preset","include","multiple","lexical","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","unknownKeys","join","usageError","Object","keys","sort","COMMANDS"],"mappings":"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"}
+{"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, USAGE } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file. Flags parse\n// per command (each command's own parse() call); this file only handles the bare top-level\n// flags (--version/--help/--list/--config) and dispatch.\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  const lines = Object.values(USAGE).map((u) => `       ${name} ${u}`);\n  return [`usage: ${name} <name> [params...] [--format table|json] [--config path]`, ...lines, `       ${name} --list`, `       ${name} --version`].join('\\n');\n}\n\nfunction resolveConfigFor(name: string, configPath: string | undefined) {\n  const cfg = loadConfig(configPath);\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\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  const first = argv[0];\n\n  // No command word, or the first token looks like a flag: the only flags this level knows.\n  if (!first || first.startsWith('-')) {\n    let values: Record<string, string | boolean | undefined>;\n    try {\n      ({ values } = parseArgs({\n        args: argv,\n        options: {\n          version: { type: 'boolean', default: false, short: 'v' },\n          help: { type: 'boolean', default: false, short: 'h' },\n          list: { type: 'boolean', default: false },\n          config: { type: 'string' },\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    try {\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      if (values.list) {\n        const queries = resolveConfigFor(name, values.config as string | undefined).queries;\n        for (const queryName of Object.keys(queries).sort()) {\n          const entry = queries[queryName];\n          const isSavedSearch = typeof entry === 'object' && entry !== null && 'search' in entry;\n          console.log(isSavedSearch ? `${queryName}  (search)` : queryName);\n        }\n        return;\n      }\n    } catch (err) {\n      console.error((err as Error).message);\n      process.exit(1);\n    }\n\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  // find -> search (breaking rename): one release of a pointer instead of \"unknown query\".\n  if (first === 'find') {\n    console.error(`${name}: find is now search`);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  const ctx: Ctx = {\n    name,\n    argv: argv.slice(1),\n    resolveConfig: (configPath) => resolveConfigFor(name, configPath),\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first);\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","lines","Object","values","USAGE","map","u","join","resolveConfigFor","configPath","cfg","loadConfig","migratedFrom","undefined","console","warn","SUPPORTED_CONFIG_VERSION","unknownKeys","argv","first","queries","queryName","entry","isSavedSearch","ctx","err","startsWith","parseArgs","args","options","type","default","short","help","list","config","allowPositionals","error","message","process","exit","log","keys","sort","slice","resolveConfig","usageError","COMMANDS"],"mappings":"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"}

package/dist/esm/cli/check.js

@@ -1,7 +1,8 @@
 import { search } from '../commands.js';
 import { open } from '../db.js';
 import { printRows } from '../output.js';
-import { printWarnings } from './shared.js';
+import { USAGE } from './index.js';
+import { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.js';
 // 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
@@ -14,7 +15,12 @@ import { printWarnings } from './shared.js';
 // result being empty is good or bad is the reader's judgment -- there is no assertion path.
 const check = async (ctx)=>{
     var _cfg_queries;
-    const cfg = ctx.resolveConfig();
+    const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.check}`, {
+        ...FORMAT,
+        ...CONFIG
+    });
+    const format = formatOf(values);
+    const cfg = ctx.resolveConfig(values.config);
     const { db, warnings } = open(cfg);
     printWarnings(warnings);
     const rows = [];
@@ -82,7 +88,7 @@ const check = async (ctx)=>{
         console.log('no saved queries in config');
         return;
     }
-    printRows(rows, ctx.format);
+    printRows(rows, format);
     if (failed > 0) process.exit(1);
 };
 export default check;

package/dist/esm/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":["search","open","printRows","printWarnings","check","ctx","cfg","resolveConfig","db","warnings","rows","failed","name","entry","Object","entries","queries","sql","count","k","where","preset","include","semantic","length","push","query","params","status","err","message","match","statement","prepare","all","close","console","log","format","process","exit"],"mappings":"AAAA,SAASA,MAAM,QAAQ,iBAAiB;AACxC,SAASC,IAAI,QAAQ,WAAW;AAEhC,SAASC,SAAS,QAAQ,eAAe;AACzC,SAASC,aAAa,QAAQ,cAAc;AAG5C,2FAA2F;AAC3F,wFAAwF;AACxF,4FAA4F;AAC5F,2FAA2F;AAC3F,4FAA4F;AAC5F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,wFAAwF;AACxF,4FAA4F;AAC5F,MAAMC,QAAiB,OAAOC;QAOeC;IAN3C,MAAMA,MAAMD,IAAIE,aAAa;IAC7B,MAAM,EAAEC,EAAE,EAAEC,QAAQ,EAAE,GAAGR,KAAKK;IAC9BH,cAAcM;IAEd,MAAMC,OAAc,EAAE;IACtB,IAAIC,SAAS;IACb,KAAK,MAAM,CAACC,MAAMC,MAAM,IAAIC,OAAOC,OAAO,EAACT,eAAAA,IAAIU,OAAO,cAAXV,0BAAAA,eAAe,CAAC,GAAI;YAY7CW;QAXhB,IAAI,OAAOJ,UAAU,YAAYA,UAAU,QAAQ,YAAYA,OAAO;YACpE,IAAI;gBACF,MAAMK,QAAQ,AAAC,CAAA,MAAMlB,OAAOQ,IAAIF,KAAKO,MAAMb,MAAM,EAAE;oBAAEmB,GAAG;oBAAGC,OAAOP,MAAMO,KAAK;oBAAEC,QAAQR,MAAMQ,MAAM;oBAAEC,SAAST,MAAMS,OAAO;oBAAEC,UAAU;gBAAM,EAAC,EAAGC,MAAM;gBACvJd,KAAKe,IAAI,CAAC;oBAAEC,OAAOd;oBAAMe,QAAQ;oBAAKjB,MAAM;oBAAKkB,QAAQV,UAAU,IAAI,4CAA4C;gBAA0B;YAC/I,EAAE,OAAOW,KAAK;gBACZlB;gBACAD,KAAKe,IAAI,CAAC;oBAAEC,OAAOd;oBAAMe,QAAQ;oBAAKjB,MAAM;oBAAKkB,QAAQ,CAAC,QAAQ,EAAE,AAACC,IAAcC,OAAO,EAAE;gBAAC;YAC/F;YACA;QACF;QACA,MAAMb,MAAM,OAAOJ,UAAU,WAAWA,QAAQA,MAAMI,GAAG;QACzD,MAAMU,SAAS,EAACV,aAAAA,IAAIc,KAAK,CAAC,oBAAVd,wBAAAA,aAAoB,EAAE,EAAEO,MAAM;QAC9C,IAAI;YACF,MAAMQ,YAAYxB,GAAGyB,OAAO,CAAChB;YAC7B,IAAIU,SAAS,GAAG;gBACdjB,KAAKe,IAAI,CAAC;oBAAEC,OAAOd;oBAAMe;oBAAQjB,MAAM;oBAAKkB,QAAQ;gBAAiC;gBACrF;YACF;YACA,MAAMV,QAAQ,AAACc,UAAUE,GAAG,GAAiBV,MAAM;YACnDd,KAAKe,IAAI,CAAC;gBAAEC,OAAOd;gBAAMe;gBAAQjB,MAAMQ;gBAAOU,QAAQV,UAAU,IAAI,2BAA2B;YAAK;QACtG,EAAE,OAAOW,KAAK;YACZlB;YACAD,KAAKe,IAAI,CAAC;gBAAEC,OAAOd;gBAAMe;gBAAQjB,MAAM;gBAAKkB,QAAQ,CAAC,QAAQ,EAAE,AAACC,IAAcC,OAAO,EAAE;YAAC;QAC1F;IACF;IAEAtB,GAAG2B,KAAK;IACR,IAAIzB,KAAKc,MAAM,KAAK,GAAG;QACrBY,QAAQC,GAAG,CAAC;QACZ;IACF;IACAnC,UAAUQ,MAAML,IAAIiC,MAAM;IAC1B,IAAI3B,SAAS,GAAG4B,QAAQC,IAAI,CAAC;AAC/B;AACA,eAAepC,MAAM"}
+{"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 { 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) process.exit(1);\n};\nexport default check;\n"],"names":["search","open","printRows","USAGE","CONFIG","FORMAT","formatOf","parse","printWarnings","check","ctx","cfg","values","argv","name","format","resolveConfig","config","db","warnings","rows","failed","entry","Object","entries","queries","sql","count","k","where","preset","include","semantic","length","push","query","params","status","err","message","match","statement","prepare","all","close","console","log","process","exit"],"mappings":"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"}

package/dist/esm/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/esm/cli/index.js

@@ -1,3 +1,17 @@
+// Each command's usage line, minus the leading "usage: <name> " -- shared by cli.ts's
+// top-level usage() and the command's own parse() error/--help output, so there is one
+// copy of each line, not two that can drift.
+export const 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]'
+};
 // Lazy registry: a command's imports load only when it runs, so a heavy dependency in one
 // command never taxes the others (or --version/--help). These names are reserved: a named
 // query in config can never shadow them.

package/dist/esm/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":"AAEA,0FAA0F;AAC1F,0FAA0F;AAC1F,yCAAyC;AACzC,OAAO,MAAMA,WAAgE;IAC3EC,MAAM,IAAM,MAAM,CAAC;IACnBC,OAAO,IAAM,MAAM,CAAC;IACpBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,OAAO,IAAM,MAAM,CAAC;IACpBC,SAAS,IAAM,MAAM,CAAC;IACtBC,OAAO,IAAM,MAAM,CAAC;IACpBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,KAAK,IAAM,MAAM,CAAC;IAClBC,MAAM,IAAM,MAAM,CAAC;AACrB,EAAE"}
+{"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":["USAGE","init","watch","status","check","rebuild","query","search","map","peek","COMMANDS"],"mappings":"AAEA,sFAAsF;AACtF,uFAAuF;AACvF,6CAA6C;AAC7C,OAAO,MAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,QAAQ;IACRC,OAAO;IACPC,SAAS;IACTC,OAAO;IACPC,QAAQ;IACRC,KAAK;IACLC,MAAM;AACR,EAAW;AAEX,0FAA0F;AAC1F,0FAA0F;AAC1F,yCAAyC;AACzC,OAAO,MAAMC,WAAgE;IAC3ET,MAAM,IAAM,MAAM,CAAC;IACnBC,OAAO,IAAM,MAAM,CAAC;IACpBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,OAAO,IAAM,MAAM,CAAC;IACpBC,SAAS,IAAM,MAAM,CAAC;IACtBC,OAAO,IAAM,MAAM,CAAC;IACpBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,KAAK,IAAM,MAAM,CAAC;IAClBC,MAAM,IAAM,MAAM,CAAC;AACrB,EAAE"}

package/dist/esm/cli/init.js

@@ -1,5 +1,8 @@
 import { initConfig } from '../config.js';
+import { USAGE } from './index.js';
+import { parse } from './shared.js';
 const init = (ctx)=>{
+    parse(ctx.argv, `usage: ${ctx.name} ${USAGE.init}`, {});
     const configPath = initConfig(process.cwd());
     console.log(`created ${configPath}`);
     console.log(`query away: ${ctx.name} query "SELECT path FROM frontmatter LIMIT 10"`);

package/dist/esm/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":["initConfig","init","ctx","configPath","process","cwd","console","log","name"],"mappings":"AAAA,SAASA,UAAU,QAAQ,eAAe;AAG1C,MAAMC,OAAgB,CAACC;IACrB,MAAMC,aAAaH,WAAWI,QAAQC,GAAG;IACzCC,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEJ,YAAY;IACnCG,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEL,IAAIM,IAAI,CAAC,8CAA8C,CAAC;IACnF,4FAA4F;IAC5F,oFAAoF;IACpFF,QAAQC,GAAG,CAAC;AACd;AACA,eAAeN,KAAK"}
+{"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":["initConfig","USAGE","parse","init","ctx","argv","name","configPath","process","cwd","console","log"],"mappings":"AAAA,SAASA,UAAU,QAAQ,eAAe;AAC1C,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,KAAK,QAAQ,cAAc;AAGpC,MAAMC,OAAgB,CAACC;IACrBF,MAAME,IAAIC,IAAI,EAAE,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAEL,MAAME,IAAI,EAAE,EAAE,CAAC;IACrD,MAAMI,aAAaP,WAAWQ,QAAQC,GAAG;IACzCC,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEJ,YAAY;IACnCG,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEP,IAAIE,IAAI,CAAC,8CAA8C,CAAC;IACnF,4FAA4F;IAC5F,oFAAoF;IACpFI,QAAQC,GAAG,CAAC;AACd;AACA,eAAeR,KAAK"}

package/dist/esm/cli/map.js

@@ -1,8 +1,16 @@
 import { mapTree } from '../commands.js';
 import { renderMap } from '../output.js';
-import { withDb } from './shared.js';
-const map = (ctx)=>withDb(ctx, (db, cfg)=>{
+import { USAGE } from './index.js';
+import { CONFIG, FORMAT, formatOf, parse, withDb } from './shared.js';
+const map = (ctx)=>{
+    const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, {
+        ...FORMAT,
+        ...CONFIG
+    });
+    const format = formatOf(values);
+    return withDb(ctx, values.config, (db, cfg)=>{
         const result = mapTree(db, cfg);
-        console.log(ctx.format === 'json' ? JSON.stringify(result, null, 2) : renderMap(result));
+        console.log(format === 'json' ? JSON.stringify(result, null, 2) : renderMap(result));
     });
+};
 export default map;

package/dist/esm/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":["mapTree","renderMap","withDb","map","ctx","db","cfg","result","console","log","format","JSON","stringify"],"mappings":"AAAA,SAASA,OAAO,QAAQ,iBAAiB;AACzC,SAASC,SAAS,QAAQ,eAAe;AACzC,SAASC,MAAM,QAAQ,cAAc;AAGrC,MAAMC,MAAe,CAACC,MACpBF,OAAOE,KAAK,CAACC,IAAIC;QACf,MAAMC,SAASP,QAAQK,IAAIC;QAC3BE,QAAQC,GAAG,CAACL,IAAIM,MAAM,KAAK,SAASC,KAAKC,SAAS,CAACL,QAAQ,MAAM,KAAKN,UAAUM;IAClF;AACF,eAAeJ,IAAI"}
+{"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":["mapTree","renderMap","USAGE","CONFIG","FORMAT","formatOf","parse","withDb","map","ctx","values","argv","name","format","config","db","cfg","result","console","log","JSON","stringify"],"mappings":"AAAA,SAASA,OAAO,QAAQ,iBAAiB;AACzC,SAASC,SAAS,QAAQ,eAAe;AACzC,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,MAAM,QAAQ,cAAc;AAGtE,MAAMC,MAAe,CAACC;IACpB,MAAM,EAAEC,MAAM,EAAE,GAAGJ,MAAMG,IAAIE,IAAI,EAAE,CAAC,OAAO,EAAEF,IAAIG,IAAI,CAAC,CAAC,EAAEV,MAAMM,GAAG,EAAE,EAAE;QAAE,GAAGJ,MAAM;QAAE,GAAGD,MAAM;IAAC;IAC7F,MAAMU,SAASR,SAASK;IACxB,OAAOH,OAAOE,KAAKC,OAAOI,MAAM,EAAwB,CAACC,IAAIC;QAC3D,MAAMC,SAASjB,QAAQe,IAAIC;QAC3BE,QAAQC,GAAG,CAACN,WAAW,SAASO,KAAKC,SAAS,CAACJ,QAAQ,MAAM,KAAKhB,UAAUgB;IAC9E;AACF;AACA,eAAeT,IAAI"}

package/dist/esm/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/esm/cli/named.js

@@ -1,11 +1,21 @@
 import { search } from '../commands.js';
 import { printRows } from '../output.js';
-import { parseK, runSql, withDb } from './shared.js';
+import { CONFIG, FORMAT, formatOf, parse, parseK, runSql, SEARCH_FLAGS, withDb } from './shared.js';
 // 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).
-export default async function named(ctx, queryName, params) {
-    var _parseK, _ctx_values_where, _ctx_values_preset, _ctx_values_include;
-    const cfg = ctx.resolveConfig();
+// Flags cover both shapes -- SEARCH_FLAGS override a saved search's fields the same way they
+// override a preset's.
+export default async function named(ctx, queryName) {
+    var _parseK, _values_where, _values_preset, _values_include;
+    const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json] [--config path] [--where "<sql>"] [--k n] [--preset name] [--include glob ...] [--lexical]`;
+    const { values, positionals: params } = parse(ctx.argv, usage, {
+        ...SEARCH_FLAGS,
+        ...FORMAT,
+        ...CONFIG
+    });
+    const format = formatOf(values);
+    const configPath = values.config;
+    const cfg = ctx.resolveConfig(configPath);
     const entry = cfg.queries[queryName];
     if (entry === undefined) {
         console.error(`unknown query: "${queryName}"`);
@@ -13,29 +23,29 @@ export default async function named(ctx, queryName, params) {
         process.exit(2);
     }
     if (typeof entry === 'string') {
-        runSql(cfg, entry, params, ctx.format, `query "${queryName}"`);
+        runSql(cfg, entry, params, format, `query "${queryName}"`);
         return;
     }
     if ('sql' in entry) {
-        runSql(cfg, entry.sql, params, ctx.format, `query "${queryName}"`);
+        runSql(cfg, entry.sql, params, format, `query "${queryName}"`);
         return;
     }
     // A saved search's text is fixed in config; there is nowhere for a positional to bind.
     if (params.length > 0) {
         ctx.usageError(`"${queryName}" is a saved search and takes no positional parameters; edit its "search" in sense.config.json, or use "${ctx.name} search" directly`);
     }
-    const k = (_parseK = parseK(ctx)) !== null && _parseK !== void 0 ? _parseK : entry.k;
-    const where = (_ctx_values_where = ctx.values.where) !== null && _ctx_values_where !== void 0 ? _ctx_values_where : entry.where;
-    const preset = (_ctx_values_preset = ctx.values.preset) !== null && _ctx_values_preset !== void 0 ? _ctx_values_preset : entry.preset;
-    const include = (_ctx_values_include = ctx.values.include) !== null && _ctx_values_include !== void 0 ? _ctx_values_include : entry.include;
+    const k = (_parseK = parseK(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : entry.k;
+    const where = (_values_where = values.where) !== null && _values_where !== void 0 ? _values_where : entry.where;
+    const preset = (_values_preset = values.preset) !== null && _values_preset !== void 0 ? _values_preset : entry.preset;
+    const 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).
-    const semantic = ctx.values.lexical ? false : entry.semantic;
-    await withDb(ctx, async (db, resolvedCfg)=>printRows(await search(db, resolvedCfg, entry.search, {
+    const semantic = values.lexical ? false : entry.semantic;
+    await withDb(ctx, configPath, async (db, resolvedCfg)=>printRows(await search(db, resolvedCfg, entry.search, {
             k,
             where,
             preset,
             include,
             semantic
-        }), ctx.format));
+        }), format));
 }