sensemaking 0.24.7 → 0.25.1

package/dist/cjs/watch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/watch.ts"],"sourcesContent":["import { watch as fsWatch } from 'node:fs';\nimport type { ResolvedConfig } from './config/index.ts';\nimport { SenseError } from './errors.ts';\nimport { guardedTick } from './lib/guarded-tick.ts';\nimport { shouldReconcileWatchNotification } from './lib/watch-notification.ts';\nimport { docCount, openStore } from './store/index.ts';\nimport { startWatchClaim, WATCH_HEARTBEAT_INTERVAL_MS } from './watch-claim.ts';\n\n// Watch is a cache pre-warmer, not a correctness mechanism: open() always reconciles anyway, so any fs event just triggers a debounced full reconcile.\nconst DEBOUNCE_MS = 200;\n\nexport type WatchEvent = { type: 'started'; rootDir: string; dbPath: string } | { type: 'reconciled'; parsed: number; total: number; warnings: string[] } | { type: 'reconcile-error'; message: string };\n\nexport interface WatchOptions {\n  force?: boolean;\n  onEvent?: (event: WatchEvent) => void;\n  // Aborting runs the same shutdown path as SIGINT/SIGTERM.\n  signal?: AbortSignal;\n  debounceMs?: number;\n  heartbeatIntervalMs?: number;\n}\n\n// Runs in the foreground until SIGINT/SIGTERM/signal abort. DuckDB and Turso hand the cache file to\n// one process at a time, so every reconcile cycle opens and closes instead of holding an idle lock.\nexport async function runWatch(cfg: ResolvedConfig, opts: WatchOptions = {}): Promise<void> {\n  const onEvent = opts.onEvent ?? (() => {});\n  const debounceMs = opts.debounceMs ?? DEBOUNCE_MS;\n  const reconcileIntervalMs = opts.heartbeatIntervalMs ?? WATCH_HEARTBEAT_INTERVAL_MS;\n  if (!Number.isFinite(reconcileIntervalMs) || reconcileIntervalMs <= 0) throw new SenseError('CONFIG_INVALID', 'watch heartbeatIntervalMs must be a finite positive number');\n  // Reconciliation may be parked for a caller, but live ownership must renew before fixed expiry.\n  const claimIntervalMs = Math.min(reconcileIntervalMs, WATCH_HEARTBEAT_INTERVAL_MS);\n  const rootDir = cfg.rootDir ?? cfg.baseDir;\n  const configDir = cfg.configDir ?? rootDir;\n  let claimFailure: Error | null = null;\n  let requestShutdown: ((reason: Error) => void) | undefined;\n  const claim = await startWatchClaim(configDir, opts.force ?? false, claimIntervalMs, (err) => {\n    claimFailure ??= err;\n    requestShutdown?.(err);\n  });\n  let claimCloseStarted = false;\n  const closeClaim = (): Promise<void> => {\n    claimCloseStarted = true;\n    return claim.close();\n  };\n  try {\n    const { store: initialStore, dbPath, warnings: initialWarnings, parsed: initialParsed } = await openStore(cfg);\n    let initialTotal = 0;\n    try {\n      // total is read before close: an event fires only once nothing is held open again.\n      initialTotal = initialWarnings.length > 0 || initialParsed > 0 ? await docCount(initialStore) : 0;\n    } finally {\n      await initialStore.close();\n    }\n    if (claimFailure) throw claimFailure;\n\n    let stopping = false;\n    // At most one open+reconcile+close cycle runs at a time; a trigger that arrives mid-cycle is\n    // coalesced into a single rerun instead of opening a second, overlapping connection.\n    let running: Promise<void> | null = null;\n    let queuedAlways: boolean | null = null;\n\n    const tick = async (alwaysEmit: boolean): Promise<void> => {\n      try {\n        const { store, parsed, warnings } = await openStore(cfg);\n        try {\n          if (alwaysEmit || parsed > 0 || warnings.length > 0) {\n            onEvent({ type: 'reconciled', parsed, total: await docCount(store), warnings });\n          }\n        } finally {\n          await store.close();\n        }\n      } catch (err) {\n        onEvent({ type: 'reconcile-error', message: (err as Error).message });\n      }\n    };\n\n    const startCycle = (alwaysEmit: boolean) => {\n      running = tick(alwaysEmit).then(() => {\n        running = null;\n        if (queuedAlways !== null && !stopping) {\n          const again = queuedAlways;\n          queuedAlways = null;\n          startCycle(again);\n        }\n      });\n    };\n\n    const requestCycle = (alwaysEmit: boolean) => {\n      if (stopping) return;\n      if (running) {\n        queuedAlways = queuedAlways || alwaysEmit;\n        return;\n      }\n      startCycle(alwaysEmit);\n    };\n\n    let debounceTimer: NodeJS.Timeout | null = null;\n    const scheduleReconcile = () => {\n      if (debounceTimer) clearTimeout(debounceTimer);\n      debounceTimer = setTimeout(() => {\n        debounceTimer = null;\n        requestCycle(true);\n      }, debounceMs);\n    };\n\n    // Ignore our own state files, or cache and claim writes would retrigger reconciliation forever.\n    // An unresolvable filename reconciles because parsing nothing costs less than missing a real edit.\n    const watcher = fsWatch(rootDir, { recursive: true }, (_event, filename) => {\n      if (!shouldReconcileWatchNotification(filename)) return;\n      scheduleReconcile();\n    });\n    const reconcileTimer = setInterval(\n      guardedTick(\n        async () => requestCycle(false),\n        () => stopping\n      ),\n      reconcileIntervalMs\n    );\n\n    return await new Promise<void>((resolveShutdown, rejectShutdown) => {\n      let shutdownReason: Error | null = null;\n      const shutdown = (reason?: Error) => {\n        shutdownReason ??= reason ?? null;\n        if (stopping) return;\n        stopping = true;\n        const shutdownTask = (async () => {\n          process.off('SIGINT', stopNormally);\n          process.off('SIGTERM', stopNormally);\n          opts.signal?.removeEventListener('abort', stopNormally);\n          clearInterval(reconcileTimer);\n          if (debounceTimer) clearTimeout(debounceTimer);\n          watcher.close();\n          await running;\n          let finalError: unknown;\n          try {\n            // A normal stop performs one final freshness pass. Ownership loss drains existing work\n            // but starts nothing new because the replacement watcher now owns that responsibility.\n            if (!shutdownReason) {\n              const { store: finalStore } = await openStore(cfg);\n              await finalStore.close();\n            }\n          } catch (err) {\n            finalError = err;\n          }\n          try {\n            await closeClaim();\n          } catch (err) {\n            if (finalError) throw new AggregateError([finalError, err], 'watch shutdown and claim cleanup both failed');\n            throw err;\n          }\n          if (finalError) throw finalError;\n          if (shutdownReason) throw shutdownReason;\n        })();\n        shutdownTask.then(resolveShutdown, rejectShutdown);\n      };\n      const stopNormally = () => shutdown();\n      requestShutdown = shutdown;\n      process.once('SIGINT', stopNormally);\n      process.once('SIGTERM', stopNormally);\n      if (claimFailure) shutdown(claimFailure);\n      else if (opts.signal?.aborted) shutdown();\n      else {\n        opts.signal?.addEventListener('abort', stopNormally, { once: true });\n        try {\n          onEvent({ type: 'started', rootDir, dbPath });\n          if (!stopping && (initialWarnings.length > 0 || initialParsed > 0)) {\n            onEvent({ type: 'reconciled', parsed: initialParsed, total: initialTotal, warnings: initialWarnings });\n          }\n        } catch (err) {\n          shutdown(err instanceof Error ? err : new Error(String(err)));\n        }\n      }\n    });\n  } catch (err) {\n    if (claimCloseStarted) throw err;\n    try {\n      await closeClaim();\n    } catch (closeError) {\n      throw new AggregateError([err, closeError], 'watch setup and claim cleanup both failed');\n    }\n    throw err;\n  } finally {\n    requestShutdown = undefined;\n  }\n}\n"],"names":["runWatch","DEBOUNCE_MS","cfg","opts","onEvent","debounceMs","reconcileIntervalMs","claimIntervalMs","rootDir","configDir","claimFailure","requestShutdown","claim","claimCloseStarted","closeClaim","initialStore","dbPath","initialWarnings","initialParsed","initialTotal","stopping","running","queuedAlways","tick","startCycle","requestCycle","debounceTimer","scheduleReconcile","watcher","reconcileTimer","err","closeError","heartbeatIntervalMs","WATCH_HEARTBEAT_INTERVAL_MS","Number","isFinite","SenseError","Math","min","baseDir","startWatchClaim","force","close","openStore","store","warnings","parsed","length","docCount","alwaysEmit","type","total","message","then","again","clearTimeout","setTimeout","fsWatch","recursive","_event","filename","shouldReconcileWatchNotification","setInterval","guardedTick","Promise","resolveShutdown","rejectShutdown","shutdownReason","shutdown","reason","shutdownTask","finalError","finalStore","process","off","stopNormally","signal","removeEventListener","clearInterval","AggregateError","once","aborted","addEventListener","Error","String","undefined"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/watch.ts"],"sourcesContent":["import { watch as fsWatch } from 'node:fs';\nimport type { ResolvedConfig } from './config/index.ts';\nimport { SenseError } from './errors.ts';\nimport { guardedTick } from './lib/guarded-tick.ts';\nimport { shouldReconcileWatchNotification } from './lib/watch-notification.ts';\nimport { docCount, openStore } from './store/index.ts';\nimport { startWatchClaim, WATCH_HEARTBEAT_INTERVAL_MS } from './watch-claim.ts';\n\n// Watch prepares the index for snapshot queries; filesystem events request debounced builds\n// and periodic reconciliation recovers missed notifications.\nconst DEBOUNCE_MS = 200;\n\nexport type WatchEvent = { type: 'started'; rootDir: string; dbPath: string } | { type: 'reconciled'; parsed: number; total: number; warnings: string[] } | { type: 'reconcile-error'; message: string };\n\nexport interface WatchOptions {\n  force?: boolean;\n  onEvent?: (event: WatchEvent) => void;\n  // Aborting runs the same shutdown path as SIGINT/SIGTERM.\n  signal?: AbortSignal;\n  debounceMs?: number;\n  heartbeatIntervalMs?: number;\n}\n\n// Runs in the foreground until SIGINT/SIGTERM/signal abort. DuckDB and Turso hand the cache file to\n// one process at a time, so every reconcile cycle opens and closes instead of holding an idle lock.\nexport async function runWatch(cfg: ResolvedConfig, opts: WatchOptions = {}): Promise<void> {\n  const onEvent = opts.onEvent ?? (() => {});\n  const debounceMs = opts.debounceMs ?? DEBOUNCE_MS;\n  const reconcileIntervalMs = opts.heartbeatIntervalMs ?? WATCH_HEARTBEAT_INTERVAL_MS;\n  if (!Number.isFinite(reconcileIntervalMs) || reconcileIntervalMs <= 0) throw new SenseError('CONFIG_INVALID', 'watch heartbeatIntervalMs must be a finite positive number');\n  // Reconciliation may be parked for a caller, but live ownership must renew before fixed expiry.\n  const claimIntervalMs = Math.min(reconcileIntervalMs, WATCH_HEARTBEAT_INTERVAL_MS);\n  const rootDir = cfg.rootDir ?? cfg.baseDir;\n  const configDir = cfg.configDir ?? rootDir;\n  let claimFailure: Error | null = null;\n  let requestShutdown: ((reason: Error) => void) | undefined;\n  const claim = await startWatchClaim(configDir, opts.force ?? false, claimIntervalMs, (err) => {\n    claimFailure ??= err;\n    requestShutdown?.(err);\n  });\n  let claimCloseStarted = false;\n  const closeClaim = (): Promise<void> => {\n    claimCloseStarted = true;\n    return claim.close();\n  };\n  let watcher: ReturnType<typeof fsWatch> | undefined;\n  let startup = true;\n  let startupNotification = false;\n  let scheduleReconcile: (() => void) | undefined;\n  let stopping = false;\n  try {\n    // Subscribe before the first build. Native watchers have no ready barrier, so startup also\n    // performs an unconditional catch-up pass after the initial build.\n    watcher = fsWatch(rootDir, { recursive: true }, (_event, filename) => {\n      if (!shouldReconcileWatchNotification(filename)) return;\n      if (startup) startupNotification = true;\n      else scheduleReconcile?.();\n    });\n    watcher.on('error', (err) => {\n      claimFailure ??= err;\n      requestShutdown?.(err);\n    });\n\n    const startupEvents: Array<{ parsed: number; total: number; warnings: string[] }> = [];\n    const { store: initialStore, dbPath, warnings: initialWarnings, parsed: initialParsed } = await openStore(cfg);\n    let initialTotal = 0;\n    try {\n      // total is read before close: an event fires only once nothing is held open again.\n      initialTotal = initialWarnings.length > 0 || initialParsed > 0 ? await docCount(initialStore) : 0;\n    } finally {\n      await initialStore.close();\n    }\n    if (claimFailure) throw claimFailure;\n\n    startupEvents.push({ parsed: initialParsed, total: initialTotal, warnings: initialWarnings });\n    // Always reopen once after subscribing, then drain notifications observed while startup was\n    // in progress. Each pass closes before the next one starts, so no stores overlap.\n    do {\n      startupNotification = false;\n      const { store, parsed, warnings } = await openStore(cfg);\n      try {\n        if (parsed > 0 || warnings.length > 0) startupEvents.push({ parsed, total: await docCount(store), warnings });\n      } finally {\n        await store.close();\n      }\n      if (claimFailure) throw claimFailure;\n    } while (startupNotification && !opts.signal?.aborted);\n    startup = false;\n\n    // At most one open+reconcile+close cycle runs at a time; a trigger that arrives mid-cycle is\n    // coalesced into a single rerun instead of opening a second, overlapping connection.\n    let running: Promise<void> | null = null;\n    let queuedAlways: boolean | null = null;\n\n    const tick = async (alwaysEmit: boolean): Promise<void> => {\n      try {\n        const { store, parsed, warnings } = await openStore(cfg);\n        try {\n          if (alwaysEmit || parsed > 0 || warnings.length > 0) {\n            onEvent({ type: 'reconciled', parsed, total: await docCount(store), warnings });\n          }\n        } finally {\n          await store.close();\n        }\n      } catch (err) {\n        onEvent({ type: 'reconcile-error', message: (err as Error).message });\n      }\n    };\n\n    const startCycle = (alwaysEmit: boolean) => {\n      running = tick(alwaysEmit).then(() => {\n        running = null;\n        if (queuedAlways !== null && !stopping) {\n          const again = queuedAlways;\n          queuedAlways = null;\n          startCycle(again);\n        }\n      });\n    };\n\n    const requestCycle = (alwaysEmit: boolean) => {\n      if (stopping) return;\n      if (running) {\n        queuedAlways = queuedAlways || alwaysEmit;\n        return;\n      }\n      startCycle(alwaysEmit);\n    };\n\n    let debounceTimer: NodeJS.Timeout | null = null;\n    // Ignore our own state files, or cache and claim writes would retrigger reconciliation forever.\n    // An unresolvable filename reconciles because parsing nothing costs less than missing a real edit.\n    scheduleReconcile = () => {\n      if (debounceTimer) clearTimeout(debounceTimer);\n      debounceTimer = setTimeout(() => {\n        debounceTimer = null;\n        requestCycle(true);\n      }, debounceMs);\n    };\n    const reconcileTimer = setInterval(\n      guardedTick(\n        async () => requestCycle(false),\n        () => stopping\n      ),\n      reconcileIntervalMs\n    );\n\n    return await new Promise<void>((resolveShutdown, rejectShutdown) => {\n      let shutdownReason: Error | null = null;\n      const shutdown = (reason?: Error) => {\n        shutdownReason ??= reason ?? null;\n        if (stopping) return;\n        stopping = true;\n        const shutdownTask = (async () => {\n          process.off('SIGINT', stopNormally);\n          process.off('SIGTERM', stopNormally);\n          opts.signal?.removeEventListener('abort', stopNormally);\n          clearInterval(reconcileTimer);\n          if (debounceTimer) clearTimeout(debounceTimer);\n          watcher?.close();\n          await running;\n          let finalError: unknown;\n          try {\n            // A normal stop performs one final freshness pass. Ownership loss drains existing work\n            // but starts nothing new because the replacement watcher now owns that responsibility.\n            if (!shutdownReason) {\n              const { store: finalStore } = await openStore(cfg);\n              await finalStore.close();\n            }\n          } catch (err) {\n            finalError = err;\n          }\n          try {\n            await closeClaim();\n          } catch (err) {\n            if (finalError) throw new AggregateError([finalError, err], 'watch shutdown and claim cleanup both failed');\n            throw err;\n          }\n          if (finalError) throw finalError;\n          if (shutdownReason) throw shutdownReason;\n        })();\n        shutdownTask.then(resolveShutdown, rejectShutdown);\n      };\n      const stopNormally = () => shutdown();\n      requestShutdown = shutdown;\n      process.once('SIGINT', stopNormally);\n      process.once('SIGTERM', stopNormally);\n      if (claimFailure) shutdown(claimFailure);\n      else if (opts.signal?.aborted) shutdown();\n      else {\n        opts.signal?.addEventListener('abort', stopNormally, { once: true });\n        try {\n          onEvent({ type: 'started', rootDir, dbPath });\n          if (!stopping) {\n            for (const event of startupEvents) {\n              if (stopping) break;\n              if (event.warnings.length > 0 || event.parsed > 0) onEvent({ type: 'reconciled', ...event });\n            }\n          }\n        } catch (err) {\n          shutdown(err instanceof Error ? err : new Error(String(err)));\n        }\n      }\n    });\n  } catch (err) {\n    watcher?.close();\n    if (claimCloseStarted) throw err;\n    try {\n      await closeClaim();\n    } catch (closeError) {\n      throw new AggregateError([err, closeError], 'watch setup and claim cleanup both failed');\n    }\n    throw err;\n  } finally {\n    requestShutdown = undefined;\n  }\n}\n"],"names":["runWatch","DEBOUNCE_MS","cfg","opts","onEvent","debounceMs","reconcileIntervalMs","claimIntervalMs","rootDir","configDir","claimFailure","requestShutdown","claim","claimCloseStarted","closeClaim","watcher","startup","startupNotification","scheduleReconcile","stopping","startupEvents","initialStore","dbPath","initialWarnings","initialParsed","initialTotal","store","parsed","warnings","running","queuedAlways","tick","startCycle","requestCycle","debounceTimer","reconcileTimer","err","closeError","heartbeatIntervalMs","WATCH_HEARTBEAT_INTERVAL_MS","Number","isFinite","SenseError","Math","min","baseDir","startWatchClaim","force","close","fsWatch","recursive","_event","filename","shouldReconcileWatchNotification","on","openStore","length","docCount","push","total","signal","aborted","alwaysEmit","type","message","then","again","clearTimeout","setTimeout","setInterval","guardedTick","Promise","resolveShutdown","rejectShutdown","shutdownReason","shutdown","reason","shutdownTask","finalError","finalStore","process","off","stopNormally","removeEventListener","clearInterval","AggregateError","once","addEventListener","event","Error","String","undefined"],"mappings":"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"}

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

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

package/dist/esm/cli/build.js

@@ -0,0 +1,18 @@
+import { buildIndex } from '../store/index.js';
+import { USAGE } from './index.js';
+import { CONFIG, parse, printWarnings } from './shared.js';
+const build = async (ctx)=>{
+    const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.build}`, {
+        force: {
+            type: 'boolean',
+            default: false
+        },
+        ...CONFIG
+    });
+    const result = await buildIndex(ctx.resolveConfig(values.config), {
+        force: values.force === true
+    });
+    printWarnings(result.warnings);
+    console.log(`${ctx.name} build: ${result.parsed} file(s) parsed; index ready at ${result.dbPath}`);
+};
+export default build;

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/build.ts"],"sourcesContent":["import { buildIndex } from '../store/index.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, parse, printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst build: Command = async (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.build}`, { force: { type: 'boolean', default: false }, ...CONFIG });\n  const result = await buildIndex(ctx.resolveConfig(values.config as string | undefined), { force: values.force === true });\n  printWarnings(result.warnings);\n  console.log(`${ctx.name} build: ${result.parsed} file(s) parsed; index ready at ${result.dbPath}`);\n};\n\nexport default build;\n"],"names":["buildIndex","USAGE","CONFIG","parse","printWarnings","build","ctx","values","argv","name","force","type","default","result","resolveConfig","config","warnings","console","log","parsed","dbPath"],"mappings":"AAAA,SAASA,UAAU,QAAQ,oBAAoB;AAC/C,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,KAAK,EAAEC,aAAa,QAAQ,cAAc;AAG3D,MAAMC,QAAiB,OAAOC;IAC5B,MAAM,EAAEC,MAAM,EAAE,GAAGJ,MAAMG,IAAIE,IAAI,EAAE,CAAC,OAAO,EAAEF,IAAIG,IAAI,CAAC,CAAC,EAAER,MAAMI,KAAK,EAAE,EAAE;QAAEK,OAAO;YAAEC,MAAM;YAAWC,SAAS;QAAM;QAAG,GAAGV,MAAM;IAAC;IAChI,MAAMW,SAAS,MAAMb,WAAWM,IAAIQ,aAAa,CAACP,OAAOQ,MAAM,GAAyB;QAAEL,OAAOH,OAAOG,KAAK,KAAK;IAAK;IACvHN,cAAcS,OAAOG,QAAQ;IAC7BC,QAAQC,GAAG,CAAC,GAAGZ,IAAIG,IAAI,CAAC,QAAQ,EAAEI,OAAOM,MAAM,CAAC,gCAAgC,EAAEN,OAAOO,MAAM,EAAE;AACnG;AAEA,eAAef,MAAM"}

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

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

package/dist/esm/cli/index.js

@@ -2,20 +2,22 @@
 // usage() and the command's own parse() error/--help output so there is one copy, not two.
 export const USAGE = {
     init: 'init [--model id-or-path] [--provider static|openai|cohere] [--url url]',
+    build: 'build [--force] [--config path]',
     watch: 'watch [--force] [--config path]',
     status: 'status [--format table|json] [--config path]',
     download: 'download [--config path]',
-    sql: 'sql "<statement>" [params...] [--preset name] [--format table|json|csv] [--config path]',
-    search: 'search "<terms>" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--format table|json|csv] [--config path]',
-    map: 'map [--format table|json] [--config path]',
-    peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--format table|json] [--config path]',
-    path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--max-depth n] [--format table|json] [--config path]',
-    related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--format table|json|csv] [--config path]'
+    sql: 'sql "<statement>" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]',
+    search: 'search "<terms>" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]',
+    map: 'map [--no-build] [--format table|json] [--config path]',
+    peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--no-build] [--format table|json] [--config path]',
+    path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--max-depth n] [--no-build] [--format table|json] [--config path]',
+    related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where "<sql>"] [--k n] [--no-build] [--format table|json|csv] [--config path]'
 };
 // Lazy registry: a command's imports load only when it runs, so a heavy dependency in one
 // command never taxes the others (or --version/--help). These names are reserved from saved queries.
 export const COMMANDS = {
     init: ()=>import('./init.js'),
+    build: ()=>import('./build.js'),
     watch: ()=>import('./watch.js'),
     status: ()=>import('./status.js'),
     download: ()=>import('./download.js'),

package/dist/esm/cli/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/index.ts"],"sourcesContent":["import type { Command } from './types.ts';\n\n// Each command's usage line, minus the leading \"usage: <name> \": shared by cli.ts's\n// usage() and the command's own parse() error/--help output so there is one copy, not two.\nexport const USAGE = {\n  init: 'init [--model id-or-path] [--provider static|openai|cohere] [--url url]',\n  watch: 'watch [--force] [--config path]',\n  status: 'status [--format table|json] [--config path]',\n  download: 'download [--config path]',\n  sql: 'sql \"<statement>\" [params...] [--preset name] [--format table|json|csv] [--config path]',\n  search: 'search \"<terms>\" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--format table|json|csv] [--config path]',\n  map: 'map [--format table|json] [--config path]',\n  peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--format table|json] [--config path]',\n  path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--format table|json] [--config path]',\n  related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--format table|json|csv] [--config path]',\n} as const;\n\n// Lazy registry: a command's imports load only when it runs, so a heavy dependency in one\n// command never taxes the others (or --version/--help). These names are reserved from saved queries.\nexport const COMMANDS: Record<string, () => Promise<{ default: Command }>> = {\n  init: () => import('./init.ts'),\n  watch: () => import('./watch.ts'),\n  status: () => import('./status.ts'),\n  download: () => import('./download.ts'),\n  sql: () => import('./sql.ts'),\n  search: () => import('./search.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n  path: () => import('./path.ts'),\n  related: () => import('./related.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["USAGE","init","watch","status","download","sql","search","map","peek","path","related","COMMANDS"],"mappings":"AAEA,oFAAoF;AACpF,2FAA2F;AAC3F,OAAO,MAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,QAAQ;IACRC,UAAU;IACVC,KAAK;IACLC,QAAQ;IACRC,KAAK;IACLC,MAAM;IACNC,MAAM;IACNC,SAAS;AACX,EAAW;AAEX,0FAA0F;AAC1F,qGAAqG;AACrG,OAAO,MAAMC,WAAgE;IAC3EV,MAAM,IAAM,MAAM,CAAC;IACnBC,OAAO,IAAM,MAAM,CAAC;IACpBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,UAAU,IAAM,MAAM,CAAC;IACvBC,KAAK,IAAM,MAAM,CAAC;IAClBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,KAAK,IAAM,MAAM,CAAC;IAClBC,MAAM,IAAM,MAAM,CAAC;IACnBC,MAAM,IAAM,MAAM,CAAC;IACnBC,SAAS,IAAM,MAAM,CAAC;AACxB,EAAE"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/index.ts"],"sourcesContent":["import type { Command } from './types.ts';\n\n// Each command's usage line, minus the leading \"usage: <name> \": shared by cli.ts's\n// usage() and the command's own parse() error/--help output so there is one copy, not two.\nexport const USAGE = {\n  init: 'init [--model id-or-path] [--provider static|openai|cohere] [--url url]',\n  build: 'build [--force] [--config path]',\n  watch: 'watch [--force] [--config path]',\n  status: 'status [--format table|json] [--config path]',\n  download: 'download [--config path]',\n  sql: 'sql \"<statement>\" [params...] [--preset name] [--no-build] [--format table|json|csv] [--config path]',\n  search: 'search \"<terms>\" [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--no-build] [--format table|json|csv] [--config path]',\n  map: 'map [--no-build] [--format table|json] [--config path]',\n  peek: 'peek <path> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--no-build] [--format table|json] [--config path]',\n  path: 'path <a> <b> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--max-depth n] [--no-build] [--format table|json] [--config path]',\n  related: 'related <note> [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--where \"<sql>\"] [--k n] [--no-build] [--format table|json|csv] [--config path]',\n} as const;\n\n// Lazy registry: a command's imports load only when it runs, so a heavy dependency in one\n// command never taxes the others (or --version/--help). These names are reserved from saved queries.\nexport const COMMANDS: Record<string, () => Promise<{ default: Command }>> = {\n  init: () => import('./init.ts'),\n  build: () => import('./build.ts'),\n  watch: () => import('./watch.ts'),\n  status: () => import('./status.ts'),\n  download: () => import('./download.ts'),\n  sql: () => import('./sql.ts'),\n  search: () => import('./search.ts'),\n  map: () => import('./map.ts'),\n  peek: () => import('./peek.ts'),\n  path: () => import('./path.ts'),\n  related: () => import('./related.ts'),\n};\n\nexport type { Command, Ctx } from './types.ts';\n"],"names":["USAGE","init","build","watch","status","download","sql","search","map","peek","path","related","COMMANDS"],"mappings":"AAEA,oFAAoF;AACpF,2FAA2F;AAC3F,OAAO,MAAMA,QAAQ;IACnBC,MAAM;IACNC,OAAO;IACPC,OAAO;IACPC,QAAQ;IACRC,UAAU;IACVC,KAAK;IACLC,QAAQ;IACRC,KAAK;IACLC,MAAM;IACNC,MAAM;IACNC,SAAS;AACX,EAAW;AAEX,0FAA0F;AAC1F,qGAAqG;AACrG,OAAO,MAAMC,WAAgE;IAC3EX,MAAM,IAAM,MAAM,CAAC;IACnBC,OAAO,IAAM,MAAM,CAAC;IACpBC,OAAO,IAAM,MAAM,CAAC;IACpBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,UAAU,IAAM,MAAM,CAAC;IACvBC,KAAK,IAAM,MAAM,CAAC;IAClBC,QAAQ,IAAM,MAAM,CAAC;IACrBC,KAAK,IAAM,MAAM,CAAC;IAClBC,MAAM,IAAM,MAAM,CAAC;IACnBC,MAAM,IAAM,MAAM,CAAC;IACnBC,SAAS,IAAM,MAAM,CAAC;AACxB,EAAE"}

package/dist/esm/cli/init.js

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

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/init.ts"],"sourcesContent":["import { DEFAULT_EMBED_MODEL, initConfig } from '../config/index.ts';\nimport { USAGE } from './index.ts';\nimport { parse } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst init: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.init}`, {\n    model: { type: 'string' },\n    provider: { type: 'string' },\n    url: { type: 'string' },\n  });\n  const modelFlag = values.model as string | undefined;\n  const providerFlag = values.provider as string | undefined;\n  const model = modelFlag ?? DEFAULT_EMBED_MODEL;\n  const provider = providerFlag ?? 'static';\n  const url = values.url as string | undefined;\n  // An invalid --provider throws here (validateConfig's own shape error), before anything is\n  // written -- one validator, not a second copy of its rules.\n  const configPath = initConfig(process.cwd(), { model: modelFlag, provider: providerFlag, url });\n  console.log(`created ${configPath}`);\n  console.log(`query away: ${ctx.name} sql \"SELECT path FROM frontmatter LIMIT 10\"`);\n  // Naming a model is consent to fetch it, so writing one into the config says so loudly,\n  // with the download consequence and the prefetch command, right where it was just written.\n  if (provider === 'static') {\n    console.log(`embed model: ${model} (static); nothing downloads until the first vector search -- ${ctx.name} download fetches it now instead`);\n  } else {\n    console.log(`embed model: ${model} (${provider}${url ? ` at ${url}` : ''}); reached over the network at search time, nothing to download`);\n  }\n  console.log('a non-English tree should pick a model for its languages: see the sense-setup skill or INTEGRATIONS.md');\n  // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not\n  // in this output; name both places that hold them, since an agent may have neither.\n  console.log('features and tree design: the sense-setup skill, or schema.json');\n};\nexport default init;\n"],"names":["DEFAULT_EMBED_MODEL","initConfig","USAGE","parse","init","ctx","values","argv","name","model","type","provider","url","modelFlag","providerFlag","configPath","process","cwd","console","log"],"mappings":"AAAA,SAASA,mBAAmB,EAAEC,UAAU,QAAQ,qBAAqB;AACrE,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,KAAK,QAAQ,cAAc;AAGpC,MAAMC,OAAgB,CAACC;IACrB,MAAM,EAAEC,MAAM,EAAE,GAAGH,MAAME,IAAIE,IAAI,EAAE,CAAC,OAAO,EAAEF,IAAIG,IAAI,CAAC,CAAC,EAAEN,MAAME,IAAI,EAAE,EAAE;QACrEK,OAAO;YAAEC,MAAM;QAAS;QACxBC,UAAU;YAAED,MAAM;QAAS;QAC3BE,KAAK;YAAEF,MAAM;QAAS;IACxB;IACA,MAAMG,YAAYP,OAAOG,KAAK;IAC9B,MAAMK,eAAeR,OAAOK,QAAQ;IACpC,MAAMF,QAAQI,sBAAAA,uBAAAA,YAAab;IAC3B,MAAMW,WAAWG,yBAAAA,0BAAAA,eAAgB;IACjC,MAAMF,MAAMN,OAAOM,GAAG;IACtB,2FAA2F;IAC3F,4DAA4D;IAC5D,MAAMG,aAAad,WAAWe,QAAQC,GAAG,IAAI;QAAER,OAAOI;QAAWF,UAAUG;QAAcF;IAAI;IAC7FM,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEJ,YAAY;IACnCG,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEd,IAAIG,IAAI,CAAC,4CAA4C,CAAC;IACjF,wFAAwF;IACxF,2FAA2F;IAC3F,IAAIG,aAAa,UAAU;QACzBO,QAAQC,GAAG,CAAC,CAAC,aAAa,EAAEV,MAAM,8DAA8D,EAAEJ,IAAIG,IAAI,CAAC,gCAAgC,CAAC;IAC9I,OAAO;QACLU,QAAQC,GAAG,CAAC,CAAC,aAAa,EAAEV,MAAM,EAAE,EAAEE,WAAWC,MAAM,CAAC,IAAI,EAAEA,KAAK,GAAG,GAAG,+DAA+D,CAAC;IAC3I;IACAM,QAAQC,GAAG,CAAC;IACZ,4FAA4F;IAC5F,oFAAoF;IACpFD,QAAQC,GAAG,CAAC;AACd;AACA,eAAef,KAAK"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/init.ts"],"sourcesContent":["import { DEFAULT_EMBED_MODEL, initConfig } from '../config/index.ts';\nimport { USAGE } from './index.ts';\nimport { parse } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst init: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.init}`, {\n    model: { type: 'string' },\n    provider: { type: 'string' },\n    url: { type: 'string' },\n  });\n  const modelFlag = values.model as string | undefined;\n  const providerFlag = values.provider as string | undefined;\n  const model = modelFlag ?? DEFAULT_EMBED_MODEL;\n  const provider = providerFlag ?? 'static';\n  const url = values.url as string | undefined;\n  // An invalid --provider throws here (validateConfig's own shape error), before anything is\n  // written -- one validator, not a second copy of its rules.\n  const configPath = initConfig(process.cwd(), { model: modelFlag, provider: providerFlag, url });\n  console.log(`created ${configPath}`);\n  console.log(`query away: ${ctx.name} sql \"SELECT path FROM frontmatter LIMIT 10\"`);\n  // Naming a model is consent to fetch it, so writing one into the config says so loudly,\n  // with the download consequence and the prefetch command, right where it was just written.\n  if (provider === 'static') {\n    console.log(`embed model: ${model} (static); ${ctx.name} build, watch, or a vector search downloads it when needed -- ${ctx.name} download fetches it now instead`);\n  } else {\n    console.log(`embed model: ${model} (${provider}${url ? ` at ${url}` : ''}); build, watch, and vector queries use the network, nothing to download`);\n  }\n  console.log('a non-English tree should pick a model for its languages: see the sense-setup skill or INTEGRATIONS.md');\n  // The decisions a new tree faces -- features, frontmatter conventions, note size -- are not\n  // in this output; name both places that hold them, since an agent may have neither.\n  console.log('features and tree design: the sense-setup skill, or schema.json');\n};\nexport default init;\n"],"names":["DEFAULT_EMBED_MODEL","initConfig","USAGE","parse","init","ctx","values","argv","name","model","type","provider","url","modelFlag","providerFlag","configPath","process","cwd","console","log"],"mappings":"AAAA,SAASA,mBAAmB,EAAEC,UAAU,QAAQ,qBAAqB;AACrE,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,KAAK,QAAQ,cAAc;AAGpC,MAAMC,OAAgB,CAACC;IACrB,MAAM,EAAEC,MAAM,EAAE,GAAGH,MAAME,IAAIE,IAAI,EAAE,CAAC,OAAO,EAAEF,IAAIG,IAAI,CAAC,CAAC,EAAEN,MAAME,IAAI,EAAE,EAAE;QACrEK,OAAO;YAAEC,MAAM;QAAS;QACxBC,UAAU;YAAED,MAAM;QAAS;QAC3BE,KAAK;YAAEF,MAAM;QAAS;IACxB;IACA,MAAMG,YAAYP,OAAOG,KAAK;IAC9B,MAAMK,eAAeR,OAAOK,QAAQ;IACpC,MAAMF,QAAQI,sBAAAA,uBAAAA,YAAab;IAC3B,MAAMW,WAAWG,yBAAAA,0BAAAA,eAAgB;IACjC,MAAMF,MAAMN,OAAOM,GAAG;IACtB,2FAA2F;IAC3F,4DAA4D;IAC5D,MAAMG,aAAad,WAAWe,QAAQC,GAAG,IAAI;QAAER,OAAOI;QAAWF,UAAUG;QAAcF;IAAI;IAC7FM,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEJ,YAAY;IACnCG,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAEd,IAAIG,IAAI,CAAC,4CAA4C,CAAC;IACjF,wFAAwF;IACxF,2FAA2F;IAC3F,IAAIG,aAAa,UAAU;QACzBO,QAAQC,GAAG,CAAC,CAAC,aAAa,EAAEV,MAAM,WAAW,EAAEJ,IAAIG,IAAI,CAAC,8DAA8D,EAAEH,IAAIG,IAAI,CAAC,gCAAgC,CAAC;IACpK,OAAO;QACLU,QAAQC,GAAG,CAAC,CAAC,aAAa,EAAEV,MAAM,EAAE,EAAEE,WAAWC,MAAM,CAAC,IAAI,EAAEA,KAAK,GAAG,GAAG,wEAAwE,CAAC;IACpJ;IACAM,QAAQC,GAAG,CAAC;IACZ,4FAA4F;IAC5F,oFAAoF;IACpFD,QAAQC,GAAG,CAAC;AACd;AACA,eAAef,KAAK"}

package/dist/esm/cli/map.js

@@ -1,15 +1,21 @@
 import { mapTree } from '../commands/map.js';
 import { renderMap, stringifyJson } from '../output/output.js';
 import { USAGE } from './index.js';
-import { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.js';
+import { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.js';
 const map = (ctx)=>{
     const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, {
         ...SCOPE,
+        ...NO_BUILD,
         ...FORMAT,
         ...CONFIG
     });
     const format = formatOf(values);
-    return withDb(ctx, values.config, async (store, cfg)=>{
+    return withDb(ctx, values.config, {
+        noBuild: values['no-build'] === true,
+        requirements: new Set([
+            'core'
+        ])
+    }, async (store, cfg)=>{
         const result = await mapTree(store, cfg, scopeOf(values));
         console.log(format === 'json' ? stringifyJson(result, 2) : renderMap(result));
     });

package/dist/esm/cli/map.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/map.ts"],"sourcesContent":["import { mapTree } from '../commands/map.ts';\nimport { renderMap, stringifyJson } from '../output/output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst map: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, { ...SCOPE, ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, async (store, cfg) => {\n    const result = await mapTree(store, cfg, scopeOf(values));\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderMap(result));\n  });\n};\nexport default map;\n"],"names":["mapTree","renderMap","stringifyJson","USAGE","CONFIG","FORMAT","formatOf","parse","SCOPE","scopeOf","withDb","map","ctx","values","argv","name","format","config","store","cfg","result","console","log"],"mappings":"AAAA,SAASA,OAAO,QAAQ,qBAAqB;AAC7C,SAASC,SAAS,EAAEC,aAAa,QAAQ,sBAAsB;AAC/D,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGtF,MAAMC,MAAe,CAACC;IACpB,MAAM,EAAEC,MAAM,EAAE,GAAGN,MAAMK,IAAIE,IAAI,EAAE,CAAC,OAAO,EAAEF,IAAIG,IAAI,CAAC,CAAC,EAAEZ,MAAMQ,GAAG,EAAE,EAAE;QAAE,GAAGH,KAAK;QAAE,GAAGH,MAAM;QAAE,GAAGD,MAAM;IAAC;IACvG,MAAMY,SAASV,SAASO;IACxB,OAAOH,OAAOE,KAAKC,OAAOI,MAAM,EAAwB,OAAOC,OAAOC;QACpE,MAAMC,SAAS,MAAMpB,QAAQkB,OAAOC,KAAKV,QAAQI;QACjDQ,QAAQC,GAAG,CAACN,WAAW,SAASd,cAAckB,QAAQ,KAAKnB,UAAUmB;IACvE;AACF;AACA,eAAeT,IAAI"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/map.ts"],"sourcesContent":["import { mapTree } from '../commands/map.ts';\nimport { renderMap, stringifyJson } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst map: Command = (ctx) => {\n  const { values } = parse(ctx.argv, `usage: ${ctx.name} ${USAGE.map}`, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const result = await mapTree(store, cfg, scopeOf(values));\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderMap(result));\n  });\n};\nexport default map;\n"],"names":["mapTree","renderMap","stringifyJson","USAGE","CONFIG","FORMAT","formatOf","NO_BUILD","parse","SCOPE","scopeOf","withDb","map","ctx","values","argv","name","format","config","noBuild","requirements","Set","store","cfg","result","console","log"],"mappings":"AAAA,SAASA,OAAO,QAAQ,qBAAqB;AAC7C,SAASC,SAAS,EAAEC,aAAa,QAAQ,sBAAsB;AAE/D,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGhG,MAAMC,MAAe,CAACC;IACpB,MAAM,EAAEC,MAAM,EAAE,GAAGN,MAAMK,IAAIE,IAAI,EAAE,CAAC,OAAO,EAAEF,IAAIG,IAAI,CAAC,CAAC,EAAEb,MAAMS,GAAG,EAAE,EAAE;QAAE,GAAGH,KAAK;QAAE,GAAGF,QAAQ;QAAE,GAAGF,MAAM;QAAE,GAAGD,MAAM;IAAC;IACpH,MAAMa,SAASX,SAASQ;IACxB,OAAOH,OAAOE,KAAKC,OAAOI,MAAM,EAAwB;QAAEC,SAASL,MAAM,CAAC,WAAW,KAAK;QAAMM,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,OAAOC,OAAOC;QACjK,MAAMC,SAAS,MAAMxB,QAAQsB,OAAOC,KAAKb,QAAQI;QACjDW,QAAQC,GAAG,CAACT,WAAW,SAASf,cAAcsB,QAAQ,KAAKvB,UAAUuB;IACvE;AACF;AACA,eAAeZ,IAAI"}

package/dist/esm/cli/named.js

@@ -1,19 +1,27 @@
+import { scopedPaths } from '../commands/scope.js';
 import { search } from '../commands/search.js';
+import { resolveSearch } from '../config/index.js';
 import { printRows } from '../output/output.js';
-import { CONFIG, FORMAT, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, runSql, SEARCH_FLAGS, withDb } from './shared.js';
+import { prepareDocumentEmbeddings } from '../store/open.js';
+import { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, runSql, SEARCH_FLAGS, withResolvedDb } from './shared.js';
 // Fallback when the first positional is not a command: a saved query, { sql } or { search }.
 // SEARCH_FLAGS override a saved search's fields the same way they override a preset's.
 export default async function named(ctx, queryName) {
     var _parseK, _values_where, _values_preset, _values_include, _values_exclude;
-    const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json|csv] [--config path] [--where "<sql>"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude]`;
+    const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json|csv] [--config path] [--where "<sql>"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--no-build]`;
     const { values, positionals: params } = parse(ctx.argv, usage, {
         ...SEARCH_FLAGS,
+        ...NO_BUILD,
         ...FORMAT,
         ...CONFIG
     });
     const format = rowFormatOf(values);
     const configPath = values.config;
-    const cfg = ctx.resolveConfig(configPath);
+    const noBuild = values['no-build'] === true;
+    const cfg = ctx.resolveConfig(configPath, {
+        writeMigration: !noBuild,
+        query: true
+    });
     const entry = cfg.queries[queryName];
     if (entry === undefined) {
         console.error(`unknown command or saved entry: "${queryName}"`);
@@ -23,7 +31,7 @@ export default async function named(ctx, queryName) {
     if ('sql' in entry) {
         // A saved statement written against `scope` is preset-agnostic, so the same entry can be
         // re-pointed at another layer from the command line instead of being copied per preset.
-        await runSql(cfg, entry.sql, params, format, `query "${queryName}"`, values.preset);
+        await runSql(cfg, entry.sql, params, format, `query "${queryName}"`, noBuild, values.preset);
         return;
     }
     // A saved search's text is fixed in config; there is nowhere for a positional to bind.
@@ -38,14 +46,30 @@ export default async function named(ctx, queryName) {
     const include = (_values_include = values.include) !== null && _values_include !== void 0 ? _values_include : entry.include;
     const exclude = (_values_exclude = values.exclude) !== null && _values_exclude !== void 0 ? _values_exclude : entry.exclude;
     const noExclude = values['no-exclude'] === true;
-    await withDb(ctx, configPath, async (store, resolvedCfg)=>printRows(await search(store, resolvedCfg, entry.search, {
-            k,
-            snippetCharLimit,
-            snippetCountLimit,
-            where,
-            preset,
-            include,
-            exclude,
-            noExclude
-        }), format));
+    const overrides = {
+        k,
+        snippetCharLimit,
+        snippetCountLimit,
+        where,
+        preset,
+        include,
+        exclude,
+        noExclude
+    };
+    await withResolvedDb(cfg, {
+        noBuild,
+        requirements: (resolvedCfg)=>{
+            const signals = resolveSearch(resolvedCfg, overrides).signals;
+            const requirements = new Set([
+                'core'
+            ]);
+            if (signals.words !== undefined) requirements.add('lexical');
+            return requirements;
+        }
+    }, async (store, resolvedCfg, build)=>{
+        if (build && resolveSearch(resolvedCfg, overrides).signals.vectors !== undefined) {
+            await prepareDocumentEmbeddings(store, resolvedCfg, await scopedPaths(store, resolvedCfg, overrides));
+        }
+        printRows(await search(store, resolvedCfg, entry.search, overrides), format);
+    });
 }

package/dist/esm/cli/named.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { search } from '../commands/search.ts';\nimport { printRows } from '../output/output.ts';\nimport { CONFIG, FORMAT, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, runSql, SEARCH_FLAGS, withDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a saved query, { sql } or { search }.\n// SEARCH_FLAGS override a saved search's fields the same way they override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json|csv] [--config path] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...FORMAT, ...CONFIG });\n  const format = rowFormatOf(values);\n  const configPath = values.config as string | undefined;\n\n  const cfg = ctx.resolveConfig(configPath);\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown command or saved entry: \"${queryName}\"`);\n    console.error(`saved queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(2);\n  }\n\n  if ('sql' in entry) {\n    // A saved statement written against `scope` is preset-agnostic, so the same entry can be\n    // re-pointed at another layer from the command line instead of being copied per preset.\n    await runSql(cfg, entry.sql, params, format, `query \"${queryName}\"`, values.preset as string | undefined);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved search and takes no positional parameters; edit its \"search\" in sense.config.json, or use \"${ctx.name} search\" directly`);\n  }\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const snippetCharLimit = parseSnippetCharLimit(values['snippet-char-limit'] as string | undefined, ctx.usageError);\n  const snippetCountLimit = parseSnippetCountLimit(values['snippet-count-limit'] as string | undefined, ctx.usageError);\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? entry.include;\n  const exclude = (values.exclude as string[] | undefined) ?? entry.exclude;\n  const noExclude = values['no-exclude'] === true;\n  await withDb(ctx, configPath, async (store, resolvedCfg) => printRows(await search(store, resolvedCfg, entry.search, { k, snippetCharLimit, snippetCountLimit, where, preset, include, exclude, noExclude }), format));\n}\n"],"names":["search","printRows","CONFIG","FORMAT","parse","parseK","parseSnippetCharLimit","parseSnippetCountLimit","rowFormatOf","runSql","SEARCH_FLAGS","withDb","named","ctx","queryName","values","usage","name","positionals","params","argv","format","configPath","config","cfg","resolveConfig","entry","queries","undefined","console","error","Object","keys","sort","join","process","exit","sql","preset","length","usageError","k","snippetCharLimit","snippetCountLimit","where","include","exclude","noExclude","store","resolvedCfg"],"mappings":"AAAA,SAASA,MAAM,QAAQ,wBAAwB;AAC/C,SAASC,SAAS,QAAQ,sBAAsB;AAChD,SAASC,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,qBAAqB,EAAEC,sBAAsB,EAAEC,WAAW,EAAEC,MAAM,EAAEC,YAAY,EAAEC,MAAM,QAAQ,cAAc;AAGtJ,6FAA6F;AAC7F,uFAAuF;AACvF,eAAe,eAAeC,MAAMC,GAAQ,EAAEC,SAAiB;QAyBnDT,SAGKU,eACCA,gBACCA,iBACAA;IA9BjB,MAAMC,QAAQ,CAAC,OAAO,EAAEH,IAAII,IAAI,CAAC,CAAC,EAAEH,UAAU,4MAA4M,CAAC;IAC3P,MAAM,EAAEC,MAAM,EAAEG,aAAaC,MAAM,EAAE,GAAGf,MAAMS,IAAIO,IAAI,EAAEJ,OAAO;QAAE,GAAGN,YAAY;QAAE,GAAGP,MAAM;QAAE,GAAGD,MAAM;IAAC;IACvG,MAAMmB,SAASb,YAAYO;IAC3B,MAAMO,aAAaP,OAAOQ,MAAM;IAEhC,MAAMC,MAAMX,IAAIY,aAAa,CAACH;IAC9B,MAAMI,QAAQF,IAAIG,OAAO,CAACb,UAAU;IACpC,IAAIY,UAAUE,WAAW;QACvBC,QAAQC,KAAK,CAAC,CAAC,iCAAiC,EAAEhB,UAAU,CAAC,CAAC;QAC9De,QAAQC,KAAK,CAAC,CAAC,eAAe,EAAEC,OAAOC,IAAI,CAACR,IAAIG,OAAO,EAAEM,IAAI,GAAGC,IAAI,CAAC,OAAO;QAC5EC,QAAQC,IAAI,CAAC;IACf;IAEA,IAAI,SAASV,OAAO;QAClB,yFAAyF;QACzF,wFAAwF;QACxF,MAAMjB,OAAOe,KAAKE,MAAMW,GAAG,EAAElB,QAAQE,QAAQ,CAAC,OAAO,EAAEP,UAAU,CAAC,CAAC,EAAEC,OAAOuB,MAAM;QAClF;IACF;IAEA,uFAAuF;IACvF,IAAInB,OAAOoB,MAAM,GAAG,GAAG;QACrB1B,IAAI2B,UAAU,CAAC,CAAC,CAAC,EAAE1B,UAAU,wGAAwG,EAAED,IAAII,IAAI,CAAC,iBAAiB,CAAC;IACpK;IACA,MAAMwB,KAAIpC,UAAAA,OAAOU,OAAO0B,CAAC,EAAwB5B,IAAI2B,UAAU,eAArDnC,qBAAAA,UAA0DqB,MAAMe,CAAC;IAC3E,MAAMC,mBAAmBpC,sBAAsBS,MAAM,CAAC,qBAAqB,EAAwBF,IAAI2B,UAAU;IACjH,MAAMG,oBAAoBpC,uBAAuBQ,MAAM,CAAC,sBAAsB,EAAwBF,IAAI2B,UAAU;IACpH,MAAMI,SAAS7B,gBAAAA,OAAO6B,KAAK,cAAZ7B,2BAAAA,gBAAuCW,MAAMkB,KAAK;IACjE,MAAMN,UAAUvB,iBAAAA,OAAOuB,MAAM,cAAbvB,4BAAAA,iBAAwCW,MAAMY,MAAM;IACpE,MAAMO,WAAW9B,kBAAAA,OAAO8B,OAAO,cAAd9B,6BAAAA,kBAA2CW,MAAMmB,OAAO;IACzE,MAAMC,WAAW/B,kBAAAA,OAAO+B,OAAO,cAAd/B,6BAAAA,kBAA2CW,MAAMoB,OAAO;IACzE,MAAMC,YAAYhC,MAAM,CAAC,aAAa,KAAK;IAC3C,MAAMJ,OAAOE,KAAKS,YAAY,OAAO0B,OAAOC,cAAgBhD,UAAU,MAAMD,OAAOgD,OAAOC,aAAavB,MAAM1B,MAAM,EAAE;YAAEyC;YAAGC;YAAkBC;YAAmBC;YAAON;YAAQO;YAASC;YAASC;QAAU,IAAI1B;AAChN"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/named.ts"],"sourcesContent":["import { scopedPaths } from '../commands/scope.ts';\nimport { search } from '../commands/search.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, runSql, SEARCH_FLAGS, withResolvedDb } from './shared.ts';\nimport type { Ctx } from './types.ts';\n\n// Fallback when the first positional is not a command: a saved query, { sql } or { search }.\n// SEARCH_FLAGS override a saved search's fields the same way they override a preset's.\nexport default async function named(ctx: Ctx, queryName: string): Promise<void> {\n  const usage = `usage: ${ctx.name} ${queryName} [params...] [--format table|json|csv] [--config path] [--where \"<sql>\"] [--k n] [--snippet-char-limit n] [--snippet-count-limit n] [--preset name] [--include glob ...] [--exclude glob ...] [--no-exclude] [--no-build]`;\n  const { values, positionals: params } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const format = rowFormatOf(values);\n  const configPath = values.config as string | undefined;\n  const noBuild = values['no-build'] === true;\n\n  const cfg = ctx.resolveConfig(configPath, { writeMigration: !noBuild, query: true });\n  const entry = cfg.queries[queryName];\n  if (entry === undefined) {\n    console.error(`unknown command or saved entry: \"${queryName}\"`);\n    console.error(`saved queries: ${Object.keys(cfg.queries).sort().join(', ')}`);\n    process.exit(2);\n  }\n\n  if ('sql' in entry) {\n    // A saved statement written against `scope` is preset-agnostic, so the same entry can be\n    // re-pointed at another layer from the command line instead of being copied per preset.\n    await runSql(cfg, entry.sql, params, format, `query \"${queryName}\"`, noBuild, values.preset as string | undefined);\n    return;\n  }\n\n  // A saved search's text is fixed in config; there is nowhere for a positional to bind.\n  if (params.length > 0) {\n    ctx.usageError(`\"${queryName}\" is a saved search and takes no positional parameters; edit its \"search\" in sense.config.json, or use \"${ctx.name} search\" directly`);\n  }\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? entry.k;\n  const snippetCharLimit = parseSnippetCharLimit(values['snippet-char-limit'] as string | undefined, ctx.usageError);\n  const snippetCountLimit = parseSnippetCountLimit(values['snippet-count-limit'] as string | undefined, ctx.usageError);\n  const where = (values.where as string | undefined) ?? entry.where;\n  const preset = (values.preset as string | undefined) ?? entry.preset;\n  const include = (values.include as string[] | undefined) ?? entry.include;\n  const exclude = (values.exclude as string[] | undefined) ?? entry.exclude;\n  const noExclude = values['no-exclude'] === true;\n  const overrides = { k, snippetCharLimit, snippetCountLimit, where, preset, include, exclude, noExclude };\n  await withResolvedDb(\n    cfg,\n    {\n      noBuild,\n      requirements: (resolvedCfg) => {\n        const signals = resolveSearch(resolvedCfg, overrides).signals;\n        const requirements = new Set<BuildRequirement>(['core']);\n        if (signals.words !== undefined) requirements.add('lexical');\n        return requirements;\n      },\n    },\n    async (store, resolvedCfg, build) => {\n      if (build && resolveSearch(resolvedCfg, overrides).signals.vectors !== undefined) {\n        await prepareDocumentEmbeddings(store, resolvedCfg, await scopedPaths(store, resolvedCfg, overrides));\n      }\n      printRows(await search(store, resolvedCfg, entry.search, overrides), format);\n    }\n  );\n}\n"],"names":["scopedPaths","search","resolveSearch","printRows","prepareDocumentEmbeddings","CONFIG","FORMAT","NO_BUILD","parse","parseK","parseSnippetCharLimit","parseSnippetCountLimit","rowFormatOf","runSql","SEARCH_FLAGS","withResolvedDb","named","ctx","queryName","values","usage","name","positionals","params","argv","format","configPath","config","noBuild","cfg","resolveConfig","writeMigration","query","entry","queries","undefined","console","error","Object","keys","sort","join","process","exit","sql","preset","length","usageError","k","snippetCharLimit","snippetCountLimit","where","include","exclude","noExclude","overrides","requirements","resolvedCfg","signals","Set","words","add","store","build","vectors"],"mappings":"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"}

package/dist/esm/cli/path.js

@@ -3,7 +3,7 @@ import { scopedPaths } from '../commands/scope.js';
 import { findPath } from '../graph/traverse.js';
 import { printRows } from '../output/output.js';
 import { USAGE } from './index.js';
-import { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.js';
+import { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.js';
 // --max-depth must be a positive integer, mirroring shared.ts's parseK.
 function parseMaxDepth(depth, usageError) {
     if (depth === undefined) return undefined;
@@ -15,6 +15,7 @@ const pathCmd = (ctx)=>{
     const usage = `usage: ${ctx.name} ${USAGE.path}`;
     const { values, positionals } = parse(ctx.argv, usage, {
         ...SCOPE,
+        ...NO_BUILD,
         ...FORMAT,
         ...CONFIG,
         'max-depth': {
@@ -25,7 +26,12 @@ const pathCmd = (ctx)=>{
     if (!a || !b) ctx.usageError(usage);
     const maxDepth = parseMaxDepth(values['max-depth'], ctx.usageError);
     const format = formatOf(values);
-    return withDb(ctx, values.config, async (store, cfg)=>{
+    return withDb(ctx, values.config, {
+        noBuild: values['no-build'] === true,
+        requirements: new Set([
+            'core'
+        ])
+    }, async (store, cfg)=>{
         const paths = (await (await store.prepare('SELECT "path" FROM frontmatter')).all()).map((r)=>r.path);
         const from = resolveNote(paths, a);
         const to = resolveNote(paths, b);

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/path.ts"],"sourcesContent":["import { resolveNote } from '../commands/peek.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { findPath } from '../graph/traverse.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// --max-depth must be a positive integer, mirroring shared.ts's parseK.\nfunction parseMaxDepth(depth: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (depth === undefined) return undefined;\n  const parsed = Number(depth);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--max-depth expects a positive integer, got \"${depth}\"`);\n  return parsed;\n}\n\nconst pathCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.path}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...FORMAT, ...CONFIG, 'max-depth': { type: 'string' } });\n  const [a, b] = positionals;\n  if (!a || !b) ctx.usageError(usage);\n  const maxDepth = parseMaxDepth(values['max-depth'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, async (store, cfg) => {\n    const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n    const from = resolveNote(paths, a);\n    const to = resolveNote(paths, b);\n    const allowed = await scopedPaths(store, cfg, scopeOf(values));\n    const hops = await findPath(store, from, to, { maxDepth, allowed });\n\n    if (format === 'json') {\n      console.log(JSON.stringify(hops));\n      return;\n    }\n    if (hops === null) {\n      console.log(maxDepth ? `no path within ${maxDepth} hops` : 'no path');\n      return;\n    }\n    const rows: Row[] = hops.map((p, step) => ({ step, path: p }));\n    printRows(rows, format);\n  });\n};\nexport default pathCmd;\n"],"names":["resolveNote","scopedPaths","findPath","printRows","USAGE","CONFIG","FORMAT","formatOf","parse","SCOPE","scopeOf","withDb","parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","name","path","values","positionals","argv","type","a","b","maxDepth","format","config","store","cfg","paths","prepare","all","map","r","from","to","allowed","hops","console","log","JSON","stringify","rows","p","step"],"mappings":"AAAA,SAASA,WAAW,QAAQ,sBAAsB;AAClD,SAASC,WAAW,QAAQ,uBAAuB;AACnD,SAASC,QAAQ,QAAQ,uBAAuB;AAEhD,SAASC,SAAS,QAAQ,sBAAsB;AAChD,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGtF,wEAAwE;AACxE,SAASC,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,MAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,CAAC,6CAA6C,EAAED,MAAM,CAAC,CAAC;IACjH,OAAOG;AACT;AAEA,MAAMG,UAAmB,CAACC;IACxB,MAAMC,QAAQ,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAElB,MAAMmB,IAAI,EAAE;IAChD,MAAM,EAAEC,MAAM,EAAEC,WAAW,EAAE,GAAGjB,MAAMY,IAAIM,IAAI,EAAEL,OAAO;QAAE,GAAGZ,KAAK;QAAE,GAAGH,MAAM;QAAE,GAAGD,MAAM;QAAE,aAAa;YAAEsB,MAAM;QAAS;IAAE;IACzH,MAAM,CAACC,GAAGC,EAAE,GAAGJ;IACf,IAAI,CAACG,KAAK,CAACC,GAAGT,IAAIN,UAAU,CAACO;IAC7B,MAAMS,WAAWlB,cAAcY,MAAM,CAAC,YAAY,EAAwBJ,IAAIN,UAAU;IACxF,MAAMiB,SAASxB,SAASiB;IACxB,OAAOb,OAAOS,KAAKI,OAAOQ,MAAM,EAAwB,OAAOC,OAAOC;QACpE,MAAMC,QAAQ,AAAE,CAAA,MAAM,AAAC,CAAA,MAAMF,MAAMG,OAAO,CAAC,iCAAgC,EAAGC,GAAG,EAAC,EAA+BC,GAAG,CAAC,CAACC,IAAMA,EAAEhB,IAAI;QAClI,MAAMiB,OAAOxC,YAAYmC,OAAOP;QAChC,MAAMa,KAAKzC,YAAYmC,OAAON;QAC9B,MAAMa,UAAU,MAAMzC,YAAYgC,OAAOC,KAAKxB,QAAQc;QACtD,MAAMmB,OAAO,MAAMzC,SAAS+B,OAAOO,MAAMC,IAAI;YAAEX;YAAUY;QAAQ;QAEjE,IAAIX,WAAW,QAAQ;YACrBa,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACJ;YAC3B;QACF;QACA,IAAIA,SAAS,MAAM;YACjBC,QAAQC,GAAG,CAACf,WAAW,CAAC,eAAe,EAAEA,SAAS,KAAK,CAAC,GAAG;YAC3D;QACF;QACA,MAAMkB,OAAcL,KAAKL,GAAG,CAAC,CAACW,GAAGC,OAAU,CAAA;gBAAEA;gBAAM3B,MAAM0B;YAAE,CAAA;QAC3D9C,UAAU6C,MAAMjB;IAClB;AACF;AACA,eAAeZ,QAAQ"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/path.ts"],"sourcesContent":["import { resolveNote } from '../commands/peek.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { findPath } from '../graph/traverse.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// --max-depth must be a positive integer, mirroring shared.ts's parseK.\nfunction parseMaxDepth(depth: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (depth === undefined) return undefined;\n  const parsed = Number(depth);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--max-depth expects a positive integer, got \"${depth}\"`);\n  return parsed;\n}\n\nconst pathCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.path}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, 'max-depth': { type: 'string' } });\n  const [a, b] = positionals;\n  if (!a || !b) ctx.usageError(usage);\n  const maxDepth = parseMaxDepth(values['max-depth'] as string | undefined, ctx.usageError);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const paths = ((await (await store.prepare('SELECT \"path\" FROM frontmatter')).all()) as Array<{ path: string }>).map((r) => r.path);\n    const from = resolveNote(paths, a);\n    const to = resolveNote(paths, b);\n    const allowed = await scopedPaths(store, cfg, scopeOf(values));\n    const hops = await findPath(store, from, to, { maxDepth, allowed });\n\n    if (format === 'json') {\n      console.log(JSON.stringify(hops));\n      return;\n    }\n    if (hops === null) {\n      console.log(maxDepth ? `no path within ${maxDepth} hops` : 'no path');\n      return;\n    }\n    const rows: Row[] = hops.map((p, step) => ({ step, path: p }));\n    printRows(rows, format);\n  });\n};\nexport default pathCmd;\n"],"names":["resolveNote","scopedPaths","findPath","printRows","USAGE","CONFIG","FORMAT","formatOf","NO_BUILD","parse","SCOPE","scopeOf","withDb","parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","name","path","values","positionals","argv","type","a","b","maxDepth","format","config","noBuild","requirements","Set","store","cfg","paths","prepare","all","map","r","from","to","allowed","hops","console","log","JSON","stringify","rows","p","step"],"mappings":"AAAA,SAASA,WAAW,QAAQ,sBAAsB;AAClD,SAASC,WAAW,QAAQ,uBAAuB;AACnD,SAASC,QAAQ,QAAQ,uBAAuB;AAEhD,SAASC,SAAS,QAAQ,sBAAsB;AAEhD,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGhG,wEAAwE;AACxE,SAASC,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,MAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,CAAC,6CAA6C,EAAED,MAAM,CAAC,CAAC;IACjH,OAAOG;AACT;AAEA,MAAMG,UAAmB,CAACC;IACxB,MAAMC,QAAQ,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAEnB,MAAMoB,IAAI,EAAE;IAChD,MAAM,EAAEC,MAAM,EAAEC,WAAW,EAAE,GAAGjB,MAAMY,IAAIM,IAAI,EAAEL,OAAO;QAAE,GAAGZ,KAAK;QAAE,GAAGF,QAAQ;QAAE,GAAGF,MAAM;QAAE,GAAGD,MAAM;QAAE,aAAa;YAAEuB,MAAM;QAAS;IAAE;IACtI,MAAM,CAACC,GAAGC,EAAE,GAAGJ;IACf,IAAI,CAACG,KAAK,CAACC,GAAGT,IAAIN,UAAU,CAACO;IAC7B,MAAMS,WAAWlB,cAAcY,MAAM,CAAC,YAAY,EAAwBJ,IAAIN,UAAU;IACxF,MAAMiB,SAASzB,SAASkB;IACxB,OAAOb,OAAOS,KAAKI,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,OAAOC,OAAOC;QACjK,MAAMC,QAAQ,AAAE,CAAA,MAAM,AAAC,CAAA,MAAMF,MAAMG,OAAO,CAAC,iCAAgC,EAAGC,GAAG,EAAC,EAA+BC,GAAG,CAAC,CAACC,IAAMA,EAAEnB,IAAI;QAClI,MAAMoB,OAAO5C,YAAYuC,OAAOV;QAChC,MAAMgB,KAAK7C,YAAYuC,OAAOT;QAC9B,MAAMgB,UAAU,MAAM7C,YAAYoC,OAAOC,KAAK3B,QAAQc;QACtD,MAAMsB,OAAO,MAAM7C,SAASmC,OAAOO,MAAMC,IAAI;YAAEd;YAAUe;QAAQ;QAEjE,IAAId,WAAW,QAAQ;YACrBgB,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACJ;YAC3B;QACF;QACA,IAAIA,SAAS,MAAM;YACjBC,QAAQC,GAAG,CAAClB,WAAW,CAAC,eAAe,EAAEA,SAAS,KAAK,CAAC,GAAG;YAC3D;QACF;QACA,MAAMqB,OAAcL,KAAKL,GAAG,CAAC,CAACW,GAAGC,OAAU,CAAA;gBAAEA;gBAAM9B,MAAM6B;YAAE,CAAA;QAC3DlD,UAAUiD,MAAMpB;IAClB;AACF;AACA,eAAeZ,QAAQ"}

package/dist/esm/cli/peek.js

@@ -1,18 +1,24 @@
 import { peek } from '../commands/peek.js';
 import { renderPeek, stringifyJson } from '../output/output.js';
 import { USAGE } from './index.js';
-import { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.js';
+import { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.js';
 const peekCmd = (ctx)=>{
     const usage = `usage: ${ctx.name} ${USAGE.peek}`;
     const { values, positionals } = parse(ctx.argv, usage, {
         ...SCOPE,
+        ...NO_BUILD,
         ...FORMAT,
         ...CONFIG
     });
     const [pathArg] = positionals;
     if (!pathArg) ctx.usageError(usage);
     const format = formatOf(values);
-    return withDb(ctx, values.config, async (store, cfg)=>{
+    return withDb(ctx, values.config, {
+        noBuild: values['no-build'] === true,
+        requirements: new Set([
+            'core'
+        ])
+    }, async (store, cfg)=>{
         const overrides = scopeOf(values);
         const result = await peek(store, cfg, pathArg, overrides);
         console.log(format === 'json' ? stringifyJson(result, 2) : renderPeek(result));

package/dist/esm/cli/peek.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/peek.ts"],"sourcesContent":["import { peek } from '../commands/peek.ts';\nimport { renderPeek, stringifyJson } from '../output/output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst peekCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.peek}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...FORMAT, ...CONFIG });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, async (store, cfg) => {\n    const overrides = scopeOf(values);\n    const result = await peek(store, cfg, pathArg, overrides);\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderPeek(result));\n  });\n};\nexport default peekCmd;\n"],"names":["peek","renderPeek","stringifyJson","USAGE","CONFIG","FORMAT","formatOf","parse","SCOPE","scopeOf","withDb","peekCmd","ctx","usage","name","values","positionals","argv","pathArg","usageError","format","config","store","cfg","overrides","result","console","log"],"mappings":"AAAA,SAASA,IAAI,QAAQ,sBAAsB;AAC3C,SAASC,UAAU,EAAEC,aAAa,QAAQ,sBAAsB;AAChE,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGtF,MAAMC,UAAmB,CAACC;IACxB,MAAMC,QAAQ,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAEX,MAAMH,IAAI,EAAE;IAChD,MAAM,EAAEe,MAAM,EAAEC,WAAW,EAAE,GAAGT,MAAMK,IAAIK,IAAI,EAAEJ,OAAO;QAAE,GAAGL,KAAK;QAAE,GAAGH,MAAM;QAAE,GAAGD,MAAM;IAAC;IACxF,MAAM,CAACc,QAAQ,GAAGF;IAClB,IAAI,CAACE,SAASN,IAAIO,UAAU,CAACN;IAC7B,MAAMO,SAASd,SAASS;IACxB,OAAOL,OAAOE,KAAKG,OAAOM,MAAM,EAAwB,OAAOC,OAAOC;QACpE,MAAMC,YAAYf,QAAQM;QAC1B,MAAMU,SAAS,MAAMzB,KAAKsB,OAAOC,KAAKL,SAASM;QAC/CE,QAAQC,GAAG,CAACP,WAAW,SAASlB,cAAcuB,QAAQ,KAAKxB,WAAWwB;IACxE;AACF;AACA,eAAed,QAAQ"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/peek.ts"],"sourcesContent":["import { peek } from '../commands/peek.ts';\nimport { renderPeek, stringifyJson } from '../output/output.ts';\nimport type { BuildRequirement } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, formatOf, NO_BUILD, parse, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst peekCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.peek}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const format = formatOf(values);\n  return withDb(ctx, values.config as string | undefined, { noBuild: values['no-build'] === true, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg) => {\n    const overrides = scopeOf(values);\n    const result = await peek(store, cfg, pathArg, overrides);\n    console.log(format === 'json' ? stringifyJson(result, 2) : renderPeek(result));\n  });\n};\nexport default peekCmd;\n"],"names":["peek","renderPeek","stringifyJson","USAGE","CONFIG","FORMAT","formatOf","NO_BUILD","parse","SCOPE","scopeOf","withDb","peekCmd","ctx","usage","name","values","positionals","argv","pathArg","usageError","format","config","noBuild","requirements","Set","store","cfg","overrides","result","console","log"],"mappings":"AAAA,SAASA,IAAI,QAAQ,sBAAsB;AAC3C,SAASC,UAAU,EAAEC,aAAa,QAAQ,sBAAsB;AAEhE,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGhG,MAAMC,UAAmB,CAACC;IACxB,MAAMC,QAAQ,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAEZ,MAAMH,IAAI,EAAE;IAChD,MAAM,EAAEgB,MAAM,EAAEC,WAAW,EAAE,GAAGT,MAAMK,IAAIK,IAAI,EAAEJ,OAAO;QAAE,GAAGL,KAAK;QAAE,GAAGF,QAAQ;QAAE,GAAGF,MAAM;QAAE,GAAGD,MAAM;IAAC;IACrG,MAAM,CAACe,QAAQ,GAAGF;IAClB,IAAI,CAACE,SAASN,IAAIO,UAAU,CAACN;IAC7B,MAAMO,SAASf,SAASU;IACxB,OAAOL,OAAOE,KAAKG,OAAOM,MAAM,EAAwB;QAAEC,SAASP,MAAM,CAAC,WAAW,KAAK;QAAMQ,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,OAAOC,OAAOC;QACjK,MAAMC,YAAYlB,QAAQM;QAC1B,MAAMa,SAAS,MAAM7B,KAAK0B,OAAOC,KAAKR,SAASS;QAC/CE,QAAQC,GAAG,CAACV,WAAW,SAASnB,cAAc2B,QAAQ,KAAK5B,WAAW4B;IACxE;AACF;AACA,eAAejB,QAAQ"}

package/dist/esm/cli/related.js

@@ -1,13 +1,17 @@
-import { relatedNotes } from '../commands/related.js';
+import { relatedNotes, resolveRelatedSeed } from '../commands/related.js';
+import { scopedPaths } from '../commands/scope.js';
+import { resolveSearch } from '../config/index.js';
 import { printRows } from '../output/output.js';
+import { prepareDocumentEmbeddings } from '../store/open.js';
 import { USAGE } from './index.js';
-import { CONFIG, FORMAT, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.js';
+import { CONFIG, FORMAT, NO_BUILD, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.js';
 const RELATED_DEFAULT_K = 5;
 const relatedCmd = (ctx)=>{
     var _parseK;
     const usage = `usage: ${ctx.name} ${USAGE.related}`;
     const { values, positionals } = parse(ctx.argv, usage, {
         ...SCOPE,
+        ...NO_BUILD,
         ...FORMAT,
         ...CONFIG,
         k: {
@@ -18,8 +22,22 @@ const relatedCmd = (ctx)=>{
     if (!pathArg) ctx.usageError(usage);
     const k = (_parseK = parseK(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : RELATED_DEFAULT_K;
     const format = rowFormatOf(values);
-    return withDb(ctx, values.config, async (store, cfg)=>{
+    const noBuild = values['no-build'] === true;
+    return withDb(ctx, values.config, {
+        noBuild,
+        requirements: new Set([
+            'core'
+        ])
+    }, async (store, cfg, build)=>{
         const overrides = scopeOf(values);
+        if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {
+            const path = await resolveRelatedSeed(store, pathArg);
+            const allowed = await scopedPaths(store, cfg, overrides);
+            await prepareDocumentEmbeddings(store, cfg, new Set([
+                ...allowed,
+                path
+            ]));
+        }
         printRows(await relatedNotes(store, cfg, pathArg, overrides, k), format);
     });
 };

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { relatedNotes } from '../commands/related.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst RELATED_DEFAULT_K = 5;\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...FORMAT, ...CONFIG, k: { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? RELATED_DEFAULT_K;\n  const format = rowFormatOf(values);\n  return withDb(ctx, values.config as string | undefined, async (store, cfg) => {\n    const overrides = scopeOf(values);\n    printRows((await relatedNotes(store, cfg, pathArg, overrides, k)) as Row[], format);\n  });\n};\nexport default relatedCmd;\n"],"names":["relatedNotes","printRows","USAGE","CONFIG","FORMAT","parse","parseK","rowFormatOf","SCOPE","scopeOf","withDb","RELATED_DEFAULT_K","relatedCmd","ctx","usage","name","related","values","positionals","argv","k","type","pathArg","usageError","format","config","store","cfg","overrides"],"mappings":"AAAA,SAASA,YAAY,QAAQ,yBAAyB;AAEtD,SAASC,SAAS,QAAQ,sBAAsB;AAChD,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,WAAW,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAGjG,MAAMC,oBAAoB;AAE1B,MAAMC,aAAsB,CAACC;QAKjBP;IAJV,MAAMQ,QAAQ,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAEb,MAAMc,OAAO,EAAE;IACnD,MAAM,EAAEC,MAAM,EAAEC,WAAW,EAAE,GAAGb,MAAMQ,IAAIM,IAAI,EAAEL,OAAO;QAAE,GAAGN,KAAK;QAAE,GAAGJ,MAAM;QAAE,GAAGD,MAAM;QAAEiB,GAAG;YAAEC,MAAM;QAAS;IAAE;IAC/G,MAAM,CAACC,QAAQ,GAAGJ;IAClB,IAAI,CAACI,SAAST,IAAIU,UAAU,CAACT;IAC7B,MAAMM,KAAId,UAAAA,OAAOW,OAAOG,CAAC,EAAwBP,IAAIU,UAAU,eAArDjB,qBAAAA,UAA0DK;IACpE,MAAMa,SAASjB,YAAYU;IAC3B,OAAOP,OAAOG,KAAKI,OAAOQ,MAAM,EAAwB,OAAOC,OAAOC;QACpE,MAAMC,YAAYnB,QAAQQ;QAC1BhB,UAAW,MAAMD,aAAa0B,OAAOC,KAAKL,SAASM,WAAWR,IAAcI;IAC9E;AACF;AACA,eAAeZ,WAAW"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/related.ts"],"sourcesContent":["import { relatedNotes, resolveRelatedSeed } from '../commands/related.ts';\nimport { scopedPaths } from '../commands/scope.ts';\nimport { resolveSearch } from '../config/index.ts';\nimport type { Row } from '../output/output.ts';\nimport { printRows } from '../output/output.ts';\nimport { type BuildRequirement, prepareDocumentEmbeddings } from '../store/open.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, rowFormatOf, SCOPE, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst RELATED_DEFAULT_K = 5;\n\nconst relatedCmd: Command = (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.related}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SCOPE, ...NO_BUILD, ...FORMAT, ...CONFIG, k: { type: 'string' } });\n  const [pathArg] = positionals;\n  if (!pathArg) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError) ?? RELATED_DEFAULT_K;\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  return withDb(ctx, values.config as string | undefined, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store, cfg, build) => {\n    const overrides = scopeOf(values);\n    if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n      const path = await resolveRelatedSeed(store, pathArg);\n      const allowed = await scopedPaths(store, cfg, overrides);\n      await prepareDocumentEmbeddings(store, cfg, new Set([...allowed, path]));\n    }\n    printRows((await relatedNotes(store, cfg, pathArg, overrides, k)) as Row[], format);\n  });\n};\nexport default relatedCmd;\n"],"names":["relatedNotes","resolveRelatedSeed","scopedPaths","resolveSearch","printRows","prepareDocumentEmbeddings","USAGE","CONFIG","FORMAT","NO_BUILD","parse","parseK","rowFormatOf","SCOPE","scopeOf","withDb","RELATED_DEFAULT_K","relatedCmd","ctx","usage","name","related","values","positionals","argv","k","type","pathArg","usageError","format","noBuild","config","requirements","Set","store","cfg","build","overrides","signals","vectors","undefined","path","allowed"],"mappings":"AAAA,SAASA,YAAY,EAAEC,kBAAkB,QAAQ,yBAAyB;AAC1E,SAASC,WAAW,QAAQ,uBAAuB;AACnD,SAASC,aAAa,QAAQ,qBAAqB;AAEnD,SAASC,SAAS,QAAQ,sBAAsB;AAChD,SAAgCC,yBAAyB,QAAQ,mBAAmB;AACpF,SAASC,KAAK,QAAQ,aAAa;AACnC,SAASC,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAEC,KAAK,EAAEC,MAAM,EAAEC,WAAW,EAAEC,KAAK,EAAEC,OAAO,EAAEC,MAAM,QAAQ,cAAc;AAG3G,MAAMC,oBAAoB;AAE1B,MAAMC,aAAsB,CAACC;QAKjBP;IAJV,MAAMQ,QAAQ,CAAC,OAAO,EAAED,IAAIE,IAAI,CAAC,CAAC,EAAEd,MAAMe,OAAO,EAAE;IACnD,MAAM,EAAEC,MAAM,EAAEC,WAAW,EAAE,GAAGb,MAAMQ,IAAIM,IAAI,EAAEL,OAAO;QAAE,GAAGN,KAAK;QAAE,GAAGJ,QAAQ;QAAE,GAAGD,MAAM;QAAE,GAAGD,MAAM;QAAEkB,GAAG;YAAEC,MAAM;QAAS;IAAE;IAC5H,MAAM,CAACC,QAAQ,GAAGJ;IAClB,IAAI,CAACI,SAAST,IAAIU,UAAU,CAACT;IAC7B,MAAMM,KAAId,UAAAA,OAAOW,OAAOG,CAAC,EAAwBP,IAAIU,UAAU,eAArDjB,qBAAAA,UAA0DK;IACpE,MAAMa,SAASjB,YAAYU;IAC3B,MAAMQ,UAAUR,MAAM,CAAC,WAAW,KAAK;IACvC,OAAOP,OAAOG,KAAKI,OAAOS,MAAM,EAAwB;QAAED;QAASE,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,OAAOC,OAAOC,KAAKC;QACzI,MAAMC,YAAYvB,QAAQQ;QAC1B,IAAIc,SAASjC,cAAcgC,KAAKE,WAAWC,OAAO,CAACC,OAAO,KAAKC,WAAW;YACxE,MAAMC,OAAO,MAAMxC,mBAAmBiC,OAAOP;YAC7C,MAAMe,UAAU,MAAMxC,YAAYgC,OAAOC,KAAKE;YAC9C,MAAMhC,0BAA0B6B,OAAOC,KAAK,IAAIF,IAAI;mBAAIS;gBAASD;aAAK;QACxE;QACArC,UAAW,MAAMJ,aAAakC,OAAOC,KAAKR,SAASU,WAAWZ,IAAcI;IAC9E;AACF;AACA,eAAeZ,WAAW"}

package/dist/esm/cli/search.js

@@ -1,11 +1,15 @@
+import { scopedPaths } from '../commands/scope.js';
 import { search } from '../commands/search.js';
+import { resolveSearch } from '../config/index.js';
 import { printRows } from '../output/output.js';
+import { prepareDocumentEmbeddings } from '../store/open.js';
 import { USAGE } from './index.js';
-import { CONFIG, FORMAT, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, SEARCH_FLAGS, scopeOf, withDb } from './shared.js';
+import { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, SEARCH_FLAGS, scopeOf, withDb } from './shared.js';
 const searchCmd = async (ctx)=>{
     const usage = `usage: ${ctx.name} ${USAGE.search}`;
     const { values, positionals } = parse(ctx.argv, usage, {
         ...SEARCH_FLAGS,
+        ...NO_BUILD,
         ...FORMAT,
         ...CONFIG
     });
@@ -15,11 +19,28 @@ const searchCmd = async (ctx)=>{
     const snippetCharLimit = parseSnippetCharLimit(values['snippet-char-limit'], ctx.usageError);
     const snippetCountLimit = parseSnippetCountLimit(values['snippet-count-limit'], ctx.usageError);
     const format = rowFormatOf(values);
-    await withDb(ctx, values.config, async (store, cfg)=>printRows(await search(store, cfg, terms, {
-            k,
-            snippetCharLimit,
-            snippetCountLimit,
-            ...scopeOf(values)
-        }), format));
+    const overrides = {
+        k,
+        snippetCharLimit,
+        snippetCountLimit,
+        ...scopeOf(values)
+    };
+    const noBuild = values['no-build'] === true;
+    await withDb(ctx, values.config, {
+        noBuild,
+        requirements: (cfg)=>{
+            const signals = resolveSearch(cfg, overrides).signals;
+            const requirements = new Set([
+                'core'
+            ]);
+            if (signals.words !== undefined) requirements.add('lexical');
+            return requirements;
+        }
+    }, async (store, cfg, build)=>{
+        if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {
+            await prepareDocumentEmbeddings(store, cfg, await scopedPaths(store, cfg, overrides));
+        }
+        printRows(await search(store, cfg, terms, overrides), format);
+    });
 };
 export default searchCmd;