sensemaking 0.2.0 → 0.3.0

package/dist/cjs/commands/watch.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _watchts = require("../watch.js");
+var _vaultts = require("./vault.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var watch = function watch(ctx) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        (0, _watchts.runWatch)(ctx.resolveConfig(), {
+                            force: ctx.values.force,
+                            onEvent: function onEvent(event) {
+                                if (event.type === 'started') {
+                                    console.log("".concat(ctx.name, " watch: watching ").concat(event.baseDir));
+                                    console.log("".concat(ctx.name, " watch: db ").concat(event.dbPath));
+                                } else if (event.type === 'reconciled') {
+                                    (0, _vaultts.printWarnings)(event.warnings);
+                                    if (event.parsed > 0) console.log("".concat(ctx.name, " watch: reconciled, ").concat(event.parsed, " file(s) reparsed (").concat(event.total, " total)"));
+                                } else {
+                                    console.error("".concat(ctx.name, " watch: reconcile error: ").concat(event.message));
+                                }
+                            }
+                        })
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+};
+var _default = watch;
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/commands/watch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/watch.ts"],"sourcesContent":["import type { WatchEvent } from '../watch.ts';\nimport { runWatch } from '../watch.ts';\nimport type { Command } from './types.ts';\nimport { printWarnings } from './vault.ts';\n\nconst watch: Command = async (ctx) => {\n  await runWatch(ctx.resolveConfig(), {\n    force: ctx.values.force,\n    onEvent: (event: WatchEvent) => {\n      if (event.type === 'started') {\n        console.log(`${ctx.name} watch: watching ${event.baseDir}`);\n        console.log(`${ctx.name} watch: db ${event.dbPath}`);\n      } else if (event.type === 'reconciled') {\n        printWarnings(event.warnings);\n        if (event.parsed > 0) console.log(`${ctx.name} watch: reconciled, ${event.parsed} file(s) reparsed (${event.total} total)`);\n      } else {\n        console.error(`${ctx.name} watch: reconcile error: ${event.message}`);\n      }\n    },\n  });\n};\nexport default watch;\n"],"names":["watch","ctx","runWatch","resolveConfig","force","values","onEvent","event","type","console","log","name","baseDir","dbPath","printWarnings","warnings","parsed","total","error","message"],"mappings":";;;;+BAqBA;;;eAAA;;;uBApByB;uBAEK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE9B,IAAMA,QAAiB,eAAOC;;;;;oBAC5B;;wBAAMC,IAAAA,iBAAQ,EAACD,IAAIE,aAAa,IAAI;4BAClCC,OAAOH,IAAII,MAAM,CAACD,KAAK;4BACvBE,SAAS,SAATA,QAAUC;gCACR,IAAIA,MAAMC,IAAI,KAAK,WAAW;oCAC5BC,QAAQC,GAAG,CAAC,AAAC,GAA8BH,OAA5BN,IAAIU,IAAI,EAAC,qBAAiC,OAAdJ,MAAMK,OAAO;oCACxDH,QAAQC,GAAG,CAAC,AAAC,GAAwBH,OAAtBN,IAAIU,IAAI,EAAC,eAA0B,OAAbJ,MAAMM,MAAM;gCACnD,OAAO,IAAIN,MAAMC,IAAI,KAAK,cAAc;oCACtCM,IAAAA,sBAAa,EAACP,MAAMQ,QAAQ;oCAC5B,IAAIR,MAAMS,MAAM,GAAG,GAAGP,QAAQC,GAAG,CAAC,AAAC,GAAiCH,OAA/BN,IAAIU,IAAI,EAAC,wBAAwDJ,OAAlCA,MAAMS,MAAM,EAAC,uBAAiC,OAAZT,MAAMU,KAAK,EAAC;gCACpH,OAAO;oCACLR,QAAQS,KAAK,CAAC,AAAC,GAAsCX,OAApCN,IAAIU,IAAI,EAAC,6BAAyC,OAAdJ,MAAMY,OAAO;gCACpE;4BACF;wBACF;;;oBAbA;;;;;;IAcF;;IACA,WAAenB"}

package/dist/cjs/config.d.cts

@@ -1,18 +1,28 @@
 export declare const CONFIG_FILENAME = "sense.config.json";
 export declare const STATE_DIR = ".sense";
-export declare const SUPPORTED_CONFIG_VERSION = 1;
+export declare const SUPPORTED_CONFIG_VERSION = 2;
+export declare const FEATURE_NAMES: readonly ["links", "sections", "rank"];
+export type FeatureName = (typeof FEATURE_NAMES)[number];
 export interface Config {
     $schema?: string;
     version?: number;
     scan: {
         include: string[];
     };
+    features?: Partial<Record<FeatureName, boolean>>;
     queries: Record<string, string>;
 }
 export interface ResolvedConfig extends Config {
     baseDir: string;
     configPath: string | null;
+    migratedFrom?: number;
 }
+export declare function featureEnabled(cfg: Config, name: FeatureName): boolean;
+export declare function enabledFeatures(cfg: Config): FeatureName[];
+export declare function migrateConfig(cfg: Config): {
+    cfg: Config;
+    from: number;
+};
 export declare function initConfig(dir: string): string;
 export declare function findConfigPath(startDir: string): string | null;
 export declare function loadConfig(explicitPath?: string): ResolvedConfig;

package/dist/cjs/config.d.ts

@@ -1,18 +1,28 @@
 export declare const CONFIG_FILENAME = "sense.config.json";
 export declare const STATE_DIR = ".sense";
-export declare const SUPPORTED_CONFIG_VERSION = 1;
+export declare const SUPPORTED_CONFIG_VERSION = 2;
+export declare const FEATURE_NAMES: readonly ["links", "sections", "rank"];
+export type FeatureName = (typeof FEATURE_NAMES)[number];
 export interface Config {
     $schema?: string;
     version?: number;
     scan: {
         include: string[];
     };
+    features?: Partial<Record<FeatureName, boolean>>;
     queries: Record<string, string>;
 }
 export interface ResolvedConfig extends Config {
     baseDir: string;
     configPath: string | null;
+    migratedFrom?: number;
 }
+export declare function featureEnabled(cfg: Config, name: FeatureName): boolean;
+export declare function enabledFeatures(cfg: Config): FeatureName[];
+export declare function migrateConfig(cfg: Config): {
+    cfg: Config;
+    from: number;
+};
 export declare function initConfig(dir: string): string;
 export declare function findConfigPath(startDir: string): string | null;
 export declare function loadConfig(explicitPath?: string): ResolvedConfig;

package/dist/cjs/config.js

@@ -12,12 +12,21 @@ _export(exports, {
     get CONFIG_FILENAME () {
         return CONFIG_FILENAME;
     },
+    get FEATURE_NAMES () {
+        return FEATURE_NAMES;
+    },
     get STATE_DIR () {
         return STATE_DIR;
     },
     get SUPPORTED_CONFIG_VERSION () {
         return SUPPORTED_CONFIG_VERSION;
     },
+    get enabledFeatures () {
+        return enabledFeatures;
+    },
+    get featureEnabled () {
+        return featureEnabled;
+    },
     get findConfigPath () {
         return findConfigPath;
     },
@@ -26,6 +35,9 @@ _export(exports, {
     },
     get loadConfig () {
         return loadConfig;
+    },
+    get migrateConfig () {
+        return migrateConfig;
     }
 });
 var _nodefs = require("node:fs");
@@ -85,23 +97,76 @@ function _object_spread_props(target, source) {
 }
 var CONFIG_FILENAME = 'sense.config.json';
 var STATE_DIR = '.sense';
-var SUPPORTED_CONFIG_VERSION = 1;
-function initConfig(dir) {
-    var configPath = (0, _nodepath.join)(dir, CONFIG_FILENAME);
-    if ((0, _nodefs.existsSync)(configPath)) {
-        throw new _errorsts.SenseError('CONFIG_EXISTS', "".concat(CONFIG_FILENAME, " already exists in ").concat(dir));
+var SUPPORTED_CONFIG_VERSION = 2;
+var FEATURE_NAMES = [
+    'links',
+    'sections',
+    'rank'
+];
+function featureEnabled(cfg, name) {
+    var _cfg_features;
+    var enabled = ((_cfg_features = cfg.features) === null || _cfg_features === void 0 ? void 0 : _cfg_features[name]) !== false;
+    if (name === 'rank') return enabled && featureEnabled(cfg, 'links');
+    return enabled;
+}
+function enabledFeatures(cfg) {
+    return FEATURE_NAMES.filter(function(name) {
+        return featureEnabled(cfg, name);
+    });
+}
+// Pure per-version steps; loadConfig chains them from the file's version up to SUPPORTED_CONFIG_VERSION.
+var MIGRATIONS = {
+    // v1 -> v2: features block introduced, everything enabled (matches the old implicit behavior of `links` etc. not existing).
+    1: function(cfg) {
+        return _object_spread_props(_object_spread({}, cfg), {
+            version: 2,
+            features: Object.fromEntries(FEATURE_NAMES.map(function(name) {
+                return [
+                    name,
+                    true
+                ];
+            }))
+        });
     }
-    var starter = {
+};
+function migrateConfig(cfg) {
+    var _cfg_version;
+    var from = (_cfg_version = cfg.version) !== null && _cfg_version !== void 0 ? _cfg_version : 1;
+    var current = cfg;
+    for(var v = from; v < SUPPORTED_CONFIG_VERSION; v++){
+        var step = MIGRATIONS[v];
+        if (!step) throw new _errorsts.SenseError('CONFIG_VERSION_UNSUPPORTED', "no migration from config version ".concat(v));
+        current = step(current);
+    }
+    return {
+        cfg: current,
+        from: from
+    };
+}
+function starterConfig() {
+    return {
         $schema: 'https://unpkg.com/sensemaking/schema.json',
-        version: 1,
+        version: SUPPORTED_CONFIG_VERSION,
         scan: {
             include: [
                 '**/*.md'
             ]
         },
+        features: Object.fromEntries(FEATURE_NAMES.map(function(name) {
+            return [
+                name,
+                true
+            ];
+        })),
         queries: {}
     };
-    (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(starter, null, 2), "\n"));
+}
+function initConfig(dir) {
+    var configPath = (0, _nodepath.join)(dir, CONFIG_FILENAME);
+    if ((0, _nodefs.existsSync)(configPath)) {
+        throw new _errorsts.SenseError('CONFIG_EXISTS', "".concat(CONFIG_FILENAME, " already exists in ").concat(dir));
+    }
+    (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(starterConfig(), null, 2), "\n"));
     return configPath;
 }
 function findConfigPath(startDir) {
@@ -133,9 +198,17 @@ function loadConfig(explicitPath) {
     if (version > SUPPORTED_CONFIG_VERSION) {
         throw new _errorsts.SenseError('CONFIG_VERSION_UNSUPPORTED', "config version ".concat(version, " requires a newer sense"));
     }
+    var migratedFrom;
+    if (version < SUPPORTED_CONFIG_VERSION) {
+        var result = migrateConfig(cfg);
+        cfg = result.cfg;
+        migratedFrom = result.from;
+        (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(cfg, null, 2), "\n"));
+    }
     return _object_spread_props(_object_spread({}, cfg), {
         baseDir: (0, _nodepath.dirname)(configPath),
-        configPath: configPath
+        configPath: configPath,
+        migratedFrom: migratedFrom
     });
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/config.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config.ts"],"sourcesContent":["import { existsSync, readFileSync, writeFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { SenseError } from './errors.ts';\n\nexport const CONFIG_FILENAME = 'sense.config.json';\nexport const STATE_DIR = '.sense';\n\n// Highest sense.config.json `version` this build understands.\nexport const SUPPORTED_CONFIG_VERSION = 1;\n\nexport interface Config {\n  // Editor-only pointer to schema.json; never read by sense.\n  $schema?: string;\n  version?: number;\n  scan: { include: string[] };\n  queries: Record<string, string>;\n}\n\nexport interface ResolvedConfig extends Config {\n  baseDir: string;\n  configPath: string | null;\n}\n\n// Refuses to overwrite an existing config.\nexport function initConfig(dir: string): string {\n  const configPath = join(dir, CONFIG_FILENAME);\n  if (existsSync(configPath)) {\n    throw new SenseError('CONFIG_EXISTS', `${CONFIG_FILENAME} already exists in ${dir}`);\n  }\n  const starter: Config = {\n    $schema: 'https://unpkg.com/sensemaking/schema.json',\n    version: 1,\n    scan: { include: ['**/*.md'] },\n    queries: {},\n  };\n  writeFileSync(configPath, `${JSON.stringify(starter, null, 2)}\\n`);\n  return configPath;\n}\n\nexport function findConfigPath(startDir: string): string | null {\n  let dir = resolve(startDir);\n  for (;;) {\n    const candidate = join(dir, CONFIG_FILENAME);\n    if (existsSync(candidate)) return candidate;\n    const parent = dirname(dir);\n    if (parent === dir) return null;\n    dir = parent;\n  }\n}\n\nexport function loadConfig(explicitPath?: string): ResolvedConfig {\n  let configPath: string;\n  if (explicitPath) {\n    configPath = resolve(process.cwd(), explicitPath);\n    if (!existsSync(configPath)) throw new SenseError('CONFIG_NOT_FOUND', `config not found: ${configPath}`);\n  } else {\n    const found = findConfigPath(process.cwd());\n    if (!found) {\n      throw new SenseError('CONFIG_NOT_FOUND', `could not find ${CONFIG_FILENAME} in ${process.cwd()} or any parent directory`);\n    }\n    configPath = found;\n  }\n\n  const raw = readFileSync(configPath, 'utf8');\n  const cfg = JSON.parse(raw) as Config;\n\n  const version = cfg.version ?? 1;\n  if (version > SUPPORTED_CONFIG_VERSION) {\n    throw new SenseError('CONFIG_VERSION_UNSUPPORTED', `config version ${version} requires a newer sense`);\n  }\n\n  return { ...cfg, baseDir: dirname(configPath), configPath };\n}\n"],"names":["CONFIG_FILENAME","STATE_DIR","SUPPORTED_CONFIG_VERSION","findConfigPath","initConfig","loadConfig","dir","configPath","join","existsSync","SenseError","starter","$schema","version","scan","include","queries","writeFileSync","JSON","stringify","startDir","resolve","candidate","parent","dirname","explicitPath","cfg","process","cwd","found","raw","readFileSync","parse","baseDir"],"mappings":";;;;;;;;;;;QAIaA;eAAAA;;QACAC;eAAAA;;QAGAC;eAAAA;;QA+BGC;eAAAA;;QAfAC;eAAAA;;QA0BAC;eAAAA;;;sBAlDwC;wBACjB;wBACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEpB,IAAML,kBAAkB;AACxB,IAAMC,YAAY;AAGlB,IAAMC,2BAA2B;AAgBjC,SAASE,WAAWE,GAAW;IACpC,IAAMC,aAAaC,IAAAA,cAAI,EAACF,KAAKN;IAC7B,IAAIS,IAAAA,kBAAU,EAACF,aAAa;QAC1B,MAAM,IAAIG,oBAAU,CAAC,iBAAiB,AAAC,GAAuCJ,OAArCN,iBAAgB,uBAAyB,OAAJM;IAChF;IACA,IAAMK,UAAkB;QACtBC,SAAS;QACTC,SAAS;QACTC,MAAM;YAAEC,SAAS;gBAAC;aAAU;QAAC;QAC7BC,SAAS,CAAC;IACZ;IACAC,IAAAA,qBAAa,EAACV,YAAY,AAAC,GAAmC,OAAjCW,KAAKC,SAAS,CAACR,SAAS,MAAM,IAAG;IAC9D,OAAOJ;AACT;AAEO,SAASJ,eAAeiB,QAAgB;IAC7C,IAAId,MAAMe,IAAAA,iBAAO,EAACD;IAClB,OAAS;QACP,IAAME,YAAYd,IAAAA,cAAI,EAACF,KAAKN;QAC5B,IAAIS,IAAAA,kBAAU,EAACa,YAAY,OAAOA;QAClC,IAAMC,SAASC,IAAAA,iBAAO,EAAClB;QACvB,IAAIiB,WAAWjB,KAAK,OAAO;QAC3BA,MAAMiB;IACR;AACF;AAEO,SAASlB,WAAWoB,YAAqB;QAgB9BC;IAfhB,IAAInB;IACJ,IAAIkB,cAAc;QAChBlB,aAAac,IAAAA,iBAAO,EAACM,QAAQC,GAAG,IAAIH;QACpC,IAAI,CAAChB,IAAAA,kBAAU,EAACF,aAAa,MAAM,IAAIG,oBAAU,CAAC,oBAAoB,AAAC,qBAA+B,OAAXH;IAC7F,OAAO;QACL,IAAMsB,QAAQ1B,eAAewB,QAAQC,GAAG;QACxC,IAAI,CAACC,OAAO;YACV,MAAM,IAAInB,oBAAU,CAAC,oBAAoB,AAAC,kBAAuCiB,OAAtB3B,iBAAgB,QAAoB,OAAd2B,QAAQC,GAAG,IAAG;QACjG;QACArB,aAAasB;IACf;IAEA,IAAMC,MAAMC,IAAAA,oBAAY,EAACxB,YAAY;IACrC,IAAMmB,MAAMR,KAAKc,KAAK,CAACF;IAEvB,IAAMjB,WAAUa,eAAAA,IAAIb,OAAO,cAAXa,0BAAAA,eAAe;IAC/B,IAAIb,UAAUX,0BAA0B;QACtC,MAAM,IAAIQ,oBAAU,CAAC,8BAA8B,AAAC,kBAAyB,OAARG,SAAQ;IAC/E;IAEA,OAAO,wCAAKa;QAAKO,SAAST,IAAAA,iBAAO,EAACjB;QAAaA,YAAAA;;AACjD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config.ts"],"sourcesContent":["import { existsSync, readFileSync, writeFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { SenseError } from './errors.ts';\n\nexport const CONFIG_FILENAME = 'sense.config.json';\nexport const STATE_DIR = '.sense';\n\n// Highest sense.config.json `version` this build understands. Older versions auto-migrate on load.\nexport const SUPPORTED_CONFIG_VERSION = 2;\n\n// Each feature owns its tables, parse-time extraction, and reconcile step; verbs degrade when one is off.\nexport const FEATURE_NAMES = ['links', 'sections', 'rank'] as const;\nexport type FeatureName = (typeof FEATURE_NAMES)[number];\n\nexport interface Config {\n  // Editor-only pointer to schema.json; never read by sense.\n  $schema?: string;\n  version?: number;\n  scan: { include: string[] };\n  features?: Partial<Record<FeatureName, boolean>>;\n  queries: Record<string, string>;\n}\n\nexport interface ResolvedConfig extends Config {\n  baseDir: string;\n  configPath: string | null;\n  // Set when loadConfig auto-migrated the file on disk; cli reports it.\n  migratedFrom?: number;\n}\n\n// Absent block or key means enabled -- features are opt-out. `rank` additionally requires `links`.\nexport function featureEnabled(cfg: Config, name: FeatureName): boolean {\n  const enabled = cfg.features?.[name] !== false;\n  if (name === 'rank') return enabled && featureEnabled(cfg, 'links');\n  return enabled;\n}\n\nexport function enabledFeatures(cfg: Config): FeatureName[] {\n  return FEATURE_NAMES.filter((name) => featureEnabled(cfg, name));\n}\n\n// Pure per-version steps; loadConfig chains them from the file's version up to SUPPORTED_CONFIG_VERSION.\nconst MIGRATIONS: Record<number, (cfg: Config) => Config> = {\n  // v1 -> v2: features block introduced, everything enabled (matches the old implicit behavior of `links` etc. not existing).\n  1: (cfg) => ({ ...cfg, version: 2, features: Object.fromEntries(FEATURE_NAMES.map((name) => [name, true])) as Config['features'] }),\n};\n\nexport function migrateConfig(cfg: Config): { cfg: Config; from: number } {\n  const from = cfg.version ?? 1;\n  let current = cfg;\n  for (let v = from; v < SUPPORTED_CONFIG_VERSION; v++) {\n    const step = MIGRATIONS[v];\n    if (!step) throw new SenseError('CONFIG_VERSION_UNSUPPORTED', `no migration from config version ${v}`);\n    current = step(current);\n  }\n  return { cfg: current, from };\n}\n\nfunction starterConfig(): Config {\n  return {\n    $schema: 'https://unpkg.com/sensemaking/schema.json',\n    version: SUPPORTED_CONFIG_VERSION,\n    scan: { include: ['**/*.md'] },\n    features: Object.fromEntries(FEATURE_NAMES.map((name) => [name, true])) as Config['features'],\n    queries: {},\n  };\n}\n\n// Refuses to overwrite an existing config.\nexport function initConfig(dir: string): string {\n  const configPath = join(dir, CONFIG_FILENAME);\n  if (existsSync(configPath)) {\n    throw new SenseError('CONFIG_EXISTS', `${CONFIG_FILENAME} already exists in ${dir}`);\n  }\n  writeFileSync(configPath, `${JSON.stringify(starterConfig(), null, 2)}\\n`);\n  return configPath;\n}\n\nexport function findConfigPath(startDir: string): string | null {\n  let dir = resolve(startDir);\n  for (;;) {\n    const candidate = join(dir, CONFIG_FILENAME);\n    if (existsSync(candidate)) return candidate;\n    const parent = dirname(dir);\n    if (parent === dir) return null;\n    dir = parent;\n  }\n}\n\nexport function loadConfig(explicitPath?: string): ResolvedConfig {\n  let configPath: string;\n  if (explicitPath) {\n    configPath = resolve(process.cwd(), explicitPath);\n    if (!existsSync(configPath)) throw new SenseError('CONFIG_NOT_FOUND', `config not found: ${configPath}`);\n  } else {\n    const found = findConfigPath(process.cwd());\n    if (!found) {\n      throw new SenseError('CONFIG_NOT_FOUND', `could not find ${CONFIG_FILENAME} in ${process.cwd()} or any parent directory`);\n    }\n    configPath = found;\n  }\n\n  const raw = readFileSync(configPath, 'utf8');\n  let cfg = JSON.parse(raw) as Config;\n\n  const version = cfg.version ?? 1;\n  if (version > SUPPORTED_CONFIG_VERSION) {\n    throw new SenseError('CONFIG_VERSION_UNSUPPORTED', `config version ${version} requires a newer sense`);\n  }\n\n  let migratedFrom: number | undefined;\n  if (version < SUPPORTED_CONFIG_VERSION) {\n    const result = migrateConfig(cfg);\n    cfg = result.cfg;\n    migratedFrom = result.from;\n    writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}\\n`);\n  }\n\n  return { ...cfg, baseDir: dirname(configPath), configPath, migratedFrom };\n}\n"],"names":["CONFIG_FILENAME","FEATURE_NAMES","STATE_DIR","SUPPORTED_CONFIG_VERSION","enabledFeatures","featureEnabled","findConfigPath","initConfig","loadConfig","migrateConfig","cfg","name","enabled","features","filter","MIGRATIONS","version","Object","fromEntries","map","from","current","v","step","SenseError","starterConfig","$schema","scan","include","queries","dir","configPath","join","existsSync","writeFileSync","JSON","stringify","startDir","resolve","candidate","parent","dirname","explicitPath","process","cwd","found","raw","readFileSync","parse","migratedFrom","result","baseDir"],"mappings":"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"}

package/dist/cjs/db.d.cts

@@ -1,7 +1,7 @@
 import { DatabaseSync } from 'node:sqlite';
 import type { Config, ResolvedConfig } from './config.js';
 export declare const DB_FILENAME = "cache.db";
-export declare const SCHEMA_VERSION = "2";
+export declare const SCHEMA_VERSION = "3";
 export interface OpenResult {
     db: DatabaseSync;
     cfg: ResolvedConfig;

package/dist/cjs/db.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseSync } from 'node:sqlite';
 import type { Config, ResolvedConfig } from './config.js';
 export declare const DB_FILENAME = "cache.db";
-export declare const SCHEMA_VERSION = "2";
+export declare const SCHEMA_VERSION = "3";
 export interface OpenResult {
     db: DatabaseSync;
     cfg: ResolvedConfig;

package/dist/cjs/db.js

@@ -38,6 +38,7 @@ var _nodefs = require("node:fs");
 var _nodepath = require("node:path");
 var _nodesqlite = require("node:sqlite");
 var _configts = require("./config.js");
+var _indexts = require("./features/index.js");
 var _scants = require("./scan.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -65,7 +66,7 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
 var DB_FILENAME = 'cache.db';
-var SCHEMA_VERSION = '2';
+var SCHEMA_VERSION = '3';
 function quoteIdent(name) {
     return '"'.concat(name.split('"').join('""'), '"');
 }
@@ -99,11 +100,33 @@ function getColumns(db) {
         return r.name;
     }));
 }
-// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter` can't dump file text into context.
-function ensureSchema(db) {
+// Content is a separate table (not a column on frontmatter) so `SELECT * FROM frontmatter`
+// can't dump file text into context. Features add their own tables after the core ones.
+function ensureSchema(db, cfg) {
     db.exec('CREATE TABLE IF NOT EXISTS frontmatter ("path" TEXT PRIMARY KEY, "_mtime" REAL, "_size" INTEGER)');
     db.exec("CREATE VIRTUAL TABLE IF NOT EXISTS content USING fts5(title, summary, text, path UNINDEXED, tokenize = 'porter unicode61')");
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = (0, _indexts.activeFeatures)(cfg)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var feature = _step.value;
+            feature.schema(db);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
     if (getMeta(db, 'schema_version') === null) setMeta(db, 'schema_version', SCHEMA_VERSION);
+    if (getMeta(db, 'features') === null) setMeta(db, 'features', (0, _configts.enabledFeatures)(cfg).join(','));
 }
 function getMeta(db, key) {
     var row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
@@ -145,6 +168,7 @@ function reconcile(db, cfg, baseDir) {
         parsed: 0,
         warnings: []
     };
+    var features = (0, _indexts.activeFeatures)(cfg);
     var seenColumns = getColumns(db);
     var newColumns = [];
     var parsedDocs = [];
@@ -154,7 +178,7 @@ function reconcile(db, cfg, baseDir) {
         for(var _iterator = toReparse[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var file = _step.value;
             var _warnings;
-            var _parseFile = (0, _scants.parseFile)(file), doc = _parseFile.doc, fileWarnings = _parseFile.warnings;
+            var _parseFile = (0, _scants.parseFile)(file, features), doc = _parseFile.doc, fileWarnings = _parseFile.warnings;
             (_warnings = warnings).push.apply(_warnings, _to_consumable_array(fileWarnings));
             var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
             try {
@@ -201,6 +225,7 @@ function reconcile(db, cfg, baseDir) {
     }).join(', '), ")");
     db.exec('BEGIN');
     try {
+        var _feature_afterReconcile;
         var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
         try {
             for(var _iterator2 = newColumns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
@@ -229,8 +254,29 @@ function reconcile(db, cfg, baseDir) {
             try {
                 for(var _iterator3 = vanished[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
                     var path = _step3.value;
+                    var _feature_remove;
                     del.run(path);
                     delBody.run(path);
+                    var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+                    try {
+                        for(var _iterator4 = features[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true){
+                            var feature = _step4.value;
+                            (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, db, path);
+                        }
+                    } catch (err) {
+                        _didIteratorError4 = true;
+                        _iteratorError4 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                                _iterator4.return();
+                            }
+                        } finally{
+                            if (_didIteratorError4) {
+                                throw _iteratorError4;
+                            }
+                        }
+                    }
                 }
             } catch (err) {
                 _didIteratorError3 = true;
@@ -250,10 +296,10 @@ function reconcile(db, cfg, baseDir) {
         if (parsedDocs.length > 0) {
             var insert = db.prepare(insertSql);
             var insertBody = db.prepare('INSERT INTO content (title, summary, text, "path") VALUES (?, ?, ?, ?)');
-            var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+            var _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
             try {
                 var _loop = function() {
-                    var doc = _step4.value;
+                    var doc = _step5.value;
                     var _insert;
                     var values = allColumns.map(function(col) {
                         var _doc_data_col;
@@ -265,23 +311,65 @@ function reconcile(db, cfg, baseDir) {
                     (_insert = insert).run.apply(_insert, _to_consumable_array(values));
                     delBody.run(doc.relPath);
                     insertBody.run(doc.search.title, doc.search.summary, doc.search.text, doc.relPath);
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = features[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var feature = _step.value;
+                            var _feature_remove, _feature_store;
+                            (_feature_remove = feature.remove) === null || _feature_remove === void 0 ? void 0 : _feature_remove.call(feature, db, doc.relPath);
+                            (_feature_store = feature.store) === null || _feature_store === void 0 ? void 0 : _feature_store.call(feature, db, doc.relPath, doc.extracted[feature.name]);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
                 };
-                for(var _iterator4 = parsedDocs[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true)_loop();
+                for(var _iterator5 = parsedDocs[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true)_loop();
             } catch (err) {
-                _didIteratorError4 = true;
-                _iteratorError4 = err;
+                _didIteratorError5 = true;
+                _iteratorError5 = err;
             } finally{
                 try {
-                    if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
-                        _iterator4.return();
+                    if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                        _iterator5.return();
                     }
                 } finally{
-                    if (_didIteratorError4) {
-                        throw _iteratorError4;
+                    if (_didIteratorError5) {
+                        throw _iteratorError5;
                     }
                 }
             }
         }
+        var _iteratorNormalCompletion6 = true, _didIteratorError6 = false, _iteratorError6 = undefined;
+        try {
+            for(var _iterator6 = features[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true){
+                var feature1 = _step6.value;
+                (_feature_afterReconcile = feature1.afterReconcile) === null || _feature_afterReconcile === void 0 ? void 0 : _feature_afterReconcile.call(feature1, db, files);
+            }
+        } catch (err) {
+            _didIteratorError6 = true;
+            _iteratorError6 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
+                    _iterator6.return();
+                }
+            } finally{
+                if (_didIteratorError6) {
+                    throw _iteratorError6;
+                }
+            }
+        }
         db.exec('COMMIT');
     } catch (err) {
         db.exec('ROLLBACK');
@@ -303,9 +391,12 @@ function open(cfg) {
     db.exec('PRAGMA busy_timeout = 5000');
     registerFunctions(db);
     db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');
-    // Schema version mismatch: reconcile only reparses changed files, so an old cache can't be patched up incrementally -- rebuild instead.
+    // Schema-version or feature-set mismatch: reconcile only reparses changed files, so an
+    // old cache can't be patched incrementally -- rebuild instead (cheap: nothing expensive lives here).
     var version = getMeta(db, 'schema_version');
-    if (version !== null && version !== SCHEMA_VERSION) {
+    var features = getMeta(db, 'features');
+    var wantFeatures = (0, _configts.enabledFeatures)(cfg).join(',');
+    if (version !== null && version !== SCHEMA_VERSION || features !== null && features !== wantFeatures) {
         db.close();
         (0, _nodefs.rmSync)(stateDir, {
             recursive: true,
@@ -313,7 +404,7 @@ function open(cfg) {
         });
         return open(cfg);
     }
-    ensureSchema(db);
+    ensureSchema(db, cfg);
     var _reconcile = reconcile(db, cfg, cfg.baseDir), parsed = _reconcile.parsed, warnings = _reconcile.warnings;
     return {
         db: db,