sensemaking 0.9.5 → 0.11.0

package/dist/cjs/cli/shared.js

@@ -15,6 +15,9 @@ _export(exports, {
     get FORMAT () {
         return FORMAT;
     },
+    get SCOPE () {
+        return SCOPE;
+    },
     get SEARCH_FLAGS () {
         return SEARCH_FLAGS;
     },
@@ -33,11 +36,15 @@ _export(exports, {
     get runSql () {
         return runSql;
     },
+    get scopeOf () {
+        return scopeOf;
+    },
     get withDb () {
         return withDb;
     }
 });
 var _nodeutil = require("node:util");
+var _configts = require("../config.js");
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
 var _searcherrorts = require("../search-error.js");
@@ -257,13 +264,10 @@ var CONFIG = {
         type: 'string'
     }
 };
-var SEARCH_FLAGS = {
+var SCOPE = {
     where: {
         type: 'string'
     },
-    k: {
-        type: 'string'
-    },
     preset: {
         type: 'string'
     },
@@ -271,11 +275,31 @@ var SEARCH_FLAGS = {
         type: 'string',
         multiple: true
     },
-    lexical: {
+    exclude: {
+        type: 'string',
+        multiple: true
+    },
+    // Widening, which no other flag can express: --include and --exclude each override their
+    // own side of the preset, so neither can drop an exclusion the preset declares.
+    'no-exclude': {
         type: 'boolean',
         default: false
     }
 };
+var SEARCH_FLAGS = _object_spread_props(_object_spread({}, SCOPE), {
+    k: {
+        type: 'string'
+    }
+});
+function scopeOf(values) {
+    return {
+        preset: values.preset,
+        include: values.include,
+        exclude: values.exclude,
+        where: values.where,
+        noExclude: values['no-exclude'] === true
+    };
+}
 function formatOf(values) {
     return values.format === 'json' ? 'json' : 'table';
 }
@@ -378,15 +402,34 @@ function withDb(ctx, configPath, fn) {
         });
     })();
 }
-function runSql(cfg, sql, params, format, label) {
+// `--preset` on SQL binds the scope rather than applying it: the statement joins `scope`
+// itself. Filtering behind the query's back is not available -- the obvious version, temp views
+// shadowing the base tables, cannot cover `content`, because FTS5 `MATCH` uses the table name
+// as a hidden column and a view has none. A flag that silently scoped three tables of four
+// would look scoped and not be. See plans/vault-field-report-fixes.md item F.
+function bindScope(db, cfg, preset) {
+    var name = (0, _configts.resolvePreset)(cfg, preset).name; // unknown names throw, listing what is declared
+    db.exec('DROP TABLE IF EXISTS temp.scope');
+    db.exec('CREATE TEMP TABLE scope ("path" TEXT PRIMARY KEY)');
+    db.prepare('INSERT INTO temp.scope ("path") SELECT "path" FROM preset_files WHERE preset = ?').run(name);
+}
+function runSql(cfg, sql, params, format, label, preset) {
     var _sql_match;
     var placeholderCount = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
     if (params.length !== placeholderCount) {
         console.error("".concat(label, " expects ").concat(placeholderCount, " parameter(s), got ").concat(params.length));
         process.exit(2);
     }
+    // Naming a preset and never joining it would return the whole index while reading as scoped,
+    // which is the one hazard of binding rather than applying. Refuse instead.
+    if (preset !== undefined && !/\bscope\b/i.test(sql)) {
+        console.error('--preset binds a temporary "scope" table of the preset\'s paths, and '.concat(label, " never joins it, so the preset would have no effect"));
+        console.error('add: JOIN scope ON scope."path" = <table>."path"');
+        process.exit(2);
+    }
     var _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
     printWarnings(warnings);
+    if (preset !== undefined) bindScope(db, cfg, preset);
     var rows;
     try {
         var _db_prepare;

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig } from '../config.ts';\nimport type { OpenResult } from '../db.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  k: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  lexical: { type: 'boolean', default: false },\n};\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return values.format === 'json' ? 'json' : 'table';\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["CONFIG","FORMAT","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","runSql","withDb","format","type","default","config","where","k","preset","include","multiple","lexical","values","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","console","error","message","process","exit","log","usageError","undefined","parsed","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","sql","params","label","placeholderCount","match","length","rows","prepare","all","test","searchError","join","printRows"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig, SearchOverrides } from '../config.ts';\nimport { resolvePreset } from '../config.ts';\nimport type { OpenResult } from '../db.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down. One\n// place to read them, so a new scope field is added to the fragment and here, not in each\n// command's call.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return values.format === 'json' ? 'json' : 'table';\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as\n// \"nothing\", and parseInt would silently truncate \"5.9\" -- all three are caller mistakes\n// worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// `--preset` on SQL binds the scope rather than applying it: the statement joins `scope`\n// itself. Filtering behind the query's back is not available -- the obvious version, temp views\n// shadowing the base tables, cannot cover `content`, because FTS5 `MATCH` uses the table name\n// as a hidden column and a view has none. A flag that silently scoped three tables of four\n// would look scoped and not be. See plans/vault-field-report-fixes.md item F.\nfunction bindScope(db: OpenResult['db'], cfg: ResolvedConfig, preset: string): void {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  db.exec('DROP TABLE IF EXISTS temp.scope');\n  db.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  db.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?').run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string, preset?: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  if (preset !== undefined) bindScope(db, cfg, preset);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["CONFIG","FORMAT","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","printWarnings","runSql","scopeOf","withDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","console","error","message","process","exit","log","usageError","undefined","parsed","Number","isInteger","warnings","w","warn","ctx","configPath","fn","cfg","open","db","resolveConfig","close","bindScope","name","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","match","length","test","rows","all","searchError","join","printRows"],"mappings":";;;;;;;;;;;QAaaA;eAAAA;;QADAC;eAAAA;;QAIAC;eAAAA;;QASAC;eAAAA;;QAiBGC;eAAAA;;QAKAC;eAAAA;;QAyBAC;eAAAA;;QASAC;eAAAA;;QA4BAC;eAAAA;;QA7EAC;eAAAA;;QAqDMC;eAAAA;;;wBApFI;wBAEI;oBAET;wBAEK;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIrB,IAAMT,SAAiC;IAAEU,QAAQ;QAAEC,MAAM;QAAUC,SAAS;IAAQ;AAAE;AACtF,IAAMb,SAAiC;IAAEc,QAAQ;QAAEF,MAAM;IAAS;AAAE;AAGpE,IAAMV,QAAgC;IAC3Ca,OAAO;QAAEH,MAAM;IAAS;IACxBI,QAAQ;QAAEJ,MAAM;IAAS;IACzBK,SAAS;QAAEL,MAAM;QAAUM,UAAU;IAAK;IAC1CC,SAAS;QAAEP,MAAM;QAAUM,UAAU;IAAK;IAC1C,yFAAyF;IACzF,gFAAgF;IAChF,cAAc;QAAEN,MAAM;QAAWC,SAAS;IAAM;AAClD;AACO,IAAMV,eAAuC,wCAAKD;IAAOkB,GAAG;QAAER,MAAM;IAAS;;AAO7E,SAASH,QAAQY,MAAc;IACpC,OAAO;QACLL,QAAQK,OAAOL,MAAM;QACrBC,SAASI,OAAOJ,OAAO;QACvBE,SAASE,OAAOF,OAAO;QACvBJ,OAAOM,OAAON,KAAK;QACnBO,WAAWD,MAAM,CAAC,aAAa,KAAK;IACtC;AACF;AAEO,SAASjB,SAASiB,MAAc;IACrC,OAAOA,OAAOV,MAAM,KAAK,SAAS,SAAS;AAC7C;AAGO,SAASN,MAAMkB,IAAc,EAAEC,KAAa,EAAEC,OAA+B;IAClF,IAAIJ;IACJ,IAAIK;IACJ,IAAI;;cACyBC,IAAAA,mBAAS,EAAC;YACnCC,MAAML;YACNE,SAAS,wCAAKA;gBAASI,MAAM;oBAAEjB,MAAM;oBAAWC,SAAS;oBAAOiB,OAAO;gBAAI;;YAC3EC,QAAQ;YACRC,kBAAkB;QACpB,IALGX,aAAAA,QAAQK,kBAAAA;IAMb,EAAE,OAAOO,KAAK;QACZC,QAAQC,KAAK,CAAC,AAACF,IAAcG,OAAO;QACpCF,QAAQC,KAAK,CAACX;QACda,QAAQC,IAAI,CAAC;IACf;IACA,IAAIjB,OAAOQ,IAAI,EAAE;QACfK,QAAQK,GAAG,CAACf;QACZa,QAAQC,IAAI,CAAC;IACf;IACA,OAAO;QAAEjB,QAAAA;QAAQK,aAAAA;IAAY;AAC/B;AAKO,SAASpB,OAAOc,CAAqB,EAAEoB,UAAsC;IAClF,IAAIpB,MAAMqB,WAAW,OAAOA;IAC5B,IAAMC,SAASC,OAAOvB;IACtB,IAAI,CAACuB,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,wCAAyC,OAAFpB,GAAE;IACnG,OAAOsB;AACT;AAIO,SAASnC,cAAcsC,QAAkB;QACzC,kCAAA,2BAAA;;QAAL,QAAK,YAAWA,6BAAX,SAAA,6BAAA,QAAA,yBAAA;YAAA,IAAMC,IAAN;YAAqBZ,QAAQa,IAAI,CAACD;;;QAAlC;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;AACP;AAEO,SAAepC,OAAOsC,GAAQ,EAAEC,UAA8B,EAAEC,EAAuE;;YACtIC,KACmBC,OAAjBC,IAAIR;;;;oBADNM,MAAMH,IAAIM,aAAa,CAACL;oBACLG,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIR,WAAaO,MAAbP;oBACZtC,cAAcsC;;;;;;;;;oBAEZ;;wBAAMK,GAAGG,IAAIF;;;oBAAb;;;;;;oBAEAE,GAAGE,KAAK;;;;;;;;;;IAEZ;;AAEA,yFAAyF;AACzF,gGAAgG;AAChG,8FAA8F;AAC9F,2FAA2F;AAC3F,8EAA8E;AAC9E,SAASC,UAAUH,EAAoB,EAAEF,GAAmB,EAAEnC,MAAc;IAC1E,IAAM,AAAEyC,OAASC,IAAAA,uBAAa,EAACP,KAAKnC,QAA5ByC,MAAqC,gDAAgD;IAC7FJ,GAAGM,IAAI,CAAC;IACRN,GAAGM,IAAI,CAAC;IACRN,GAAGO,OAAO,CAAC,oFAAoFC,GAAG,CAACJ;AACrG;AAGO,SAASjD,OAAO2C,GAAmB,EAAEW,GAAW,EAAEC,MAAgB,EAAEpD,MAAwB,EAAEqD,KAAa,EAAEhD,MAAe;QACvG8C;IAA1B,IAAMG,mBAAmB,EAACH,aAAAA,IAAII,KAAK,CAAC,oBAAVJ,wBAAAA,aAAoB,EAAE,EAAEK,MAAM;IACxD,IAAIJ,OAAOI,MAAM,KAAKF,kBAAkB;QACtC/B,QAAQC,KAAK,CAAC,AAAC,GAAmB8B,OAAjBD,OAAM,aAAiDD,OAAtCE,kBAAiB,uBAAmC,OAAdF,OAAOI,MAAM;QACrF9B,QAAQC,IAAI,CAAC;IACf;IACA,6FAA6F;IAC7F,2EAA2E;IAC3E,IAAItB,WAAWyB,aAAa,CAAC,aAAa2B,IAAI,CAACN,MAAM;QACnD5B,QAAQC,KAAK,CAAC,AAAC,wEAA4E,OAAN6B,OAAM;QAC3F9B,QAAQC,KAAK,CAAC;QACdE,QAAQC,IAAI,CAAC;IACf;IACA,IAAyBc,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIR,WAAaO,MAAbP;IACZtC,cAAcsC;IACd,IAAI7B,WAAWyB,WAAWe,UAAUH,IAAIF,KAAKnC;IAC7C,IAAIqD;IACJ,IAAI;YACKhB;QAAPgB,OAAOhB,CAAAA,cAAAA,GAAGO,OAAO,CAACE,MAAKQ,GAAG,OAAnBjB,aAAoB,qBAAGU;IAChC,EAAE,OAAO9B,KAAK;QACZoB,GAAGE,KAAK;QACR,gFAAgF;QAChF,mFAAmF;QACnF,sFAAsF;QACtF,IAAI,aAAaa,IAAI,CAACN,MAAM,MAAMS,IAAAA,0BAAW,EAACtC,KAAc8B,OAAOS,IAAI,CAAC;QACxE,MAAMvC;IACR;IACAwC,IAAAA,mBAAS,EAACJ,MAAM1D;IAChB0C,GAAGE,KAAK;AACV"}

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

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

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

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

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

@@ -52,6 +52,30 @@ function _object_spread(target) {
     }
     return target;
 }
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _to_array(arr) {
     return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
 }
@@ -63,13 +87,17 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-var query = function query(ctx) {
-    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.query);
-    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+var sqlCmd = function sqlCmd(ctx) {
+    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.sql);
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG), {
+        preset: {
+            type: 'string'
+        }
+    })), values = _parse.values, positionals = _parse.positionals;
     var _positionals = _to_array(positionals), sql = _positionals[0], params = _positionals.slice(1);
     if (!sql) ctx.usageError(usage);
     var format = (0, _sharedts.formatOf)(values);
-    (0, _sharedts.runSql)(ctx.resolveConfig(values.config), sql, params, format, 'ad-hoc query');
+    (0, _sharedts.runSql)(ctx.resolveConfig(values.config), sql, params, format, 'ad-hoc statement', values.preset);
 };
-var _default = query;
+var _default = sqlCmd;
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/sql.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst sqlCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.sql}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...FORMAT, ...CONFIG, preset: { type: 'string' } });\n  const [sql, ...params] = positionals;\n  if (!sql) ctx.usageError(usage);\n  const format = formatOf(values);\n  runSql(ctx.resolveConfig(values.config as string | undefined), sql, params, format, 'ad-hoc statement', values.preset as string | undefined);\n};\nexport default sqlCmd;\n"],"names":["sqlCmd","ctx","usage","USAGE","name","sql","parse","argv","FORMAT","CONFIG","preset","type","values","positionals","params","usageError","format","formatOf","runSql","resolveConfig","config"],"mappings":";;;;+BAYA;;;eAAA;;;uBAZsB;wBACkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxD,IAAMA,SAAkB,gBAACC;IACvB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACE,GAAG;IAC7C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,gBAAM,EAAKC,gBAAM;QAAEC,QAAQ;YAAEC,MAAM;QAAS;SAAhGC,SAAwBN,OAAxBM,QAAQC,cAAgBP,OAAhBO;IAChB,IAAyBA,yBAAAA,cAAlBR,MAAkBQ,iBAAb,AAAGC,SAAUD,mBAAb;IACZ,IAAI,CAACR,KAAKJ,IAAIc,UAAU,CAACb;IACzB,IAAMc,SAASC,IAAAA,kBAAQ,EAACL;IACxBM,IAAAA,gBAAM,EAACjB,IAAIkB,aAAa,CAACP,OAAOQ,MAAM,GAAyBf,KAAKS,QAAQE,QAAQ,oBAAoBJ,OAAOF,MAAM;AACvH;IACA,WAAeV"}

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

@@ -1,3 +1,4 @@
 import type { Command } from './types.js';
+export declare function redactUrl(url: string): string;
 declare const status: Command;
 export default status;

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

@@ -1,3 +1,4 @@
 import type { Command } from './types.js';
+export declare function redactUrl(url: string): string;
 declare const status: Command;
 export default status;

package/dist/cjs/cli/status.js

@@ -2,15 +2,25 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
-    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 default () {
         return _default;
+    },
+    get redactUrl () {
+        return redactUrl;
     }
 });
+var _nodepath = require("node:path");
 var _commandsts = require("../commands.js");
 var _configts = require("../config.js");
 var _dbts = require("../db.js");
+var _embedts = require("../features/embed.js");
 var _outputts = require("../output.js");
 var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
@@ -42,8 +52,12 @@ function _object_spread(target) {
     }
     return target;
 }
+// status names what you cannot read off the config file: locations sense chose, values it
+// derived, state it stored. Config content is not echoed -- the config line says which file to
+// read, and duplicating its globs here would create two places that disagree after an edit.
+// The exception is the embed block's url and key, whose effect is remote and otherwise invisible.
 // Vectors are computed on the first semantic query, not at reconcile, so a tree can have a
-// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on
+// semantic-on preset with nothing embedded yet -- reported here because a fast reconcile on
 // such a tree otherwise reads as "the feature isn't on".
 function vectorState(db) {
     try {
@@ -53,7 +67,23 @@ function vectorState(db) {
         return null;
     }
 }
+function parseErrorCount(db) {
+    var row = db.prepare('SELECT COUNT(*) AS n FROM frontmatter WHERE "_parse_error" IS NOT NULL').get();
+    return row.n;
+}
+function redactUrl(url) {
+    try {
+        var parsed = new URL(url);
+        if (!parsed.username && !parsed.password) return url;
+        parsed.username = '';
+        parsed.password = '';
+        return "".concat(parsed.toString().replace(/\/$/, ''), " (credentials redacted)");
+    } catch (unused) {
+        return url;
+    }
+}
 var status = function status(ctx) {
+    var _process_env_e_key, _cfg_migratedFrom, _cfg_unknownKeys, _cfg_queries;
     var values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.status), _object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG)).values;
     var format = (0, _sharedts.formatOf)(values);
     var cfg = ctx.resolveConfig(values.config);
@@ -61,6 +91,7 @@ var status = function status(ctx) {
     (0, _sharedts.printWarnings)(warnings);
     var features = (0, _configts.featureStates)(cfg);
     var e = (0, _configts.embedConfig)(cfg);
+    var hasModel = e ? (0, _embedts.modelPresent)(cfg) : false;
     var vectors = e ? vectorState(db) : null;
     var presets = (0, _commandsts.presetCoverage)(db, cfg);
     var heartbeat = (0, _dbts.getMeta)(db, 'watch_heartbeat');
@@ -68,26 +99,62 @@ var status = function status(ctx) {
     // transaction for, floored at 30s -- read back from the connection rather than
     // recomputed here, so this always reports what open() actually set.
     var busyTimeoutMs = db.prepare('PRAGMA busy_timeout').get().timeout;
+    // The env var holds the token; only its name and whether it is set are ever reported.
+    var keyEnv = (e === null || e === void 0 ? void 0 : e.key) ? {
+        name: e.key,
+        set: ((_process_env_e_key = process.env[e.key]) !== null && _process_env_e_key !== void 0 ? _process_env_e_key : '') !== ''
+    } : null;
     var result = {
+        config: cfg.configPath,
+        configVersion: _configts.SUPPORTED_CONFIG_VERSION,
+        migratedFrom: (_cfg_migratedFrom = cfg.migratedFrom) !== null && _cfg_migratedFrom !== void 0 ? _cfg_migratedFrom : null,
+        unknownConfigKeys: (_cfg_unknownKeys = cfg.unknownKeys) !== null && _cfg_unknownKeys !== void 0 ? _cfg_unknownKeys : null,
+        tree: cfg.baseDir,
+        cache: (0, _nodepath.dirname)(dbPath),
         db: dbPath,
+        cacheSchema: _dbts.SCHEMA_VERSION,
         docs: (0, _dbts.docCount)(db),
+        unparseableFrontmatter: parseErrorCount(db),
         features: features.on,
         featuresOff: features.off,
         embed: e ? _object_spread({
             type: e.type,
-            model: e.model
+            model: e.model,
+            dir: e.type === 'static' ? (0, _embedts.modelDir)(e.model) : null,
+            url: e.url ? redactUrl(e.url) : null,
+            keyEnv: keyEnv,
+            downloaded: hasModel
         }, vectors !== null && vectors !== void 0 ? vectors : {}) : null,
         presets: presets,
+        queries: Object.keys((_cfg_queries = cfg.queries) !== null && _cfg_queries !== void 0 ? _cfg_queries : {}).length,
+        watcherPid: (0, _dbts.getMeta)(db, 'watch_pid'),
         watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,
         busyTimeoutMs: busyTimeoutMs
     };
     if (format === 'json') {
         console.log(JSON.stringify(result, null, 2));
     } else {
-        console.log("db: ".concat(result.db));
-        console.log("docs: ".concat(result.docs));
+        var migrated = cfg.migratedFrom !== undefined ? ", migrated from v".concat(cfg.migratedFrom, " on this run") : '';
+        console.log("config:   ".concat(result.config, " (v").concat(_configts.SUPPORTED_CONFIG_VERSION).concat(migrated, ")"));
+        // A load-time stderr warning has scrolled away by the time anyone looks here.
+        if (cfg.unknownKeys) console.log("          unknown keys, ignored: ".concat(cfg.unknownKeys.join(', ')));
+        console.log("tree:     ".concat(result.tree));
+        console.log("cache:    ".concat(result.cache, " (schema ").concat(_dbts.SCHEMA_VERSION, "; delete this directory to reset)"));
+        console.log("docs:     ".concat(result.docs).concat(result.unparseableFrontmatter > 0 ? "  (".concat(result.unparseableFrontmatter, " with unparseable frontmatter: WHERE _parse_error IS NOT NULL)") : ''));
+        console.log('');
         console.log((0, _outputts.featuresLine)(features));
-        if (e) console.log("embed: ".concat(e.type, " ").concat(e.model).concat(vectors ? " (vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending — embedded on the first semantic search)") : ''));
+        // One authoritative block, off states included: an absent model reads as a degraded search,
+        // not as an empty corpus.
+        if (!e) console.log('embed:    off (no preset asks for vectors)');
+        else {
+            console.log("embed:    ".concat(e.type, " ").concat(e.model));
+            if (e.type === 'static') console.log("          model:   ".concat((0, _embedts.modelDir)(e.model), " (").concat(hasModel ? 'present' : "missing, ".concat((0, _embedts.isDownloadable)(e.model) ? "run `".concat(ctx.name, " download`") : "no ".concat(_embedts.MODEL_FILENAMES, " in that directory")), ")"));
+            if (e.url) console.log("          url:     ".concat(redactUrl(e.url)));
+            if (keyEnv) console.log("          key:     env ".concat(keyEnv.name, " (").concat(keyEnv.set ? 'set' : 'NOT SET', ")"));
+            if (!hasModel) console.log('          vectors: off until the model is present; search runs on words and links');
+            else if (vectors) console.log("          vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending (embedded on the first semantic search)"));
+        }
+        console.log('');
         var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
             for(var _iterator = (0, _outputts.presetsLines)(presets)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
@@ -108,8 +175,11 @@ var status = function status(ctx) {
                 }
             }
         }
-        console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : "watcher: last heartbeat ".concat(result.watcherHeartbeatSecondsAgo, "s ago"));
-        console.log("busy_timeout: ".concat(result.busyTimeoutMs, "ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)"));
+        console.log('');
+        console.log("queries:  ".concat(result.queries, " saved (").concat(ctx.name, " --list)"));
+        var pid = result.watcherPid ? "pid ".concat(result.watcherPid, ", ") : '';
+        console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher:  none' : "watcher:  ".concat(pid, "last heartbeat ").concat(result.watcherHeartbeatSecondsAgo, "s ago"));
+        console.log("sqlite:   busy_timeout ".concat(result.busyTimeoutMs, "ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)"));
     }
     db.close();
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on\n// such a tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.status}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined);\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const presets = presetCoverage(db, cfg);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    presets,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    console.log(featuresLine(features));\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on the first semantic search)` : ''}`);\n    for (const line of presetsLines(presets)) console.log(line);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`busy_timeout: ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","values","parse","argv","USAGE","name","FORMAT","CONFIG","format","formatOf","cfg","resolveConfig","config","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","watcherHeartbeatSecondsAgo","Math","round","Date","now","console","log","JSON","stringify","featuresLine","embedded","pending","presetsLines","line","close"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { dirname } from 'node:path';\nimport { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates, SUPPORTED_CONFIG_VERSION } from '../config.ts';\nimport { docCount, getMeta, open, SCHEMA_VERSION } from '../db.ts';\nimport { isDownloadable, MODEL_FILENAMES, modelDir, modelPresent } from '../features/embed.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// status names what you cannot read off the config file: locations sense chose, values it\n// derived, state it stored. Config content is not echoed -- the config line says which file to\n// read, and duplicating its globs here would create two places that disagree after an edit.\n// The exception is the embed block's url and key, whose effect is remote and otherwise invisible.\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast reconcile on\n// such a tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nfunction parseErrorCount(db: ReturnType<typeof open>['db']): number {\n  const row = db.prepare(`SELECT COUNT(*) AS n FROM frontmatter WHERE \"_parse_error\" IS NOT NULL`).get() as { n: number };\n  return row.n;\n}\n\n// A URL can carry credentials in its userinfo (https://user:pass@host/v1). status output gets\n// pasted into issues and transcripts, so it is always safe to paste.\nexport function redactUrl(url: string): string {\n  try {\n    const parsed = new URL(url);\n    if (!parsed.username && !parsed.password) return url;\n    parsed.username = '';\n    parsed.password = '';\n    return `${parsed.toString().replace(/\\/$/, '')} (credentials redacted)`;\n  } catch {\n    return url;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.status}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined);\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const hasModel = e ? modelPresent(cfg) : false;\n  const vectors = e ? vectorState(db) : null;\n  const presets = presetCoverage(db, cfg);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  // The env var holds the token; only its name and whether it is set are ever reported.\n  const keyEnv = e?.key ? { name: e.key, set: (process.env[e.key] ?? '') !== '' } : null;\n  const result = {\n    config: cfg.configPath,\n    configVersion: SUPPORTED_CONFIG_VERSION,\n    migratedFrom: cfg.migratedFrom ?? null,\n    unknownConfigKeys: cfg.unknownKeys ?? null,\n    tree: cfg.baseDir,\n    cache: dirname(dbPath),\n    db: dbPath,\n    cacheSchema: SCHEMA_VERSION,\n    docs: docCount(db),\n    unparseableFrontmatter: parseErrorCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, dir: e.type === 'static' ? modelDir(e.model) : null, url: e.url ? redactUrl(e.url) : null, keyEnv, downloaded: hasModel, ...(vectors ?? {}) } : null,\n    presets,\n    queries: Object.keys(cfg.queries ?? {}).length,\n    watcherPid: getMeta(db, 'watch_pid'),\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    const migrated = cfg.migratedFrom !== undefined ? `, migrated from v${cfg.migratedFrom} on this run` : '';\n    console.log(`config:   ${result.config} (v${SUPPORTED_CONFIG_VERSION}${migrated})`);\n    // A load-time stderr warning has scrolled away by the time anyone looks here.\n    if (cfg.unknownKeys) console.log(`          unknown keys, ignored: ${cfg.unknownKeys.join(', ')}`);\n    console.log(`tree:     ${result.tree}`);\n    console.log(`cache:    ${result.cache} (schema ${SCHEMA_VERSION}; delete this directory to reset)`);\n    console.log(`docs:     ${result.docs}${result.unparseableFrontmatter > 0 ? `  (${result.unparseableFrontmatter} with unparseable frontmatter: WHERE _parse_error IS NOT NULL)` : ''}`);\n    console.log('');\n    console.log(featuresLine(features));\n    // One authoritative block, off states included: an absent model reads as a degraded search,\n    // not as an empty corpus.\n    if (!e) console.log('embed:    off (no preset asks for vectors)');\n    else {\n      console.log(`embed:    ${e.type} ${e.model}`);\n      if (e.type === 'static') console.log(`          model:   ${modelDir(e.model)} (${hasModel ? 'present' : `missing, ${isDownloadable(e.model) ? `run \\`${ctx.name} download\\`` : `no ${MODEL_FILENAMES} in that directory`}`})`);\n      if (e.url) console.log(`          url:     ${redactUrl(e.url)}`);\n      if (keyEnv) console.log(`          key:     env ${keyEnv.name} (${keyEnv.set ? 'set' : 'NOT SET'})`);\n      if (!hasModel) console.log('          vectors: off until the model is present; search runs on words and links');\n      else if (vectors) console.log(`          vectors: ${vectors.embedded} embedded, ${vectors.pending} pending (embedded on the first semantic search)`);\n    }\n    console.log('');\n    for (const line of presetsLines(presets)) console.log(line);\n    console.log('');\n    console.log(`queries:  ${result.queries} saved (${ctx.name} --list)`);\n    const pid = result.watcherPid ? `pid ${result.watcherPid}, ` : '';\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher:  none' : `watcher:  ${pid}last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`sqlite:   busy_timeout ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["redactUrl","vectorState","db","row","prepare","get","parseErrorCount","n","url","parsed","URL","username","password","toString","replace","status","ctx","process","cfg","values","parse","argv","USAGE","name","FORMAT","CONFIG","format","formatOf","resolveConfig","config","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","hasModel","modelPresent","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","keyEnv","key","set","env","result","configPath","configVersion","SUPPORTED_CONFIG_VERSION","migratedFrom","unknownConfigKeys","unknownKeys","tree","baseDir","cache","dirname","cacheSchema","SCHEMA_VERSION","docs","docCount","unparseableFrontmatter","on","featuresOff","off","embed","type","model","dir","modelDir","downloaded","queries","Object","keys","length","watcherPid","watcherHeartbeatSecondsAgo","Math","round","Date","now","console","log","JSON","stringify","migrated","undefined","join","featuresLine","isDownloadable","MODEL_FILENAMES","embedded","pending","presetsLines","line","pid","close"],"mappings":"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"}

package/dist/cjs/cli.js

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

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, 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(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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"}
+{"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 lazy-load from src/cli/, so nothing heavy is imported\n// here. Flags parse per command -- this file handles only --version/--help/--list/--config.\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(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          // Every entry names its verb, so --list can label both kinds rather than only\n          // marking the exception.\n          console.log(`${queryName}  (${'search' in queries[queryName] ? 'search' : 'sql'})`);\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  // Breaking renames get one release of a pointer instead of an \"unknown\" error: find ->\n  // search, and query -> sql (which took its name back from the search sense of \"query\").\n  const RENAMED: Record<string, string> = { find: 'search', query: 'sql' };\n  if (RENAMED[first]) {\n    console.error(`${name}: ${first} is now ${RENAMED[first]}`);\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","RENAMED","ctx","err","startsWith","parseArgs","args","options","type","default","short","help","list","config","allowPositionals","error","message","process","exit","log","keys","sort","find","query","slice","resolveConfig","usageError","COMMANDS"],"mappings":"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"}

package/dist/cjs/commands.d.cts

@@ -1,18 +1,21 @@
 import type { DatabaseSync } from 'node:sqlite';
-import type { FeatureName, ResolvedConfig } from './config.js';
+import type { FeatureName, ResolvedConfig, SearchOverrides } from './config.js';
 import type { Row } from './output.js';
 export interface SearchOptions {
     k?: number;
     where?: string;
     preset?: string;
     include?: string[];
-    semantic?: boolean;
+    exclude?: string[];
+    noExclude?: boolean;
 }
 export declare function search(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export declare function scopedPaths(db: DatabaseSync, cfg: ResolvedConfig, overrides: SearchOverrides): Set<string>;
 export interface PresetCoverage {
     name: string;
     files: number;
     embedded: number;
+    semantic: boolean;
 }
 export declare function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[];
 export interface TreeMap {
@@ -30,11 +33,13 @@ export interface TreeMap {
     hubs: Row[];
     recent: Row[];
 }
-export declare function mapTree(db: DatabaseSync, cfg: ResolvedConfig): TreeMap;
+export declare function mapTree(db: DatabaseSync, cfg: ResolvedConfig, overrides?: SearchOverrides): TreeMap;
+export declare function resolveNote(paths: string[], arg: string): string;
 export interface Peek {
     path: string;
     tokens: number;
     frontmatter: Row;
+    parseError: string | null;
     sections: Row[];
     outbound: string[];
     backlinks: string[];
@@ -45,4 +50,8 @@ export interface Peek {
     unresolvedTotal: number;
     off: FeatureName[];
 }
-export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string): Peek;
+export declare function peek(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Peek;
+export declare function relatedNotes(db: DatabaseSync, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{
+    path: string;
+    similarity: number;
+}>>;