sensemaking 0.26.0 → 0.27.1

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 { serialQuery } from '../lib/serial-query.ts';\nimport type { FieldStat, Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, scopedPaths, setupMapScope } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\nimport type { PresetCoverage } from './status.ts';\nimport { presetCoverage } from './status.ts';\n\nexport interface TreeMap {\n  docs: { count: number; bytes: number };\n  fields: TreeMapField[]; // top 20 by coverage; fieldsTotal carries the real count\n  fieldsTotal: number;\n  features: { on: FeatureName[]; off: FeatureName[] };\n  presets: PresetCoverage[];\n  hubs: TreeMapHub[];\n  recent: TreeMapRecent[];\n  recentCaveat: string | null;\n}\n\nexport type TreeMapField = FieldStat;\n\nexport type TreeMapHub = {\n  path: string;\n  rank: number;\n  title: string;\n};\n\nexport type TreeMapRecent = {\n  path: string;\n  modified: string;\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 assertQuerySnapshot(store, cfg);\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);\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 TreeMapHub[])\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","assertQuerySnapshot","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/open-source/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 { FieldStat, Store } from '../store/types.ts';\nimport { INTERNAL_COLUMNS, scopedPaths, setupMapScope } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\nimport type { PresetCoverage } from './status.ts';\nimport { presetCoverage } from './status.ts';\n\nexport interface TreeMap {\n  docs: { count: number; bytes: number };\n  fields: TreeMapField[]; // top 20 by coverage; fieldsTotal carries the real count\n  fieldsTotal: number;\n  features: { on: FeatureName[]; off: FeatureName[] };\n  presets: PresetCoverage[];\n  hubs: TreeMapHub[];\n  recent: TreeMapRecent[];\n  recentCaveat: string | null;\n}\n\nexport type TreeMapField = FieldStat;\n\nexport type TreeMapHub = {\n  path: string;\n  rank: number;\n  title: string;\n};\n\nexport type TreeMapRecent = {\n  path: string;\n  modified: string;\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 assertQuerySnapshot(store, cfg);\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);\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 TreeMapHub[])\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","assertQuerySnapshot","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/path.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/path.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { findPathInSnapshot } from '../graph/traverse.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\n/**\n * Options for {@link findPath}. Scope fields constrain intermediate nodes; `maxDepth` limits the\n * number of traversed links and must be a positive integer when supplied.\n */\nexport type PathOptions = Omit<SearchOverrides, 'k'> & {\n  maxDepth?: number;\n};\n\n/**\n * Finds the shortest undirected link path between two indexed notes. Endpoints resolve across\n * the indexed tree and remain permitted outside the scope applied to intermediate nodes.\n */\nexport function findPath(store: Store, cfg: ResolvedConfig, fromArg: string, toArg: string, options: PathOptions = {}): Promise<string[] | null> {\n  return serialQuery(store, () => findScopedPath(store, cfg, fromArg, toArg, options));\n}\n\nasync function findScopedPath(store: Store, cfg: ResolvedConfig, fromArg: string, toArg: string, options: PathOptions): Promise<string[] | null> {\n  if (options.maxDepth !== undefined && (!Number.isFinite(options.maxDepth) || !Number.isInteger(options.maxDepth) || options.maxDepth <= 0)) {\n    throw new SenseError('SEARCH_OPTION_INVALID', `path option \"maxDepth\" must be a positive finite integer, got ${String(options.maxDepth)}`);\n  }\n  // Validate the named preset before opening the snapshot; repeat it inside because preset_files\n  // and the compatibility assertion below belong to the final published generation.\n  resolveSearch(cfg, options);\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    resolveSearch(cfg, options);\n    const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((row) => row.path);\n    const from = resolveNote(paths, fromArg);\n    const to = resolveNote(paths, toArg);\n    const allowed = await scopedPaths(store, cfg, options);\n    return findPathInSnapshot(store, from, to, { maxDepth: options.maxDepth, allowed });\n  });\n}\n"],"names":["findPath","store","cfg","fromArg","toArg","options","serialQuery","findScopedPath","maxDepth","undefined","Number","isFinite","isInteger","SenseError","String","resolveSearch","transaction","paths","from","to","allowed","assertQuerySnapshot","prepare","all","map","row","path","resolveNote","scopedPaths","findPathInSnapshot"],"mappings":";;;;+BAsBgBA;;;eAAAA;;;uBArBc;wBACH;0BACQ;6BACP;sBAEA;uBACA;0BACQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAc7B,SAASA,SAASC,KAAY,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,KAAa;QAAEC,UAAAA,iEAAuB,CAAC;IAClH,OAAOC,IAAAA,0BAAW,EAACL,OAAO;eAAMM,eAAeN,OAAOC,KAAKC,SAASC,OAAOC;;AAC7E;AAEA,SAAeE,eAAeN,KAAY,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,KAAa,EAAEC,OAAoB;;;YACnH,IAAIA,QAAQG,QAAQ,KAAKC,aAAc,CAAA,CAACC,OAAOC,QAAQ,CAACN,QAAQG,QAAQ,KAAK,CAACE,OAAOE,SAAS,CAACP,QAAQG,QAAQ,KAAKH,QAAQG,QAAQ,IAAI,CAAA,GAAI;gBAC1I,MAAM,IAAIK,oBAAU,CAAC,yBAAyB,AAAC,iEAAyF,OAAzBC,OAAOT,QAAQG,QAAQ;YACxI;YACA,+FAA+F;YAC/F,kFAAkF;YAClFO,IAAAA,sBAAa,EAACb,KAAKG;YACnB;;gBAAOJ,MAAMe,WAAW,CAAC;;4BAGjBC,OACAC,MACAC,IACAC;;;;oCALN;;wCAAMC,IAAAA,+BAAmB,EAACpB,OAAOC;;;oCAAjC;oCACAa,IAAAA,sBAAa,EAACb,KAAKG;oCACI;;wCAAMJ,MAAMqB,OAAO,CAAC;;;oCAA3B;;wCAAO,cAAuDC,GAAG;;;oCAA3EN,QAAQ,AAAE,cAAiGO,GAAG,CAAC,SAACC;+CAAQA,IAAIC,IAAI;;oCAChIR,OAAOS,IAAAA,mBAAW,EAACV,OAAOd;oCAC1BgB,KAAKQ,IAAAA,mBAAW,EAACV,OAAOb;oCACd;;wCAAMwB,IAAAA,oBAAW,EAAC3B,OAAOC,KAAKG;;;oCAAxCe,UAAU;oCAChB;;wCAAOS,IAAAA,8BAAkB,EAAC5B,OAAOiB,MAAMC,IAAI;4CAAEX,UAAUH,QAAQG,QAAQ;4CAAEY,SAAAA;wCAAQ;;;;oBACnF;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/ai/sensemaking/src/commands/path.ts"],"sourcesContent":["import type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { findPathInSnapshot } from '../graph/traverse.ts';\nimport { serialQuery } from '../lib/serial-query.ts';\nimport type { Store } from '../store/types.ts';\nimport { resolveNote } from './peek.ts';\nimport { scopedPaths } from './scope.ts';\nimport { assertQuerySnapshot } from './snapshot.ts';\n\n/**\n * Options for {@link findPath}. Scope fields constrain intermediate nodes; `maxDepth` limits the\n * number of traversed links and must be a positive integer when supplied.\n */\nexport type PathOptions = Omit<SearchOverrides, 'k'> & {\n  maxDepth?: number;\n};\n\n/**\n * Finds the shortest undirected link path between two indexed notes. Endpoints resolve across\n * the indexed tree and remain permitted outside the scope applied to intermediate nodes.\n */\nexport function findPath(store: Store, cfg: ResolvedConfig, fromArg: string, toArg: string, options: PathOptions = {}): Promise<string[] | null> {\n  return serialQuery(store, () => findScopedPath(store, cfg, fromArg, toArg, options));\n}\n\nasync function findScopedPath(store: Store, cfg: ResolvedConfig, fromArg: string, toArg: string, options: PathOptions): Promise<string[] | null> {\n  if (options.maxDepth !== undefined && (!Number.isFinite(options.maxDepth) || !Number.isInteger(options.maxDepth) || options.maxDepth <= 0)) {\n    throw new SenseError('SEARCH_OPTION_INVALID', `path option \"maxDepth\" must be a positive finite integer, got ${String(options.maxDepth)}`);\n  }\n  // Validate the named preset before opening the snapshot; repeat it inside because preset_files\n  // and the compatibility assertion below belong to the final published generation.\n  resolveSearch(cfg, options);\n  return store.transaction(async () => {\n    await assertQuerySnapshot(store, cfg);\n    resolveSearch(cfg, options);\n    const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((row) => row.path);\n    const from = resolveNote(paths, fromArg);\n    const to = resolveNote(paths, toArg);\n    const allowed = await scopedPaths(store, cfg, options);\n    return findPathInSnapshot(store, from, to, { maxDepth: options.maxDepth, allowed });\n  });\n}\n"],"names":["findPath","store","cfg","fromArg","toArg","options","serialQuery","findScopedPath","maxDepth","undefined","Number","isFinite","isInteger","SenseError","String","resolveSearch","transaction","paths","from","to","allowed","assertQuerySnapshot","prepare","all","map","row","path","resolveNote","scopedPaths","findPathInSnapshot"],"mappings":";;;;+BAsBgBA;;;eAAAA;;;uBArBc;wBACH;0BACQ;6BACP;sBAEA;uBACA;0BACQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAc7B,SAASA,SAASC,KAAY,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,KAAa;QAAEC,UAAAA,iEAAuB,CAAC;IAClH,OAAOC,IAAAA,0BAAW,EAACL,OAAO;eAAMM,eAAeN,OAAOC,KAAKC,SAASC,OAAOC;;AAC7E;AAEA,SAAeE,eAAeN,KAAY,EAAEC,GAAmB,EAAEC,OAAe,EAAEC,KAAa,EAAEC,OAAoB;;;YACnH,IAAIA,QAAQG,QAAQ,KAAKC,aAAc,CAAA,CAACC,OAAOC,QAAQ,CAACN,QAAQG,QAAQ,KAAK,CAACE,OAAOE,SAAS,CAACP,QAAQG,QAAQ,KAAKH,QAAQG,QAAQ,IAAI,CAAA,GAAI;gBAC1I,MAAM,IAAIK,oBAAU,CAAC,yBAAyB,AAAC,iEAAyF,OAAzBC,OAAOT,QAAQG,QAAQ;YACxI;YACA,+FAA+F;YAC/F,kFAAkF;YAClFO,IAAAA,sBAAa,EAACb,KAAKG;YACnB;;gBAAOJ,MAAMe,WAAW,CAAC;;4BAGjBC,OACAC,MACAC,IACAC;;;;oCALN;;wCAAMC,IAAAA,+BAAmB,EAACpB,OAAOC;;;oCAAjC;oCACAa,IAAAA,sBAAa,EAACb,KAAKG;oCACI;;wCAAMJ,MAAMqB,OAAO,CAAC;;;oCAA3B;;wCAAO,cAAuDC,GAAG;;;oCAA3EN,QAAQ,AAAE,cAAiGO,GAAG,CAAC,SAACC;+CAAQA,IAAIC,IAAI;;oCAChIR,OAAOS,IAAAA,mBAAW,EAACV,OAAOd;oCAC1BgB,KAAKQ,IAAAA,mBAAW,EAACV,OAAOb;oCACd;;wCAAMwB,IAAAA,oBAAW,EAAC3B,OAAOC,KAAKG;;;oCAAxCe,UAAU;oCAChB;;wCAAOS,IAAAA,8BAAkB,EAAC5B,OAAOiB,MAAMC,IAAI;4CAAEX,UAAUH,QAAQG,QAAQ;4CAAEY,SAAAA;wCAAQ;;;;oBACnF;;;;IACF"}

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

@@ -21,6 +21,7 @@ export interface Peek {
     /** Disabled features whose result blocks are omitted rather than returned empty. */
     off: FeatureName[];
 }
+/** A section description, with an inclusive source line range and token estimate, not section prose. */
 export interface PeekSection {
     level: number;
     heading: string;
@@ -28,8 +29,15 @@ export interface PeekSection {
     end_line: number;
     tokens: number;
 }
+/** Options for the root {@link peek} API. */
+export interface PeekOptions extends SearchOverrides {
+    /** Maximum section descriptions. Defaults to 20; must be a positive safe integer. */
+    sectionCountLimit?: number;
+    /** Maximum entries in each link group independently. Defaults to 20; must be a positive safe integer. */
+    linkCountLimit?: number;
+}
 /**
  * Returns indexed metadata for a note in scope. Exact excluded paths fail before scoped basename
  * resolution; resolved neighbors stay in scope, while unresolved written targets remain visible.
  */
-export declare function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Promise<Peek>;
+export declare function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides?: PeekOptions): Promise<Peek>;

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

@@ -21,6 +21,7 @@ export interface Peek {
     /** Disabled features whose result blocks are omitted rather than returned empty. */
     off: FeatureName[];
 }
+/** A section description, with an inclusive source line range and token estimate, not section prose. */
 export interface PeekSection {
     level: number;
     heading: string;
@@ -28,8 +29,15 @@ export interface PeekSection {
     end_line: number;
     tokens: number;
 }
+/** Options for the root {@link peek} API. */
+export interface PeekOptions extends SearchOverrides {
+    /** Maximum section descriptions. Defaults to 20; must be a positive safe integer. */
+    sectionCountLimit?: number;
+    /** Maximum entries in each link group independently. Defaults to 20; must be a positive safe integer. */
+    linkCountLimit?: number;
+}
 /**
  * Returns indexed metadata for a note in scope. Exact excluded paths fail before scoped basename
  * resolution; resolved neighbors stay in scope, while unresolved written targets remain visible.
  */
-export declare function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides?: SearchOverrides): Promise<Peek>;
+export declare function peek(store: Store, cfg: ResolvedConfig, pathArg: string, overrides?: PeekOptions): Promise<Peek>;

package/dist/cjs/commands/peek.js

@@ -232,7 +232,7 @@ function resolveNote(paths, arg) {
     if (matches.length > 1) throw new _errorsts.SenseError('NOTE_AMBIGUOUS', '"'.concat(arg, '" is ambiguous: ').concat(matches.join(', ')));
     throw new _errorsts.SenseError('NOTE_NOT_FOUND', 'no note matches "'.concat(arg, '"'));
 }
-var PEEK_LIST_LIMIT = 20;
+var PEEK_COUNT_LIMIT = 20;
 function peek(store, cfg, pathArg) {
     var overrides = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
     return (0, _serialqueryts.serialQuery)(store, function() {
@@ -241,12 +241,25 @@ function peek(store, cfg, pathArg) {
 }
 function peekIndexed(store, cfg, pathArg, overrides) {
     return _async_to_generator(function() {
+        var _overrides_sectionCountLimit, _overrides_linkCountLimit, _i, _iter, name, value, sectionCountLimit, linkCountLimit;
         return _ts_generator(this, function(_state) {
+            for(_i = 0, _iter = [
+                'sectionCountLimit',
+                'linkCountLimit'
+            ]; _i < _iter.length; _i++){
+                name = _iter[_i];
+                value = overrides[name];
+                if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
+                    throw new _errorsts.SenseError('SEARCH_OPTION_INVALID', 'peek option "'.concat(name, '" must be a positive safe integer, got ').concat(String(value)));
+                }
+            }
+            sectionCountLimit = (_overrides_sectionCountLimit = overrides.sectionCountLimit) !== null && _overrides_sectionCountLimit !== void 0 ? _overrides_sectionCountLimit : PEEK_COUNT_LIMIT;
+            linkCountLimit = (_overrides_linkCountLimit = overrides.linkCountLimit) !== null && _overrides_linkCountLimit !== void 0 ? _overrides_linkCountLimit : PEEK_COUNT_LIMIT;
             return [
                 2,
                 store.transaction(function() {
                     return _async_to_generator(function() {
-                        var _row__parse_error, _row__size, _this, pathsStmt, paths, allowed, path, excludedPath, rowStmt, row, parseError, frontmatter, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, sectionsTotal, sections, outbound, backlinks, unresolved, backlinksTotal, out, body, byteTokens, tokens;
+                        var _row__parse_error, _row__size, _this, pathsStmt, paths, allowed, path, excludedPath, rowStmt, row, parseError, frontmatter, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, sectionsTotal, sections, outbound, backlinks, unresolved, outboundTotal, backlinksTotal, unresolvedTotal, body, byteTokens, tokens;
                         return _ts_generator(this, function(_state) {
                             switch(_state.label){
                                 case 0:
@@ -354,7 +367,7 @@ function peekIndexed(store, cfg, pathArg, overrides) {
                                 case 9:
                                     return [
                                         4,
-                                        _state.sent().all(path, PEEK_LIST_LIMIT)
+                                        _state.sent().all(path, sectionCountLimit)
                                     ];
                                 case 10:
                                     sections = _state.sent();
@@ -363,10 +376,12 @@ function peekIndexed(store, cfg, pathArg, overrides) {
                                     outbound = [];
                                     backlinks = [];
                                     unresolved = [];
+                                    outboundTotal = 0;
                                     backlinksTotal = 0;
+                                    unresolvedTotal = 0;
                                     if (!(0, _indexts1.featureEnabled)(cfg, 'links')) return [
                                         3,
-                                        19
+                                        25
                                     ];
                                     return [
                                         4,
@@ -376,61 +391,89 @@ function peekIndexed(store, cfg, pathArg, overrides) {
                                     _state.sent();
                                     return [
                                         4,
-                                        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')
+                                        store.prepare('SELECT COUNT(DISTINCT dst) AS n FROM links WHERE src = ? AND dst != src AND dst IN (SELECT "path" FROM _peek_scope)')
                                     ];
                                 case 13:
                                     return [
                                         4,
-                                        _state.sent().all(path)
+                                        _state.sent().get(path)
                                     ];
                                 case 14:
-                                    out = _state.sent();
-                                    outbound = _to_consumable_array(new Set(out.filter(function(l) {
-                                        return l.dst !== null;
-                                    }).map(function(l) {
-                                        return l.dst;
-                                    })));
-                                    unresolved = out.filter(function(l) {
-                                        return l.dst === null;
-                                    }).map(function(l) {
-                                        return l.target;
+                                    outboundTotal = _state.sent().n;
+                                    return [
+                                        4,
+                                        store.prepare('SELECT dst FROM links WHERE src = ? AND dst != src AND dst IN (SELECT "path" FROM _peek_scope) GROUP BY dst ORDER BY MIN(target) LIMIT ?')
+                                    ];
+                                case 15:
+                                    return [
+                                        4,
+                                        _state.sent().all(path, linkCountLimit)
+                                    ];
+                                case 16:
+                                    // The first written target determines each resolved destination's position.
+                                    outbound = _state.sent().map(function(r) {
+                                        return r.dst;
+                                    });
+                                    return [
+                                        4,
+                                        store.prepare('SELECT COUNT(*) AS n FROM links WHERE src = ? AND dst IS NULL')
+                                    ];
+                                case 17:
+                                    return [
+                                        4,
+                                        _state.sent().get(path)
+                                    ];
+                                case 18:
+                                    unresolvedTotal = _state.sent().n;
+                                    return [
+                                        4,
+                                        store.prepare('SELECT target FROM links WHERE src = ? AND dst IS NULL ORDER BY target LIMIT ?')
+                                    ];
+                                case 19:
+                                    return [
+                                        4,
+                                        _state.sent().all(path, linkCountLimit)
+                                    ];
+                                case 20:
+                                    unresolved = _state.sent().map(function(r) {
+                                        return r.target;
                                     });
                                     return [
                                         4,
                                         store.prepare('SELECT COUNT(DISTINCT src) AS n FROM links WHERE dst = ? AND src != dst AND src IN (SELECT "path" FROM _peek_scope)')
                                     ];
-                                case 15:
+                                case 21:
                                     return [
                                         4,
                                         _state.sent().get(path)
                                     ];
-                                case 16:
+                                case 22:
                                     backlinksTotal = _state.sent().n;
                                     return [
                                         4,
                                         store.prepare('SELECT DISTINCT src FROM links WHERE dst = ? AND src != dst AND src IN (SELECT "path" FROM _peek_scope) ORDER BY src LIMIT ?')
                                     ];
-                                case 17:
+                                case 23:
                                     return [
                                         4,
-                                        _state.sent().all(path, PEEK_LIST_LIMIT)
+                                        _state.sent().all(path, linkCountLimit)
                                     ];
-                                case 18:
+                                case 24:
                                     backlinks = _state.sent().map(function(r) {
                                         return r.src;
                                     });
-                                    _state.label = 19;
-                                case 19:
+                                    _state.label = 25;
+                                case 25:
                                     return [
                                         4,
                                         store.prepare('SELECT text FROM content WHERE "path" = ?')
                                     ];
-                                case 20:
+                                case 26:
                                     return [
                                         4,
                                         _state.sent().get(path)
                                     ];
-                                case 21:
+                                case 27:
                                     body = (_this = _state.sent()) === null || _this === void 0 ? void 0 : _this.text;
                                     byteTokens = Math.ceil(((_row__size = row._size) !== null && _row__size !== void 0 ? _row__size : 0) / 4);
                                     tokens = body !== undefined ? Math.max(Math.ceil((0, _indexts.estimateTokens)(body)), byteTokens) : byteTokens;
@@ -442,13 +485,13 @@ function peekIndexed(store, cfg, pathArg, overrides) {
                                             frontmatter: frontmatter,
                                             parseError: parseError,
                                             sections: sections,
-                                            outbound: outbound.slice(0, PEEK_LIST_LIMIT),
+                                            outbound: outbound,
                                             backlinks: backlinks,
-                                            unresolved: unresolved.slice(0, PEEK_LIST_LIMIT),
+                                            unresolved: unresolved,
                                             sectionsTotal: sectionsTotal,
-                                            outboundTotal: outbound.length,
+                                            outboundTotal: outboundTotal,
                                             backlinksTotal: backlinksTotal,
-                                            unresolvedTotal: unresolved.length,
+                                            unresolvedTotal: unresolvedTotal,
                                             off: [
                                                 'sections',
                                                 'links'

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, 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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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/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\n/** A section description, with an inclusive source line range and token estimate, not section prose. */\nexport interface PeekSection {\n  level: number;\n  heading: string;\n  start_line: number;\n  end_line: number;\n  tokens: number;\n}\n\n/** Options for the root {@link peek} API. */\nexport interface PeekOptions extends SearchOverrides {\n  /** Maximum section descriptions. Defaults to 20; must be a positive safe integer. */\n  sectionCountLimit?: number;\n  /** Maximum entries in each link group independently. Defaults to 20; must be a positive safe integer. */\n  linkCountLimit?: number;\n}\n\nconst PEEK_COUNT_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: PeekOptions = {}): Promise<Peek> {\n  return serialQuery(store, () => peekIndexed(store, cfg, pathArg, overrides));\n}\n\nasync function peekIndexed(store: Store, cfg: ResolvedConfig, pathArg: string, overrides: PeekOptions): Promise<Peek> {\n  for (const name of ['sectionCountLimit', 'linkCountLimit'] as const) {\n    const value = overrides[name];\n    if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {\n      throw new SenseError('SEARCH_OPTION_INVALID', `peek option \"${name}\" must be a positive safe integer, got ${String(value)}`);\n    }\n  }\n  const sectionCountLimit = overrides.sectionCountLimit ?? PEEK_COUNT_LIMIT;\n  const linkCountLimit = overrides.linkCountLimit ?? PEEK_COUNT_LIMIT;\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, sectionCountLimit)) as PeekSection[];\n    }\n\n    let outbound: string[] = [];\n    let backlinks: string[] = [];\n    let unresolved: string[] = [];\n    let outboundTotal = 0;\n    let backlinksTotal = 0;\n    let unresolvedTotal = 0;\n    if (featureEnabled(cfg, 'links')) {\n      await materializeScope(store, '_peek_scope', allowed);\n      outboundTotal = ((await (await store.prepare('SELECT COUNT(DISTINCT dst) AS n FROM links WHERE src = ? AND dst != src AND dst IN (SELECT \"path\" FROM _peek_scope)')).get(path)) as { n: number }).n;\n      // The first written target determines each resolved destination's position.\n      outbound = ((await (await store.prepare('SELECT dst FROM links WHERE src = ? AND dst != src AND dst IN (SELECT \"path\" FROM _peek_scope) GROUP BY dst ORDER BY MIN(target) LIMIT ?')).all(path, linkCountLimit)) as Array<{ dst: string }>).map((r) => r.dst);\n      unresolvedTotal = ((await (await store.prepare('SELECT COUNT(*) AS n FROM links WHERE src = ? AND dst IS NULL')).get(path)) as { n: number }).n;\n      unresolved = ((await (await store.prepare('SELECT target FROM links WHERE src = ? AND dst IS NULL ORDER BY target LIMIT ?')).all(path, linkCountLimit)) as Array<{ target: string }>).map((r) => r.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, linkCountLimit)) 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,\n      backlinks,\n      unresolved,\n      sectionsTotal,\n      outboundTotal,\n      backlinksTotal,\n      unresolvedTotal,\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_COUNT_LIMIT","store","cfg","pathArg","overrides","serialQuery","peekIndexed","name","value","sectionCountLimit","linkCountLimit","undefined","Number","isSafeInteger","String","transaction","row","pathsStmt","allowed","path","excludedPath","rowStmt","parseError","frontmatter","key","sectionsTotal","sections","outbound","backlinks","unresolved","outboundTotal","backlinksTotal","unresolvedTotal","body","byteTokens","tokens","assertQuerySnapshot","prepare","all","map","r","scopedPaths","includes","has","err","code","unscopedErr","get","_parse_error","Object","entries","INTERNAL_COLUMNS","featureEnabled","n","materializeScope","dst","target","src","text","Math","ceil","_size","max","estimateTokens","off"],"mappings":"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"}

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, 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":";;;;;;;;;;;QAWaA;eAAAA;;QAwBGC;eAAAA;;QATMC;eAAAA;;;uBAzBmC;uBACY;uBAClB;wBACxB;6BACC;sBAEA;uBACiD;0BACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE7B,IAAMF,oBAAoB;AAe1B,SAAeE,mBAAmBC,KAAY,EAAEC,OAAe;;YAC9DC;;;;oBAAiB;;wBAAMF,MAAMG,OAAO,CAAC;;;oBAA3B;;wBAAO,cAAuDC,GAAG;;;oBAA3EF,QAAQ,AAAE,cAAiGG,GAAG,CAAC,SAACC;+BAAQA,IAAIC,IAAI;;oBACtI;;wBAAOC,IAAAA,mBAAW,EAACN,OAAOD;;;;IAC5B;;AAMO,SAASH,aAAaE,KAAY,EAAES,GAAmB,EAAER,OAAe;QAAES,UAAAA,iEAA0B,CAAC;IAC1G,OAAOC,IAAAA,0BAAW,EAACX,OAAO;YAAmDU;eAA7CE,eAAeZ,OAAOS,KAAKR,SAASS,UAASA,aAAAA,QAAQG,CAAC,cAATH,wBAAAA,aAAab;;AAC5F;AAEA,SAAee,eAAeZ,KAAY,EAAES,GAAmB,EAAER,OAAe,EAAEa,SAAyB,EAAED,CAAS;;YAM9GE,WAWAC;;YAhBN,IAAI,CAACC,OAAOC,QAAQ,CAACL,MAAM,CAACI,OAAOE,SAAS,CAACN,MAAMA,KAAK,GAAG;gBACzD,MAAM,IAAIO,oBAAU,CAAC,yBAAyB,AAAC,6DAAsE,OAAVC,OAAOR;YACpH;YACA,yFAAyF;YACzF,8EAA8E;YACxEE,YAAYO,IAAAA,sBAAa,EAACb,KAAKK;YACrC,IAAI,CAACS,IAAAA,qBAAY,EAACd,MAAM;gBACtB,MAAM,IAAIW,oBAAU,CAAC,kBAAkB;YACzC;YACA,0FAA0F;YAC1F,2FAA2F;YAC3F,IAAIL,UAAUS,OAAO,CAACC,OAAO,KAAKC,WAAW;gBAC3C,MAAM,IAAIN,oBAAU,CAAC,uBAAuB,AAAC,WAA+B,OAArBL,UAAUY,UAAU,EAAC;YAC9E;YACA,2FAA2F;YAC3F,0BAA0B;YACpBX,IAAIY,IAAAA,oBAAW,EAACnB,MAAM,iDAAiD;YAC7E,IAAIoB,IAAAA,0BAAiB,EAACb,IAAI;gBACxB,MAAM,IAAII,oBAAU,CAAC,uBAAuB,AAAC,8FAAoHU,OAAvBd,EAAEe,KAAK,EAAC,iBAA+B,OAAhBD,wBAAe,EAAC;YACnL;YAEA;;gBAAO9B,MAAMgC,WAAW,CAAC;;4BAGjBC,SAKA1B,MACA2B,UACAC,WACAC,SACAC;;;;oCAXN;;wCAAMC,IAAAA,+BAAmB,EAACtC,OAAOS;;;oCAAjC;oCACA,0FAA0F;oCACpFwB,UAAUX,IAAAA,sBAAa,EAACb,KAAKK;oCACnC,IAAImB,QAAQT,OAAO,CAACC,OAAO,KAAKC,WAAW;wCACzC,MAAM,IAAIN,oBAAU,CAAC,uBAAuB,AAAC,WAA6B,OAAnBa,QAAQN,UAAU,EAAC;oCAC5E;oCAEa;;wCAAM5B,mBAAmBC,OAAOC;;;oCAAvCM,OAAO;oCACa;;wCAAMP,MAAMG,OAAO,CAAC;;;oCAA3B;;wCAAO,cAAwGC,GAAG,CAACG;;;oCAAhI2B,WAAW,AAAE,cAAqJ7B,GAAG,CAAC,SAACkC;+CAAMA,EAAEC,GAAG;;oCAC7J;;wCAAMxC,MAAMG,OAAO,CAAC;;;oCAA3B;;wCAAO,cAAoFC,GAAG,CAACG;;;oCAA7G4B,YAAY,AAAE,cAAiI9B,GAAG,CAAC,SAACkC;+CAAMA,EAAEE,GAAG;;oCAC/JL,UAAU,IAAIM,IAAI;wCAACnC;sCAAD,OAAO,qBAAG2B,WAAU,qBAAGC;oCAC/B;;wCAAMQ,IAAAA,oBAAW,EAAC3C,OAAOS,KAAKK;;;oCAAxCuB,UAAU;oCAChB,8FAA8F;oCAC9F,kFAAkF;oCAClF;;wCAAMO,IAAAA,iCAAwB,EAAC5C,OAAOS,KAAK,IAAIiC,IAAI,AAAC,qBAAGL;4CAAS9B;;;;oCAAhE;oCACM;;wCAAMsC,IAAAA,qBAAY,EAAC7C,OAAOO;;;oCAAhC,IAAI,CAAE,eAAkC;wCACtC,MAAM,IAAIa,oBAAU,CAAC,qBAAqB,AAAC,GAAO,OAALb,MAAK;oCACpD;oCACM;;wCAAMuC,IAAAA,2BAAkB,EAAC9C,OAAOS,KAAK4B;;;oCAA3C,IAAI,CAAE,eAAgD;;;;oCACtD;;wCAAOU,IAAAA,oCAA2B,EAAC/C,OAAOqC,SAAS;mDAAMW,IAAAA,qBAAY,EAAChD,OAAOS,KAAKF,MAAM;gDAAE6B,SAAAA;gDAASC,SAAAA;gDAASxB,GAAAA;4CAAE;;;;;oBAChH;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/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.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';\nimport { NATIVE_VECTOR_SCOPE_TABLE, reserveNativeVectorScope } from '../store/vectors.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\n// Native vector adapters can consume a small exact scope through their connection-local temp\n// table. The reservation is tied to this Store's VectorStore wrapper, so another Store cannot\n// activate it by receiving the same Set object.\nexport async function withMaterializedVectorScope<T>(store: Store, allowed: Set<string>, callback: () => Promise<T>, knownTotal?: number): Promise<T> {\n  const reservation = reserveNativeVectorScope(store.vectors, allowed);\n  if (!reservation) return callback();\n\n  if (allowed.size === 0) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let total = knownTotal;\n  if (total === undefined) {\n    try {\n      const stmt = await store.prepare('SELECT COUNT(*) AS count FROM frontmatter');\n      const row = (await stmt.get()) as { count: number | bigint };\n      total = Number(row.count);\n    } catch (err) {\n      reservation.invalidate();\n      throw err;\n    }\n  }\n  // Materialization only buys work when this is a nonempty true narrowing and the allowed side\n  // is no larger than its complement. Direct adapter calls and broader scopes retain JS filtering.\n  if (allowed.size >= total || allowed.size > total - allowed.size) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let operationFailed = false;\n  let operationError: unknown;\n  let result!: T;\n  try {\n    await materializeScope(store, NATIVE_VECTOR_SCOPE_TABLE, allowed);\n    reservation.activate();\n    result = await callback();\n  } catch (err) {\n    operationFailed = true;\n    operationError = err;\n  }\n\n  let cleanupFailed = false;\n  let cleanupError: unknown;\n  try {\n    reservation.deactivate();\n    await store.exec(`DROP TABLE IF EXISTS ${NATIVE_VECTOR_SCOPE_TABLE}`);\n  } catch (err) {\n    cleanupFailed = true;\n    cleanupError = err;\n  } finally {\n    reservation.invalidate();\n  }\n\n  if (operationFailed && cleanupFailed) throw new AggregateError([operationError, cleanupError], 'native vector scope operation and cleanup failed');\n  if (operationFailed) throw operationError;\n  if (cleanupFailed) throw cleanupError;\n  return result;\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","withMaterializedVectorScope","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","allowed","callback","knownTotal","reservation","total","row","operationFailed","operationError","result","cleanupFailed","cleanupError","reserveNativeVectorScope","vectors","size","invalidate","get","Number","count","NATIVE_VECTOR_SCOPE_TABLE","activate","deactivate","AggregateError"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/open-source/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';\nimport { NATIVE_VECTOR_SCOPE_TABLE, reserveNativeVectorScope } from '../store/vectors.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\n// Native vector adapters can consume a small exact scope through their connection-local temp\n// table. The reservation is tied to this Store's VectorStore wrapper, so another Store cannot\n// activate it by receiving the same Set object.\nexport async function withMaterializedVectorScope<T>(store: Store, allowed: Set<string>, callback: () => Promise<T>, knownTotal?: number): Promise<T> {\n  const reservation = reserveNativeVectorScope(store.vectors, allowed);\n  if (!reservation) return callback();\n\n  if (allowed.size === 0) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let total = knownTotal;\n  if (total === undefined) {\n    try {\n      const stmt = await store.prepare('SELECT COUNT(*) AS count FROM frontmatter');\n      const row = (await stmt.get()) as { count: number | bigint };\n      total = Number(row.count);\n    } catch (err) {\n      reservation.invalidate();\n      throw err;\n    }\n  }\n  // Materialization only buys work when this is a nonempty true narrowing and the allowed side\n  // is no larger than its complement. Direct adapter calls and broader scopes retain JS filtering.\n  if (allowed.size >= total || allowed.size > total - allowed.size) {\n    reservation.invalidate();\n    return callback();\n  }\n\n  let operationFailed = false;\n  let operationError: unknown;\n  let result!: T;\n  try {\n    await materializeScope(store, NATIVE_VECTOR_SCOPE_TABLE, allowed);\n    reservation.activate();\n    result = await callback();\n  } catch (err) {\n    operationFailed = true;\n    operationError = err;\n  }\n\n  let cleanupFailed = false;\n  let cleanupError: unknown;\n  try {\n    reservation.deactivate();\n    await store.exec(`DROP TABLE IF EXISTS ${NATIVE_VECTOR_SCOPE_TABLE}`);\n  } catch (err) {\n    cleanupFailed = true;\n    cleanupError = err;\n  } finally {\n    reservation.invalidate();\n  }\n\n  if (operationFailed && cleanupFailed) throw new AggregateError([operationError, cleanupError], 'native vector scope operation and cleanup failed');\n  if (operationFailed) throw operationError;\n  if (cleanupFailed) throw cleanupError;\n  return result;\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","withMaterializedVectorScope","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","allowed","callback","knownTotal","reservation","total","row","operationFailed","operationError","result","cleanupFailed","cleanupError","reserveNativeVectorScope","vectors","size","invalidate","get","Number","count","NATIVE_VECTOR_SCOPE_TABLE","activate","deactivate","AggregateError"],"mappings":"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"}

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

@@ -1,7 +1,7 @@
 import type { ResolvedConfig } from '../config/index.js';
 import type { Store } from '../store/types.js';
-import type { SearchResultVia } from './signals.js';
-export type { SearchResultVia } from './signals.js';
+import type { SearchResultVia, SearchSignalContribution } from './signals.js';
+export type { SearchResultVia, SearchSignalContribution } from './signals.js';
 export declare const SNIPPET_CHAR_LIMIT_DEFAULT = 80;
 export declare const SNIPPET_COUNT_LIMIT_DEFAULT = 1;
 export declare function computeSnippets(text: string, terms: string[], charLimit: number, countLimit: number): {
@@ -12,6 +12,8 @@ export declare function lineNumberAt(text: string, offset: number): number;
 /** Options for the root {@link search} API. */
 export interface SearchOptions {
     k?: number;
+    /** Collects ranking contributions for returned candidates; omitted or false preserves ordinary output. */
+    explain?: boolean;
     where?: string;
     preset?: string;
     include?: string[];
@@ -31,6 +33,8 @@ export type SearchResult = {
     score: number;
     lines: string | null;
     similarity?: number | null;
+    /** Present only with explain: true, in words/links/vectors order; contributions can differ from via labels. */
+    explanation?: SearchSignalContribution[];
 };
 export interface SearchHydrationRow {
     path: string;

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

@@ -1,7 +1,7 @@
 import type { ResolvedConfig } from '../config/index.js';
 import type { Store } from '../store/types.js';
-import type { SearchResultVia } from './signals.js';
-export type { SearchResultVia } from './signals.js';
+import type { SearchResultVia, SearchSignalContribution } from './signals.js';
+export type { SearchResultVia, SearchSignalContribution } from './signals.js';
 export declare const SNIPPET_CHAR_LIMIT_DEFAULT = 80;
 export declare const SNIPPET_COUNT_LIMIT_DEFAULT = 1;
 export declare function computeSnippets(text: string, terms: string[], charLimit: number, countLimit: number): {
@@ -12,6 +12,8 @@ export declare function lineNumberAt(text: string, offset: number): number;
 /** Options for the root {@link search} API. */
 export interface SearchOptions {
     k?: number;
+    /** Collects ranking contributions for returned candidates; omitted or false preserves ordinary output. */
+    explain?: boolean;
     where?: string;
     preset?: string;
     include?: string[];
@@ -31,6 +33,8 @@ export type SearchResult = {
     score: number;
     lines: string | null;
     similarity?: number | null;
+    /** Present only with explain: true, in words/links/vectors order; contributions can differ from via labels. */
+    explanation?: SearchSignalContribution[];
 };
 export interface SearchHydrationRow {
     path: string;