@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/dist/{v2/server-51dv1pr5.js → index-1qb0z7wa.js}

@@ -1,25 +1,13 @@
 import {
-  log
-} from "./server-1qbnzc80.js";
-
-// src/shared/internal-initiator-marker.ts
-var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
-
-// src/shared/system-directive.ts
-var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
-function isSystemDirective(text) {
-  return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
-}
-function removeSystemReminders(text) {
-  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
-}
+  log2
+} from "./index-8j7gqj40.js";
 
 // src/hooks/magic-context/read-session-formatting.ts
 import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 // src/shared/commit-detection.ts
 var HASH_HEX = "[0-9a-f]{7,12}";
@@ -32,6 +20,284 @@ function createCommitHashExtractPattern() {
   return new RegExp(`\`?\\b(${HASH_HEX})\\b\`?`, "gi");
 }
 
+// src/shared/internal-initiator-marker.ts
+var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+
+// src/shared/system-directive.ts
+var SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
+function isSystemDirective(text) {
+  return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
+}
+function removeSystemReminders(text) {
+  return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+}
+
+// src/hooks/magic-context/token-count-exact.ts
+var NO_RANK = 4294967295;
+var LONG_PIECE_BYTES = 256;
+var MERGE_CACHE_GENERATION = 50000;
+function hasInternals(tokenizer) {
+  const value = tokenizer;
+  return !!value && value.patternRegex instanceof RegExp && value.patternRegex.global && typeof value.stringRankEncoder === "object" && value.stringRankEncoder !== null && Array.isArray(value.binaryFirstByteIndex);
+}
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder("utf-8");
+function isValidUtf8(bytes) {
+  let index = 0;
+  while (index < bytes.length) {
+    const first = bytes[index];
+    let size = 0;
+    let codePoint = 0;
+    if (first <= 127) {
+      size = 1;
+      codePoint = first;
+    } else if ((first & 224) === 192) {
+      size = 2;
+      codePoint = first & 31;
+      if (first <= 193)
+        return false;
+    } else if ((first & 240) === 224) {
+      size = 3;
+      codePoint = first & 15;
+    } else if ((first & 248) === 240) {
+      size = 4;
+      codePoint = first & 7;
+      if (first > 244)
+        return false;
+    } else
+      return false;
+    if (index + size > bytes.length)
+      return false;
+    for (let offset = 1;offset < size; offset += 1) {
+      const byte = bytes[index + offset];
+      if ((byte & 192) !== 128)
+        return false;
+      codePoint = codePoint << 6 | byte & 63;
+    }
+    if (size === 2 && codePoint < 128)
+      return false;
+    if (size === 3 && codePoint < 2048)
+      return false;
+    if (size === 4 && codePoint < 65536)
+      return false;
+    if (codePoint >= 55296 && codePoint <= 57343)
+      return false;
+    if (codePoint > 1114111)
+      return false;
+    index += size;
+  }
+  return true;
+}
+function binarySearchBytes(sorted, key) {
+  let low = 0;
+  let high = sorted.length - 1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const midKey = sorted[mid][0];
+    let compare = 0;
+    const shared = Math.min(midKey.length, key.length);
+    for (let index = 0;index < shared; index += 1) {
+      compare = midKey[index] - key[index];
+      if (compare !== 0)
+        break;
+    }
+    if (compare === 0)
+      compare = midKey.length - key.length;
+    if (compare === 0)
+      return sorted[mid][1];
+    if (compare < 0)
+      low = mid + 1;
+    else
+      high = mid - 1;
+  }
+  return -1;
+}
+function rankOf(tokenizer, slice) {
+  if (isValidUtf8(slice)) {
+    const rank = tokenizer.stringRankEncoder[textDecoder.decode(slice)];
+    if (rank !== undefined)
+      return rank;
+  }
+  const bucket = tokenizer.binaryFirstByteIndex[slice[0]];
+  if (bucket !== null && bucket !== undefined) {
+    const rank = binarySearchBytes(bucket, slice);
+    if (rank !== -1)
+      return rank;
+  }
+  return NO_RANK;
+}
+function mergeByScanning(tokenizer, bytes) {
+  const starts = [];
+  const ranks = [];
+  const pairRank = (index) => {
+    const end = starts[index + 2];
+    return end === undefined ? NO_RANK : rankOf(tokenizer, bytes.subarray(starts[index], end));
+  };
+  for (let index = 0;index <= bytes.length; index += 1)
+    starts.push(index);
+  for (let index = 0;index < starts.length; index += 1)
+    ranks.push(pairRank(index));
+  while (starts.length > 1) {
+    let minRank = NO_RANK;
+    let minIndex = -1;
+    for (let index = 0;index < ranks.length - 1; index += 1) {
+      if (ranks[index] < minRank) {
+        minRank = ranks[index];
+        minIndex = index;
+      }
+    }
+    if (minIndex === -1)
+      break;
+    starts.splice(minIndex + 1, 1);
+    ranks.splice(minIndex, 1);
+    ranks[minIndex] = pairRank(minIndex);
+    if (minIndex > 0)
+      ranks[minIndex - 1] = pairRank(minIndex - 1);
+  }
+  const tokens = [];
+  for (let index = 0;index < starts.length - 1; index += 1) {
+    const rank = rankOf(tokenizer, bytes.subarray(starts[index], starts[index + 1]));
+    if (rank !== NO_RANK)
+      tokens.push(rank);
+  }
+  return tokens;
+}
+function mergeWithHeap(tokenizer, bytes) {
+  const length = bytes.length;
+  const next = new Int32Array(length + 1);
+  const prev = new Int32Array(length + 1);
+  const alive = new Uint8Array(length + 1).fill(1);
+  const rank = new Float64Array(length + 1).fill(NO_RANK);
+  for (let index = 0;index <= length; index += 1) {
+    next[index] = index + 1;
+    prev[index] = index - 1;
+  }
+  const heapRank = [];
+  const heapAt = [];
+  const less = (a, b) => heapRank[a] < heapRank[b] || heapRank[a] === heapRank[b] && heapAt[a] < heapAt[b];
+  const swap = (a, b) => {
+    [heapRank[a], heapRank[b]] = [heapRank[b], heapRank[a]];
+    [heapAt[a], heapAt[b]] = [heapAt[b], heapAt[a]];
+  };
+  const push = (value, at) => {
+    heapRank.push(value);
+    heapAt.push(at);
+    let child = heapRank.length - 1;
+    while (child > 0) {
+      const parent = child - 1 >> 1;
+      if (!less(child, parent))
+        break;
+      swap(child, parent);
+      child = parent;
+    }
+  };
+  const pop = () => {
+    const last = heapRank.length - 1;
+    swap(0, last);
+    heapRank.pop();
+    heapAt.pop();
+    let parent = 0;
+    for (;; ) {
+      const left = parent * 2 + 1;
+      const right = left + 1;
+      let smallest = parent;
+      if (left < heapRank.length && less(left, smallest))
+        smallest = left;
+      if (right < heapRank.length && less(right, smallest))
+        smallest = right;
+      if (smallest === parent)
+        break;
+      swap(parent, smallest);
+      parent = smallest;
+    }
+  };
+  const pairRank = (at) => {
+    const middle = next[at];
+    if (middle >= length)
+      return NO_RANK;
+    return rankOf(tokenizer, bytes.subarray(at, next[middle]));
+  };
+  const update = (at) => {
+    rank[at] = pairRank(at);
+    if (rank[at] !== NO_RANK)
+      push(rank[at], at);
+  };
+  for (let at = 0;at < length; at += 1)
+    update(at);
+  while (heapRank.length > 0) {
+    const value = heapRank[0];
+    const at = heapAt[0];
+    pop();
+    if (!alive[at] || rank[at] !== value)
+      continue;
+    const removed = next[at];
+    alive[removed] = 0;
+    next[at] = next[removed];
+    prev[next[removed]] = at;
+    update(at);
+    if (at > 0)
+      update(prev[at]);
+  }
+  const tokens = [];
+  for (let at = 0;at < length; at = next[at]) {
+    const value = rankOf(tokenizer, bytes.subarray(at, next[at]));
+    if (value !== NO_RANK)
+      tokens.push(value);
+  }
+  return tokens;
+}
+var mergeCaches = new WeakMap;
+var mergedPieces = 0;
+function mergePiece(tokenizer, piece) {
+  let cache = mergeCaches.get(tokenizer);
+  if (!cache) {
+    cache = { current: new Map, previous: new Map };
+    mergeCaches.set(tokenizer, cache);
+  }
+  let tokens = cache.current.get(piece);
+  if (tokens)
+    return tokens;
+  tokens = cache.previous.get(piece);
+  if (!tokens) {
+    const bytes = textEncoder.encode(piece);
+    mergedPieces += 1;
+    tokens = bytes.length > LONG_PIECE_BYTES ? mergeWithHeap(tokenizer, bytes) : mergeByScanning(tokenizer, bytes);
+  }
+  if (cache.current.size >= MERGE_CACHE_GENERATION) {
+    cache.previous = cache.current;
+    cache.current = new Map;
+  }
+  cache.current.set(piece, tokens);
+  return tokens;
+}
+function encodeTokensExactly(tokenizer, text) {
+  if (!hasInternals(tokenizer)) {
+    return tokenizer.encode(text, "all");
+  }
+  if (text.length < 10) {
+    const direct = tokenizer.stringRankEncoder[text];
+    if (direct !== undefined)
+      return [direct];
+  }
+  const tokens = [];
+  const regex = tokenizer.patternRegex;
+  regex.lastIndex = 0;
+  for (let match = regex.exec(text);match !== null; match = regex.exec(text)) {
+    const piece = match[0];
+    const direct = tokenizer.stringRankEncoder[piece];
+    if (direct !== undefined) {
+      tokens.push(direct);
+      continue;
+    }
+    for (const token of mergePiece(tokenizer, piece))
+      tokens.push(token);
+  }
+  return tokens;
+}
+function countTokensExactly(tokenizer, text) {
+  return encodeTokensExactly(tokenizer, text).length;
+}
+
 // src/hooks/magic-context/read-session-formatting.ts
 var MAX_COMMITS_PER_BLOCK = 5;
 function hasMeaningfulUserText2(parts) {
@@ -144,22 +410,30 @@ var tokenizerSerializedTableBytes;
 function tokenizerPackageRoots() {
   const cwd = process.cwd();
   const openCodeCache = join(process.env.XDG_CACHE_HOME ?? join(homedir(), ".cache"), "opencode");
-  const roots = [cwd, openCodeCache];
   const candidates = [];
-  for (const root of roots) {
+  const probeRoot = (root) => {
     for (const packageDir of TOKENIZER_PACKAGE_DIRS) {
       candidates.push(join(root, "node_modules", ...packageDir, "node_modules", "ai-tokenizer"));
     }
     candidates.push(join(root, "node_modules", "ai-tokenizer"));
+  };
+  for (const root of [cwd, openCodeCache]) {
+    probeRoot(root);
   }
-  let ancestor = process.argv[1] ? dirname(resolve(process.argv[1])) : cwd;
-  while (true) {
-    candidates.push(join(ancestor, "node_modules", "ai-tokenizer"));
-    const parent = dirname(ancestor);
-    if (parent === ancestor)
-      break;
-    ancestor = parent;
-  }
+  const pushAncestors = (startDir) => {
+    let ancestor = startDir;
+    while (true) {
+      candidates.push(join(ancestor, "node_modules", "ai-tokenizer"));
+      const parent = dirname(ancestor);
+      if (parent === ancestor)
+        break;
+      ancestor = parent;
+    }
+  };
+  pushAncestors(process.argv[1] ? dirname(resolve(process.argv[1])) : cwd);
+  const ownDir = dirname(fileURLToPath(new URL(import.meta.url)));
+  pushAncestors(ownDir);
+  probeRoot(join(homedir(), ".omp", "plugins"));
   return [...new Set(candidates)];
 }
 function packageImportTarget(value) {
@@ -264,7 +538,7 @@ function warnTokenizerFallback(error) {
     return;
   tokenizerWarningSent = true;
   const reason = error instanceof Error ? error.message : String(error);
-  log("[magic-context] ai-tokenizer is unavailable; using approximate character-based token counts for this process. Token budgets, persisted per-message counts, and protected-tail/compartment boundaries may be less accurate until restart:", reason);
+  log2("[magic-context] ai-tokenizer is unavailable; using approximate character-based token counts for this process. Token budgets, persisted per-message counts, and protected-tail/compartment boundaries may be less accurate until restart:", reason);
 }
 async function preloadTokenizer() {
   if (tokenizer)
@@ -339,7 +613,7 @@ function estimateTokens(text) {
   if (!activeTokenizer)
     return estimateTokensHeuristically(text);
   try {
-    return activeTokenizer.encode(text, "all").length;
+    return countTokensExactly(activeTokenizer, text);
   } catch (error) {
     tokenizer = undefined;
     tokenizerLoadAttempted = true;

package/dist/index-2bvekkfy.js

@@ -0,0 +1,11 @@
+// src/features/magic-context/memory/normalize-hash.ts
+import { createHash } from "node:crypto";
+function normalizeMemoryContent(content) {
+  return content.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function computeNormalizedHash(content) {
+  const normalized = normalizeMemoryContent(content);
+  return createHash("md5").update(normalized).digest("hex");
+}
+
+export { computeNormalizedHash };

package/dist/{index-sj29b3z2.js → index-2y0s2hep.js}

@@ -1,6 +1,6 @@
 import {
-  log
-} from "./index-hybnrwq0.js";
+  log2
+} from "./index-8j7gqj40.js";
 
 // src/shared/write-transaction-timing.ts
 var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;
@@ -10,7 +10,7 @@ function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANS
     if (durationMs < thresholdMs)
       return;
     const detail = steps ? Object.entries(steps).map(([name, ms]) => `${name}=${ms.toFixed(1)}ms`).join(" ") : "";
-    log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms${detail ? ` ${detail}` : ""}`);
+    log2(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms${detail ? ` ${detail}` : ""}`);
   } catch {}
 }
 

package/dist/index-4dhv7mqz.js

@@ -0,0 +1,131 @@
+// src/features/magic-context/memory/storage-memory-embeddings.ts
+var saveEmbeddingStatements = new WeakMap;
+var saveEmbeddingIfHashMatchesStatements = new WeakMap;
+var loadAllEmbeddingsStatements = new WeakMap;
+var deleteEmbeddingStatements = new WeakMap;
+var getStoredModelIdStatements = new WeakMap;
+var clearAllEmbeddingsStatements = new WeakMap;
+var clearModelEmbeddingsStatements = new WeakMap;
+function isEmbeddingBlob(value) {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+function isEmbeddingRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.memoryId === "number" && isEmbeddingBlob(candidate.embedding) && (candidate.modelId === null || typeof candidate.modelId === "string");
+}
+function toFloat32Array(blob) {
+  if (blob instanceof Uint8Array) {
+    const buffer = blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength);
+    return new Float32Array(buffer);
+  }
+  return new Float32Array(blob.slice(0));
+}
+function getSaveEmbeddingIfHashMatchesStatement(db) {
+  let stmt = saveEmbeddingIfHashMatchesStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("INSERT INTO memory_embeddings (memory_id, embedding, model_id) SELECT ?, ?, ? FROM memories WHERE id = ? AND normalized_hash = ? ON CONFLICT(memory_id, model_id) DO UPDATE SET embedding = excluded.embedding");
+    saveEmbeddingIfHashMatchesStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function getLoadAllEmbeddingsStatement(db) {
+  let stmt = loadAllEmbeddingsStatements.get(db);
+  if (!stmt) {
+    stmt = db.prepare("SELECT memory_embeddings.memory_id AS memoryId, memory_embeddings.embedding AS embedding, memory_embeddings.model_id AS modelId FROM memory_embeddings INNER JOIN memories ON memories.id = memory_embeddings.memory_id WHERE memories.project_path = ? AND memory_embeddings.model_id = ? ORDER BY memory_embeddings.memory_id ASC");
+    loadAllEmbeddingsStatements.set(db, stmt);
+  }
+  return stmt;
+}
+function saveEmbeddingIfHashMatches(db, memoryId, embedding, modelId, normalizedHash) {
+  const blob = Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+  return getSaveEmbeddingIfHashMatchesStatement(db).run(memoryId, blob, modelId, memoryId, normalizedHash).changes > 0;
+}
+function loadAllEmbeddings(db, projectPath, modelId) {
+  const rows = getLoadAllEmbeddingsStatement(db).all(projectPath, modelId).filter(isEmbeddingRow);
+  const embeddings = new Map;
+  for (const row of rows) {
+    embeddings.set(row.memoryId, {
+      embedding: toFloat32Array(row.embedding),
+      modelId: row.modelId
+    });
+  }
+  return embeddings;
+}
+function getMemoryEmbedCoverage(db, projectPath, modelId) {
+  const row = db.prepare(`SELECT
+               COUNT(*) AS total,
+               SUM(CASE WHEN EXISTS (
+                   SELECT 1 FROM memory_embeddings e
+                   WHERE e.memory_id = m.id AND e.model_id = ?
+               ) THEN 1 ELSE 0 END) AS embedded
+             FROM memories m
+             WHERE m.project_path = ? AND m.status = 'active'`).get(modelId, projectPath);
+  return {
+    total: typeof row?.total === "number" ? row.total : 0,
+    embedded: typeof row?.embedded === "number" ? row.embedded : 0
+  };
+}
+
+// src/features/magic-context/memory/embedding-cache.ts
+var DEFAULT_EMBEDDING_CACHE_TTL_MS = 60000;
+var projectEmbeddingCache = new Map;
+var embeddingCacheTtlMs = DEFAULT_EMBEDDING_CACHE_TTL_MS;
+function cacheKey(projectPath, modelId) {
+  return `${projectPath}\x00${modelId}`;
+}
+function getValidCacheEntry(projectPath, modelId) {
+  const entry = projectEmbeddingCache.get(cacheKey(projectPath, modelId));
+  if (!entry) {
+    return null;
+  }
+  if (entry.expiresAt <= Date.now()) {
+    projectEmbeddingCache.delete(cacheKey(projectPath, modelId));
+    return null;
+  }
+  return entry;
+}
+function getProjectEmbeddings2(db, projectPath, modelId) {
+  const cached = getValidCacheEntry(projectPath, modelId);
+  if (cached) {
+    return cached.embeddings;
+  }
+  const embeddings = loadAllEmbeddings(db, projectPath, modelId);
+  projectEmbeddingCache.set(cacheKey(projectPath, modelId), {
+    embeddings,
+    expiresAt: Date.now() + embeddingCacheTtlMs
+  });
+  return embeddings;
+}
+function peekProjectEmbeddings2(projectPath, modelId) {
+  return getValidCacheEntry(projectPath, modelId)?.embeddings ?? null;
+}
+function invalidateProject2(projectPath) {
+  for (const key of projectEmbeddingCache.keys()) {
+    if (key.startsWith(`${projectPath}\x00`)) {
+      projectEmbeddingCache.delete(key);
+    }
+  }
+}
+function invalidateMemory2(projectPath, memoryId) {
+  for (const key of projectEmbeddingCache.keys()) {
+    if (!key.startsWith(`${projectPath}\x00`))
+      continue;
+    const entry = projectEmbeddingCache.get(key);
+    if (!entry || entry.expiresAt <= Date.now()) {
+      projectEmbeddingCache.delete(key);
+      continue;
+    }
+    entry.embeddings.delete(memoryId);
+  }
+}
+function resetEmbeddingCacheForTests2() {
+  projectEmbeddingCache.clear();
+  embeddingCacheTtlMs = DEFAULT_EMBEDDING_CACHE_TTL_MS;
+}
+function setEmbeddingCacheTtlForTests2(ttlMs) {
+  embeddingCacheTtlMs = Math.max(0, Math.floor(ttlMs));
+}
+
+export { saveEmbeddingIfHashMatches, getMemoryEmbedCoverage, getProjectEmbeddings2, peekProjectEmbeddings2, invalidateProject2, invalidateMemory2, resetEmbeddingCacheForTests2, setEmbeddingCacheTtlForTests2 };

package/dist/{index-b35pxds2.js → index-58e3y90n.js}

@@ -190,21 +190,4 @@ function claimOpenCodeDbDiagnosticOnce(surface, resolution) {
   return true;
 }
 
-// src/shared/sqlite-helpers.ts
-function closeQuietly(db) {
-  if (!db)
-    return;
-  try {
-    db.close();
-  } catch {}
-}
-function isKnownAutocommit(db) {
-  const state = db;
-  try {
-    return state.inTransaction === false || state.isTransaction === false;
-  } catch {
-    return false;
-  }
-}
-
-export { resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, formatOpenCodeDbMissingBanner, formatOpenCodeDbMissingStatusLine, formatOpenCodeDbReadFailureStatusLine, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, getOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, closeQuietly, isKnownAutocommit };
+export { resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, formatOpenCodeDbMissingBanner, formatOpenCodeDbMissingStatusLine, formatOpenCodeDbReadFailureStatusLine, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, getOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce };