sensemaking 0.24.7 → 0.25.0

package/dist/cjs/cli/named.js

@@ -10,8 +10,11 @@ Object.defineProperty(exports, // Fallback when the first positional is not a co
         return named;
     }
 });
+var _scopets = require("../commands/scope.js");
 var _searchts = require("../commands/search.js");
+var _indexts = require("../config/index.js");
 var _outputts = require("../output/output.js");
+var _opents = require("../store/open.js");
 var _sharedts = require("./shared.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -166,15 +169,19 @@ function _ts_generator(thisArg, body) {
 }
 function named(ctx, queryName) {
     return _async_to_generator(function() {
-        var _parseK, _values_where, _values_preset, _values_include, _values_exclude, usage, _parse, values, params, format, configPath, cfg, entry, k, snippetCharLimit, snippetCountLimit, where, preset, include, exclude, noExclude;
+        var _parseK, _values_where, _values_preset, _values_include, _values_exclude, usage, _parse, values, params, format, configPath, noBuild, cfg, entry, k, snippetCharLimit, snippetCountLimit, where, preset, include, exclude, noExclude, overrides;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    usage = "usage: ".concat(ctx.name, " ").concat(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]');
-                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, params = _parse.positionals;
+                    usage = "usage: ".concat(ctx.name, " ").concat(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]');
+                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, params = _parse.positionals;
                     format = (0, _sharedts.rowFormatOf)(values);
                     configPath = values.config;
-                    cfg = ctx.resolveConfig(configPath);
+                    noBuild = values['no-build'] === true;
+                    cfg = ctx.resolveConfig(configPath, {
+                        writeMigration: !noBuild,
+                        query: true
+                    });
                     entry = cfg.queries[queryName];
                     if (entry === undefined) {
                         console.error('unknown command or saved entry: "'.concat(queryName, '"'));
@@ -189,7 +196,7 @@ function named(ctx, queryName) {
                     // re-pointed at another layer from the command line instead of being copied per preset.
                     return [
                         4,
-                        (0, _sharedts.runSql)(cfg, entry.sql, params, format, 'query "'.concat(queryName, '"'), values.preset)
+                        (0, _sharedts.runSql)(cfg, entry.sql, params, format, 'query "'.concat(queryName, '"'), noBuild, values.preset)
                     ];
                 case 1:
                     _state.sent();
@@ -209,33 +216,68 @@ function named(ctx, queryName) {
                     include = (_values_include = values.include) !== null && _values_include !== void 0 ? _values_include : entry.include;
                     exclude = (_values_exclude = values.exclude) !== null && _values_exclude !== void 0 ? _values_exclude : entry.exclude;
                     noExclude = values['no-exclude'] === true;
+                    overrides = {
+                        k: k,
+                        snippetCharLimit: snippetCharLimit,
+                        snippetCountLimit: snippetCountLimit,
+                        where: where,
+                        preset: preset,
+                        include: include,
+                        exclude: exclude,
+                        noExclude: noExclude
+                    };
                     return [
                         4,
-                        (0, _sharedts.withDb)(ctx, configPath, function(store, resolvedCfg) {
+                        (0, _sharedts.withResolvedDb)(cfg, {
+                            noBuild: noBuild,
+                            requirements: function requirements(resolvedCfg) {
+                                var signals = (0, _indexts.resolveSearch)(resolvedCfg, overrides).signals;
+                                var requirements = new Set([
+                                    'core'
+                                ]);
+                                if (signals.words !== undefined) requirements.add('lexical');
+                                return requirements;
+                            }
+                        }, function(store, resolvedCfg, build) {
                             return _async_to_generator(function() {
+                                var _tmp;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
+                                            if (!(build && (0, _indexts.resolveSearch)(resolvedCfg, overrides).signals.vectors !== undefined)) return [
+                                                3,
+                                                3
+                                            ];
+                                            _tmp = [
+                                                store,
+                                                resolvedCfg
+                                            ];
                                             return [
                                                 4,
-                                                (0, _searchts.search)(store, resolvedCfg, entry.search, {
-                                                    k: k,
-                                                    snippetCharLimit: snippetCharLimit,
-                                                    snippetCountLimit: snippetCountLimit,
-                                                    where: where,
-                                                    preset: preset,
-                                                    include: include,
-                                                    exclude: exclude,
-                                                    noExclude: noExclude
-                                                })
+                                                (0, _scopets.scopedPaths)(store, resolvedCfg, overrides)
                                             ];
                                         case 1:
                                             return [
-                                                2,
-                                                _outputts.printRows.apply(void 0, [
-                                                    _state.sent(),
-                                                    format
-                                                ])
+                                                4,
+                                                _opents.prepareDocumentEmbeddings.apply(void 0, _tmp.concat([
+                                                    _state.sent()
+                                                ]))
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            _state.label = 3;
+                                        case 3:
+                                            return [
+                                                4,
+                                                (0, _searchts.search)(store, resolvedCfg, entry.search, overrides)
+                                            ];
+                                        case 4:
+                                            _outputts.printRows.apply(void 0, [
+                                                _state.sent(),
+                                                format
+                                            ]);
+                                            return [
+                                                2
                                             ];
                                     }
                                 });

package/dist/cjs/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":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","cfg","entry","k","snippetCharLimit","snippetCountLimit","where","preset","include","exclude","noExclude","name","argv","SEARCH_FLAGS","FORMAT","CONFIG","positionals","rowFormatOf","config","resolveConfig","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","sql","length","usageError","parseSnippetCharLimit","parseSnippetCountLimit","withDb","store","resolvedCfg","search","printRows"],"mappings":"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"}
+{"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":["named","ctx","queryName","parseK","values","usage","parse","params","format","configPath","noBuild","cfg","entry","k","snippetCharLimit","snippetCountLimit","where","preset","include","exclude","noExclude","overrides","name","argv","SEARCH_FLAGS","NO_BUILD","FORMAT","CONFIG","positionals","rowFormatOf","config","resolveConfig","writeMigration","query","queries","undefined","console","error","Object","keys","sort","join","process","exit","runSql","sql","length","usageError","parseSnippetCharLimit","parseSnippetCountLimit","withResolvedDb","requirements","resolvedCfg","signals","resolveSearch","Set","words","add","store","build","vectors","scopedPaths","prepareDocumentEmbeddings","search","printRows"],"mappings":"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"}

package/dist/cjs/cli/path.js

@@ -243,7 +243,7 @@ function parseMaxDepth(depth, usageError) {
 }
 var pathCmd = function pathCmd(ctx) {
     var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.path);
-    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SCOPE, _sharedts.FORMAT, _sharedts.CONFIG), {
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SCOPE, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG), {
         'max-depth': {
             type: 'string'
         }
@@ -252,7 +252,12 @@ var pathCmd = function pathCmd(ctx) {
     if (!a || !b) ctx.usageError(usage);
     var maxDepth = parseMaxDepth(values['max-depth'], ctx.usageError);
     var format = (0, _sharedts.formatOf)(values);
-    return (0, _sharedts.withDb)(ctx, values.config, function(store, cfg) {
+    return (0, _sharedts.withDb)(ctx, values.config, {
+        noBuild: values['no-build'] === true,
+        requirements: new Set([
+            'core'
+        ])
+    }, function(store, cfg) {
         return _async_to_generator(function() {
             var paths, from, to, allowed, hops, rows;
             return _ts_generator(this, function(_state) {

package/dist/cjs/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":["parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","USAGE","name","path","parse","argv","SCOPE","FORMAT","CONFIG","type","values","positionals","a","b","maxDepth","format","formatOf","withDb","config","store","cfg","paths","from","to","allowed","hops","rows","prepare","all","map","r","resolveNote","scopedPaths","scopeOf","findPath","console","log","JSON","stringify","p","step","printRows"],"mappings":";;;;+BA2CA;;;eAAA;;;sBA3C4B;uBACA;0BACH;wBAEC;uBACJ;wBACkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxE,wEAAwE;AACxE,SAASA,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,gDAAqD,OAAND,OAAM;IAC/G,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,aAAa;YAAEC,MAAM;QAAS;SAA/GC,SAAwBN,OAAxBM,QAAQC,cAAgBP,OAAhBO;IAChB,IAAeA,gCAAAA,iBAARC,IAAQD,iBAALE,IAAKF;IACf,IAAI,CAACC,KAAK,CAACC,GAAGd,IAAIN,UAAU,CAACO;IAC7B,IAAMc,WAAWvB,cAAcmB,MAAM,CAAC,YAAY,EAAwBX,IAAIN,UAAU;IACxF,IAAMsB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAAClB,KAAKW,OAAOQ,MAAM,EAAwB,SAAOC,OAAOC;;gBAC9DC,OACAC,MACAC,IACAC,SACAC,MAUAC;;;;wBAdiB;;4BAAMP,MAAMQ,OAAO,CAAC;;;wBAA3B;;4BAAO,cAAuDC,GAAG;;;wBAA3EP,QAAQ,AAAE,cAAiGQ,GAAG,CAAC,SAACC;mCAAMA,EAAE3B,IAAI;;wBAC5HmB,OAAOS,IAAAA,mBAAW,EAACV,OAAOT;wBAC1BW,KAAKQ,IAAAA,mBAAW,EAACV,OAAOR;wBACd;;4BAAMmB,IAAAA,oBAAW,EAACb,OAAOC,KAAKa,IAAAA,iBAAO,EAACvB;;;wBAAhDc,UAAU;wBACH;;4BAAMU,IAAAA,oBAAQ,EAACf,OAAOG,MAAMC,IAAI;gCAAET,UAAAA;gCAAUU,SAAAA;4BAAQ;;;wBAA3DC,OAAO;wBAEb,IAAIV,WAAW,QAAQ;4BACrBoB,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACb;4BAC3B;;;wBACF;wBACA,IAAIA,SAAS,MAAM;4BACjBU,QAAQC,GAAG,CAACtB,WAAW,AAAC,kBAA0B,OAATA,UAAS,WAAS;4BAC3D;;;wBACF;wBACMY,OAAcD,KAAKI,GAAG,CAAC,SAACU,GAAGC;mCAAU;gCAAEA,MAAAA;gCAAMrC,MAAMoC;4BAAE;;wBAC3DE,IAAAA,mBAAS,EAACf,MAAMX;;;;;;QAClB;;AACF;IACA,WAAejB"}
+{"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":["parseMaxDepth","depth","usageError","undefined","parsed","Number","isInteger","pathCmd","ctx","usage","USAGE","name","path","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","type","values","positionals","a","b","maxDepth","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","paths","from","to","allowed","hops","rows","prepare","all","map","r","resolveNote","scopedPaths","scopeOf","findPath","console","log","JSON","stringify","p","step","printRows"],"mappings":";;;;+BA4CA;;;eAAA;;;sBA5C4B;uBACA;0BACH;wBAEC;uBAEJ;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,wEAAwE;AACxE,SAASA,cAAcC,KAAyB,EAAEC,UAAsC;IACtF,IAAID,UAAUE,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOJ;IACtB,IAAI,CAACI,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,gDAAqD,OAAND,OAAM;IAC/G,OAAOG;AACT;AAEA,IAAMG,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAE,aAAa;YAAEC,MAAM;QAAS;SAA5HC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAeA,gCAAAA,iBAARC,IAAQD,iBAALE,IAAKF;IACf,IAAI,CAACC,KAAK,CAACC,GAAGf,IAAIN,UAAU,CAACO;IAC7B,IAAMe,WAAWxB,cAAcoB,MAAM,CAAC,YAAY,EAAwBZ,IAAIN,UAAU;IACxF,IAAMuB,SAASC,IAAAA,kBAAQ,EAACN;IACxB,OAAOO,IAAAA,gBAAM,EAACnB,KAAKY,OAAOQ,MAAM,EAAwB;QAAEC,SAAST,MAAM,CAAC,WAAW,KAAK;QAAMU,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,OACAC,MACAC,IACAC,SACAC,MAUAC;;;;wBAdiB;;4BAAMP,MAAMQ,OAAO,CAAC;;;wBAA3B;;4BAAO,cAAuDC,GAAG;;;wBAA3EP,QAAQ,AAAE,cAAiGQ,GAAG,CAAC,SAACC;mCAAMA,EAAE/B,IAAI;;wBAC5HuB,OAAOS,IAAAA,mBAAW,EAACV,OAAOZ;wBAC1Bc,KAAKQ,IAAAA,mBAAW,EAACV,OAAOX;wBACd;;4BAAMsB,IAAAA,oBAAW,EAACb,OAAOC,KAAKa,IAAAA,iBAAO,EAAC1B;;;wBAAhDiB,UAAU;wBACH;;4BAAMU,IAAAA,oBAAQ,EAACf,OAAOG,MAAMC,IAAI;gCAAEZ,UAAAA;gCAAUa,SAAAA;4BAAQ;;;wBAA3DC,OAAO;wBAEb,IAAIb,WAAW,QAAQ;4BACrBuB,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACb;4BAC3B;;;wBACF;wBACA,IAAIA,SAAS,MAAM;4BACjBU,QAAQC,GAAG,CAACzB,WAAW,AAAC,kBAA0B,OAATA,UAAS,WAAS;4BAC3D;;;wBACF;wBACMe,OAAcD,KAAKI,GAAG,CAAC,SAACU,GAAGC;mCAAU;gCAAEA,MAAAA;gCAAMzC,MAAMwC;4BAAE;;wBAC3DE,IAAAA,mBAAS,EAACf,MAAMd;;;;;;QAClB;;AACF;IACA,WAAelB"}

package/dist/cjs/cli/peek.js

@@ -211,11 +211,16 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 var peekCmd = function peekCmd(ctx) {
     var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.peek);
-    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SCOPE, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SCOPE, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
     var _positionals = _sliced_to_array(positionals, 1), pathArg = _positionals[0];
     if (!pathArg) ctx.usageError(usage);
     var format = (0, _sharedts.formatOf)(values);
-    return (0, _sharedts.withDb)(ctx, values.config, function(store, cfg) {
+    return (0, _sharedts.withDb)(ctx, values.config, {
+        noBuild: values['no-build'] === true,
+        requirements: new Set([
+            'core'
+        ])
+    }, function(store, cfg) {
         return _async_to_generator(function() {
             var overrides, result;
             return _ts_generator(this, function(_state) {

package/dist/cjs/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":["peekCmd","ctx","usage","USAGE","name","peek","parse","argv","SCOPE","FORMAT","CONFIG","values","positionals","pathArg","usageError","format","formatOf","withDb","config","store","cfg","overrides","result","scopeOf","console","log","stringifyJson","renderPeek"],"mappings":";;;;+BAkBA;;;eAAA;;;sBAlBqB;wBACqB;uBACpB;wBACkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGxE,IAAMA,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,mBAAKM,eAAK,EAAKC,gBAAM,EAAKC,gBAAM,IAA/EC,SAAwBL,OAAxBK,QAAQC,cAAgBN,OAAhBM;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASZ,IAAIa,UAAU,CAACZ;IAC7B,IAAMa,SAASC,IAAAA,kBAAQ,EAACL;IACxB,OAAOM,IAAAA,gBAAM,EAAChB,KAAKU,OAAOO,MAAM,EAAwB,SAAOC,OAAOC;;gBAC9DC,WACAC;;;;wBADAD,YAAYE,IAAAA,iBAAO,EAACZ;wBACX;;4BAAMN,IAAAA,YAAI,EAACc,OAAOC,KAAKP,SAASQ;;;wBAAzCC,SAAS;wBACfE,QAAQC,GAAG,CAACV,WAAW,SAASW,IAAAA,uBAAa,EAACJ,QAAQ,KAAKK,IAAAA,oBAAU,EAACL;;;;;;QACxE;;AACF;IACA,WAAetB"}
+{"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":["peekCmd","ctx","usage","USAGE","name","peek","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","values","positionals","pathArg","usageError","format","formatOf","withDb","config","noBuild","requirements","Set","store","cfg","overrides","result","scopeOf","console","log","stringifyJson","renderPeek"],"mappings":";;;;+BAmBA;;;eAAA;;;sBAnBqB;wBACqB;uBAEpB;wBAC4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGlF,IAAMA,UAAmB,iBAACC;IACxB,IAAMC,QAAQ,AAAC,UAAqBC,OAAZF,IAAIG,IAAI,EAAC,KAAc,OAAXD,cAAK,CAACE,IAAI;IAC9C,IAAgCC,SAAAA,IAAAA,eAAK,EAACL,IAAIM,IAAI,EAAEL,OAAO,mBAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM,IAA5FC,SAAwBN,OAAxBM,QAAQC,cAAgBP,OAAhBO;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASb,IAAIc,UAAU,CAACb;IAC7B,IAAMc,SAASC,IAAAA,kBAAQ,EAACL;IACxB,OAAOM,IAAAA,gBAAM,EAACjB,KAAKW,OAAOO,MAAM,EAAwB;QAAEC,SAASR,MAAM,CAAC,WAAW,KAAK;QAAMS,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC;;gBAC3JC,WACAC;;;;wBADAD,YAAYE,IAAAA,iBAAO,EAACf;wBACX;;4BAAMP,IAAAA,YAAI,EAACkB,OAAOC,KAAKV,SAASW;;;wBAAzCC,SAAS;wBACfE,QAAQC,GAAG,CAACb,WAAW,SAASc,IAAAA,uBAAa,EAACJ,QAAQ,KAAKK,IAAAA,oBAAU,EAACL;;;;;;QACxE;;AACF;IACA,WAAe1B"}

package/dist/cjs/cli/related.js

@@ -9,8 +9,11 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _relatedts = require("../commands/related.js");
+var _scopets = require("../commands/scope.js");
+var _indexts = require("../config/index.js");
 var _outputts = require("../output/output.js");
-var _indexts = require("./index.js");
+var _opents = require("../store/open.js");
+var _indexts1 = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -20,6 +23,9 @@ function _array_like_to_array(arr, len) {
 function _array_with_holes(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -57,6 +63,11 @@ function _define_property(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
 function _iterable_to_array_limit(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -84,6 +95,9 @@ function _iterable_to_array_limit(arr, i) {
 function _non_iterable_rest() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _object_spread(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
@@ -125,6 +139,9 @@ function _object_spread_props(target, source) {
 function _sliced_to_array(arr, i) {
     return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
 }
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -235,8 +252,8 @@ function _unsupported_iterable_to_array(o, minLen) {
 var RELATED_DEFAULT_K = 5;
 var relatedCmd = function relatedCmd(ctx) {
     var _parseK;
-    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.related);
-    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SCOPE, _sharedts.FORMAT, _sharedts.CONFIG), {
+    var usage = "usage: ".concat(ctx.name, " ").concat(_indexts1.USAGE.related);
+    var _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.SCOPE, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG), {
         k: {
             type: 'string'
         }
@@ -245,18 +262,50 @@ var relatedCmd = function relatedCmd(ctx) {
     if (!pathArg) ctx.usageError(usage);
     var k = (_parseK = (0, _sharedts.parseK)(values.k, ctx.usageError)) !== null && _parseK !== void 0 ? _parseK : RELATED_DEFAULT_K;
     var format = (0, _sharedts.rowFormatOf)(values);
-    return (0, _sharedts.withDb)(ctx, values.config, function(store, cfg) {
+    var noBuild = values['no-build'] === true;
+    return (0, _sharedts.withDb)(ctx, values.config, {
+        noBuild: noBuild,
+        requirements: new Set([
+            'core'
+        ])
+    }, function(store, cfg, build) {
         return _async_to_generator(function() {
-            var overrides;
+            var overrides, path, allowed;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         overrides = (0, _sharedts.scopeOf)(values);
+                        if (!(build && (0, _indexts.resolveSearch)(cfg, overrides).signals.vectors !== undefined)) return [
+                            3,
+                            4
+                        ];
                         return [
                             4,
-                            (0, _relatedts.relatedNotes)(store, cfg, pathArg, overrides, k)
+                            (0, _relatedts.resolveRelatedSeed)(store, pathArg)
                         ];
                     case 1:
+                        path = _state.sent();
+                        return [
+                            4,
+                            (0, _scopets.scopedPaths)(store, cfg, overrides)
+                        ];
+                    case 2:
+                        allowed = _state.sent();
+                        return [
+                            4,
+                            (0, _opents.prepareDocumentEmbeddings)(store, cfg, new Set(_to_consumable_array(allowed).concat([
+                                path
+                            ])))
+                        ];
+                    case 3:
+                        _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        return [
+                            4,
+                            (0, _relatedts.relatedNotes)(store, cfg, pathArg, overrides, k)
+                        ];
+                    case 5:
                         _outputts.printRows.apply(void 0, [
                             _state.sent(),
                             format

package/dist/cjs/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":["RELATED_DEFAULT_K","relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","format","rowFormatOf","withDb","config","store","cfg","overrides","scopeOf","relatedNotes","printRows"],"mappings":";;;;+BAqBA;;;eAAA;;;yBArB6B;wBAEH;uBACJ;wBAC6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGnF,IAAMA,oBAAoB;AAE1B,IAAMC,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,cAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAArGC,SAAwBP,OAAxBO,QAAQC,cAAgBR,OAAhBQ;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAASf,IAAIgB,UAAU,CAACd;IAC7B,IAAMS,KAAIV,UAAAA,IAAAA,gBAAM,EAACY,OAAOF,CAAC,EAAwBX,IAAIgB,UAAU,eAArDf,qBAAAA,UAA0DH;IACpE,IAAMmB,SAASC,IAAAA,qBAAW,EAACL;IAC3B,OAAOM,IAAAA,gBAAM,EAACnB,KAAKa,OAAOO,MAAM,EAAwB,SAAOC,OAAOC;;gBAC9DC;;;;wBAAAA,YAAYC,IAAAA,iBAAO,EAACX;wBACf;;4BAAMY,IAAAA,uBAAY,EAACJ,OAAOC,KAAKP,SAASQ,WAAWZ;;;wBAA9De,mBAAS;4BAAE;4BAAiET;;;;;;;QAC9E;;AACF;IACA,WAAelB"}
+{"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":["RELATED_DEFAULT_K","relatedCmd","ctx","parseK","usage","USAGE","name","related","parse","argv","SCOPE","NO_BUILD","FORMAT","CONFIG","k","type","values","positionals","pathArg","usageError","format","rowFormatOf","noBuild","withDb","config","requirements","Set","store","cfg","build","overrides","path","allowed","scopeOf","resolveSearch","signals","vectors","undefined","resolveRelatedSeed","scopedPaths","prepareDocumentEmbeddings","relatedNotes","printRows"],"mappings":";;;;+BA8BA;;;eAAA;;;yBA9BiD;uBACrB;uBACE;wBAEJ;sBACuC;wBAC3C;wBACuE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG7F,IAAMA,oBAAoB;AAE1B,IAAMC,aAAsB,oBAACC;QAKjBC;IAJV,IAAMC,QAAQ,AAAC,UAAqBC,OAAZH,IAAII,IAAI,EAAC,KAAiB,OAAdD,eAAK,CAACE,OAAO;IACjD,IAAgCC,SAAAA,IAAAA,eAAK,EAACN,IAAIO,IAAI,EAAEL,OAAO,wCAAKM,eAAK,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;QAAEC,GAAG;YAAEC,MAAM;QAAS;SAAlHC,SAAwBR,OAAxBQ,QAAQC,cAAgBT,OAAhBS;IAChB,IAAkBA,gCAAAA,iBAAXC,UAAWD;IAClB,IAAI,CAACC,SAAShB,IAAIiB,UAAU,CAACf;IAC7B,IAAMU,KAAIX,UAAAA,IAAAA,gBAAM,EAACa,OAAOF,CAAC,EAAwBZ,IAAIiB,UAAU,eAArDhB,qBAAAA,UAA0DH;IACpE,IAAMoB,SAASC,IAAAA,qBAAW,EAACL;IAC3B,IAAMM,UAAUN,MAAM,CAAC,WAAW,KAAK;IACvC,OAAOO,IAAAA,gBAAM,EAACrB,KAAKc,OAAOQ,MAAM,EAAwB;QAAEF,SAAAA;QAASG,cAAc,IAAIC,IAAsB;YAAC;SAAO;IAAE,GAAG,SAAOC,OAAOC,KAAKC;;gBACnIC,WAEEC,MACAC;;;;wBAHFF,YAAYG,IAAAA,iBAAO,EAACjB;6BACtBa,CAAAA,SAASK,IAAAA,sBAAa,EAACN,KAAKE,WAAWK,OAAO,CAACC,OAAO,KAAKC,SAAQ,GAAnER;;;;wBACW;;4BAAMS,IAAAA,6BAAkB,EAACX,OAAOT;;;wBAAvCa,OAAO;wBACG;;4BAAMQ,IAAAA,oBAAW,EAACZ,OAAOC,KAAKE;;;wBAAxCE,UAAU;wBAChB;;4BAAMQ,IAAAA,iCAAyB,EAACb,OAAOC,KAAK,IAAIF,IAAI,AAAC,qBAAGM;gCAASD;;;;wBAAjE;;;wBAES;;4BAAMU,IAAAA,uBAAY,EAACd,OAAOC,KAAKV,SAASY,WAAWhB;;;wBAA9D4B,mBAAS;4BAAE;4BAAiEtB;;;;;;;QAC9E;;AACF;IACA,WAAenB"}

package/dist/cjs/cli/search.js

@@ -8,9 +8,12 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+var _scopets = require("../commands/scope.js");
 var _searchts = require("../commands/search.js");
+var _indexts = require("../config/index.js");
 var _outputts = require("../output/output.js");
-var _indexts = require("./index.js");
+var _opents = require("../store/open.js");
+var _indexts1 = require("./index.js");
 var _sharedts = require("./shared.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -211,40 +214,76 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 var searchCmd = function searchCmd(ctx) {
     return _async_to_generator(function() {
-        var usage, _parse, values, positionals, _positionals, terms, k, snippetCharLimit, snippetCountLimit, format;
+        var usage, _parse, values, positionals, _positionals, terms, k, snippetCharLimit, snippetCountLimit, format, overrides, noBuild;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.search);
-                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
+                    usage = "usage: ".concat(ctx.name, " ").concat(_indexts1.USAGE.search);
+                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread({}, _sharedts.SEARCH_FLAGS, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG)), values = _parse.values, positionals = _parse.positionals;
                     _positionals = _sliced_to_array(positionals, 1), terms = _positionals[0];
                     if (!terms) ctx.usageError(usage);
                     k = (0, _sharedts.parseK)(values.k, ctx.usageError);
                     snippetCharLimit = (0, _sharedts.parseSnippetCharLimit)(values['snippet-char-limit'], ctx.usageError);
                     snippetCountLimit = (0, _sharedts.parseSnippetCountLimit)(values['snippet-count-limit'], ctx.usageError);
                     format = (0, _sharedts.rowFormatOf)(values);
+                    overrides = _object_spread({
+                        k: k,
+                        snippetCharLimit: snippetCharLimit,
+                        snippetCountLimit: snippetCountLimit
+                    }, (0, _sharedts.scopeOf)(values));
+                    noBuild = values['no-build'] === true;
                     return [
                         4,
-                        (0, _sharedts.withDb)(ctx, values.config, function(store, cfg) {
+                        (0, _sharedts.withDb)(ctx, values.config, {
+                            noBuild: noBuild,
+                            requirements: function requirements(cfg) {
+                                var signals = (0, _indexts.resolveSearch)(cfg, overrides).signals;
+                                var requirements = new Set([
+                                    'core'
+                                ]);
+                                if (signals.words !== undefined) requirements.add('lexical');
+                                return requirements;
+                            }
+                        }, function(store, cfg, build) {
                             return _async_to_generator(function() {
+                                var _tmp;
                                 return _ts_generator(this, function(_state) {
                                     switch(_state.label){
                                         case 0:
+                                            if (!(build && (0, _indexts.resolveSearch)(cfg, overrides).signals.vectors !== undefined)) return [
+                                                3,
+                                                3
+                                            ];
+                                            _tmp = [
+                                                store,
+                                                cfg
+                                            ];
                                             return [
                                                 4,
-                                                (0, _searchts.search)(store, cfg, terms, _object_spread({
-                                                    k: k,
-                                                    snippetCharLimit: snippetCharLimit,
-                                                    snippetCountLimit: snippetCountLimit
-                                                }, (0, _sharedts.scopeOf)(values)))
+                                                (0, _scopets.scopedPaths)(store, cfg, overrides)
                                             ];
                                         case 1:
                                             return [
-                                                2,
-                                                _outputts.printRows.apply(void 0, [
-                                                    _state.sent(),
-                                                    format
-                                                ])
+                                                4,
+                                                _opents.prepareDocumentEmbeddings.apply(void 0, _tmp.concat([
+                                                    _state.sent()
+                                                ]))
+                                            ];
+                                        case 2:
+                                            _state.sent();
+                                            _state.label = 3;
+                                        case 3:
+                                            return [
+                                                4,
+                                                (0, _searchts.search)(store, cfg, terms, overrides)
+                                            ];
+                                        case 4:
+                                            _outputts.printRows.apply(void 0, [
+                                                _state.sent(),
+                                                format
+                                            ]);
+                                            return [
+                                                2
                                             ];
                                     }
                                 });

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/search.ts"],"sourcesContent":["import { search } from '../commands/search.ts';\nimport { printRows } from '../output/output.ts';\nimport { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, SEARCH_FLAGS, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst searchCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.search}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...FORMAT, ...CONFIG });\n  const [terms] = positionals;\n  if (!terms) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError);\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 format = rowFormatOf(values);\n  await withDb(ctx, values.config as string | undefined, async (store, cfg) => printRows(await search(store, cfg, terms, { k, snippetCharLimit, snippetCountLimit, ...scopeOf(values) }), format));\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","usage","parse","values","positionals","terms","k","snippetCharLimit","snippetCountLimit","format","USAGE","name","search","argv","SEARCH_FLAGS","FORMAT","CONFIG","usageError","parseK","parseSnippetCharLimit","parseSnippetCountLimit","rowFormatOf","withDb","config","store","cfg","scopeOf","printRows"],"mappings":";;;;+BAiBA;;;eAAA;;;wBAjBuB;wBACG;uBACJ;wBACmH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGzI,IAAMA,YAAqB,mBAAOC;;YAC1BC,OAC0BC,QAAxBC,QAAQC,aACAA,cAATC,OAEDC,GACAC,kBACAC,mBACAC;;;;oBAPAR,QAAQ,AAAC,UAAqBS,OAAZV,IAAIW,IAAI,EAAC,KAAgB,OAAbD,cAAK,CAACE,MAAM;oBAChBV,SAAAA,IAAAA,eAAK,EAACF,IAAIa,IAAI,EAAEZ,OAAO,mBAAKa,sBAAY,EAAKC,gBAAM,EAAKC,gBAAM,IAAtFb,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACAA,gCAAAA,iBAATC,QAASD;oBAChB,IAAI,CAACC,OAAOL,IAAIiB,UAAU,CAAChB;oBACrBK,IAAIY,IAAAA,gBAAM,EAACf,OAAOG,CAAC,EAAwBN,IAAIiB,UAAU;oBACzDV,mBAAmBY,IAAAA,+BAAqB,EAAChB,MAAM,CAAC,qBAAqB,EAAwBH,IAAIiB,UAAU;oBAC3GT,oBAAoBY,IAAAA,gCAAsB,EAACjB,MAAM,CAAC,sBAAsB,EAAwBH,IAAIiB,UAAU;oBAC9GR,SAASY,IAAAA,qBAAW,EAAClB;oBAC3B;;wBAAMmB,IAAAA,gBAAM,EAACtB,KAAKG,OAAOoB,MAAM,EAAwB,SAAOC,OAAOC;;;;;4CAAkB;;gDAAMb,IAAAA,gBAAM,EAACY,OAAOC,KAAKpB,OAAO;oDAAEC,GAAAA;oDAAGC,kBAAAA;oDAAkBC,mBAAAA;mDAAsBkB,IAAAA,iBAAO,EAACvB;;;;;gDAA/FwB,mBAAS;oDAAC;oDAAiGlB;;;;;;;;;oBAAxL;;;;;;IACF;;IACA,WAAeV"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/search.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 { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, parseK, parseSnippetCharLimit, parseSnippetCountLimit, rowFormatOf, SEARCH_FLAGS, scopeOf, withDb } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst searchCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.search}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...SEARCH_FLAGS, ...NO_BUILD, ...FORMAT, ...CONFIG });\n  const [terms] = positionals;\n  if (!terms) ctx.usageError(usage);\n  const k = parseK(values.k as string | undefined, ctx.usageError);\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 format = rowFormatOf(values);\n  const overrides = { k, snippetCharLimit, snippetCountLimit, ...scopeOf(values) };\n  const noBuild = values['no-build'] === true;\n  await withDb(\n    ctx,\n    values.config as string | undefined,\n    {\n      noBuild,\n      requirements: (cfg) => {\n        const signals = resolveSearch(cfg, 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, cfg, build) => {\n      if (build && resolveSearch(cfg, overrides).signals.vectors !== undefined) {\n        await prepareDocumentEmbeddings(store, cfg, await scopedPaths(store, cfg, overrides));\n      }\n      printRows(await search(store, cfg, terms, overrides), format);\n    }\n  );\n};\nexport default searchCmd;\n"],"names":["searchCmd","ctx","usage","parse","values","positionals","terms","k","snippetCharLimit","snippetCountLimit","format","overrides","noBuild","USAGE","name","search","argv","SEARCH_FLAGS","NO_BUILD","FORMAT","CONFIG","usageError","parseK","parseSnippetCharLimit","parseSnippetCountLimit","rowFormatOf","scopeOf","withDb","config","requirements","cfg","signals","resolveSearch","Set","words","undefined","add","store","build","vectors","scopedPaths","prepareDocumentEmbeddings","printRows"],"mappings":";;;;+BAwCA;;;eAAA;;;uBAxC4B;wBACL;uBACO;wBACJ;sBACuC;wBAC3C;wBAC6H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGnJ,IAAMA,YAAqB,mBAAOC;;YAC1BC,OAC0BC,QAAxBC,QAAQC,aACAA,cAATC,OAEDC,GACAC,kBACAC,mBACAC,QACAC,WACAC;;;;oBATAV,QAAQ,AAAC,UAAqBW,OAAZZ,IAAIa,IAAI,EAAC,KAAgB,OAAbD,eAAK,CAACE,MAAM;oBAChBZ,SAAAA,IAAAA,eAAK,EAACF,IAAIe,IAAI,EAAEd,OAAO,mBAAKe,sBAAY,EAAKC,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM,IAAnGhB,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACAA,gCAAAA,iBAATC,QAASD;oBAChB,IAAI,CAACC,OAAOL,IAAIoB,UAAU,CAACnB;oBACrBK,IAAIe,IAAAA,gBAAM,EAAClB,OAAOG,CAAC,EAAwBN,IAAIoB,UAAU;oBACzDb,mBAAmBe,IAAAA,+BAAqB,EAACnB,MAAM,CAAC,qBAAqB,EAAwBH,IAAIoB,UAAU;oBAC3GZ,oBAAoBe,IAAAA,gCAAsB,EAACpB,MAAM,CAAC,sBAAsB,EAAwBH,IAAIoB,UAAU;oBAC9GX,SAASe,IAAAA,qBAAW,EAACrB;oBACrBO,YAAY;wBAAEJ,GAAAA;wBAAGC,kBAAAA;wBAAkBC,mBAAAA;uBAAsBiB,IAAAA,iBAAO,EAACtB;oBACjEQ,UAAUR,MAAM,CAAC,WAAW,KAAK;oBACvC;;wBAAMuB,IAAAA,gBAAM,EACV1B,KACAG,OAAOwB,MAAM,EACb;4BACEhB,SAAAA;4BACAiB,cAAc,SAAdA,aAAeC;gCACb,IAAMC,UAAUC,IAAAA,sBAAa,EAACF,KAAKnB,WAAWoB,OAAO;gCACrD,IAAMF,eAAe,IAAII,IAAsB;oCAAC;iCAAO;gCACvD,IAAIF,QAAQG,KAAK,KAAKC,WAAWN,aAAaO,GAAG,CAAC;gCAClD,OAAOP;4BACT;wBACF,GACA,SAAOQ,OAAOP,KAAKQ;;;;;;iDACbA,CAAAA,SAASN,IAAAA,sBAAa,EAACF,KAAKnB,WAAWoB,OAAO,CAACQ,OAAO,KAAKJ,SAAQ,GAAnEG;;;;;gDAC8BD;gDAAOP;;4CAAK;;gDAAMU,IAAAA,oBAAW,EAACH,OAAOP,KAAKnB;;;4CAA1E;;gDAAM8B,iCAAyB;oDAAa;;;;4CAA5C;;;4CAEQ;;gDAAM1B,IAAAA,gBAAM,EAACsB,OAAOP,KAAKxB,OAAOK;;;4CAA1C+B,mBAAS;gDAAC;gDAA4ChC;;;;;;;4BACxD;;;;oBAjBF;;;;;;IAmBF;;IACA,WAAeV"}

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

@@ -1,10 +1,11 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
 import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
 import type { RowFormat } from '../output/output.js';
-import type { OpenResult } from '../store/index.js';
+import type { BuildRequirement, OpenResult } from '../store/open.js';
 import type { Ctx } from './types.js';
 export declare const FORMAT: ParseArgsOptionsConfig;
 export declare const CONFIG: ParseArgsOptionsConfig;
+export declare const NO_BUILD: ParseArgsOptionsConfig;
 export declare const SCOPE: ParseArgsOptionsConfig;
 export declare const SEARCH_FLAGS: ParseArgsOptionsConfig;
 type Values = Record<string, string | boolean | string[] | undefined>;
@@ -19,6 +20,11 @@ export declare function parseK(k: string | undefined, usageError: (message: stri
 export declare function parseSnippetCharLimit(value: string | undefined, usageError: (message: string) => never): number | undefined;
 export declare function parseSnippetCountLimit(value: string | undefined, usageError: (message: string) => never): number | undefined;
 export declare function printWarnings(warnings: string[]): void;
-export declare function withDb(ctx: Ctx, configPath: string | undefined, fn: (store: OpenResult['store'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
-export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, preset?: string): Promise<void>;
+export interface DbOpenOptions {
+    noBuild: boolean;
+    requirements: ReadonlySet<BuildRequirement> | ((cfg: ResolvedConfig) => ReadonlySet<BuildRequirement>);
+}
+export declare function withResolvedDb(cfg: ResolvedConfig, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void>;
+export declare function withDb(ctx: Ctx, configPath: string | undefined, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void>;
+export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, noBuild: boolean, preset?: string): Promise<void>;
 export {};

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

@@ -1,10 +1,11 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
 import type { ResolvedConfig, SearchOverrides } from '../config/index.js';
 import type { RowFormat } from '../output/output.js';
-import type { OpenResult } from '../store/index.js';
+import type { BuildRequirement, OpenResult } from '../store/open.js';
 import type { Ctx } from './types.js';
 export declare const FORMAT: ParseArgsOptionsConfig;
 export declare const CONFIG: ParseArgsOptionsConfig;
+export declare const NO_BUILD: ParseArgsOptionsConfig;
 export declare const SCOPE: ParseArgsOptionsConfig;
 export declare const SEARCH_FLAGS: ParseArgsOptionsConfig;
 type Values = Record<string, string | boolean | string[] | undefined>;
@@ -19,6 +20,11 @@ export declare function parseK(k: string | undefined, usageError: (message: stri
 export declare function parseSnippetCharLimit(value: string | undefined, usageError: (message: string) => never): number | undefined;
 export declare function parseSnippetCountLimit(value: string | undefined, usageError: (message: string) => never): number | undefined;
 export declare function printWarnings(warnings: string[]): void;
-export declare function withDb(ctx: Ctx, configPath: string | undefined, fn: (store: OpenResult['store'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void>;
-export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, preset?: string): Promise<void>;
+export interface DbOpenOptions {
+    noBuild: boolean;
+    requirements: ReadonlySet<BuildRequirement> | ((cfg: ResolvedConfig) => ReadonlySet<BuildRequirement>);
+}
+export declare function withResolvedDb(cfg: ResolvedConfig, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void>;
+export declare function withDb(ctx: Ctx, configPath: string | undefined, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void>;
+export declare function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, noBuild: boolean, preset?: string): Promise<void>;
 export {};