sensemaking 0.1.0

package/dist/cjs/config.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get CONFIG_FILENAME () {
+        return CONFIG_FILENAME;
+    },
+    get STATE_DIR () {
+        return STATE_DIR;
+    },
+    get SUPPORTED_CONFIG_VERSION () {
+        return SUPPORTED_CONFIG_VERSION;
+    },
+    get findConfigPath () {
+        return findConfigPath;
+    },
+    get initConfig () {
+        return initConfig;
+    },
+    get loadConfig () {
+        return loadConfig;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _errorsts = require("./errors.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+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 starter = {
+        $schema: 'https://unpkg.com/sensemaking/schema.json',
+        version: 1,
+        scan: {
+            include: [
+                '**/*.md'
+            ]
+        },
+        queries: {
+            all: 'SELECT path, title FROM docs ORDER BY path',
+            'by-tag': 'SELECT path, title FROM docs WHERE has(tags, ?) ORDER BY path'
+        }
+    };
+    (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(starter, null, 2), "\n"));
+    return configPath;
+}
+function findConfigPath(startDir) {
+    var dir = (0, _nodepath.resolve)(startDir);
+    for(;;){
+        var candidate = (0, _nodepath.join)(dir, CONFIG_FILENAME);
+        if ((0, _nodefs.existsSync)(candidate)) return candidate;
+        var parent = (0, _nodepath.dirname)(dir);
+        if (parent === dir) return null;
+        dir = parent;
+    }
+}
+function loadConfig(explicitPath) {
+    var _cfg_version;
+    var configPath;
+    if (explicitPath) {
+        configPath = (0, _nodepath.resolve)(process.cwd(), explicitPath);
+        if (!(0, _nodefs.existsSync)(configPath)) throw new _errorsts.SenseError('CONFIG_NOT_FOUND', "config not found: ".concat(configPath));
+    } else {
+        var found = findConfigPath(process.cwd());
+        if (!found) {
+            throw new _errorsts.SenseError('CONFIG_NOT_FOUND', "could not find ".concat(CONFIG_FILENAME, " in ").concat(process.cwd(), " or any parent directory"));
+        }
+        configPath = found;
+    }
+    var raw = (0, _nodefs.readFileSync)(configPath, 'utf8');
+    var cfg = JSON.parse(raw);
+    // Missing `version` is treated as 1. A version newer than this build
+    // supports is a hard error -- misinterpreting a future config format
+    // silently would be worse than refusing to run.
+    var version = (_cfg_version = cfg.version) !== null && _cfg_version !== void 0 ? _cfg_version : 1;
+    if (version > SUPPORTED_CONFIG_VERSION) {
+        throw new _errorsts.SenseError('CONFIG_VERSION_UNSUPPORTED', "config version ".concat(version, " requires a newer sense"));
+    }
+    return _object_spread_props(_object_spread({}, cfg), {
+        baseDir: (0, _nodepath.dirname)(configPath),
+        configPath: configPath
+    });
+}
+/* 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

@@ -0,0 +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\n// All config concerns live here: the file name, discovery, parsing, and\n// version gating. db.ts consumes only the result -- it does no discovery\n// and no version logic of its own.\n\nexport const CONFIG_FILENAME = 'sense.config.json';\nexport const STATE_DIR = '.sense';\n\n// The highest `sense.config.json` `version` this build understands. Bumped\n// only when the config *format* changes in a breaking way -- unrelated to\n// the package's own semver.\nexport const SUPPORTED_CONFIG_VERSION = 1;\n\n// sense.config.json's on-disk shape.\nexport interface Config {\n  // Editor-only pointer to schema.json; never read by sense.\n  $schema?: string;\n  // Config format version. Omitted = 1.\n  version?: number;\n  scan: { include: string[] };\n  queries: Record<string, string>;\n}\n\n// A Config resolved to where it lives on disk (or, for tests, a baseDir\n// supplied directly with no backing file). `scan.include` globs and the\n// `.sense/` state dir both resolve relative to `baseDir`, never process cwd.\nexport interface ResolvedConfig extends Config {\n  baseDir: string;\n  configPath: string | null;\n}\n\n// `sense init`: write a starter config into `dir` — the example doubles as\n// the documentation of the format. Refuses to overwrite an existing one.\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      all: 'SELECT path, title FROM docs ORDER BY path',\n      'by-tag': 'SELECT path, title FROM docs WHERE has(tags, ?) ORDER BY path',\n    },\n  };\n  writeFileSync(configPath, `${JSON.stringify(starter, null, 2)}\\n`);\n  return configPath;\n}\n\n// Find sense.config.json by walking up from startDir, git-style.\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\n// Resolve + load sense.config.json: `explicitPath` bypasses walk-up\n// discovery (as `--config` does on the CLI); otherwise discovery starts at\n// process cwd. Throws on a missing config, invalid JSON, or a `version`\n// newer than this build supports -- callers surface the message and exit 1.\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  // Missing `version` is treated as 1. A version newer than this build\n  // supports is a hard error -- misinterpreting a future config format\n  // silently would be worse than refusing to run.\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","all","writeFileSync","JSON","stringify","startDir","resolve","candidate","parent","dirname","explicitPath","cfg","process","cwd","found","raw","readFileSync","parse","baseDir"],"mappings":";;;;;;;;;;;QAQaA;eAAAA;;QACAC;eAAAA;;QAKAC;eAAAA;;QAyCGC;eAAAA;;QAnBAC;eAAAA;;QAkCAC;eAAAA;;;sBAtEwC;wBACjB;wBACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMpB,IAAML,kBAAkB;AACxB,IAAMC,YAAY;AAKlB,IAAMC,2BAA2B;AAsBjC,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;YACPC,KAAK;YACL,UAAU;QACZ;IACF;IACAC,IAAAA,qBAAa,EAACX,YAAY,AAAC,GAAmC,OAAjCY,KAAKC,SAAS,CAACT,SAAS,MAAM,IAAG;IAC9D,OAAOJ;AACT;AAGO,SAASJ,eAAekB,QAAgB;IAC7C,IAAIf,MAAMgB,IAAAA,iBAAO,EAACD;IAClB,OAAS;QACP,IAAME,YAAYf,IAAAA,cAAI,EAACF,KAAKN;QAC5B,IAAIS,IAAAA,kBAAU,EAACc,YAAY,OAAOA;QAClC,IAAMC,SAASC,IAAAA,iBAAO,EAACnB;QACvB,IAAIkB,WAAWlB,KAAK,OAAO;QAC3BA,MAAMkB;IACR;AACF;AAMO,SAASnB,WAAWqB,YAAqB;QAmB9BC;IAlBhB,IAAIpB;IACJ,IAAImB,cAAc;QAChBnB,aAAae,IAAAA,iBAAO,EAACM,QAAQC,GAAG,IAAIH;QACpC,IAAI,CAACjB,IAAAA,kBAAU,EAACF,aAAa,MAAM,IAAIG,oBAAU,CAAC,oBAAoB,AAAC,qBAA+B,OAAXH;IAC7F,OAAO;QACL,IAAMuB,QAAQ3B,eAAeyB,QAAQC,GAAG;QACxC,IAAI,CAACC,OAAO;YACV,MAAM,IAAIpB,oBAAU,CAAC,oBAAoB,AAAC,kBAAuCkB,OAAtB5B,iBAAgB,QAAoB,OAAd4B,QAAQC,GAAG,IAAG;QACjG;QACAtB,aAAauB;IACf;IAEA,IAAMC,MAAMC,IAAAA,oBAAY,EAACzB,YAAY;IACrC,IAAMoB,MAAMR,KAAKc,KAAK,CAACF;IAEvB,qEAAqE;IACrE,qEAAqE;IACrE,gDAAgD;IAChD,IAAMlB,WAAUc,eAAAA,IAAId,OAAO,cAAXc,0BAAAA,eAAe;IAC/B,IAAId,UAAUX,0BAA0B;QACtC,MAAM,IAAIQ,oBAAU,CAAC,8BAA8B,AAAC,kBAAyB,OAARG,SAAQ;IAC/E;IAEA,OAAO,wCAAKc;QAAKO,SAAST,IAAAA,iBAAO,EAAClB;QAAaA,YAAAA;;AACjD"}

package/dist/cjs/db.d.cts

@@ -0,0 +1,20 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { Config, ResolvedConfig } from './config.js';
+export declare const DB_FILENAME = "cache.db";
+export declare const SCHEMA_VERSION = "1";
+export interface OpenResult {
+    db: DatabaseSync;
+    cfg: ResolvedConfig;
+    dbPath: string;
+    parsed: number;
+    warnings: string[];
+}
+export declare function getMeta(db: DatabaseSync, key: string): string | null;
+export declare function setMeta(db: DatabaseSync, key: string, value: string | null): void;
+export declare function docCount(db: DatabaseSync): number;
+export declare function reconcile(db: DatabaseSync, cfg: Config, baseDir: string): {
+    parsed: number;
+    warnings: string[];
+};
+export declare function open(cfg: ResolvedConfig): OpenResult;
+export declare function rebuild(cfg: ResolvedConfig): OpenResult;

package/dist/cjs/db.d.ts

@@ -0,0 +1,20 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { Config, ResolvedConfig } from './config.js';
+export declare const DB_FILENAME = "cache.db";
+export declare const SCHEMA_VERSION = "1";
+export interface OpenResult {
+    db: DatabaseSync;
+    cfg: ResolvedConfig;
+    dbPath: string;
+    parsed: number;
+    warnings: string[];
+}
+export declare function getMeta(db: DatabaseSync, key: string): string | null;
+export declare function setMeta(db: DatabaseSync, key: string, value: string | null): void;
+export declare function docCount(db: DatabaseSync): number;
+export declare function reconcile(db: DatabaseSync, cfg: Config, baseDir: string): {
+    parsed: number;
+    warnings: string[];
+};
+export declare function open(cfg: ResolvedConfig): OpenResult;
+export declare function rebuild(cfg: ResolvedConfig): OpenResult;

package/dist/cjs/db.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DB_FILENAME () {
+        return DB_FILENAME;
+    },
+    get SCHEMA_VERSION () {
+        return SCHEMA_VERSION;
+    },
+    get docCount () {
+        return docCount;
+    },
+    get getMeta () {
+        return getMeta;
+    },
+    get open () {
+        return open;
+    },
+    get rebuild () {
+        return rebuild;
+    },
+    get reconcile () {
+        return reconcile;
+    },
+    get setMeta () {
+        return setMeta;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _nodesqlite = require("node:sqlite");
+var _configts = require("./config.js");
+var _scants = require("./scan.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    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 = '1';
+// Quote a SQL identifier, escaping embedded double quotes so an unusual
+// frontmatter key (however unlikely) can't break out of the identifier.
+function quoteIdent(name) {
+    return '"'.concat(name.split('"').join('""'), '"');
+}
+// The one custom SQL function in the whole tool: has(field, value).
+//   - JSON-array field (stored as JSON text, e.g. `["a","b"]`) -> membership
+//   - string field -> substring
+//   - NULL -> false
+function registerFunctions(db) {
+    db.function('has', {
+        deterministic: true,
+        varargs: false
+    }, function(field, value) {
+        if (field === null || field === undefined) return 0;
+        var needle = String(value);
+        if (typeof field === 'string') {
+            // Try JSON array first (arrays are stored as JSON text).
+            if (field.startsWith('[')) {
+                try {
+                    var parsed = JSON.parse(field);
+                    if (Array.isArray(parsed)) {
+                        return parsed.some(function(item) {
+                            return String(item) === needle;
+                        }) ? 1 : 0;
+                    }
+                } catch (unused) {
+                // fall through to substring match
+                }
+            }
+            return field.includes(needle) ? 1 : 0;
+        }
+        // Numbers, etc: coerce to string and substring-match.
+        return String(field).includes(needle) ? 1 : 0;
+    });
+}
+function getColumns(db) {
+    var rows = db.prepare('PRAGMA table_info(docs)').all();
+    return new Set(rows.map(function(r) {
+        return r.name;
+    }));
+}
+function ensureSchema(db) {
+    db.exec('CREATE TABLE IF NOT EXISTS docs ("path" TEXT PRIMARY KEY, "_mtime" REAL, "_size" INTEGER)');
+    db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');
+    if (getMeta(db, 'schema_version') === null) setMeta(db, 'schema_version', SCHEMA_VERSION);
+}
+function getMeta(db, key) {
+    var row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key);
+    return row ? row.value : null;
+}
+function setMeta(db, key, value) {
+    if (value === null) {
+        db.prepare('DELETE FROM meta WHERE key = ?').run(key);
+        return;
+    }
+    db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, value);
+}
+function docCount(db) {
+    var row = db.prepare('SELECT COUNT(*) AS n FROM docs').get();
+    return row.n;
+}
+function reconcile(db, cfg, baseDir) {
+    var files = (0, _scants.listFiles)(cfg, baseDir);
+    var currentSet = new Set(files.map(function(f) {
+        return f.relPath;
+    }));
+    var existingRows = db.prepare('SELECT "path", "_mtime", "_size" FROM docs').all();
+    var existing = new Map(existingRows.map(function(r) {
+        return [
+            r.path,
+            r
+        ];
+    }));
+    var vanished = existingRows.filter(function(r) {
+        return !currentSet.has(r.path);
+    }).map(function(r) {
+        return r.path;
+    });
+    var toReparse = files.filter(function(f) {
+        var row = existing.get(f.relPath);
+        return !row || row._mtime !== f.mtimeMs || row._size !== f.size;
+    });
+    if (vanished.length === 0 && toReparse.length === 0) return {
+        parsed: 0,
+        warnings: []
+    };
+    var seenColumns = getColumns(db);
+    var newColumns = [];
+    var parsedDocs = [];
+    var warnings = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        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;
+            (_warnings = warnings).push.apply(_warnings, _to_consumable_array(fileWarnings));
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = Object.keys(doc.data)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var key = _step1.value;
+                    if (!seenColumns.has(key)) {
+                        seenColumns.add(key);
+                        newColumns.push(key);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+            parsedDocs.push(doc);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    // seenColumns already contains the reserved columns (they're real columns
+    // of `docs`), so spreading it alone avoids duplicate names in the INSERT.
+    var allColumns = _to_consumable_array(seenColumns);
+    var insertSql = "INSERT OR REPLACE INTO docs (".concat(allColumns.map(quoteIdent).join(', '), ") VALUES (").concat(allColumns.map(function() {
+        return '?';
+    }).join(', '), ")");
+    db.exec('BEGIN');
+    try {
+        var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+        try {
+            for(var _iterator2 = newColumns[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                var col = _step2.value;
+                db.exec("ALTER TABLE docs ADD COLUMN ".concat(quoteIdent(col)));
+            }
+        } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                    _iterator2.return();
+                }
+            } finally{
+                if (_didIteratorError2) {
+                    throw _iteratorError2;
+                }
+            }
+        }
+        if (vanished.length > 0) {
+            var del = db.prepare('DELETE FROM docs WHERE "path" = ?');
+            var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+            try {
+                for(var _iterator3 = vanished[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                    var path = _step3.value;
+                    del.run(path);
+                }
+            } catch (err) {
+                _didIteratorError3 = true;
+                _iteratorError3 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                        _iterator3.return();
+                    }
+                } finally{
+                    if (_didIteratorError3) {
+                        throw _iteratorError3;
+                    }
+                }
+            }
+        }
+        if (parsedDocs.length > 0) {
+            var insert = db.prepare(insertSql);
+            var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+            try {
+                var _loop = function() {
+                    var doc = _step4.value;
+                    var _insert;
+                    var values = allColumns.map(function(col) {
+                        var _doc_data_col;
+                        if (col === 'path') return doc.relPath;
+                        if (col === '_mtime') return doc.mtimeMs;
+                        if (col === '_size') return doc.size;
+                        return (_doc_data_col = doc.data[col]) !== null && _doc_data_col !== void 0 ? _doc_data_col : null;
+                    });
+                    (_insert = insert).run.apply(_insert, _to_consumable_array(values));
+                };
+                for(var _iterator4 = parsedDocs[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true)_loop();
+            } catch (err) {
+                _didIteratorError4 = true;
+                _iteratorError4 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                        _iterator4.return();
+                    }
+                } finally{
+                    if (_didIteratorError4) {
+                        throw _iteratorError4;
+                    }
+                }
+            }
+        }
+        db.exec('COMMIT');
+    } catch (err) {
+        db.exec('ROLLBACK');
+        throw err;
+    }
+    return {
+        parsed: parsedDocs.length,
+        warnings: warnings
+    };
+}
+function open(cfg) {
+    var stateDir = (0, _nodepath.join)(cfg.baseDir, _configts.STATE_DIR);
+    (0, _nodefs.mkdirSync)(stateDir, {
+        recursive: true
+    });
+    var dbPath = (0, _nodepath.join)(stateDir, DB_FILENAME);
+    var db = new _nodesqlite.DatabaseSync(dbPath);
+    db.exec('PRAGMA journal_mode = WAL');
+    db.exec('PRAGMA busy_timeout = 5000');
+    registerFunctions(db);
+    ensureSchema(db);
+    var _reconcile = reconcile(db, cfg, cfg.baseDir), parsed = _reconcile.parsed, warnings = _reconcile.warnings;
+    return {
+        db: db,
+        cfg: cfg,
+        dbPath: dbPath,
+        parsed: parsed,
+        warnings: warnings
+    };
+}
+function rebuild(cfg) {
+    (0, _nodefs.rmSync)((0, _nodepath.join)(cfg.baseDir, _configts.STATE_DIR), {
+        recursive: true,
+        force: true
+    });
+    return open(cfg);
+}
+/* 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/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/db.ts"],"sourcesContent":["import { mkdirSync, rmSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\nimport type { Config, ResolvedConfig } from './config.ts';\nimport { STATE_DIR } from './config.ts';\nimport type { ParsedDoc } from './scan.ts';\nimport { listFiles, parseFile } from './scan.ts';\n\n// Rows -> SQLite only: schema/ALTER, the reconcile diff + transaction,\n// pragmas, the meta table, has() registration. Filesystem reading and\n// frontmatter parsing live in scan.ts; this module never touches\n// node:fs/gray-matter directly and never prints (throws are for callers).\n\nexport const DB_FILENAME = 'cache.db';\nexport const SCHEMA_VERSION = '1';\n\nexport interface OpenResult {\n  db: DatabaseSync;\n  cfg: ResolvedConfig;\n  dbPath: string;\n  // Number of files (re)parsed by this open's reconcile -- 0 on a fully\n  // warm cache. Tests use this as reconcile instrumentation.\n  parsed: number;\n  warnings: string[];\n}\n\n// Quote a SQL identifier, escaping embedded double quotes so an unusual\n// frontmatter key (however unlikely) can't break out of the identifier.\nfunction quoteIdent(name: string): string {\n  return `\"${name.split('\"').join('\"\"')}\"`;\n}\n\n// The one custom SQL function in the whole tool: has(field, value).\n//   - JSON-array field (stored as JSON text, e.g. `[\"a\",\"b\"]`) -> membership\n//   - string field -> substring\n//   - NULL -> false\nfunction registerFunctions(db: DatabaseSync): void {\n  db.function('has', { deterministic: true, varargs: false }, (field: unknown, value: unknown): number => {\n    if (field === null || field === undefined) return 0;\n\n    const needle = String(value);\n\n    if (typeof field === 'string') {\n      // Try JSON array first (arrays are stored as JSON text).\n      if (field.startsWith('[')) {\n        try {\n          const parsed = JSON.parse(field);\n          if (Array.isArray(parsed)) {\n            return parsed.some((item) => String(item) === needle) ? 1 : 0;\n          }\n        } catch {\n          // fall through to substring match\n        }\n      }\n      return field.includes(needle) ? 1 : 0;\n    }\n\n    // Numbers, etc: coerce to string and substring-match.\n    return String(field).includes(needle) ? 1 : 0;\n  });\n}\n\nfunction getColumns(db: DatabaseSync): Set<string> {\n  const rows = db.prepare('PRAGMA table_info(docs)').all() as Array<{ name: string }>;\n  return new Set(rows.map((r) => r.name));\n}\n\nfunction ensureSchema(db: DatabaseSync): void {\n  db.exec(`CREATE TABLE IF NOT EXISTS docs (\"path\" TEXT PRIMARY KEY, \"_mtime\" REAL, \"_size\" INTEGER)`);\n  db.exec('CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT)');\n  if (getMeta(db, 'schema_version') === null) setMeta(db, 'schema_version', SCHEMA_VERSION);\n}\n\nexport function getMeta(db: DatabaseSync, key: string): string | null {\n  const row = db.prepare('SELECT value FROM meta WHERE key = ?').get(key) as { value: string } | undefined;\n  return row ? row.value : null;\n}\n\nexport function setMeta(db: DatabaseSync, key: string, value: string | null): void {\n  if (value === null) {\n    db.prepare('DELETE FROM meta WHERE key = ?').run(key);\n    return;\n  }\n  db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(key, value);\n}\n\nexport function docCount(db: DatabaseSync): number {\n  const row = db.prepare('SELECT COUNT(*) AS n FROM docs').get() as { n: number };\n  return row.n;\n}\n\n// Reconcile the `docs` table against the filesystem: glob current files via\n// scan.ts, reparse stale (mtime/size changed) + new files in one\n// transaction, DELETE vanished paths, ALTER TABLE ADD COLUMN for newly\n// discovered frontmatter keys. Returns the number of files (re)parsed and\n// any warnings scan.ts collected (e.g. reserved-key collisions).\nexport function reconcile(db: DatabaseSync, cfg: Config, baseDir: string): { parsed: number; warnings: string[] } {\n  const files = listFiles(cfg, baseDir);\n  const currentSet = new Set(files.map((f) => f.relPath));\n\n  const existingRows = db.prepare(`SELECT \"path\", \"_mtime\", \"_size\" FROM docs`).all() as Array<{\n    path: string;\n    _mtime: number;\n    _size: number;\n  }>;\n  const existing = new Map(existingRows.map((r) => [r.path, r]));\n  const vanished = existingRows.filter((r) => !currentSet.has(r.path)).map((r) => r.path);\n\n  const toReparse = files.filter((f) => {\n    const row = existing.get(f.relPath);\n    return !row || row._mtime !== f.mtimeMs || row._size !== f.size;\n  });\n\n  if (vanished.length === 0 && toReparse.length === 0) return { parsed: 0, warnings: [] };\n\n  const seenColumns = getColumns(db);\n  const newColumns: string[] = [];\n  const parsedDocs: ParsedDoc[] = [];\n  const warnings: string[] = [];\n\n  for (const file of toReparse) {\n    const { doc, warnings: fileWarnings } = parseFile(file);\n    warnings.push(...fileWarnings);\n    for (const key of Object.keys(doc.data)) {\n      if (!seenColumns.has(key)) {\n        seenColumns.add(key);\n        newColumns.push(key);\n      }\n    }\n    parsedDocs.push(doc);\n  }\n\n  // seenColumns already contains the reserved columns (they're real columns\n  // of `docs`), so spreading it alone avoids duplicate names in the INSERT.\n  const allColumns = [...seenColumns];\n  const insertSql = `INSERT OR REPLACE INTO docs (${allColumns.map(quoteIdent).join(', ')}) VALUES (${allColumns.map(() => '?').join(', ')})`;\n\n  db.exec('BEGIN');\n  try {\n    for (const col of newColumns) db.exec(`ALTER TABLE docs ADD COLUMN ${quoteIdent(col)}`);\n    if (vanished.length > 0) {\n      const del = db.prepare(`DELETE FROM docs WHERE \"path\" = ?`);\n      for (const path of vanished) del.run(path);\n    }\n    if (parsedDocs.length > 0) {\n      const insert = db.prepare(insertSql);\n      for (const doc of parsedDocs) {\n        const values = allColumns.map((col) => {\n          if (col === 'path') return doc.relPath;\n          if (col === '_mtime') return doc.mtimeMs;\n          if (col === '_size') return doc.size;\n          return doc.data[col] ?? null;\n        });\n        insert.run(...values);\n      }\n    }\n    db.exec('COMMIT');\n  } catch (err) {\n    db.exec('ROLLBACK');\n    throw err;\n  }\n\n  return { parsed: parsedDocs.length, warnings };\n}\n\n// open(resolved config): open (or create) the on-disk SQLite cache at\n// `<baseDir>/.sense/cache.db`, reconcile against the filesystem, and return\n// a live handle. The DB is a warm start, never a source of truth -- the\n// `.md` files remain truth. Takes only an already-resolved config; discovery\n// and version-gating are config.ts's job, not this one's.\nexport function open(cfg: ResolvedConfig): OpenResult {\n  const stateDir = join(cfg.baseDir, STATE_DIR);\n  mkdirSync(stateDir, { recursive: true });\n  const dbPath = join(stateDir, DB_FILENAME);\n\n  const db = new DatabaseSync(dbPath);\n  db.exec('PRAGMA journal_mode = WAL');\n  db.exec('PRAGMA busy_timeout = 5000');\n  registerFunctions(db);\n\n  ensureSchema(db);\n  const { parsed, warnings } = reconcile(db, cfg, cfg.baseDir);\n\n  return { db, cfg, dbPath, parsed, warnings };\n}\n\n// Delete the `.sense/` state dir entirely and reconcile fresh -- the manual\n// reset for lingering columns or a doubted cache.\nexport function rebuild(cfg: ResolvedConfig): OpenResult {\n  rmSync(join(cfg.baseDir, STATE_DIR), { recursive: true, force: true });\n  return open(cfg);\n}\n"],"names":["DB_FILENAME","SCHEMA_VERSION","docCount","getMeta","open","rebuild","reconcile","setMeta","quoteIdent","name","split","join","registerFunctions","db","function","deterministic","varargs","field","value","undefined","needle","String","startsWith","parsed","JSON","parse","Array","isArray","some","item","includes","getColumns","rows","prepare","all","Set","map","r","ensureSchema","exec","key","row","get","run","n","cfg","baseDir","files","listFiles","currentSet","f","relPath","existingRows","existing","Map","path","vanished","filter","has","toReparse","_mtime","mtimeMs","_size","size","length","warnings","seenColumns","newColumns","parsedDocs","file","parseFile","doc","fileWarnings","push","Object","keys","data","add","allColumns","insertSql","col","del","insert","values","err","stateDir","STATE_DIR","mkdirSync","recursive","dbPath","DatabaseSync","rmSync","force"],"mappings":"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"}

package/dist/cjs/errors.d.cts

@@ -0,0 +1,5 @@
+export type SenseErrorCode = 'CONFIG_NOT_FOUND' | 'CONFIG_EXISTS' | 'CONFIG_VERSION_UNSUPPORTED' | 'WATCH_ACTIVE';
+export declare class SenseError extends Error {
+    code: SenseErrorCode;
+    constructor(code: SenseErrorCode, message: string);
+}

package/dist/cjs/errors.d.ts

@@ -0,0 +1,5 @@
+export type SenseErrorCode = 'CONFIG_NOT_FOUND' | 'CONFIG_EXISTS' | 'CONFIG_VERSION_UNSUPPORTED' | 'WATCH_ACTIVE';
+export declare class SenseError extends Error {
+    code: SenseErrorCode;
+    constructor(code: SenseErrorCode, message: string);
+}