@cortexkit/magic-context 0.49.24 → 0.49.25

package/dist/index.js

@@ -25260,6 +25260,29 @@ function getOpenCodeV2ActiveGeneration(slot) {
     return;
   }
 }
+function openCodeV2SlotSpec(spec, platform = process.platform) {
+  if (platform !== "win32")
+    return spec;
+  return Array.from(spec, (char) => '<>:"|?*'.includes(char) || char.charCodeAt(0) < 32 ? "_" : char).join("");
+}
+function getOpenCodePluginInstallRoots(hostGeneration, config, npmCacheDir = getOpenCodeV2NpmCacheDir(), platform = process.platform) {
+  const configured = openCodeV2SlotSpec(readConfiguredOpenCodePluginSpec(config), platform);
+  const v2 = listOpenCodeV2PluginCacheSlots(npmCacheDir).sort((a, b) => Number(b.spec === configured) - Number(a.spec === configured)).map((slot) => getOpenCodeV2ActiveGeneration(slot.slot)).filter((generation) => generation !== undefined);
+  const v1 = getOpenCodePluginCacheRoots();
+  return hostGeneration === "v2" ? [...v2, ...v1] : [...v1, ...v2];
+}
+function getOpenCodeLoadedPluginInstallRoots(hostGeneration, config, npmCacheDir = getOpenCodeV2NpmCacheDir(), platform = process.platform) {
+  let loaded;
+  if (hostGeneration === "v2") {
+    const configured = openCodeV2SlotSpec(readConfiguredOpenCodePluginSpec(config), platform);
+    const generation = getOpenCodeV2ActiveGeneration(getOpenCodeV2PluginCacheSlot(npmCacheDir, configured));
+    loaded = generation === undefined ? [] : [generation];
+  } else {
+    loaded = getOpenCodePluginCacheRoots();
+  }
+  const others = getOpenCodePluginInstallRoots(hostGeneration, config, npmCacheDir, platform).filter((root) => !loaded.includes(root));
+  return { loaded, others };
+}
 function readOpenCodeV2CachedPluginVersion(slot) {
   const generation = getOpenCodeV2ActiveGeneration(slot);
   if (!generation)
@@ -33114,6 +33137,51 @@ var init_read_session_formatting = __esm(() => {
   PROMPT_TOKEN_COUNT_BYTES = 8 * 1024 * 1024;
 });
 
+// ../plugin/src/shared/bounded-session-map.ts
+class BoundedSessionMap {
+  maxEntries;
+  store = new Map;
+  constructor(maxEntries) {
+    if (!Number.isFinite(maxEntries) || maxEntries < 1) {
+      throw new Error(`BoundedSessionMap: maxEntries must be >= 1, got ${maxEntries}`);
+    }
+    this.maxEntries = maxEntries;
+  }
+  get(sessionId) {
+    const value = this.store.get(sessionId);
+    if (value === undefined)
+      return;
+    this.store.delete(sessionId);
+    this.store.set(sessionId, value);
+    return value;
+  }
+  peek(sessionId) {
+    return this.store.get(sessionId);
+  }
+  has(sessionId) {
+    return this.store.has(sessionId);
+  }
+  set(sessionId, value) {
+    if (this.store.has(sessionId)) {
+      this.store.delete(sessionId);
+    } else if (this.store.size >= this.maxEntries) {
+      const oldest = this.store.keys().next().value;
+      if (oldest !== undefined)
+        this.store.delete(oldest);
+    }
+    this.store.set(sessionId, value);
+  }
+  delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+}
+
 // ../plugin/src/shared/stable-json.ts
 function stableStringify(value, seen = new WeakSet) {
   const pieces = [];
@@ -33168,36 +33236,122 @@ function writeStable(value, seen, write) {
 }
 
 // ../plugin/src/features/magic-context/tool-definition-tokens.ts
+function agentKey(agentName) {
+  return agentName && agentName.length > 0 ? agentName : "default";
+}
 function keyFor(providerID, modelID, agentName) {
-  const agent = agentName && agentName.length > 0 ? agentName : "default";
-  return `${providerID}/${modelID}/${agent}`;
+  return `${providerID}/${modelID}/${agentKey(agentName)}`;
+}
+function routeFor(providerID, modelID, agentName) {
+  const key = keyFor(providerID, modelID, agentName);
+  let route = routes.get(key);
+  if (!route) {
+    route = {
+      providerID,
+      modelID,
+      agentName: agentKey(agentName),
+      tools: new Map,
+      live: false,
+      clock: 0,
+      lastWallAt: Date.now(),
+      oldestFireAt: Number.POSITIVE_INFINITY,
+      retired: new Map,
+      legacyRows: new Set
+    };
+    routes.set(key, route);
+  }
+  return { key, route };
+}
+function advanceClock(route) {
+  const now = Date.now();
+  const gap = Math.min(Math.max(now - route.lastWallAt, 0), MAX_ACTIVITY_GAP_MS);
+  route.clock += gap;
+  route.lastWallAt = Math.max(route.lastWallAt, now);
+  return route.clock;
+}
+function readWindowedSince(db) {
+  try {
+    const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(WINDOWED_SINCE_KEY);
+    if (!row)
+      return;
+    const value = Number(row.value);
+    return Number.isFinite(value) ? value : undefined;
+  } catch {
+    return;
+  }
+}
+function markWindowed() {
+  if (windowedSince !== undefined || !persistenceDb)
+    return;
+  try {
+    persistenceDb.prepare("INSERT OR IGNORE INTO schema_migrations_meta (key, value) VALUES (?, ?)").run(WINDOWED_SINCE_KEY, String(boundAt));
+    windowedSince = readWindowedSince(persistenceDb);
+  } catch {}
 }
 function setDatabase(db) {
+  const rebound = persistenceDb !== null && persistenceDb !== db;
   persistenceDb = db;
+  boundAt = Date.now();
   cachedInsertStmt = null;
+  cachedDeleteStmt = null;
+  if (rebound) {
+    for (const route of routes.values()) {
+      for (const slot of route.tools.values()) {
+        slot.persisted = false;
+        slot.writeFailedAt = undefined;
+      }
+      for (const retired of route.retired.values())
+        retired.rowKept = false;
+      route.legacyRows.clear();
+    }
+  }
+  windowedSince = readWindowedSince(db);
+  if (windowedSince !== undefined)
+    return;
+  try {
+    if (!db.prepare("SELECT 1 FROM tool_definition_measurements LIMIT 1").get())
+      markWindowed();
+  } catch {}
 }
 function loadToolDefinitionMeasurements(db) {
   let rows = [];
   try {
-    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count, recorded_at FROM tool_definition_measurements").all();
   } catch {
     return;
   }
+  const since = readWindowedSince(db);
+  const loadedAt = new Map;
   for (const row of rows) {
-    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
-    let inner = measurements.get(key);
-    if (!inner) {
-      inner = new Map;
-      measurements.set(key, inner);
-    }
-    inner.set(row.tool_id, row.token_count);
+    const { route } = routeFor(row.provider_id, row.model_id, row.agent_name);
+    if (route.live)
+      continue;
+    let now = loadedAt.get(route);
+    if (now === undefined) {
+      now = advanceClock(route);
+      loadedAt.set(route, now);
+    }
+    const legacy = since === undefined || !(Number(row.recorded_at) >= since);
+    route.tools.set(row.tool_id, {
+      tokens: row.token_count,
+      fingerprint: undefined,
+      lastFireAt: now,
+      legacy,
+      persisted: !legacy
+    });
+    route.oldestFireAt = Math.min(route.oldestFireAt, now);
+    if (legacy)
+      route.legacyRows.add(row.tool_id);
+    else
+      route.legacyRows.delete(row.tool_id);
   }
 }
-var measurements, fingerprints, persistenceDb = null, cachedInsertStmt = null;
+var ACTIVITY_WINDOW_MS, MAX_ACTIVITY_GAP_MS = 60000, WINDOWED_SINCE_KEY = "tool_definition_measurements:windowed_since", routes, sessionFlights, persistenceDb = null, windowedSince, boundAt = 0, cachedInsertStmt = null, cachedDeleteStmt = null;
 var init_tool_definition_tokens = __esm(() => {
   init_read_session_formatting();
-  measurements = new Map;
-  fingerprints = new Map;
+  ACTIVITY_WINDOW_MS = 10 * 60000;
+  routes = new Map;
+  sessionFlights = new BoundedSessionMap(1000);
 });
 
 // ../plugin/src/features/magic-context/tool-owner-backfill.ts
@@ -52538,8 +52692,8 @@ async function runIssueFlow2(options = {}, deps = { collectDiagnostics }) {
     return 1;
   }
 }
-function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
-  const runtime = checkLocalEmbeddingRuntime(getOpenCodePluginCacheRoots(), process.platform, process.arch, runtimePreference);
+function checkLocalEmbeddingRuntimeForDoctor(installRoots, runtimePreference = "auto") {
+  const runtime = checkLocalEmbeddingRuntime(installRoots, process.platform, process.arch, runtimePreference);
   if (runtime.state === "wasm-selected") {
     log3.warn(formatLocalEmbeddingRuntimeWasmSelected(runtime));
     return { issues: 0 };
@@ -52559,15 +52713,15 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   log3.success("Embedding provider: local (native runtime selected and OK; Xenova/all-MiniLM-L6-v2 bundled)");
   return { issues: 0 };
 }
-async function checkEmbeddingConfig(magicContextConfigPath) {
+async function checkEmbeddingConfig(magicContextConfigPath, installRoots) {
   if (!existsSync49(magicContextConfigPath)) {
-    return checkLocalEmbeddingRuntimeForDoctor();
+    return checkLocalEmbeddingRuntimeForDoctor(installRoots);
   }
   let rawText;
   try {
     const raw = loadRawConfigFile({ configPath: magicContextConfigPath, tier: "user" });
     if (!raw)
-      return checkLocalEmbeddingRuntimeForDoctor();
+      return checkLocalEmbeddingRuntimeForDoctor(installRoots);
     rawText = raw.text;
   } catch {
     log3.warn("Could not read magic-context.jsonc for embedding check");
@@ -52592,7 +52746,7 @@ async function checkEmbeddingConfig(magicContextConfigPath) {
   }
   if (provider === undefined || provider === "local") {
     const runtimePreference = embedding?.local_runtime === "native" || embedding?.local_runtime === "wasm" ? embedding.local_runtime : "auto";
-    return checkLocalEmbeddingRuntimeForDoctor(runtimePreference);
+    return checkLocalEmbeddingRuntimeForDoctor(installRoots, runtimePreference);
   }
   if (provider === "synapse") {
     const loaded = loadPluginConfig(process.cwd());
@@ -53271,7 +53425,16 @@ async function runDoctor2(options = {}) {
       }
     } catch {}
   }
-  const embeddingCheck = await checkEmbeddingConfig(paths.magicContextConfig);
+  let embeddingHostConfig = null;
+  try {
+    if (paths.opencodeConfigFormat !== "none")
+      embeddingHostConfig = import_comment_json11.parse(readFileSync32(paths.opencodeConfig, "utf-8"));
+  } catch {}
+  const embeddingInstalls = getOpenCodeLoadedPluginInstallRoots(hostGeneration, embeddingHostConfig);
+  const unusedInstalls = embeddingInstalls.others.filter((root) => existsSync49(root));
+  if (unusedInstalls.length > 0)
+    log3.info(`Local embedding runtime: checked only the copy ${hostGeneration === "v2" ? "OpenCode 2" : "OpenCode 1"} loads; other installed copies (not loaded, not checked): ${unusedInstalls.join(", ")}`);
+  const embeddingCheck = await checkEmbeddingConfig(paths.magicContextConfig, embeddingInstalls.loaded);
   issues += embeddingCheck.issues;
   if (embeddingCheck.issues > 0)
     failCount += embeddingCheck.issues;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cortexkit/magic-context",
-    "version": "0.49.24",
+    "version": "0.49.25",
     "description": "Unified CLI for Magic Context — setup, doctor, and migration across OpenCode, Pi, and OMP",
     "keywords": [
         "opencode",