sensemaking 0.12.2 → 0.13.0

package/dist/cjs/config/load.js

@@ -0,0 +1,448 @@
+"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 findConfigPath () {
+        return findConfigPath;
+    },
+    get initConfig () {
+        return initConfig;
+    },
+    get loadConfig () {
+        return loadConfig;
+    },
+    get migrateConfig () {
+        return migrateConfig;
+    }
+});
+var _nodefs = require("node:fs");
+var _nodepath = require("node:path");
+var _errorsts = require("../errors.js");
+var _typests = require("./types.js");
+var _validatets = require("./validate.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 _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_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 _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 _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys, key, i;
+    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
+        sourceKeys = Reflect.ownKeys(Object(source));
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+        return target;
+    }
+    target = _object_without_properties_loose(source, excluded);
+    if (Object.getOwnPropertySymbols) {
+        sourceKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceKeys.length; i++){
+            key = sourceKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+        target[key] = 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 _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    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);
+}
+// v1 and v2 were `scan`/`find`-shaped; v3 introduced `presets`. Only the former need the
+// legacy shape check before migrating.
+var FIRST_PRESET_VERSION = 3;
+// v1 -> v2 migration only: the features v2 introduced as opt-out (embed was opt-in then).
+var V2_OPT_OUT_NAMES = [
+    'links',
+    'sections',
+    'rank'
+];
+// Pure per-version steps, chained by loadConfig. Intermediate shapes predate the Config type,
+// so steps are loosely typed and only the final result is cast back.
+var MIGRATIONS = {
+    // v1 -> v2: features block introduced, opt-out features enabled (matches the old implicit
+    // behavior of `links` etc. not existing). embed stays absent -- opt-in.
+    1: function(cfg) {
+        return _object_spread_props(_object_spread({}, cfg), {
+            version: 2,
+            features: Object.fromEntries(V2_OPT_OUT_NAMES.map(function(name) {
+                return [
+                    name,
+                    true
+                ];
+            }))
+        });
+    },
+    // v2 -> v3: mechanical-minimal, by decision -- only what keeps an existing config loading.
+    // No restructuring, no preset inference, no query rewriting; real trees get hand-migrated
+    // separately to actually use presets.
+    2: function(cfg) {
+        var _prevDefaults_find;
+        var scan = cfg.scan, defaults = cfg.defaults, features = cfg.features, checks = cfg.checks, queries = cfg.queries, rest = _object_without_properties(cfg, [
+            "scan",
+            "defaults",
+            "features",
+            "checks",
+            "queries"
+        ]);
+        var scanInclude = scan.include;
+        var nextQueries = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.entries(queries !== null && queries !== void 0 ? queries : {})[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], value = _step_value[1];
+                if (typeof value === 'string') {
+                    nextQueries[name] = value;
+                    continue;
+                }
+                var entry = value;
+                // Loosely typed on purpose: this step emits the v3 shape, which still had `semantic`.
+                // The v3 -> v4 step below strips it.
+                var search = {
+                    search: entry.find
+                };
+                if (entry.k !== undefined) search.k = entry.k;
+                if (entry.where !== undefined) search.where = entry.where;
+                // semantic: true was opt-in; it is now the default, so it drops. semantic: false is kept.
+                if (entry.semantic === false) search.semantic = false;
+                nextQueries[name] = search;
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        var prevDefaults = defaults;
+        var defaultWhere = prevDefaults === null || prevDefaults === void 0 ? void 0 : (_prevDefaults_find = prevDefaults.find) === null || _prevDefaults_find === void 0 ? void 0 : _prevDefaults_find.where;
+        // features.embed false becomes semantic:false on every preset produced here.
+        var prevFeatures = features !== null && features !== void 0 ? features : {};
+        var embedWasOff = prevFeatures.embed === false;
+        // Object form carried provider settings (model/type/url/key), not a toggle -- they move
+        // to the v3 top-level `embed` block verbatim; dropping them would silently switch an
+        // api tree back to the built-in static model.
+        var embedProvider = _type_of(prevFeatures.embed) === 'object' && prevFeatures.embed !== null ? prevFeatures.embed : undefined;
+        var _embed = prevFeatures.embed, restFeatures = _object_without_properties(prevFeatures, [
+            "embed"
+        ]);
+        var defaultPreset = {
+            include: scanInclude
+        };
+        if (defaultWhere !== undefined) defaultPreset.where = defaultWhere;
+        if (embedWasOff) defaultPreset.semantic = false;
+        // checks (assertions over saved queries) was removed in v3; its queries still run under
+        // `queries`, just without the pass/fail assertion -- reachable now only as a saved query.
+        if (checks !== undefined) {
+            console.error('sense: v2 "checks" was removed in v3 (sense check no longer asserts on saved queries); its queries are carried over under "queries" -- a returned row set is now the reader\'s judgment');
+        }
+        var result = _object_spread_props(_object_spread({}, rest), {
+            version: 3,
+            presets: {
+                default: defaultPreset
+            },
+            queries: nextQueries
+        });
+        if (embedProvider !== undefined) result.embed = embedProvider;
+        if (Object.keys(restFeatures).length > 0) result.features = restFeatures;
+        return result;
+    },
+    // v3 -> v4: write the model into the file, wrap bare-string queries as { sql }, drop a saved
+    // search's `semantic` (its preset decides). Same effective model, so nothing re-embeds.
+    3: function(cfg) {
+        var _cfg_queries, _cfg_embed;
+        var presets = cfg.presets;
+        var embedded = Object.values(presets).some(function(p) {
+            return p.semantic !== false;
+        });
+        var nextQueries = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.entries((_cfg_queries = cfg.queries) !== null && _cfg_queries !== void 0 ? _cfg_queries : {})[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], value = _step_value[1];
+                // v3's bare string meant SQL by inference; v4 makes every entry name its verb.
+                if (typeof value === 'string') {
+                    nextQueries[name] = {
+                        sql: value
+                    };
+                    continue;
+                }
+                if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || value === null || !('search' in value)) {
+                    nextQueries[name] = value;
+                    continue;
+                }
+                var _semantic = value.semantic, rest = _object_without_properties(value, [
+                    "semantic"
+                ]);
+                nextQueries[name] = rest;
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        var prev = (_cfg_embed = cfg.embed) !== null && _cfg_embed !== void 0 ? _cfg_embed : {};
+        var result = _object_spread_props(_object_spread({}, cfg), {
+            version: 4,
+            queries: nextQueries
+        });
+        if (embedded) {
+            var _prev_model, _prev_type;
+            result.embed = _object_spread({
+                model: (_prev_model = prev.model) !== null && _prev_model !== void 0 ? _prev_model : _typests.DEFAULT_EMBED_MODEL,
+                type: (_prev_type = prev.type) !== null && _prev_type !== void 0 ? _prev_type : 'static'
+            }, prev.url !== undefined ? {
+                url: prev.url
+            } : {}, prev.key !== undefined ? {
+                key: prev.key
+            } : {});
+        } else {
+            delete result.embed;
+            // Dropping settings silently would look like a bug in a tree that had configured an
+            // api endpoint and then turned vectors off; say it, since v4 has no way to carry
+            // provider settings for a tree that does not embed.
+            if (Object.keys(prev).length > 0) console.error('sense: every preset has "semantic": false, so v4 drops the "embed" block (vectors stay off); re-add it, or set a preset\'s semantic back to true, to turn them on');
+        }
+        return result;
+    }
+};
+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 < _typests.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: _typests.SUPPORTED_CONFIG_VERSION,
+        presets: {
+            default: {
+                include: [
+                    '**/*.md'
+                ],
+                k: 10
+            },
+            large: {
+                include: [
+                    '**/*.md'
+                ],
+                k: 20
+            }
+        },
+        // Written out rather than defaulted in code: this line is what makes `sense download`
+        // fetch 124 MB, so it belongs where it can be read and changed.
+        embed: {
+            model: _typests.DEFAULT_EMBED_MODEL,
+            type: 'static'
+        },
+        queries: {}
+    };
+}
+function initConfig(dir) {
+    var configPath = (0, _nodepath.join)(dir, _typests.CONFIG_FILENAME);
+    if ((0, _nodefs.existsSync)(configPath)) {
+        throw new _errorsts.SenseError('CONFIG_EXISTS', "".concat(_typests.CONFIG_FILENAME, " already exists in ").concat(dir));
+    }
+    (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(starterConfig(), null, 2), "\n"));
+    return configPath;
+}
+function findConfigPath(startDir) {
+    var dir = (0, _nodepath.resolve)(startDir);
+    for(;;){
+        var candidate = (0, _nodepath.join)(dir, _typests.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 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(_typests.CONFIG_FILENAME, " in ").concat(process.cwd(), " or any parent directory"));
+        }
+        configPath = found;
+    }
+    var raw = (0, _nodefs.readFileSync)(configPath, 'utf8');
+    var parsed = JSON.parse(raw);
+    // Ahead of both the version gate and legacy/current shape checks: a non-object file (or
+    // an array -- typeof [] is also 'object') is malformed at every version, so it gets one
+    // error regardless of which branch would otherwise run.
+    if ((typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new _errorsts.SenseError('CONFIG_INVALID', "".concat(configPath, ": config must be a JSON object"));
+    }
+    // Version gate before shape validation: a config written by a newer sense should fail
+    // with "requires a newer sense", not with shape errors its own version may not have.
+    var version = (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && parsed !== null && typeof parsed.version === 'number' ? parsed.version : 1;
+    if (version > _typests.SUPPORTED_CONFIG_VERSION) {
+        throw new _errorsts.SenseError('CONFIG_VERSION_UNSUPPORTED', "config version ".concat(version, " requires a newer sense"));
+    }
+    // validateConfig only knows the current shape, so scan-shaped files (pre-v3) get a minimal
+    // check, migrate, then the full one on the result.
+    var cfg;
+    var migratedFrom;
+    if (version < _typests.SUPPORTED_CONFIG_VERSION) {
+        if (version < FIRST_PRESET_VERSION) (0, _validatets.validateLegacyScan)(parsed, configPath);
+        var result = migrateConfig(parsed);
+        cfg = (0, _validatets.validateConfig)(result.cfg, configPath);
+        migratedFrom = result.from;
+        (0, _nodefs.writeFileSync)(configPath, "".concat(JSON.stringify(cfg, null, 2), "\n"));
+    } else {
+        cfg = (0, _validatets.validateConfig)(parsed, configPath);
+    }
+    var unknownKeys = (0, _validatets.unknownConfigKeys)(cfg);
+    return _object_spread_props(_object_spread({}, cfg), {
+        baseDir: (0, _nodepath.dirname)(configPath),
+        configPath: configPath,
+        migratedFrom: migratedFrom,
+        unknownKeys: unknownKeys.length > 0 ? unknownKeys : undefined
+    });
+}
+/* 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/load.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/load.ts"],"sourcesContent":["import { existsSync, readFileSync, writeFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { SenseError } from '../errors.ts';\nimport type { Config, ResolvedConfig } from './types.ts';\nimport { CONFIG_FILENAME, DEFAULT_EMBED_MODEL, SUPPORTED_CONFIG_VERSION } from './types.ts';\nimport { unknownConfigKeys, validateConfig, validateLegacyScan } from './validate.ts';\n\n// v1 and v2 were `scan`/`find`-shaped; v3 introduced `presets`. Only the former need the\n// legacy shape check before migrating.\nconst FIRST_PRESET_VERSION = 3;\n\n// v1 -> v2 migration only: the features v2 introduced as opt-out (embed was opt-in then).\nconst V2_OPT_OUT_NAMES = ['links', 'sections', 'rank'] as const;\n\n// Pure per-version steps, chained by loadConfig. Intermediate shapes predate the Config type,\n// so steps are loosely typed and only the final result is cast back.\nconst MIGRATIONS: Record<number, (cfg: Record<string, unknown>) => Record<string, unknown>> = {\n  // v1 -> v2: features block introduced, opt-out features enabled (matches the old implicit\n  // behavior of `links` etc. not existing). embed stays absent -- opt-in.\n  1: (cfg) => ({ ...cfg, version: 2, features: Object.fromEntries(V2_OPT_OUT_NAMES.map((name) => [name, true])) }),\n  // v2 -> v3: mechanical-minimal, by decision -- only what keeps an existing config loading.\n  // No restructuring, no preset inference, no query rewriting; real trees get hand-migrated\n  // separately to actually use presets.\n  2: (cfg) => {\n    const { scan, defaults, features, checks, queries, ...rest } = cfg;\n    const scanInclude = (scan as { include: string[] }).include;\n\n    const nextQueries: Record<string, unknown> = {};\n    for (const [name, value] of Object.entries((queries as Record<string, unknown> | undefined) ?? {})) {\n      if (typeof value === 'string') {\n        nextQueries[name] = value;\n        continue;\n      }\n      const entry = value as { find: string; k?: number; where?: string; semantic?: boolean };\n      // Loosely typed on purpose: this step emits the v3 shape, which still had `semantic`.\n      // The v3 -> v4 step below strips it.\n      const search: Record<string, unknown> = { search: entry.find };\n      if (entry.k !== undefined) search.k = entry.k;\n      if (entry.where !== undefined) search.where = entry.where;\n      // semantic: true was opt-in; it is now the default, so it drops. semantic: false is kept.\n      if (entry.semantic === false) search.semantic = false;\n      nextQueries[name] = search;\n    }\n\n    const prevDefaults = defaults as { find?: { where?: string } } | undefined;\n    const defaultWhere = prevDefaults?.find?.where;\n\n    // features.embed false becomes semantic:false on every preset produced here.\n    const prevFeatures = (features as Record<string, unknown> | undefined) ?? {};\n    const embedWasOff = prevFeatures.embed === false;\n    // Object form carried provider settings (model/type/url/key), not a toggle -- they move\n    // to the v3 top-level `embed` block verbatim; dropping them would silently switch an\n    // api tree back to the built-in static model.\n    const embedProvider = typeof prevFeatures.embed === 'object' && prevFeatures.embed !== null ? prevFeatures.embed : undefined;\n    const { embed: _embed, ...restFeatures } = prevFeatures;\n\n    const defaultPreset: Record<string, unknown> = { include: scanInclude };\n    if (defaultWhere !== undefined) defaultPreset.where = defaultWhere;\n    if (embedWasOff) defaultPreset.semantic = false;\n\n    // checks (assertions over saved queries) was removed in v3; its queries still run under\n    // `queries`, just without the pass/fail assertion -- reachable now only as a saved query.\n    if (checks !== undefined) {\n      console.error('sense: v2 \"checks\" was removed in v3 (sense check no longer asserts on saved queries); its queries are carried over under \"queries\" -- a returned row set is now the reader\\'s judgment');\n    }\n\n    const result: Record<string, unknown> = { ...rest, version: 3, presets: { default: defaultPreset }, queries: nextQueries };\n    if (embedProvider !== undefined) result.embed = embedProvider;\n    if (Object.keys(restFeatures).length > 0) result.features = restFeatures;\n    return result;\n  },\n  // v3 -> v4: write the model into the file, wrap bare-string queries as { sql }, drop a saved\n  // search's `semantic` (its preset decides). Same effective model, so nothing re-embeds.\n  3: (cfg) => {\n    const presets = cfg.presets as Record<string, Record<string, unknown>>;\n    const embedded = Object.values(presets).some((p) => p.semantic !== false);\n\n    const nextQueries: Record<string, unknown> = {};\n    for (const [name, value] of Object.entries((cfg.queries as Record<string, unknown> | undefined) ?? {})) {\n      // v3's bare string meant SQL by inference; v4 makes every entry name its verb.\n      if (typeof value === 'string') {\n        nextQueries[name] = { sql: value };\n        continue;\n      }\n      if (typeof value !== 'object' || value === null || !('search' in value)) {\n        nextQueries[name] = value;\n        continue;\n      }\n      const { semantic: _semantic, ...rest } = value as Record<string, unknown>;\n      nextQueries[name] = rest;\n    }\n\n    const prev = (cfg.embed as Record<string, unknown> | undefined) ?? {};\n    const result: Record<string, unknown> = { ...cfg, version: 4, queries: nextQueries };\n    if (embedded) {\n      result.embed = { model: (prev.model as string | undefined) ?? DEFAULT_EMBED_MODEL, type: (prev.type as string | undefined) ?? 'static', ...(prev.url !== undefined ? { url: prev.url } : {}), ...(prev.key !== undefined ? { key: prev.key } : {}) };\n    } else {\n      delete result.embed;\n      // Dropping settings silently would look like a bug in a tree that had configured an\n      // api endpoint and then turned vectors off; say it, since v4 has no way to carry\n      // provider settings for a tree that does not embed.\n      if (Object.keys(prev).length > 0) console.error('sense: every preset has \"semantic\": false, so v4 drops the \"embed\" block (vectors stay off); re-add it, or set a preset\\'s semantic back to true, to turn them on');\n    }\n    return result;\n  },\n};\n\nexport function migrateConfig(cfg: Config): { cfg: Config; from: number } {\n  const from = cfg.version ?? 1;\n  let current: Record<string, unknown> = cfg as unknown as Record<string, unknown>;\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 as unknown as Config, from };\n}\n\nfunction starterConfig(): Config {\n  return {\n    $schema: 'https://unpkg.com/sensemaking/schema.json',\n    version: SUPPORTED_CONFIG_VERSION,\n    presets: {\n      default: { include: ['**/*.md'], k: 10 },\n      large: { include: ['**/*.md'], k: 20 },\n    },\n    // Written out rather than defaulted in code: this line is what makes `sense download`\n    // fetch 124 MB, so it belongs where it can be read and changed.\n    embed: { model: DEFAULT_EMBED_MODEL, type: 'static' },\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  const parsed: unknown = JSON.parse(raw);\n\n  // Ahead of both the version gate and legacy/current shape checks: a non-object file (or\n  // an array -- typeof [] is also 'object') is malformed at every version, so it gets one\n  // error regardless of which branch would otherwise run.\n  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {\n    throw new SenseError('CONFIG_INVALID', `${configPath}: config must be a JSON object`);\n  }\n\n  // Version gate before shape validation: a config written by a newer sense should fail\n  // with \"requires a newer sense\", not with shape errors its own version may not have.\n  const version = typeof parsed === 'object' && parsed !== null && typeof (parsed as { version?: unknown }).version === 'number' ? (parsed as { version: number }).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  // validateConfig only knows the current shape, so scan-shaped files (pre-v3) get a minimal\n  // check, migrate, then the full one on the result.\n  let cfg: Config;\n  let migratedFrom: number | undefined;\n  if (version < SUPPORTED_CONFIG_VERSION) {\n    if (version < FIRST_PRESET_VERSION) validateLegacyScan(parsed, configPath);\n    const result = migrateConfig(parsed as unknown as Config);\n    cfg = validateConfig(result.cfg, configPath);\n    migratedFrom = result.from;\n    writeFileSync(configPath, `${JSON.stringify(cfg, null, 2)}\\n`);\n  } else {\n    cfg = validateConfig(parsed, configPath);\n  }\n\n  const unknownKeys = unknownConfigKeys(cfg as unknown as Record<string, unknown>);\n  return { ...cfg, baseDir: dirname(configPath), configPath, migratedFrom, unknownKeys: unknownKeys.length > 0 ? unknownKeys : undefined };\n}\n"],"names":["findConfigPath","initConfig","loadConfig","migrateConfig","FIRST_PRESET_VERSION","V2_OPT_OUT_NAMES","MIGRATIONS","cfg","version","features","Object","fromEntries","map","name","prevDefaults","scan","defaults","checks","queries","rest","scanInclude","include","nextQueries","entries","value","entry","search","find","k","undefined","where","semantic","defaultWhere","prevFeatures","embedWasOff","embed","embedProvider","_embed","restFeatures","defaultPreset","console","error","result","presets","default","keys","length","embedded","values","some","p","sql","_semantic","prev","model","DEFAULT_EMBED_MODEL","type","url","key","from","current","v","SUPPORTED_CONFIG_VERSION","step","SenseError","starterConfig","$schema","large","dir","configPath","join","CONFIG_FILENAME","existsSync","writeFileSync","JSON","stringify","startDir","resolve","candidate","parent","dirname","explicitPath","process","cwd","found","raw","readFileSync","parsed","parse","Array","isArray","migratedFrom","validateLegacyScan","validateConfig","unknownKeys","unknownConfigKeys","baseDir"],"mappings":"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"}

package/dist/cjs/config/resolve.d.cts

@@ -0,0 +1,6 @@
+import type { Config, EffectiveSearch, Preset, SearchOverrides } from './types.js';
+export declare function resolvePreset(cfg: Config, name?: string): {
+    name: string;
+    preset: Preset;
+};
+export declare function resolveSearch(cfg: Config, opts?: SearchOverrides): EffectiveSearch;

package/dist/cjs/config/resolve.d.ts

@@ -0,0 +1,6 @@
+import type { Config, EffectiveSearch, Preset, SearchOverrides } from './types.js';
+export declare function resolvePreset(cfg: Config, name?: string): {
+    name: string;
+    preset: Preset;
+};
+export declare function resolveSearch(cfg: Config, opts?: SearchOverrides): EffectiveSearch;

package/dist/cjs/config/resolve.js

@@ -0,0 +1,50 @@
+"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 resolvePreset () {
+        return resolvePreset;
+    },
+    get resolveSearch () {
+        return resolveSearch;
+    }
+});
+var _errorsts = require("../errors.js");
+var _accessts = require("./access.js");
+function resolvePreset(cfg, name) {
+    var presetName = name !== null && name !== void 0 ? name : 'default';
+    var preset = cfg.presets[presetName];
+    if (!preset) throw new _errorsts.SenseError('PRESET_UNKNOWN', 'unknown preset "'.concat(presetName, '"; declared presets: ').concat((0, _accessts.presetNames)(cfg).join(', ')));
+    return {
+        name: presetName,
+        preset: preset
+    };
+}
+function resolveSearch(cfg) {
+    var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var _ref, _opts_k, _opts_where, _opts_include, _opts_exclude;
+    var _resolvePreset = resolvePreset(cfg, opts.preset), presetName = _resolvePreset.name, preset = _resolvePreset.preset;
+    var k = (_ref = (_opts_k = opts.k) !== null && _opts_k !== void 0 ? _opts_k : preset.k) !== null && _ref !== void 0 ? _ref : 10;
+    var where = (_opts_where = opts.where) !== null && _opts_where !== void 0 ? _opts_where : preset.where;
+    // Each overrides its own side only, so neither clears the other.
+    var include = (_opts_include = opts.include) !== null && _opts_include !== void 0 ? _opts_include : preset.include;
+    // --no-exclude widens past the preset's exclusions; an explicit --exclude alongside it is
+    // still the scope for this command, since it says what to leave out rather than what to keep.
+    var exclude = (_opts_exclude = opts.exclude) !== null && _opts_exclude !== void 0 ? _opts_exclude : opts.noExclude ? undefined : preset.exclude;
+    return {
+        presetName: presetName,
+        k: k,
+        where: where,
+        include: include,
+        exclude: exclude,
+        semantic: preset.semantic !== false
+    };
+}
+/* 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/resolve.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/resolve.ts"],"sourcesContent":["import { SenseError } from '../errors.ts';\nimport { presetNames } from './access.ts';\nimport type { Config, EffectiveSearch, Preset, SearchOverrides } from './types.ts';\n\n// Looks up a declared preset by name, defaulting to `default`. Throws naming every declared\n// preset when an explicit name is not declared -- the `default` fallback is never unknown\n// itself (validateConfig requires it).\nexport function resolvePreset(cfg: Config, name?: string): { name: string; preset: Preset } {\n  const presetName = name ?? 'default';\n  const preset = cfg.presets[presetName];\n  if (!preset) throw new SenseError('PRESET_UNKNOWN', `unknown preset \"${presetName}\"; declared presets: ${presetNames(cfg).join(', ')}`);\n  return { name: presetName, preset };\n}\n\n// Precedence, per field: built-ins <- named preset (or `default`) <- caller overrides.\n// `opts` arrives with any saved-query/CLI merge already resolved (src/cli/named.ts).\nexport function resolveSearch(cfg: Config, opts: SearchOverrides = {}): EffectiveSearch {\n  const { name: presetName, preset } = resolvePreset(cfg, opts.preset);\n  const k = opts.k ?? preset.k ?? 10;\n  const where = opts.where ?? preset.where;\n  // Each overrides its own side only, so neither clears the other.\n  const include = opts.include ?? preset.include;\n  // --no-exclude widens past the preset's exclusions; an explicit --exclude alongside it is\n  // still the scope for this command, since it says what to leave out rather than what to keep.\n  const exclude = opts.exclude ?? (opts.noExclude ? undefined : preset.exclude);\n  return { presetName, k, where, include, exclude, semantic: preset.semantic !== false };\n}\n"],"names":["resolvePreset","resolveSearch","cfg","name","presetName","preset","presets","SenseError","presetNames","join","opts","k","where","include","exclude","noExclude","undefined","semantic"],"mappings":";;;;;;;;;;;QAOgBA;eAAAA;;QASAC;eAAAA;;;wBAhBW;wBACC;AAMrB,SAASD,cAAcE,GAAW,EAAEC,IAAa;IACtD,IAAMC,aAAaD,iBAAAA,kBAAAA,OAAQ;IAC3B,IAAME,SAASH,IAAII,OAAO,CAACF,WAAW;IACtC,IAAI,CAACC,QAAQ,MAAM,IAAIE,oBAAU,CAAC,kBAAkB,AAAC,mBAAoDC,OAAlCJ,YAAW,yBAAmD,OAA5BI,IAAAA,qBAAW,EAACN,KAAKO,IAAI,CAAC;IAC/H,OAAO;QAAEN,MAAMC;QAAYC,QAAAA;IAAO;AACpC;AAIO,SAASJ,cAAcC,GAAW;QAAEQ,OAAAA,iEAAwB,CAAC;QAExDA,MAAAA,SACIA,aAEEA,eAGAA;IAPhB,IAAqCV,iBAAAA,cAAcE,KAAKQ,KAAKL,MAAM,GAA3DF,AAAMC,aAAuBJ,eAA7BG,MAAkBE,SAAWL,eAAXK;IAC1B,IAAMM,KAAID,QAAAA,UAAAA,KAAKC,CAAC,cAAND,qBAAAA,UAAUL,OAAOM,CAAC,cAAlBD,kBAAAA,OAAsB;IAChC,IAAME,SAAQF,cAAAA,KAAKE,KAAK,cAAVF,yBAAAA,cAAcL,OAAOO,KAAK;IACxC,iEAAiE;IACjE,IAAMC,WAAUH,gBAAAA,KAAKG,OAAO,cAAZH,2BAAAA,gBAAgBL,OAAOQ,OAAO;IAC9C,0FAA0F;IAC1F,8FAA8F;IAC9F,IAAMC,WAAUJ,gBAAAA,KAAKI,OAAO,cAAZJ,2BAAAA,gBAAiBA,KAAKK,SAAS,GAAGC,YAAYX,OAAOS,OAAO;IAC5E,OAAO;QAAEV,YAAAA;QAAYO,GAAAA;QAAGC,OAAAA;QAAOC,SAAAA;QAASC,SAAAA;QAASG,UAAUZ,OAAOY,QAAQ,KAAK;IAAM;AACvF"}

package/dist/{esm/config.d.ts → cjs/config/types.d.cts}

@@ -1,7 +1,7 @@
 export declare const CONFIG_FILENAME = "sense.config.json";
 export declare const STATE_DIR = ".sense";
 export declare const SUPPORTED_CONFIG_VERSION = 4;
-declare const FEATURE_NAMES: readonly ["links", "sections", "rank", "embed"];
+export declare const FEATURE_NAMES: readonly ["links", "sections", "tags", "rank", "embed"];
 export type FeatureName = (typeof FEATURE_NAMES)[number];
 export interface EmbedConfig {
     model?: string;
@@ -35,6 +35,7 @@ export interface Config {
     features?: {
         links?: boolean;
         sections?: boolean;
+        tags?: boolean;
         rank?: boolean;
     };
     embed?: EmbedConfig;
@@ -49,28 +50,6 @@ export interface ResolvedConfig extends Config {
     unknownKeys?: string[];
     migratedFrom?: number;
 }
-export declare function presetNames(cfg: Config): string[];
-export declare function embedEnabled(cfg: Config): boolean;
-export declare function presetSemanticEnabled(cfg: Config, name: string): boolean;
-export declare function anyPresetEmbeds(cfg: Config): boolean;
-export declare function featureEnabled(cfg: Config, name: FeatureName): boolean;
-export declare function enabledFeatures(cfg: Config): FeatureName[];
-export declare function featureStates(cfg: Config): {
-    on: FeatureName[];
-    off: FeatureName[];
-};
-export declare function embedConfig(cfg: Config): {
-    model: string;
-    type: 'static' | 'api';
-    url?: string;
-    key?: string;
-} | null;
-export declare function contentTokenize(cfg: Config): string | undefined;
-export declare function featureSignature(cfg: Config): string;
-export declare function resolvePreset(cfg: Config, name?: string): {
-    name: string;
-    preset: Preset;
-};
 export interface SearchOverrides {
     preset?: string;
     k?: number;
@@ -87,12 +66,3 @@ export interface EffectiveSearch {
     exclude?: string[];
     semantic: boolean;
 }
-export declare function resolveSearch(cfg: Config, opts?: SearchOverrides): EffectiveSearch;
-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;
-export {};