sensemaking 0.25.0 → 0.26.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/peek.ts"],"sourcesContent":["import posix from 'node:path/posix';\nimport { estimateTokens } from '../chunk/index.ts';\nimport type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Row } from '../output/output.ts';\nimport type { Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, scopedPaths } from './scope.ts';\n\n// Note resolution shared by peek and path: an exact path, or a unique basename (case\n// insensitive, .md stripped).\nexport function resolveNote(paths: string[], arg: string): string {\n  const exact = paths.find((p) => p === arg);\n  if (exact) return exact;\n  const base = posix.basename(arg).replace(/\\.md$/i, '').toLowerCase();\n  const matches = paths.filter((p) => posix.basename(p).replace(/\\.md$/i, '').toLowerCase() === base);\n  if (matches.length === 1) return matches[0];\n  if (matches.length > 1) throw new SenseError('NOTE_AMBIGUOUS', `\"${arg}\" is ambiguous: ${matches.join(', ')}`);\n  throw new SenseError('NOTE_NOT_FOUND', `no note matches \"${arg}\"`);\n}\n\nexport interface Peek {\n  path: string;\n  tokens: number;\n  frontmatter: Row;\n  // Set when the note's frontmatter was refused, so an empty frontmatter block reads as \"did\n  // not parse\" rather than \"has none\". Same reason `_parse_error` sits in the row.\n  parseError: string | null;\n  sections: Row[];\n  outbound: string[];\n  backlinks: string[];\n  unresolved: string[];\n  // Totals before truncation: a hub can have thousands of backlinks (or a note thousands of\n  // headings), and peek's whole point is bounded output.\n  sectionsTotal: number;\n  outboundTotal: number;\n  backlinksTotal: number;\n  unresolvedTotal: number;\n  // Bounded k-hop expansion beyond the immediate ring already shown by outbound/backlinks\n  // (depth starts at 2).\n  off: FeatureName[]; // disabled features whose blocks are omitted (not empty)\n}\n\nconst PEEK_LIST_LIMIT = 20;\n\n// peek: everything about one note except its prose -- frontmatter, outline with line\n// ranges + token estimates (so the follow-up Read is a range, not the file), links both ways.\nexport function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides = {}): Promise<Peek> {\n  return serialQuery(store, () => peekIndexed(store, cfg, pathArg, overrides));\n}\n\nasync function peekIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides): Promise<Peek> {\n  return store.transaction(async () => {\n    const pathsStmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n    const paths = ((await pathsStmt.all()) as Array<{ path: string }>).map((r) => r.path);\n    const path = resolveNote(paths, pathArg);\n\n    const rowStmt = await store.prepare('SELECT * FROM frontmatter WHERE \"path\" = ?');\n    const row = (await rowStmt.get(path)) as Row;\n    const parseError = (row._parse_error as string | null) ?? null;\n    const frontmatter: Row = {};\n    for (const [key, value] of Object.entries(row)) {\n      if (!INTERNAL_COLUMNS.has(key) && value !== null) frontmatter[key] = value;\n    }\n\n    let sectionsTotal = 0;\n    let sections: Row[] = [];\n    if (featureEnabled(cfg, 'sections')) {\n      sectionsTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM sections WHERE \"path\" = ?')).get(path)) as { n: number }).n;\n      sections = (await (await store.prepare('SELECT level, heading, start_line, end_line, tokens FROM sections WHERE \"path\" = ? ORDER BY idx LIMIT ?')).all(path, PEEK_LIST_LIMIT)) as Row[];\n    }\n\n    let outbound: string[] = [];\n    let backlinks: string[] = [];\n    let unresolved: string[] = [];\n    let backlinksTotal = 0;\n    await scopedPaths(store, cfg, overrides); // validates --preset/--where/--include/--exclude even though peek's own output isn't scope-filtered\n    if (featureEnabled(cfg, 'links')) {\n      const out = (await (await store.prepare('SELECT target, dst FROM links WHERE src = ? AND (dst IS NULL OR dst != src) ORDER BY target')).all(path)) as Array<{ target: string; dst: string | null }>;\n      outbound = [...new Set(out.filter((l) => l.dst !== null).map((l) => l.dst as string))];\n      unresolved = out.filter((l) => l.dst === null).map((l) => l.target);\n      backlinksTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT src) AS n FROM links WHERE dst = ? AND src != dst')).get(path)) as { n: number }).n;\n      backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst ORDER BY src LIMIT ?')).all(path, PEEK_LIST_LIMIT)) as Array<{ src: string }>).map((r) => r.src);\n    }\n\n    // content.text is the stripped body already computed at reconcile time (no extra file read),\n    // floored by the byte/4 estimate so stripped-away syntax and frontmatter can't vanish from the price.\n    const body = ((await (await store.prepare('SELECT text FROM content WHERE \"path\" = ?')).get(path)) as { text: string } | undefined)?.text;\n    const byteTokens = Math.ceil(((row._size as number) ?? 0) / 4);\n    const tokens = body !== undefined ? Math.max(Math.ceil(estimateTokens(body)), byteTokens) : byteTokens;\n\n    return {\n      path,\n      tokens,\n      frontmatter,\n      parseError,\n      sections,\n      outbound: outbound.slice(0, PEEK_LIST_LIMIT),\n      backlinks,\n      unresolved: unresolved.slice(0, PEEK_LIST_LIMIT),\n      sectionsTotal,\n      outboundTotal: outbound.length,\n      backlinksTotal,\n      unresolvedTotal: unresolved.length,\n      off: (['sections', 'links'] as FeatureName[]).filter((name) => !featureEnabled(cfg, name)),\n    };\n  });\n}\n"],"names":["peek","resolveNote","paths","arg","exact","find","p","base","posix","basename","replace","toLowerCase","matches","filter","length","SenseError","join","PEEK_LIST_LIMIT","store","cfg","pathArg","overrides","serialQuery","peekIndexed","transaction","row","pathsStmt","path","rowStmt","parseError","frontmatter","key","value","sectionsTotal","sections","outbound","backlinks","unresolved","backlinksTotal","out","body","byteTokens","tokens","prepare","all","map","r","get","_parse_error","Object","entries","INTERNAL_COLUMNS","has","featureEnabled","n","scopedPaths","Set","l","dst","target","src","text","Math","ceil","_size","undefined","max","estimateTokens","slice","outboundTotal","unresolvedTotal","off","name"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/peek.ts"],"sourcesContent":["import posix from 'node:path/posix';\nimport { estimateTokens } from '../chunk/index.ts';\nimport type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Row } from '../output/output.ts';\nimport type { Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, materializeScope, scopedPaths } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\n// Note resolution shared by peek and path: an exact path, or a unique basename (case\n// insensitive, .md stripped).\nexport function resolveNote(paths: string[], arg: string): string {\n  const exact = paths.find((p) => p === arg);\n  if (exact) return exact;\n  const base = posix.basename(arg).replace(/\\.md$/i, '').toLowerCase();\n  const matches = paths.filter((p) => posix.basename(p).replace(/\\.md$/i, '').toLowerCase() === base);\n  if (matches.length === 1) return matches[0];\n  if (matches.length > 1) throw new SenseError('NOTE_AMBIGUOUS', `\"${arg}\" is ambiguous: ${matches.join(', ')}`);\n  throw new SenseError('NOTE_NOT_FOUND', `no note matches \"${arg}\"`);\n}\n\n/** Structured, bounded metadata returned by the root {@link peek} API. */\nexport interface Peek {\n  path: string;\n  tokens: number;\n  frontmatter: Row;\n  /** Set when frontmatter parsing failed, distinguishing that case from an empty block. */\n  parseError: string | null;\n  sections: PeekSection[];\n  outbound: string[];\n  backlinks: string[];\n  unresolved: string[];\n  /** Totals before each bounded list is truncated. */\n  sectionsTotal: number;\n  outboundTotal: number;\n  backlinksTotal: number;\n  unresolvedTotal: number;\n  /** Disabled features whose result blocks are omitted rather than returned empty. */\n  off: FeatureName[];\n}\n\nexport interface PeekSection {\n  level: number;\n  heading: string;\n  start_line: number;\n  end_line: number;\n  tokens: number;\n}\n\nconst PEEK_LIST_LIMIT = 20;\n\n/**\n * Returns indexed metadata for a note in scope. Exact excluded paths fail before scoped basename\n * resolution; resolved neighbors stay in scope, while unresolved written targets remain visible.\n */\nexport function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides = {}): Promise<Peek> {\n  return serialQuery(store, () => peekIndexed(store, cfg, pathArg, overrides));\n}\n\nasync function peekIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides): Promise<Peek> {\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    const pathsStmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n    const paths = ((await pathsStmt.all()) as Array<{ path: string }>).map((r) => r.path);\n    const allowed = await scopedPaths(store, cfg, overrides);\n    if (paths.includes(pathArg) && !allowed.has(pathArg)) {\n      throw new SenseError('NOTE_NOT_FOUND', `note \"${pathArg}\" exists but is outside the current scope; change the preset, include/exclude patterns, or where condition`);\n    }\n    let path: string;\n    try {\n      path = resolveNote([...allowed], pathArg);\n    } catch (err) {\n      if (err instanceof SenseError && err.code === 'NOTE_NOT_FOUND') {\n        let excludedPath: string;\n        try {\n          excludedPath = resolveNote(paths, pathArg);\n        } catch (unscopedErr) {\n          if (unscopedErr instanceof SenseError && unscopedErr.code === 'NOTE_AMBIGUOUS') {\n            throw new SenseError('NOTE_NOT_FOUND', `no note in the current scope matches \"${pathArg}\"; indexed matches exist outside the scope, so change the preset, include/exclude patterns, or where condition`);\n          }\n          throw err;\n        }\n        throw new SenseError('NOTE_NOT_FOUND', `note \"${excludedPath}\" exists but is outside the current scope; change the preset, include/exclude patterns, or where condition`);\n      }\n      throw err;\n    }\n\n    const rowStmt = await store.prepare('SELECT * FROM frontmatter WHERE \"path\" = ?');\n    const row = (await rowStmt.get(path)) as Row;\n    const parseError = (row._parse_error as string | null) ?? null;\n    const frontmatter: Row = {};\n    for (const [key, value] of Object.entries(row)) {\n      if (!INTERNAL_COLUMNS.has(key) && value !== null) frontmatter[key] = value;\n    }\n\n    let sectionsTotal = 0;\n    let sections: PeekSection[] = [];\n    if (featureEnabled(cfg, 'sections')) {\n      sectionsTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM sections WHERE \"path\" = ?')).get(path)) as { n: number }).n;\n      sections = (await (await store.prepare('SELECT level, heading, start_line, end_line, tokens FROM sections WHERE \"path\" = ? ORDER BY idx LIMIT ?')).all(path, PEEK_LIST_LIMIT)) as PeekSection[];\n    }\n\n    let outbound: string[] = [];\n    let backlinks: string[] = [];\n    let unresolved: string[] = [];\n    let backlinksTotal = 0;\n    if (featureEnabled(cfg, 'links')) {\n      await materializeScope(store, '_peek_scope', allowed);\n      const out = (await (await store.prepare('SELECT target, dst FROM links WHERE src = ? AND (dst IS NULL OR (dst != src AND dst IN (SELECT \"path\" FROM _peek_scope))) ORDER BY target')).all(path)) as Array<{ target: string; dst: string | null }>;\n      outbound = [...new Set(out.filter((l): l is { target: string; dst: string } => l.dst !== null).map((l) => l.dst))];\n      unresolved = out.filter((l) => l.dst === null).map((l) => l.target);\n      backlinksTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT src) AS n FROM links WHERE dst = ? AND src != dst AND src IN (SELECT \"path\" FROM _peek_scope)')).get(path)) as { n: number }).n;\n      backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst AND src IN (SELECT \"path\" FROM _peek_scope) ORDER BY src LIMIT ?')).all(path, PEEK_LIST_LIMIT)) as Array<{ src: string }>).map((r) => r.src);\n    }\n\n    // content.text is the stripped body already computed at reconcile time (no extra file read),\n    // floored by the byte/4 estimate so stripped-away syntax and frontmatter can't vanish from the price.\n    const body = ((await (await store.prepare('SELECT text FROM content WHERE \"path\" = ?')).get(path)) as { text: string } | undefined)?.text;\n    const byteTokens = Math.ceil(((row._size as number) ?? 0) / 4);\n    const tokens = body !== undefined ? Math.max(Math.ceil(estimateTokens(body)), byteTokens) : byteTokens;\n\n    return {\n      path,\n      tokens,\n      frontmatter,\n      parseError,\n      sections,\n      outbound: outbound.slice(0, PEEK_LIST_LIMIT),\n      backlinks,\n      unresolved: unresolved.slice(0, PEEK_LIST_LIMIT),\n      sectionsTotal,\n      outboundTotal: outbound.length,\n      backlinksTotal,\n      unresolvedTotal: unresolved.length,\n      off: (['sections', 'links'] as FeatureName[]).filter((name) => !featureEnabled(cfg, name)),\n    };\n  });\n}\n"],"names":["peek","resolveNote","paths","arg","exact","find","p","base","posix","basename","replace","toLowerCase","matches","filter","length","SenseError","join","PEEK_LIST_LIMIT","store","cfg","pathArg","overrides","serialQuery","peekIndexed","transaction","row","pathsStmt","allowed","path","excludedPath","rowStmt","parseError","frontmatter","key","value","sectionsTotal","sections","outbound","backlinks","unresolved","backlinksTotal","out","body","byteTokens","tokens","assertQuerySnapshot","prepare","all","map","r","scopedPaths","includes","has","err","code","unscopedErr","get","_parse_error","Object","entries","INTERNAL_COLUMNS","featureEnabled","n","materializeScope","Set","l","dst","target","src","text","Math","ceil","_size","undefined","max","estimateTokens","slice","outboundTotal","unresolvedTotal","off","name"],"mappings":"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"}

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

@@ -1,7 +1,20 @@
 import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
 import type { Store } from '../store/types.js';
-export declare function resolveRelatedSeed(store: Store, pathArg: string): Promise<string>;
-export declare function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{
+export declare const RELATED_DEFAULT_K = 5;
+/**
+ * Options for {@link relatedNotes}. Scope fields filter result candidates, not the seed note;
+ * `k` defaults to 5, matching the CLI.
+ */
+export interface RelatedOptions extends SearchOverrides {
+    k?: number;
+}
+export type RelatedResult = {
     path: string;
     similarity: number;
-}>>;
+};
+export declare function resolveRelatedSeed(store: Store, pathArg: string): Promise<string>;
+/**
+ * Returns the notes most similar to an indexed seed, excluding the seed and notes linked either
+ * way. The seed resolves across the indexed tree even when it is outside the candidate scope.
+ */
+export declare function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, options?: RelatedOptions): Promise<RelatedResult[]>;

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

@@ -1,7 +1,20 @@
 import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
 import type { Store } from '../store/types.js';
-export declare function resolveRelatedSeed(store: Store, pathArg: string): Promise<string>;
-export declare function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{
+export declare const RELATED_DEFAULT_K = 5;
+/**
+ * Options for {@link relatedNotes}. Scope fields filter result candidates, not the seed note;
+ * `k` defaults to 5, matching the CLI.
+ */
+export interface RelatedOptions extends SearchOverrides {
+    k?: number;
+}
+export type RelatedResult = {
     path: string;
     similarity: number;
-}>>;
+};
+export declare function resolveRelatedSeed(store: Store, pathArg: string): Promise<string>;
+/**
+ * Returns the notes most similar to an indexed seed, excluding the seed and notes linked either
+ * way. The seed resolves across the indexed tree even when it is outside the candidate scope.
+ */
+export declare function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, options?: RelatedOptions): Promise<RelatedResult[]>;

package/dist/cjs/commands/related.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get RELATED_DEFAULT_K () {
+        return RELATED_DEFAULT_K;
+    },
     get relatedNotes () {
         return relatedNotes;
     },
@@ -23,6 +26,7 @@ var _errorsts = require("../errors.js");
 var _serialqueryts = require("../lib/serial-query.js");
 var _peekts = require("./peek.js");
 var _scopets = require("./scope.js");
+var _snapshotts = require("./snapshot.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -175,6 +179,7 @@ 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;
 function resolveRelatedSeed(store, pathArg) {
     return _async_to_generator(function() {
         var paths;
@@ -202,111 +207,139 @@ function resolveRelatedSeed(store, pathArg) {
         });
     })();
 }
-function relatedNotes(store, cfg, pathArg, overrides, k) {
+function relatedNotes(store, cfg, pathArg) {
+    var options = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
     return (0, _serialqueryts.serialQuery)(store, function() {
-        return relatedIndexed(store, cfg, pathArg, overrides, k);
+        var _options_k;
+        return relatedIndexed(store, cfg, pathArg, options, (_options_k = options.k) !== null && _options_k !== void 0 ? _options_k : RELATED_DEFAULT_K);
     });
 }
 function relatedIndexed(store, cfg, pathArg, overrides, k) {
     return _async_to_generator(function() {
-        var path, outbound, backlinks, exclude, effective, e, allowed;
+        var effective, e;
         return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        resolveRelatedSeed(store, pathArg)
-                    ];
-                case 1:
-                    path = _state.sent();
-                    return [
-                        4,
-                        store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')
-                    ];
-                case 2:
-                    return [
-                        4,
-                        _state.sent().all(path)
-                    ];
-                case 3:
-                    outbound = _state.sent().map(function(r) {
-                        return r.dst;
-                    });
-                    return [
-                        4,
-                        store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')
-                    ];
-                case 4:
-                    return [
-                        4,
-                        _state.sent().all(path)
-                    ];
-                case 5:
-                    backlinks = _state.sent().map(function(r) {
-                        return r.src;
-                    });
-                    exclude = new Set([
-                        path
-                    ].concat(_to_consumable_array(outbound), _to_consumable_array(backlinks)));
-                    // Vectors are the only signal `related` has, so every way of not having them is an error
-                    // naming the cause; an empty result means one thing, nothing near in meaning.
-                    effective = (0, _indexts.resolveSearch)(cfg, overrides);
-                    if (!(0, _indexts.embedEnabled)(cfg)) {
-                        throw new _errorsts.SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an "embed" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');
-                    }
-                    // search gates on the same signal, so a preset's declared signals mean one thing: without
-                    // this check an overlapping vectors-on preset would answer for a scope that declined them.
-                    if (effective.signals.vectors === undefined) {
-                        throw new _errorsts.SenseError('PRESET_NOT_SEMANTIC', 'preset "'.concat(effective.presetName, '" has no "vectors" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add "vectors" to that preset\'s signals'));
-                    }
-                    // A downloadable HF id can be fetched by preparation. Only a local path with missing files
-                    // can never fetch itself.
-                    e = (0, _indexts.embedConfig)(cfg); // embedEnabled(cfg) above guarantees this is set
-                    if ((0, _storets.localModelMissing)(e)) {
-                        throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'related ranks notes by meaning, so it needs the embedding model, but the local model path "'.concat(e.model, '" is missing ').concat(_storets.MODEL_FILENAMES, "; point embed.model at a directory containing them (search still works without it, on words and links)"));
-                    }
-                    return [
-                        4,
-                        (0, _scopets.scopedPaths)(store, cfg, overrides)
-                    ];
-                case 6:
-                    allowed = _state.sent();
-                    // The seed may sit outside a narrowed candidate scope; both it and every eligible result must
-                    // be ready, while pending vectors in unrelated notes do not block this operation.
-                    return [
-                        4,
-                        (0, _queryts.ensureDocumentEmbeddings)(store, cfg, new Set(_to_consumable_array(allowed).concat([
-                            path
-                        ])))
-                    ];
-                case 7:
-                    _state.sent();
-                    return [
-                        4,
-                        (0, _queryts.hasEmbedding)(store, path)
-                    ];
-                case 8:
-                    if (!_state.sent()) {
-                        throw new _errorsts.SenseError('NOTE_NOT_EMBEDDED', "".concat(path, " has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning"));
-                    }
-                    return [
-                        4,
-                        (0, _scopets.scopeHasEmbeddings)(store, cfg, allowed)
-                    ];
-                case 9:
-                    if (!_state.sent()) return [
-                        2,
-                        []
-                    ];
-                    return [
-                        2,
-                        (0, _queryts.similarNotes)(store, cfg, path, {
-                            exclude: exclude,
-                            allowed: allowed,
-                            k: k
-                        })
-                    ];
+            if (!Number.isFinite(k) || !Number.isInteger(k) || k <= 0) {
+                throw new _errorsts.SenseError('SEARCH_OPTION_INVALID', 'related option "k" must be a positive finite integer, got '.concat(String(k)));
+            }
+            // Vectors are the only signal `related` has, so every way of not having them is an error
+            // naming the cause; an empty result means one thing, nothing near in meaning.
+            effective = (0, _indexts.resolveSearch)(cfg, overrides);
+            if (!(0, _indexts.embedEnabled)(cfg)) {
+                throw new _errorsts.SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an "embed" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');
             }
+            // search gates on the same signal, so a preset's declared signals mean one thing: without
+            // this check an overlapping vectors-on preset would answer for a scope that declined them.
+            if (effective.signals.vectors === undefined) {
+                throw new _errorsts.SenseError('PRESET_NOT_SEMANTIC', 'preset "'.concat(effective.presetName, '" has no "vectors" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add "vectors" to that preset\'s signals'));
+            }
+            // A downloadable HF id can be fetched by preparation. Only a local path with missing files
+            // can never fetch itself.
+            e = (0, _indexts.embedConfig)(cfg); // embedEnabled(cfg) above guarantees this is set
+            if ((0, _storets.localModelMissing)(e)) {
+                throw new _errorsts.SenseError('EMBED_MODEL_MISSING', 'related ranks notes by meaning, so it needs the embedding model, but the local model path "'.concat(e.model, '" is missing ').concat(_storets.MODEL_FILENAMES, "; point embed.model at a directory containing them (search still works without it, on words and links)"));
+            }
+            return [
+                2,
+                store.transaction(function() {
+                    return _async_to_generator(function() {
+                        var current, path, outbound, backlinks, exclude, allowed;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    return [
+                                        4,
+                                        (0, _snapshotts.assertQuerySnapshot)(store, cfg)
+                                    ];
+                                case 1:
+                                    _state.sent();
+                                    // Repeat effective preset validation inside the snapshot that supplies its durable scope.
+                                    current = (0, _indexts.resolveSearch)(cfg, overrides);
+                                    if (current.signals.vectors === undefined) {
+                                        throw new _errorsts.SenseError('PRESET_NOT_SEMANTIC', 'preset "'.concat(current.presetName, '" has no "vectors" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add "vectors" to that preset\'s signals'));
+                                    }
+                                    return [
+                                        4,
+                                        resolveRelatedSeed(store, pathArg)
+                                    ];
+                                case 2:
+                                    path = _state.sent();
+                                    return [
+                                        4,
+                                        store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')
+                                    ];
+                                case 3:
+                                    return [
+                                        4,
+                                        _state.sent().all(path)
+                                    ];
+                                case 4:
+                                    outbound = _state.sent().map(function(r) {
+                                        return r.dst;
+                                    });
+                                    return [
+                                        4,
+                                        store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')
+                                    ];
+                                case 5:
+                                    return [
+                                        4,
+                                        _state.sent().all(path)
+                                    ];
+                                case 6:
+                                    backlinks = _state.sent().map(function(r) {
+                                        return r.src;
+                                    });
+                                    exclude = new Set([
+                                        path
+                                    ].concat(_to_consumable_array(outbound), _to_consumable_array(backlinks)));
+                                    return [
+                                        4,
+                                        (0, _scopets.scopedPaths)(store, cfg, overrides)
+                                    ];
+                                case 7:
+                                    allowed = _state.sent();
+                                    // The seed may sit outside a narrowed candidate scope; both it and every eligible result must
+                                    // be ready, while pending vectors in unrelated notes do not block this operation.
+                                    return [
+                                        4,
+                                        (0, _queryts.ensureDocumentEmbeddings)(store, cfg, new Set(_to_consumable_array(allowed).concat([
+                                            path
+                                        ])))
+                                    ];
+                                case 8:
+                                    _state.sent();
+                                    return [
+                                        4,
+                                        (0, _queryts.hasEmbedding)(store, path)
+                                    ];
+                                case 9:
+                                    if (!_state.sent()) {
+                                        throw new _errorsts.SenseError('NOTE_NOT_EMBEDDED', "".concat(path, " has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning"));
+                                    }
+                                    return [
+                                        4,
+                                        (0, _scopets.scopeHasEmbeddings)(store, cfg, allowed)
+                                    ];
+                                case 10:
+                                    if (!_state.sent()) return [
+                                        2,
+                                        []
+                                    ];
+                                    return [
+                                        2,
+                                        (0, _scopets.withMaterializedVectorScope)(store, allowed, function() {
+                                            return (0, _queryts.similarNotes)(store, cfg, path, {
+                                                exclude: exclude,
+                                                allowed: allowed,
+                                                k: k
+                                            });
+                                        })
+                                    ];
+                            }
+                        });
+                    })();
+                })
+            ];
         });
     })();
 }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/related.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { embedConfig, embedEnabled, resolveSearch } from '../config/index.ts';\nimport { ensureDocumentEmbeddings, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings } from './scope.ts';\n\nexport async function resolveRelatedSeed(store: Store, pathArg: string): Promise<string> {\n  const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((row) => row.path);\n  return resolveNote(paths, pathArg);\n}\n\n// Notes most similar by cosine, excluding self and everything already linked either way.\n// Its own command, not a peek section: a full embeddings scan is ~480ms at 26k notes.\nexport function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{ path: string; similarity: number }>> {\n  return serialQuery(store, () => relatedIndexed(store, cfg, pathArg, overrides, k));\n}\n\nasync function relatedIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{ path: string; similarity: number }>> {\n  const path = await resolveRelatedSeed(store, pathArg);\n\n  const outbound = ((await (await store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')).all(path)) as Array<{ dst: string }>).map((r) => r.dst);\n  const backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')).all(path)) as Array<{ src: string }>).map((r) => r.src);\n  const exclude = new Set([path, ...outbound, ...backlinks]);\n\n  // Vectors are the only signal `related` has, so every way of not having them is an error\n  // naming the cause; an empty result means one thing, nothing near in meaning.\n  const effective = resolveSearch(cfg, overrides);\n  if (!embedEnabled(cfg)) {\n    throw new SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an \"embed\" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');\n  }\n  // search gates on the same signal, so a preset's declared signals mean one thing: without\n  // this check an overlapping vectors-on preset would answer for a scope that declined them.\n  if (effective.signals.vectors === undefined) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n  }\n  // A downloadable HF id can be fetched by preparation. Only a local path with missing files\n  // can never fetch itself.\n  const e = embedConfig(cfg); // embedEnabled(cfg) above guarantees this is set\n  if (localModelMissing(e)) {\n    throw new SenseError('EMBED_MODEL_MISSING', `related ranks notes by meaning, so it needs the embedding model, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them (search still works without it, on words and links)`);\n  }\n  const allowed = await scopedPaths(store, cfg, overrides);\n  // The seed may sit outside a narrowed candidate scope; both it and every eligible result must\n  // be ready, while pending vectors in unrelated notes do not block this operation.\n  await ensureDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n  if (!(await hasEmbedding(store, path))) {\n    throw new SenseError('NOTE_NOT_EMBEDDED', `${path} has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning`);\n  }\n  if (!(await scopeHasEmbeddings(store, cfg, allowed))) return [];\n  return similarNotes(store, cfg, path, { exclude, allowed, k });\n}\n"],"names":["relatedNotes","resolveRelatedSeed","store","pathArg","paths","prepare","all","map","row","path","resolveNote","cfg","overrides","k","serialQuery","relatedIndexed","outbound","backlinks","exclude","effective","e","allowed","r","dst","src","Set","resolveSearch","embedEnabled","SenseError","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","scopedPaths","ensureDocumentEmbeddings","hasEmbedding","scopeHasEmbeddings","similarNotes"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/related.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { embedConfig, embedEnabled, resolveSearch } from '../config/index.ts';\nimport { ensureDocumentEmbeddings, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings, withMaterializedVectorScope } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\nexport const RELATED_DEFAULT_K = 5;\n\n/**\n * Options for {@link relatedNotes}. Scope fields filter result candidates, not the seed note;\n * `k` defaults to 5, matching the CLI.\n */\nexport interface RelatedOptions extends SearchOverrides {\n  k?: number;\n}\n\nexport type RelatedResult = {\n  path: string;\n  similarity: number;\n};\n\nexport async function resolveRelatedSeed(store: Store, pathArg: string): Promise<string> {\n  const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((row) => row.path);\n  return resolveNote(paths, pathArg);\n}\n\n/**\n * Returns the notes most similar to an indexed seed, excluding the seed and notes linked either\n * way. The seed resolves across the indexed tree even when it is outside the candidate scope.\n */\nexport function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, options: RelatedOptions = {}): Promise<RelatedResult[]> {\n  return serialQuery(store, () => relatedIndexed(store, cfg, pathArg, options, options.k ?? RELATED_DEFAULT_K));\n}\n\nasync function relatedIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: RelatedOptions, k: number): Promise<RelatedResult[]> {\n  if (!Number.isFinite(k) || !Number.isInteger(k) || k <= 0) {\n    throw new SenseError('SEARCH_OPTION_INVALID', `related option \"k\" must be a positive finite integer, got ${String(k)}`);\n  }\n  // Vectors are the only signal `related` has, so every way of not having them is an error\n  // naming the cause; an empty result means one thing, nothing near in meaning.\n  const effective = resolveSearch(cfg, overrides);\n  if (!embedEnabled(cfg)) {\n    throw new SenseError('EMBED_DISABLED', 'related ranks notes by meaning, and this tree has no embedding model; add an \"embed\" block naming one to sense.config.json (a Hugging Face id fetches automatically at first use; `sense download` prefetches it) -- search works without it, on words and links');\n  }\n  // search gates on the same signal, so a preset's declared signals mean one thing: without\n  // this check an overlapping vectors-on preset would answer for a scope that declined them.\n  if (effective.signals.vectors === undefined) {\n    throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${effective.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n  }\n  // A downloadable HF id can be fetched by preparation. Only a local path with missing files\n  // can never fetch itself.\n  const e = embedConfig(cfg); // embedEnabled(cfg) above guarantees this is set\n  if (localModelMissing(e)) {\n    throw new SenseError('EMBED_MODEL_MISSING', `related ranks notes by meaning, so it needs the embedding model, but the local model path \"${e.model}\" is missing ${MODEL_FILENAMES}; point embed.model at a directory containing them (search still works without it, on words and links)`);\n  }\n\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    // Repeat effective preset validation inside the snapshot that supplies its durable scope.\n    const current = resolveSearch(cfg, overrides);\n    if (current.signals.vectors === undefined) {\n      throw new SenseError('PRESET_NOT_SEMANTIC', `preset \"${current.presetName}\" has no \"vectors\" signal, so this scope has no vectors and related has no other signal; search it instead (words and links), or add \"vectors\" to that preset's signals`);\n    }\n\n    const path = await resolveRelatedSeed(store, pathArg);\n    const outbound = ((await (await store.prepare('SELECT DISTINCT dst FROM links WHERE src = ? AND dst IS NOT NULL AND dst != src')).all(path)) as Array<{ dst: string }>).map((r) => r.dst);\n    const backlinks = ((await (await store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')).all(path)) as Array<{ src: string }>).map((r) => r.src);\n    const exclude = new Set([path, ...outbound, ...backlinks]);\n    const allowed = await scopedPaths(store, cfg, overrides);\n    // The seed may sit outside a narrowed candidate scope; both it and every eligible result must\n    // be ready, while pending vectors in unrelated notes do not block this operation.\n    await ensureDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    if (!(await hasEmbedding(store, path))) {\n      throw new SenseError('NOTE_NOT_EMBEDDED', `${path} has no indexed text to compare -- a note that is frontmatter only, or empty, has nothing to rank by meaning`);\n    }\n    if (!(await scopeHasEmbeddings(store, cfg, allowed))) return [];\n    return withMaterializedVectorScope(store, allowed, () => similarNotes(store, cfg, path, { exclude, allowed, k }));\n  });\n}\n"],"names":["RELATED_DEFAULT_K","relatedNotes","resolveRelatedSeed","store","pathArg","paths","prepare","all","map","row","path","resolveNote","cfg","options","serialQuery","relatedIndexed","k","overrides","effective","e","Number","isFinite","isInteger","SenseError","String","resolveSearch","embedEnabled","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","transaction","current","outbound","backlinks","exclude","allowed","assertQuerySnapshot","r","dst","src","Set","scopedPaths","ensureDocumentEmbeddings","hasEmbedding","scopeHasEmbeddings","withMaterializedVectorScope","similarNotes"],"mappings":"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"}

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

@@ -7,4 +7,5 @@ export declare function rawScope(store: Store, cfg: ResolvedConfig, overrides: S
 export declare function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>>;
 export declare function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>>;
 export declare function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void>;
+export declare function withMaterializedVectorScope<T>(store: Store, allowed: Set<string>, callback: () => Promise<T>, knownTotal?: number): Promise<T>;
 export declare function setupMapScope(store: Store, paths: Set<string>): Promise<void>;

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

@@ -7,4 +7,5 @@ export declare function rawScope(store: Store, cfg: ResolvedConfig, overrides: S
 export declare function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>>;
 export declare function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>>;
 export declare function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void>;
+export declare function withMaterializedVectorScope<T>(store: Store, allowed: Set<string>, callback: () => Promise<T>, knownTotal?: number): Promise<T>;
 export declare function setupMapScope(store: Store, paths: Set<string>): Promise<void>;

package/dist/cjs/commands/scope.js

@@ -32,11 +32,15 @@ _export(exports, {
     },
     get setupMapScope () {
         return setupMapScope;
+    },
+    get withMaterializedVectorScope () {
+        return withMaterializedVectorScope;
     }
 });
 var _nodepath = require("node:path");
 var _indexts = require("../config/index.js");
 var _columnhintts = require("../output/column-hint.js");
+var _vectorsts = require("../store/vectors.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -448,6 +452,151 @@ function materializeScope(store, table, paths) {
         });
     })();
 }
+function withMaterializedVectorScope(store, allowed, callback, knownTotal) {
+    return _async_to_generator(function() {
+        var reservation, total, stmt, row, err, operationFailed, operationError, result, err1, cleanupFailed, cleanupError, err2;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    reservation = (0, _vectorsts.reserveNativeVectorScope)(store.vectors, allowed);
+                    if (!reservation) return [
+                        2,
+                        callback()
+                    ];
+                    if (allowed.size === 0) {
+                        reservation.invalidate();
+                        return [
+                            2,
+                            callback()
+                        ];
+                    }
+                    total = knownTotal;
+                    if (!(total === undefined)) return [
+                        3,
+                        5
+                    ];
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        store.prepare('SELECT COUNT(*) AS count FROM frontmatter')
+                    ];
+                case 2:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.get()
+                    ];
+                case 3:
+                    row = _state.sent();
+                    total = Number(row.count);
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    reservation.invalidate();
+                    throw err;
+                case 5:
+                    // Materialization only buys work when this is a nonempty true narrowing and the allowed side
+                    // is no larger than its complement. Direct adapter calls and broader scopes retain JS filtering.
+                    if (allowed.size >= total || allowed.size > total - allowed.size) {
+                        reservation.invalidate();
+                        return [
+                            2,
+                            callback()
+                        ];
+                    }
+                    operationFailed = false;
+                    _state.label = 6;
+                case 6:
+                    _state.trys.push([
+                        6,
+                        9,
+                        ,
+                        10
+                    ]);
+                    return [
+                        4,
+                        materializeScope(store, _vectorsts.NATIVE_VECTOR_SCOPE_TABLE, allowed)
+                    ];
+                case 7:
+                    _state.sent();
+                    reservation.activate();
+                    return [
+                        4,
+                        callback()
+                    ];
+                case 8:
+                    result = _state.sent();
+                    return [
+                        3,
+                        10
+                    ];
+                case 9:
+                    err1 = _state.sent();
+                    operationFailed = true;
+                    operationError = err1;
+                    return [
+                        3,
+                        10
+                    ];
+                case 10:
+                    cleanupFailed = false;
+                    _state.label = 11;
+                case 11:
+                    _state.trys.push([
+                        11,
+                        13,
+                        14,
+                        15
+                    ]);
+                    reservation.deactivate();
+                    return [
+                        4,
+                        store.exec("DROP TABLE IF EXISTS ".concat(_vectorsts.NATIVE_VECTOR_SCOPE_TABLE))
+                    ];
+                case 12:
+                    _state.sent();
+                    return [
+                        3,
+                        15
+                    ];
+                case 13:
+                    err2 = _state.sent();
+                    cleanupFailed = true;
+                    cleanupError = err2;
+                    return [
+                        3,
+                        15
+                    ];
+                case 14:
+                    reservation.invalidate();
+                    return [
+                        7
+                    ];
+                case 15:
+                    if (operationFailed && cleanupFailed) throw new AggregateError([
+                        operationError,
+                        cleanupError
+                    ], 'native vector scope operation and cleanup failed');
+                    if (operationFailed) throw operationError;
+                    if (cleanupFailed) throw cleanupError;
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
 function setupMapScope(store, paths) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {