sensemaking 0.24.6 → 0.25.0

package/README.md

@@ -2,20 +2,20 @@
 
 Search and query a directory of Markdown notes from the command line. `sense` indexes frontmatter, prose and links in a local database. It can also combine word matches with links and semantic similarity.
 
-Results contain file paths, snippets and line ranges. A person or agent can inspect the relevant passages without loading every note. No server or build step is required.
+Results contain file paths, snippets and line ranges. A person or agent can inspect the relevant passages without loading every note. No server or daemon is required; the default CLI query performs the incremental preparation it needs.
 
 ## Problem
 
 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 a local database (SQLite by default, or the experimental DuckDB store, see Config) 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 a local database (SQLite by default, or the experimental DuckDB store, see Config). By default, CLI queries reconcile the capabilities they need before reading; `--no-build` instead reads the last completed indexed generation without scanning live files. Nothing has to be running.
 
 ## Quick start
 
 ```bash
 npm install -g sensemaking
 cd your-notes && sense init
-sense download          # the embedding model, once per machine; the first vector search fetches it otherwise
+sense download          # optional prefetch; build or the first default vector search fetches it otherwise
 ```
 
 Requires Node.js 22.20 or newer. The default store uses Node's built-in SQLite.
@@ -65,6 +65,7 @@ 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 |
 | `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) |
@@ -74,9 +75,15 @@ ORDER BY bm25(content, 10.0, 5.0, 1.0) LIMIT 10
 | `<name> [params...]` | run a query saved in the config; `--list` names them |
 | `init` | write a starter `sense.config.json` |
 | `status` | index location, doc count, per-preset coverage, watcher heartbeat |
-| `download` | fetch the embedding model named in the config (once per machine; the first vector search fetches it otherwise) |
+| `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)) |
 
+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.
+
+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.
+
 `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: []`.
@@ -90,7 +97,8 @@ Lexical words are case- and accent-insensitive. SQLite and DuckDB use their nati
 ```json
 {
   "$schema": "https://unpkg.com/sensemaking/schema.json",
-  "version": 5,
+  "version": 6,
+  "build": true,
   "presets": {
     "default": { "include": ["**/*.md"], "k": 10 },
     "raw":     { "include": ["raw/**/*.md"], "k": 5 }
@@ -106,6 +114,7 @@ Lexical words are case- and accent-insensitive. SQLite and DuckDB use their nati
 
 | key | holds |
 |---|---|
+| `build` | CLI query-time build default, `true`. Set `false` to query the existing index maintained by explicit `build` or `watch`; `--no-build` overrides `true` for one query. |
 | `root` | optional markdown-tree path. Relative to the config directory; omitted means that directory. Preset globs, filesystem reads, watcher events, and indexed `path` values use this root. `.sense/` state stays beside the config. Changing it rebuilds the index. |
 | `presets` | named bundles of `include`/`exclude` globs, `k` (result count), `signals` (which engines this scope searches with, `words`, `links`, `vectors`; every signal whose prerequisites hold, unless the preset lists them exhaustively), `where` (a standing SQL filter). A file is indexed if any preset includes it, embedded if a model is named and some covering preset's `signals` include `vectors`; `status` shows each preset's coverage. |
 | `embed` | the model vectors are built with. Naming one gives the tree vectors; omitting the block means none at all, whatever the presets say. `sense download` fetches it. |
@@ -119,9 +128,9 @@ Bare commands use the `default` preset; `--preset` names another; flags override
 
 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.
 
-The commands and table names are shared. Raw SQL still follows the selected engine's dialect, and advanced FTS5 operators only work on `sqlite`.
+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.
 
-Vectors need a model. Naming a Hugging Face id in `embed.model` is consent to fetch it: it downloads lazily, on the first vector search, 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, so the wait happens on your schedule instead of the first query's; 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). Embedding the notes themselves happens on the first vector search, with progress.
+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.
 
 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.
 
@@ -155,11 +164,11 @@ Ollama serves this shape at `http://localhost:11434/v1`. LM Studio serves the sa
 
 ## 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:
+Default CLI queries start with an incremental build of the capabilities they need; only changed files are re-parsed. `--no-build` skips that scan and reads the last completed generation. What to expect as a tree grows:
 
-- **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.
+- **Build work is linear in note count.** Crawl and reconcile are the floor cost of a default query and the first thing to watch on a large tree; `--no-build` avoids them when snapshot semantics are appropriate.
 - **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 coordination](https://github.com/kmalakoff/sensemaking/blob/master/DESIGN.md#watch-coordination)): it changes latency, never answers, since every query reconciles for itself. To start the cache over, delete the directory `sense status` prints.
+- **Bulk changes are paid by the next builder.** That is normally the next default query. `sense watch` moves the re-parse into the background ([watch coordination](https://github.com/kmalakoff/sensemaking/blob/master/DESIGN.md#watch-coordination)); `--no-build` continues to read the last completed generation. Run `sense build --force` to recreate the derived index.
 
 ## For AI agents
 
@@ -178,7 +187,7 @@ Three skills: `sense` for querying a tree, including store-specific SQL and sear
 ## 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.
+- **Index-on-build tools (MarkdownDB):** query a snapshot; `sense` defaults to an incremental build before querying and also offers explicit snapshot reads with `--no-build`.
 - **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.

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

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

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

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

package/dist/cjs/cli/build.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _indexts = require("../store/index.js");
+var _indexts1 = require("./index.js");
+var _sharedts = require("./shared.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var build = function build(ctx) {
+    return _async_to_generator(function() {
+        var values, result;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts1.USAGE.build), _object_spread({
+                        force: {
+                            type: 'boolean',
+                            default: false
+                        }
+                    }, _sharedts.CONFIG)).values;
+                    return [
+                        4,
+                        (0, _indexts.buildIndex)(ctx.resolveConfig(values.config), {
+                            force: values.force === true
+                        })
+                    ];
+                case 1:
+                    result = _state.sent();
+                    (0, _sharedts.printWarnings)(result.warnings);
+                    console.log("".concat(ctx.name, " build: ").concat(result.parsed, " file(s) parsed; index ready at ").concat(result.dbPath));
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+};
+var _default = build;
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/build.ts"],"sourcesContent":["import { buildIndex } from '../store/index.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst build: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.build}`, { force: { type: 'boolean', default: false }, ...CONFIG });\n  const result = await buildIndex(ctx.resolveConfig(values.config as string | undefined), { force: values.force === true });\n  printWarnings(result.warnings);\n  console.log(`${ctx.name} build: ${result.parsed} file(s) parsed; index ready at ${result.dbPath}`);\n};\n\nexport default build;\n"],"names":["build","ctx","values","result","parse","argv","USAGE","name","force","type","default","CONFIG","buildIndex","resolveConfig","config","printWarnings","warnings","console","log","parsed","dbPath"],"mappings":";;;;+BAYA;;;eAAA;;;uBAZ2B;wBACL;wBACuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7C,IAAMA,QAAiB,eAAOC;;YACpBC,QACFC;;;;oBADED,SAAWE,IAAAA,eAAK,EAACH,IAAII,IAAI,EAAE,AAAC,UAAqBC,OAAZL,IAAIM,IAAI,EAAC,KAAe,OAAZD,eAAK,CAACN,KAAK,GAAI;wBAAEQ,OAAO;4BAAEC,MAAM;4BAAWC,SAAS;wBAAM;uBAAMC,gBAAM,GAAvHT;oBACO;;wBAAMU,IAAAA,mBAAU,EAACX,IAAIY,aAAa,CAACX,OAAOY,MAAM,GAAyB;4BAAEN,OAAON,OAAOM,KAAK,KAAK;wBAAK;;;oBAAjHL,SAAS;oBACfY,IAAAA,uBAAa,EAACZ,OAAOa,QAAQ;oBAC7BC,QAAQC,GAAG,CAAC,AAAC,GAAqBf,OAAnBF,IAAIM,IAAI,EAAC,YAA0DJ,OAAhDA,OAAOgB,MAAM,EAAC,oCAAgD,OAAdhB,OAAOiB,MAAM;;;;;;IACjG;;IAEA,WAAepB"}

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

@@ -1,15 +1,16 @@
 import type { Command } from './types.js';
 export declare const USAGE: {
     readonly init: "init [--model id-or-path] [--provider static|openai|cohere] [--url url]";
+    readonly build: "build [--force] [--config path]";
     readonly watch: "watch [--force] [--config path]";
     readonly status: "status [--format table|json] [--config path]";
     readonly download: "download [--config path]";
-    readonly sql: "sql \"<statement>\" [params...] [--preset name] [--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] [--format table|json|csv] [--config path]";
-    readonly map: "map [--format table|json] [--config path]";
-    readonly peek: "peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--format table|json] [--config path]";
-    readonly path: "path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--format table|json] [--config path]";
-    readonly related: "related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--format table|json|csv] [--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 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]";
 };
 export declare const COMMANDS: Record<string, () => Promise<{
     default: Command;

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

@@ -1,15 +1,16 @@
 import type { Command } from './types.js';
 export declare const USAGE: {
     readonly init: "init [--model id-or-path] [--provider static|openai|cohere] [--url url]";
+    readonly build: "build [--force] [--config path]";
     readonly watch: "watch [--force] [--config path]";
     readonly status: "status [--format table|json] [--config path]";
     readonly download: "download [--config path]";
-    readonly sql: "sql \"<statement>\" [params...] [--preset name] [--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] [--format table|json|csv] [--config path]";
-    readonly map: "map [--format table|json] [--config path]";
-    readonly peek: "peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--format table|json] [--config path]";
-    readonly path: "path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--format table|json] [--config path]";
-    readonly related: "related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--format table|json|csv] [--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 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]";
 };
 export declare const COMMANDS: Record<string, () => Promise<{
     default: Command;

package/dist/cjs/cli/index.js

@@ -48,15 +48,16 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 var USAGE = {
     init: 'init [--model id-or-path] [--provider static|openai|cohere] [--url url]',
+    build: 'build [--force] [--config path]',
     watch: 'watch [--force] [--config path]',
     status: 'status [--format table|json] [--config path]',
     download: 'download [--config path]',
-    sql: 'sql "<statement>" [params...] [--preset name] [--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] [--format table|json|csv] [--config path]',
-    map: 'map [--format table|json] [--config path]',
-    peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--format table|json] [--config path]',
-    path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--max-depth n] [--format table|json] [--config path]',
-    related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--format table|json|csv] [--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]',
+    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]'
 };
 var COMMANDS = {
     init: function init() {
@@ -64,6 +65,11 @@ var COMMANDS = {
             return /*#__PURE__*/ _interop_require_wildcard(require("./init.js"));
         });
     },
+    build: function build() {
+        return Promise.resolve().then(function() {
+            return /*#__PURE__*/ _interop_require_wildcard(require("./build.js"));
+        });
+    },
     watch: function watch() {
         return Promise.resolve().then(function() {
             return /*#__PURE__*/ _interop_require_wildcard(require("./watch.js"));

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  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] [--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] [--format table|json|csv] [--config path]',\n  map: 'map [--format table|json] [--config path]',\n  peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--format table|json] [--config path]',\n  path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--format table|json] [--config path]',\n  related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--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  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","watch","status","download","sql","search","map","peek","path","related"],"mappings":";;;;;;;;;;;QAmBaA;eAAAA;;QAfAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,QAAQ;IACRC,UAAU;IACVC,KAAK;IACLC,QAAQ;IACRC,KAAK;IACLC,MAAM;IACNC,MAAM;IACNC,SAAS;AACX;AAIO,IAAMX,WAAgE;IAC3EE,MAAM,SAANA;eAAY;2DAAA,QAAO;;;IACnBC,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 [--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/init.js

@@ -40,9 +40,9 @@ var init = function init(ctx) {
     // Naming a model is consent to fetch it, so writing one into the config says so loudly,
     // with the download consequence and the prefetch command, right where it was just written.
     if (provider === 'static') {
-        console.log("embed model: ".concat(model, " (static); nothing downloads until the first vector search -- ").concat(ctx.name, " download fetches it now instead"));
+        console.log("embed model: ".concat(model, " (static); ").concat(ctx.name, " build, watch, or a vector search downloads it when needed -- ").concat(ctx.name, " download fetches it now instead"));
     } else {
-        console.log("embed model: ".concat(model, " (").concat(provider).concat(url ? " at ".concat(url) : '', "); reached over the network at search time, nothing to download"));
+        console.log("embed model: ".concat(model, " (").concat(provider).concat(url ? " at ".concat(url) : '', "); build, watch, and vector queries use the network, nothing to download"));
     }
     console.log('a non-English tree should pick a model for its languages: see the sense-setup skill or INTEGRATIONS.md');
     // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/init.ts"],"sourcesContent":["import { DEFAULT_EMBED_MODEL, initConfig } from '../config/index.ts';\nimport { USAGE } from './index.ts';\nimport { parse } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst init: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.init}`, {\n    model: { type: 'string' },\n    provider: { type: 'string' },\n    url: { type: 'string' },\n  });\n  const modelFlag = values.model as string | undefined;\n  const providerFlag = values.provider as string | undefined;\n  const model = modelFlag ?? DEFAULT_EMBED_MODEL;\n  const provider = providerFlag ?? 'static';\n  const url = values.url as string | undefined;\n  // An invalid --provider throws here (validateConfig's own shape error), before anything is\n  // written -- one validator, not a second copy of its rules.\n  const configPath = initConfig(process.cwd(), { model: modelFlag, provider: providerFlag, url });\n  console.log(`created ${configPath}`);\n  console.log(`query away: ${ctx.name} sql \"SELECT path FROM frontmatter LIMIT 10\"`);\n  // Naming a model is consent to fetch it, so writing one into the config says so loudly,\n  // with the download consequence and the prefetch command, right where it was just written.\n  if (provider === 'static') {\n    console.log(`embed model: ${model} (static); nothing downloads until the first vector search -- ${ctx.name} download fetches it now instead`);\n  } else {\n    console.log(`embed model: ${model} (${provider}${url ? ` at ${url}` : ''}); reached over the network at search time, nothing to download`);\n  }\n  console.log('a non-English tree should pick a model for its languages: see the sense-setup skill or INTEGRATIONS.md');\n  // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not\n  // in this output; name both places that hold them, since an agent may have neither.\n  console.log('features and tree design: the sense-setup skill, or schema.json');\n};\nexport default init;\n"],"names":["init","ctx","values","parse","argv","USAGE","name","model","type","provider","url","modelFlag","providerFlag","DEFAULT_EMBED_MODEL","configPath","initConfig","process","cwd","console","log"],"mappings":";;;;+BAiCA;;;eAAA;;;uBAjCgD;wBAC1B;wBACA;AAGtB,IAAMA,OAAgB,cAACC;IACrB,IAAM,AAAEC,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAc,OAAXD,eAAK,CAACL,IAAI,GAAI;QACrEO,OAAO;YAAEC,MAAM;QAAS;QACxBC,UAAU;YAAED,MAAM;QAAS;QAC3BE,KAAK;YAAEF,MAAM;QAAS;IACxB,GAJQN;IAKR,IAAMS,YAAYT,OAAOK,KAAK;IAC9B,IAAMK,eAAeV,OAAOO,QAAQ;IACpC,IAAMF,QAAQI,sBAAAA,uBAAAA,YAAaE,4BAAmB;IAC9C,IAAMJ,WAAWG,yBAAAA,0BAAAA,eAAgB;IACjC,IAAMF,MAAMR,OAAOQ,GAAG;IACtB,2FAA2F;IAC3F,4DAA4D;IAC5D,IAAMI,aAAaC,IAAAA,mBAAU,EAACC,QAAQC,GAAG,IAAI;QAAEV,OAAOI;QAAWF,UAAUG;QAAcF,KAAAA;IAAI;IAC7FQ,QAAQC,GAAG,CAAC,AAAC,WAAqB,OAAXL;IACvBI,QAAQC,GAAG,CAAC,AAAC,eAAuB,OAATlB,IAAIK,IAAI,EAAC;IACpC,wFAAwF;IACxF,2FAA2F;IAC3F,IAAIG,aAAa,UAAU;QACzBS,QAAQC,GAAG,CAAC,AAAC,gBAAqFlB,OAAtEM,OAAM,kEAAyE,OAATN,IAAIK,IAAI,EAAC;IAC7G,OAAO;QACLY,QAAQC,GAAG,CAAC,AAAC,gBAAyBV,OAAVF,OAAM,MAAeG,OAAXD,UAAmC,OAAxBC,MAAM,AAAC,OAAU,OAAJA,OAAQ,IAAG;IAC3E;IACAQ,QAAQC,GAAG,CAAC;IACZ,4FAA4F;IAC5F,oFAAoF;IACpFD,QAAQC,GAAG,CAAC;AACd;IACA,WAAenB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/init.ts"],"sourcesContent":["import { DEFAULT_EMBED_MODEL, initConfig } from '../config/index.ts';\nimport { USAGE } from './index.ts';\nimport { parse } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst init: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.init}`, {\n    model: { type: 'string' },\n    provider: { type: 'string' },\n    url: { type: 'string' },\n  });\n  const modelFlag = values.model as string | undefined;\n  const providerFlag = values.provider as string | undefined;\n  const model = modelFlag ?? DEFAULT_EMBED_MODEL;\n  const provider = providerFlag ?? 'static';\n  const url = values.url as string | undefined;\n  // An invalid --provider throws here (validateConfig's own shape error), before anything is\n  // written -- one validator, not a second copy of its rules.\n  const configPath = initConfig(process.cwd(), { model: modelFlag, provider: providerFlag, url });\n  console.log(`created ${configPath}`);\n  console.log(`query away: ${ctx.name} sql \"SELECT path FROM frontmatter LIMIT 10\"`);\n  // Naming a model is consent to fetch it, so writing one into the config says so loudly,\n  // with the download consequence and the prefetch command, right where it was just written.\n  if (provider === 'static') {\n    console.log(`embed model: ${model} (static); ${ctx.name} build, watch, or a vector search downloads it when needed -- ${ctx.name} download fetches it now instead`);\n  } else {\n    console.log(`embed model: ${model} (${provider}${url ? ` at ${url}` : ''}); build, watch, and vector queries use the network, nothing to download`);\n  }\n  console.log('a non-English tree should pick a model for its languages: see the sense-setup skill or INTEGRATIONS.md');\n  // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not\n  // in this output; name both places that hold them, since an agent may have neither.\n  console.log('features and tree design: the sense-setup skill, or schema.json');\n};\nexport default init;\n"],"names":["init","ctx","values","parse","argv","USAGE","name","model","type","provider","url","modelFlag","providerFlag","DEFAULT_EMBED_MODEL","configPath","initConfig","process","cwd","console","log"],"mappings":";;;;+BAiCA;;;eAAA;;;uBAjCgD;wBAC1B;wBACA;AAGtB,IAAMA,OAAgB,cAACC;IACrB,IAAM,AAAEC,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAc,OAAXD,eAAK,CAACL,IAAI,GAAI;QACrEO,OAAO;YAAEC,MAAM;QAAS;QACxBC,UAAU;YAAED,MAAM;QAAS;QAC3BE,KAAK;YAAEF,MAAM;QAAS;IACxB,GAJQN;IAKR,IAAMS,YAAYT,OAAOK,KAAK;IAC9B,IAAMK,eAAeV,OAAOO,QAAQ;IACpC,IAAMF,QAAQI,sBAAAA,uBAAAA,YAAaE,4BAAmB;IAC9C,IAAMJ,WAAWG,yBAAAA,0BAAAA,eAAgB;IACjC,IAAMF,MAAMR,OAAOQ,GAAG;IACtB,2FAA2F;IAC3F,4DAA4D;IAC5D,IAAMI,aAAaC,IAAAA,mBAAU,EAACC,QAAQC,GAAG,IAAI;QAAEV,OAAOI;QAAWF,UAAUG;QAAcF,KAAAA;IAAI;IAC7FQ,QAAQC,GAAG,CAAC,AAAC,WAAqB,OAAXL;IACvBI,QAAQC,GAAG,CAAC,AAAC,eAAuB,OAATlB,IAAIK,IAAI,EAAC;IACpC,wFAAwF;IACxF,2FAA2F;IAC3F,IAAIG,aAAa,UAAU;QACzBS,QAAQC,GAAG,CAAC,AAAC,gBAAkClB,OAAnBM,OAAM,eAAsFN,OAAzEA,IAAIK,IAAI,EAAC,kEAAyE,OAATL,IAAIK,IAAI,EAAC;IACnI,OAAO;QACLY,QAAQC,GAAG,CAAC,AAAC,gBAAyBV,OAAVF,OAAM,MAAeG,OAAXD,UAAmC,OAAxBC,MAAM,AAAC,OAAU,OAAJA,OAAQ,IAAG;IAC3E;IACAQ,QAAQC,GAAG,CAAC;IACZ,4FAA4F;IAC5F,oFAAoF;IACpFD,QAAQC,GAAG,CAAC;AACd;IACA,WAAenB"}

package/dist/cjs/cli/map.js

@@ -164,9 +164,14 @@ function _ts_generator(thisArg, body) {
     }
 }
 var map = function map(ctx) {
-    var values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.map), _object_spread({}, _sharedts.SCOPE, _sharedts.FORMAT, _sharedts.CONFIG)).values;
+    var values = (0, _sharedts.parse)(ctx.argv, "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.map), _object_spread({}, _sharedts.SCOPE, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG)).values;
     var format = (0, _sharedts.formatOf)(values);
-    return (0, _sharedts.withDb)(ctx, values.config, function(store, cfg) {
+    return (0, _sharedts.withDb)(ctx, values.config, {
+        noBuild: values['no-build'] === true,
+        requirements: new Set([
+            'core'
+        ])
+    }, function(store, cfg) {
         return _async_to_generator(function() {
             var result;
             return _ts_generator(this, function(_state) {

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/map.ts"],"sourcesContent":["import { mapTree } from '../commands/map.ts';\nimport { renderMap, stringifyJson } from '../output/output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst map: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, { ...SCOPE, ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, async (store, cfg) => {\n    const result = await mapTree(store, cfg, scopeOf(values));\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderMap(result));\n  });\n};\nexport default map;\n"],"names":["map","ctx","values","parse","argv","USAGE","name","SCOPE","FORMAT","CONFIG","format","formatOf","withDb","config","store","cfg","result","mapTree","scopeOf","console","log","stringifyJson","renderMap"],"mappings":";;;;+BAcA;;;eAAA;;;qBAdwB;wBACiB;uBACnB;wBACkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxE,IAAMA,MAAe,aAACC;IACpB,IAAM,AAAEC,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACL,GAAG,GAAI,mBAAKO,eAAK,EAAKC,gBAAM,EAAKC,gBAAM,GAA9FP;IACR,IAAMQ,SAASC,IAAAA,kBAAQ,EAACT;IACxB,OAAOU,IAAAA,gBAAM,EAACX,KAAKC,OAAOW,MAAM,EAAwB,SAAOC,OAAOC;;gBAC9DC;;;;wBAAS;;4BAAMC,IAAAA,cAAO,EAACH,OAAOC,KAAKG,IAAAA,iBAAO,EAAChB;;;wBAA3Cc,SAAS;wBACfG,QAAQC,GAAG,CAACV,WAAW,SAASW,IAAAA,uBAAa,EAACL,QAAQ,KAAKM,IAAAA,mBAAS,EAACN;;;;;;QACvE;;AACF;IACA,WAAehB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/map.ts"],"sourcesContent":["import { mapTree } from '../commands/map.ts';\nimport { renderMap, stringifyJson } 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\nconst map: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG });\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 result = await mapTree(store, cfg, scopeOf(values));\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderMap(result));\n  });\n};\nexport default map;\n"],"names":["map","ctx","values","parse","argv","USAGE","name","SCOPE","NO_BUILD","FORMAT","CONFIG","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","result","mapTree","scopeOf","console","log","stringifyJson","renderMap"],"mappings":";;;;+BAeA;;;eAAA;;;qBAfwB;wBACiB;uBAEnB;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,IAAMA,MAAe,aAACC;IACpB,IAAM,AAAEC,SAAWC,IAAAA,eAAK,EAACF,IAAIG,IAAI,EAAE,AAAC,UAAqBC,OAAZJ,IAAIK,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACL,GAAG,GAAI,mBAAKO,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM,GAA3GR;IACR,IAAMS,SAASC,IAAAA,kBAAQ,EAACV;IACxB,OAAOW,IAAAA,gBAAM,EAACZ,KAAKC,OAAOY,MAAM,EAAwB;QAAEC,SAASb,MAAM,CAAC,WAAW,KAAK;QAAMc,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC;;;;wBAAS;;4BAAMC,IAAAA,cAAO,EAACH,OAAOC,KAAKG,IAAAA,iBAAO,EAACpB;;;wBAA3CkB,SAAS;wBACfG,QAAQC,GAAG,CAACb,WAAW,SAASc,IAAAA,uBAAa,EAACL,QAAQ,KAAKM,IAAAA,mBAAS,EAACN;;;;;;QACvE;;AACF;IACA,WAAepB"}