@cortexkit/opencode-magic-context 0.33.0 → 0.34.0

package/dist/index-fcyvznch.js

@@ -0,0 +1,279 @@
+import {
+  log
+} from "./index-k1esqfwk.js";
+import {
+  getDataDir
+} from "./index-kvrcg31b.js";
+
+// src/shared/sqlite-helpers.ts
+function closeQuietly(db) {
+  if (!db)
+    return;
+  try {
+    db.close();
+  } catch {}
+}
+
+// src/hooks/magic-context/read-session-db.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+// src/shared/sqlite.ts
+var isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+var bunSpec = "bun:" + "sqlite";
+var nodeSpec = "node:" + "sqlite";
+var sqliteModule = isBun ? await import(bunSpec) : await import(nodeSpec);
+var DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+function buildNodeSqliteDatabaseClass(DatabaseSync) {
+  const SAVEPOINT = "mc_tx_sp";
+
+  class NodeSqliteDatabase extends DatabaseSync {
+    constructor(filename, options) {
+      const translated = { ...options };
+      if (options && "readonly" in options) {
+        translated.readOnly = options.readonly;
+        delete translated.readonly;
+      }
+      super(typeof filename === "string" ? filename : ":memory:", translated);
+    }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
+    transaction(fn) {
+      const self = this;
+      const execute = (mode, receiver, args) => {
+        const nested = self.isTransaction === true;
+        self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
+        try {
+          const result = fn.apply(receiver, args);
+          self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
+          return result;
+        } catch (error) {
+          if (nested) {
+            self.exec(`ROLLBACK TO ${SAVEPOINT}`);
+            self.exec(`RELEASE ${SAVEPOINT}`);
+          } else {
+            self.exec("ROLLBACK");
+          }
+          throw error;
+        }
+      };
+      const wrapped = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.default = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.deferred = function(...args) {
+        return execute("DEFERRED", this, args);
+      };
+      wrapped.immediate = function(...args) {
+        return execute("IMMEDIATE", this, args);
+      };
+      wrapped.exclusive = function(...args) {
+        return execute("EXCLUSIVE", this, args);
+      };
+      return wrapped;
+    }
+  }
+  return NodeSqliteDatabase;
+}
+var Database = DatabaseImpl;
+var privilegeDepth = new WeakMap;
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function withPrivilegedWriter(db, operation) {
+  const previousDepth = privilegeDepth.get(db) ?? 0;
+  const nested = isInTransaction(db);
+  const savepoint = "mc_privilege_scope";
+  if (nested) {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  } else {
+    db.exec("BEGIN IMMEDIATE");
+  }
+  privilegeDepth.set(db, previousDepth + 1);
+  try {
+    db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1").run();
+    const result = operation();
+    if (previousDepth === 0) {
+      db.prepare("UPDATE context_privilege_state SET enabled = 0 WHERE id = 1").run();
+    }
+    if (nested) {
+      db.exec(`RELEASE ${savepoint}`);
+    } else {
+      db.exec("COMMIT");
+    }
+    if (previousDepth > 0)
+      privilegeDepth.set(db, previousDepth);
+    else
+      privilegeDepth.delete(db);
+    return result;
+  } catch (error) {
+    try {
+      if (nested) {
+        db.exec(`ROLLBACK TO ${savepoint}`);
+        db.exec(`RELEASE ${savepoint}`);
+      } else {
+        db.exec("ROLLBACK");
+      }
+    } finally {
+      if (previousDepth > 0)
+        privilegeDepth.set(db, previousDepth);
+      else
+        privilegeDepth.delete(db);
+    }
+    throw error;
+  }
+}
+
+// src/hooks/magic-context/read-session-db.ts
+function getOpenCodeDbPath() {
+  return join(getDataDir(), "opencode", "opencode.db");
+}
+function openCodeDbExists() {
+  return existsSync(getOpenCodeDbPath());
+}
+var cachedReadOnlyDb = null;
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
+    return;
+  }
+  try {
+    closeQuietly(cachedReadOnlyDb.db);
+  } catch (error) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
+}
+function getReadOnlySessionDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database(dbPath, { readonly: true });
+  cachedReadOnlyDb = { path: dbPath, db };
+  return db;
+}
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
+}
+function getRawSessionMessageCountFromDb(db, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
+             AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function isMidTurn(_deps, sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => isMidTurnFromOpenCodeDb(db, sessionId));
+  } catch (error) {
+    log("[magic-context] failed to inspect OpenCode mid-turn state:", error);
+    return false;
+  }
+}
+function isMidTurnFromOpenCodeDb(db, sessionId) {
+  const latestAssistant = db.prepare(`SELECT id,
+                    json_extract(data, '$.finish') as finish,
+                    time_created as timeCreated
+             FROM message
+             WHERE session_id = ?
+               AND json_extract(data, '$.role') = 'assistant'
+             ORDER BY time_created DESC
+             LIMIT 1`).get(sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated))
+    return false;
+  if (latestAssistant.finish === "tool-calls")
+    return true;
+  const partRows = db.prepare("SELECT data FROM part WHERE session_id = ? AND message_id = ?").all(sessionId, latestAssistant.id);
+  return partRows.some((row) => {
+    if (typeof row.data !== "string" || row.data.length === 0)
+      return false;
+    try {
+      const part = JSON.parse(row.data);
+      return part.type === "tool" && part.providerExecuted !== true;
+    } catch {
+      return false;
+    }
+  });
+}
+function hasNewerRealUserMessage(db, sessionId, latestAssistantTimeCreated) {
+  if (typeof latestAssistantTimeCreated !== "number")
+    return false;
+  const row = db.prepare(`SELECT 1 as one
+             FROM message m
+             WHERE m.session_id = ?
+               AND m.time_created > ?
+               AND json_extract(m.data, '$.role') = 'user'
+               AND NOT (
+                 EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id)
+                 AND NOT EXISTS (
+                   SELECT 1 FROM part p
+                   WHERE p.message_id = m.id
+                     AND COALESCE(json_extract(p.data, '$.synthetic'), 0) NOT IN (1, 'true')
+                     AND json_extract(p.data, '$.metadata.marker.kind') IS NULL
+                     AND COALESCE(json_extract(p.data, '$.ignored'), 0) NOT IN (1, 'true')
+                 )
+               )
+             LIMIT 1`).get(sessionId, latestAssistantTimeCreated);
+  return row?.one === 1;
+}
+function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
+  const result = new Map;
+  if (messageIds.length === 0)
+    return result;
+  try {
+    withReadOnlySessionDb((db) => {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
+      for (const row of rows) {
+        if (typeof row.id === "string" && typeof row.time_created === "number") {
+          result.set(row.id, row.time_created);
+        }
+      }
+    });
+  } catch (error) {
+    log("[magic-context] failed to resolve message times from OpenCode DB:", error);
+  }
+  return result;
+}
+function findLastAssistantModelFromOpenCodeDb(sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => {
+      const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
+                            json_extract(data, '$.modelID') as modelID,
+                            json_extract(data, '$.agent') as agent
+                     FROM message
+                     WHERE session_id = ?
+                       AND json_extract(data, '$.role') = 'assistant'
+                       AND json_extract(data, '$.providerID') IS NOT NULL
+                       AND json_extract(data, '$.modelID') IS NOT NULL
+                     ORDER BY time_created DESC
+                     LIMIT 1`).get(sessionId);
+      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
+        return null;
+      }
+      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
+      return {
+        providerID: row.providerID,
+        modelID: row.modelID,
+        ...agent ? { agent } : {}
+      };
+    });
+  } catch (error) {
+    log("[magic-context] failed to recover live model from OpenCode DB:", error);
+    return null;
+  }
+}
+
+export { Database, withPrivilegedWriter, closeQuietly, openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, isMidTurn, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };

package/dist/{index-63dq2g4d.js → index-ry8rh8cv.js}

@@ -9,11 +9,46 @@ import {
 // src/shared/models-dev-cache.ts
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+
+// src/shared/harness-provider-map.ts
+var PI_TO_CANONICAL_PROVIDER = {
+  "openai-codex": "openai",
+  "google-antigravity": "google"
+};
+function remapProviderPrefix(ref, map) {
+  if (typeof ref !== "string")
+    return ref;
+  const slash = ref.indexOf("/");
+  if (slash <= 0)
+    return ref;
+  const provider = ref.slice(0, slash);
+  const mapped = map[provider];
+  return mapped ? `${mapped}${ref.slice(slash)}` : ref;
+}
+function piModelRefToCanonical(ref) {
+  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
+}
+
+// src/shared/storage-permissions.ts
+var enforcePrivateStoragePermissions = true;
+function setStoragePrivatePermissionEnforcement(enforce) {
+  enforcePrivateStoragePermissions = enforce;
+}
+function shouldEnforcePrivateStoragePermissions() {
+  return enforcePrivateStoragePermissions;
+}
+
+// src/shared/models-dev-cache.ts
 var MIN_SANE_LIMIT = 20000;
 var MAX_SANE_LIMIT = 3000000;
 function isSaneLimit(limit) {
   return typeof limit === "number" && limit >= MIN_SANE_LIMIT && limit <= MAX_SANE_LIMIT;
 }
+var SEPARATE_OUTPUT_QUOTA_PROVIDERS = new Set(["google", "google-antigravity"]);
+var MIN_PLAUSIBLE_CONTEXT_LIMIT = 1024;
+var OUTPUT_RESERVE_CAP_RATIO = 0.25;
+var outputReserveConfig;
+var reserveClampLogSeen = new Set;
 var apiCache = null;
 var apiLoadedAt = 0;
 var persistSeedLoaded = false;
@@ -30,12 +65,16 @@ function loadPersistedApiCacheOnce() {
     const map = new Map;
     for (const [key, persisted] of Object.entries(obj)) {
       const limit = typeof persisted === "number" ? persisted : persisted.limit;
+      const contextLimit = typeof persisted === "number" ? undefined : persisted.contextLimit;
       const inputLimit = typeof persisted === "number" ? undefined : persisted.inputLimit;
+      const outputLimit = typeof persisted === "number" ? undefined : persisted.outputLimit;
       const vision = typeof persisted === "number" ? false : persisted.vision === true;
-      if (isSaneLimit(limit)) {
+      if (isSaneLimit(contextLimit) || isSaneLimit(limit)) {
         map.set(key, {
-          limit,
+          limit: isSaneLimit(limit) ? limit : undefined,
+          contextLimit: isSaneLimit(contextLimit) ? contextLimit : undefined,
           inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined,
+          outputLimit: isFinitePositive(outputLimit) ? outputLimit : undefined,
           vision
         });
       }
@@ -54,7 +93,9 @@ function persistApiCache() {
     if (isSaneLimit(value.limit)) {
       obj[key] = {
         limit: value.limit,
+        contextLimit: isSaneLimit(value.contextLimit) ? value.contextLimit : undefined,
         inputLimit: isSaneLimit(value.inputLimit) ? value.inputLimit : undefined,
+        outputLimit: isFinitePositive(value.outputLimit) ? value.outputLimit : undefined,
         vision: value.vision === true
       };
     }
@@ -64,30 +105,95 @@ function persistApiCache() {
     mkdirSync(dir, { recursive: true });
     const target = persistFilePath();
     const tmp = `${target}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8", mode: 384 });
+    if (shouldEnforcePrivateStoragePermissions()) {
+      writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8", mode: 384 });
+    } else {
+      writeFileSync(tmp, JSON.stringify(obj), { encoding: "utf-8" });
+    }
     renameSync(tmp, target);
   } catch {}
 }
-function resolveLimit(limit) {
+function isFinitePositive(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+function modelKeyLookupOrder(providerID, modelID) {
+  const full = `${providerID}/${modelID}`;
+  const canonicalFull = piModelRefToCanonical(full);
+  const candidates = [full, canonicalFull, modelID];
+  const colon = modelID.lastIndexOf(":");
+  if (colon > 0) {
+    const bareModel = modelID.slice(0, colon);
+    const providerBare = `${providerID}/${bareModel}`;
+    candidates.push(providerBare, piModelRefToCanonical(providerBare), bareModel);
+  }
+  return [...new Set(candidates)];
+}
+function configuredOutputReserve(config, providerID, modelID) {
+  if (typeof config === "number")
+    return Number.isFinite(config) && config >= 0 ? config : undefined;
+  if (!config)
+    return;
+  for (const candidate of modelKeyLookupOrder(providerID, modelID)) {
+    const value = config[candidate];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+      return value;
+  }
+  return Number.isFinite(config.default) && config.default >= 0 ? config.default : undefined;
+}
+function logReserveClampOnce(key, message) {
+  if (reserveClampLogSeen.has(key))
+    return;
+  reserveClampLogSeen.add(key);
+  sessionLog("global", `models-dev-cache: ${message}`);
+}
+function setOutputReserveConfig(config) {
+  outputReserveConfig = config;
+}
+function resolveLimit(limit, providerID, modelID, reserveConfig = outputReserveConfig) {
   if (!limit)
     return;
-  if (typeof limit.input === "number" && limit.input > 0)
-    return limit.input;
-  if (typeof limit.context === "number" && limit.context > 0)
-    return limit.context;
-  return;
+  const context = isFinitePositive(limit.context) ? limit.context : undefined;
+  const input = isFinitePositive(limit.input) ? limit.input : undefined;
+  if (input !== undefined && (context === undefined || input < context))
+    return input;
+  if (context === undefined)
+    return;
+  const configuredReserve = configuredOutputReserve(reserveConfig, providerID, modelID);
+  let reserve;
+  if (configuredReserve !== undefined) {
+    reserve = configuredReserve;
+  } else if (SEPARATE_OUTPUT_QUOTA_PROVIDERS.has(providerID)) {
+    reserve = 0;
+  } else {
+    const output = isFinitePositive(limit.output) ? limit.output : 0;
+    const cap = context * OUTPUT_RESERVE_CAP_RATIO;
+    reserve = Math.min(output, cap);
+    if (output > cap) {
+      logReserveClampOnce(`cap|${providerID}/${modelID}|${context}|${output}`, `output reserve capped at 25% for ${providerID}/${modelID}: ${output} → ${cap}`);
+    }
+  }
+  const floor = Math.max(MIN_PLAUSIBLE_CONTEXT_LIMIT, context * 0.5);
+  const maxReserve = Math.max(0, context - floor);
+  if (reserve > maxReserve) {
+    logReserveClampOnce(`floor|${providerID}/${modelID}|${context}|${reserve}`, `output reserve clamped for ${providerID}/${modelID}: ${reserve} → ${maxReserve} (usable floor ${floor})`);
+    reserve = maxReserve;
+  }
+  return Math.floor(context - reserve);
 }
 function setCachedModelMetadata(cache, key, model) {
-  const limit = resolveLimit(model?.limit);
+  const contextLimit = model?.limit?.context;
   const inputLimit = model?.limit?.input;
-  if (!isSaneLimit(limit)) {
+  const outputLimit = model?.limit?.output;
+  const rawLimit = isSaneLimit(contextLimit) ? contextLimit : isSaneLimit(inputLimit) ? inputLimit : undefined;
+  if (rawLimit === undefined)
     return;
-  }
   const values = [model?.capabilities, model?.modalities, model?.input, model?.attachment];
   const vision = values.some((value2) => JSON.stringify(value2 ?? "").toLowerCase().includes("image") || JSON.stringify(value2 ?? "").toLowerCase().includes("vision"));
   const value = {
-    limit,
+    limit: rawLimit,
+    contextLimit: isSaneLimit(contextLimit) ? contextLimit : undefined,
     inputLimit: isSaneLimit(inputLimit) ? inputLimit : undefined,
+    outputLimit: isFinitePositive(outputLimit) ? outputLimit : undefined,
     vision
   };
   cache.set(key, value);
@@ -152,10 +258,21 @@ async function refreshModelLimitsOnce(client) {
     return false;
   }
 }
-function getSdkContextLimit(providerID, modelID) {
+function getSdkContextLimit(providerID, modelID, detectedContextLimit, options) {
   loadPersistedApiCacheOnce();
-  const fromApi = lookupLimitWithTagFallback(apiCache, providerID, modelID);
-  return isSaneLimit(fromApi) ? fromApi : undefined;
+  const metadata = lookupMetadataWithTagFallback(apiCache, providerID, modelID);
+  if (!metadata)
+    return;
+  const rawContext = metadata.contextLimit ?? metadata.limit;
+  const promptOnlyDetected = options?.detectedLimitProvenance === "prompt_only" && isFinitePositive(detectedContextLimit) ? detectedContextLimit : undefined;
+  const context = promptOnlyDetected === undefined && isFinitePositive(detectedContextLimit) && isFinitePositive(rawContext) ? Math.min(rawContext, detectedContextLimit) : promptOnlyDetected === undefined && isFinitePositive(detectedContextLimit) ? detectedContextLimit : rawContext;
+  const inputCandidates = [metadata.inputLimit, promptOnlyDetected].filter(isFinitePositive);
+  const input = inputCandidates.length > 0 ? Math.min(...inputCandidates) : undefined;
+  return resolveLimit({
+    context,
+    input,
+    output: metadata.outputLimit
+  }, providerID, modelID, options?.reservation === "none" ? 0 : undefined);
 }
 function modelSupportsVision(providerID, modelID) {
   loadPersistedApiCacheOnce();
@@ -167,18 +284,15 @@ function modelSupportsVision(providerID, modelID) {
   const colon = modelID.lastIndexOf(":");
   return colon > 0 ? apiCache.get(`${providerID}/${modelID.slice(0, colon)}`)?.vision === true : false;
 }
-function lookupLimitWithTagFallback(cache, providerID, modelID) {
+function lookupMetadataWithTagFallback(cache, providerID, modelID) {
   if (!cache)
     return;
-  const exact = cache.get(`${providerID}/${modelID}`)?.limit;
-  if (typeof exact === "number")
+  const exact = cache.get(`${providerID}/${modelID}`);
+  if (exact)
     return exact;
   const colonIdx = modelID.lastIndexOf(":");
   if (colonIdx > 0) {
-    const baseModel = modelID.slice(0, colonIdx);
-    const fallback = cache.get(`${providerID}/${baseModel}`)?.limit;
-    if (typeof fallback === "number")
-      return fallback;
+    return cache.get(`${providerID}/${modelID.slice(0, colonIdx)}`);
   }
   return;
 }
@@ -224,4 +338,4 @@ function resolveHistorianContextLimit(historianModelOverride) {
   return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
 }
 
-export { isSaneLimit, refreshModelLimitsFromApi, refreshModelLimitsAfterAuthOnce, getSdkContextLimit, modelSupportsVision, deriveTriggerBudget, deriveHistorianChunkTokens, resolveHistorianContextLimit };
+export { piModelRefToCanonical, setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions, isSaneLimit, setOutputReserveConfig, refreshModelLimitsFromApi, refreshModelLimitsAfterAuthOnce, getSdkContextLimit, modelSupportsVision, deriveTriggerBudget, deriveHistorianChunkTokens, resolveHistorianContextLimit };