@cortexkit/opencode-magic-context 0.46.0 → 0.47.0

package/dist/v2/auto-search-worker.js

@@ -0,0 +1,115 @@
+import {
+  setEmbeddingSessionBusy
+} from "./server-yr3zj7e7.js";
+import {
+  setHarness
+} from "./server-1qbnzc80.js";
+import"./server-50hvkg3v.js";
+import"./server-fq7kq32k.js";
+import"./server-51dv1pr5.js";
+import"./server-y10vbq6y.js";
+import {
+  Database
+} from "./server-wx8a6bw3.js";
+import"./server-njt3np1k.js";
+import {
+  getProjectEmbeddings,
+  installProjectEmbeddingSearchBridge,
+  ensureMemoryEmbeddings,
+  getMemoriesByProject
+} from "./server-3trjk1hx.js";
+import {
+  unifiedSearch
+} from "./server-e0c1b7a7.js";
+import"./server-1zx87sdm.js";
+import"./server-nm9n3aqq.js";
+import"./server-vs5gpnd4.js";
+import"./server-ajzeteqw.js";
+import"./server-vd4e7174.js";
+import"./server-14vq4kpm.js";
+
+// 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;
+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 {
+    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();
+}