sensemaking 0.9.3 → 0.9.5

package/README.md

@@ -1,18 +1,12 @@
 # sensemaking
 
-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.
+Query and search your markdown notes with context-aware progressive disclosure: SQL over frontmatter, links, and text, plus semantic search and link-graph ranking. No server, no build step.
 
 ## Problem
 
-Working with AI agents produces piles of small notes. Past a few dozen, finding the right ones
-means grepping or reading whole folders into context. The structure that makes notes navigable —
-frontmatter, wikilinks, headings — is exactly what an agent needs, but nothing exposes it as a
-query surface.
+Markdown notes accumulate: research, decisions, meeting notes, agent output. Past a few dozen, finding the ones relevant to what you're doing means grepping or reading whole folders into context. The structure that makes notes navigable (frontmatter, wikilinks, headings) is exactly what a query needs, but nothing exposes it as a query surface.
 
-`sense` indexes all of it into SQLite and reconciles against file timestamps on every query, so
-results are never stale and nothing has to be running.
+`sense` indexes all of it into SQLite and reconciles against file timestamps on every query, so results are never stale and nothing has to be running.
 
 ## Quick start
 
@@ -21,8 +15,7 @@ npm install -g sensemaking
 cd your-notes && sense init
 ```
 
-Needs Node 22.16 or newer: that is the first release whose built-in SQLite carries FTS5, which
-`sense search` indexes prose with.
+Needs Node 22.16 or newer: that is the first release whose built-in SQLite carries FTS5, which `sense search` indexes prose with.
 
 ```bash
 sense map                                        # orient: fields, hub notes, recent changes
@@ -42,14 +35,9 @@ Every file becomes rows in these tables, plus whatever an enabled feature adds o
 | `links` | `src`, `target` as written, `dst` resolved (`NULL` = dead link) | graph |
 | `sections` | heading, `level`, `start_line`, `end_line`, `tokens` estimate | structure |
 
-Results are references — path, title, summary, excerpt — never file contents. Reading happens
-afterward through the filesystem, scoped to the line ranges `peek` returns. This is the
-[just-in-time context pattern](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents):
-the agent holds lightweight identifiers and loads payloads only when needed.
+Results are references (path, title, summary, excerpt), never file contents. Reading happens afterward through the filesystem, scoped to the line ranges `peek` returns. This is the [just-in-time context pattern](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents): the agent holds lightweight identifiers and loads payloads only when needed.
 
-Output size is a contract, measured per release ([BENCHMARKING.md](BENCHMARKING.md)): `map` is
-fixed-size, a `find` row is tens of tokens, and a `peek` stays flat however large the note is —
-so what it saves over reading grows with the file, and a small note is cheaper read whole.
+Output size is a contract, measured per release ([BENCHMARKING.md](BENCHMARKING.md)): `map` is fixed-size, a `find` row is tens of tokens, and a `peek` stays flat however large the note is. What it saves over reading grows with the file; a small note is cheaper to read whole.
 
 ```sql
 -- filter and search compose in one query
@@ -65,7 +53,7 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 |---|---|
 | `map` | doc count, frontmatter field coverage, top hubs by link rank, recent changes |
 | `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 |
+| `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` |
@@ -74,21 +62,11 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 | `rebuild` | delete the cache and re-crawl |
 | `watch` | keep the index warm in the background (optional; see [WATCH.md](WATCH.md)) |
 
-`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 reporting 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). A `vector`-only row means the search words don't appear in that note; it showed up because the model judged it semantically related. `--preset` picks a named settings bundle from the config, `--lexical` skips vectors for one command, `--where` filters on frontmatter. `--format json` on any reporting 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). Three keys: **presets** (named, self-contained setting
-bundles), **queries** (saved commands), and the version.
+`sense init` writes `sense.config.json`; discovery walks up from cwd like git (`--config <path>` overrides).
 
 ```json
 {
@@ -106,46 +84,27 @@ bundles), **queries** (saved commands), and the version.
 }
 ```
 
-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.
+| key | holds |
+|---|---|
+| `presets` | named bundles of `include`/`exclude` globs, `k` (result count), `semantic` (vectors, on unless `false`), `where` (a standing SQL filter). A file is indexed if any preset includes it, embedded if any covering preset has `semantic` on. A `semantic: false` preset's files cost no vectors, and `status` shows each preset's coverage. |
+| `queries` | 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. |
+| `version` | schema version; older configs 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.
+Bare commands use the `default` preset; `--preset` names another; flags override single fields. Editing a preset rebuilds the cache and says which preset caused it.
 
-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.
+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
-per-file warnings and the values are still indexed, so one bad note never costs you the crawl.
+`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 per-file warnings, and the values are still indexed, so one bad note never costs you the crawl.
 
 ## Scale
 
-Every query starts with a freshness check against the cache in `.sense/`; only changed files are
-re-parsed. What to expect as a tree grows:
+Every query starts with a freshness check against the cache in `.sense/`; only changed files are re-parsed. What to expect as a tree grows:
 
-- **Work is linear in note count** — crawl, reconcile, and the freshness check every invocation
-  pays. That check is the floor cost of a query and the first thing to watch on a large tree.
-- **Output is flat.** `map`, `peek`, and a `find` row cost the same on a small tree as a large
-  one: context cost is bounded by what you ask for, not by how much there is.
-- **Bulk changes are paid by whoever queries next.** `sense watch` moves that re-parse into the
-  background ([WATCH.md](WATCH.md)) — it changes latency, never answers, since every query
-  reconciles for itself. `sense rebuild` starts the cache over.
+- **Work is linear in note count.** Crawl, reconcile, and the freshness check are what every invocation pays; that check is the floor cost of a query and the first thing to watch on a large tree.
+- **Output is flat.** `map`, `peek`, and a search row cost the same on a small tree as a large one: context cost is bounded by what you ask for, not by how much there is.
+- **Bulk changes are paid by whoever queries next.** `sense watch` moves that re-parse into the background ([WATCH.md](WATCH.md)): it changes latency, never answers, since every query reconciles for itself. `sense rebuild` starts the cache over.
 
-These are release gates rather than hopes: every release regenerates the numbers on pinned
-corpora spanning a 4x range in note count plus a stress tree that packs the worst measured
-shapes into one place — a megabyte-scale note, heading-dense outlines, dense link graphs,
-hundreds of frontmatter fields. A row that grows faster than linearly, or a token count
-that grows at all, blocks the release. Current figures: [BENCHMARKING.md](BENCHMARKING.md).
+These are release gates rather than hopes: every release regenerates the numbers on pinned corpora spanning a 4x range in note count plus a stress tree that packs the worst measured shapes into one place: a megabyte-scale note, heading-dense outlines, dense link graphs, hundreds of frontmatter fields. A row that grows faster than linearly, or a token count that grows at all, blocks the release. Current figures: [BENCHMARKING.md](BENCHMARKING.md).
 
 ## For AI agents
 
@@ -153,42 +112,25 @@ that grows at all, blocks the release. Current figures: [BENCHMARKING.md](BENCHM
 npx skills add kmalakoff/sensemaking   # -g for global, -a claude-code to target
 ```
 
-Two skills: `sense` for querying a tree — what each command is for, FTS5 syntax, reading the
-`via`/`score`/`similarity` columns, worked examples — and `sense-setup` for making one, where
-features, frontmatter conventions, and note size are decisions with consequences either way.
+Two skills: `sense` for querying a tree (what each command is for, FTS5 syntax, reading the `via`/`score`/`similarity` columns, worked examples) and `sense-setup` for making one, where features, frontmatter conventions, and note size are decisions with consequences either way.
 
 ## Prior art
 
-- [Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
-  (Anthropic): agents should hold lightweight identifiers — file paths, links — and load payloads
-  just in time, because context is a finite resource. The commands implement that pattern as a CLI.
-- [llm-wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) (Karpathy): an
-  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.
+- [Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) (Anthropic): agents should hold lightweight identifiers (file paths, links) and load payloads just in time, because context is a finite resource. The commands implement that pattern as a CLI.
+- [llm-wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) (Karpathy): an 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. It isn't an implementation of any one of them.
 
 ## Alternatives
 
-- **Obsidian Bases/Dataview** — same filters, but only inside the running app; agents can't
-  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 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),
-[fast-glob](https://github.com/mrmlnc/fast-glob),
-[@huggingface/tokenizers](https://github.com/huggingface/tokenizers.js) (pure JS),
-[getopts-compat](https://github.com/kmalakoff/getopts) and
-[exit-compat](https://github.com/kmalakoff/exit-compat) for the CLI, and Node's
-built-in SQLite. No native builds.
+- **Obsidian Bases/Dataview:** same filters, but only inside the running app; agents can't 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.
+- **Graph/LSP tools (IWE):** structural queries over a markdown graph via LSP/CLI/MCP, retrieval by structure rather than similarity; no SQL, no vector search.
+- **Markdown vector stores (markdown-vdb):** hybrid BM25 + vector search over markdown files, no frontmatter filtering; `sense` treats vectors as one signal alongside SQL, not the whole store.
+- **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.
+- **Document-OS apps (Anytype, Logseq, SilverBullet, Capacities):** full applications with their own UI and storage. `sense` is headless: your files stay files, there's no app to run.
+
+Dependencies: [yaml](https://github.com/eemeli/yaml), [remove-markdown](https://github.com/zuchka/remove-markdown), [fast-glob](https://github.com/mrmlnc/fast-glob), [@huggingface/tokenizers](https://github.com/huggingface/tokenizers.js) (pure JS), and Node's built-in SQLite. No native builds.
 
 ## License
 

package/dist/cjs/cli/check.js

@@ -11,7 +11,6 @@ Object.defineProperty(exports, "default", {
 var _commandsts = require("../commands.js");
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
-var _exitts = require("./exit.js");
 var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
@@ -387,7 +386,7 @@ var check = function check(ctx) {
                         ];
                     }
                     (0, _outputts.printRows)(rows, format);
-                    if (failed > 0) throw new _exitts.ExitError(1);
+                    if (failed > 0) process.exit(1);
                     return [
                         2
                     ];

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/check.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { ExitError } from './exit.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// A saved query that returns zero rows looks identical to a true empty result, so a broken\n// one can sit unnoticed -- one field report had `WHERE flag = 'true'` against a numeric\n// column reading as \"nothing tagged yet\" for hours. Preparing each query catches syntax and\n// unknown-column errors without executing it; queries that take no parameters are also run\n// for a row count. Parameterised queries are validated but not counted: inventing arguments\n// would report a count for a query nobody ran. Saved searches run lexically with k=1 -- that\n// validates the `where` fragment, the FTS5 terms, and the `preset` name (resolveSearch throws\n// on an unknown one, the same breakage class prepare() catches for SQL strings) -- but never\n// semantically (a semantic pass costs model time and, on api trees, network). Whether a\n// result being empty is good or bad is the reader's judgment -- there is no assertion path.\nconst check: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.check}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const rows: Row[] = [];\n  let failed = 0;\n  for (const [name, entry] of Object.entries(cfg.queries ?? {})) {\n    if (typeof entry === 'object' && entry !== null && 'search' in entry) {\n      try {\n        const count = (await search(db, cfg, entry.search, { k: 1, where: entry.where, preset: entry.preset, include: entry.include, semantic: false })).length;\n        rows.push({ query: name, params: '—', rows: '—', status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : 'ok (probe run with k=1)' });\n      } catch (err) {\n        failed++;\n        rows.push({ query: name, params: '—', rows: '—', status: `FAILED: ${(err as Error).message}` });\n      }\n      continue;\n    }\n    const sql = typeof entry === 'string' ? entry : entry.sql;\n    const params = (sql.match(/\\?/g) ?? []).length;\n    try {\n      const statement = db.prepare(sql);\n      if (params > 0) {\n        rows.push({ query: name, params, rows: '—', status: 'ok (not run: needs parameters)' });\n        continue;\n      }\n      const count = (statement.all() as unknown[]).length;\n      rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\n    } catch (err) {\n      failed++;\n      rows.push({ query: name, params, rows: '—', status: `FAILED: ${(err as Error).message}` });\n    }\n  }\n\n  db.close();\n  if (rows.length === 0) {\n    console.log('no saved queries in config');\n    return;\n  }\n  printRows(rows, format);\n  if (failed > 0) throw new ExitError(1);\n};\nexport default check;\n"],"names":["check","ctx","cfg","values","format","open","db","warnings","rows","failed","name","entry","sql","count","err","params","statement","parse","argv","USAGE","FORMAT","CONFIG","formatOf","resolveConfig","config","printWarnings","Object","entries","queries","search","k","where","preset","include","semantic","length","push","query","status","message","match","prepare","all","close","console","log","printRows","ExitError"],"mappings":";;;;+BA+DA;;;eAAA;;;0BA/DuB;oBACF;wBAEK;sBACA;uBACJ;wBACyC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG/D,2FAA2F;AAC3F,wFAAwF;AACxF,4FAA4F;AAC5F,2FAA2F;AAC3F,4FAA4F;AAC5F,6FAA6F;AAC7F,8FAA8F;AAC9F,6FAA6F;AAC7F,wFAAwF;AACxF,4FAA4F;AAC5F,IAAMA,QAAiB,eAAOC;;YASeC,cARnCC,QACFC,QACAF,KACmBG,OAAjBC,IAAIC,UAGNC,MACFC,QACC,2BAAA,mBAAA,gBAAA,WAAA,oBAAOC,MAAMC,OAYAC,YATNC,OAECC,KAMLF,KACAG,QAEEC,WAKAH;;;;oBA3BFV,SAAWc,IAAAA,eAAK,EAAChB,IAAIiB,IAAI,EAAE,AAAC,UAAqBC,OAAZlB,IAAIS,IAAI,EAAC,KAAe,OAAZS,cAAK,CAACnB,KAAK,GAAI,mBAAKoB,gBAAM,EAAKC,gBAAM,GAAtFlB;oBACFC,SAASkB,IAAAA,kBAAQ,EAACnB;oBAClBD,MAAMD,IAAIsB,aAAa,CAACpB,OAAOqB,MAAM;oBAClBnB,QAAAA,IAAAA,UAAI,EAACH,MAAtBI,KAAiBD,MAAjBC,IAAIC,WAAaF,MAAbE;oBACZkB,IAAAA,uBAAa,EAAClB;oBAERC;oBACFC,SAAS;oBACR,kCAAA,2BAAA;;;;;;;;;oBAAA,YAAuBiB,OAAOC,OAAO,EAACzB,eAAAA,IAAI0B,OAAO,cAAX1B,0BAAAA,eAAe,CAAC;;;2BAAtD,6BAAA,QAAA;;;;mDAAA,iBAAOQ,uBAAMC;yBACZ,CAAA,CAAA,OAAOA,sCAAP,SAAOA,MAAI,MAAM,YAAYA,UAAU,QAAQ,YAAYA,KAAI,GAA/D;;;;;;;;;;;;oBAEe;;wBAAMkB,IAAAA,kBAAM,EAACvB,IAAIJ,KAAKS,MAAMkB,MAAM,EAAE;4BAAEC,GAAG;4BAAGC,OAAOpB,MAAMoB,KAAK;4BAAEC,QAAQrB,MAAMqB,MAAM;4BAAEC,SAAStB,MAAMsB,OAAO;4BAAEC,UAAU;wBAAM;;;oBAAvIrB,QAAQ,AAAC,cAAkIsB,MAAM;oBACvJ3B,KAAK4B,IAAI,CAAC;wBAAEC,OAAO3B;wBAAMK,QAAQ;wBAAKP,MAAM;wBAAK8B,QAAQzB,UAAU,IAAI,4CAA4C;oBAA0B;;;;;;oBACtIC;oBACPL;oBACAD,KAAK4B,IAAI,CAAC;wBAAEC,OAAO3B;wBAAMK,QAAQ;wBAAKP,MAAM;wBAAK8B,QAAQ,AAAC,WAAiC,OAAvB,AAACxB,IAAcyB,OAAO;oBAAG;;;;;;oBAE/F;;;;;oBAEI3B,MAAM,OAAOD,UAAU,WAAWA,QAAQA,MAAMC,GAAG;oBACnDG,SAAS,EAACH,aAAAA,IAAI4B,KAAK,CAAC,oBAAV5B,wBAAAA,iBAAwBuB,MAAM;oBAC9C,IAAI;wBACInB,YAAYV,GAAGmC,OAAO,CAAC7B;wBAC7B,IAAIG,SAAS,GAAG;4BACdP,KAAK4B,IAAI,CAAC;gCAAEC,OAAO3B;gCAAMK,QAAAA;gCAAQP,MAAM;gCAAK8B,QAAQ;4BAAiC;4BACrF;;;;wBACF;wBACMzB,SAAQ,AAACG,UAAU0B,GAAG,GAAiBP,MAAM;wBACnD3B,KAAK4B,IAAI,CAAC;4BAAEC,OAAO3B;4BAAMK,QAAAA;4BAAQP,MAAMK;4BAAOyB,QAAQzB,WAAU,IAAI,2BAA2B;wBAAK;oBACtG,EAAE,OAAOC,KAAK;wBACZL;wBACAD,KAAK4B,IAAI,CAAC;4BAAEC,OAAO3B;4BAAMK,QAAAA;4BAAQP,MAAM;4BAAK8B,QAAQ,AAAC,WAAiC,OAAvB,AAACxB,IAAcyB,OAAO;wBAAG;oBAC1F;;;oBAxBG;;;;;;;;;;;;oBAAA;oBAAA;;;;;;;6BAAA,6BAAA;4BAAA;;;4BAAA;kCAAA;;;;;;;oBA2BLjC,GAAGqC,KAAK;oBACR,IAAInC,KAAK2B,MAAM,KAAK,GAAG;wBACrBS,QAAQC,GAAG,CAAC;wBACZ;;;oBACF;oBACAC,IAAAA,mBAAS,EAACtC,MAAMJ;oBAChB,IAAIK,SAAS,GAAG,MAAM,IAAIsC,iBAAS,CAAC;;;;;;IACtC;;IACA,WAAe/C"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/check.ts"],"sourcesContent":["import { search } from '../commands.ts';\nimport { open } from '../db.ts';\nimport type { Row } from '../output.ts';\nimport { printRows } from '../output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// A saved query that returns zero rows looks identical to a true empty result, so a broken\n// one can sit unnoticed -- one field report had `WHERE flag = 'true'` against a numeric\n// column reading as \"nothing tagged yet\" for hours. Preparing each query catches syntax and\n// unknown-column errors without executing it; queries that take no parameters are also run\n// for a row count. Parameterised queries are validated but not counted: inventing arguments\n// would report a count for a query nobody ran. Saved searches run lexically with k=1 -- that\n// validates the `where` fragment, the FTS5 terms, and the `preset` name (resolveSearch throws\n// on an unknown one, the same breakage class prepare() catches for SQL strings) -- but never\n// semantically (a semantic pass costs model time and, on api trees, network). Whether a\n// result being empty is good or bad is the reader's judgment -- there is no assertion path.\nconst check: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.check}`, { ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const cfg = ctx.resolveConfig(values.config as string | undefined);\n  const { db, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const rows: Row[] = [];\n  let failed = 0;\n  for (const [name, entry] of Object.entries(cfg.queries ?? {})) {\n    if (typeof entry === 'object' && entry !== null && 'search' in entry) {\n      try {\n        const count = (await search(db, cfg, entry.search, { k: 1, where: entry.where, preset: entry.preset, include: entry.include, semantic: false })).length;\n        rows.push({ query: name, params: '—', rows: '—', status: count === 0 ? 'ok, but matches 0 notes (lexical probe)' : 'ok (probe run with k=1)' });\n      } catch (err) {\n        failed++;\n        rows.push({ query: name, params: '—', rows: '—', status: `FAILED: ${(err as Error).message}` });\n      }\n      continue;\n    }\n    const sql = typeof entry === 'string' ? entry : entry.sql;\n    const params = (sql.match(/\\?/g) ?? []).length;\n    try {\n      const statement = db.prepare(sql);\n      if (params > 0) {\n        rows.push({ query: name, params, rows: '—', status: 'ok (not run: needs parameters)' });\n        continue;\n      }\n      const count = (statement.all() as unknown[]).length;\n      rows.push({ query: name, params, rows: count, status: count === 0 ? 'ok, but returns 0 rows' : 'ok' });\n    } catch (err) {\n      failed++;\n      rows.push({ query: name, params, rows: '—', status: `FAILED: ${(err as Error).message}` });\n    }\n  }\n\n  db.close();\n  if (rows.length === 0) {\n    console.log('no saved queries in config');\n    return;\n  }\n  printRows(rows, format);\n  if (failed > 0) process.exit(1);\n};\nexport default check;\n"],"names":["check","ctx","cfg","values","format","open","db","warnings","rows","failed","name","entry","sql","count","err","params","statement","parse","argv","USAGE","FORMAT","CONFIG","formatOf","resolveConfig","config","printWarnings","Object","entries","queries","search","k","where","preset","include","semantic","length","push","query","status","message","match","prepare","all","close","console","log","printRows","process","exit"],"mappings":"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"}

package/dist/cjs/cli/named.js

@@ -14,7 +14,6 @@ Object.defineProperty(exports, // Fallback when the first positional is not a co
 });
 var _commandsts = require("../commands.js");
 var _outputts = require("../output.js");
-var _exitts = require("./exit.js");
 var _sharedts = require("./shared.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -184,7 +183,11 @@ function named(ctx, queryName) {
                     configPath = values.config;
                     cfg = ctx.resolveConfig(configPath);
                     entry = cfg.queries[queryName];
-                    if (entry === undefined) (0, _exitts.usageError)('unknown query: "'.concat(queryName, '"'), "valid queries: ".concat(Object.keys(cfg.queries).sort().join(', ')));
+                    if (entry === undefined) {
+                        console.error('unknown query: "'.concat(queryName, '"'));
+                        console.error("valid queries: ".concat(Object.keys(cfg.queries).sort().join(', ')));
+                        process.exit(2);
+                    }
                     if (typeof entry === 'string') {
                         (0, _sharedts.runSql)(cfg, entry, params, format, 'query "'.concat(queryName, '"'));
                         return [

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

@@ -1 +1 @@
-{"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 { usageError } from './exit.ts';\nimport { CONFIG, FORMAT, formatOf, parse, parseK, runSql, SEARCH_FLAGS, 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).\n// Flags cover both shapes -- SEARCH_FLAGS override a saved search's fields the same way they\n// override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json] [--config path] [--where \"<sql>\"] [--k n] [--preset name] [--include glob ...] [--lexical]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const configPath = values.config as string | undefined;\n\n  const cfg = ctx.resolveConfig(configPath);\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) usageError(`unknown query: \"${queryName}\"`, `valid queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n\n  if (typeof entry === 'string') {\n    runSql(cfg, entry, params, format, `query \"${queryName}\"`);\n    return;\n  }\n  if ('sql' in entry) {\n    runSql(cfg, entry.sql, params, 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(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? 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 = values.lexical ? false : entry.semantic;\n  await withDb(ctx, configPath, async (db, resolvedCfg) => printRows(await search(db, resolvedCfg, entry.search, { k, where, preset, include, semantic }), format));\n}\n"],"names":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","cfg","entry","k","where","preset","include","semantic","name","argv","SEARCH_FLAGS","FORMAT","CONFIG","positionals","formatOf","config","resolveConfig","queries","undefined","usageError","Object","keys","sort","join","runSql","sql","length","lexical","withDb","db","resolvedCfg","search","printRows"],"mappings":";;;;+BAMA,2FAA2F;AAC3F,+FAA+F;AAC/F,6FAA6F;AAC7F,uBAAuB;AACvB;;;eAA8BA;;;0BAVP;wBACG;sBACC;wBAC2D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOvE,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB;;YAuBnDC,SACKC,eACCA,gBACCA,iBAzBXC,OACkCC,QAAhCF,QAAqBG,QACvBC,QACAC,YAEAC,KACAC,OAgBAC,GACAC,OACAC,QACAC,SAGAC;;;;oBA5BAX,QAAQ,AAAC,UAAqBH,OAAZD,IAAIgB,IAAI,EAAC,KAAa,OAAVf,WAAU;oBACNI,SAAAA,IAAAA,eAAK,EAACL,IAAIiB,IAAI,EAAEb,OAAO,mBAAKc,sBAAY,EAAKC,gBAAM,EAAKC,gBAAM,IAA9FjB,SAAgCE,OAAhCF,QAAqBG,SAAWD,OAAxBgB;oBACVd,SAASe,IAAAA,kBAAQ,EAACnB;oBAClBK,aAAaL,OAAOoB,MAAM;oBAE1Bd,MAAMT,IAAIwB,aAAa,CAAChB;oBACxBE,QAAQD,IAAIgB,OAAO,CAACxB,UAAU;oBACpC,IAAIS,UAAUgB,WAAWC,IAAAA,kBAAU,EAAC,AAAC,mBAA4B,OAAV1B,WAAU,MAAI,AAAC,kBAA4D,OAA3C2B,OAAOC,IAAI,CAACpB,IAAIgB,OAAO,EAAEK,IAAI,GAAGC,IAAI,CAAC;oBAE5H,IAAI,OAAOrB,UAAU,UAAU;wBAC7BsB,IAAAA,gBAAM,EAACvB,KAAKC,OAAOJ,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU;wBACvD;;;oBACF;oBACA,IAAI,SAASS,OAAO;wBAClBsB,IAAAA,gBAAM,EAACvB,KAAKC,MAAMuB,GAAG,EAAE3B,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU;wBAC3D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIK,OAAO4B,MAAM,GAAG,GAAG;wBACrBlC,IAAI2B,UAAU,CAAC,AAAC,IAAuH3B,OAApHC,WAAU,4GAAmH,OAATD,IAAIgB,IAAI,EAAC;oBAClJ;oBACML,KAAIT,UAAAA,IAAAA,gBAAM,EAACC,OAAOQ,CAAC,EAAwBX,IAAI2B,UAAU,eAArDzB,qBAAAA,UAA0DQ,MAAMC,CAAC;oBACrEC,SAAST,gBAAAA,OAAOS,KAAK,cAAZT,2BAAAA,gBAAuCO,MAAME,KAAK;oBAC3DC,UAAUV,iBAAAA,OAAOU,MAAM,cAAbV,4BAAAA,iBAAwCO,MAAMG,MAAM;oBAC9DC,WAAWX,kBAAAA,OAAOW,OAAO,cAAdX,6BAAAA,kBAA2CO,MAAMI,OAAO;oBACzE,iFAAiF;oBACjF,mFAAmF;oBAC7EC,WAAWZ,OAAOgC,OAAO,GAAG,QAAQzB,MAAMK,QAAQ;oBACxD;;wBAAMqB,IAAAA,gBAAM,EAACpC,KAAKQ,YAAY,SAAO6B,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,aAAa5B,MAAM6B,MAAM,EAAE;oDAAE5B,GAAAA;oDAAGC,OAAAA;oDAAOC,QAAAA;oDAAQC,SAAAA;oDAASC,UAAAA;gDAAS;;;;;gDAA5FyB,mBAAS;oDAAC;oDAAsFjC;;;;;;;;;oBAAzJ;;;;;;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 { CONFIG, FORMAT, formatOf, parse, parseK, runSql, SEARCH_FLAGS, 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).\n// Flags cover both shapes -- SEARCH_FLAGS override a saved search's fields the same way they\n// override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json] [--config path] [--where \"<sql>\"] [--k n] [--preset name] [--include glob ...] [--lexical]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  const configPath = values.config as string | undefined;\n\n  const cfg = ctx.resolveConfig(configPath);\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, format, `query \"${queryName}\"`);\n    return;\n  }\n  if ('sql' in entry) {\n    runSql(cfg, entry.sql, params, 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(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? 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 = values.lexical ? false : entry.semantic;\n  await withDb(ctx, configPath, async (db, resolvedCfg) => printRows(await search(db, resolvedCfg, entry.search, { k, where, preset, include, semantic }), format));\n}\n"],"names":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","cfg","entry","k","where","preset","include","semantic","name","argv","SEARCH_FLAGS","FORMAT","CONFIG","positionals","formatOf","config","resolveConfig","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","sql","length","usageError","lexical","withDb","db","resolvedCfg","search","printRows"],"mappings":";;;;+BAKA,2FAA2F;AAC3F,+FAA+F;AAC/F,6FAA6F;AAC7F,uBAAuB;AACvB;;;eAA8BA;;;0BATP;wBACG;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOvE,SAAeA,MAAMC,GAAQ,EAAEC,SAAiB;;YA2BnDC,SACKC,eACCA,gBACCA,iBA7BXC,OACkCC,QAAhCF,QAAqBG,QACvBC,QACAC,YAEAC,KACAC,OAoBAC,GACAC,OACAC,QACAC,SAGAC;;;;oBAhCAX,QAAQ,AAAC,UAAqBH,OAAZD,IAAIgB,IAAI,EAAC,KAAa,OAAVf,WAAU;oBACNI,SAAAA,IAAAA,eAAK,EAACL,IAAIiB,IAAI,EAAEb,OAAO,mBAAKc,sBAAY,EAAKC,gBAAM,EAAKC,gBAAM,IAA9FjB,SAAgCE,OAAhCF,QAAqBG,SAAWD,OAAxBgB;oBACVd,SAASe,IAAAA,kBAAQ,EAACnB;oBAClBK,aAAaL,OAAOoB,MAAM;oBAE1Bd,MAAMT,IAAIwB,aAAa,CAAChB;oBACxBE,QAAQD,IAAIgB,OAAO,CAACxB,UAAU;oBACpC,IAAIS,UAAUgB,WAAW;wBACvBC,QAAQC,KAAK,CAAC,AAAC,mBAA4B,OAAV3B,WAAU;wBAC3C0B,QAAQC,KAAK,CAAC,AAAC,kBAA4D,OAA3CC,OAAOC,IAAI,CAACrB,IAAIgB,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC;wBACrEC,QAAQC,IAAI,CAAC;oBACf;oBAEA,IAAI,OAAOxB,UAAU,UAAU;wBAC7ByB,IAAAA,gBAAM,EAAC1B,KAAKC,OAAOJ,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU;wBACvD;;;oBACF;oBACA,IAAI,SAASS,OAAO;wBAClByB,IAAAA,gBAAM,EAAC1B,KAAKC,MAAM0B,GAAG,EAAE9B,QAAQC,QAAQ,AAAC,UAAmB,OAAVN,WAAU;wBAC3D;;;oBACF;oBAEA,uFAAuF;oBACvF,IAAIK,OAAO+B,MAAM,GAAG,GAAG;wBACrBrC,IAAIsC,UAAU,CAAC,AAAC,IAAuHtC,OAApHC,WAAU,4GAAmH,OAATD,IAAIgB,IAAI,EAAC;oBAClJ;oBACML,KAAIT,UAAAA,IAAAA,gBAAM,EAACC,OAAOQ,CAAC,EAAwBX,IAAIsC,UAAU,eAArDpC,qBAAAA,UAA0DQ,MAAMC,CAAC;oBACrEC,SAAST,gBAAAA,OAAOS,KAAK,cAAZT,2BAAAA,gBAAuCO,MAAME,KAAK;oBAC3DC,UAAUV,iBAAAA,OAAOU,MAAM,cAAbV,4BAAAA,iBAAwCO,MAAMG,MAAM;oBAC9DC,WAAWX,kBAAAA,OAAOW,OAAO,cAAdX,6BAAAA,kBAA2CO,MAAMI,OAAO;oBACzE,iFAAiF;oBACjF,mFAAmF;oBAC7EC,WAAWZ,OAAOoC,OAAO,GAAG,QAAQ7B,MAAMK,QAAQ;oBACxD;;wBAAMyB,IAAAA,gBAAM,EAACxC,KAAKQ,YAAY,SAAOiC,IAAIC;;;;;4CAA0B;;gDAAMC,IAAAA,kBAAM,EAACF,IAAIC,aAAahC,MAAMiC,MAAM,EAAE;oDAAEhC,GAAAA;oDAAGC,OAAAA;oDAAOC,QAAAA;oDAAQC,SAAAA;oDAASC,UAAAA;gDAAS;;;;;gDAA5F6B,mBAAS;oDAAC;oDAAsFrC;;;;;;;;;oBAAzJ;;;;;;IACF"}

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

@@ -1,23 +1,18 @@
+import type { ParseArgsOptionsConfig } from 'node:util';
 import type { ResolvedConfig } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
-export interface Flag {
-    type: 'string' | 'boolean';
-    default?: string | boolean;
-    multiple?: boolean;
-    short?: string;
-}
-export type Flags = Record<string, Flag>;
-export declare const FORMAT: Flags;
-export declare const CONFIG: Flags;
-export declare const SEARCH_FLAGS: Flags;
-export type Values = Record<string, string | boolean | string[] | undefined>;
+export declare const FORMAT: ParseArgsOptionsConfig;
+export declare const CONFIG: ParseArgsOptionsConfig;
+export declare const SEARCH_FLAGS: ParseArgsOptionsConfig;
+type Values = Record<string, string | boolean | string[] | undefined>;
 export declare function formatOf(values: Values): 'table' | 'json';
-export declare function parse(argv: string[], usage: string, flags?: Flags): {
+export declare function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): {
     values: Values;
     positionals: string[];
 };
-export declare function parseK(k: string | undefined, usageErrorFn: (message: string) => never): number | undefined;
+export declare function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined;
 export declare function printWarnings(warnings: string[]): void;
 export declare function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
 export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void;
+export {};

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

@@ -1,23 +1,18 @@
+import type { ParseArgsOptionsConfig } from 'node:util';
 import type { ResolvedConfig } from '../config.js';
 import type { OpenResult } from '../db.js';
 import type { Ctx } from './types.js';
-export interface Flag {
-    type: 'string' | 'boolean';
-    default?: string | boolean;
-    multiple?: boolean;
-    short?: string;
-}
-export type Flags = Record<string, Flag>;
-export declare const FORMAT: Flags;
-export declare const CONFIG: Flags;
-export declare const SEARCH_FLAGS: Flags;
-export type Values = Record<string, string | boolean | string[] | undefined>;
+export declare const FORMAT: ParseArgsOptionsConfig;
+export declare const CONFIG: ParseArgsOptionsConfig;
+export declare const SEARCH_FLAGS: ParseArgsOptionsConfig;
+type Values = Record<string, string | boolean | string[] | undefined>;
 export declare function formatOf(values: Values): 'table' | 'json';
-export declare function parse(argv: string[], usage: string, flags?: Flags): {
+export declare function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): {
     values: Values;
     positionals: string[];
 };
-export declare function parseK(k: string | undefined, usageErrorFn: (message: string) => never): number | undefined;
+export declare function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined;
 export declare function printWarnings(warnings: string[]): void;
 export declare function withDb(ctx: Ctx, configPath: string | undefined, fn: (db: OpenResult['db'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
 export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: 'table' | 'json', label: string): void;
+export {};

package/dist/cjs/cli/shared.js

@@ -37,19 +37,15 @@ _export(exports, {
         return withDb;
     }
 });
-var _getoptscompat = /*#__PURE__*/ _interop_require_default(require("getopts-compat"));
+var _nodeutil = require("node:util");
 var _dbts = require("../db.js");
 var _outputts = require("../output.js");
 var _searcherrorts = require("../search-error.js");
-var _exitts = require("./exit.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_with_holes(arr) {
-    if (Array.isArray(arr)) return arr;
-}
 function _array_without_holes(arr) {
     if (Array.isArray(arr)) return _array_like_to_array(arr);
 }
@@ -95,41 +91,9 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 function _iterable_to_array(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _iterable_to_array_limit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
-    }
-    return _arr;
-}
-function _non_iterable_rest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
 function _non_iterable_spread() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
@@ -172,9 +136,6 @@ function _object_spread_props(target, source) {
     }
     return target;
 }
-function _sliced_to_array(arr, i) {
-    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
-}
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
@@ -318,100 +279,41 @@ var SEARCH_FLAGS = {
 function formatOf(values) {
     return values.format === 'json' ? 'json' : 'table';
 }
-function parse(argv, usage) {
-    var flags = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-    var table = _object_spread_props(_object_spread({}, flags), {
-        help: {
-            type: 'boolean',
-            default: false,
-            short: 'h'
-        }
-    });
-    var string = [];
-    var boolean = [];
-    var alias = {};
-    var defaults = {};
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+function parse(argv, usage, options) {
+    var values;
+    var positionals;
     try {
-        for(var _iterator = Object.entries(table)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-            var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], flag = _step_value[1];
-            (flag.type === 'boolean' ? boolean : string).push(name);
-            if (flag.default !== undefined) defaults[name] = flag.default;
-            if (flag.short !== undefined) alias[name] = flag.short;
-        }
+        var ref;
+        ref = (0, _nodeutil.parseArgs)({
+            args: argv,
+            options: _object_spread_props(_object_spread({}, options), {
+                help: {
+                    type: 'boolean',
+                    default: false,
+                    short: 'h'
+                }
+            }),
+            strict: true,
+            allowPositionals: true
+        }), values = ref.values, positionals = ref.positionals, ref;
     } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
-            }
-        } finally{
-            if (_didIteratorError) {
-                throw _iteratorError;
-            }
-        }
+        console.error(err.message);
+        console.error(usage);
+        process.exit(2);
     }
-    // getopts is lenient about undeclared flags -- they land in the result and are silently
-    // ignored, which is the bug 0.9.2 fixed. Record the first and fail below; returning false
-    // also keeps it out of the result. `--k -1` arrives here as unknown option "1", because
-    // getopts reads a leading dash as a new option rather than as --k's value; the message is
-    // blunter than the old one but it is still a usage error rather than a silent default.
-    var unknown;
-    var parsed = (0, _getoptscompat.default)(argv, {
-        string: string,
-        boolean: boolean,
-        alias: alias,
-        default: defaults,
-        unknown: function unknown1(name) {
-            if (unknown === undefined) unknown = name;
-            return false;
-        }
-    });
-    if (unknown !== undefined) (0, _exitts.usageError)("unknown option: ".concat(unknown), usage);
-    if (parsed.help) {
+    if (values.help) {
         console.log(usage);
-        throw new _exitts.ExitError(0);
-    }
-    // Two getopts shapes the callers must not see: an unset string flag reads as "" rather
-    // than undefined, and a flag passed once reads as a string rather than a one-element
-    // array. Both matter -- `?? saved.field` means "flag absent", and --include is a list.
-    var values = {};
-    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-    try {
-        for(var _iterator1 = Object.entries(table)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-            var _step_value1 = _sliced_to_array(_step1.value, 2), name1 = _step_value1[0], flag1 = _step_value1[1];
-            var raw = parsed[name1];
-            if (flag1.type === 'boolean') values[name1] = raw;
-            else if (flag1.multiple) values[name1] = raw === '' ? undefined : Array.isArray(raw) ? raw : [
-                raw
-            ];
-            else values[name1] = raw === '' ? undefined : raw;
-        }
-    } catch (err) {
-        _didIteratorError1 = true;
-        _iteratorError1 = err;
-    } finally{
-        try {
-            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                _iterator1.return();
-            }
-        } finally{
-            if (_didIteratorError1) {
-                throw _iteratorError1;
-            }
-        }
+        process.exit(0);
     }
     return {
         values: values,
-        positionals: parsed._
+        positionals: positionals
     };
 }
-function parseK(k, usageErrorFn) {
+function parseK(k, usageError) {
     if (k === undefined) return undefined;
     var parsed = Number(k);
-    if (!Number.isInteger(parsed) || parsed <= 0) usageErrorFn('--k expects a positive integer, got "'.concat(k, '"'));
+    if (!Number.isInteger(parsed) || parsed <= 0) usageError('--k expects a positive integer, got "'.concat(k, '"'));
     return parsed;
 }
 function printWarnings(warnings) {
@@ -479,7 +381,10 @@ function withDb(ctx, configPath, fn) {
 function runSql(cfg, sql, params, format, label) {
     var _sql_match;
     var placeholderCount = ((_sql_match = sql.match(/\?/g)) !== null && _sql_match !== void 0 ? _sql_match : []).length;
-    if (params.length !== placeholderCount) (0, _exitts.usageError)("".concat(label, " expects ").concat(placeholderCount, " parameter(s), got ").concat(params.length));
+    if (params.length !== placeholderCount) {
+        console.error("".concat(label, " expects ").concat(placeholderCount, " parameter(s), got ").concat(params.length));
+        process.exit(2);
+    }
     var _open = (0, _dbts.open)(cfg), db = _open.db, warnings = _open.warnings;
     printWarnings(warnings);
     var rows;