@cortexkit/pi-magic-context 0.46.1 → 0.48.0

package/dist/auto-search-worker.js

@@ -0,0 +1,112 @@
+// ../plugin/src/hooks/magic-context/auto-search-worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+var port = parentPort;
+if (!port)
+  throw new Error("auto-search worker requires a parent port");
+var input = workerData;
+if (input.job === "messages") {
+  port.postMessage({ kind: "accepted" });
+}
+var [
+  { ensureMemoryEmbeddings },
+  { getProjectEmbeddings },
+  { getMemoriesByProject },
+  { installProjectEmbeddingSearchBridge },
+  { searchMessageHistory, unifiedSearch },
+  { setEmbeddingSessionBusy },
+  { setHarness },
+  { Database }
+] = await Promise.all([
+  import("./embedding-backfill-bnnytehy.js"),
+  import("./embedding-cache-7rp4gqzr.js"),
+  import("./storage-memory-1z20y55x.js"),
+  import("./project-embedding-registry-jy2hmq28.js"),
+  import("./search-42szfhwp.js"),
+  import("./embedding-activity-ew6dshfd.js"),
+  import("./harness-9872e0ym.js"),
+  import("./sqlite-3yye76ht.js")
+]);
+setHarness(input.harness);
+setEmbeddingSessionBusy(input.sessionId, input.embeddingHostBusy === true);
+var nextId = 0;
+var pending = new Map;
+var queryDimensions = null;
+var db;
+port.on("message", (reply) => {
+  if (reply.embeddingHostBusy !== undefined)
+    setEmbeddingSessionBusy(input.sessionId, reply.embeddingHostBusy);
+  const vector = reply.result instanceof Float32Array ? reply.result : reply.result?.vector;
+  if (vector)
+    queryDimensions = vector.length;
+  pending.get(reply.id)?.(reply);
+  pending.delete(reply.id);
+});
+function request(message) {
+  return new Promise((resolve, reject) => {
+    const id = ++nextId;
+    pending.set(id, (reply) => reply.error ? reject(new Error(reply.error)) : resolve(reply));
+    port?.postMessage({ ...message, id });
+  });
+}
+if (input.snapshot) {
+  installProjectEmbeddingSearchBridge(input.snapshot, {
+    modelId: input.snapshot.modelId,
+    initialize: async () => true,
+    isLoaded: () => true,
+    dispose: async () => {},
+    embed: async (text) => {
+      const result = (await request({ kind: "query", text })).result;
+      return result instanceof Float32Array ? result : result?.vector ?? null;
+    },
+    embedBatch: async (texts, _signal, purpose = "passage") => {
+      const passage = (await request({ kind: "batch", texts, purpose })).passage;
+      const captured = input.snapshot;
+      if (!passage || !captured || passage.generation !== captured.generation || passage.modelId !== captured.modelId || passage.providerIdentity !== captured.providerIdentity || passage.runtimeFingerprint !== captured.runtimeFingerprint || !queryDimensions || passage.dimensions !== queryDimensions || passage.vectors.length !== texts.length)
+        return texts.map(() => null);
+      return passage.vectors.map((vector) => vector && vector.length === queryDimensions && vector.every(Number.isFinite) ? vector : null);
+    }
+  });
+}
+db = new Database(input.path, input.job === "backfill" ? undefined : { readonly: true });
+db.exec("PRAGMA busy_timeout = 250");
+try {
+  if (input.job === "backfill") {
+    if (input.snapshot?.enabled && input.snapshot.features.memoryEnabled) {
+      await request({ kind: "query", text: input.query });
+      if (queryDimensions) {
+        const existingEmbeddings = getProjectEmbeddings(db, input.projectPath, input.snapshot.modelId);
+        const memories = getMemoriesByProject(db, input.projectPath).filter((memory) => !existingEmbeddings.has(memory.id)).slice(0, 50);
+        await ensureMemoryEmbeddings({
+          db,
+          projectIdentity: input.projectPath,
+          memories,
+          existingEmbeddings
+        });
+      }
+    }
+    port.postMessage({ kind: "result", results: [] });
+  } else if (input.job === "messages") {
+    if (!input.messageRequest)
+      throw new Error("message search job carries no request");
+    const outcome = searchMessageHistory(db, input.messageRequest);
+    port.postMessage({ kind: "messages", outcome });
+  } else {
+    const results = await unifiedSearch(db, input.sessionId, input.projectPath, input.query, {
+      ...input.options,
+      backfillMemoryEmbeddings: false,
+      countRetrievals: false,
+      measurementDisabled: true,
+      embedQuery: async (text) => (await request({ kind: "query", text })).result ?? null,
+      isEmbeddingRuntimeEnabled: () => input.embeddingRuntimeEnabled
+    });
+    port.postMessage({ kind: "result", results });
+  }
+} catch (error) {
+  port.postMessage({
+    kind: "error",
+    error: error instanceof Error ? error.message : String(error)
+  });
+} finally {
+  db.close();
+  port.close();
+}

package/dist/embedding-activity-ew6dshfd.js

@@ -0,0 +1,10 @@
+import {
+  setEmbeddingSessionBusy2,
+  observeEmbeddingActivity2,
+  isEmbeddingHostBusy2
+} from "./index-9p40dgkm.js";
+export {
+  isEmbeddingHostBusy2 as isEmbeddingHostBusy,
+  observeEmbeddingActivity2 as observeEmbeddingActivity,
+  setEmbeddingSessionBusy2 as setEmbeddingSessionBusy
+};

package/dist/embedding-backfill-bnnytehy.js

@@ -0,0 +1,20 @@
+import {
+  ensureMemoryEmbeddings2
+} from "./index-0am8a7k1.js";
+import"./index-544c0e0x.js";
+import"./index-fm3ksh5e.js";
+import"./index-yhzhdp3m.js";
+import"./index-9p40dgkm.js";
+import"./index-6pgq5ns2.js";
+import"./index-419bndtm.js";
+import"./index-dkx0b1kt.js";
+import"./index-603mt6nm.js";
+import"./index-fp37he9a.js";
+import"./index-bgmv2kaf.js";
+import"./index-3cgbv47m.js";
+import"./index-9xb0axhc.js";
+import"./index-f956htf3.js";
+import"./index-0h2mkab2.js";
+export {
+  ensureMemoryEmbeddings2 as ensureMemoryEmbeddings
+};

package/dist/embedding-cache-7rp4gqzr.js

@@ -0,0 +1,16 @@
+import {
+  getProjectEmbeddings2,
+  peekProjectEmbeddings2,
+  invalidateProject2,
+  invalidateMemory2,
+  resetEmbeddingCacheForTests2,
+  setEmbeddingCacheTtlForTests2
+} from "./index-yhzhdp3m.js";
+export {
+  getProjectEmbeddings2 as getProjectEmbeddings,
+  invalidateMemory2 as invalidateMemory,
+  invalidateProject2 as invalidateProject,
+  peekProjectEmbeddings2 as peekProjectEmbeddings,
+  resetEmbeddingCacheForTests2 as resetEmbeddingCacheForTests,
+  setEmbeddingCacheTtlForTests2 as setEmbeddingCacheTtlForTests
+};

package/dist/embedding-worker.js

@@ -1,25 +1,28 @@
 import {
-  setHarness,
-  log
-} from "./index-7n8gb6j3.js";
+  setHarness2
+} from "./index-0h2mkab2.js";
+import {
+  log2
+} from "./index-f956htf3.js";
 import {
   resolveLocalEmbeddingWorkerRuntime,
   getLocalEmbeddingNativeMemoryStats,
   LocalEmbeddingProvider
-} from "./index-r01b1b78.js";
-import"./index-phh7e055.js";
-import"./index-266qrgss.js";
+} from "./index-6pgq5ns2.js";
+import"./index-bgmv2kaf.js";
+import"./index-419bndtm.js";
+import"./index-9xb0axhc.js";
 import {
   setStoragePrivatePermissionEnforcement
 } from "./index-vf38qhee.js";
 
 // ../plugin/src/features/magic-context/memory/embedding-worker.ts
 import { parentPort, workerData } from "node:worker_threads";
-setHarness(workerData.harness);
+setHarness2(workerData.harness);
 setStoragePrivatePermissionEnforcement(workerData.enforcePrivateStoragePermissions !== false);
 var unsafeNative = workerData.runtimePreference === "native" && resolveLocalEmbeddingWorkerRuntime("native") === "wasm";
 if (unsafeNative)
-  log("[magic-context] native embedding worker teardown is unsafe on this Bun version; using WASM. Upgrade the host to Bun >=1.4.0 for native inference.");
+  log2("[magic-context] native embedding worker teardown is unsafe on this Bun version; using WASM. Upgrade the host to Bun >=1.4.0 for native inference.");
 var provider = new LocalEmbeddingProvider(workerData.model, workerData.maxInputTokens, workerData.dtype, unsafeNative ? "wasm" : workerData.runtimePreference);
 var queue = Promise.resolve();
 parentPort?.on("message", (request) => {

package/dist/harness-9872e0ym.js

@@ -0,0 +1,10 @@
+import {
+  setHarness2,
+  getHarness2,
+  harnessOwnsOpenCodeStore2
+} from "./index-0h2mkab2.js";
+export {
+  getHarness2 as getHarness,
+  harnessOwnsOpenCodeStore2 as harnessOwnsOpenCodeStore,
+  setHarness2 as setHarness
+};

package/dist/historian-calibration-extension.js

@@ -1,8 +1,9 @@
-import"./index-7n8gb6j3.js";
+import"./index-0h2mkab2.js";
+import"./index-f956htf3.js";
 import {
   promptFingerprint,
   readHostSystemPrompt
-} from "./index-w76x3af7.js";
+} from "./index-zrr5t5a7.js";
 
 // src/historian-calibration-extension.ts
 import { readFileSync } from "node:fs";

package/dist/index-0am8a7k1.js

@@ -0,0 +1,152 @@
+import {
+  DEFAULT_LOCAL_EMBEDDING_MODEL,
+  LocalEmbeddingProvider
+} from "./index-6pgq5ns2.js";
+import {
+  log2
+} from "./index-f956htf3.js";
+import {
+  isSynapseEmbeddingTruncated,
+  SynapseEmbeddingProvider
+} from "./index-419bndtm.js";
+import {
+  OpenAICompatibleEmbeddingProvider,
+  getProjectEmbeddingSnapshot2,
+  embedBatchForProject2
+} from "./index-544c0e0x.js";
+import {
+  isEmbeddingHostBusy2
+} from "./index-9p40dgkm.js";
+import {
+  saveEmbeddingIfHashMatches
+} from "./index-yhzhdp3m.js";
+
+// ../plugin/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;
+}
+
+// ../plugin/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;
+}
+
+// ../plugin/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/index-0h2mkab2.js

@@ -0,0 +1,17 @@
+// ../plugin/src/shared/harness.ts
+var currentHarness = "opencode";
+var harnessLocked = false;
+function setHarness2(value) {
+  if (harnessLocked && currentHarness !== value) {
+    throw new Error(`Magic Context: harness already locked to "${currentHarness}"; cannot change to "${value}"`);
+  }
+  currentHarness = value;
+  harnessLocked = true;
+}
+function getHarness2() {
+  return currentHarness;
+}
+function harnessOwnsOpenCodeStore2(harness = currentHarness) {
+  return harness === "opencode" || harness === "opencode2";
+}
+export { setHarness2, getHarness2, harnessOwnsOpenCodeStore2 };

package/dist/index-135e8hvg.js

@@ -0,0 +1,43 @@
+// ../plugin/src/features/magic-context/memory/constants.ts
+var V2_MEMORY_CATEGORIES = [
+  "PROJECT_RULES",
+  "ARCHITECTURE",
+  "CONSTRAINTS",
+  "CONFIG_VALUES",
+  "NAMING"
+];
+var PROMOTABLE_CATEGORIES = [
+  ...V2_MEMORY_CATEGORIES,
+  "ARCHITECTURE_DECISIONS",
+  "CONFIG_DEFAULTS",
+  "USER_PREFERENCES",
+  "USER_DIRECTIVES",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var CATEGORY_PRIORITY = [
+  ...V2_MEMORY_CATEGORIES,
+  "USER_DIRECTIVES",
+  "USER_PREFERENCES",
+  "CONFIG_DEFAULTS",
+  "ARCHITECTURE_DECISIONS",
+  "ENVIRONMENT",
+  "WORKFLOW_RULES",
+  "KNOWN_ISSUES"
+];
+var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
+var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
+  acc[category] = index;
+  return acc;
+}, {});
+var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
+function getMemoryCategoryOrder(category) {
+  return MEMORY_CATEGORY_ORDER_PRIORITY[category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
+}
+var CATEGORY_DEFAULT_TTL = {
+  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
+  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
+};
+
+export { V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, MEMORY_CATEGORY_ORDER_SQL, getMemoryCategoryOrder, CATEGORY_DEFAULT_TTL };