sensemaking 0.24.7 → 0.25.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/map.ts"],"sourcesContent":["import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled, featureStates } from '../config/index.ts';\nimport type { Row } from '../output/output.ts';\nimport type { FieldStat, Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, scopedPaths, setupMapScope } from './scope.ts';\nimport type { PresetCoverage } from './status.ts';\nimport { presetCoverage } from './status.ts';\n\nexport interface TreeMap {\n  docs: { count: number; bytes: number };\n  fields: Row[]; // top 20 by coverage; fieldsTotal carries the real count\n  fieldsTotal: number;\n  features: { on: FeatureName[]; off: FeatureName[] };\n  presets: PresetCoverage[];\n  hubs: Row[];\n  recent: Row[];\n  recentCaveat: string | null;\n}\n\n// A result row is capped at SQLITE_MAX_COLUMN (2000, default); two aggregate expressions per\n// field keeps a chunk's row width safely under that regardless of how many fields the tree has.\nconst MAP_COLUMN_CHUNK = 300;\n\n// \"YYYY-MM-DD HH:MM:SS\" UTC, the exact shape sqlite's datetime(ms / 1000, 'unixepoch') prints;\n// formatted in JS so the query stays dialect-free.\nfunction utcSecond(ms: number): string {\n  return new Date(ms).toISOString().slice(0, 19).replace('T', ' ');\n}\n\nfunction chunk<T>(items: T[], size: number): T[][] {\n  const out: T[][] = [];\n  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));\n  return out;\n}\n\n// What is this scope: fixed-size output regardless of tree size. Coverage and features stay\n// global -- they describe the tree, not the current question.\nexport async function mapTree(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides = {}): Promise<TreeMap> {\n  return store.transaction(async () => {\n    await setupMapScope(store, await scopedPaths(store, cfg, overrides));\n    const scopeWhere = 'WHERE \"path\" IN (SELECT \"path\" FROM _map_scope)';\n    const scopeAnd = 'AND f.\"path\" IN (SELECT \"path\" FROM _map_scope)';\n\n    const docs = (await (await store.prepare(`SELECT COUNT(*) AS count, COALESCE(SUM(\"_size\"), 0) AS bytes FROM frontmatter ${scopeWhere}`)).get()) as { count: number; bytes: number };\n\n    const columns = (await store.docs.columns()).filter((name) => !INTERNAL_COLUMNS.has(name));\n    // Observed types, not declared: a field can be text in most notes and numeric in a few, so\n    // every distinct type observed across the scope is reported, not just the first.\n    const allFields: FieldStat[] = [];\n    for (const group of chunk(columns, MAP_COLUMN_CHUNK)) allFields.push(...(await store.docs.fieldStats(group, scopeWhere)));\n    allFields.sort((a, b) => b.coverage - a.coverage);\n    const fields = allFields.slice(0, 20) as unknown as Row[];\n\n    const hubs = featureEnabled(cfg, 'rank')\n      ? ((await (await store.prepare(`SELECT f.\"path\" AS path, round(f.\"_rank\" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f.\"path\" WHERE f.\"_rank\" IS NOT NULL ${scopeAnd} ORDER BY f.\"_rank\" DESC, f.\"path\" ASC LIMIT 8`)).all()) as Row[])\n      : [];\n\n    const recent = ((await (await store.prepare(`SELECT \"path\", \"_mtime\" AS mtime FROM frontmatter ${scopeWhere} ORDER BY \"_mtime\" DESC, \"path\" ASC LIMIT 5`)).all()) as Array<{ path: string; mtime: number }>).map((r) => ({ path: r.path, modified: utcSecond(r.mtime) }));\n\n    // A fresh clone/copy stamps files with checkout time, not edit history; second granularity\n    // matches the `recent` table above and is coarse enough to catch that without an exact-ms match.\n    const topSecond = (await (await store.prepare(`SELECT COUNT(*) AS n FROM frontmatter ${scopeWhere} GROUP BY CAST(\"_mtime\" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1`)).get()) as { n: number } | undefined;\n    const recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? `${topSecond.n} of ${docs.count} files share one modified second, so recency likely reflects a checkout or copy, not edit history` : null;\n\n    return { docs, fields, fieldsTotal: allFields.length, features: featureStates(cfg), presets: await presetCoverage(store, cfg), hubs, recent, recentCaveat };\n  });\n}\n"],"names":["mapTree","MAP_COLUMN_CHUNK","utcSecond","ms","Date","toISOString","slice","replace","chunk","items","size","out","i","length","push","store","cfg","overrides","transaction","allFields","scopeWhere","scopeAnd","docs","columns","group","fields","hubs","recent","topSecond","recentCaveat","scopedPaths","setupMapScope","prepare","get","filter","name","INTERNAL_COLUMNS","has","fieldStats","sort","a","b","coverage","featureEnabled","all","map","r","path","modified","mtime","count","n","fieldsTotal","features","featureStates","presetCoverage","presets"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/map.ts"],"sourcesContent":["import type { FeatureName, ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { featureEnabled, featureStates } from '../config/index.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Row } from '../output/output.ts';\nimport type { FieldStat, Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, scopedPaths, setupMapScope } from './scope.ts';\nimport type { PresetCoverage } from './status.ts';\nimport { presetCoverage } from './status.ts';\n\nexport interface TreeMap {\n  docs: { count: number; bytes: number };\n  fields: Row[]; // top 20 by coverage; fieldsTotal carries the real count\n  fieldsTotal: number;\n  features: { on: FeatureName[]; off: FeatureName[] };\n  presets: PresetCoverage[];\n  hubs: Row[];\n  recent: Row[];\n  recentCaveat: string | null;\n}\n\n// A result row is capped at SQLITE_MAX_COLUMN (2000, default); two aggregate expressions per\n// field keeps a chunk's row width safely under that regardless of how many fields the tree has.\nconst MAP_COLUMN_CHUNK = 300;\n\n// \"YYYY-MM-DD HH:MM:SS\" UTC, the exact shape sqlite's datetime(ms / 1000, 'unixepoch') prints;\n// formatted in JS so the query stays dialect-free.\nfunction utcSecond(ms: number): string {\n  return new Date(ms).toISOString().slice(0, 19).replace('T', ' ');\n}\n\nfunction chunk<T>(items: T[], size: number): T[][] {\n  const out: T[][] = [];\n  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));\n  return out;\n}\n\n// What is this scope: fixed-size output regardless of tree size. Coverage and features stay\n// global -- they describe the tree, not the current question.\nexport function mapTree(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides = {}): Promise<TreeMap> {\n  return serialQuery(store, () => mapIndexed(store, cfg, overrides));\n}\n\nasync function mapIndexed(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<TreeMap> {\n  return store.transaction(async () => {\n    await setupMapScope(store, await scopedPaths(store, cfg, overrides));\n    const scopeWhere = 'WHERE \"path\" IN (SELECT \"path\" FROM _map_scope)';\n    const scopeAnd = 'AND f.\"path\" IN (SELECT \"path\" FROM _map_scope)';\n\n    const docs = (await (await store.prepare(`SELECT COUNT(*) AS count, COALESCE(SUM(\"_size\"), 0) AS bytes FROM frontmatter ${scopeWhere}`)).get()) as { count: number; bytes: number };\n\n    const columns = (await store.docs.columns()).filter((name) => !INTERNAL_COLUMNS.has(name));\n    // Observed types, not declared: a field can be text in most notes and numeric in a few, so\n    // every distinct type observed across the scope is reported, not just the first.\n    const allFields: FieldStat[] = [];\n    for (const group of chunk(columns, MAP_COLUMN_CHUNK)) allFields.push(...(await store.docs.fieldStats(group, scopeWhere)));\n    allFields.sort((a, b) => b.coverage - a.coverage);\n    const fields = allFields.slice(0, 20) as unknown as Row[];\n\n    const hubs = featureEnabled(cfg, 'rank')\n      ? ((await (await store.prepare(`SELECT f.\"path\" AS path, round(f.\"_rank\" * 100, 2) AS rank, content.title FROM frontmatter f JOIN content ON content.path = f.\"path\" WHERE f.\"_rank\" IS NOT NULL ${scopeAnd} ORDER BY f.\"_rank\" DESC, f.\"path\" ASC LIMIT 8`)).all()) as Row[])\n      : [];\n\n    const recent = ((await (await store.prepare(`SELECT \"path\", \"_mtime\" AS mtime FROM frontmatter ${scopeWhere} ORDER BY \"_mtime\" DESC, \"path\" ASC LIMIT 5`)).all()) as Array<{ path: string; mtime: number }>).map((r) => ({ path: r.path, modified: utcSecond(r.mtime) }));\n\n    // A fresh clone/copy stamps files with checkout time, not edit history; second granularity\n    // matches the `recent` table above and is coarse enough to catch that without an exact-ms match.\n    const topSecond = (await (await store.prepare(`SELECT COUNT(*) AS n FROM frontmatter ${scopeWhere} GROUP BY CAST(\"_mtime\" / 1000 AS INTEGER) ORDER BY n DESC LIMIT 1`)).get()) as { n: number } | undefined;\n    const recentCaveat = topSecond && docs.count > 1 && topSecond.n > docs.count / 2 ? `${topSecond.n} of ${docs.count} files share one modified second, so recency likely reflects a checkout or copy, not edit history` : null;\n\n    return { docs, fields, fieldsTotal: allFields.length, features: featureStates(cfg), presets: await presetCoverage(store, cfg), hubs, recent, recentCaveat };\n  });\n}\n"],"names":["mapTree","MAP_COLUMN_CHUNK","utcSecond","ms","Date","toISOString","slice","replace","chunk","items","size","out","i","length","push","store","cfg","overrides","serialQuery","mapIndexed","transaction","allFields","scopeWhere","scopeAnd","docs","columns","group","fields","hubs","recent","topSecond","recentCaveat","scopedPaths","setupMapScope","prepare","get","filter","name","INTERNAL_COLUMNS","has","fieldStats","sort","a","b","coverage","featureEnabled","all","map","r","path","modified","mtime","count","n","fieldsTotal","features","featureStates","presetCoverage","presets"],"mappings":"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"}

package/dist/cjs/commands/peek.js

@@ -20,6 +20,7 @@ var _posix = /*#__PURE__*/ _interop_require_default(require("node:path/posix"));
 var _indexts = require("../chunk/index.js");
 var _indexts1 = require("../config/index.js");
 var _errorsts = require("../errors.js");
+var _serialqueryts = require("../lib/serial-query.js");
 var _scopets = require("./scope.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -225,12 +226,15 @@ function resolveNote(paths, arg) {
     throw new _errorsts.SenseError('NOTE_NOT_FOUND', 'no note matches "'.concat(arg, '"'));
 }
 var PEEK_LIST_LIMIT = 20;
-function peek(_0, _1, _2) {
-    return _async_to_generator(function(store, cfg, pathArg) {
-        var overrides;
-        var _arguments = arguments;
+function peek(store, cfg, pathArg) {
+    var overrides = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+    return (0, _serialqueryts.serialQuery)(store, function() {
+        return peekIndexed(store, cfg, pathArg, overrides);
+    });
+}
+function peekIndexed(store, cfg, pathArg, overrides) {
+    return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
-            overrides = _arguments.length > 3 && _arguments[3] !== void 0 ? _arguments[3] : {};
             return [
                 2,
                 store.transaction(function() {
@@ -421,6 +425,6 @@ function peek(_0, _1, _2) {
                 })
             ];
         });
-    }).apply(this, arguments);
+    })();
 }
 /* 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/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 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 async function peek(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","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, 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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"}

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

@@ -1,5 +1,6 @@
 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<{
     path: string;
     similarity: number;

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

@@ -1,5 +1,6 @@
 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<{
     path: string;
     similarity: number;

package/dist/cjs/commands/related.js

@@ -2,16 +2,25 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "relatedNotes", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get relatedNotes () {
         return relatedNotes;
+    },
+    get resolveRelatedSeed () {
+        return resolveRelatedSeed;
     }
 });
 var _indexts = require("../config/index.js");
 var _queryts = require("../embed/query.js");
 var _storets = require("../embed/store.js");
 var _errorsts = require("../errors.js");
+var _serialqueryts = require("../lib/serial-query.js");
 var _peekts = require("./peek.js");
 var _scopets = require("./scope.js");
 function _array_like_to_array(arr, len) {
@@ -166,9 +175,9 @@ 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);
 }
-function relatedNotes(store, cfg, pathArg, overrides, k) {
+function resolveRelatedSeed(store, pathArg) {
     return _async_to_generator(function() {
-        var _cfg_rootDir, paths, path, outbound, backlinks, exclude, effective, e, allowed;
+        var paths;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -182,20 +191,44 @@ function relatedNotes(store, cfg, pathArg, overrides, k) {
                         _state.sent().all()
                     ];
                 case 2:
-                    paths = _state.sent().map(function(r) {
-                        return r.path;
+                    paths = _state.sent().map(function(row) {
+                        return row.path;
                     });
-                    path = (0, _peekts.resolveNote)(paths, pathArg);
+                    return [
+                        2,
+                        (0, _peekts.resolveNote)(paths, pathArg)
+                    ];
+            }
+        });
+    })();
+}
+function relatedNotes(store, cfg, pathArg, overrides, k) {
+    return (0, _serialqueryts.serialQuery)(store, function() {
+        return relatedIndexed(store, cfg, pathArg, overrides, k);
+    });
+}
+function relatedIndexed(store, cfg, pathArg, overrides, k) {
+    return _async_to_generator(function() {
+        var path, outbound, backlinks, exclude, effective, e, allowed;
+        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 3:
+                case 2:
                     return [
                         4,
                         _state.sent().all(path)
                     ];
-                case 4:
+                case 3:
                     outbound = _state.sent().map(function(r) {
                         return r.dst;
                     });
@@ -203,12 +236,12 @@ function relatedNotes(store, cfg, pathArg, overrides, k) {
                         4,
                         store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst')
                     ];
-                case 5:
+                case 4:
                     return [
                         4,
                         _state.sent().all(path)
                     ];
-                case 6:
+                case 5:
                     backlinks = _state.sent().map(function(r) {
                         return r.src;
                     });
@@ -226,8 +259,8 @@ function relatedNotes(store, cfg, pathArg, overrides, k) {
                     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 proceeds -- embedPending's getProvider call fetches it lazily on
-                    // consent. Only a local path with missing files can never fetch itself.
+                    // 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)"));
@@ -236,21 +269,23 @@ function relatedNotes(store, cfg, pathArg, overrides, k) {
                         4,
                         (0, _scopets.scopedPaths)(store, cfg, overrides)
                     ];
-                case 7:
+                case 6:
                     allowed = _state.sent();
-                    // Top up pending rows before the seed check, or a fresh index reports every note as
-                    // having no indexed text until some search has run.
+                    // 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.embedPending)(store, cfg, (_cfg_rootDir = cfg.rootDir) !== null && _cfg_rootDir !== void 0 ? _cfg_rootDir : cfg.baseDir)
+                        (0, _queryts.ensureDocumentEmbeddings)(store, cfg, new Set(_to_consumable_array(allowed).concat([
+                            path
+                        ])))
                     ];
-                case 8:
+                case 7:
                     _state.sent();
                     return [
                         4,
                         (0, _queryts.hasEmbedding)(store, path)
                     ];
-                case 9:
+                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"));
                     }
@@ -258,7 +293,7 @@ function relatedNotes(store, cfg, pathArg, overrides, k) {
                         4,
                         (0, _scopets.scopeHasEmbeddings)(store, cfg, allowed)
                     ];
-                case 10:
+                case 9:
                     if (!_state.sent()) return [
                         2,
                         []

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 { embedPending, hasEmbedding, similarNotes } from '../embed/query.ts';\nimport { localModelMissing, MODEL_FILENAMES } from '../embed/store.ts';\nimport { SenseError } from '../errors.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths, scopeHasEmbeddings } from './scope.ts';\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 async function relatedNotes(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: SearchOverrides, k: number): Promise<Array<{ path: string; similarity: number }>> {\n  const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n  const path = resolveNote(paths, 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 proceeds -- embedPending's getProvider call fetches it lazily on\n  // consent. Only a local path with missing files 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  // Top up pending rows before the seed check, or a fresh index reports every note as\n  // having no indexed text until some search has run.\n  await embedPending(store, cfg, cfg.rootDir ?? cfg.baseDir);\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","store","cfg","pathArg","overrides","k","paths","path","outbound","backlinks","exclude","effective","e","allowed","prepare","all","map","r","resolveNote","dst","src","Set","resolveSearch","embedEnabled","SenseError","signals","vectors","undefined","presetName","embedConfig","localModelMissing","MODEL_FILENAMES","model","scopedPaths","embedPending","rootDir","baseDir","hasEmbedding","scopeHasEmbeddings","similarNotes"],"mappings":";;;;+BAWsBA;;;eAAAA;;;uBAVmC;uBACA;uBACN;wBACxB;sBAEC;uBACoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIzC,SAAeA,aAAaC,KAAY,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,SAA0B,EAAEC,CAAS;;YA4B3FH,cA3BzBI,OACAC,MAEAC,UACAC,WACAC,SAIAC,WAWAC,GAIAC;;;;oBAxBiB;;wBAAMZ,MAAMa,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAuDC,GAAG;;;oBAA3ET,QAAQ,AAAE,cAAiGU,GAAG,CAAC,SAACC;+BAAMA,EAAEV,IAAI;;oBAC5HA,OAAOW,IAAAA,mBAAW,EAACZ,OAAOH;oBAEN;;wBAAMF,MAAMa,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAwGC,GAAG,CAACR;;;oBAAhIC,WAAW,AAAE,cAAqJQ,GAAG,CAAC,SAACC;+BAAMA,EAAEE,GAAG;;oBAC7J;;wBAAMlB,MAAMa,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAoFC,GAAG,CAACR;;;oBAA7GE,YAAY,AAAE,cAAiIO,GAAG,CAAC,SAACC;+BAAMA,EAAEG,GAAG;;oBAC/JV,UAAU,IAAIW,IAAI;wBAACd;sBAAD,OAAO,qBAAGC,WAAU,qBAAGC;oBAE/C,yFAAyF;oBACzF,8EAA8E;oBACxEE,YAAYW,IAAAA,sBAAa,EAACpB,KAAKE;oBACrC,IAAI,CAACmB,IAAAA,qBAAY,EAACrB,MAAM;wBACtB,MAAM,IAAIsB,oBAAU,CAAC,kBAAkB;oBACzC;oBACA,0FAA0F;oBAC1F,2FAA2F;oBAC3F,IAAIb,UAAUc,OAAO,CAACC,OAAO,KAAKC,WAAW;wBAC3C,MAAM,IAAIH,oBAAU,CAAC,uBAAuB,AAAC,WAA+B,OAArBb,UAAUiB,UAAU,EAAC;oBAC9E;oBACA,wFAAwF;oBACxF,wEAAwE;oBAClEhB,IAAIiB,IAAAA,oBAAW,EAAC3B,MAAM,iDAAiD;oBAC7E,IAAI4B,IAAAA,0BAAiB,EAAClB,IAAI;wBACxB,MAAM,IAAIY,oBAAU,CAAC,uBAAuB,AAAC,8FAAoHO,OAAvBnB,EAAEoB,KAAK,EAAC,iBAA+B,OAAhBD,wBAAe,EAAC;oBACnL;oBACgB;;wBAAME,IAAAA,oBAAW,EAAChC,OAAOC,KAAKE;;;oBAAxCS,UAAU;oBAChB,oFAAoF;oBACpF,oDAAoD;oBACpD;;wBAAMqB,IAAAA,qBAAY,EAACjC,OAAOC,MAAKA,eAAAA,IAAIiC,OAAO,cAAXjC,0BAAAA,eAAeA,IAAIkC,OAAO;;;oBAAzD;oBACM;;wBAAMC,IAAAA,qBAAY,EAACpC,OAAOM;;;oBAAhC,IAAI,CAAE,eAAkC;wBACtC,MAAM,IAAIiB,oBAAU,CAAC,qBAAqB,AAAC,GAAO,OAALjB,MAAK;oBACpD;oBACM;;wBAAM+B,IAAAA,2BAAkB,EAACrC,OAAOC,KAAKW;;;oBAA3C,IAAI,CAAE,eAAgD;;;;oBACtD;;wBAAO0B,IAAAA,qBAAY,EAACtC,OAAOC,KAAKK,MAAM;4BAAEG,SAAAA;4BAASG,SAAAA;4BAASR,GAAAA;wBAAE;;;;IAC9D"}
+{"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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"}

package/dist/cjs/commands/scope.js

@@ -218,7 +218,7 @@ function scopeHasEmbeddings(store, cfg, scopedPaths) {
                     ]; // the embeddings table doesn't exist at all in this case
                     return [
                         4,
-                        store.prepare('SELECT DISTINCT "path" FROM embeddings')
+                        store.prepare('SELECT DISTINCT "path" FROM embeddings WHERE vector IS NOT NULL')
                     ];
                 case 1:
                     stmt = _state.sent();

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Store } from '../store/types.ts';\n\nexport const INTERNAL_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_rank', '_parse_error']);\n\n// node:path's matchesGlob is experimental (stable behind an unstable-API flag) at the\n// Node >=22.20 engines floor; used here in JS rather than a directory walk in the query path.\nexport function inScope(path: string, include: string[], exclude?: string[]): boolean {\n  if (!include.some((g) => matchesGlob(path, g))) return false;\n  if (exclude?.some((g) => matchesGlob(path, g))) return false;\n  return true;\n}\n\nexport async function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean> {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const stmt = await store.prepare('SELECT DISTINCT \"path\" FROM embeddings');\n  const rows = (await stmt.all()) as Array<{ path: string }>;\n  return rows.some((r) => scopedPaths.has(r.path));\n}\n\n// Scope only (no --where): preset_files for a named preset, JS glob matching for an ad hoc\n// include/exclude override. Shared by scopedPaths() and search()'s candidate-pool sizing.\nexport async function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  const { include, exclude } = effective;\n  const adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;\n  if (!adHocScope) {\n    const stmt = await store.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?');\n    return new Set(((await stmt.all(effective.presetName)) as Array<{ path: string }>).map((r) => r.path));\n  }\n  const paths = allPaths ?? (await allFrontmatterPaths(store));\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nasync function allFrontmatterPaths(store: Store): Promise<string[]> {\n  const stmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n  return ((await stmt.all()) as Array<{ path: string }>).map((r) => r.path);\n}\n\nexport async function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    const stmt = await store.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`);\n    whereRows = (await stmt.all()) as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(await store.docs.columns(), err as Error);\n  }\n  const wherePaths = new Set(whereRows.map((r) => r.path));\n  return new Set([...paths].filter((p) => wherePaths.has(p)));\n}\n\n// The scope resolver for non-search commands (path, peek, map): same coverage rule search()\n// applies, then narrowed by the resolved `where`.\nexport async function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(store, await rawScope(store, cfg, overrides), effective.where);\n}\n\n// Materializes a path set into a named temp table (same shape as traverse.ts's allowed_nodes)\n// so a query can join/filter against it cheaply instead of binding a parameter per path.\nexport async function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void> {\n  await store.exec(`DROP TABLE IF EXISTS ${table}`);\n  await store.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  await store.runBatch(\n    `INSERT INTO ${table} (\"path\") VALUES (?)`,\n    [...paths].map((p) => [p])\n  );\n}\n\nexport async function setupMapScope(store: Store, paths: Set<string>): Promise<void> {\n  await materializeScope(store, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","Set","path","include","exclude","some","g","matchesGlob","store","cfg","stmt","rows","anyPresetEmbeds","prepare","all","r","has","overrides","allPaths","effective","adHocScope","paths","resolveSearch","undefined","noExclude","presetName","map","allFrontmatterPaths","filter","p","where","whereRows","err","wherePaths","docs","columns","columnHint","table","exec","runBatch"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/scope.ts"],"sourcesContent":["import { matchesGlob } from 'node:path';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { anyPresetEmbeds, resolveSearch } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Store } from '../store/types.ts';\n\nexport const INTERNAL_COLUMNS = new Set(['path', '_mtime', '_ctime', '_size', '_rank', '_parse_error']);\n\n// node:path's matchesGlob is experimental (stable behind an unstable-API flag) at the\n// Node >=22.20 engines floor; used here in JS rather than a directory walk in the query path.\nexport function inScope(path: string, include: string[], exclude?: string[]): boolean {\n  if (!include.some((g) => matchesGlob(path, g))) return false;\n  if (exclude?.some((g) => matchesGlob(path, g))) return false;\n  return true;\n}\n\nexport async function scopeHasEmbeddings(store: Store, cfg: ResolvedConfig, scopedPaths: Set<string>): Promise<boolean> {\n  if (!anyPresetEmbeds(cfg)) return false; // the embeddings table doesn't exist at all in this case\n  const stmt = await store.prepare('SELECT DISTINCT \"path\" FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{ path: string }>;\n  return rows.some((r) => scopedPaths.has(r.path));\n}\n\n// Scope only (no --where): preset_files for a named preset, JS glob matching for an ad hoc\n// include/exclude override. Shared by scopedPaths() and search()'s candidate-pool sizing.\nexport async function rawScope(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides, allPaths?: string[]): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  const { include, exclude } = effective;\n  const adHocScope = overrides.include !== undefined || overrides.exclude !== undefined || overrides.noExclude === true;\n  if (!adHocScope) {\n    const stmt = await store.prepare('SELECT \"path\" FROM preset_files WHERE preset = ?');\n    return new Set(((await stmt.all(effective.presetName)) as Array<{ path: string }>).map((r) => r.path));\n  }\n  const paths = allPaths ?? (await allFrontmatterPaths(store));\n  return new Set(paths.filter((p) => inScope(p, include, exclude)));\n}\n\nasync function allFrontmatterPaths(store: Store): Promise<string[]> {\n  const stmt = await store.prepare('SELECT \"path\" FROM frontmatter');\n  return ((await stmt.all()) as Array<{ path: string }>).map((r) => r.path);\n}\n\nexport async function narrowByWhere(store: Store, paths: Set<string>, where: string | undefined): Promise<Set<string>> {\n  if (!where) return paths;\n  let whereRows: Array<{ path: string }>;\n  try {\n    const stmt = await store.prepare(`SELECT \"path\" FROM frontmatter f WHERE (${where})`);\n    whereRows = (await stmt.all()) as Array<{ path: string }>;\n  } catch (err) {\n    throw columnHint(await store.docs.columns(), err as Error);\n  }\n  const wherePaths = new Set(whereRows.map((r) => r.path));\n  return new Set([...paths].filter((p) => wherePaths.has(p)));\n}\n\n// The scope resolver for non-search commands (path, peek, map): same coverage rule search()\n// applies, then narrowed by the resolved `where`.\nexport async function scopedPaths(store: Store, cfg: ResolvedConfig, overrides: SearchOverrides): Promise<Set<string>> {\n  const effective = resolveSearch(cfg, overrides);\n  return narrowByWhere(store, await rawScope(store, cfg, overrides), effective.where);\n}\n\n// Materializes a path set into a named temp table (same shape as traverse.ts's allowed_nodes)\n// so a query can join/filter against it cheaply instead of binding a parameter per path.\nexport async function materializeScope(store: Store, table: string, paths: Set<string>): Promise<void> {\n  await store.exec(`DROP TABLE IF EXISTS ${table}`);\n  await store.exec(`CREATE TEMP TABLE ${table} (\"path\" TEXT PRIMARY KEY)`);\n  await store.runBatch(\n    `INSERT INTO ${table} (\"path\") VALUES (?)`,\n    [...paths].map((p) => [p])\n  );\n}\n\nexport async function setupMapScope(store: Store, paths: Set<string>): Promise<void> {\n  await materializeScope(store, '_map_scope', paths);\n}\n"],"names":["INTERNAL_COLUMNS","inScope","materializeScope","narrowByWhere","rawScope","scopeHasEmbeddings","scopedPaths","setupMapScope","Set","path","include","exclude","some","g","matchesGlob","store","cfg","stmt","rows","anyPresetEmbeds","prepare","all","r","has","overrides","allPaths","effective","adHocScope","paths","resolveSearch","undefined","noExclude","presetName","map","allFrontmatterPaths","filter","p","where","whereRows","err","wherePaths","docs","columns","columnHint","table","exec","runBatch"],"mappings":"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"}