sensemaking 0.24.7 → 0.25.0

package/dist/cjs/cli/shared.js

@@ -15,6 +15,9 @@ _export(exports, {
     get FORMAT () {
         return FORMAT;
     },
+    get NO_BUILD () {
+        return NO_BUILD;
+    },
     get SCOPE () {
         return SCOPE;
     },
@@ -50,6 +53,9 @@ _export(exports, {
     },
     get withDb () {
         return withDb;
+    },
+    get withResolvedDb () {
+        return withResolvedDb;
     }
 });
 var _nodeutil = require("node:util");
@@ -270,6 +276,12 @@ var CONFIG = {
         type: 'string'
     }
 };
+var NO_BUILD = {
+    'no-build': {
+        type: 'boolean',
+        default: false
+    }
+};
 var SCOPE = {
     where: {
         type: 'string'
@@ -404,16 +416,20 @@ function printWarnings(warnings) {
         }
     }
 }
-function withDb(ctx, configPath, fn) {
+function withResolvedDb(cfg, options, fn) {
     return _async_to_generator(function() {
-        var cfg, _ref, store, warnings;
+        var requirements, build, _ref, store, warnings;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    cfg = ctx.resolveConfig(configPath);
+                    requirements = typeof options.requirements === 'function' ? options.requirements(cfg) : options.requirements;
+                    build = !options.noBuild && cfg.build !== false;
                     return [
                         4,
-                        (0, _indexts1.openStore)(cfg)
+                        (0, _indexts1.openStoreFor)(cfg, {
+                            build: build,
+                            requirements: requirements
+                        })
                     ];
                 case 1:
                     _ref = _state.sent(), store = _ref.store, warnings = _ref.warnings;
@@ -428,7 +444,7 @@ function withDb(ctx, configPath, fn) {
                     ]);
                     return [
                         4,
-                        fn(store, cfg)
+                        fn(store, cfg, build)
                     ];
                 case 3:
                     _state.sent();
@@ -454,6 +470,21 @@ function withDb(ctx, configPath, fn) {
         });
     })();
 }
+function withDb(ctx, configPath, options, fn) {
+    return _async_to_generator(function() {
+        var cfg;
+        return _ts_generator(this, function(_state) {
+            cfg = ctx.resolveConfig(configPath, {
+                writeMigration: !options.noBuild,
+                query: true
+            });
+            return [
+                2,
+                withResolvedDb(cfg, options, fn)
+            ];
+        });
+    })();
+}
 // `--preset` on SQL binds a temp `scope` table rather than transparently filtering: temp views shadowing the base tables can't cover `content`, since FTS5 MATCH treats the table name as a hidden column.
 // A flag that silently scoped three tables of four would look scoped and not be.
 function bindScope(store, cfg, preset) {
@@ -494,9 +525,9 @@ function bindScope(store, cfg, preset) {
         });
     })();
 }
-function runSql(cfg, sql, params, format, label, preset) {
+function runSql(cfg, sql, params, format, label, noBuild, preset) {
     return _async_to_generator(function() {
-        var _sql_match, placeholderCount, _ref, store, warnings, _statement, statement, columns, err, hinted;
+        var _sql_match, placeholderCount;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -514,75 +545,79 @@ function runSql(cfg, sql, params, format, label, preset) {
                     }
                     return [
                         4,
-                        (0, _indexts1.openStore)(cfg)
+                        withResolvedDb(cfg, {
+                            noBuild: noBuild,
+                            requirements: new Set([
+                                'core'
+                            ])
+                        }, function(store) {
+                            return _async_to_generator(function() {
+                                var _statement, statement, columns, err, hinted;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            if (!(preset !== undefined)) return [
+                                                3,
+                                                2
+                                            ];
+                                            return [
+                                                4,
+                                                bindScope(store, cfg, preset)
+                                            ];
+                                        case 1:
+                                            _state.sent();
+                                            _state.label = 2;
+                                        case 2:
+                                            _state.trys.push([
+                                                2,
+                                                5,
+                                                ,
+                                                7
+                                            ]);
+                                            return [
+                                                4,
+                                                store.raw.prepare(sql)
+                                            ];
+                                        case 3:
+                                            statement = _state.sent();
+                                            columns = statement.columns().map(function(c) {
+                                                return c.name;
+                                            });
+                                            return [
+                                                4,
+                                                (0, _outputts.printRowStream)((_statement = statement).iterate.apply(_statement, _to_consumable_array(params)), format, columns)
+                                            ];
+                                        case 4:
+                                            _state.sent();
+                                            return [
+                                                3,
+                                                7
+                                            ];
+                                        case 5:
+                                            err = _state.sent();
+                                            return [
+                                                4,
+                                                store.docs.columns()
+                                            ];
+                                        case 6:
+                                            hinted = _columnhintts.columnHint.apply(void 0, [
+                                                _state.sent(),
+                                                err
+                                            ]);
+                                            // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5 punctuation trap applies to its bound parameters.
+                                            // SQL without MATCH gets its error verbatim; search advice on a plain typo would mislead.
+                                            if (/\bMATCH\b/i.test(sql)) throw (0, _searcherrorts.searchError)(hinted, params.join(' '));
+                                            throw hinted;
+                                        case 7:
+                                            return [
+                                                2
+                                            ];
+                                    }
+                                });
+                            })();
+                        })
                     ];
                 case 1:
-                    _ref = _state.sent(), store = _ref.store, warnings = _ref.warnings;
-                    printWarnings(warnings);
-                    if (!(preset !== undefined)) return [
-                        3,
-                        3
-                    ];
-                    return [
-                        4,
-                        bindScope(store, cfg, preset)
-                    ];
-                case 2:
-                    _state.sent();
-                    _state.label = 3;
-                case 3:
-                    _state.trys.push([
-                        3,
-                        6,
-                        ,
-                        9
-                    ]);
-                    return [
-                        4,
-                        store.raw.prepare(sql)
-                    ];
-                case 4:
-                    statement = _state.sent();
-                    columns = statement.columns().map(function(c) {
-                        return c.name;
-                    });
-                    return [
-                        4,
-                        (0, _outputts.printRowStream)((_statement = statement).iterate.apply(_statement, _to_consumable_array(params)), format, columns)
-                    ];
-                case 5:
-                    _state.sent();
-                    return [
-                        3,
-                        9
-                    ];
-                case 6:
-                    err = _state.sent();
-                    return [
-                        4,
-                        store.docs.columns()
-                    ];
-                case 7:
-                    hinted = _columnhintts.columnHint.apply(void 0, [
-                        _state.sent(),
-                        err
-                    ]);
-                    return [
-                        4,
-                        store.close()
-                    ];
-                case 8:
-                    _state.sent();
-                    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5 punctuation trap applies to its bound parameters.
-                    // SQL without MATCH gets its error verbatim; search advice on a plain typo would mislead.
-                    if (/\bMATCH\b/i.test(sql)) throw (0, _searcherrorts.searchError)(hinted, params.join(' '));
-                    throw hinted;
-                case 9:
-                    return [
-                        4,
-                        store.close()
-                    ];
-                case 10:
                     _state.sent();
                     return [
                         2

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolvePreset } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Row, RowFormat } from '../output/output.ts';\nimport { printRowStream } from '../output/output.ts';\nimport { searchError } from '../output/search-error.ts';\nimport type { OpenResult } from '../store/index.ts';\nimport { openStore } from '../store/index.ts';\nimport type { Store } from '../store/types.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' }, 'snippet-char-limit': { type: 'string' }, 'snippet-count-limit': { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down.\n// One place to read them: a new scope field is added to the fragment and here, not per-command.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\n// parseArgs is strict about flag names; this applies the same strictness to the value.\n// An unrecognised --format is a usage error, not a silent fallback to `table`.\nfunction pickFormat<T extends string>(values: Values, allowed: readonly T[]): T {\n  const format = String(values.format);\n  if ((allowed as readonly string[]).includes(format)) return format as T;\n  console.error(`unknown --format \"${format}\"; expected ${allowed.join(', ')}`);\n  process.exit(2);\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return pickFormat(values, ['table', 'json'] as const);\n}\n\n// csv is a row set rendered as rows; map, peek, status, and path render structures instead,\n// and take formatOf.\nexport function rowFormatOf(values: Values): RowFormat {\n  return pickFormat(values, ['table', 'json', 'csv'] as const);\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as \"nothing\", and parseInt would silently truncate \"5.9\".\n// All three are caller mistakes worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Same positive-integer rule as --k, beside it since both flags come from SEARCH_FLAGS.\nexport function parseSnippetCharLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-char-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\nexport function parseSnippetCountLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-count-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, fn: (store: OpenResult['store'], cfg: ResolvedConfig) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath);\n  const { store, warnings } = await openStore(cfg);\n  printWarnings(warnings);\n  try {\n    await fn(store, cfg);\n  } finally {\n    await store.close();\n  }\n}\n\n// `--preset` on SQL binds a temp `scope` table rather than transparently filtering: temp views shadowing the base tables can't cover `content`, since FTS5 MATCH treats the table name as a hidden column.\n// A flag that silently scoped three tables of four would look scoped and not be.\nasync function bindScope(store: Store, cfg: ResolvedConfig, preset: string): Promise<void> {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  await store.exec('DROP TABLE IF EXISTS temp.scope');\n  await store.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  const insert = await store.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?');\n  await insert.run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport async function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, preset?: string): Promise<void> {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(2);\n  }\n  const { store, warnings } = await openStore(cfg);\n  printWarnings(warnings);\n  if (preset !== undefined) await bindScope(store, cfg, preset);\n  // Streamed, not collected: `sql`'s result size is the caller's business, not ours. columns() reads the statement's own metadata, so a 0-row csv gets a header too.\n  // A mid-stream SQLite error (e.g. SQLITE_BUSY outlasting busy_timeout) may leave partial output; the nonzero exit code is the failure signal, not a completeness guarantee.\n  try {\n    const statement = await store.raw.prepare(sql);\n    const columns = statement.columns().map((c) => c.name);\n    await printRowStream(statement.iterate(...params) as AsyncIterable<Row>, format, columns);\n  } catch (err) {\n    const hinted = columnHint(await store.docs.columns(), err as Error); // columns read while the store is still open\n    await store.close();\n    // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5 punctuation trap applies to its bound parameters.\n    // SQL without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n    if (/\\bMATCH\\b/i.test(sql)) throw searchError(hinted, params.join(' '));\n    throw hinted;\n  }\n  await store.close();\n}\n"],"names":["CONFIG","FORMAT","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","parseSnippetCharLimit","parseSnippetCountLimit","printWarnings","rowFormatOf","runSql","scopeOf","withDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","pickFormat","allowed","String","includes","console","error","join","process","exit","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","message","log","usageError","undefined","parsed","Number","isInteger","value","warnings","w","warn","ctx","configPath","fn","cfg","store","resolveConfig","openStore","close","bindScope","name","insert","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","statement","columns","hinted","match","length","test","raw","map","c","printRowStream","iterate","docs","columnHint","searchError"],"mappings":";;;;;;;;;;;QAeaA;eAAAA;;QADAC;eAAAA;;QAIAC;eAAAA;;QASAC;eAAAA;;QAyBGC;eAAAA;;QAWAC;eAAAA;;QAwBAC;eAAAA;;QAQAC;eAAAA;;QAOAC;eAAAA;;QASAC;eAAAA;;QArDAC;eAAAA;;QA+EMC;eAAAA;;QAxGNC;eAAAA;;QAkFMC;eAAAA;;;wBAlHI;uBAEI;4BACH;wBAEI;6BACH;wBAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKnB,IAAMZ,SAAiC;IAAEa,QAAQ;QAAEC,MAAM;QAAUC,SAAS;IAAQ;AAAE;AACtF,IAAMhB,SAAiC;IAAEiB,QAAQ;QAAEF,MAAM;IAAS;AAAE;AAGpE,IAAMb,QAAgC;IAC3CgB,OAAO;QAAEH,MAAM;IAAS;IACxBI,QAAQ;QAAEJ,MAAM;IAAS;IACzBK,SAAS;QAAEL,MAAM;QAAUM,UAAU;IAAK;IAC1CC,SAAS;QAAEP,MAAM;QAAUM,UAAU;IAAK;IAC1C,yFAAyF;IACzF,gFAAgF;IAChF,cAAc;QAAEN,MAAM;QAAWC,SAAS;IAAM;AAClD;AACO,IAAMb,eAAuC,wCAAKD;IAAOqB,GAAG;QAAER,MAAM;IAAS;IAAG,sBAAsB;QAAEA,MAAM;IAAS;IAAG,uBAAuB;QAAEA,MAAM;IAAS;;AAMlK,SAASH,QAAQY,MAAc;IACpC,OAAO;QACLL,QAAQK,OAAOL,MAAM;QACrBC,SAASI,OAAOJ,OAAO;QACvBE,SAASE,OAAOF,OAAO;QACvBJ,OAAOM,OAAON,KAAK;QACnBO,WAAWD,MAAM,CAAC,aAAa,KAAK;IACtC;AACF;AAEA,uFAAuF;AACvF,+EAA+E;AAC/E,SAASE,WAA6BF,MAAc,EAAEG,OAAqB;IACzE,IAAMb,SAASc,OAAOJ,OAAOV,MAAM;IACnC,IAAI,AAACa,QAA8BE,QAAQ,CAACf,SAAS,OAAOA;IAC5DgB,QAAQC,KAAK,CAAC,AAAC,qBAAyCJ,OAArBb,QAAO,gBAAiC,OAAnBa,QAAQK,IAAI,CAAC;IACrEC,QAAQC,IAAI,CAAC;AACf;AAEO,SAAS9B,SAASoB,MAAc;IACrC,OAAOE,WAAWF,QAAQ;QAAC;QAAS;KAAO;AAC7C;AAIO,SAASd,YAAYc,MAAc;IACxC,OAAOE,WAAWF,QAAQ;QAAC;QAAS;QAAQ;KAAM;AACpD;AAGO,SAASnB,MAAM8B,IAAc,EAAEC,KAAa,EAAEC,OAA+B;IAClF,IAAIb;IACJ,IAAIc;IACJ,IAAI;;cACyBC,IAAAA,mBAAS,EAAC;YACnCC,MAAML;YACNE,SAAS,wCAAKA;gBAASI,MAAM;oBAAE1B,MAAM;oBAAWC,SAAS;oBAAO0B,OAAO;gBAAI;;YAC3EC,QAAQ;YACRC,kBAAkB;QACpB,IALGpB,aAAAA,QAAQc,kBAAAA;IAMb,EAAE,OAAOO,KAAK;QACZf,QAAQC,KAAK,CAAC,AAACc,IAAcC,OAAO;QACpChB,QAAQC,KAAK,CAACK;QACdH,QAAQC,IAAI,CAAC;IACf;IACA,IAAIV,OAAOiB,IAAI,EAAE;QACfX,QAAQiB,GAAG,CAACX;QACZH,QAAQC,IAAI,CAAC;IACf;IACA,OAAO;QAAEV,QAAAA;QAAQc,aAAAA;IAAY;AAC/B;AAIO,SAAShC,OAAOiB,CAAqB,EAAEyB,UAAsC;IAClF,IAAIzB,MAAM0B,WAAW,OAAOA;IAC5B,IAAMC,SAASC,OAAO5B;IACtB,IAAI,CAAC4B,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,wCAAyC,OAAFzB,GAAE;IACnG,OAAO2B;AACT;AAGO,SAAS3C,sBAAsB8C,KAAyB,EAAEL,UAAsC;IACrG,IAAIK,UAAUJ,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOE;IACtB,IAAI,CAACF,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,yDAA8D,OAANK,OAAM;IACxH,OAAOH;AACT;AAEO,SAAS1C,uBAAuB6C,KAAyB,EAAEL,UAAsC;IACtG,IAAIK,UAAUJ,WAAW,OAAOA;IAChC,IAAMC,SAASC,OAAOE;IACtB,IAAI,CAACF,OAAOC,SAAS,CAACF,WAAWA,UAAU,GAAGF,WAAW,AAAC,0DAA+D,OAANK,OAAM;IACzH,OAAOH;AACT;AAIO,SAASzC,cAAc6C,QAAkB;QACzC,kCAAA,2BAAA;;QAAL,QAAK,YAAWA,6BAAX,SAAA,6BAAA,QAAA,yBAAA;YAAA,IAAMC,IAAN;YAAqBzB,QAAQ0B,IAAI,CAACD;;;QAAlC;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;AACP;AAEO,SAAe1C,OAAO4C,GAAQ,EAAEC,UAA8B,EAAEC,EAA6E;;YAC5IC,KACsB,MAApBC,OAAOP;;;;oBADTM,MAAMH,IAAIK,aAAa,CAACJ;oBACF;;wBAAMK,IAAAA,mBAAS,EAACH;;;oBAAhB,OAAA,eAApBC,QAAoB,KAApBA,OAAOP,WAAa,KAAbA;oBACf7C,cAAc6C;;;;;;;;;oBAEZ;;wBAAMK,GAAGE,OAAOD;;;oBAAhB;;;;;;oBAEA;;wBAAMC,MAAMG,KAAK;;;oBAAjB;;;;;;;;;;IAEJ;;AAEA,2MAA2M;AAC3M,iFAAiF;AACjF,SAAeC,UAAUJ,KAAY,EAAED,GAAmB,EAAEzC,MAAc;;YAChE+C,MAGFC;;;;oBAHED,OAASE,IAAAA,sBAAa,EAACR,KAAKzC,QAA5B+C,MAAqC,gDAAgD;oBAC7F;;wBAAML,MAAMQ,IAAI,CAAC;;;oBAAjB;oBACA;;wBAAMR,MAAMQ,IAAI,CAAC;;;oBAAjB;oBACe;;wBAAMR,MAAMS,OAAO,CAAC;;;oBAA7BH,SAAS;oBACf;;wBAAMA,OAAOI,GAAG,CAACL;;;oBAAjB;;;;;;IACF;;AAGO,SAAevD,OAAOiD,GAAmB,EAAEY,GAAW,EAAEC,MAAgB,EAAE3D,MAAiB,EAAE4D,KAAa,EAAEvD,MAAe;;YACtGqD,YAApBG,kBAYsB,MAApBd,OAAOP,UAQQsB,YAFfA,WACAC,SAEChC,KACDiC;;;;oBAtBFH,mBAAmB,EAACH,aAAAA,IAAIO,KAAK,CAAC,oBAAVP,wBAAAA,iBAAwBQ,MAAM;oBACxD,IAAIP,OAAOO,MAAM,KAAKL,kBAAkB;wBACtC7C,QAAQC,KAAK,CAAC,AAAC,GAAmB4C,OAAjBD,OAAM,aAAiDD,OAAtCE,kBAAiB,uBAAmC,OAAdF,OAAOO,MAAM;wBACrF/C,QAAQC,IAAI,CAAC;oBACf;oBACA,6FAA6F;oBAC7F,2EAA2E;oBAC3E,IAAIf,WAAW8B,aAAa,CAAC,aAAagC,IAAI,CAACT,MAAM;wBACnD1C,QAAQC,KAAK,CAAC,AAAC,wEAA4E,OAAN2C,OAAM;wBAC3F5C,QAAQC,KAAK,CAAC;wBACdE,QAAQC,IAAI,CAAC;oBACf;oBAC4B;;wBAAM6B,IAAAA,mBAAS,EAACH;;;oBAAhB,OAAA,eAApBC,QAAoB,KAApBA,OAAOP,WAAa,KAAbA;oBACf7C,cAAc6C;yBACVnC,CAAAA,WAAW8B,SAAQ,GAAnB9B;;;;oBAAsB;;wBAAM8C,UAAUJ,OAAOD,KAAKzC;;;oBAA5B;;;;;;;;;oBAIN;;wBAAM0C,MAAMqB,GAAG,CAACZ,OAAO,CAACE;;;oBAApCI,YAAY;oBACZC,UAAUD,UAAUC,OAAO,GAAGM,GAAG,CAAC,SAACC;+BAAMA,EAAElB,IAAI;;oBACrD;;wBAAMmB,IAAAA,wBAAc,EAACT,CAAAA,aAAAA,WAAUU,OAAO,OAAjBV,YAAkB,qBAAGH,UAA+B3D,QAAQ+D;;;oBAAjF;;;;;;oBACOhC;oBACmB;;wBAAMgB,MAAM0B,IAAI,CAACV,OAAO;;;oBAA5CC,SAASU,wBAAU;wBAAC;wBAA4B3C;;oBACtD;;wBAAMgB,MAAMG,KAAK;;;oBAAjB;oBACA,kIAAkI;oBAClI,0FAA0F;oBAC1F,IAAI,aAAaiB,IAAI,CAACT,MAAM,MAAMiB,IAAAA,0BAAW,EAACX,QAAQL,OAAOzC,IAAI,CAAC;oBAClE,MAAM8C;;oBAER;;wBAAMjB,MAAMG,KAAK;;;oBAAjB;;;;;;IACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/shared.ts"],"sourcesContent":["import type { ParseArgsOptionsConfig } from 'node:util';\nimport { parseArgs } from 'node:util';\nimport type { ResolvedConfig, SearchOverrides } from '../config/index.ts';\nimport { resolvePreset } from '../config/index.ts';\nimport { columnHint } from '../output/column-hint.ts';\nimport type { Row, RowFormat } from '../output/output.ts';\nimport { printRowStream } from '../output/output.ts';\nimport { searchError } from '../output/search-error.ts';\nimport { openStoreFor } from '../store/index.ts';\nimport type { BuildRequirement, OpenResult } from '../store/open.ts';\nimport type { Store } from '../store/types.ts';\nimport type { Ctx } from './types.ts';\n\n// Spreadable option fragments -- one flag name keeps one meaning across every command's table.\nexport const FORMAT: ParseArgsOptionsConfig = { format: { type: 'string', default: 'table' } };\nexport const CONFIG: ParseArgsOptionsConfig = { config: { type: 'string' } };\nexport const NO_BUILD: ParseArgsOptionsConfig = { 'no-build': { type: 'boolean', default: false } };\n// The scope vocabulary every scoped command shares: named preset, ad hoc include/exclude\n// globs, a where SQL condition. search adds k on top.\nexport const SCOPE: ParseArgsOptionsConfig = {\n  where: { type: 'string' },\n  preset: { type: 'string' },\n  include: { type: 'string', multiple: true },\n  exclude: { type: 'string', multiple: true },\n  // Widening, which no other flag can express: --include and --exclude each override their\n  // own side of the preset, so neither can drop an exclusion the preset declares.\n  'no-exclude': { type: 'boolean', default: false },\n};\nexport const SEARCH_FLAGS: ParseArgsOptionsConfig = { ...SCOPE, k: { type: 'string' }, 'snippet-char-limit': { type: 'string' }, 'snippet-count-limit': { type: 'string' } };\n\ntype Values = Record<string, string | boolean | string[] | undefined>;\n\n// The SCOPE fragment's parsed values as the overrides every scoped command passes down.\n// One place to read them: a new scope field is added to the fragment and here, not per-command.\nexport function scopeOf(values: Values): SearchOverrides {\n  return {\n    preset: values.preset as string | undefined,\n    include: values.include as string[] | undefined,\n    exclude: values.exclude as string[] | undefined,\n    where: values.where as string | undefined,\n    noExclude: values['no-exclude'] === true,\n  };\n}\n\n// parseArgs is strict about flag names; this applies the same strictness to the value.\n// An unrecognised --format is a usage error, not a silent fallback to `table`.\nfunction pickFormat<T extends string>(values: Values, allowed: readonly T[]): T {\n  const format = String(values.format);\n  if ((allowed as readonly string[]).includes(format)) return format as T;\n  console.error(`unknown --format \"${format}\"; expected ${allowed.join(', ')}`);\n  process.exit(2);\n}\n\nexport function formatOf(values: Values): 'table' | 'json' {\n  return pickFormat(values, ['table', 'json'] as const);\n}\n\n// csv is a row set rendered as rows; map, peek, status, and path render structures instead,\n// and take formatOf.\nexport function rowFormatOf(values: Values): RowFormat {\n  return pickFormat(values, ['table', 'json', 'csv'] as const);\n}\n\n// Per-command parseArgs: strict (a foreign flag exits 2), and every table gets --help for free.\nexport function parse(argv: string[], usage: string, options: ParseArgsOptionsConfig): { values: Values; positionals: string[] } {\n  let values: Values;\n  let positionals: string[];\n  try {\n    ({ values, positionals } = parseArgs({\n      args: argv,\n      options: { ...options, help: { type: 'boolean', default: false, short: 'h' } },\n      strict: true,\n      allowPositionals: true,\n    }));\n  } catch (err) {\n    console.error((err as Error).message);\n    console.error(usage);\n    process.exit(2);\n  }\n  if (values.help) {\n    console.log(usage);\n    process.exit(0);\n  }\n  return { values, positionals };\n}\n\n// --k must be a positive integer: SQLite reads a bound LIMIT of -1 as \"unlimited\" and 0 as \"nothing\", and parseInt would silently truncate \"5.9\".\n// All three are caller mistakes worth a usage error, matching the config-level SavedSearch validation.\nexport function parseK(k: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (k === undefined) return undefined;\n  const parsed = Number(k);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--k expects a positive integer, got \"${k}\"`);\n  return parsed;\n}\n\n// Same positive-integer rule as --k, beside it since both flags come from SEARCH_FLAGS.\nexport function parseSnippetCharLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-char-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\nexport function parseSnippetCountLimit(value: string | undefined, usageError: (message: string) => never): number | undefined {\n  if (value === undefined) return undefined;\n  const parsed = Number(value);\n  if (!Number.isInteger(parsed) || parsed <= 0) usageError(`--snippet-count-limit expects a positive integer, got \"${value}\"`);\n  return parsed;\n}\n\n// Shared open-query-close envelope for commands that touch the tree.\n\nexport function printWarnings(warnings: string[]): void {\n  for (const w of warnings) console.warn(w);\n}\n\nexport interface DbOpenOptions {\n  noBuild: boolean;\n  requirements: ReadonlySet<BuildRequirement> | ((cfg: ResolvedConfig) => ReadonlySet<BuildRequirement>);\n}\n\nexport async function withResolvedDb(cfg: ResolvedConfig, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void> {\n  const requirements = typeof options.requirements === 'function' ? options.requirements(cfg) : options.requirements;\n  const build = !options.noBuild && cfg.build !== false;\n  const { store, warnings } = await openStoreFor(cfg, {\n    build,\n    requirements,\n  });\n  printWarnings(warnings);\n  try {\n    await fn(store, cfg, build);\n  } finally {\n    await store.close();\n  }\n}\n\nexport async function withDb(ctx: Ctx, configPath: string | undefined, options: DbOpenOptions, fn: (store: OpenResult['store'], cfg: ResolvedConfig, build: boolean) => void | Promise<void>): Promise<void> {\n  const cfg = ctx.resolveConfig(configPath, { writeMigration: !options.noBuild, query: true });\n  return withResolvedDb(cfg, options, fn);\n}\n\n// `--preset` on SQL binds a temp `scope` table rather than transparently filtering: temp views shadowing the base tables can't cover `content`, since FTS5 MATCH treats the table name as a hidden column.\n// A flag that silently scoped three tables of four would look scoped and not be.\nasync function bindScope(store: Store, cfg: ResolvedConfig, preset: string): Promise<void> {\n  const { name } = resolvePreset(cfg, preset); // unknown names throw, listing what is declared\n  await store.exec('DROP TABLE IF EXISTS temp.scope');\n  await store.exec('CREATE TEMP TABLE scope (\"path\" TEXT PRIMARY KEY)');\n  const insert = await store.prepare('INSERT INTO temp.scope (\"path\") SELECT \"path\" FROM preset_files WHERE preset = ?');\n  await insert.run(name);\n}\n\n// An unbound `?` silently binds NULL, so mismatched param counts fail loudly instead.\nexport async function runSql(cfg: ResolvedConfig, sql: string, params: string[], format: RowFormat, label: string, noBuild: boolean, preset?: string): Promise<void> {\n  const placeholderCount = (sql.match(/\\?/g) ?? []).length;\n  if (params.length !== placeholderCount) {\n    console.error(`${label} expects ${placeholderCount} parameter(s), got ${params.length}`);\n    process.exit(2);\n  }\n  // Naming a preset and never joining it would return the whole index while reading as scoped,\n  // which is the one hazard of binding rather than applying. Refuse instead.\n  if (preset !== undefined && !/\\bscope\\b/i.test(sql)) {\n    console.error(`--preset binds a temporary \"scope\" table of the preset's paths, and ${label} never joins it, so the preset would have no effect`);\n    console.error(`add: JOIN scope ON scope.\"path\" = <table>.\"path\"`);\n    process.exit(2);\n  }\n  await withResolvedDb(cfg, { noBuild, requirements: new Set<BuildRequirement>(['core']) }, async (store) => {\n    if (preset !== undefined) await bindScope(store, cfg, preset);\n    // Streamed, not collected: `sql`'s result size is the caller's business, not ours. columns() reads the statement's own metadata, so a 0-row csv gets a header too.\n    // A mid-stream SQLite error (e.g. SQLITE_BUSY outlasting busy_timeout) may leave partial output; the nonzero exit code is the failure signal, not a completeness guarantee.\n    try {\n      const statement = await store.raw.prepare(sql);\n      const columns = statement.columns().map((c) => c.name);\n      await printRowStream(statement.iterate(...params) as AsyncIterable<Row>, format, columns);\n    } catch (err) {\n      const hinted = columnHint(await store.docs.columns(), err as Error); // columns read while the store is still open\n      // A saved query or ad-hoc SQL can carry `content MATCH ?` too, so the same FTS5 punctuation trap applies to its bound parameters.\n      // SQL without MATCH gets its error verbatim; search advice on a plain typo would mislead.\n      if (/\\bMATCH\\b/i.test(sql)) throw searchError(hinted, params.join(' '));\n      throw hinted;\n    }\n  });\n}\n"],"names":["CONFIG","FORMAT","NO_BUILD","SCOPE","SEARCH_FLAGS","formatOf","parse","parseK","parseSnippetCharLimit","parseSnippetCountLimit","printWarnings","rowFormatOf","runSql","scopeOf","withDb","withResolvedDb","format","type","default","config","where","preset","include","multiple","exclude","k","values","noExclude","pickFormat","allowed","String","includes","console","error","join","process","exit","argv","usage","options","positionals","parseArgs","args","help","short","strict","allowPositionals","err","message","log","usageError","undefined","parsed","Number","isInteger","value","warnings","w","warn","cfg","fn","requirements","build","store","noBuild","openStoreFor","close","ctx","configPath","resolveConfig","writeMigration","query","bindScope","name","insert","resolvePreset","exec","prepare","run","sql","params","label","placeholderCount","match","length","test","Set","statement","columns","hinted","raw","map","c","printRowStream","iterate","docs","columnHint","searchError"],"mappings":"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"}

package/dist/cjs/cli/sql.js

@@ -213,12 +213,12 @@ function _unsupported_iterable_to_array(o, minLen) {
 }
 var sqlCmd = function sqlCmd(ctx) {
     return _async_to_generator(function() {
-        var usage, _parse, values, positionals, _positionals, sql, params, format;
+        var usage, _parse, values, positionals, _positionals, sql, params, format, noBuild, cfg;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
                     usage = "usage: ".concat(ctx.name, " ").concat(_indexts.USAGE.sql);
-                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.FORMAT, _sharedts.CONFIG), {
+                    _parse = (0, _sharedts.parse)(ctx.argv, usage, _object_spread_props(_object_spread({}, _sharedts.NO_BUILD, _sharedts.FORMAT, _sharedts.CONFIG), {
                         preset: {
                             type: 'string'
                         }
@@ -226,9 +226,14 @@ var sqlCmd = function sqlCmd(ctx) {
                     _positionals = _to_array(positionals), sql = _positionals[0], params = _positionals.slice(1);
                     if (!sql) ctx.usageError(usage);
                     format = (0, _sharedts.rowFormatOf)(values);
+                    noBuild = values['no-build'] === true;
+                    cfg = ctx.resolveConfig(values.config, {
+                        writeMigration: !noBuild,
+                        query: true
+                    });
                     return [
                         4,
-                        (0, _sharedts.runSql)(ctx.resolveConfig(values.config), sql, params, format, 'ad-hoc statement', values.preset)
+                        (0, _sharedts.runSql)(cfg, sql, params, format, 'ad-hoc statement', noBuild, values.preset)
                     ];
                 case 1:
                     _state.sent();

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/sql.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, parse, rowFormatOf, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst sqlCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.sql}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...FORMAT, ...CONFIG, preset: { type: 'string' } });\n  const [sql, ...params] = positionals;\n  if (!sql) ctx.usageError(usage);\n  const format = rowFormatOf(values);\n  await runSql(ctx.resolveConfig(values.config as string | undefined), sql, params, format, 'ad-hoc statement', values.preset as string | undefined);\n};\nexport default sqlCmd;\n"],"names":["sqlCmd","ctx","usage","parse","values","positionals","sql","params","format","USAGE","name","argv","FORMAT","CONFIG","preset","type","usageError","rowFormatOf","runSql","resolveConfig","config"],"mappings":";;;;+BAYA;;;eAAA;;;uBAZsB;wBACqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG3D,IAAMA,SAAkB,gBAAOC;;YACvBC,OAC0BC,QAAxBC,QAAQC,aACSA,cAAlBC,KAAQC,QAETC;;;;oBAJAN,QAAQ,AAAC,UAAqBO,OAAZR,IAAIS,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACH,GAAG;oBACbH,SAAAA,IAAAA,eAAK,EAACF,IAAIU,IAAI,EAAET,OAAO,wCAAKU,gBAAM,EAAKC,gBAAM;wBAAEC,QAAQ;4BAAEC,MAAM;wBAAS;yBAAhGX,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACSA,yBAAAA,cAAlBC,MAAkBD,iBAAVE,SAAUF,mBAAb;oBACZ,IAAI,CAACC,KAAKL,IAAIe,UAAU,CAACd;oBACnBM,SAASS,IAAAA,qBAAW,EAACb;oBAC3B;;wBAAMc,IAAAA,gBAAM,EAACjB,IAAIkB,aAAa,CAACf,OAAOgB,MAAM,GAAyBd,KAAKC,QAAQC,QAAQ,oBAAoBJ,OAAOU,MAAM;;;oBAA3H;;;;;;IACF;;IACA,WAAed"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/cli/sql.ts"],"sourcesContent":["import { USAGE } from './index.ts';\nimport { CONFIG, FORMAT, NO_BUILD, parse, rowFormatOf, runSql } from './shared.ts';\nimport type { Command } from './types.ts';\n\nconst sqlCmd: Command = async (ctx) => {\n  const usage = `usage: ${ctx.name} ${USAGE.sql}`;\n  const { values, positionals } = parse(ctx.argv, usage, { ...NO_BUILD, ...FORMAT, ...CONFIG, preset: { type: 'string' } });\n  const [sql, ...params] = positionals;\n  if (!sql) ctx.usageError(usage);\n  const format = rowFormatOf(values);\n  const noBuild = values['no-build'] === true;\n  const cfg = ctx.resolveConfig(values.config as string | undefined, { writeMigration: !noBuild, query: true });\n  await runSql(cfg, sql, params, format, 'ad-hoc statement', noBuild, values.preset as string | undefined);\n};\nexport default sqlCmd;\n"],"names":["sqlCmd","ctx","usage","parse","values","positionals","sql","params","format","noBuild","cfg","USAGE","name","argv","NO_BUILD","FORMAT","CONFIG","preset","type","usageError","rowFormatOf","resolveConfig","config","writeMigration","query","runSql"],"mappings":";;;;+BAcA;;;eAAA;;;uBAdsB;wBAC+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGrE,IAAMA,SAAkB,gBAAOC;;YACvBC,OAC0BC,QAAxBC,QAAQC,aACSA,cAAlBC,KAAQC,QAETC,QACAC,SACAC;;;;oBANAR,QAAQ,AAAC,UAAqBS,OAAZV,IAAIW,IAAI,EAAC,KAAa,OAAVD,cAAK,CAACL,GAAG;oBACbH,SAAAA,IAAAA,eAAK,EAACF,IAAIY,IAAI,EAAEX,OAAO,wCAAKY,kBAAQ,EAAKC,gBAAM,EAAKC,gBAAM;wBAAEC,QAAQ;4BAAEC,MAAM;wBAAS;yBAA7Gd,SAAwBD,OAAxBC,QAAQC,cAAgBF,OAAhBE;oBACSA,yBAAAA,cAAlBC,MAAkBD,iBAAVE,SAAUF,mBAAb;oBACZ,IAAI,CAACC,KAAKL,IAAIkB,UAAU,CAACjB;oBACnBM,SAASY,IAAAA,qBAAW,EAAChB;oBACrBK,UAAUL,MAAM,CAAC,WAAW,KAAK;oBACjCM,MAAMT,IAAIoB,aAAa,CAACjB,OAAOkB,MAAM,EAAwB;wBAAEC,gBAAgB,CAACd;wBAASe,OAAO;oBAAK;oBAC3G;;wBAAMC,IAAAA,gBAAM,EAACf,KAAKJ,KAAKC,QAAQC,QAAQ,oBAAoBC,SAASL,OAAOa,MAAM;;;oBAAjF;;;;;;IACF;;IACA,WAAejB"}