@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/dist/v2/server-gjcr4w98.js

@@ -0,0 +1,154 @@
+import {
+  DEFAULT_LOCAL_EMBEDDING_MODEL
+} from "./server-zm570tr2.js";
+import {
+  log2
+} from "./server-5m3dt5r1.js";
+import {
+  isSynapseEmbeddingTruncated,
+  SynapseEmbeddingProvider
+} from "./server-4k748ke6.js";
+import {
+  LocalEmbeddingProvider
+} from "./server-vqpf3167.js";
+import {
+  OpenAICompatibleEmbeddingProvider,
+  getProjectEmbeddingSnapshot2,
+  embedBatchForProject2
+} from "./server-7wwc2nga.js";
+import {
+  isEmbeddingHostBusy2
+} from "./server-qt1qqasc.js";
+import {
+  saveEmbeddingIfHashMatches
+} from "./server-4dhv7mqz.js";
+
+// src/features/magic-context/memory/cosine-similarity.ts
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    return 0;
+  }
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let index = 0;index < a.length; index++) {
+    dotProduct += a[index] * b[index];
+    normA += a[index] * a[index];
+    normB += b[index] * b[index];
+  }
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  return denominator === 0 ? 0 : dotProduct / denominator;
+}
+
+// src/features/magic-context/memory/embedding.ts
+var DEFAULT_EMBEDDING_CONFIG = {
+  provider: "local",
+  model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+  local_runtime: "auto"
+};
+var embeddingConfig = DEFAULT_EMBEDDING_CONFIG;
+var provider = null;
+function createProvider(config) {
+  if (config.provider === "off") {
+    return null;
+  }
+  if (config.provider === "openai-compatible") {
+    return new OpenAICompatibleEmbeddingProvider({
+      endpoint: config.endpoint,
+      model: config.model,
+      apiKey: config.api_key,
+      inputType: config.input_type,
+      queryInputType: config.query_input_type,
+      queryInstruction: config.query_instruction,
+      documentPrefix: config.document_prefix,
+      truncate: config.truncate,
+      maxInputTokens: config.max_input_tokens
+    });
+  }
+  if (config.provider === "local") {
+    return new LocalEmbeddingProvider(config.model, config.max_input_tokens, config.local_dtype, config.local_runtime);
+  }
+  if (config.provider === "synapse") {
+    const synapse = config;
+    return new SynapseEmbeddingProvider({
+      connectionFile: synapse.synapse_connection_file ?? "",
+      projectRoot: "",
+      session: "embedding",
+      model: synapse.model,
+      fingerprint: synapse.synapse_fingerprint,
+      tableEpoch: synapse.synapse_table_epoch,
+      dims: synapse.synapse_dims,
+      recommendedBatch: synapse.synapse_recommended_batch,
+      recommendedTokenBudget: synapse.synapse_recommended_token_budget,
+      descriptor: synapse.synapse_descriptor,
+      provenance: synapse.synapse_provenance
+    });
+  }
+  throw new Error("Unknown embedding provider");
+}
+function getOrCreateProvider() {
+  if (provider) {
+    return provider;
+  }
+  provider = createProvider(embeddingConfig);
+  return provider;
+}
+function isEmbeddingEnabled() {
+  return embeddingConfig.provider !== "off";
+}
+async function embedText(text, signal) {
+  const currentProvider = getOrCreateProvider();
+  if (!currentProvider) {
+    return null;
+  }
+  if (!await currentProvider.initialize()) {
+    return null;
+  }
+  const vector = await currentProvider.embed(text, signal);
+  return vector && !isSynapseEmbeddingTruncated(vector) ? vector : null;
+}
+
+// src/features/magic-context/memory/embedding-backfill.ts
+async function ensureMemoryEmbeddings2(args) {
+  if (isEmbeddingHostBusy2())
+    return args.existingEmbeddings;
+  const snapshot = getProjectEmbeddingSnapshot2(args.projectIdentity);
+  if (!snapshot?.enabled) {
+    return args.existingEmbeddings;
+  }
+  const missingMemories = args.memories.filter((memory) => !args.existingEmbeddings.has(memory.id));
+  if (missingMemories.length === 0) {
+    return args.existingEmbeddings;
+  }
+  try {
+    const result = await embedBatchForProject2(args.projectIdentity, missingMemories.map((memory) => memory.content));
+    if (!result) {
+      return args.existingEmbeddings;
+    }
+    const staged = new Map;
+    args.db.transaction(() => {
+      for (const [index, memory] of missingMemories.entries()) {
+        const embedding = result.vectors[index];
+        if (!embedding) {
+          continue;
+        }
+        const saved = saveEmbeddingIfHashMatches(args.db, memory.id, embedding, result.modelId, memory.normalizedHash);
+        if (saved) {
+          staged.set(memory.id, { embedding, modelId: result.modelId });
+        }
+      }
+    }).immediate();
+    const currentSnapshot = getProjectEmbeddingSnapshot2(args.projectIdentity);
+    if (!currentSnapshot || currentSnapshot.generation !== result.generation) {
+      return args.existingEmbeddings;
+    }
+    for (const [id, embedding] of staged) {
+      args.existingEmbeddings.set(id, embedding);
+    }
+  } catch (error) {
+    log2("[magic-context] failed to backfill memory embeddings:", error);
+  }
+  return args.existingEmbeddings;
+}
+
+export { cosineSimilarity, isEmbeddingEnabled, embedText, ensureMemoryEmbeddings2 };

package/dist/v2/server-k228xhjg.js

@@ -0,0 +1,171 @@
+import {
+  withSqliteBackgroundWriter2,
+  withoutSqliteTransformPass2
+} from "./server-kb9nn0a0.js";
+import {
+  logSlowWriteTransaction
+} from "./server-aan4q8mx.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 };