sensemaking 0.19.2 → 0.21.0

package/dist/cjs/store/preset-scope.js

@@ -0,0 +1,293 @@
+"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 forcedPresetPaths () {
+        return forcedPresetPaths;
+    },
+    get isPresetOnlyChange () {
+        return isPresetOnlyChange;
+    }
+});
+var _indexts = require("../config/index.js");
+var _indexts1 = require("../scan/index.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_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _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 _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        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;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _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);
+}
+function isPresetOnlyChange(changedKeys) {
+    return changedKeys.size > 0 && _to_consumable_array(changedKeys).every(function(key) {
+        return key.startsWith('preset:');
+    });
+}
+// One preset's old include/exclude/vectors-on-off, read back out of a stored `preset:<name>:...`
+// segment (config/access.ts's featureSignature format). Absent (a brand-new preset) is the empty
+// preset, not a parse failure; a segment present but not in that exact shape returns null so the
+// caller falls back to a full rebuild instead of guessing.
+function parseOldPreset(before, name) {
+    var part = before.split('|').find(function(p) {
+        return p.startsWith("preset:".concat(name, ":"));
+    });
+    if (part === undefined) return {
+        include: [],
+        exclude: [],
+        vectors: false
+    };
+    var fields = part.split(':');
+    if (fields.length !== 5) return null;
+    var _fields = _sliced_to_array(fields, 5), includeStr = _fields[2], excludeStr = _fields[3], onOff = _fields[4];
+    if (onOff !== 'on' && onOff !== 'off') return null;
+    return {
+        include: includeStr === '' ? [] : includeStr.split('+'),
+        exclude: excludeStr === '' ? [] : excludeStr.split('+'),
+        vectors: onOff === 'on'
+    };
+}
+// Paths one preset definition covers, via the real listFiles so stat filtering (directories,
+// dangling symlinks) matches production coverage exactly.
+function matchPreset(cfg, baseDir, name, def) {
+    var scoped = _object_spread_props(_object_spread({}, cfg), {
+        presets: _define_property({}, name, {
+            include: def.include,
+            exclude: def.exclude
+        })
+    });
+    return new Set((0, _indexts1.listFiles)(scoped, baseDir).map(function(f) {
+        return f.relPath;
+    }));
+}
+function forcedPresetPaths(cfg, baseDir, before, changedKeys) {
+    var forced = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = changedKeys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            var _cfg_presets_name_exclude;
+            var name = key.slice('preset:'.length);
+            var oldDef = parseOldPreset(before, name);
+            if (oldDef === null) return null;
+            var stillDeclared = Object.hasOwn(cfg.presets, name);
+            var newDef = stillDeclared ? {
+                include: cfg.presets[name].include,
+                exclude: (_cfg_presets_name_exclude = cfg.presets[name].exclude) !== null && _cfg_presets_name_exclude !== void 0 ? _cfg_presets_name_exclude : [],
+                vectors: (0, _indexts.presetHasSignal)(cfg, name, 'vectors')
+            } : {
+                include: [],
+                exclude: [],
+                vectors: false
+            };
+            var oldMatch = matchPreset(cfg, baseDir, name, oldDef);
+            var newMatch = stillDeclared ? matchPreset(cfg, baseDir, name, newDef) : new Set();
+            if (oldDef.vectors !== newDef.vectors) {
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = oldMatch[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var p = _step1.value;
+                        forced.add(p);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                try {
+                    for(var _iterator2 = newMatch[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                        var p1 = _step2.value;
+                        forced.add(p1);
+                    }
+                } catch (err) {
+                    _didIteratorError2 = true;
+                    _iteratorError2 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                            _iterator2.return();
+                        }
+                    } finally{
+                        if (_didIteratorError2) {
+                            throw _iteratorError2;
+                        }
+                    }
+                }
+            } else {
+                var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+                try {
+                    for(var _iterator3 = oldMatch[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                        var p2 = _step3.value;
+                        if (!newMatch.has(p2)) forced.add(p2);
+                    }
+                } catch (err) {
+                    _didIteratorError3 = true;
+                    _iteratorError3 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                            _iterator3.return();
+                        }
+                    } finally{
+                        if (_didIteratorError3) {
+                            throw _iteratorError3;
+                        }
+                    }
+                }
+                var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+                try {
+                    for(var _iterator4 = newMatch[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true){
+                        var p3 = _step4.value;
+                        if (!oldMatch.has(p3)) forced.add(p3);
+                    }
+                } catch (err) {
+                    _didIteratorError4 = true;
+                    _iteratorError4 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                            _iterator4.return();
+                        }
+                    } finally{
+                        if (_didIteratorError4) {
+                            throw _iteratorError4;
+                        }
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return forced;
+}
+/* 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/store/preset-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/preset-scope.ts"],"sourcesContent":["import type { Config } from '../config/index.ts';\nimport { presetHasSignal } from '../config/index.ts';\nimport { listFiles } from '../scan/index.ts';\n\n// A signature change open() can route to a narrow reparse instead of a full clear: every changed\n// segment is a preset's own (glob or vector on/off), never a global feature or embed change.\nexport function isPresetOnlyChange(changedKeys: ReadonlySet<string>): boolean {\n  return changedKeys.size > 0 && [...changedKeys].every((key) => key.startsWith('preset:'));\n}\n\ninterface PresetDef {\n  include: string[];\n  exclude: string[];\n  vectors: boolean;\n}\n\n// One preset's old include/exclude/vectors-on-off, read back out of a stored `preset:<name>:...`\n// segment (config/access.ts's featureSignature format). Absent (a brand-new preset) is the empty\n// preset, not a parse failure; a segment present but not in that exact shape returns null so the\n// caller falls back to a full rebuild instead of guessing.\nfunction parseOldPreset(before: string, name: string): PresetDef | null {\n  const part = before.split('|').find((p) => p.startsWith(`preset:${name}:`));\n  if (part === undefined) return { include: [], exclude: [], vectors: false };\n  const fields = part.split(':');\n  if (fields.length !== 5) return null;\n  const [, , includeStr, excludeStr, onOff] = fields;\n  if (onOff !== 'on' && onOff !== 'off') return null;\n  return { include: includeStr === '' ? [] : includeStr.split('+'), exclude: excludeStr === '' ? [] : excludeStr.split('+'), vectors: onOff === 'on' };\n}\n\n// Paths one preset definition covers, via the real listFiles so stat filtering (directories,\n// dangling symlinks) matches production coverage exactly.\nfunction matchPreset(cfg: Config, baseDir: string, name: string, def: PresetDef): Set<string> {\n  const scoped: Config = { ...cfg, presets: { [name]: { include: def.include, exclude: def.exclude } } };\n  return new Set(listFiles(scoped, baseDir).map((f) => f.relPath));\n}\n\n// Every path whose coverage by a changed preset genuinely moved: gained or lost it (a glob edit),\n// or kept it under a flipped vectors on/off (that preset's whole match set, since its contribution\n// to the file's union embed flag may have changed even though membership itself did not). Returns\n// null when a changed preset's stored segment can't be parsed, so the caller takes the full rebuild.\nexport function forcedPresetPaths(cfg: Config, baseDir: string, before: string, changedKeys: ReadonlySet<string>): Set<string> | null {\n  const forced = new Set<string>();\n  for (const key of changedKeys) {\n    const name = key.slice('preset:'.length);\n    const oldDef = parseOldPreset(before, name);\n    if (oldDef === null) return null;\n    const stillDeclared = Object.hasOwn(cfg.presets, name);\n    const newDef: PresetDef = stillDeclared ? { include: cfg.presets[name].include, exclude: cfg.presets[name].exclude ?? [], vectors: presetHasSignal(cfg, name, 'vectors') } : { include: [], exclude: [], vectors: false };\n\n    const oldMatch = matchPreset(cfg, baseDir, name, oldDef);\n    const newMatch = stillDeclared ? matchPreset(cfg, baseDir, name, newDef) : new Set<string>();\n\n    if (oldDef.vectors !== newDef.vectors) {\n      for (const p of oldMatch) forced.add(p);\n      for (const p of newMatch) forced.add(p);\n    } else {\n      for (const p of oldMatch) if (!newMatch.has(p)) forced.add(p);\n      for (const p of newMatch) if (!oldMatch.has(p)) forced.add(p);\n    }\n  }\n  return forced;\n}\n"],"names":["forcedPresetPaths","isPresetOnlyChange","changedKeys","size","every","key","startsWith","parseOldPreset","before","name","part","split","find","p","undefined","include","exclude","vectors","fields","length","includeStr","excludeStr","onOff","matchPreset","cfg","baseDir","def","scoped","presets","Set","listFiles","map","f","relPath","forced","slice","oldDef","stillDeclared","Object","hasOwn","newDef","presetHasSignal","oldMatch","newMatch","add","has"],"mappings":"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"}

package/dist/cjs/store/reconcile.d.cts

@@ -1,6 +1,7 @@
 import type { Config } from '../config/index.js';
+import type { ParsePool } from '../scan/pool.js';
 import type { Connection, ReconcileDialect } from './types.js';
-export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Promise<{
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool?: ParsePool, forcedPaths?: ReadonlySet<string>): Promise<{
     parsed: number;
     warnings: string[];
 }>;

package/dist/cjs/store/reconcile.d.ts

@@ -1,6 +1,7 @@
 import type { Config } from '../config/index.js';
+import type { ParsePool } from '../scan/pool.js';
 import type { Connection, ReconcileDialect } from './types.js';
-export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect): Promise<{
+export declare function reconcile(conn: Connection, cfg: Config, baseDir: string, dialect: ReconcileDialect, pool?: ParsePool, forcedPaths?: ReadonlySet<string>): Promise<{
     parsed: number;
     warnings: string[];
 }>;