sensemaking 0.8.0 → 0.9.0

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can be\n// embed-enabled with nothing embedded yet -- reported here because a fast `rebuild` on an\n// embed tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    findDefaultWhere: cfg.defaults?.find?.where ?? null,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (ctx.format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    const off = features.off.length > 0 ? ` · off: ${features.off.map((name) => `${name} (features.${name})`).join(', ')}` : '';\n    console.log(`features: ${features.on.join(', ')}${off}`);\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on first --semantic query)` : ''}`);\n    if (result.findDefaultWhere) console.log(`find default scope: ${result.findDefaultWhere} (--where replaces it)`);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`busy_timeout: ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","cfg","resolveConfig","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","findDefaultWhere","defaults","find","where","watcherHeartbeatSecondsAgo","Math","round","Date","now","parse","format","console","log","JSON","stringify","length","map","name","join","embedded","pending","close"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/status.ts"],"sourcesContent":["import { presetCoverage } from '../commands.ts';\nimport { embedConfig, featureStates } from '../config.ts';\nimport { docCount, getMeta, open } from '../db.ts';\nimport { featuresLine, presetsLines } from '../output.ts';\nimport { printWarnings } from './shared.ts';\nimport type { Command } from './types.ts';\n\n// Vectors are computed on the first semantic query, not at reconcile, so a tree can have a\n// semantic-on preset with nothing embedded yet -- reported here because a fast `rebuild` on\n// such a tree otherwise reads as \"the feature isn't on\".\nfunction vectorState(db: ReturnType<typeof open>['db']): { embedded: number; pending: number } | null {\n  try {\n    const row = db.prepare('SELECT COUNT(vector) AS embedded, COUNT(*) - COUNT(vector) AS pending FROM embeddings').get() as { embedded: number; pending: number };\n    return row;\n  } catch {\n    return null;\n  }\n}\n\nconst status: Command = (ctx) => {\n  const cfg = ctx.resolveConfig();\n  const { db, dbPath, warnings } = open(cfg);\n  printWarnings(warnings);\n\n  const features = featureStates(cfg);\n  const e = embedConfig(cfg);\n  const vectors = e ? vectorState(db) : null;\n  const presets = presetCoverage(db, cfg);\n  const heartbeat = getMeta(db, 'watch_heartbeat');\n  // Derived at open() (F): 3x the largest reconcile this cache has ever held its write\n  // transaction for, floored at 30s -- read back from the connection rather than\n  // recomputed here, so this always reports what open() actually set.\n  const busyTimeoutMs = (db.prepare('PRAGMA busy_timeout').get() as { timeout: number }).timeout;\n  const result = {\n    db: dbPath,\n    docs: docCount(db),\n    features: features.on,\n    featuresOff: features.off,\n    embed: e ? { type: e.type, model: e.model, ...(vectors ?? {}) } : null,\n    presets,\n    watcherHeartbeatSecondsAgo: heartbeat ? Math.round((Date.now() - Date.parse(heartbeat)) / 1000) : null,\n    busyTimeoutMs,\n  };\n\n  if (ctx.format === 'json') {\n    console.log(JSON.stringify(result, null, 2));\n  } else {\n    console.log(`db: ${result.db}`);\n    console.log(`docs: ${result.docs}`);\n    console.log(featuresLine(features));\n    if (e) console.log(`embed: ${e.type} ${e.model}${vectors ? ` (vectors: ${vectors.embedded} embedded, ${vectors.pending} pending — embedded on the first semantic search)` : ''}`);\n    for (const line of presetsLines(presets)) console.log(line);\n    console.log(result.watcherHeartbeatSecondsAgo === null ? 'watcher: no watcher' : `watcher: last heartbeat ${result.watcherHeartbeatSecondsAgo}s ago`);\n    console.log(`busy_timeout: ${result.busyTimeoutMs}ms (derived: 3x the largest reconcile this cache has recorded, floored at 30000ms)`);\n  }\n  db.close();\n};\nexport default status;\n"],"names":["vectorState","db","row","prepare","get","status","ctx","cfg","resolveConfig","open","dbPath","warnings","printWarnings","features","featureStates","e","embedConfig","vectors","presets","presetCoverage","heartbeat","getMeta","busyTimeoutMs","timeout","result","docs","docCount","on","featuresOff","off","embed","type","model","watcherHeartbeatSecondsAgo","Math","round","Date","now","parse","format","console","log","JSON","stringify","featuresLine","embedded","pending","presetsLines","line","close"],"mappings":";;;;+BAyDA;;;eAAA;;;0BAzD+B;wBACY;oBACH;wBACG;wBACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG9B,2FAA2F;AAC3F,4FAA4F;AAC5F,yDAAyD;AACzD,SAASA,YAAYC,EAAiC;IACpD,IAAI;QACF,IAAMC,MAAMD,GAAGE,OAAO,CAAC,yFAAyFC,GAAG;QACnH,OAAOF;IACT,EAAE,eAAM;QACN,OAAO;IACT;AACF;AAEA,IAAMG,SAAkB,gBAACC;IACvB,IAAMC,MAAMD,IAAIE,aAAa;IAC7B,IAAiCC,QAAAA,IAAAA,UAAI,EAACF,MAA9BN,KAAyBQ,MAAzBR,IAAIS,SAAqBD,MAArBC,QAAQC,WAAaF,MAAbE;IACpBC,IAAAA,uBAAa,EAACD;IAEd,IAAME,WAAWC,IAAAA,uBAAa,EAACP;IAC/B,IAAMQ,IAAIC,IAAAA,qBAAW,EAACT;IACtB,IAAMU,UAAUF,IAAIf,YAAYC,MAAM;IACtC,IAAMiB,UAAUC,IAAAA,0BAAc,EAAClB,IAAIM;IACnC,IAAMa,YAAYC,IAAAA,aAAO,EAACpB,IAAI;IAC9B,qFAAqF;IACrF,+EAA+E;IAC/E,oEAAoE;IACpE,IAAMqB,gBAAgB,AAACrB,GAAGE,OAAO,CAAC,uBAAuBC,GAAG,GAA2BmB,OAAO;IAC9F,IAAMC,SAAS;QACbvB,IAAIS;QACJe,MAAMC,IAAAA,cAAQ,EAACzB;QACfY,UAAUA,SAASc,EAAE;QACrBC,aAAaf,SAASgB,GAAG;QACzBC,OAAOf,IAAI;YAAEgB,MAAMhB,EAAEgB,IAAI;YAAEC,OAAOjB,EAAEiB,KAAK;WAAMf,oBAAAA,qBAAAA,UAAW,CAAC,KAAO;QAClEC,SAAAA;QACAe,4BAA4Bb,YAAYc,KAAKC,KAAK,CAAC,AAACC,CAAAA,KAAKC,GAAG,KAAKD,KAAKE,KAAK,CAAClB,UAAS,IAAK,QAAQ;QAClGE,eAAAA;IACF;IAEA,IAAIhB,IAAIiC,MAAM,KAAK,QAAQ;QACzBC,QAAQC,GAAG,CAACC,KAAKC,SAAS,CAACnB,QAAQ,MAAM;IAC3C,OAAO;QACLgB,QAAQC,GAAG,CAAC,AAAC,OAAgB,OAAVjB,OAAOvB,EAAE;QAC5BuC,QAAQC,GAAG,CAAC,AAAC,SAAoB,OAAZjB,OAAOC,IAAI;QAChCe,QAAQC,GAAG,CAACG,IAAAA,sBAAY,EAAC/B;QACzB,IAAIE,GAAGyB,QAAQC,GAAG,CAAC,AAAC,UAAmB1B,OAAVA,EAAEgB,IAAI,EAAC,KAAad,OAAVF,EAAEiB,KAAK,EAAiI,OAA9Hf,UAAU,AAAC,cAA2CA,OAA9BA,QAAQ4B,QAAQ,EAAC,eAA6B,OAAhB5B,QAAQ6B,OAAO,EAAC,uDAAqD;YACvK,kCAAA,2BAAA;;YAAL,QAAK,YAAcC,IAAAA,sBAAY,EAAC7B,6BAA3B,SAAA,6BAAA,QAAA,yBAAA;gBAAA,IAAM8B,OAAN;gBAAqCR,QAAQC,GAAG,CAACO;;;YAAjD;YAAA;;;qBAAA,6BAAA;oBAAA;;;oBAAA;0BAAA;;;;QACLR,QAAQC,GAAG,CAACjB,OAAOS,0BAA0B,KAAK,OAAO,wBAAwB,AAAC,2BAA4D,OAAlCT,OAAOS,0BAA0B,EAAC;QAC9IO,QAAQC,GAAG,CAAC,AAAC,iBAAqC,OAArBjB,OAAOF,aAAa,EAAC;IACpD;IACArB,GAAGgD,KAAK;AACV;IACA,WAAe5C"}

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

@@ -7,8 +7,10 @@ export interface Ctx {
         config?: string;
         where?: string;
         k?: string;
+        preset?: string;
+        include?: string[];
         force: boolean;
-        semantic: boolean;
+        lexical: boolean;
     };
     resolveConfig(): ResolvedConfig;
     usageError(message: string): never;

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

@@ -7,8 +7,10 @@ export interface Ctx {
         config?: string;
         where?: string;
         k?: string;
+        preset?: string;
+        include?: string[];
         force: boolean;
-        semantic: boolean;
+        lexical: boolean;
     };
     resolveConfig(): ResolvedConfig;
     usageError(message: string): never;

package/dist/cjs/cli.js

@@ -100,6 +100,10 @@ function _non_iterable_rest() {
 function _to_array(arr) {
     return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -226,11 +230,11 @@ function packageVersion() {
     return 'unknown';
 }
 function usage(name) {
-    return "usage: ".concat(name, " <name> [params...] [--format table|json] [--config path]\n") + "       ".concat(name, ' query "<sql>" [params...]\n') + "       ".concat(name, ' find "<terms>" [--where "<sql>"] [--k n] [--semantic]\n') + "       ".concat(name, " map\n") + "       ".concat(name, " peek <path>\n") + "       ".concat(name, " --list\n") + "       ".concat(name, " init\n") + "       ".concat(name, " watch [--force]\n") + "       ".concat(name, " status\n") + "       ".concat(name, " check\n") + "       ".concat(name, " rebuild\n") + "       ".concat(name, " --version");
+    return "usage: ".concat(name, " <name> [params...] [--format table|json] [--config path]\n") + "       ".concat(name, ' query "<sql>" [params...]\n') + "       ".concat(name, ' search "<terms>" [--preset name] [--include glob ...] [--where "<sql>"] [--k n] [--lexical]\n') + "       ".concat(name, " map\n") + "       ".concat(name, " peek <path>\n") + "       ".concat(name, " --list\n") + "       ".concat(name, " init\n") + "       ".concat(name, " watch [--force]\n") + "       ".concat(name, " status\n") + "       ".concat(name, " check\n") + "       ".concat(name, " rebuild\n") + "       ".concat(name, " --version");
 }
 function cli(argv, name) {
     return _async_to_generator(function() {
-        var values, positionals, ref, ctx, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, _positionals, first, params, load, err;
+        var values, positionals, ref, ctx, queries, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, queryName, entry, isSavedSearch, _positionals, first, params, load, err;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -252,8 +256,16 @@ function cli(argv, name) {
                                 k: {
                                     type: 'string'
                                 },
-                                semantic: {
-                                    type: 'boolean'
+                                preset: {
+                                    type: 'string'
+                                },
+                                include: {
+                                    type: 'string',
+                                    multiple: true
+                                },
+                                lexical: {
+                                    type: 'boolean',
+                                    default: false
                                 },
                                 list: {
                                     type: 'boolean',
@@ -327,7 +339,9 @@ function cli(argv, name) {
                         try {
                             for(_iterator = Object.keys(queries).sort()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                                 queryName = _step.value;
-                                console.log(typeof queries[queryName] === 'string' ? queryName : "".concat(queryName, "  (find)"));
+                                entry = queries[queryName];
+                                isSavedSearch = (typeof entry === "undefined" ? "undefined" : _type_of(entry)) === 'object' && entry !== null && 'search' in entry;
+                                console.log(isSavedSearch ? "".concat(queryName, "  (search)") : queryName);
                             }
                         } catch (err) {
                             _didIteratorError = true;
@@ -352,6 +366,12 @@ function cli(argv, name) {
                         console.error(usage(name));
                         process.exit(2);
                     }
+                    // find -> search (breaking rename): one release of a pointer instead of "unknown query".
+                    if (first === 'find') {
+                        console.error("".concat(name, ": find is now search"));
+                        console.error(usage(name));
+                        process.exit(2);
+                    }
                     load = _indexts.COMMANDS[first];
                     if (!load) return [
                         3,

package/dist/cjs/cli.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} find \"<terms>\" [--where \"<sql>\"] [--k n] [--semantic]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} check\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  let values: Record<string, string | boolean | undefined>;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: {\n        format: { type: 'string', default: 'table' },\n        config: { type: 'string' },\n        where: { type: 'string' },\n        k: { type: 'string' },\n        semantic: { type: 'boolean' },\n        list: { type: 'boolean', default: false },\n        force: { type: 'boolean', default: false },\n        version: { type: 'boolean', default: false, short: 'v' },\n        help: { type: 'boolean', default: false, short: 'h' },\n      },\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  if (values.version) {\n    console.log(`v${packageVersion()}`);\n    return;\n  }\n  if (values.help) {\n    console.log(usage(name));\n    return;\n  }\n\n  const ctx: Ctx = {\n    name,\n    rest: positionals.slice(1),\n    format: values.format === 'json' ? 'json' : 'table',\n    values: values as Ctx['values'],\n    resolveConfig() {\n      const cfg = loadConfig(values.config as string | undefined);\n      if (cfg.migratedFrom !== undefined) {\n        console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\n      }\n      if (cfg.unknownKeys !== undefined) {\n        console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n      }\n      return cfg;\n    },\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    if (values.list) {\n      const queries = ctx.resolveConfig().queries;\n      for (const queryName of Object.keys(queries).sort()) {\n        console.log(typeof queries[queryName] === 'string' ? queryName : `${queryName}  (find)`);\n      }\n      return;\n    }\n\n    const [first, ...params] = positionals;\n    if (!first) {\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first, params);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","argv","values","positionals","ctx","queries","queryName","first","params","err","parseArgs","args","options","format","type","default","config","where","k","semantic","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","unknownKeys","join","usageError","Object","keys","sort","COMMANDS"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli.ts"],"sourcesContent":["import { createRequire } from 'node:module';\nimport { parseArgs } from 'node:util';\nimport { COMMANDS } from './cli/index.ts';\nimport type { Ctx } from './cli/types.ts';\nimport { loadConfig, SUPPORTED_CONFIG_VERSION } from './config.ts';\n\n// Parsing and dispatch only. Commands live in src/cli/, one file each, lazy-loaded --\n// nothing tree- or dependency-heavy may be imported at the top of this file.\n\n// Works from dist/cjs and dist/esm alike: walk up past the dist type-marker package.json.\nfunction packageVersion(): string {\n  const load = createRequire(import.meta.url);\n  for (const rel of ['../package.json', '../../package.json', '../../../package.json']) {\n    try {\n      const pkg = load(rel) as { name?: string; version?: string };\n      if (pkg.name === 'sensemaking' && pkg.version) return pkg.version;\n    } catch {}\n  }\n  return 'unknown';\n}\n\nfunction usage(name: string): string {\n  return (\n    `usage: ${name} <name> [params...] [--format table|json] [--config path]\\n` +\n    `       ${name} query \"<sql>\" [params...]\\n` +\n    `       ${name} search \"<terms>\" [--preset name] [--include glob ...] [--where \"<sql>\"] [--k n] [--lexical]\\n` +\n    `       ${name} map\\n` +\n    `       ${name} peek <path>\\n` +\n    `       ${name} --list\\n` +\n    `       ${name} init\\n` +\n    `       ${name} watch [--force]\\n` +\n    `       ${name} status\\n` +\n    `       ${name} check\\n` +\n    `       ${name} rebuild\\n` +\n    `       ${name} --version`\n  );\n}\n\n// Thrown errors -> exit 1 with the message verbatim; usage errors exit 2 directly.\nexport default async function cli(argv: string[], name: string): Promise<void> {\n  let values: Record<string, string | boolean | string[] | undefined>;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: {\n        format: { type: 'string', default: 'table' },\n        config: { type: 'string' },\n        where: { type: 'string' },\n        k: { type: 'string' },\n        preset: { type: 'string' },\n        include: { type: 'string', multiple: true },\n        lexical: { type: 'boolean', default: false },\n        list: { type: 'boolean', default: false },\n        force: { type: 'boolean', default: false },\n        version: { type: 'boolean', default: false, short: 'v' },\n        help: { type: 'boolean', default: false, short: 'h' },\n      },\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage(name));\n    process.exit(2);\n  }\n\n  if (values.version) {\n    console.log(`v${packageVersion()}`);\n    return;\n  }\n  if (values.help) {\n    console.log(usage(name));\n    return;\n  }\n\n  const ctx: Ctx = {\n    name,\n    rest: positionals.slice(1),\n    format: values.format === 'json' ? 'json' : 'table',\n    values: values as Ctx['values'],\n    resolveConfig() {\n      const cfg = loadConfig(values.config as string | undefined);\n      if (cfg.migratedFrom !== undefined) {\n        console.warn(`${name}: migrated ${cfg.configPath} from config version ${cfg.migratedFrom} to ${SUPPORTED_CONFIG_VERSION}`);\n      }\n      if (cfg.unknownKeys !== undefined) {\n        console.warn(`${name}: ${cfg.configPath} sets ${cfg.unknownKeys.join(', ')}, which this build does not read (no effect); see schema.json for the keys it does`);\n      }\n      return cfg;\n    },\n    usageError(message) {\n      console.error(message);\n      process.exit(2);\n    },\n  };\n\n  try {\n    if (values.list) {\n      const queries = ctx.resolveConfig().queries;\n      for (const queryName of Object.keys(queries).sort()) {\n        const entry = queries[queryName];\n        const isSavedSearch = typeof entry === 'object' && entry !== null && 'search' in entry;\n        console.log(isSavedSearch ? `${queryName}  (search)` : queryName);\n      }\n      return;\n    }\n\n    const [first, ...params] = positionals;\n    if (!first) {\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    // find -> search (breaking rename): one release of a pointer instead of \"unknown query\".\n    if (first === 'find') {\n      console.error(`${name}: find is now search`);\n      console.error(usage(name));\n      process.exit(2);\n    }\n\n    const load = COMMANDS[first];\n    if (load) await (await load()).default(ctx);\n    else await (await import('./cli/named.ts')).default(ctx, first, params);\n  } catch (err) {\n    console.error((err as Error).message);\n    process.exit(1);\n  }\n}\n"],"names":["cli","packageVersion","load","createRequire","rel","pkg","name","version","usage","argv","values","positionals","ctx","queries","queryName","entry","isSavedSearch","first","params","err","parseArgs","args","options","format","type","default","config","where","k","preset","include","multiple","lexical","list","force","short","help","allowPositionals","console","error","message","process","exit","log","rest","slice","resolveConfig","cfg","loadConfig","migratedFrom","undefined","warn","configPath","SUPPORTED_CONFIG_VERSION","unknownKeys","join","usageError","Object","keys","sort","COMMANDS"],"mappings":"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"}

package/dist/cjs/commands.d.cts

@@ -1,12 +1,20 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { FeatureName, ResolvedConfig } from './config.js';
 import type { Row } from './output.js';
-export interface FindOptions {
+export interface SearchOptions {
     k?: number;
     where?: string;
+    preset?: string;
+    include?: string[];
     semantic?: boolean;
 }
-export declare function find(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: FindOptions): Promise<Row[]>;
+export declare function search(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export interface PresetCoverage {
+    name: string;
+    files: number;
+    embedded: number;
+}
+export declare function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[];
 export interface TreeMap {
     docs: {
         count: number;
@@ -18,6 +26,7 @@ export interface TreeMap {
         on: FeatureName[];
         off: FeatureName[];
     };
+    presets: PresetCoverage[];
     hubs: Row[];
     recent: Row[];
 }

package/dist/cjs/commands.d.ts

@@ -1,12 +1,20 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { FeatureName, ResolvedConfig } from './config.js';
 import type { Row } from './output.js';
-export interface FindOptions {
+export interface SearchOptions {
     k?: number;
     where?: string;
+    preset?: string;
+    include?: string[];
     semantic?: boolean;
 }
-export declare function find(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: FindOptions): Promise<Row[]>;
+export declare function search(db: DatabaseSync, cfg: ResolvedConfig, terms: string, opts?: SearchOptions): Promise<Row[]>;
+export interface PresetCoverage {
+    name: string;
+    files: number;
+    embedded: number;
+}
+export declare function presetCoverage(db: DatabaseSync, cfg: ResolvedConfig): PresetCoverage[];
 export interface TreeMap {
     docs: {
         count: number;
@@ -18,6 +26,7 @@ export interface TreeMap {
         on: FeatureName[];
         off: FeatureName[];
     };
+    presets: PresetCoverage[];
     hubs: Row[];
     recent: Row[];
 }

package/dist/cjs/commands.js

@@ -9,14 +9,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get find () {
-        return find;
-    },
     get mapTree () {
         return mapTree;
     },
     get peek () {
         return peek;
+    },
+    get presetCoverage () {
+        return presetCoverage;
+    },
+    get search () {
+        return search;
     }
 });
 var _nodefs = require("node:fs");
@@ -219,7 +222,7 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-// The three layer commands: mapTree (orient), find (locate), peek (structure).
+// The three commands: mapTree (orient), search (locate), peek (structure).
 // Each returns data; cli.ts renders. All of them degrade when a feature is off.
 var WEIGHTED_BM25 = 'bm25(content, 10.0, 5.0, 1.0)';
 var RRF_K = 60;
@@ -363,23 +366,63 @@ function lineRangeFor(db, path, line) {
     var row = db.prepare('SELECT start_line, end_line FROM sections WHERE "path" = ? AND start_line <= ? AND end_line >= ? ORDER BY start_line DESC LIMIT 1').get(path, line, line);
     return row ? "L".concat(row.start_line, "-").concat(row.end_line) : null;
 }
-function find(_0, _1, _2) {
+// node:path's matchesGlob is experimental (stable behind an unstable-API flag) as of the
+// engines floor (Node >=22.16); scope filtering only ever needs single-pattern matching, so
+// it's used here in JS rather than pulling fast-glob's directory walk into the query path.
+function inScope(path, include, exclude) {
+    if (!include.some(function(g) {
+        return (0, _nodepath.matchesGlob)(path, g);
+    })) return false;
+    if (exclude === null || exclude === void 0 ? void 0 : exclude.some(function(g) {
+        return (0, _nodepath.matchesGlob)(path, g);
+    })) return false;
+    return true;
+}
+function scopeHasEmbeddings(db, cfg, scopedPaths) {
+    if (!(0, _configts.anyPresetEmbeds)(cfg)) return false; // the embeddings table doesn't exist at all in this case
+    var rows = db.prepare('SELECT DISTINCT "path" FROM embeddings').all();
+    return rows.some(function(r) {
+        return scopedPaths.has(r.path);
+    });
+}
+function search(_0, _1, _2) {
     return _async_to_generator(function(db, cfg, terms) {
-        var opts, _opts_k, _opts_where, _hits_get, _chunkLines_get, _chunkSimilarity_get, _cfg_defaults_find, _cfg_defaults, k, fetch, scope, whereJoin, whereCond, matchSql, matchRows, hits, oversized, candidates, edges, linked, nodes, seeds, ranked, chunkLines, chunkSimilarity, vec, insert, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, c, where, similarityCol, rows, bareTerms, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, row, text, _computeExcerpt, excerpt, offset;
+        var opts, _hits_get, _chunkLines_get, _chunkSimilarity_get, effective, k, include, exclude, allPaths, scopedPaths, scopeActive, fetch, semanticEnabled, scope, whereJoin, whereCond, matchSql, matchRows, hits, oversized, candidates, edges, linked, seeds, ranked, chunkLines, chunkSimilarity, vec, insert, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, path, c, where, similarityCol, rows, bareTerms, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, row, text, _computeExcerpt, excerpt, offset;
         var _arguments = arguments;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     opts = _arguments.length > 3 && _arguments[3] !== void 0 ? _arguments[3] : {};
-                    k = (_opts_k = opts.k) !== null && _opts_k !== void 0 ? _opts_k : 10;
-                    fetch = Math.max(k * 3, 30);
+                    effective = (0, _configts.resolveSearch)(cfg, opts);
+                    k = effective.k, include = effective.include, exclude = effective.exclude;
+                    allPaths = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
+                        return r.path;
+                    });
+                    // A preset scope reads preset_files -- the coverage reconcile actually indexed with
+                    // (fast-glob semantics); re-matching globs here with node:path's matchesGlob could
+                    // silently disagree with it. Ad-hoc --include has no persisted coverage, so only that
+                    // path pays the JS glob match.
+                    scopedPaths = opts.include ? new Set(allPaths.filter(function(p) {
+                        return inScope(p, include, exclude);
+                    })) : new Set(db.prepare('SELECT "path" FROM preset_files WHERE preset = ?').all(effective.presetName).map(function(r) {
+                        return r.path;
+                    }));
+                    // A scope narrower than the whole index needs a bigger candidate pool before filtering, or
+                    // filtering can starve k even though enough in-scope matches exist further down the ranked
+                    // list that a plain over-fetch wouldn't have reached.
+                    scopeActive = scopedPaths.size < allPaths.length;
+                    fetch = scopeActive ? Math.max(k * 5, 50) : Math.max(k * 3, 30);
+                    // Semantic participation: vectors run only when the effective setting allows it AND the
+                    // scope actually has embedded files -- a scope covered only by semantic-false presets (or
+                    // by no preset embedding at all) searches lexically, automatically, no error.
+                    semanticEnabled = effective.semantic && scopeHasEmbeddings(db, cfg, scopedPaths);
                     // Terms pass verbatim to FTS5 MATCH: bare words AND-join, operators are the caller's.
                     // Invalid syntax propagates as an error, zero matches return zero -- no silent rewrites.
                     // --where applies inside the candidate query (a post-filter over the top-N would drop
                     // matches ranked past the pool) and again on the final select for link-derived rows.
-                    // An explicit --where replaces the tree's declared default rather than ANDing with it,
-                    // so a caller can always widen back to the whole tree.
-                    scope = (_opts_where = opts.where) !== null && _opts_where !== void 0 ? _opts_where : (_cfg_defaults = cfg.defaults) === null || _cfg_defaults === void 0 ? void 0 : (_cfg_defaults_find = _cfg_defaults.find) === null || _cfg_defaults_find === void 0 ? void 0 : _cfg_defaults_find.where;
+                    // An explicit --where replaces the preset's declared where rather than ANDing with it,
+                    // so a caller can always widen back to the whole scope.
+                    scope = effective.where;
                     whereJoin = scope ? 'JOIN frontmatter f ON f."path" = content.path' : '';
                     whereCond = scope ? "AND (".concat(scope, ")") : '';
                     // Docs past SNIPPET_BOUND skip snippet() entirely -- SQLite
@@ -390,6 +433,12 @@ function find(_0, _1, _2) {
                     } catch (err) {
                         throw (0, _searcherrorts.searchError)(err, terms, scope);
                     }
+                    // Scope filtering happens in JS, on each candidate list, rather than in SQL: FTS5 match,
+                    // link expansion, and vector search all run unscoped above (cheap to over-fetch), then get
+                    // filtered here against the effective include/exclude before ranking is finalized.
+                    matchRows = matchRows.filter(function(r) {
+                        return scopedPaths.has(r.path);
+                    });
                     hits = new Map(matchRows.map(function(r) {
                         return [
                             r.path,
@@ -417,18 +466,15 @@ function find(_0, _1, _2) {
                         // that mass from the score list reweights fusion toward connectivity and measurably
                         // wrecks ranking on link-dense corpora (FEVER hit@10 0.997 -> 0.907; fusion-tuning.md).
                         linked = new Set(edges.flat());
-                        nodes = db.prepare('SELECT "path" FROM frontmatter').all().map(function(r) {
-                            return r.path;
-                        });
                         seeds = new Map(matchRows.map(function(r, i) {
                             return [
                                 r.path,
                                 1 / (i + 1)
                             ];
                         }));
-                        ranked = _to_consumable_array((0, _graphts.personalizedRank)(nodes, edges, seeds)).filter(function(param) {
-                            var _param = _sliced_to_array(param, 2), score = _param[1];
-                            return score > 1e-9;
+                        ranked = _to_consumable_array((0, _graphts.personalizedRank)(allPaths, edges, seeds)).filter(function(param) {
+                            var _param = _sliced_to_array(param, 2), path = _param[0], score = _param[1];
+                            return score > 1e-9 && scopedPaths.has(path);
                         }).sort(function(a, b) {
                             return b[1] - a[1];
                         }).slice(0, fetch);
@@ -450,7 +496,7 @@ function find(_0, _1, _2) {
                     // (weight 1, pool = fetch). Each row carries its best chunk's line range.
                     chunkLines = new Map();
                     chunkSimilarity = new Map();
-                    if (!opts.semantic) return [
+                    if (!semanticEnabled) return [
                         3,
                         2
                     ];
@@ -459,7 +505,9 @@ function find(_0, _1, _2) {
                         (0, _embedts.semanticCandidates)(db, cfg, terms, fetch)
                     ];
                 case 1:
-                    vec = _state.sent();
+                    vec = _state.sent().filter(function(v) {
+                        return scopedPaths.has(v.path);
+                    });
                     vec.forEach(function(param, i) {
                         var path = param.path, lines = param.lines, similarity = param.similarity;
                         chunkLines.set(path, lines);
@@ -500,10 +548,14 @@ function find(_0, _1, _2) {
                             }
                         }
                     }
-                    where = scope ? "WHERE ".concat(scope) : '';
+                    // Every candidate list was already filtered to scopedPaths above, so _find only ever holds
+                    // in-scope rows -- the final select just needs --where again, same as before, for rows
+                    // whichever candidate query didn't itself apply it to (link-derived rows never touched
+                    // whereCond above).
+                    where = scope ? "WHERE (".concat(scope, ")") : '';
                     // lines is always present now: semantic rows carry their chunk's range, oversized-doc
                     // lexical rows gain one below, everything else stays null. similarity stays semantic-only.
-                    similarityCol = opts.semantic ? ', _find.similarity' : '';
+                    similarityCol = semanticEnabled ? ', _find.similarity' : '';
                     rows = db.prepare('SELECT f."path" AS path, content.title, content.summary, _find.hit, _find.via, round(_find.score, 4) AS score, _find.lines'.concat(similarityCol, '\n       FROM _find JOIN frontmatter f ON f."path" = _find."path" JOIN content ON content.path = _find."path"\n       ').concat(where, " ORDER BY _find.score DESC LIMIT ?")).all(k);
                     if (oversized.size > 0) {
                         bareTerms = extractBareTerms(terms);
@@ -545,6 +597,18 @@ function find(_0, _1, _2) {
         });
     }).apply(this, arguments);
 }
+function presetCoverage(db, cfg) {
+    var embedActive = (0, _configts.anyPresetEmbeds)(cfg);
+    return (0, _configts.presetNames)(cfg).map(function(name) {
+        var files = db.prepare('SELECT COUNT(*) AS n FROM preset_files WHERE preset = ?').get(name).n;
+        var embedded = embedActive ? db.prepare('SELECT COUNT(*) AS n FROM preset_files pf WHERE pf.preset = ? AND EXISTS (SELECT 1 FROM embeddings e WHERE e."path" = pf."path" AND e.vector IS NOT NULL)').get(name).n : 0;
+        return {
+            name: name,
+            files: files,
+            embedded: embedded
+        };
+    });
+}
 var INTERNAL_COLUMNS = new Set([
     'path',
     '_mtime',
@@ -617,6 +681,7 @@ function mapTree(db, cfg) {
         fields: fields,
         fieldsTotal: allFields.length,
         features: (0, _configts.featureStates)(cfg),
+        presets: presetCoverage(db, cfg),
         hubs: hubs,
         recent: recent
     };