sensemaking 0.25.1 → 0.27.0

package/dist/cjs/commands/snapshot.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "assertQuerySnapshot", {
+    enumerable: true,
+    get: function() {
+        return assertQuerySnapshot;
+    }
+});
+var _indexts = require("../config/index.js");
+var _errorsts = require("../errors.js");
+var _indexts1 = require("../features/index.js");
+var _readinessts = require("../store/readiness.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function assertQuerySnapshot(store, cfg) {
+    return _async_to_generator(function() {
+        var _values_get, _values_get1, stmt, rows, values, actual, expected;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        store.prepare('SELECT key, value FROM meta WHERE key IN (?, ?)')
+                    ];
+                case 1:
+                    stmt = _state.sent();
+                    return [
+                        4,
+                        stmt.all(_readinessts.CORE_READY_META_KEY, _readinessts.FEATURE_SIGNATURE_META_KEY)
+                    ];
+                case 2:
+                    rows = _state.sent();
+                    values = new Map(rows.map(function(row) {
+                        return [
+                            row.key,
+                            row.value
+                        ];
+                    }));
+                    if (!(0, _readinessts.isCoreReady)((_values_get = values.get(_readinessts.CORE_READY_META_KEY)) !== null && _values_get !== void 0 ? _values_get : null)) {
+                        throw new _errorsts.SenseError('INDEX_NOT_READY', 'the index has no complete published generation; wait for the active build to finish, or run `sense build` (or library build(config)) to recover it');
+                    }
+                    actual = (_values_get1 = values.get(_readinessts.FEATURE_SIGNATURE_META_KEY)) !== null && _values_get1 !== void 0 ? _values_get1 : null;
+                    expected = (0, _indexts.featureSignature)(cfg, _indexts1.FEATURES);
+                    if (actual === null || !(0, _readinessts.isPublishedFeatureSignature)(actual, expected)) {
+                        throw new _errorsts.SenseError('INDEX_NOT_READY', 'the published index was built for different configuration features; rebuild it with `sense build` (or library build(config)) before querying');
+                    }
+                    return [
+                        2,
+                        actual
+                    ];
+            }
+        });
+    })();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/commands/snapshot.ts"],"sourcesContent":["import type { ResolvedConfig } from '../config/index.ts';\nimport { featureSignature } from '../config/index.ts';\nimport { SenseError } from '../errors.ts';\nimport { FEATURES } from '../features/index.ts';\nimport { CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY, isCoreReady, isPublishedFeatureSignature } from '../store/readiness.ts';\nimport type { Store } from '../store/types.ts';\n\n// Read-only policy check for a caller-owned transaction. The store readiness module owns the\n// durable keys and compatibility rules; commands only require one published generation before\n// reading scope, candidates, graph state, and result details from that same snapshot.\nexport async function assertQuerySnapshot(store: Store, cfg: ResolvedConfig): Promise<string> {\n  const stmt = await store.prepare('SELECT key, value FROM meta WHERE key IN (?, ?)');\n  const rows = (await stmt.all(CORE_READY_META_KEY, FEATURE_SIGNATURE_META_KEY)) as Array<{ key: string; value: string }>;\n  const values = new Map(rows.map((row) => [row.key, row.value]));\n  if (!isCoreReady(values.get(CORE_READY_META_KEY) ?? null)) {\n    throw new SenseError('INDEX_NOT_READY', 'the index has no complete published generation; wait for the active build to finish, or run `sense build` (or library build(config)) to recover it');\n  }\n\n  const actual = values.get(FEATURE_SIGNATURE_META_KEY) ?? null;\n  const expected = featureSignature(cfg, FEATURES);\n  if (actual === null || !isPublishedFeatureSignature(actual, expected)) {\n    throw new SenseError('INDEX_NOT_READY', 'the published index was built for different configuration features; rebuild it with `sense build` (or library build(config)) before querying');\n  }\n  return actual;\n}\n"],"names":["assertQuerySnapshot","store","cfg","values","stmt","rows","actual","expected","prepare","all","CORE_READY_META_KEY","FEATURE_SIGNATURE_META_KEY","Map","map","row","key","value","isCoreReady","get","SenseError","featureSignature","FEATURES","isPublishedFeatureSignature"],"mappings":";;;;+BAUsBA;;;eAAAA;;;uBATW;wBACN;wBACF;2BACiF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMnG,SAAeA,oBAAoBC,KAAY,EAAEC,GAAmB;;YAIxDC,aAIFA,cAPTC,MACAC,MACAF,QAKAG,QACAC;;;;oBARO;;wBAAMN,MAAMO,OAAO,CAAC;;;oBAA3BJ,OAAO;oBACC;;wBAAMA,KAAKK,GAAG,CAACC,gCAAmB,EAAEC,uCAA0B;;;oBAAtEN,OAAQ;oBACRF,SAAS,IAAIS,IAAIP,KAAKQ,GAAG,CAAC,SAACC;+BAAQ;4BAACA,IAAIC,GAAG;4BAAED,IAAIE,KAAK;yBAAC;;oBAC7D,IAAI,CAACC,IAAAA,wBAAW,GAACd,cAAAA,OAAOe,GAAG,CAACR,gCAAmB,eAA9BP,yBAAAA,cAAmC,OAAO;wBACzD,MAAM,IAAIgB,oBAAU,CAAC,mBAAmB;oBAC1C;oBAEMb,UAASH,eAAAA,OAAOe,GAAG,CAACP,uCAA0B,eAArCR,0BAAAA,eAA0C;oBACnDI,WAAWa,IAAAA,yBAAgB,EAAClB,KAAKmB,kBAAQ;oBAC/C,IAAIf,WAAW,QAAQ,CAACgB,IAAAA,wCAA2B,EAAChB,QAAQC,WAAW;wBACrE,MAAM,IAAIY,oBAAU,CAAC,mBAAmB;oBAC1C;oBACA;;wBAAOb;;;;IACT"}

package/dist/cjs/config/load.js

@@ -22,6 +22,7 @@ _export(exports, {
         return migrateConfig;
     }
 });
+var _nodediagnostics_channel = require("node:diagnostics_channel");
 var _nodefs = require("node:fs");
 var _nodepath = require("node:path");
 var _errorsts = require("../errors.js");
@@ -172,6 +173,7 @@ function _unsupported_iterable_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;
+var migrationReady = (0, _nodediagnostics_channel.channel)('sensemaking.config.migration-ready');
 // v1 -> v2 migration only: the features v2 introduced as opt-out (embed was opt-in then).
 var V2_OPT_OUT_NAMES = [
     'links',
@@ -510,6 +512,10 @@ function loadConfig(explicitPath) {
         migratedFrom = result.from;
         if (options.writeMigration !== false) {
             var migrated = "".concat(JSON.stringify(cfg, null, 2), "\n");
+            if (migrationReady.hasSubscribers) migrationReady.publish({
+                configPath: configPath,
+                from: migratedFrom
+            });
             try {
                 (0, _atomicwritets.writeFileAtomic)(configPath, migrated);
             } catch (err) {

package/dist/cjs/config/load.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/load.ts"],"sourcesContent":["import { existsSync, readFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { SenseError } from '../errors.ts';\nimport { writeFileAtomic } from '../lib/atomic-write.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 (no\n  // restructuring, no preset inference, no query rewriting); real trees get hand-migrated to 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 carries provider settings (model/type/url/key), not a toggle -- they move to\n    // the v3 top-level `embed` block verbatim; dropping them would silently switch an api tree to the 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    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 configured an api endpoint\n      // then turned vectors off; say it, since v4 has no way to carry provider settings for a tree that doesn't 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  // v4 -> v5: embed.type renames to embed.provider (\"api\" migrates to \"openai\", the wire protocol\n  // it always was; other values pass through). A preset's `semantic` also migrates to `signals` (false -> explicit weights, true/absent -> no key).\n  4: (cfg) => {\n    const prevEmbed = cfg.embed as Record<string, unknown> | undefined;\n    const result: Record<string, unknown> = { ...cfg, version: 5 };\n    if (prevEmbed) {\n      const { type, ...rest } = prevEmbed;\n      result.embed = type === undefined ? rest : { ...rest, provider: type === 'api' ? 'openai' : type };\n    }\n\n    const linksOn = (cfg.features as Record<string, unknown> | undefined)?.links !== false;\n    const presets = cfg.presets as Record<string, Record<string, unknown>> | undefined;\n    if (presets) {\n      const nextPresets: Record<string, unknown> = {};\n      for (const [name, preset] of Object.entries(presets)) {\n        const { semantic, ...rest } = preset;\n        if (semantic === undefined) {\n          nextPresets[name] = preset;\n          continue;\n        }\n        if (typeof semantic !== 'boolean') {\n          throw new SenseError('CONFIG_INVALID', `presets.${name}.semantic must be a boolean`);\n        }\n        nextPresets[name] = semantic === false ? { ...rest, signals: linksOn ? { words: 1, links: 1 } : { words: 1 } } : rest;\n      }\n      result.presets = nextPresets;\n    }\n    return result;\n  },\n  // v5 -> v6: query-triggered builds are on by default. Preserve an explicit opt-out.\n  5: (cfg) => ({ ...cfg, version: 6, build: cfg.build === undefined ? true : cfg.build }),\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\n// `sense init`'s flags map onto these three `embed` keys one-to-one; an absent field\n// keeps the built-in default rather than merging partial input.\nexport interface InitOverrides {\n  model?: string;\n  provider?: string;\n  url?: string;\n}\n\nfunction starterConfig(overrides?: InitOverrides): Config {\n  const embed: Record<string, unknown> = { model: DEFAULT_EMBED_MODEL, provider: 'static' };\n  if (overrides?.model !== undefined) embed.model = overrides.model;\n  if (overrides?.provider !== undefined) embed.provider = overrides.provider;\n  if (overrides?.url !== undefined) embed.url = overrides.url;\n  return {\n    $schema: 'https://unpkg.com/sensemaking/schema.json',\n    version: SUPPORTED_CONFIG_VERSION,\n    build: true,\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 a model, so it belongs where it can be read and changed.\n    embed: embed as Config['embed'],\n    queries: {},\n  };\n}\n\n// Refuses to overwrite an existing config. `overrides` come from `sense init`'s flags; an\n// invalid --provider fails validateConfig's own shape check before anything is written.\nexport function initConfig(dir: string, overrides?: InitOverrides): 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 cfg = starterConfig(overrides);\n  validateConfig(cfg, configPath);\n  writeFileAtomic(configPath, `${JSON.stringify(cfg, 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\n/** Controls whether loading an older config may persist its in-memory migration. */\nexport interface LoadConfigOptions {\n  /** Write a successful migration back to the config file. Defaults to true. */\n  writeMigration?: boolean;\n}\n\nexport function loadConfig(explicitPath?: string, options: LoadConfigOptions = {}): 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 shape checks: a non-object file (or array -- typeof []\n  // is also 'object') is malformed at every version, so it gets one error regardless of branch.\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    if (options.writeMigration !== false) {\n      const migrated = `${JSON.stringify(cfg, null, 2)}\\n`;\n      try {\n        writeFileAtomic(configPath, migrated);\n      } catch (err) {\n        // Only a rename-contention error might already be published by a racing writer.\n        // Any other failure, including a failed initial write, rethrows immediately.\n        const errno = err as NodeJS.ErrnoException;\n        if (!(err instanceof Error) || errno.syscall !== 'rename' || !['EPERM', 'EACCES', 'EBUSY'].includes(errno.code ?? '')) throw err;\n        let existing: string;\n        try {\n          existing = readFileSync(configPath, 'utf8');\n        } catch {\n          throw err;\n        }\n        if (existing !== migrated) throw err;\n      }\n    }\n  } else {\n    cfg = validateConfig(parsed, configPath);\n  }\n\n  const unknownKeys = unknownConfigKeys(cfg as unknown as Record<string, unknown>);\n  const configDir = dirname(configPath);\n  const rootDir = resolve(configDir, cfg.root ?? '.');\n  return { ...cfg, configDir, rootDir, baseDir: rootDir, 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","prevEmbed","provider","linksOn","links","nextPresets","preset","SenseError","signals","words","build","from","current","v","SUPPORTED_CONFIG_VERSION","step","starterConfig","overrides","$schema","large","dir","configPath","join","CONFIG_FILENAME","existsSync","validateConfig","writeFileAtomic","JSON","stringify","startDir","resolve","candidate","parent","dirname","explicitPath","options","process","cwd","found","raw","readFileSync","parsed","parse","Array","isArray","migratedFrom","validateLegacyScan","writeMigration","migrated","err","errno","Error","syscall","includes","code","existing","unknownKeys","unknownConfigKeys","configDir","rootDir","root","baseDir"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/config/load.ts"],"sourcesContent":["import { channel } from 'node:diagnostics_channel';\nimport { existsSync, readFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { SenseError } from '../errors.ts';\nimport { writeFileAtomic } from '../lib/atomic-write.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;\nconst migrationReady = channel('sensemaking.config.migration-ready');\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 (no\n  // restructuring, no preset inference, no query rewriting); real trees get hand-migrated to 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 carries provider settings (model/type/url/key), not a toggle -- they move to\n    // the v3 top-level `embed` block verbatim; dropping them would silently switch an api tree to the 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    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 configured an api endpoint\n      // then turned vectors off; say it, since v4 has no way to carry provider settings for a tree that doesn't 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  // v4 -> v5: embed.type renames to embed.provider (\"api\" migrates to \"openai\", the wire protocol\n  // it always was; other values pass through). A preset's `semantic` also migrates to `signals` (false -> explicit weights, true/absent -> no key).\n  4: (cfg) => {\n    const prevEmbed = cfg.embed as Record<string, unknown> | undefined;\n    const result: Record<string, unknown> = { ...cfg, version: 5 };\n    if (prevEmbed) {\n      const { type, ...rest } = prevEmbed;\n      result.embed = type === undefined ? rest : { ...rest, provider: type === 'api' ? 'openai' : type };\n    }\n\n    const linksOn = (cfg.features as Record<string, unknown> | undefined)?.links !== false;\n    const presets = cfg.presets as Record<string, Record<string, unknown>> | undefined;\n    if (presets) {\n      const nextPresets: Record<string, unknown> = {};\n      for (const [name, preset] of Object.entries(presets)) {\n        const { semantic, ...rest } = preset;\n        if (semantic === undefined) {\n          nextPresets[name] = preset;\n          continue;\n        }\n        if (typeof semantic !== 'boolean') {\n          throw new SenseError('CONFIG_INVALID', `presets.${name}.semantic must be a boolean`);\n        }\n        nextPresets[name] = semantic === false ? { ...rest, signals: linksOn ? { words: 1, links: 1 } : { words: 1 } } : rest;\n      }\n      result.presets = nextPresets;\n    }\n    return result;\n  },\n  // v5 -> v6: query-triggered builds are on by default. Preserve an explicit opt-out.\n  5: (cfg) => ({ ...cfg, version: 6, build: cfg.build === undefined ? true : cfg.build }),\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\n// `sense init`'s flags map onto these three `embed` keys one-to-one; an absent field\n// keeps the built-in default rather than merging partial input.\nexport interface InitOverrides {\n  model?: string;\n  provider?: string;\n  url?: string;\n}\n\nfunction starterConfig(overrides?: InitOverrides): Config {\n  const embed: Record<string, unknown> = { model: DEFAULT_EMBED_MODEL, provider: 'static' };\n  if (overrides?.model !== undefined) embed.model = overrides.model;\n  if (overrides?.provider !== undefined) embed.provider = overrides.provider;\n  if (overrides?.url !== undefined) embed.url = overrides.url;\n  return {\n    $schema: 'https://unpkg.com/sensemaking/schema.json',\n    version: SUPPORTED_CONFIG_VERSION,\n    build: true,\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 a model, so it belongs where it can be read and changed.\n    embed: embed as Config['embed'],\n    queries: {},\n  };\n}\n\n// Refuses to overwrite an existing config. `overrides` come from `sense init`'s flags; an\n// invalid --provider fails validateConfig's own shape check before anything is written.\nexport function initConfig(dir: string, overrides?: InitOverrides): 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 cfg = starterConfig(overrides);\n  validateConfig(cfg, configPath);\n  writeFileAtomic(configPath, `${JSON.stringify(cfg, 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\n/** Controls whether loading an older config may persist its in-memory migration. */\nexport interface LoadConfigOptions {\n  /** Write a successful migration back to the config file. Defaults to true. */\n  writeMigration?: boolean;\n}\n\nexport function loadConfig(explicitPath?: string, options: LoadConfigOptions = {}): 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 shape checks: a non-object file (or array -- typeof []\n  // is also 'object') is malformed at every version, so it gets one error regardless of branch.\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    if (options.writeMigration !== false) {\n      const migrated = `${JSON.stringify(cfg, null, 2)}\\n`;\n      if (migrationReady.hasSubscribers) migrationReady.publish({ configPath, from: migratedFrom });\n      try {\n        writeFileAtomic(configPath, migrated);\n      } catch (err) {\n        // Only a rename-contention error might already be published by a racing writer.\n        // Any other failure, including a failed initial write, rethrows immediately.\n        const errno = err as NodeJS.ErrnoException;\n        if (!(err instanceof Error) || errno.syscall !== 'rename' || !['EPERM', 'EACCES', 'EBUSY'].includes(errno.code ?? '')) throw err;\n        let existing: string;\n        try {\n          existing = readFileSync(configPath, 'utf8');\n        } catch {\n          throw err;\n        }\n        if (existing !== migrated) throw err;\n      }\n    }\n  } else {\n    cfg = validateConfig(parsed, configPath);\n  }\n\n  const unknownKeys = unknownConfigKeys(cfg as unknown as Record<string, unknown>);\n  const configDir = dirname(configPath);\n  const rootDir = resolve(configDir, cfg.root ?? '.');\n  return { ...cfg, configDir, rootDir, baseDir: rootDir, configPath, migratedFrom, unknownKeys: unknownKeys.length > 0 ? unknownKeys : undefined };\n}\n"],"names":["findConfigPath","initConfig","loadConfig","migrateConfig","FIRST_PRESET_VERSION","migrationReady","channel","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","prevEmbed","provider","linksOn","links","nextPresets","preset","SenseError","signals","words","build","from","current","v","SUPPORTED_CONFIG_VERSION","step","starterConfig","overrides","$schema","large","dir","configPath","join","CONFIG_FILENAME","existsSync","validateConfig","writeFileAtomic","JSON","stringify","startDir","resolve","candidate","parent","dirname","explicitPath","options","process","cwd","found","raw","readFileSync","parsed","parse","Array","isArray","migratedFrom","validateLegacyScan","writeMigration","migrated","hasSubscribers","publish","err","errno","Error","syscall","includes","code","existing","unknownKeys","unknownConfigKeys","configDir","rootDir","root","baseDir"],"mappings":"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"}

package/dist/cjs/embed/cohere.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "cohereProvider", {
     }
 });
 var _errorsts = require("../errors.js");
+var _endpointts = require("./endpoint.js");
 var _httpts = require("./http.js");
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -135,13 +136,37 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 var BATCH_CAP = 96;
+function isNumberArray(value) {
+    return Array.isArray(value) && value.every(function(part) {
+        return typeof part === 'number';
+    });
+}
+function isEmbeddingArray(value) {
+    return Array.isArray(value) && value.every(isNumberArray);
+}
+function parseBody(body, endpoint) {
+    var decoded;
+    try {
+        decoded = JSON.parse(new TextDecoder().decode(body));
+    } catch (unused) {
+        throw new _errorsts.SenseError('EMBED_MODEL', "".concat(endpoint, " returned invalid JSON"));
+    }
+    if (decoded === null || (typeof decoded === "undefined" ? "undefined" : _type_of(decoded)) !== 'object' || !('embeddings' in decoded) || decoded.embeddings === null || _type_of(decoded.embeddings) !== 'object' || !('float' in decoded.embeddings) || !isEmbeddingArray(decoded.embeddings.float)) {
+        throw new _errorsts.SenseError('EMBED_MODEL', "".concat(endpoint, " returned an invalid embedding response"));
+    }
+    return decoded.embeddings.float;
+}
 function cohereProvider(model, url, keyEnv) {
     return _async_to_generator(function() {
         var base, headers, key, dims;
-        function post(texts, inputType) {
+        function post(texts, inputType, options) {
             return _async_to_generator(function() {
-                var res, body, vectors;
+                var _options_signal, res, body, vectors;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
@@ -158,21 +183,20 @@ function cohereProvider(model, url, keyEnv) {
                                             'float'
                                         ]
                                     })
+                                }, {
+                                    signal: options === null || options === void 0 ? void 0 : options.signal,
+                                    attemptTimeoutMs: _httpts.HTTP_ATTEMPT_TIMEOUT_MS
                                 })
                             ];
                         case 1:
                             res = _state.sent();
-                            if (!res.ok) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(base, "/v2/embed -> HTTP ").concat(res.status));
-                            return [
-                                4,
-                                res.json()
-                            ];
-                        case 2:
-                            body = _state.sent();
+                            options === null || options === void 0 ? void 0 : (_options_signal = options.signal) === null || _options_signal === void 0 ? void 0 : _options_signal.throwIfAborted();
+                            if (!res.ok) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(res.url, " -> HTTP ").concat(res.status));
+                            body = parseBody(res.body, res.url);
                             // Cohere returns one vector per text in order, with no index field to re-sort by; a caller
                             // maps them positionally, so the count below must be trustworthy.
-                            vectors = body.embeddings.float;
-                            if (vectors.length !== texts.length) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(base, "/v2/embed returned ").concat(vectors.length, " embeddings for ").concat(texts.length, " inputs"));
+                            vectors = body;
+                            if (vectors.length !== texts.length) throw new _errorsts.SenseError('EMBED_MODEL', "".concat(res.url, " returned ").concat(vectors.length, " embeddings for ").concat(texts.length, " inputs"));
                             return [
                                 2,
                                 vectors.map(function(v) {
@@ -186,7 +210,8 @@ function cohereProvider(model, url, keyEnv) {
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
-                    base = (url !== null && url !== void 0 ? url : 'https://api.cohere.com').replace(/\/+$/, '');
+                    base = (0, _endpointts.effectiveEmbedEndpoint)('cohere', url);
+                    if (!base) throw new _errorsts.SenseError('EMBED_MODEL', 'cohere endpoint resolution failed');
                     headers = {
                         'content-type': 'application/json'
                     };
@@ -206,10 +231,10 @@ function cohereProvider(model, url, keyEnv) {
                             id: "cohere:".concat(base, ":").concat(model),
                             dims: dims,
                             batchCap: BATCH_CAP,
-                            embedDocuments: function embedDocuments(texts) {
-                                return post(texts, 'search_document');
+                            embedDocuments: function embedDocuments(texts, options) {
+                                return post(texts, 'search_document', options);
                             },
-                            embedQuery: function embedQuery(text) {
+                            embedQuery: function embedQuery(text, options) {
                                 return _async_to_generator(function() {
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
@@ -218,7 +243,7 @@ function cohereProvider(model, url, keyEnv) {
                                                     4,
                                                     post([
                                                         text
-                                                    ], 'search_query')
+                                                    ], 'search_query', options)
                                                 ];
                                             case 1:
                                                 return [

package/dist/cjs/embed/cohere.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/cohere.ts"],"sourcesContent":["import { SenseError } from '../errors.ts';\nimport { fetchWithRetry } from './http.ts';\nimport type { EmbedProvider } from './types.ts';\n\nconst BATCH_CAP = 96;\n\n// Cohere's native /v2/embed: input_type distinguishes doc vs query embeddings, which the\n// OpenAI-compatible shape cannot express.\nexport async function cohereProvider(model: string, url: string | undefined, keyEnv: string | undefined): Promise<EmbedProvider> {\n  const base = (url ?? 'https://api.cohere.com').replace(/\\/+$/, '');\n  const headers: Record<string, string> = { 'content-type': 'application/json' };\n  const key = keyEnv ? process.env[keyEnv] : undefined;\n  if (key) headers.authorization = `Bearer ${key}`;\n\n  async function post(texts: string[], inputType: 'search_document' | 'search_query'): Promise<Float32Array[]> {\n    const res = await fetchWithRetry(`${base}/v2/embed`, { method: 'POST', headers, body: JSON.stringify({ model, input_type: inputType, texts, embedding_types: ['float'] }) });\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `${base}/v2/embed -> HTTP ${res.status}`);\n    const body = (await res.json()) as { embeddings: { float: number[][] } };\n    // Cohere returns one vector per text in order, with no index field to re-sort by; a caller\n    // maps them positionally, so the count below must be trustworthy.\n    const vectors = body.embeddings.float;\n    if (vectors.length !== texts.length) throw new SenseError('EMBED_MODEL', `${base}/v2/embed returned ${vectors.length} embeddings for ${texts.length} inputs`);\n    return vectors.map((v) => Float32Array.from(v));\n  }\n\n  const dims = (await post(['dimension probe'], 'search_query'))[0].length;\n  return { id: `cohere:${base}:${model}`, dims, batchCap: BATCH_CAP, embedDocuments: (texts) => post(texts, 'search_document'), embedQuery: async (text) => (await post([text], 'search_query'))[0] };\n}\n"],"names":["cohereProvider","BATCH_CAP","model","url","keyEnv","base","headers","key","dims","post","texts","inputType","res","body","vectors","fetchWithRetry","method","JSON","stringify","input_type","embedding_types","ok","SenseError","status","json","embeddings","float","length","map","v","Float32Array","from","replace","process","env","undefined","authorization","id","batchCap","embedDocuments","embedQuery","text"],"mappings":";;;;+BAQsBA;;;eAAAA;;;wBARK;sBACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAG/B,IAAMC,YAAY;AAIX,SAAeD,eAAeE,KAAa,EAAEC,GAAuB,EAAEC,MAA0B;;YAC/FC,MACAC,SACAC,KAcAC;QAXN,SAAeC,KAAKC,KAAe,EAAEC,SAA6C;;oBAC1EC,KAEAC,MAGAC;;;;4BALM;;gCAAMC,IAAAA,sBAAc,EAAC,AAAC,GAAO,OAALV,MAAK,cAAY;oCAAEW,QAAQ;oCAAQV,SAAAA;oCAASO,MAAMI,KAAKC,SAAS,CAAC;wCAAEhB,OAAAA;wCAAOiB,YAAYR;wCAAWD,OAAAA;wCAAOU,eAAe;4CAAG;;oCAAS;gCAAG;;;4BAApKR,MAAM;4BACZ,IAAI,CAACA,IAAIS,EAAE,EAAE,MAAM,IAAIC,oBAAU,CAAC,eAAe,AAAC,GAA2BV,OAAzBP,MAAK,sBAA+B,OAAXO,IAAIW,MAAM;4BACzE;;gCAAMX,IAAIY,IAAI;;;4BAAtBX,OAAQ;4BACd,2FAA2F;4BAC3F,kEAAkE;4BAC5DC,UAAUD,KAAKY,UAAU,CAACC,KAAK;4BACrC,IAAIZ,QAAQa,MAAM,KAAKjB,MAAMiB,MAAM,EAAE,MAAM,IAAIL,oBAAU,CAAC,eAAe,AAAC,GAA4BR,OAA1BT,MAAK,uBAAsDK,OAAjCI,QAAQa,MAAM,EAAC,oBAA+B,OAAbjB,MAAMiB,MAAM,EAAC;4BACpJ;;gCAAOb,QAAQc,GAAG,CAAC,SAACC;2CAAMC,aAAaC,IAAI,CAACF;;;;;YAC9C;;;;;oBAdMxB,OAAO,CAACF,gBAAAA,iBAAAA,MAAO,0BAA0B6B,OAAO,CAAC,QAAQ;oBACzD1B,UAAkC;wBAAE,gBAAgB;oBAAmB;oBACvEC,MAAMH,SAAS6B,QAAQC,GAAG,CAAC9B,OAAO,GAAG+B;oBAC3C,IAAI5B,KAAKD,QAAQ8B,aAAa,GAAG,AAAC,UAAa,OAAJ7B;oBAa7B;;wBAAME;4BAAM;2BAAoB;;;oBAAxCD,OAAO,AAAC,aAAgD,CAAC,EAAE,CAACmB,MAAM;oBACxE;;wBAAO;4BAAEU,IAAI,AAAC,UAAiBnC,OAARG,MAAK,KAAS,OAANH;4BAASM,MAAAA;4BAAM8B,UAAUrC;4BAAWsC,gBAAgB,SAAhBA,eAAiB7B;uCAAUD,KAAKC,OAAO;;4BAAoB8B,YAAY,SAAZA,WAAmBC;;;;;gDAAU;;oDAAMhC;wDAAMgC;uDAAO;;;;;oDAAnB,aAAmC,CAAC,EAAE;;;;;;wBAAC;;;;IACpM"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/cohere.ts"],"sourcesContent":["import { SenseError } from '../errors.ts';\nimport { effectiveEmbedEndpoint } from './endpoint.ts';\nimport { fetchWithRetry, HTTP_ATTEMPT_TIMEOUT_MS } from './http.ts';\nimport type { EmbedCallOptions, EmbedProvider } from './types.ts';\n\nconst BATCH_CAP = 96;\n\nfunction isNumberArray(value: unknown): value is number[] {\n  return Array.isArray(value) && value.every((part) => typeof part === 'number');\n}\n\nfunction isEmbeddingArray(value: unknown): value is number[][] {\n  return Array.isArray(value) && value.every(isNumberArray);\n}\n\nfunction parseBody(body: ArrayBuffer, endpoint: string): number[][] {\n  let decoded: unknown;\n  try {\n    decoded = JSON.parse(new TextDecoder().decode(body));\n  } catch {\n    throw new SenseError('EMBED_MODEL', `${endpoint} returned invalid JSON`);\n  }\n  if (decoded === null || typeof decoded !== 'object' || !('embeddings' in decoded) || decoded.embeddings === null || typeof decoded.embeddings !== 'object' || !('float' in decoded.embeddings) || !isEmbeddingArray(decoded.embeddings.float)) {\n    throw new SenseError('EMBED_MODEL', `${endpoint} returned an invalid embedding response`);\n  }\n  return decoded.embeddings.float;\n}\n\n// Cohere's native /v2/embed: input_type distinguishes doc vs query embeddings, which the\n// OpenAI-compatible shape cannot express.\nexport async function cohereProvider(model: string, url: string | undefined, keyEnv: string | undefined): Promise<EmbedProvider> {\n  const base = effectiveEmbedEndpoint('cohere', url);\n  if (!base) throw new SenseError('EMBED_MODEL', 'cohere endpoint resolution failed');\n  const headers: Record<string, string> = { 'content-type': 'application/json' };\n  const key = keyEnv ? process.env[keyEnv] : undefined;\n  if (key) headers.authorization = `Bearer ${key}`;\n\n  async function post(texts: string[], inputType: 'search_document' | 'search_query', options?: EmbedCallOptions): Promise<Float32Array[]> {\n    const res = await fetchWithRetry(`${base}/v2/embed`, { method: 'POST', headers, body: JSON.stringify({ model, input_type: inputType, texts, embedding_types: ['float'] }) }, { signal: options?.signal, attemptTimeoutMs: HTTP_ATTEMPT_TIMEOUT_MS });\n    options?.signal?.throwIfAborted();\n    if (!res.ok) throw new SenseError('EMBED_MODEL', `${res.url} -> HTTP ${res.status}`);\n    const body = parseBody(res.body, res.url);\n    // Cohere returns one vector per text in order, with no index field to re-sort by; a caller\n    // maps them positionally, so the count below must be trustworthy.\n    const vectors = body;\n    if (vectors.length !== texts.length) throw new SenseError('EMBED_MODEL', `${res.url} returned ${vectors.length} embeddings for ${texts.length} inputs`);\n    return vectors.map((v) => Float32Array.from(v));\n  }\n\n  const dims = (await post(['dimension probe'], 'search_query'))[0].length;\n  return { id: `cohere:${base}:${model}`, dims, batchCap: BATCH_CAP, embedDocuments: (texts, options) => post(texts, 'search_document', options), embedQuery: async (text, options) => (await post([text], 'search_query', options))[0] };\n}\n"],"names":["cohereProvider","BATCH_CAP","isNumberArray","value","Array","isArray","every","part","isEmbeddingArray","parseBody","body","endpoint","decoded","JSON","parse","TextDecoder","decode","SenseError","embeddings","float","model","url","keyEnv","base","headers","key","dims","post","texts","inputType","options","res","vectors","fetchWithRetry","method","stringify","input_type","embedding_types","signal","attemptTimeoutMs","HTTP_ATTEMPT_TIMEOUT_MS","throwIfAborted","ok","status","length","map","v","Float32Array","from","effectiveEmbedEndpoint","process","env","undefined","authorization","id","batchCap","embedDocuments","embedQuery","text"],"mappings":"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"}

package/dist/cjs/embed/endpoint.d.cts

@@ -0,0 +1,2 @@
+export declare function effectiveEmbedEndpoint(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;
+export declare function embedEndpointIdentity(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;

package/dist/cjs/embed/endpoint.d.ts

@@ -0,0 +1,2 @@
+export declare function effectiveEmbedEndpoint(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;
+export declare function embedEndpointIdentity(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined;

package/dist/cjs/embed/endpoint.js

@@ -0,0 +1,30 @@
+"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 effectiveEmbedEndpoint () {
+        return effectiveEmbedEndpoint;
+    },
+    get embedEndpointIdentity () {
+        return embedEndpointIdentity;
+    }
+});
+var _nodecrypto = require("node:crypto");
+var DEFAULT_COHERE_ENDPOINT = 'https://api.cohere.com';
+function effectiveEmbedEndpoint(provider, url) {
+    if (provider === 'static') return undefined;
+    var endpoint = provider === 'cohere' ? url !== null && url !== void 0 ? url : DEFAULT_COHERE_ENDPOINT : url;
+    return endpoint === null || endpoint === void 0 ? void 0 : endpoint.replace(/\/+$/, '');
+}
+function embedEndpointIdentity(provider, url) {
+    var endpoint = effectiveEmbedEndpoint(provider, url);
+    return endpoint === undefined ? undefined : (0, _nodecrypto.createHash)('sha256').update(endpoint).digest('hex');
+}
+/* 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/embed/endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/endpoint.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nconst DEFAULT_COHERE_ENDPOINT = 'https://api.cohere.com';\n\nexport function effectiveEmbedEndpoint(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined {\n  if (provider === 'static') return undefined;\n  const endpoint = provider === 'cohere' ? (url ?? DEFAULT_COHERE_ENDPOINT) : url;\n  return endpoint?.replace(/\\/+$/, '');\n}\n\nexport function embedEndpointIdentity(provider: 'static' | 'openai' | 'cohere', url: string | undefined): string | undefined {\n  const endpoint = effectiveEmbedEndpoint(provider, url);\n  return endpoint === undefined ? undefined : createHash('sha256').update(endpoint).digest('hex');\n}\n"],"names":["effectiveEmbedEndpoint","embedEndpointIdentity","DEFAULT_COHERE_ENDPOINT","provider","url","undefined","endpoint","replace","createHash","update","digest"],"mappings":";;;;;;;;;;;QAIgBA;eAAAA;;QAMAC;eAAAA;;;0BAVW;AAE3B,IAAMC,0BAA0B;AAEzB,SAASF,uBAAuBG,QAAwC,EAAEC,GAAuB;IACtG,IAAID,aAAa,UAAU,OAAOE;IAClC,IAAMC,WAAWH,aAAa,WAAYC,gBAAAA,iBAAAA,MAAOF,0BAA2BE;IAC5E,OAAOE,qBAAAA,+BAAAA,SAAUC,OAAO,CAAC,QAAQ;AACnC;AAEO,SAASN,sBAAsBE,QAAwC,EAAEC,GAAuB;IACrG,IAAME,WAAWN,uBAAuBG,UAAUC;IAClD,OAAOE,aAAaD,YAAYA,YAAYG,IAAAA,sBAAU,EAAC,UAAUC,MAAM,CAACH,UAAUI,MAAM,CAAC;AAC3F"}

package/dist/cjs/embed/handoff.d.cts

@@ -1,3 +1,8 @@
-export declare function stashChunkText(key: object, texts: Map<string, string[]>): void;
+export interface ChunkText {
+    text: string;
+    identity: string;
+}
+export declare function identifyChunkText(text: string): ChunkText;
+export declare function stashChunkText(key: object, texts: Map<string, ChunkText[]>): void;
 export declare function rekeyChunkText(from: object, to: object): void;
-export declare function takeChunkText(key: object): Map<string, string[]> | undefined;
+export declare function takeChunkText(key: object): Map<string, ChunkText[]> | undefined;

package/dist/cjs/embed/handoff.d.ts

@@ -1,3 +1,8 @@
-export declare function stashChunkText(key: object, texts: Map<string, string[]>): void;
+export interface ChunkText {
+    text: string;
+    identity: string;
+}
+export declare function identifyChunkText(text: string): ChunkText;
+export declare function stashChunkText(key: object, texts: Map<string, ChunkText[]>): void;
 export declare function rekeyChunkText(from: object, to: object): void;
-export declare function takeChunkText(key: object): Map<string, string[]> | undefined;
+export declare function takeChunkText(key: object): Map<string, ChunkText[]> | undefined;

package/dist/cjs/embed/handoff.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get identifyChunkText () {
+        return identifyChunkText;
+    },
     get rekeyChunkText () {
         return rekeyChunkText;
     },
@@ -19,6 +22,13 @@ _export(exports, {
         return takeChunkText;
     }
 });
+var _nodecrypto = require("node:crypto");
+function identifyChunkText(text) {
+    return {
+        text: text,
+        identity: (0, _nodecrypto.createHash)('sha256').update(text).digest('hex')
+    };
+}
 // Chunk text from reconcile to embed time when both run in one process, so the text is neither
 // re-derived nor persisted. Keyed by the store it was stashed against, so an entry dies with it.
 var HANDOFF = new WeakMap();

package/dist/cjs/embed/handoff.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/handoff.ts"],"sourcesContent":["// Chunk text from reconcile to embed time when both run in one process, so the text is neither\n// re-derived nor persisted. Keyed by the store it was stashed against, so an entry dies with it.\nconst HANDOFF = new WeakMap<object, Map<string, string[]>>();\n\nexport function stashChunkText(key: object, texts: Map<string, string[]>): void {\n  if (texts.size > 0) HANDOFF.set(key, texts);\n}\n\n// Moves an entry from one key to another: reconcile runs before the store object exists, so it\n// stashes against the connection and open() re-keys onto the store it then builds.\nexport function rekeyChunkText(from: object, to: object): void {\n  const texts = HANDOFF.get(from);\n  if (!texts) return;\n  HANDOFF.delete(from);\n  HANDOFF.set(to, texts);\n}\n\n// Read once and drop: the text is consumed by the embed pass that follows reconcile, and holding\n// it past that would pin the tree's prose in memory for the life of the store.\nexport function takeChunkText(key: object): Map<string, string[]> | undefined {\n  const texts = HANDOFF.get(key);\n  HANDOFF.delete(key);\n  return texts;\n}\n"],"names":["rekeyChunkText","stashChunkText","takeChunkText","HANDOFF","WeakMap","key","texts","size","set","from","to","get","delete"],"mappings":";;;;;;;;;;;QAUgBA;eAAAA;;QANAC;eAAAA;;QAeAC;eAAAA;;;AAnBhB,+FAA+F;AAC/F,iGAAiG;AACjG,IAAMC,UAAU,IAAIC;AAEb,SAASH,eAAeI,GAAW,EAAEC,KAA4B;IACtE,IAAIA,MAAMC,IAAI,GAAG,GAAGJ,QAAQK,GAAG,CAACH,KAAKC;AACvC;AAIO,SAASN,eAAeS,IAAY,EAAEC,EAAU;IACrD,IAAMJ,QAAQH,QAAQQ,GAAG,CAACF;IAC1B,IAAI,CAACH,OAAO;IACZH,QAAQS,MAAM,CAACH;IACfN,QAAQK,GAAG,CAACE,IAAIJ;AAClB;AAIO,SAASJ,cAAcG,GAAW;IACvC,IAAMC,QAAQH,QAAQQ,GAAG,CAACN;IAC1BF,QAAQS,MAAM,CAACP;IACf,OAAOC;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/embed/handoff.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nexport interface ChunkText {\n  text: string;\n  identity: string;\n}\n\nexport function identifyChunkText(text: string): ChunkText {\n  return { text, identity: createHash('sha256').update(text).digest('hex') };\n}\n\n// Chunk text from reconcile to embed time when both run in one process, so the text is neither\n// re-derived nor persisted. Keyed by the store it was stashed against, so an entry dies with it.\nconst HANDOFF = new WeakMap<object, Map<string, ChunkText[]>>();\n\nexport function stashChunkText(key: object, texts: Map<string, ChunkText[]>): void {\n  if (texts.size > 0) HANDOFF.set(key, texts);\n}\n\n// Moves an entry from one key to another: reconcile runs before the store object exists, so it\n// stashes against the connection and open() re-keys onto the store it then builds.\nexport function rekeyChunkText(from: object, to: object): void {\n  const texts = HANDOFF.get(from);\n  if (!texts) return;\n  HANDOFF.delete(from);\n  HANDOFF.set(to, texts);\n}\n\n// Read once and drop: the text is consumed by the embed pass that follows reconcile, and holding\n// it past that would pin the tree's prose in memory for the life of the store.\nexport function takeChunkText(key: object): Map<string, ChunkText[]> | undefined {\n  const texts = HANDOFF.get(key);\n  HANDOFF.delete(key);\n  return texts;\n}\n"],"names":["identifyChunkText","rekeyChunkText","stashChunkText","takeChunkText","text","identity","createHash","update","digest","HANDOFF","WeakMap","key","texts","size","set","from","to","get","delete"],"mappings":";;;;;;;;;;;QAOgBA;eAAAA;;QAcAC;eAAAA;;QANAC;eAAAA;;QAeAC;eAAAA;;;0BA9BW;AAOpB,SAASH,kBAAkBI,IAAY;IAC5C,OAAO;QAAEA,MAAAA;QAAMC,UAAUC,IAAAA,sBAAU,EAAC,UAAUC,MAAM,CAACH,MAAMI,MAAM,CAAC;IAAO;AAC3E;AAEA,+FAA+F;AAC/F,iGAAiG;AACjG,IAAMC,UAAU,IAAIC;AAEb,SAASR,eAAeS,GAAW,EAAEC,KAA+B;IACzE,IAAIA,MAAMC,IAAI,GAAG,GAAGJ,QAAQK,GAAG,CAACH,KAAKC;AACvC;AAIO,SAASX,eAAec,IAAY,EAAEC,EAAU;IACrD,IAAMJ,QAAQH,QAAQQ,GAAG,CAACF;IAC1B,IAAI,CAACH,OAAO;IACZH,QAAQS,MAAM,CAACH;IACfN,QAAQK,GAAG,CAACE,IAAIJ;AAClB;AAIO,SAAST,cAAcQ,GAAW;IACvC,IAAMC,QAAQH,QAAQQ,GAAG,CAACN;IAC1BF,QAAQS,MAAM,CAACP;IACf,OAAOC;AACT"}

package/dist/cjs/embed/http.d.cts

@@ -1,2 +1,19 @@
-export declare function fetchWithRetry(url: string, init: RequestInit, baseDelayMs?: number): Promise<Response>;
+export declare const HTTP_ATTEMPT_TIMEOUT_MS = 30000;
+export declare const MODEL_FILE_ATTEMPT_TIMEOUT_MS: number;
+export type FetchRequestInit = Omit<RequestInit, 'signal'> & {
+    signal?: never;
+};
+export interface FetchRetryOptions {
+    signal?: AbortSignal;
+    attemptTimeoutMs?: number;
+    baseDelayMs?: number;
+}
+export interface BufferedResponse {
+    readonly ok: boolean;
+    readonly status: number;
+    readonly headers: Headers;
+    readonly body: ArrayBuffer;
+    readonly url: string;
+}
+export declare function fetchWithRetry(url: string, init: FetchRequestInit, options?: FetchRetryOptions): Promise<BufferedResponse>;
 export declare function probeReachable(url: string, timeoutMs?: number): Promise<boolean>;