sensemaking 0.8.0 → 0.9.0

package/README.md

@@ -1,7 +1,8 @@
 # sensemaking
 
-SQL over a tree of markdown notes: filter by frontmatter, search the prose, follow the links,
-read the structure. A CLI that starts, answers, and exits — no server, no build step.
+Query and search a tree of markdown notes: SQL over frontmatter and links, ranked search over
+the prose — words, links, and meaning fused. A CLI that starts, answers, and exits — no
+server, no build step.
 
 ## Problem
 
@@ -22,7 +23,7 @@ cd your-notes && sense init
 
 ```bash
 sense map                                        # orient: fields, hub notes, recent changes
-sense find "revenue OR earnings" --k 10          # locate: ranked references with excerpts
+sense search "revenue OR earnings" --k 10        # locate: words + links + meaning, one ranked list
 sense peek notes/q3-report.md                    # structure: outline + links, before reading
 sense query "SELECT path FROM frontmatter WHERE has(tags, ?)" urgent
 ```
@@ -60,62 +61,65 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 | command | does |
 |---|---|
 | `map` | doc count, frontmatter field coverage, top hubs by link rank, recent changes |
-| `find "<terms>" [--where "<sql>"] [--k n] [--semantic]` | BM25 + link-graph expansion, fused; `via` marks each row `match`, `link`, or `match+link` |
+| `search "<text>" [--preset name] [--include glob] [--where "<sql>"] [--k n] [--lexical]` | words + links + vectors, one fused ranked list; `via` labels each row's evidence |
 | `peek <path>` | frontmatter + heading outline (`[L143-162, ~380t]`) + links both ways — first 20 per list, each with its total; the `links` table has the rest |
 | `query "<sql>" [params...]` | ad-hoc SQL over all the tables; `?` binds positional args |
 | `<name> [params...]` | run a query saved in the config; `--list` names them |
 | `init` | write a starter `sense.config.json` |
-| `status` | index location, doc count, feature state, watcher heartbeat |
-| `check` | prepare and run the saved queries, so a broken one fails here instead of mid-task |
+| `status` | index location, doc count, per-preset coverage, watcher heartbeat |
+| `check` | run every saved query and search, so a broken one fails here instead of mid-task |
 | `rebuild` | delete the cache and re-crawl |
 | `watch` | keep the index warm in the background (optional; see [WATCH.md](WATCH.md)) |
 
-`find` seeds a personalized-PageRank walk with the BM25 matches, so a note that never contains
-the terms but is linked from ones that do still surfaces. Terms pass verbatim to FTS5 `MATCH`
-(bare words AND-join; operators are yours to write). `--where` takes any SQL condition against
-frontmatter alias `f`. On trees with the `embed` feature, `--semantic` additionally expands by
-meaning — explicit per query, never silent; rows it adds are labeled `via: vector` and carry
-`similarity` (cosine against the best-matching chunk). A `lines` column points at the section
-that earned a row — a direct read range. `--format json` on any command returns structured
-output; `--version` and `--help` do what they say.
+`search` runs one text through every engine its scope has — FTS5 word match (BM25-ranked,
+bare words AND-join, operators are yours), a personalized-PageRank walk over the link graph,
+and vector similarity — fused into one list. `via` labels each row's evidence (`match`,
+`link`, `vector`, combinations); `similarity` is the cosine against the best-matching chunk;
+`lines` points at the section that earned the row — a direct read range. Rows that only
+vectors produced are the "these words aren't in the tree, this is what's near in meaning"
+signal. `--preset` picks a named settings bundle from the config, `--lexical` skips vectors
+for one command, `--where` filters on frontmatter. `--format json` on any command returns
+structured output; `--version` and `--help` do what they say.
 
 ## Config
 
 `sense init` writes `sense.config.json`; discovery walks up from cwd like git
-(`--config <path>` overrides). Name reusable queries and run them as `sense <name> [params...]`:
+(`--config <path>` overrides). Three keys: **presets** (named, self-contained setting
+bundles), **queries** (saved commands), and the version.
 
 ```json
 {
   "$schema": "https://unpkg.com/sensemaking/schema.json",
-  "version": 2,
-  "scan": { "include": ["**/*.md"] },
-  "features": { "links": true, "sections": true, "rank": true },
-  "defaults": { "find": { "where": "f.type != 'generated'" } },
+  "version": 3,
+  "presets": {
+    "default": { "include": ["**/*.md"], "k": 10 },
+    "raw":     { "include": ["raw/**/*.md"], "k": 5, "semantic": false }
+  },
   "queries": {
     "dead-links": "SELECT src, target FROM links WHERE dst IS NULL",
     "by-tag": "SELECT path, title FROM frontmatter WHERE has(tags, ?) ORDER BY path",
-    "hot": { "find": "pricing OR billing", "k": 20 }
-  },
-  "checks": { "dead-links": "empty" }
+    "hot": { "search": "pricing OR billing", "preset": "raw" }
+  }
 }
 ```
 
-A query entry is a SQL string, or a saved `find` with its settings baked in — `sense hot`
-then needs no flags. `defaults.find.where` scopes `find` tree-wide (an explicit `--where`
-replaces it, so `--where "1=1"` always reaches everything). `checks` turns a saved query
-into an assertion: `sense check` fails when a query marked `empty` returns rows. Every key
-is documented in [schema.json](schema.json), which editors read for autocomplete.
+A preset bundles `include`/`exclude` globs (which files), `k` (result count), `semantic`
+(vectors, on unless `false`), and `where` (a standing SQL filter). Bare commands use
+`default`; `--preset` names another; flags override single fields. **Indexing derives from
+the presets**: a file is indexed if any preset includes it, and embedded if any covering
+preset has semantic on — so a `semantic: false` preset's files cost no vectors, and
+`status` shows each preset's coverage. Editing a preset rebuilds the cache and says which
+preset caused it.
 
-Features toggle independently; disabling one degrades its command instead of failing it (`find`
-goes BM25-only without `links`, `map` drops hubs without `rank`, `peek` drops the outline
-without `sections`). Toggling rebuilds the cache. Older config versions auto-migrate on load,
-noted on stderr.
+A query entry is a SQL string (`?` binds positional args) or a saved search with its
+settings baked in — `sense hot` needs no flags. `sense check` runs them all, so a typo'd
+column fails at check time instead of mid-task. Older config versions auto-migrate on
+load, noted on stderr.
 
-`embed` is opt-in — the only feature off by default, since most trees don't need vectors.
-`"embed": true` uses the built-in static model (downloaded to `~/.cache/sensemaking` on first
-use, never in the package), or `{ "model", "type": "static"|"api", "url", "key" }` points at any Model2Vec model,
-local path, or OpenAI-compatible endpoint (Ollama, LM Studio, hosted). With it on, vectors stay
-fresh at reconcile and `find --semantic` uses them; default `find` results are unchanged.
+Vectors use the built-in static model (downloaded to `~/.cache/sensemaking` on first use,
+never in the package); an optional top-level `"embed": { "model", "type", "url", "key" }`
+block points at any Model2Vec model, local path, or OpenAI-compatible endpoint (Ollama,
+LM Studio, hosted). Embedding happens on the first semantic search, with progress.
 
 `has(field, value)` is the one custom SQL function: array membership on JSON-array fields,
 substring on strings, false on missing keys. Frontmatter parsing is lenient — syntax errors are
@@ -159,6 +163,10 @@ features, frontmatter conventions, and note size are decisions with consequences
   agent-maintained wiki navigated by an `index.md` and links, which he notes needs real search
   infrastructure past a few hundred pages. `sense map` derives that index from the notes instead of
   maintaining it; `find` is the hybrid local search it calls for.
+- Agent memory patterns — llm-wiki's raw/wiki split, Claude Code's dreaming-style nightly
+  consolidation — are trees of small notes with metadata, links, and layers of differing
+  authority. sense is the query layer such patterns need (filter by metadata and age, scope
+  by layer, surface near-duplicates semantically), not an implementation of any one of them.
 
 ## Alternatives
 
@@ -166,9 +174,10 @@ features, frontmatter conventions, and note size are decisions with consequences
   query it headless.
 - **Index-on-build tools (MarkdownDB)** — query a snapshot; `sense` reconciles on every query.
 - **Note CLIs (zk)** — fixed schema; `sense` filters on arbitrary frontmatter.
-- **RAG / vector stores** — similarity can't express `WHERE status = 'active'`. Here vectors are
-  the optional `embed` feature: same SQLite file, filters compose, expansion is explicit per
-  query (`find --semantic`) and labeled — no second store, no daemon, no native builds.
+- **RAG / vector stores** — similarity can't express `WHERE status = 'active'`. Here vectors
+  are one signal inside `search`: same SQLite file, filters compose, every row labels its
+  evidence (`via`), and a preset turns vectors off per layer of the tree — no second store,
+  no daemon, no native builds.
 
 Dependencies: [yaml](https://github.com/eemeli/yaml),
 [remove-markdown](https://github.com/zuchka/remove-markdown),

package/dist/cjs/cli/check.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _commandsts = require("../commands.js");
-var _configts = require("../config.js");
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
 var _sharedts = require("./shared.js");
@@ -80,6 +79,10 @@ function _non_iterable_rest() {
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _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);
@@ -192,14 +195,14 @@ function _ts_generator(thisArg, body) {
 // column reading as "nothing tagged yet" for hours. Preparing each query catches syntax and
 // unknown-column errors without executing it; queries that take no parameters are also run
 // for a row count. Parameterised queries are validated but not counted: inventing arguments
-// would report a count for a query nobody ran. Saved finds run lexically with k=1 -- that
-// validates the `where` fragment and the FTS5 terms against the real schema, the same
-// breakage class prepare() catches for SQL strings -- but never semantically (a --semantic
-// pass costs model time and, on api trees, network); `semantic: true` is only checked for
-// a features.embed to run against.
+// would report a count for a query nobody ran. Saved searches run lexically with k=1 -- that
+// validates the `where` fragment, the FTS5 terms, and the `preset` name (resolveSearch throws
+// on an unknown one, the same breakage class prepare() catches for SQL strings) -- but never
+// semantically (a semantic pass costs model time and, on api trees, network). Whether a
+// result being empty is good or bad is the reader's judgment -- there is no assertion path.
 var check = function check(ctx) {
     return _async_to_generator(function() {
-        var _cfg_queries, cfg, _open, db, warnings, rows, failed, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, entry, _sql_match, _cfg_checks, count, err, sql, params, expectEmpty, statement, count1, err1;
+        var _cfg_queries, cfg, _open, db, warnings, rows, failed, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, entry, _sql_match, count, err, sql, params, statement, count1, err1;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -225,23 +228,10 @@ var check = function check(ctx) {
                         9
                     ];
                     _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], entry = _step_value[1];
-                    if (!(typeof entry !== 'string')) return [
+                    if (!((typeof entry === "undefined" ? "undefined" : _type_of(entry)) === 'object' && entry !== null && 'search' in entry)) return [
                         3,
                         7
                     ];
-                    if (entry.semantic && !(0, _configts.featureEnabled)(cfg, 'embed')) {
-                        failed++;
-                        rows.push({
-                            query: name,
-                            params: '—',
-                            rows: '—',
-                            status: 'FAILED: semantic requested but features.embed is off'
-                        });
-                        return [
-                            3,
-                            8
-                        ];
-                    }
                     _state.label = 3;
                 case 3:
                     _state.trys.push([
@@ -252,9 +242,12 @@ var check = function check(ctx) {
                     ]);
                     return [
                         4,
-                        (0, _commandsts.find)(db, cfg, entry.find, {
+                        (0, _commandsts.search)(db, cfg, entry.search, {
                             k: 1,
-                            where: entry.where
+                            where: entry.where,
+                            preset: entry.preset,
+                            include: entry.include,
+                            semantic: false
                         })
                     ];
                 case 4:
@@ -263,7 +256,7 @@ var check = function check(ctx) {
                         query: name,
                         params: '—',
                         rows: '—',
-                        status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : entry.semantic ? 'ok (lexical probe; semantic not run)' : 'ok (probe run with k=1)'
+                        status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : 'ok (probe run with k=1)'
                     });
                     return [
                         3,
@@ -288,9 +281,8 @@ var check = function check(ctx) {
                         8
                     ];
                 case 7:
-                    sql = entry;
+                    sql = typeof entry === 'string' ? entry : entry.sql;
                     params = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
-                    expectEmpty = ((_cfg_checks = cfg.checks) === null || _cfg_checks === void 0 ? void 0 : _cfg_checks[name]) === 'empty';
                     try {
                         statement = db.prepare(sql);
                         if (params > 0) {
@@ -306,23 +298,12 @@ var check = function check(ctx) {
                             ];
                         }
                         count1 = statement.all().length;
-                        if (expectEmpty) {
-                            // An invariant query: rows are violations, so 0 is the pass, anything else fails.
-                            if (count1 > 0) failed++;
-                            rows.push({
-                                query: name,
-                                params: params,
-                                rows: count1,
-                                status: count1 === 0 ? 'ok (empty, as asserted)' : "FAILED: expected empty, returned ".concat(count1, " row(s)")
-                            });
-                        } else {
-                            rows.push({
-                                query: name,
-                                params: params,
-                                rows: count1,
-                                status: count1 === 0 ? 'ok, but returns 0 rows' : 'ok'
-                            });
-                        }
+                        rows.push({
+                            query: name,
+                            params: params,
+                            rows: count1,
+                            status: count1 === 0 ? 'ok, but returns 0 rows' : 'ok'
+                        });
                     } catch (err) {
                         failed++;
                         rows.push({

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/check.ts"],"sourcesContent":["import { find } from '../commands.ts';\nimport { featureEnabled } from '../config.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 finds run lexically with k=1 -- that\n// validates the `where` fragment and the FTS5 terms against the real schema, the same\n// breakage class prepare() catches for SQL strings -- but never semantically (a --semantic\n// pass costs model time and, on api trees, network); `semantic: true` is only checked for\n// a features.embed to run against.\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 !== 'string') {\n      if (entry.semantic && !featureEnabled(cfg, 'embed')) {\n        failed++;\n        rows.push({ query: name, params: '—', rows: '—', status: 'FAILED: semantic requested but features.embed is off' });\n        continue;\n      }\n      try {\n        const count = (await find(db, cfg, entry.find, { k: 1, where: entry.where })).length;\n        rows.push({ query: name, params: '—', rows: '—', status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : entry.semantic ? 'ok (lexical probe; semantic not run)' : '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 = entry;\n    const params = (sql.match(/\\?/g) ?? []).length;\n    const expectEmpty = cfg.checks?.[name] === 'empty';\n    try {\n      const statement = db.prepare(sql);\n      if (params > 0) {\n        rows.push({ query: name, params, rows: '—', status: 'ok (not run: needs parameters)' });\n        continue;\n      }\n      const count = (statement.all() as unknown[]).length;\n      if (expectEmpty) {\n        // An invariant query: rows are violations, so 0 is the pass, anything else fails.\n        if (count > 0) failed++;\n        rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok (empty, as asserted)' : `FAILED: expected empty, returned ${count} row(s)` });\n      } else {\n        rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\n      }\n    } catch (err) {\n      failed++;\n      rows.push({ query: name, params, rows: '—', status: `FAILED: ${(err as Error).message}` });\n    }\n  }\n\n  db.close();\n  if (rows.length === 0) {\n    console.log('no saved queries in config');\n    return;\n  }\n  printRows(rows, ctx.format);\n  if (failed > 0) process.exit(1);\n};\nexport default check;\n"],"names":["check","ctx","cfg","open","db","warnings","rows","failed","name","entry","sql","count","err","params","expectEmpty","statement","resolveConfig","printWarnings","Object","entries","queries","semantic","featureEnabled","push","query","status","find","k","where","length","message","match","checks","prepare","all","close","console","log","printRows","format","process","exit"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/check.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// A saved query that returns zero rows looks identical to a true empty result, so a broken\n// one can sit unnoticed -- one field report had `WHERE flag = 'true'` against a numeric\n// column reading as \"nothing tagged yet\" for hours. Preparing each query catches syntax and\n// unknown-column errors without executing it; queries that take no parameters are also run\n// for a row count. Parameterised queries are validated but not counted: inventing arguments\n// would report a count for a query nobody ran. Saved searches run lexically with k=1 -- that\n// validates the `where` fragment, the FTS5 terms, and the `preset` name (resolveSearch throws\n// on an unknown one, the same breakage class prepare() catches for SQL strings) -- but never\n// semantically (a semantic pass costs model time and, on api trees, network). Whether a\n// result being empty is good or bad is the reader's judgment -- there is no assertion path.\nconst check: Command = async (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const rows: Row[] = [];\n  let failed = 0;\n  for (const [name, entry] of Object.entries(cfg.queries ?? {})) {\n    if (typeof entry === 'object' && entry !== null && 'search' in entry) {\n      try {\n        const count = (await search(db, cfg, entry.search, { k: 1, where: entry.where, preset: entry.preset, include: entry.include, semantic: false })).length;\n        rows.push({ query: name, params: '—', rows: '—', status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : 'ok (probe run with k=1)' });\n      } catch (err) {\n        failed++;\n        rows.push({ query: name, params: '—', rows: '—', status: `FAILED: ${(err as Error).message}` });\n      }\n      continue;\n    }\n    const sql = typeof entry === 'string' ? entry : entry.sql;\n    const params = (sql.match(/\\?/g) ?? []).length;\n    try {\n      const statement = db.prepare(sql);\n      if (params > 0) {\n        rows.push({ query: name, params, rows: '—', status: 'ok (not run: needs parameters)' });\n        continue;\n      }\n      const count = (statement.all() as unknown[]).length;\n      rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\n    } catch (err) {\n      failed++;\n      rows.push({ query: name, params, rows: '—', status: `FAILED: ${(err as Error).message}` });\n    }\n  }\n\n  db.close();\n  if (rows.length === 0) {\n    console.log('no saved queries in config');\n    return;\n  }\n  printRows(rows, ctx.format);\n  if (failed > 0) process.exit(1);\n};\nexport default check;\n"],"names":["check","ctx","cfg","open","db","warnings","rows","failed","name","entry","sql","count","err","params","statement","resolveConfig","printWarnings","Object","entries","queries","search","k","where","preset","include","semantic","length","push","query","status","message","match","prepare","all","close","console","log","printRows","format","process","exit"],"mappings":"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"}

package/dist/cjs/cli/index.js

@@ -80,9 +80,9 @@ var COMMANDS = {
             return /*#__PURE__*/ _interop_require_wildcard(require("./query.js"));
         });
     },
-    find: function find() {
+    search: function search() {
         return Promise.resolve().then(function() {
-            return /*#__PURE__*/ _interop_require_wildcard(require("./find.js"));
+            return /*#__PURE__*/ _interop_require_wildcard(require("./search.js"));
         });
     },
     map: function map() {

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

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

package/dist/cjs/cli/named.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 Object.defineProperty(exports, // Fallback when the first positional is not a command: a named query from config, either a
-// SQL string (run as-is) or a saved find (run through the `find` command's own machinery).
+// SQL string (run as-is) or a saved search (run through the `search` command's own machinery).
 "default", {
     enumerable: true,
     get: function() {
@@ -143,7 +143,7 @@ function _ts_generator(thisArg, body) {
 }
 function named(ctx, queryName, params) {
     return _async_to_generator(function() {
-        var _parseK, _ctx_values_where, cfg, entry, k, where, semantic;
+        var _parseK, _ctx_values_where, _ctx_values_preset, _ctx_values_include, cfg, entry, k, where, preset, include, semantic;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -160,15 +160,23 @@ function named(ctx, queryName, params) {
                             2
                         ];
                     }
-                    // A saved find's terms are fixed in config; there is nowhere for a positional to bind.
+                    if ('sql' in entry) {
+                        (0, _sharedts.runSql)(cfg, entry.sql, params, ctx.format, 'query "'.concat(queryName, '"'));
+                        return [
+                            2
+                        ];
+                    }
+                    // A saved search's text is fixed in config; there is nowhere for a positional to bind.
                     if (params.length > 0) {
-                        ctx.usageError('"'.concat(queryName, '" is a saved find and takes no positional parameters; edit its "find" in sense.config.json, or use "').concat(ctx.name, ' find" directly'));
+                        ctx.usageError('"'.concat(queryName, '" is a saved search and takes no positional parameters; edit its "search" in sense.config.json, or use "').concat(ctx.name, ' search" directly'));
                     }
                     k = (_parseK = (0, _sharedts.parseK)(ctx)) !== null && _parseK !== void 0 ? _parseK : entry.k;
                     where = (_ctx_values_where = ctx.values.where) !== null && _ctx_values_where !== void 0 ? _ctx_values_where : entry.where;
-                    // --semantic upgrades a saved find the same way --where/--k override; absent means the
-                    // saved value (the flag has no default, so absent is distinguishable from false).
-                    semantic = ctx.values.semantic === true || entry.semantic;
+                    preset = (_ctx_values_preset = ctx.values.preset) !== null && _ctx_values_preset !== void 0 ? _ctx_values_preset : entry.preset;
+                    include = (_ctx_values_include = ctx.values.include) !== null && _ctx_values_include !== void 0 ? _ctx_values_include : entry.include;
+                    // --lexical upgrades a saved search's semantic behavior the same way --where/--k
+                    // override; absent means the saved value (the flag has no default false override).
+                    semantic = ctx.values.lexical ? false : entry.semantic;
                     return [
                         4,
                         (0, _sharedts.withDb)(ctx, function(db, resolvedCfg) {
@@ -178,9 +186,11 @@ function named(ctx, queryName, params) {
                                         case 0:
                                             return [
                                                 4,
-                                                (0, _commandsts.find)(db, resolvedCfg, entry.find, {
+                                                (0, _commandsts.search)(db, resolvedCfg, entry.search, {
                                                     k: k,
                                                     where: where,
+                                                    preset: preset,
+                                                    include: include,
                                                     semantic: semantic
                                                 })
                                             ];

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { find } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { parseK, runSql, withDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a named query from config, either a\n// SQL string (run as-is) or a saved find (run through the `find` command's own machinery).\nexport default async function named(ctx: Ctx, queryName: string, params: string[]): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown query: \"${queryName}\"`);\n    console.error(`valid queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(2);\n  }\n\n  if (typeof entry === 'string') {\n    runSql(cfg, entry, params, ctx.format, `query \"${queryName}\"`);\n    return;\n  }\n\n  // A saved find's terms are fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved find and takes no positional parameters; edit its \"find\" in sense.config.json, or use \"${ctx.name} find\" directly`);\n  }\n  const k = parseK(ctx) ?? entry.k;\n  const where = ctx.values.where ?? entry.where;\n  // --semantic upgrades a saved find the same way --where/--k override; absent means the\n  // saved value (the flag has no default, so absent is distinguishable from false).\n  const semantic = ctx.values.semantic === true || entry.semantic;\n  await withDb(ctx, async (db, resolvedCfg) => printRows(await find(db, resolvedCfg, entry.find, { k, where, semantic }), ctx.format));\n}\n"],"names":["named","ctx","queryName","params","parseK","cfg","entry","k","where","semantic","resolveConfig","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","format","length","usageError","name","values","withDb","db","resolvedCfg","find","printRows"],"mappings":";;;;+BAKA,2FAA2F;AAC3F,2FAA2F;AAC3F;;;eAA8BA;;;0BAPT;wBACK;wBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKxB,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB,EAAEC,MAAgB;;YAkBrEC,SACIH,mBAlBRI,KACAC,OAgBAC,GACAC,OAGAC;;;;oBArBAJ,MAAMJ,IAAIS,aAAa;oBACvBJ,QAAQD,IAAIM,OAAO,CAACT,UAAU;oBACpC,IAAII,UAAUM,WAAW;wBACvBC,QAAQC,KAAK,CAAC,AAAC,mBAA4B,OAAVZ,WAAU;wBAC3CW,QAAQC,KAAK,CAAC,AAAC,kBAA4D,OAA3CC,OAAOC,IAAI,CAACX,IAAIM,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC;wBACrEC,QAAQC,IAAI,CAAC;oBACf;oBAEA,IAAI,OAAOd,UAAU,UAAU;wBAC7Be,IAAAA,gBAAM,EAAChB,KAAKC,OAAOH,QAAQF,IAAIqB,MAAM,EAAE,AAAC,UAAmB,OAAVpB,WAAU;wBAC3D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIC,OAAOoB,MAAM,GAAG,GAAG;wBACrBtB,IAAIuB,UAAU,CAAC,AAAC,IAAmHvB,OAAhHC,WAAU,wGAA+G,OAATD,IAAIwB,IAAI,EAAC;oBAC9I;oBACMlB,KAAIH,UAAAA,IAAAA,gBAAM,EAACH,kBAAPG,qBAAAA,UAAeE,MAAMC,CAAC;oBAC1BC,SAAQP,oBAAAA,IAAIyB,MAAM,CAAClB,KAAK,cAAhBP,+BAAAA,oBAAoBK,MAAME,KAAK;oBAC7C,uFAAuF;oBACvF,kFAAkF;oBAC5EC,WAAWR,IAAIyB,MAAM,CAACjB,QAAQ,KAAK,QAAQH,MAAMG,QAAQ;oBAC/D;;wBAAMkB,IAAAA,gBAAM,EAAC1B,KAAK,SAAO2B,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,gBAAI,EAACF,IAAIC,aAAavB,MAAMwB,IAAI,EAAE;oDAAEvB,GAAAA;oDAAGC,OAAAA;oDAAOC,UAAAA;gDAAS;;;;;gDAAvEsB,mBAAS;oDAAC;oDAAiE9B,IAAIqB,MAAM;;;;;;;;;oBAAlI;;;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { parseK, runSql, withDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a named query from config, either a\n// SQL string (run as-is) or a saved search (run through the `search` command's own machinery).\nexport default async function named(ctx: Ctx, queryName: string, params: string[]): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown query: \"${queryName}\"`);\n    console.error(`valid queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(2);\n  }\n\n  if (typeof entry === 'string') {\n    runSql(cfg, entry, params, ctx.format, `query \"${queryName}\"`);\n    return;\n  }\n  if ('sql' in entry) {\n    runSql(cfg, entry.sql, params, ctx.format, `query \"${queryName}\"`);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    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`);\n  }\n  const k = parseK(ctx) ?? entry.k;\n  const where = ctx.values.where ?? entry.where;\n  const preset = ctx.values.preset ?? entry.preset;\n  const include = ctx.values.include ?? entry.include;\n  // --lexical upgrades a saved search's semantic behavior the same way --where/--k\n  // override; absent means the saved value (the flag has no default false override).\n  const semantic = ctx.values.lexical ? false : entry.semantic;\n  await withDb(ctx, async (db, resolvedCfg) => printRows(await search(db, resolvedCfg, entry.search, { k, where, preset, include, semantic }), ctx.format));\n}\n"],"names":["named","ctx","queryName","params","parseK","cfg","entry","k","where","preset","include","semantic","resolveConfig","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","format","sql","length","usageError","name","values","lexical","withDb","db","resolvedCfg","search","printRows"],"mappings":";;;;+BAKA,2FAA2F;AAC3F,+FAA+F;AAC/F;;;eAA8BA;;;0BAPP;wBACG;wBACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKxB,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB,EAAEC,MAAgB;;YAsBrEC,SACIH,mBACCA,oBACCA,qBAxBVI,KACAC,OAoBAC,GACAC,OACAC,QACAC,SAGAC;;;;oBA3BAN,MAAMJ,IAAIW,aAAa;oBACvBN,QAAQD,IAAIQ,OAAO,CAACX,UAAU;oBACpC,IAAII,UAAUQ,WAAW;wBACvBC,QAAQC,KAAK,CAAC,AAAC,mBAA4B,OAAVd,WAAU;wBAC3Ca,QAAQC,KAAK,CAAC,AAAC,kBAA4D,OAA3CC,OAAOC,IAAI,CAACb,IAAIQ,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC;wBACrEC,QAAQC,IAAI,CAAC;oBACf;oBAEA,IAAI,OAAOhB,UAAU,UAAU;wBAC7BiB,IAAAA,gBAAM,EAAClB,KAAKC,OAAOH,QAAQF,IAAIuB,MAAM,EAAE,AAAC,UAAmB,OAAVtB,WAAU;wBAC3D;;;oBACF;oBACA,IAAI,SAASI,OAAO;wBAClBiB,IAAAA,gBAAM,EAAClB,KAAKC,MAAMmB,GAAG,EAAEtB,QAAQF,IAAIuB,MAAM,EAAE,AAAC,UAAmB,OAAVtB,WAAU;wBAC/D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIC,OAAOuB,MAAM,GAAG,GAAG;wBACrBzB,IAAI0B,UAAU,CAAC,AAAC,IAAuH1B,OAApHC,WAAU,4GAAmH,OAATD,IAAI2B,IAAI,EAAC;oBAClJ;oBACMrB,KAAIH,UAAAA,IAAAA,gBAAM,EAACH,kBAAPG,qBAAAA,UAAeE,MAAMC,CAAC;oBAC1BC,SAAQP,oBAAAA,IAAI4B,MAAM,CAACrB,KAAK,cAAhBP,+BAAAA,oBAAoBK,MAAME,KAAK;oBACvCC,UAASR,qBAAAA,IAAI4B,MAAM,CAACpB,MAAM,cAAjBR,gCAAAA,qBAAqBK,MAAMG,MAAM;oBAC1CC,WAAUT,sBAAAA,IAAI4B,MAAM,CAACnB,OAAO,cAAlBT,iCAAAA,sBAAsBK,MAAMI,OAAO;oBACnD,iFAAiF;oBACjF,mFAAmF;oBAC7EC,WAAWV,IAAI4B,MAAM,CAACC,OAAO,GAAG,QAAQxB,MAAMK,QAAQ;oBAC5D;;wBAAMoB,IAAAA,gBAAM,EAAC9B,KAAK,SAAO+B,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,aAAa3B,MAAM4B,MAAM,EAAE;oDAAE3B,GAAAA;oDAAGC,OAAAA;oDAAOC,QAAAA;oDAAQC,SAAAA;oDAASC,UAAAA;gDAAS;;;;;gDAA5FwB,mBAAS;oDAAC;oDAAsFlC,IAAIuB,MAAM;;;;;;;;;oBAAvJ;;;;;;IACF"}

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

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

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

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

package/dist/cjs/cli/{find.js → search.js}

@@ -185,14 +185,14 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-var findCmd = function findCmd(ctx) {
+var searchCmd = function searchCmd(ctx) {
     return _async_to_generator(function() {
         var _ctx_rest, terms, k;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     _ctx_rest = _sliced_to_array(ctx.rest, 1), terms = _ctx_rest[0];
-                    if (!terms) ctx.usageError("usage: ".concat(ctx.name, ' find "<terms>" [--where "<sql>"] [--k n] [--semantic]'));
+                    if (!terms) ctx.usageError("usage: ".concat(ctx.name, ' search "<terms>" [--preset name] [--include glob ...] [--where "<sql>"] [--k n] [--lexical]'));
                     k = (0, _sharedts.parseK)(ctx);
                     return [
                         4,
@@ -203,10 +203,12 @@ var findCmd = function findCmd(ctx) {
                                         case 0:
                                             return [
                                                 4,
-                                                (0, _commandsts.find)(db, cfg, terms, {
+                                                (0, _commandsts.search)(db, cfg, terms, {
                                                     k: k,
                                                     where: ctx.values.where,
-                                                    semantic: ctx.values.semantic
+                                                    preset: ctx.values.preset,
+                                                    include: ctx.values.include,
+                                                    semantic: ctx.values.lexical ? false : undefined
                                                 })
                                             ];
                                         case 1:
@@ -231,5 +233,5 @@ var findCmd = function findCmd(ctx) {
         });
     })();
 };
-var _default = findCmd;
+var _default = searchCmd;
 /* 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/search.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/search.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { printRows } from '../output.ts';\nimport { parseK, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst searchCmd: Command = async (ctx) => {\n  const [terms] = ctx.rest;\n  if (!terms) ctx.usageError(`usage: ${ctx.name} search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical]`);\n  const k = parseK(ctx);\n  await withDb(ctx, async (db, cfg) => printRows(await search(db, cfg, terms, { k, where: ctx.values.where, preset: ctx.values.preset, include: ctx.values.include, semantic: ctx.values.lexical ? false : undefined }), ctx.format));\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","terms","k","rest","usageError","name","parseK","withDb","db","cfg","search","where","values","preset","include","semantic","lexical","undefined","printRows","format"],"mappings":";;;;+BAWA;;;eAAA;;;0BAXuB;wBACG;wBACK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG/B,IAAMA,YAAqB,mBAAOC;;YAChBA,WAATC,OAEDC;;;;oBAFUF,6BAAAA,IAAIG,IAAI,MAAjBF,QAASD;oBAChB,IAAI,CAACC,OAAOD,IAAII,UAAU,CAAC,AAAC,UAAkB,OAATJ,IAAIK,IAAI,EAAC;oBACxCH,IAAII,IAAAA,gBAAM,EAACN;oBACjB;;wBAAMO,IAAAA,gBAAM,EAACP,KAAK,SAAOQ,IAAIC;;;;;4CAAkB;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,KAAKR,OAAO;oDAAEC,GAAAA;oDAAGS,OAAOX,IAAIY,MAAM,CAACD,KAAK;oDAAEE,QAAQb,IAAIY,MAAM,CAACC,MAAM;oDAAEC,SAASd,IAAIY,MAAM,CAACE,OAAO;oDAAEC,UAAUf,IAAIY,MAAM,CAACI,OAAO,GAAG,QAAQC;gDAAU;;;;;gDAA9KC,mBAAS;oDAAC;oDAAwKlB,IAAImB,MAAM;;;;;;;;;oBAAjO;;;;;;IACF;;IACA,WAAepB"}

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 { 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// --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 SavedFind validation.\nexport function parseK(ctx: Ctx): number | undefined {\n  if (ctx.values.k === undefined) return undefined;\n  const k = Number(ctx.values.k);\n  if (!Number.isInteger(k) || k <= 0) ctx.usageError(`--k expects a positive integer, got \"${ctx.values.k}\"`);\n  return k;\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, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["parseK","printWarnings","runSql","withDb","ctx","values","k","undefined","Number","isInteger","usageError","warnings","w","console","warn","fn","cfg","open","db","resolveConfig","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","rows","prepare","all","err","test","searchError","join","printRows"],"mappings":";;;;;;;;;;;QAWgBA;eAAAA;;QASAC;eAAAA;;QAgBAC;eAAAA;;QAZMC;eAAAA;;;oBAtBD;wBAEK;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMrB,SAASH,OAAOI,GAAQ;IAC7B,IAAIA,IAAIC,MAAM,CAACC,CAAC,KAAKC,WAAW,OAAOA;IACvC,IAAMD,IAAIE,OAAOJ,IAAIC,MAAM,CAACC,CAAC;IAC7B,IAAI,CAACE,OAAOC,SAAS,CAACH,MAAMA,KAAK,GAAGF,IAAIM,UAAU,CAAC,AAAC,wCAAoD,OAAbN,IAAIC,MAAM,CAACC,CAAC,EAAC;IACxG,OAAOA;AACT;AAIO,SAASL,cAAcU,QAAkB;QACzC,kCAAA,2BAAA;;QAAL,QAAK,YAAWA,6BAAX,SAAA,6BAAA,QAAA,yBAAA;YAAA,IAAMC,IAAN;YAAqBC,QAAQC,IAAI,CAACF;;;QAAlC;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;AACP;AAEO,SAAeT,OAAOC,GAAQ,EAAEW,EAAuE;;YACtGC,KACmBC,OAAjBC,IAAIP;;;;oBADNK,MAAMZ,IAAIe,aAAa;oBACJF,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;oBACZV,cAAcU;;;;;;;;;oBAEZ;;wBAAMI,GAAGG,IAAIF;;;oBAAb;;;;;;oBAEAE,GAAGE,KAAK;;;;;;;;;;IAEZ;;AAGO,SAASlB,OAAOc,GAAmB,EAAEK,GAAW,EAAEC,MAAgB,EAAEC,MAAwB,EAAEC,KAAa;QACtFH;IAA1B,IAAMI,mBAAmB,EAACJ,aAAAA,IAAIK,KAAK,CAAC,oBAAVL,wBAAAA,aAAoB,EAAE,EAAEM,MAAM;IACxD,IAAIL,OAAOK,MAAM,KAAKF,kBAAkB;QACtCZ,QAAQe,KAAK,CAAC,AAAC,GAAmBH,OAAjBD,OAAM,aAAiDF,OAAtCG,kBAAiB,uBAAmC,OAAdH,OAAOK,MAAM;QACrFE,QAAQC,IAAI,CAAC;IACf;IACA,IAAyBb,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;IACZV,cAAcU;IACd,IAAIoB;IACJ,IAAI;YACKb;QAAPa,OAAOb,CAAAA,cAAAA,GAAGc,OAAO,CAACX,MAAKY,GAAG,OAAnBf,aAAoB,qBAAGI;IAChC,EAAE,OAAOY,KAAK;QACZhB,GAAGE,KAAK;QACR,gFAAgF;QAChF,mFAAmF;QACnF,sFAAsF;QACtF,IAAI,aAAae,IAAI,CAACd,MAAM,MAAMe,IAAAA,0BAAW,EAACF,KAAcZ,OAAOe,IAAI,CAAC;QACxE,MAAMH;IACR;IACAI,IAAAA,mBAAS,EAACP,MAAMR;IAChBL,GAAGE,KAAK;AACV"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config.ts';\nimport type { OpenResult } from '../db.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { searchError } from '../search-error.ts';\nimport type { Ctx } from './types.ts';\n\n// --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(ctx: Ctx): number | undefined {\n  if (ctx.values.k === undefined) return undefined;\n  const k = Number(ctx.values.k);\n  if (!Number.isInteger(k) || k <= 0) ctx.usageError(`--k expects a positive integer, got \"${ctx.values.k}\"`);\n  return k;\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, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig();\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(db, cfg);\n  } finally {\n    db.close();\n  }\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n  let rows: Row[];\n  try {\n    rows = db.prepare(sql).all(...params) as Row[];\n  } catch (err) {\n    db.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5\n    // punctuation trap applies -- the bound parameters are the search terms there. SQL\n    // without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(err as Error, params.join(' '));\n    throw err;\n  }\n  printRows(rows, format);\n  db.close();\n}\n"],"names":["parseK","printWarnings","runSql","withDb","ctx","values","k","undefined","Number","isInteger","usageError","warnings","w","console","warn","fn","cfg","open","db","resolveConfig","close","sql","params","format","label","placeholderCount","match","length","error","process","exit","rows","prepare","all","err","test","searchError","join","printRows"],"mappings":";;;;;;;;;;;QAWgBA;eAAAA;;QASAC;eAAAA;;QAgBAC;eAAAA;;QAZMC;eAAAA;;;oBAtBD;wBAEK;6BACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMrB,SAASH,OAAOI,GAAQ;IAC7B,IAAIA,IAAIC,MAAM,CAACC,CAAC,KAAKC,WAAW,OAAOA;IACvC,IAAMD,IAAIE,OAAOJ,IAAIC,MAAM,CAACC,CAAC;IAC7B,IAAI,CAACE,OAAOC,SAAS,CAACH,MAAMA,KAAK,GAAGF,IAAIM,UAAU,CAAC,AAAC,wCAAoD,OAAbN,IAAIC,MAAM,CAACC,CAAC,EAAC;IACxG,OAAOA;AACT;AAIO,SAASL,cAAcU,QAAkB;QACzC,kCAAA,2BAAA;;QAAL,QAAK,YAAWA,6BAAX,SAAA,6BAAA,QAAA,yBAAA;YAAA,IAAMC,IAAN;YAAqBC,QAAQC,IAAI,CAACF;;;QAAlC;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;AACP;AAEO,SAAeT,OAAOC,GAAQ,EAAEW,EAAuE;;YACtGC,KACmBC,OAAjBC,IAAIP;;;;oBADNK,MAAMZ,IAAIe,aAAa;oBACJF,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;oBACZV,cAAcU;;;;;;;;;oBAEZ;;wBAAMI,GAAGG,IAAIF;;;oBAAb;;;;;;oBAEAE,GAAGE,KAAK;;;;;;;;;;IAEZ;;AAGO,SAASlB,OAAOc,GAAmB,EAAEK,GAAW,EAAEC,MAAgB,EAAEC,MAAwB,EAAEC,KAAa;QACtFH;IAA1B,IAAMI,mBAAmB,EAACJ,aAAAA,IAAIK,KAAK,CAAC,oBAAVL,wBAAAA,aAAoB,EAAE,EAAEM,MAAM;IACxD,IAAIL,OAAOK,MAAM,KAAKF,kBAAkB;QACtCZ,QAAQe,KAAK,CAAC,AAAC,GAAmBH,OAAjBD,OAAM,aAAiDF,OAAtCG,kBAAiB,uBAAmC,OAAdH,OAAOK,MAAM;QACrFE,QAAQC,IAAI,CAAC;IACf;IACA,IAAyBb,QAAAA,IAAAA,UAAI,EAACD,MAAtBE,KAAiBD,MAAjBC,IAAIP,WAAaM,MAAbN;IACZV,cAAcU;IACd,IAAIoB;IACJ,IAAI;YACKb;QAAPa,OAAOb,CAAAA,cAAAA,GAAGc,OAAO,CAACX,MAAKY,GAAG,OAAnBf,aAAoB,qBAAGI;IAChC,EAAE,OAAOY,KAAK;QACZhB,GAAGE,KAAK;QACR,gFAAgF;QAChF,mFAAmF;QACnF,sFAAsF;QACtF,IAAI,aAAae,IAAI,CAACd,MAAM,MAAMe,IAAAA,0BAAW,EAACF,KAAcZ,OAAOe,IAAI,CAAC;QACxE,MAAMH;IACR;IACAI,IAAAA,mBAAS,EAACP,MAAMR;IAChBL,GAAGE,KAAK;AACV"}

package/dist/cjs/cli/status.js

@@ -8,8 +8,10 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+var _commandsts = require("../commands.js");
 var _configts = require("../config.js");
 var _dbts = require("../db.js");
+var _outputts = require("../output.js");
 var _sharedts = require("./shared.js");
 function _define_property(obj, key, value) {
     if (key in obj) {
@@ -39,9 +41,9 @@ function _object_spread(target) {
     }
     return target;
 }
-// Vectors are computed on the first semantic query, not at reconcile, so a tree can be
-// embed-enabled with nothing embedded yet -- reported here because a fast `rebuild` on an
-// embed tree otherwise reads as "the feature isn't on".
+// 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
+// such a tree otherwise reads as "the feature isn't on".
 function vectorState(db) {
     try {
         var row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get();
@@ -51,14 +53,13 @@ function vectorState(db) {
     }
 }
 var status = function status(ctx) {
-    var _ref;
-    var _cfg_defaults_find, _cfg_defaults;
     var cfg = ctx.resolveConfig();
     var _open = (0, _dbts.open)(cfg), db = _open.db, dbPath = _open.dbPath, warnings = _open.warnings;
     (0, _sharedts.printWarnings)(warnings);
     var features = (0, _configts.featureStates)(cfg);
     var e = (0, _configts.embedConfig)(cfg);
     var vectors = e ? vectorState(db) : null;
+    var presets = (0, _commandsts.presetCoverage)(db, cfg);
     var heartbeat = (0, _dbts.getMeta)(db, 'watch_heartbeat');
     // Derived at open() (F): 3x the largest reconcile this cache has ever held its write
     // transaction for, floored at 30s -- read back from the connection rather than
@@ -73,7 +74,7 @@ var status = function status(ctx) {
             type: e.type,
             model: e.model
         }, vectors !== null && vectors !== void 0 ? vectors : {}) : null,
-        findDefaultWhere: (_ref = (_cfg_defaults = cfg.defaults) === null || _cfg_defaults === void 0 ? void 0 : (_cfg_defaults_find = _cfg_defaults.find) === null || _cfg_defaults_find === void 0 ? void 0 : _cfg_defaults_find.where) !== null && _ref !== void 0 ? _ref : null,
+        presets: presets,
         watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,
         busyTimeoutMs: busyTimeoutMs
     };
@@ -82,12 +83,28 @@ var status = function status(ctx) {
     } else {
         console.log("db: ".concat(result.db));
         console.log("docs: ".concat(result.docs));
-        var off = features.off.length > 0 ? " \xb7 off: ".concat(features.off.map(function(name) {
-            return "".concat(name, " (features.").concat(name, ")");
-        }).join(', ')) : '';
-        console.log("features: ".concat(features.on.join(', ')).concat(off));
-        if (e) console.log("embed: ".concat(e.type, " ").concat(e.model).concat(vectors ? " (vectors: ".concat(vectors.embedded, " embedded, ").concat(vectors.pending, " pending — embedded on first --semantic query)") : ''));
-        if (result.findDefaultWhere) console.log("find default scope: ".concat(result.findDefaultWhere, " (--where replaces it)"));
+        console.log((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)") : ''));
+        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){
+                var line = _step.value;
+                console.log(line);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
         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)"));
     }