@cortexkit/opencode-magic-context 0.45.0 → 0.46.0

package/dist/v2/{server-rhdgxp1t.js → server-51dv1pr5.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./server-ckpc8pxy.js";
+} from "./server-1qbnzc80.js";
 
 // src/shared/internal-initiator-marker.ts
 var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
@@ -326,6 +326,12 @@ function getTokenEstimatorFingerprint() {
   estimatorFingerprint = fingerprint;
   return fingerprint;
 }
+function hasTokenizerForFit() {
+  return getTokenizer() !== undefined;
+}
+function tokenCountUsesByteBound(text) {
+  return text.length > 1024 * 1024 || /[\p{L}\p{N}]{16385}/u.test(text);
+}
 function estimateTokens(text) {
   if (!text)
     return 0;
@@ -341,6 +347,61 @@ function estimateTokens(text) {
     return estimateTokensHeuristically(text);
   }
 }
+function createTokenCountMemo(maxEntries, maxBytes) {
+  const counts = new Map;
+  let bytes = 0;
+  return (text) => {
+    const cached = counts.get(text);
+    if (cached && cached.tokenizer === getTokenizer())
+      return cached.tokens;
+    const tokens = estimateTokens(text);
+    if (cached) {
+      bytes -= text.length * 2;
+      counts.delete(text);
+    }
+    if (text.length * 2 <= maxBytes) {
+      while (counts.size >= maxEntries || bytes + text.length * 2 > maxBytes) {
+        const oldest = counts.keys().next().value;
+        if (oldest === undefined)
+          break;
+        bytes -= oldest.length * 2;
+        counts.delete(oldest);
+      }
+      counts.set(text, { tokenizer: getTokenizer(), tokens });
+      bytes += text.length * 2;
+    }
+    return tokens;
+  };
+}
+var promptTokenCounts = new Map;
+var promptTokenCountBytes = 0;
+var PROMPT_TOKEN_COUNT_BYTES = 8 * 1024 * 1024;
+function estimateFixedPromptTokens(text) {
+  const activeTokenizer = getTokenizer();
+  const cached = promptTokenCounts.get(text);
+  if (cached && cached.tokenizer === activeTokenizer) {
+    promptTokenCounts.delete(text);
+    promptTokenCounts.set(text, cached);
+    return cached.tokens;
+  }
+  const tokens = estimateTokens(text);
+  if (cached) {
+    promptTokenCountBytes -= text.length * 2;
+    promptTokenCounts.delete(text);
+  }
+  if (text.length * 2 <= PROMPT_TOKEN_COUNT_BYTES) {
+    while (promptTokenCounts.size >= 64 || promptTokenCountBytes + text.length * 2 > PROMPT_TOKEN_COUNT_BYTES) {
+      const oldest = promptTokenCounts.keys().next().value;
+      if (oldest === undefined)
+        break;
+      promptTokenCountBytes -= oldest.length * 2;
+      promptTokenCounts.delete(oldest);
+    }
+    promptTokenCounts.set(text, { tokenizer: getTokenizer(), tokens });
+    promptTokenCountBytes += text.length * 2;
+  }
+  return tokens;
+}
 function normalizeText(text) {
   return text.replace(/\s+/g, " ").trim();
 }
@@ -395,4 +456,4 @@ function mergeCommitHashes(existing, next) {
   return merged;
 }
 
-export { textMentionsRecentCommit, OMO_INTERNAL_INITIATOR_MARKER, isSystemDirective, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, extractToolResultBodyTokens, extractToolCallSummaries, getTokenizerNativeMemoryStats, preloadTokenizer, getTokenEstimatorFingerprint, estimateTokens, normalizeText, compactRole, formatBlock, compactTextForSummary, mergeCommitHashes };
+export { textMentionsRecentCommit, OMO_INTERNAL_INITIATOR_MARKER, isSystemDirective, removeSystemReminders, hasMeaningfulUserText2, extractTexts2, extractToolResultBodyTokens, extractToolCallSummaries, getTokenizerNativeMemoryStats, preloadTokenizer, getTokenEstimatorFingerprint, hasTokenizerForFit, tokenCountUsesByteBound, estimateTokens, createTokenCountMemo, estimateFixedPromptTokens, normalizeText, compactRole, formatBlock, compactTextForSummary, mergeCommitHashes };

package/dist/v2/{server-5317ykaf.js → server-6r257mf5.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./server-ckpc8pxy.js";
+} from "./server-1qbnzc80.js";
 
 // src/shared/safe-notification-target.ts
 var DEFAULT_TITLE_RE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;

package/dist/v2/server-84w6rvvf.js

@@ -0,0 +1,14 @@
+// src/hooks/auto-update-checker/semver.ts
+function isValidSemver(version) {
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version);
+}
+function compareSemverCore(a, b) {
+  if (!isValidSemver(a) || !isValidSemver(b))
+    return null;
+  const core = (v) => v.split(/[-+]/, 1)[0].split(".").map((n) => Number.parseInt(n, 10));
+  const [a0, a1, a2] = core(a);
+  const [b0, b1, b2] = core(b);
+  return a0 - b0 || a1 - b1 || a2 - b2;
+}
+
+export { compareSemverCore };

package/dist/v2/{server-qpg6wf72.js → server-ajzeteqw.js}

@@ -6,6 +6,14 @@ function closeQuietly(db) {
     db.close();
   } catch {}
 }
+function isKnownAutocommit(db) {
+  const state = db;
+  try {
+    return state.inTransaction === false || state.isTransaction === false;
+  } catch {
+    return false;
+  }
+}
 
 // src/shared/opencode-db-path.ts
 import { existsSync, readdirSync, statSync } from "node:fs";
@@ -184,4 +192,4 @@ function claimOpenCodeDbDiagnosticOnce(surface, resolution) {
   return true;
 }
 
-export { resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, closeQuietly };
+export { closeQuietly, isKnownAutocommit, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce };

package/dist/{index-a4m2b1yv.js → v2/server-fg34g6a5.js}

@@ -169,6 +169,12 @@ function trackSqliteConnection(db, filename, options) {
     ...metadata,
     reference: new WeakRef(db)
   });
+  const prepare = db.prepare.bind(db);
+  Object.defineProperty(db, "prepare", {
+    configurable: true,
+    writable: true,
+    value: (sql) => ownPreparedStatement(db, prepare(sql))
+  });
   return db;
 }
 var TrackedDatabase = new Proxy(DatabaseImpl, {
@@ -279,6 +285,54 @@ function getSqliteMemoryStats() {
     connections
   };
 }
+var statementOwners = new WeakMap;
+var FIRST_PRUNE_AT = 256;
+function ownPreparedStatement(db, statement) {
+  const finalizable = statement;
+  if (typeof finalizable.finalize !== "function")
+    return statement;
+  let owner = statementOwners.get(db);
+  if (!owner) {
+    const references = new Set;
+    owner = { references, registered: new WeakSet, pruneAt: FIRST_PRUNE_AT };
+    statementOwners.set(db, owner);
+    const close = db.close.bind(db);
+    Object.defineProperty(db, "close", {
+      configurable: true,
+      writable: true,
+      value: (...args) => {
+        let failure;
+        for (const reference of references) {
+          try {
+            reference.deref()?.finalize();
+          } catch (error) {
+            failure ??= error;
+          }
+        }
+        references.clear();
+        const result = close(...args);
+        if (failure)
+          throw failure;
+        return result;
+      }
+    });
+  }
+  if (!owner.registered.has(finalizable)) {
+    if (owner.references.size >= owner.pruneAt) {
+      for (const reference of owner.references) {
+        if (reference.deref() === undefined)
+          owner.references.delete(reference);
+      }
+      owner.pruneAt = Math.max(FIRST_PRUNE_AT, owner.references.size * 2);
+    }
+    owner.references.add(new WeakRef(finalizable));
+    owner.registered.add(finalizable);
+  }
+  return statement;
+}
+function prepareCachedStatement(db, sql) {
+  return ownPreparedStatement(db, db.prepare(sql));
+}
 var privilegeDepth = new WeakMap;
 var transformPassScope = new AsyncLocalStorage;
 var admissionScope = new AsyncLocalStorage;
@@ -527,4 +581,4 @@ function withPrivilegedWriter(db, operation) {
   }
 }
 
-export { registerSlowWriteReporter, registerSqliteDiagnosticSink, detectSqliteRuntime, Database, getSqliteMemoryStats, withSqliteBackgroundWriter, withSqliteTransformPass, withoutSqliteTransformPass, isTransientSqliteError, SqliteAcquisitionBusyError, beginSqliteWriterAsync, withAsyncPrivilegedWriter, withPrivilegedWriter };
+export { registerSlowWriteReporter, registerSqliteDiagnosticSink, detectSqliteRuntime, Database, getSqliteMemoryStats, prepareCachedStatement, withSqliteBackgroundWriter, withSqliteTransformPass, withoutSqliteTransformPass, isTransientSqliteError, SqliteAcquisitionBusyError, beginSqliteWriterAsync, withAsyncPrivilegedWriter, withPrivilegedWriter };