sensemaking 0.25.0 → 0.26.0

package/README.md

@@ -66,11 +66,11 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 | command | does |
 |---|---|
 | `build [--force]` | incrementally update the derived index and prepare every configured search capability; `--force` recreates only `.sense/` |
-| `map` | doc count, frontmatter field coverage, top hubs by link rank, recent changes; hub/recent limits use bytewise path order on ties |
+| `map [--preset name] [--include glob] [--exclude glob] [--no-exclude] [--where "<sql>"]` | doc count, frontmatter field coverage, top hubs by link rank, recent changes; hub/recent limits use bytewise path order on ties |
 | `search "<text>" [--preset name] [--include glob] [--exclude glob] [--no-exclude] [--where "<sql>"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n]` | words + links + vectors, one fused ranked list; `via` labels each row's evidence. `--k` bounds notes returned, `--snippet-char-limit` (default 80) each passage, `--snippet-count-limit` (default 1) passages per note |
-| `peek <path> [--preset name] [--where "<sql>"]` | frontmatter + heading outline (`[L143-162, ~380t]`) + links both ways (first 20 per list, each with its total) |
-| `path <a> <b> [--max-depth n] [--preset name] [--where "<sql>"]` | shortest link chain between two notes, or none within the bound |
-| `related <note> [--k n] [--preset name] [--where "<sql>"]` | notes similar in meaning that `<note>` does not yet link to; reads vectors, so semantic-search cost |
+| `peek <path> [--preset name] [--include glob] [--exclude glob] [--no-exclude] [--where "<sql>"]` | frontmatter + heading outline (`[L143-162, ~380t]`) + links both ways (first 20 per list, each with its total) |
+| `path <a> <b> [--max-depth n] [--preset name] [--include glob] [--exclude glob] [--no-exclude] [--where "<sql>"]` | shortest link chain between two notes, or none within the bound |
+| `related <note> [--k n] [--preset name] [--include glob] [--exclude glob] [--no-exclude] [--where "<sql>"]` | notes similar in meaning that `<note>` does not yet link to; reads vectors, so semantic-search cost |
 | `sql "<statement>" [params...] [--preset name]` | ad-hoc SQL over all the tables; `?` binds positional args. Index-wide by default; `--preset` binds the preset's paths as a `scope` table the statement joins |
 | `<name> [params...]` | run a query saved in the config; `--list` names them |
 | `init` | write a starter `sense.config.json` |
@@ -78,15 +78,19 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 | `download` | prefetch the embedding model named in the config; build, watch, or a default CLI vector query fetches it when needed otherwise |
 | `watch` | keep the index warm in the background (optional; see [watch coordination](https://github.com/kmalakoff/sensemaking/blob/master/DESIGN.md#watch-coordination)) |
 
+Scope flags select from indexed notes; presets are not a security boundary. `peek` rejects an exact path outside the selected scope before trying a basename, resolves a basename only within that scope, and limits resolved outbound links and backlinks to it; unresolved targets remain as written. `path` resolves both endpoints across the indexed tree and applies scope to intermediate notes. `related` resolves its seed across the indexed tree and applies scope to result candidates.
+
 Query commands use the config's `"build": true` default to update the index first and prepare only what that operation needs. Core map, peek, path and SQL work do not prepare vectors. Set `"build": false` for a manual-build or watch workflow, or add `--no-build` for one query. These read the last completed generation without scanning source files or repairing missing readiness; they fail with a `sense build` instruction when the requested capability is not ready. This disables Sense index maintenance, not database access or arbitrary SQL.
 
-The completed generation stores the exact decoded source used for indexed snippets. A no-build query reads those stored sources and checks readiness for the capabilities it requests; it does not hydrate from newer live files. A default query incrementally scans the configured tree for the capabilities it needs; vector preparation is limited to its eligible scope. `sense build` prepares every configured capability, and `sense watch` keeps them prepared as changes arrive.
+The completed generation stores the exact decoded source used for indexed snippets. A no-build query reads those stored sources and checks readiness for the capabilities it requests; it does not hydrate from newer live files. Public `search`, `mapTree`, `peek`, `findPath`, and `relatedNotes` calls assemble each result inside one committed database snapshot. Search completes provider and model preparation before its final snapshot and rejects an incomplete generation or one built for different feature settings instead of mixing generations. A default query incrementally scans the configured tree for the capabilities it needs; vector preparation is limited to its eligible scope. `sense build` prepares every configured capability, and `sense watch` keeps them prepared as changes arrive.
+
+Explicit `sense build` and `sense watch` prepare the index regardless of the config's `build` default. Watch builds before reporting ready, then processes edits; with SQLite, a no-build query can read the previous generation while an edit is being processed. DuckDB permits concurrent cross-process no-build readers only while every handle is observational and read-only; a build or watcher opens the cache read-write and excludes every other process. Turso no-build queries still require a query-capable, exclusive handle. Native contenders wait within a bounded lock budget, then raise `STORE_BUSY`, as described under Store choice. Library callers choose preparation separately at `open`: `open(config)` prepares every configured capability, and `open(config, { build: false })` opens existing compatible state. A build-enabled open repairs incomplete feature state and replaces an incompatible derived cache format; a no-build open reports the required build without rebuilding or repairing the Sense index. The config's `build` setting controls CLI queries only. `build(config, { force: true })` recreates only the derived index. Public `search`, `mapTree`, `peek`, `findPath`, and `relatedNotes` calls on one retained `Store` serialize with one another. Await those calls before running raw SQL, starting a transaction, or closing the handle.
 
-Explicit `sense build` and `sense watch` prepare the index regardless of the config's `build` default. Watch builds before reporting ready, then processes edits; a no-build query can read the previous generation while an edit is being processed. Library callers choose preparation separately at `open`: `open(config)` prepares every configured capability, and `open(config, { build: false })` opens existing compatible state. The config's `build` setting controls CLI queries only. `build(config, { force: true })` recreates only the derived index. Public `search`, `mapTree`, and `peek` calls on one retained `Store` serialize with one another. Await those calls before running raw SQL, starting a transaction, or closing the handle.
+The root `search(store, config, terms, { signal })`, `open(config, { signal })`, and `build(config, { signal })` APIs accept an `AbortSignal`. Cancellation stops supported provider I/O and is checked between phases; synchronous native SQL or CPU work and resource cleanup finish before the promise settles. Cancellation checks preserve `signal.reason`, but a cleanup failure can surface instead or be combined with it in an `AggregateError`.
 
 `search` runs one text through every engine its scope has: FTS5 word match (BM25-ranked, bare words AND-join, operators are yours on `sqlite`; on `duckdb` and `turso` the FTS5 operators are a named error, see Config), 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). Within the vector signal, candidates rank by the true cosine against the best-matching canonical chunk before `similarity` is rounded to three decimals for display; a zero-direction vector has similarity `0`, exact cosine ties use bytewise path order, and equal-scoring chunks choose the earliest authored chunk. The public search list ranks the combined word, link, and vector candidates by fused reciprocal-rank score. `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, `--where` filters on frontmatter. `--format json` on any reporting command returns structured output, and `--format csv` writes the row-returning commands one row per line, for redirecting a large result to a file instead of into context; `--version` and `--help` do what they say.
 
-Search rows carry `snippets: string[]`. Each passage is generated around the matched words, marked with `«»`, and limited to 80 characters by default. `--snippet-count-limit` returns more non-overlapping passages from a note, in document order. Link- and vector-only rows have `snippets: []`.
+Search rows carry `snippets: string[]`. Each passage is generated around the matched words, marked with `«»`, and normally limited to 80 characters by default. A whole matched word is preserved, so a passage can exceed that limit when the word is longer. `--snippet-count-limit` returns more non-overlapping passages from a note, in document order. Link- and vector-only rows have `snippets: []`.
 
 Lexical words are case- and accent-insensitive. SQLite and DuckDB use their native English stem tokenizers; Turso's native Tantivy index has no stem tokenizer in the supported release, so it applies the shared Porter normalization to a derived field before native indexing. In every store, `run`, `running`, and `runs` match the same authored notes, while authored bytes are never rewritten. Quoted phrases require adjacent words, with punctuation treated as a separator, and punctuation-only input returns no lexical rows. SQLite's native caret and `NEAR(...)` expressions over unspaced text use original FTS5 tokens rather than sidecar substring semantics; use an ordinary quoted search when substring findability matters, at the cost of positional filtering.
 
@@ -126,11 +130,11 @@ Bare commands use the `default` preset; `--preset` names another; flags override
 
 ### Store choice
 
-Choose `sqlite` for the smallest setup, full FTS5 query syntax, and concurrent Sense commands. Choose `duckdb` when the cache should participate in DuckDB analytical work over large datasets or in local/cloud workflows. Choose `turso` for its embedded Rust engine and Tantivy text index. The DuckDB and Turso adapters are experimental, install their native package on first use, and currently serialize Sense commands that open the same cache.
+Choose `sqlite` for the smallest setup, full FTS5 query syntax, and concurrent Sense commands. Choose `duckdb` when the cache should participate in DuckDB analytical work over large datasets or in local/cloud workflows. Choose `turso` for its embedded Rust engine and Tantivy text index. The DuckDB and Turso adapters are experimental and install their native package on first use.
 
-The commands and table names are shared. Raw SQL still follows the selected engine's dialect, and advanced FTS5 operators only work on `sqlite`. DuckDB and Turso hold their cache file for the life of a native handle, so Sense commands opening the same cache wait for the current command or watcher cycle to close; this is an adapter limitation, not a reader/writer coexistence guarantee.
+The commands and table names are shared. Raw SQL still follows the selected engine's dialect, and advanced FTS5 operators only work on `sqlite`. Separate DuckDB processes may coexist only when every handle is observational and read-only. A DuckDB build-enabled open or watcher is read-write and excludes all other processes. Turso's observational path remains query-capable, so any Turso handle excludes other processes. Sense waits within a bounded lock budget for exclusive native access, then raises `STORE_BUSY`; neither adapter promises writer/reader coexistence. Public commands on one retained `Store` serialize separately, as described above.
 
-Vectors need a model. Naming a Hugging Face id in `embed.model` is consent to fetch it when `sense build`, `sense watch`, or a default CLI vector query first prepares vectors, with progress on stderr, into `~/.sense/models` (huggingface_hub's cache layout, one snapshot directory per resolved revision, shared by every tree, 124 MB, never in the package). `sense download` prefetches the same model ahead of time; it is idempotent and prints the resolved revision. `embed.model` is a Hugging Face id, or a path to a directory holding `model.safetensors` and `tokenizer.json`, which nothing fetches for you. A preset that asks for vectors when a local model path is missing those files is an error naming the fix, rather than a quieter result that would make the same search answer differently before and after; a preset whose `signals` exclude `vectors` never asks, so it is unaffected. An optional top-level `"embed": { "model", "provider", "url", "key" }` block points at any Model2Vec model, local path, or OpenAI-compatible endpoint (Ollama, LM Studio, hosted). Explicit builds and watch prepare all configured vectors. A default CLI vector query prepares only its eligible scope; `--no-build` requires that scope to be ready and never prepares it. Unrelated pending documents do not block either path.
+Vectors need a model. Naming a Hugging Face id in `embed.model` is consent to fetch it when `sense build`, `sense watch`, or a default CLI vector query first prepares vectors, with progress on stderr, into `~/.sense/models` (huggingface_hub's cache layout, one snapshot directory per resolved revision, shared by every tree, 124 MB, never in the package). `sense download` prefetches the same model ahead of time; it is idempotent and prints the resolved revision. `embed.model` is a Hugging Face id, or a path to a directory holding `model.safetensors` and `tokenizer.json`, which nothing fetches for you. A preset that asks for vectors when a local model path is missing those files is an error naming the fix, rather than a quieter result that would make the same search answer differently before and after; a preset whose `signals` exclude `vectors` never asks, so it is unaffected. An optional top-level `"embed": { "model", "provider", "url", "key" }` block points at any Model2Vec model, local path, or OpenAI-compatible endpoint (Ollama, LM Studio, hosted). Changing the provider, model, or effective endpoint invalidates stale vectors; changing chunk size rebuilds the affected embedding rows. Explicit builds and watch prepare all configured vectors. A default CLI vector query prepares only its eligible scope; `--no-build` requires that scope to be ready and never prepares it. Unrelated pending documents do not block either path.
 
 Sense adds `has(field, value)` for array membership or string containment and `basename(path)` for path queries on every store. SQLite and DuckDB also provide `segment(terms)` for hand-written matching over text without word spaces. A frontmatter syntax error records `_parse_error` and leaves that file's discovered fields empty; the file's content still enters the index.
 

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

@@ -7,7 +7,7 @@ export declare const USAGE: {
     readonly download: "download [--config path]";
     readonly sql: "sql \"<statement>\" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]";
     readonly search: "search \"<terms>\" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]";
-    readonly map: "map [--no-build] [--format table|json] [--config path]";
+    readonly map: "map [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]";
     readonly peek: "peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]";
     readonly path: "path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--no-build] [--format table|json] [--config path]";
     readonly related: "related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--no-build] [--format table|json|csv] [--config path]";

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

@@ -7,7 +7,7 @@ export declare const USAGE: {
     readonly download: "download [--config path]";
     readonly sql: "sql \"<statement>\" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]";
     readonly search: "search \"<terms>\" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]";
-    readonly map: "map [--no-build] [--format table|json] [--config path]";
+    readonly map: "map [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]";
     readonly peek: "peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]";
     readonly path: "path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--no-build] [--format table|json] [--config path]";
     readonly related: "related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--no-build] [--format table|json|csv] [--config path]";

package/dist/cjs/cli/index.js

@@ -54,7 +54,7 @@ var USAGE = {
     download: 'download [--config path]',
     sql: 'sql "<statement>" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]',
     search: 'search "<terms>" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]',
-    map: 'map [--no-build] [--format table|json] [--config path]',
+    map: 'map [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--no-build] [--format table|json] [--config path]',
     peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--no-build] [--format table|json] [--config path]',
     path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--max-depth n] [--no-build] [--format table|json] [--config path]',
     related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--no-build] [--format table|json|csv] [--config path]'

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// Each command's usage line, minus the leading \"usage: <name> \": shared by cli.ts's\n// usage() and the command's own parse() error/--help output so there is one copy, not two.\nexport const USAGE = {\n  init: 'init [--model id-or-path] [--provider static|openai|cohere] [--url url]',\n  build: 'build [--force] [--config path]',\n  watch: 'watch [--force] [--config path]',\n  status: 'status [--format table|json] [--config path]',\n  download: 'download [--config path]',\n  sql: 'sql \"<statement>\" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]',\n  search: 'search \"<terms>\" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]',\n  map: 'map [--no-build] [--format table|json] [--config path]',\n  peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]',\n  path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--no-build] [--format table|json] [--config path]',\n  related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--no-build] [--format table|json|csv] [--config path]',\n} as const;\n\n// Lazy registry: a command's imports load only when it runs, so a heavy dependency in one\n// command never taxes the others (or --version/--help). These names are reserved from saved queries.\nexport const COMMANDS: Record<string, () => Promise<{ default: Command }>> = {\n  init: () => import('./init.ts'),\n  build: () => import('./build.ts'),\n  watch: () => import('./watch.ts'),\n  status: () => import('./status.ts'),\n  download: () => import('./download.ts'),\n  sql: () => import('./sql.ts'),\n  search: () => import('./search.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n  path: () => import('./path.ts'),\n  related: () => import('./related.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["COMMANDS","USAGE","init","build","watch","status","download","sql","search","map","peek","path","related"],"mappings":";;;;;;;;;;;QAoBaA;eAAAA;;QAhBAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,OAAO;IACPC,QAAQ;IACRC,UAAU;IACVC,KAAK;IACLC,QAAQ;IACRC,KAAK;IACLC,MAAM;IACNC,MAAM;IACNC,SAAS;AACX;AAIO,IAAMZ,WAAgE;IAC3EE,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,UAAU,SAAVA;eAAgB;2DAAA,QAAO;;;IACvBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,SAAS,SAATA;eAAe;2DAAA,QAAO;;;AACxB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/index.ts"],"sourcesContent":["import type { Command } from './types.ts';\n\n// Each command's usage line, minus the leading \"usage: <name> \": shared by cli.ts's\n// usage() and the command's own parse() error/--help output so there is one copy, not two.\nexport const USAGE = {\n  init: 'init [--model id-or-path] [--provider static|openai|cohere] [--url url]',\n  build: 'build [--force] [--config path]',\n  watch: 'watch [--force] [--config path]',\n  status: 'status [--format table|json] [--config path]',\n  download: 'download [--config path]',\n  sql: 'sql \"<statement>\" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]',\n  search: 'search \"<terms>\" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]',\n  map: 'map [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]',\n  peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]',\n  path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--no-build] [--format table|json] [--config path]',\n  related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--no-build] [--format table|json|csv] [--config path]',\n} as const;\n\n// Lazy registry: a command's imports load only when it runs, so a heavy dependency in one\n// command never taxes the others (or --version/--help). These names are reserved from saved queries.\nexport const COMMANDS: Record<string, () => Promise<{ default: Command }>> = {\n  init: () => import('./init.ts'),\n  build: () => import('./build.ts'),\n  watch: () => import('./watch.ts'),\n  status: () => import('./status.ts'),\n  download: () => import('./download.ts'),\n  sql: () => import('./sql.ts'),\n  search: () => import('./search.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n  path: () => import('./path.ts'),\n  related: () => import('./related.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["COMMANDS","USAGE","init","build","watch","status","download","sql","search","map","peek","path","related"],"mappings":";;;;;;;;;;;QAoBaA;eAAAA;;QAhBAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,OAAO;IACPC,QAAQ;IACRC,UAAU;IACVC,KAAK;IACLC,QAAQ;IACRC,KAAK;IACLC,MAAM;IACNC,MAAM;IACNC,SAAS;AACX;AAIO,IAAMZ,WAAgE;IAC3EE,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,OAAO,SAAPA;eAAa;2DAAA,QAAO;;;IACpBC,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,UAAU,SAAVA;eAAgB;2DAAA,QAAO;;;IACvBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,QAAQ,SAARA;eAAc;2DAAA,QAAO;;;IACrBC,KAAK,SAALA;eAAW;2DAAA,QAAO;;;IAClBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,SAAS,SAATA;eAAe;2DAAA,QAAO;;;AACxB"}

package/dist/cjs/cli/path.js

@@ -8,9 +8,7 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _peekts = require("../commands/peek.js");
-var _scopets = require("../commands/scope.js");
-var _traversets = require("../graph/traverse.js");
+var _pathts = require("../commands/path.js");
 var _outputts = require("../output/output.js");
 var _indexts = require("./index.js");
 var _sharedts = require("./shared.js");
@@ -259,39 +257,17 @@ var pathCmd = function pathCmd(ctx) {
         ])
     }, function(store, cfg) {
         return _async_to_generator(function() {
-            var paths, from, to, allowed, hops, rows;
+            var hops, rows;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         return [
                             4,
-                            store.prepare('SELECT "path" FROM frontmatter')
+                            (0, _pathts.findPath)(store, cfg, a, b, _object_spread_props(_object_spread({}, (0, _sharedts.scopeOf)(values)), {
+                                maxDepth: maxDepth
+                            }))
                         ];
                     case 1:
-                        return [
-                            4,
-                            _state.sent().all()
-                        ];
-                    case 2:
-                        paths = _state.sent().map(function(r) {
-                            return r.path;
-                        });
-                        from = (0, _peekts.resolveNote)(paths, a);
-                        to = (0, _peekts.resolveNote)(paths, b);
-                        return [
-                            4,
-                            (0, _scopets.scopedPaths)(store, cfg, (0, _sharedts.scopeOf)(values))
-                        ];
-                    case 3:
-                        allowed = _state.sent();
-                        return [
-                            4,
-                            (0, _traversets.findPath)(store, from, to, {
-                                maxDepth: maxDepth,
-                                allowed: allowed
-                            })
-                        ];
-                    case 4:
                         hops = _state.sent();
                         if (format === 'json') {
                             console.log(JSON.stringify(hops));

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/path.ts"],"sourcesContent":["import { resolveNote } from '../commands/peek.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { findPath } from '../graph/traverse.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// --max-depth must be a positive integer, mirroring shared.ts's parseK.\nfunction parseMaxDepth(depth: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (depth === undefined) return undefined;\n  const parsed = Number(depth);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--max-depth expects a positive integer, got \"${depth}\"`);\n  return parsed;\n}\n\nconst pathCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.path}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, 'max-depth': { type: 'string' } });\n  const [a, b] = positionals;\n  if (!a || !b) ctx.usageError(usage);\n  const maxDepth = parseMaxDepth(values['max-depth'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n    const from = resolveNote(paths, a);\n    const to = resolveNote(paths, b);\n    const allowed = await scopedPaths(store, cfg, scopeOf(values));\n    const hops = await findPath(store, from, to, { maxDepth, allowed });\n\n    if (format === 'json') {\n      console.log(JSON.stringify(hops));\n      return;\n    }\n    if (hops === null) {\n      console.log(maxDepth ? `no path within ${maxDepth} hops` : 'no path');\n      return;\n    }\n    const rows: Row[] = hops.map((p, step) => ({ step, path: p }));\n    printRows(rows, format);\n  });\n};\nexport default pathCmd;\n"],"names":["parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","USAGE","name","path","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","type","values","positionals","a","b","maxDepth","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","paths","from","to","allowed","hops","rows","prepare","all","map","r","resolveNote","scopedPaths","scopeOf","findPath","console","log","JSON","stringify","p","step","printRows"],"mappings":";;;;+BA4CA;;;eAAA;;;sBA5C4B;uBACA;0BACH;wBAEC;uBAEJ;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,wEAAwE;AACxE,SAASA,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,gDAAqD,OAAND,OAAM;IAC/G,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,aAAa;YAAEC,MAAM;QAAS;SAA5HC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAeA,gCAAAA,iBAARC,IAAQD,iBAALE,IAAKF;IACf,IAAI,CAACC,KAAK,CAACC,GAAGf,IAAIN,UAAU,CAACO;IAC7B,IAAMe,WAAWxB,cAAcoB,MAAM,CAAC,YAAY,EAAwBZ,IAAIN,UAAU;IACxF,IAAMuB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAACnB,KAAKY,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,OACAC,MACAC,IACAC,SACAC,MAUAC;;;;wBAdiB;;4BAAMP,MAAMQ,OAAO,CAAC;;;wBAA3B;;4BAAO,cAAuDC,GAAG;;;wBAA3EP,QAAQ,AAAE,cAAiGQ,GAAG,CAAC,SAACC;mCAAMA,EAAE/B,IAAI;;wBAC5HuB,OAAOS,IAAAA,mBAAW,EAACV,OAAOZ;wBAC1Bc,KAAKQ,IAAAA,mBAAW,EAACV,OAAOX;wBACd;;4BAAMsB,IAAAA,oBAAW,EAACb,OAAOC,KAAKa,IAAAA,iBAAO,EAAC1B;;;wBAAhDiB,UAAU;wBACH;;4BAAMU,IAAAA,oBAAQ,EAACf,OAAOG,MAAMC,IAAI;gCAAEZ,UAAAA;gCAAUa,SAAAA;4BAAQ;;;wBAA3DC,OAAO;wBAEb,IAAIb,WAAW,QAAQ;4BACrBuB,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACb;4BAC3B;;;wBACF;wBACA,IAAIA,SAAS,MAAM;4BACjBU,QAAQC,GAAG,CAACzB,WAAW,AAAC,kBAA0B,OAATA,UAAS,WAAS;4BAC3D;;;wBACF;wBACMe,OAAcD,KAAKI,GAAG,CAAC,SAACU,GAAGC;mCAAU;gCAAEA,MAAAA;gCAAMzC,MAAMwC;4BAAE;;wBAC3DE,IAAAA,mBAAS,EAACf,MAAMd;;;;;;QAClB;;AACF;IACA,WAAelB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/path.ts"],"sourcesContent":["import { findPath } from '../commands/path.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// --max-depth must be a positive integer, mirroring shared.ts's parseK.\nfunction parseMaxDepth(depth: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (depth === undefined) return undefined;\n  const parsed = Number(depth);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--max-depth expects a positive integer, got \"${depth}\"`);\n  return parsed;\n}\n\nconst pathCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.path}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, 'max-depth': { type: 'string' } });\n  const [a, b] = positionals;\n  if (!a || !b) ctx.usageError(usage);\n  const maxDepth = parseMaxDepth(values['max-depth'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const hops = await findPath(store, cfg, a, b, { ...scopeOf(values), maxDepth });\n\n    if (format === 'json') {\n      console.log(JSON.stringify(hops));\n      return;\n    }\n    if (hops === null) {\n      console.log(maxDepth ? `no path within ${maxDepth} hops` : 'no path');\n      return;\n    }\n    const rows: Row[] = hops.map((p, step) => ({ step, path: p }));\n    printRows(rows, format);\n  });\n};\nexport default pathCmd;\n"],"names":["parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","USAGE","name","path","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","type","values","positionals","a","b","maxDepth","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","hops","rows","findPath","scopeOf","console","log","JSON","stringify","map","p","step","printRows"],"mappings":";;;;+BAsCA;;;eAAA;;;sBAtCyB;wBAEC;uBAEJ;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,wEAAwE;AACxE,SAASA,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,gDAAqD,OAAND,OAAM;IAC/G,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,aAAa;YAAEC,MAAM;QAAS;SAA5HC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAeA,gCAAAA,iBAARC,IAAQD,iBAALE,IAAKF;IACf,IAAI,CAACC,KAAK,CAACC,GAAGf,IAAIN,UAAU,CAACO;IAC7B,IAAMe,WAAWxB,cAAcoB,MAAM,CAAC,YAAY,EAAwBZ,IAAIN,UAAU;IACxF,IAAMuB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAACnB,KAAKY,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,MAUAC;;;;wBAVO;;4BAAMC,IAAAA,gBAAQ,EAACJ,OAAOC,KAAKX,GAAGC,GAAG,wCAAKc,IAAAA,iBAAO,EAACjB;gCAASI,UAAAA;;;;wBAA9DU,OAAO;wBAEb,IAAIT,WAAW,QAAQ;4BACrBa,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACP;4BAC3B;;;wBACF;wBACA,IAAIA,SAAS,MAAM;4BACjBI,QAAQC,GAAG,CAACf,WAAW,AAAC,kBAA0B,OAATA,UAAS,WAAS;4BAC3D;;;wBACF;wBACMW,OAAcD,KAAKQ,GAAG,CAAC,SAACC,GAAGC;mCAAU;gCAAEA,MAAAA;gCAAMhC,MAAM+B;4BAAE;;wBAC3DE,IAAAA,mBAAS,EAACV,MAAMV;;;;;;QAClB;;AACF;IACA,WAAelB"}

package/dist/cjs/cli/related.js

@@ -249,7 +249,6 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-var RELATED_DEFAULT_K = 5;
 var relatedCmd = function relatedCmd(ctx) {
     var _parseK;
     var usage = "usage: ".concat(ctx.name, " ").concat(_indexts1.USAGE.related);
@@ -260,7 +259,7 @@ var relatedCmd = function relatedCmd(ctx) {
     })), values = _parse.values, positionals = _parse.positionals;
     var _positionals = _sliced_to_array(positionals, 1), pathArg = _positionals[0];
     if (!pathArg) ctx.usageError(usage);
-    var k = (_parseK = (0, _sharedts.parseK)(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : RELATED_DEFAULT_K;
+    var k = (_parseK = (0, _sharedts.parseK)(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : _relatedts.RELATED_DEFAULT_K;
     var format = (0, _sharedts.rowFormatOf)(values);
     var noBuild = values['no-build'] === true;
     return (0, _sharedts.withDb)(ctx, values.config, {
@@ -303,7 +302,9 @@ var relatedCmd = function relatedCmd(ctx) {
                     case 4:
                         return [
                             4,
-                            (0, _relatedts.relatedNotes)(store, cfg, pathArg, overrides, k)
+                            (0, _relatedts.relatedNotes)(store, cfg, pathArg, _object_spread_props(_object_spread({}, overrides), {
+                                k: k
+                            }))
                         ];
                     case 5:
                         _outputts.printRows.apply(void 0, [

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { relatedNotes, resolveRelatedSeed } from '../commands/related.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst RELATED_DEFAULT_K = 5;\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, k: { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? RELATED_DEFAULT_K;\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  return withDb(ctx, values.config as string | undefined, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg, build) => {\n    const overrides = scopeOf(values);\n    if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n      const path = await resolveRelatedSeed(store, pathArg);\n      const allowed = await scopedPaths(store, cfg, overrides);\n      await prepareDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    }\n    printRows((await relatedNotes(store, cfg, pathArg, overrides, k)) as Row[], format);\n  });\n};\nexport default relatedCmd;\n"],"names":["RELATED_DEFAULT_K","relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","format","rowFormatOf","noBuild","withDb","config","requirements","Set","store","cfg","build","overrides","path","allowed","scopeOf","resolveSearch","signals","vectors","undefined","resolveRelatedSeed","scopedPaths","prepareDocumentEmbeddings","relatedNotes","printRows"],"mappings":";;;;+BA8BA;;;eAAA;;;yBA9BiD;uBACrB;uBACE;wBAEJ;sBACuC;wBAC3C;wBACuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7F,IAAMA,oBAAoB;AAE1B,IAAMC,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,eAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAAlHC,SAAwBR,OAAxBQ,QAAQC,cAAgBT,OAAhBS;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAAShB,IAAIiB,UAAU,CAACf;IAC7B,IAAMU,KAAIX,UAAAA,IAAAA,gBAAM,EAACa,OAAOF,CAAC,EAAwBZ,IAAIiB,UAAU,eAArDhB,qBAAAA,UAA0DH;IACpE,IAAMoB,SAASC,IAAAA,qBAAW,EAACL;IAC3B,IAAMM,UAAUN,MAAM,CAAC,WAAW,KAAK;IACvC,OAAOO,IAAAA,gBAAM,EAACrB,KAAKc,OAAOQ,MAAM,EAAwB;QAAEF,SAAAA;QAASG,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC,KAAKC;;gBACnIC,WAEEC,MACAC;;;;wBAHFF,YAAYG,IAAAA,iBAAO,EAACjB;6BACtBa,CAAAA,SAASK,IAAAA,sBAAa,EAACN,KAAKE,WAAWK,OAAO,CAACC,OAAO,KAAKC,SAAQ,GAAnER;;;;wBACW;;4BAAMS,IAAAA,6BAAkB,EAACX,OAAOT;;;wBAAvCa,OAAO;wBACG;;4BAAMQ,IAAAA,oBAAW,EAACZ,OAAOC,KAAKE;;;wBAAxCE,UAAU;wBAChB;;4BAAMQ,IAAAA,iCAAyB,EAACb,OAAOC,KAAK,IAAIF,IAAI,AAAC,qBAAGM;gCAASD;;;;wBAAjE;;;wBAES;;4BAAMU,IAAAA,uBAAY,EAACd,OAAOC,KAAKV,SAASY,WAAWhB;;;wBAA9D4B,mBAAS;4BAAE;4BAAiEtB;;;;;;;QAC9E;;AACF;IACA,WAAenB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { RELATED_DEFAULT_K, relatedNotes, resolveRelatedSeed } from '../commands/related.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, k: { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? RELATED_DEFAULT_K;\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  return withDb(ctx, values.config as string | undefined, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg, build) => {\n    const overrides = scopeOf(values);\n    if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n      const path = await resolveRelatedSeed(store, pathArg);\n      const allowed = await scopedPaths(store, cfg, overrides);\n      await prepareDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    }\n    printRows(await relatedNotes(store, cfg, pathArg, { ...overrides, k }), format);\n  });\n};\nexport default relatedCmd;\n"],"names":["relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","RELATED_DEFAULT_K","format","rowFormatOf","noBuild","withDb","config","requirements","Set","store","cfg","build","overrides","path","allowed","scopeOf","resolveSearch","signals","vectors","undefined","resolveRelatedSeed","scopedPaths","prepareDocumentEmbeddings","relatedNotes","printRows"],"mappings":";;;;+BA2BA;;;eAAA;;;yBA3BoE;uBACxC;uBACE;wBACJ;sBACuC;wBAC3C;wBACuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7F,IAAMA,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,eAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAAlHC,SAAwBR,OAAxBQ,QAAQC,cAAgBT,OAAhBS;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAAShB,IAAIiB,UAAU,CAACf;IAC7B,IAAMU,KAAIX,UAAAA,IAAAA,gBAAM,EAACa,OAAOF,CAAC,EAAwBZ,IAAIiB,UAAU,eAArDhB,qBAAAA,UAA0DiB,4BAAiB;IACrF,IAAMC,SAASC,IAAAA,qBAAW,EAACN;IAC3B,IAAMO,UAAUP,MAAM,CAAC,WAAW,KAAK;IACvC,OAAOQ,IAAAA,gBAAM,EAACtB,KAAKc,OAAOS,MAAM,EAAwB;QAAEF,SAAAA;QAASG,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC,KAAKC;;gBACnIC,WAEEC,MACAC;;;;wBAHFF,YAAYG,IAAAA,iBAAO,EAAClB;6BACtBc,CAAAA,SAASK,IAAAA,sBAAa,EAACN,KAAKE,WAAWK,OAAO,CAACC,OAAO,KAAKC,SAAQ,GAAnER;;;;wBACW;;4BAAMS,IAAAA,6BAAkB,EAACX,OAAOV;;;wBAAvCc,OAAO;wBACG;;4BAAMQ,IAAAA,oBAAW,EAACZ,OAAOC,KAAKE;;;wBAAxCE,UAAU;wBAChB;;4BAAMQ,IAAAA,iCAAyB,EAACb,OAAOC,KAAK,IAAIF,IAAI,AAAC,qBAAGM;gCAASD;;;;wBAAjE;;;wBAEQ;;4BAAMU,IAAAA,uBAAY,EAACd,OAAOC,KAAKX,SAAS,wCAAKa;gCAAWjB,GAAAA;;;;wBAAlE6B,mBAAS;4BAAC;4BAA8DtB;;;;;;;QAC1E;;AACF;IACA,WAAepB"}

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

@@ -1,10 +1,13 @@
-export type { TreeMap } from './map.js';
+export type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.js';
 export { mapTree } from './map.js';
-export type { Peek } from './peek.js';
+export type { PathOptions } from './path.js';
+export { findPath } from './path.js';
+export type { Peek, PeekSection } from './peek.js';
 export { peek, resolveNote } from './peek.js';
+export type { RelatedOptions, RelatedResult } from './related.js';
 export { relatedNotes } from './related.js';
 export { scopedPaths } from './scope.js';
-export type { SearchOptions } from './search.js';
+export type { SearchOptions, SearchResult, SearchResultVia } from './search.js';
 export { search } from './search.js';
 export type { PresetCoverage } from './status.js';
 export { presetCoverage } from './status.js';

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

@@ -1,10 +1,13 @@
-export type { TreeMap } from './map.js';
+export type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.js';
 export { mapTree } from './map.js';
-export type { Peek } from './peek.js';
+export type { PathOptions } from './path.js';
+export { findPath } from './path.js';
+export type { Peek, PeekSection } from './peek.js';
 export { peek, resolveNote } from './peek.js';
+export type { RelatedOptions, RelatedResult } from './related.js';
 export { relatedNotes } from './related.js';
 export { scopedPaths } from './scope.js';
-export type { SearchOptions } from './search.js';
+export type { SearchOptions, SearchResult, SearchResultVia } from './search.js';
 export { search } from './search.js';
 export type { PresetCoverage } from './status.js';
 export { presetCoverage } from './status.js';

package/dist/cjs/commands/index.js

@@ -11,6 +11,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get findPath () {
+        return _pathts.findPath;
+    },
     get mapTree () {
         return _mapts.mapTree;
     },
@@ -34,6 +37,7 @@ _export(exports, {
     }
 });
 var _mapts = require("./map.js");
+var _pathts = require("./path.js");
 var _peekts = require("./peek.js");
 var _relatedts = require("./related.js");
 var _scopets = require("./scope.js");

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/index.ts"],"sourcesContent":["// The three commands: mapTree (orient), search (locate), peek (structure).\n// Each returns data; cli.ts renders. All of them degrade when a feature is off.\n\nexport type { TreeMap } from './map.ts';\nexport { mapTree } from './map.ts';\nexport type { Peek } from './peek.ts';\nexport { peek, resolveNote } from './peek.ts';\nexport { relatedNotes } from './related.ts';\nexport { scopedPaths } from './scope.ts';\nexport type { SearchOptions } from './search.ts';\nexport { search } from './search.ts';\nexport type { PresetCoverage } from './status.ts';\nexport { presetCoverage } from './status.ts';\n"],"names":["mapTree","peek","presetCoverage","relatedNotes","resolveNote","scopedPaths","search"],"mappings":"AAAA,2EAA2E;AAC3E,gFAAgF;;;;;;;;;;;;QAGvEA;eAAAA,cAAO;;QAEPC;eAAAA,YAAI;;QAMJC;eAAAA,wBAAc;;QALdC;eAAAA,uBAAY;;QADNC;eAAAA,mBAAW;;QAEjBC;eAAAA,oBAAW;;QAEXC;eAAAA,gBAAM;;;qBANS;sBAEU;yBACL;uBACD;wBAEL;wBAEQ"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/index.ts"],"sourcesContent":["// The three commands: mapTree (orient), search (locate), peek (structure).\n// Each returns data; cli.ts renders. All of them degrade when a feature is off.\n\nexport type { TreeMap, TreeMapField, TreeMapHub, TreeMapRecent } from './map.ts';\nexport { mapTree } from './map.ts';\nexport type { PathOptions } from './path.ts';\nexport { findPath } from './path.ts';\nexport type { Peek, PeekSection } from './peek.ts';\nexport { peek, resolveNote } from './peek.ts';\nexport type { RelatedOptions, RelatedResult } from './related.ts';\nexport { relatedNotes } from './related.ts';\nexport { scopedPaths } from './scope.ts';\nexport type { SearchOptions, SearchResult, SearchResultVia } from './search.ts';\nexport { search } from './search.ts';\nexport type { PresetCoverage } from './status.ts';\nexport { presetCoverage } from './status.ts';\n"],"names":["findPath","mapTree","peek","presetCoverage","relatedNotes","resolveNote","scopedPaths","search"],"mappings":"AAAA,2EAA2E;AAC3E,gFAAgF;;;;;;;;;;;;QAKvEA;eAAAA,gBAAQ;;QAFRC;eAAAA,cAAO;;QAIPC;eAAAA,YAAI;;QAOJC;eAAAA,wBAAc;;QALdC;eAAAA,uBAAY;;QAFNC;eAAAA,mBAAW;;QAGjBC;eAAAA,oBAAW;;QAEXC;eAAAA,gBAAM;;;qBATS;sBAEC;sBAES;yBAEL;uBACD;wBAEL;wBAEQ"}

package/dist/cjs/commands/map.d.cts

@@ -1,21 +1,30 @@
 import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.js';
-import type { Row } from '../output/output.js';
-import type { Store } from '../store/types.js';
+import type { FieldStat, Store } from '../store/types.js';
 import type { PresetCoverage } from './status.js';
 export interface TreeMap {
     docs: {
         count: number;
         bytes: number;
     };
-    fields: Row[];
+    fields: TreeMapField[];
     fieldsTotal: number;
     features: {
         on: FeatureName[];
         off: FeatureName[];
     };
     presets: PresetCoverage[];
-    hubs: Row[];
-    recent: Row[];
+    hubs: TreeMapHub[];
+    recent: TreeMapRecent[];
     recentCaveat: string | null;
 }
+export type TreeMapField = FieldStat;
+export type TreeMapHub = {
+    path: string;
+    rank: number;
+    title: string;
+};
+export type TreeMapRecent = {
+    path: string;
+    modified: string;
+};
 export declare function mapTree(store: Store, cfg: ResolvedConfig, overrides?: SearchOverrides): Promise<TreeMap>;

package/dist/cjs/commands/map.d.ts

@@ -1,21 +1,30 @@
 import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.js';
-import type { Row } from '../output/output.js';
-import type { Store } from '../store/types.js';
+import type { FieldStat, Store } from '../store/types.js';
 import type { PresetCoverage } from './status.js';
 export interface TreeMap {
     docs: {
         count: number;
         bytes: number;
     };
-    fields: Row[];
+    fields: TreeMapField[];
     fieldsTotal: number;
     features: {
         on: FeatureName[];
         off: FeatureName[];
     };
     presets: PresetCoverage[];
-    hubs: Row[];
-    recent: Row[];
+    hubs: TreeMapHub[];
+    recent: TreeMapRecent[];
     recentCaveat: string | null;
 }
+export type TreeMapField = FieldStat;
+export type TreeMapHub = {
+    path: string;
+    rank: number;
+    title: string;
+};
+export type TreeMapRecent = {
+    path: string;
+    modified: string;
+};
 export declare function mapTree(store: Store, cfg: ResolvedConfig, overrides?: SearchOverrides): Promise<TreeMap>;

package/dist/cjs/commands/map.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "mapTree", {
 var _indexts = require("../config/index.js");
 var _serialqueryts = require("../lib/serial-query.js");
 var _scopets = require("./scope.js");
+var _snapshotts = require("./snapshot.js");
 var _statusts = require("./status.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -194,6 +195,12 @@ function mapIndexed(store, cfg, overrides) {
                         return _ts_generator(this, function(_state) {
                             switch(_state.label){
                                 case 0:
+                                    return [
+                                        4,
+                                        (0, _snapshotts.assertQuerySnapshot)(store, cfg)
+                                    ];
+                                case 1:
+                                    _state.sent();
                                     _tmp = [
                                         store
                                     ];
@@ -201,14 +208,14 @@ function mapIndexed(store, cfg, overrides) {
                                         4,
                                         (0, _scopets.scopedPaths)(store, cfg, overrides)
                                     ];
-                                case 1:
+                                case 2:
                                     return [
                                         4,
                                         _scopets.setupMapScope.apply(void 0, _tmp.concat([
                                             _state.sent()
                                         ]))
                                     ];
-                                case 2:
+                                case 3:
                                     _state.sent();
                                     scopeWhere = 'WHERE "path" IN (SELECT "path" FROM _map_scope)';
                                     scopeAnd = 'AND f."path" IN (SELECT "path" FROM _map_scope)';
@@ -216,18 +223,18 @@ function mapIndexed(store, cfg, overrides) {
                                         4,
                                         store.prepare('SELECT COUNT(*) AS count, COALESCE(SUM("_size"), 0) AS bytes FROM frontmatter '.concat(scopeWhere))
                                     ];
-                                case 3:
+                                case 4:
                                     return [
                                         4,
                                         _state.sent().get()
                                     ];
-                                case 4:
+                                case 5:
                                     docs = _state.sent();
                                     return [
                                         4,
                                         store.docs.columns()
                                     ];
-                                case 5:
+                                case 6:
                                     columns = _state.sent().filter(function(name) {
                                         return !_scopets.INTERNAL_COLUMNS.has(name);
                                     });
@@ -235,20 +242,20 @@ function mapIndexed(store, cfg, overrides) {
                                     // every distinct type observed across the scope is reported, not just the first.
                                     allFields = [];
                                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                    _state.label = 6;
-                                case 6:
+                                    _state.label = 7;
+                                case 7:
                                     _state.trys.push([
-                                        6,
-                                        11,
+                                        7,
                                         12,
-                                        13
+                                        13,
+                                        14
                                     ]);
                                     _iterator = chunk(columns, MAP_COLUMN_CHUNK)[Symbol.iterator]();
-                                    _state.label = 7;
-                                case 7:
+                                    _state.label = 8;
+                                case 8:
                                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                                         3,
-                                        10
+                                        11
                                     ];
                                     group = _step.value;
                                     _1 = (_ = (_allFields = allFields).push).apply;
@@ -259,33 +266,33 @@ function mapIndexed(store, cfg, overrides) {
                                         4,
                                         store.docs.fieldStats(group, scopeWhere)
                                     ];
-                                case 8:
+                                case 9:
                                     _1.apply(_, _tmp1.concat([
                                         _to_consumable_array.apply(void 0, [
                                             _state.sent()
                                         ])
                                     ]));
-                                    _state.label = 9;
-                                case 9:
+                                    _state.label = 10;
+                                case 10:
                                     _iteratorNormalCompletion = true;
                                     return [
                                         3,
-                                        7
+                                        8
                                     ];
-                                case 10:
+                                case 11:
                                     return [
                                         3,
-                                        13
+                                        14
                                     ];
-                                case 11:
+                                case 12:
                                     err = _state.sent();
                                     _didIteratorError = true;
                                     _iteratorError = err;
                                     return [
                                         3,
-                                        13
+                                        14
                                     ];
-                                case 12:
+                                case 13:
                                     try {
                                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                                             _iterator.return();
@@ -298,45 +305,45 @@ function mapIndexed(store, cfg, overrides) {
                                     return [
                                         7
                                     ];
-                                case 13:
+                                case 14:
                                     allFields.sort(function(a, b) {
                                         return b.coverage - a.coverage;
                                     });
                                     fields = allFields.slice(0, 20);
                                     if (!(0, _indexts.featureEnabled)(cfg, 'rank')) return [
                                         3,
-                                        16
+                                        17
                                     ];
                                     return [
                                         4,
                                         store.prepare('SELECT f."path" AS path, round(f."_rank" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f."path" WHERE f."_rank" IS NOT NULL '.concat(scopeAnd, ' ORDER BY f."_rank" DESC, f."path" ASC LIMIT 8'))
                                     ];
-                                case 14:
+                                case 15:
                                     return [
                                         4,
                                         _state.sent().all()
                                     ];
-                                case 15:
+                                case 16:
                                     _tmp2 = _state.sent();
                                     return [
                                         3,
-                                        17
+                                        18
                                     ];
-                                case 16:
-                                    _tmp2 = [];
-                                    _state.label = 17;
                                 case 17:
+                                    _tmp2 = [];
+                                    _state.label = 18;
+                                case 18:
                                     hubs = _tmp2;
                                     return [
                                         4,
                                         store.prepare('SELECT "path", "_mtime" AS mtime FROM frontmatter '.concat(scopeWhere, ' ORDER BY "_mtime" DESC, "path" ASC LIMIT 5'))
                                     ];
-                                case 18:
+                                case 19:
                                     return [
                                         4,
                                         _state.sent().all()
                                     ];
-                                case 19:
+                                case 20:
                                     recent = _state.sent().map(function(r) {
                                         return {
                                             path: r.path,
@@ -347,12 +354,12 @@ function mapIndexed(store, cfg, overrides) {
                                         4,
                                         store.prepare("SELECT COUNT(*) AS n FROM frontmatter ".concat(scopeWhere, ' GROUP BY CAST("_mtime" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1'))
                                     ];
-                                case 20:
+                                case 21:
                                     return [
                                         4,
                                         _state.sent().get()
                                     ];
-                                case 21:
+                                case 22:
                                     topSecond = _state.sent();
                                     recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? "".concat(topSecond.n, " of ").concat(docs.count, " files share one modified second, so recency likely reflects a checkout or copy, not edit history") : null;
                                     _tmp3 = {
@@ -365,7 +372,7 @@ function mapIndexed(store, cfg, overrides) {
                                         4,
                                         (0, _statusts.presetCoverage)(store, cfg)
                                     ];
-                                case 22:
+                                case 23:
                                     return [
                                         2,
                                         (_tmp3.presets = _state.sent(), _tmp3.hubs = hubs, _tmp3.recent = recent, _tmp3.recentCaveat = recentCaveat, _tmp3)