@cortexkit/opencode-magic-context 0.47.0 → 0.49.0

package/dist/v2/{server-fcdehk1s.js → server-2s9qz6n7.js}

@@ -1,11 +1,11 @@
 import {
-  log
-} from "./server-1qbnzc80.js";
+  log2
+} from "./server-t4k4qexw.js";
 import {
   getSdkWindowGeometry,
   getSdkContextLimit,
   getSdkInputLimit
-} from "./server-cpepxy2q.js";
+} from "./server-8k2agx29.js";
 import {
   localBudget,
   calibrationForModelKey
@@ -66,7 +66,7 @@ function resolveHistorianContextLimit2(historianModelOverride) {
     return resolveKnownHistorianContextLimit2(historianModelOverride) ?? DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
   }
   if (typeof historianModelOverride === "string" && historianModelOverride.trim() !== "") {
-    log(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
+    log2(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
   }
   return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
 }

package/dist/v2/server-3j4d00kf.js

@@ -0,0 +1,171 @@
+import {
+  withSqliteBackgroundWriter2,
+  withoutSqliteTransformPass2
+} from "./server-kb9nn0a0.js";
+import {
+  logSlowWriteTransaction
+} from "./server-3t0q2cqx.js";
+
+// src/features/magic-context/message-fts-rowid-map.ts
+import { createHash } from "node:crypto";
+var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
+var BACKFILL_STATE_ID = 1;
+var EMPTY_INDEX_CONTENT_HASH = createHash("sha256").update("").digest("hex");
+var upsertMapStatements = new WeakMap;
+var rangeReadyStatements = new WeakMap;
+var updateTimeStatements = new WeakMap;
+var activeBackfills = new WeakMap;
+function getUpsertMapStatement(db) {
+  let statement = upsertMapStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`INSERT INTO message_fts_rowid_map
+                 (session_id, message_ordinal, fts_rowid, message_time_ms)
+             VALUES (?, ?, ?, ?)
+             ON CONFLICT(session_id, message_ordinal) DO UPDATE SET
+                 fts_rowid = excluded.fts_rowid,
+                 message_time_ms = COALESCE(
+                     excluded.message_time_ms,
+                     message_fts_rowid_map.message_time_ms
+                 )`);
+    upsertMapStatements.set(db, statement);
+  }
+  return statement;
+}
+function getBackfillState(db) {
+  const row = db.prepare(`SELECT watermark_rowid AS watermarkRowid, completed
+             FROM message_fts_rowid_map_backfill_state
+             WHERE id = ?`).get(BACKFILL_STATE_ID);
+  return {
+    processed: 0,
+    watermarkRowid: typeof row?.watermarkRowid === "number" && Number.isSafeInteger(row.watermarkRowid) ? row.watermarkRowid : 0,
+    completed: row?.completed === 1
+  };
+}
+function recordMessageFtsRowid(db, sessionId, messageOrdinal, ftsRowid, messageTimeMs = null) {
+  const numericRowid = Number(ftsRowid);
+  if (!Number.isSafeInteger(numericRowid) || numericRowid <= 0) {
+    throw new Error(`invalid message FTS rowid: ${String(ftsRowid)}`);
+  }
+  const normalizedTime = typeof messageTimeMs === "number" && Number.isSafeInteger(messageTimeMs) && messageTimeMs >= 0 ? messageTimeMs : null;
+  getUpsertMapStatement(db).run(sessionId, messageOrdinal, numericRowid, normalizedTime);
+}
+function recordIndexedMessageTime(db, sessionId, messageOrdinal, messageTimeMs) {
+  if (typeof messageTimeMs !== "number" || !Number.isSafeInteger(messageTimeMs) || messageTimeMs < 0) {
+    return;
+  }
+  let statement = updateTimeStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`UPDATE message_fts_rowid_map
+                SET message_time_ms = ?
+              WHERE session_id = ? AND message_ordinal = ?
+                AND message_time_ms IS NULL`);
+    updateTimeStatements.set(db, statement);
+  }
+  statement.run(messageTimeMs, sessionId, messageOrdinal);
+}
+function backfillMessageFtsRowidMapBatch(db, batchSize = MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE) {
+  const boundedBatchSize = Number.isFinite(batchSize) ? Math.min(MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE, Math.max(1, Math.floor(batchSize))) : MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE;
+  let progress = {
+    processed: 0,
+    watermarkRowid: 0,
+    completed: false
+  };
+  let transactionStartedAt = 0;
+  db.transaction(() => {
+    transactionStartedAt = performance.now();
+    db.prepare(`INSERT OR IGNORE INTO message_fts_rowid_map_backfill_state
+            (id, watermark_rowid, completed) VALUES (?, 0, 0)`).run(BACKFILL_STATE_ID);
+    const state = getBackfillState(db);
+    if (state.completed) {
+      progress = state;
+      return;
+    }
+    const rows = db.prepare(`SELECT rowid AS ftsRowid,
+            session_id AS sessionId, message_ordinal AS messageOrdinal
+            FROM message_history_fts WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`).all(state.watermarkRowid, boundedBatchSize);
+    let watermarkRowid = state.watermarkRowid;
+    for (const row of rows) {
+      const ftsRowid = Number(row.ftsRowid);
+      const messageOrdinal = Number(row.messageOrdinal);
+      if (Number.isSafeInteger(ftsRowid) && ftsRowid > watermarkRowid) {
+        watermarkRowid = ftsRowid;
+      }
+      if (typeof row.sessionId === "string" && Number.isSafeInteger(messageOrdinal) && messageOrdinal >= 0 && Number.isSafeInteger(ftsRowid) && ftsRowid > 0) {
+        recordMessageFtsRowid(db, row.sessionId, messageOrdinal, ftsRowid);
+      }
+    }
+    const completed = rows.length < boundedBatchSize;
+    db.prepare(`UPDATE message_fts_rowid_map_backfill_state
+             SET watermark_rowid = ?, completed = ?, updated_at = ?
+             WHERE id = ?`).run(watermarkRowid, completed ? 1 : 0, Date.now(), BACKFILL_STATE_ID);
+    progress = {
+      processed: rows.length,
+      watermarkRowid,
+      completed
+    };
+  }).immediate();
+  logSlowWriteTransaction("message_fts_rowid_backfill", transactionStartedAt);
+  return progress;
+}
+async function runMessageFtsRowidMapBackfill(db) {
+  await new Promise((resolve) => setTimeout(resolve, 0));
+  for (;; ) {
+    const progress = backfillMessageFtsRowidMapBatch(db);
+    if (progress.completed)
+      return;
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  }
+}
+function startMessageFtsRowidMapBackfill(db) {
+  const active = activeBackfills.get(db);
+  if (active)
+    return active;
+  const run = withoutSqliteTransformPass2(() => withSqliteBackgroundWriter2(() => runMessageFtsRowidMapBackfill(db))).finally(() => {
+    activeBackfills.delete(db);
+  });
+  activeBackfills.set(db, run);
+  return run;
+}
+function messageFtsOrdinalRangeIsMapped(db, sessionId, startOrdinal, endOrdinal) {
+  if (endOrdinal < startOrdinal)
+    return true;
+  if (getBackfillState(db).completed)
+    return true;
+  let statement = rangeReadyStatements.get(db);
+  if (!statement) {
+    statement = db.prepare(`SELECT COUNT(DISTINCT source.message_ordinal) AS sourceOrdinalCount,
+                    COUNT(DISTINCT CASE
+                        WHEN source.role IN ('user', 'assistant')
+                         AND source.normalized_content_hash != ?
+                        THEN source.message_ordinal
+                    END) AS expectedMapCount,
+                    COUNT(DISTINCT CASE
+                        WHEN source.role IN ('user', 'assistant')
+                         AND source.normalized_content_hash != ?
+                         AND map.fts_rowid IS NOT NULL
+                        THEN source.message_ordinal
+                    END) AS mappedCount
+             FROM message_history_source AS source
+             LEFT JOIN message_fts_rowid_map AS map
+               ON map.session_id = source.session_id
+              AND map.message_ordinal = source.message_ordinal
+             WHERE source.session_id = ?
+               AND source.message_ordinal BETWEEN ? AND ?`);
+    rangeReadyStatements.set(db, statement);
+  }
+  const row = statement.get(EMPTY_INDEX_CONTENT_HASH, EMPTY_INDEX_CONTENT_HASH, sessionId, startOrdinal, endOrdinal);
+  const ordinalCount = endOrdinal - startOrdinal + 1;
+  return row?.sourceOrdinalCount === ordinalCount && row.expectedMapCount === row.mappedCount;
+}
+function deleteUnmappedMessageFtsRows(db, sessionIds) {
+  if (sessionIds.length === 0)
+    return;
+  const state = getBackfillState(db);
+  if (state.completed)
+    return;
+  const placeholders = sessionIds.map(() => "?").join(", ");
+  db.prepare(`DELETE FROM message_history_fts
+         WHERE rowid > ? AND session_id IN (${placeholders})`).run(state.watermarkRowid, ...sessionIds);
+}
+
+export { recordMessageFtsRowid, recordIndexedMessageTime, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows };

package/dist/v2/{server-14vq4kpm.js → server-3t0q2cqx.js}

@@ -1,6 +1,6 @@
 import {
-  log
-} from "./server-1qbnzc80.js";
+  log2
+} from "./server-t4k4qexw.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/v2/server-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 };