@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/memory-sync/query.js

@@ -0,0 +1,294 @@
+// @bun
+// packages/runtime/src/control-plane/memory-sync/embed.ts
+import { createHash } from "crypto";
+
+// packages/runtime/src/control-plane/memory-sync/db.ts
+function parseJsonRecord(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return JSON.parse(value);
+}
+function parseEmbedding(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return JSON.parse(value);
+}
+function rowString(row, key) {
+  const value = row[key];
+  return value == null ? null : String(value);
+}
+function toMemoryItemRow(row) {
+  return {
+    canonicalKey: String(row.canonical_key),
+    summary: String(row.summary),
+    kind: rowString(row, "kind"),
+    category: rowString(row, "category"),
+    status: String(row.status),
+    confidence: Number(row.confidence),
+    sourceRunId: rowString(row, "source_run_id"),
+    sourceTaskId: rowString(row, "source_task_id"),
+    branch: rowString(row, "branch"),
+    details: parseJsonRecord(row.details_json),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    lastEventId: String(row.last_event_id),
+    supersededBy: rowString(row, "superseded_by"),
+    embedding: parseEmbedding(row.embedding)
+  };
+}
+async function listActiveMemoryItems(db) {
+  const result = await db.client.execute(`
+    SELECT
+      canonical_key,
+      summary,
+      kind,
+      category,
+      status,
+      confidence,
+      source_run_id,
+      source_task_id,
+      branch,
+      details_json,
+      created_at,
+      updated_at,
+      last_event_id,
+      superseded_by,
+      embedding
+    FROM memory_items
+    WHERE status = 'active'
+    ORDER BY canonical_key
+  `);
+  return result.rows.map((row) => toMemoryItemRow(row));
+}
+
+// packages/runtime/src/control-plane/memory-sync/embed.ts
+var DEFAULT_EMBEDDING_API_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+var DETERMINISTIC_EMBEDDER_MODE = "deterministic";
+var DETERMINISTIC_VECTOR_DIMS = 32;
+function tokenizeForDeterministicEmbedding(text) {
+  const tokens = text.toLowerCase().match(/[a-z0-9_./:-]+/g) ?? [];
+  return tokens.length > 0 ? tokens : [text.toLowerCase()];
+}
+function deterministicTokenVector(token) {
+  const hash = createHash("sha256").update(token).digest();
+  const vector = new Array(DETERMINISTIC_VECTOR_DIMS).fill(0);
+  for (let index = 0;index < 8; index += 1) {
+    const slot = (hash[index] ?? 0) % DETERMINISTIC_VECTOR_DIMS;
+    const sign = ((hash[index + 8] ?? 0) & 1) === 0 ? 1 : -1;
+    const magnitude = ((hash[index + 16] ?? 0) + 1) / 256;
+    vector[slot] = (vector[slot] ?? 0) + sign * magnitude;
+  }
+  return vector;
+}
+function normalizeVector(vector) {
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+  if (norm === 0) {
+    return vector.map(() => 0);
+  }
+  return vector.map((value) => Number((value / norm).toFixed(6)));
+}
+function createDeterministicMemoryEmbedder() {
+  return {
+    async embed(texts) {
+      return texts.map((text) => {
+        const vector = new Array(DETERMINISTIC_VECTOR_DIMS).fill(0);
+        for (const token of tokenizeForDeterministicEmbedding(text)) {
+          const tokenVector = deterministicTokenVector(token);
+          for (let index = 0;index < tokenVector.length; index += 1) {
+            vector[index] = (vector[index] ?? 0) + (tokenVector[index] ?? 0);
+          }
+        }
+        return normalizeVector(vector);
+      });
+    }
+  };
+}
+function embeddingResponseMessage(payload, status) {
+  if (typeof payload === "object" && payload !== null) {
+    const maybeMessage = payload.error?.message;
+    if (maybeMessage) {
+      return maybeMessage;
+    }
+  }
+  return `memory embedding request failed with status ${status}`;
+}
+function createOpenAiMemoryEmbedder(options) {
+  const apiKey = options.apiKey.trim();
+  const model = options.model?.trim() || DEFAULT_EMBEDDING_MODEL;
+  const apiBaseUrl = (options.apiBaseUrl?.trim() || DEFAULT_EMBEDDING_API_BASE_URL).replace(/\/+$/, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  if (!apiKey) {
+    throw new Error("memory embedding api key must be non-empty");
+  }
+  return {
+    async embed(texts) {
+      if (texts.length === 0) {
+        return [];
+      }
+      const response = await fetchImpl(`${apiBaseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${apiKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          input: texts,
+          model
+        })
+      });
+      const payload = await response.json();
+      if (!response.ok) {
+        throw new Error(embeddingResponseMessage(payload, response.status));
+      }
+      if (!Array.isArray(payload.data) || payload.data.length !== texts.length) {
+        throw new Error(`memory embedding provider returned ${payload.data?.length ?? 0} embeddings for ${texts.length} inputs`);
+      }
+      const byIndex = new Map;
+      for (const row of payload.data) {
+        if (typeof row.index !== "number" || !Array.isArray(row.embedding)) {
+          throw new Error("memory embedding provider returned an invalid response payload");
+        }
+        byIndex.set(row.index, row.embedding);
+      }
+      return texts.map((_text, index) => {
+        const embedding = byIndex.get(index);
+        if (!embedding) {
+          throw new Error(`memory embedding provider omitted embedding ${index}`);
+        }
+        return embedding;
+      });
+    }
+  };
+}
+function createConfiguredMemoryEmbedder(options = {}) {
+  const env = options.env ?? process.env;
+  const mode = env.RIG_MEMORY_EMBEDDER?.trim();
+  if (mode === DETERMINISTIC_EMBEDDER_MODE) {
+    return createDeterministicMemoryEmbedder();
+  }
+  const apiKey = env.OPENAI_API_KEY?.trim();
+  if (!apiKey) {
+    throw new Error("memory embeddings require OPENAI_API_KEY or RIG_MEMORY_EMBEDDER=deterministic");
+  }
+  return createOpenAiMemoryEmbedder({
+    apiKey,
+    model: env.RIG_MEMORY_EMBEDDING_MODEL?.trim() || DEFAULT_EMBEDDING_MODEL,
+    apiBaseUrl: options.apiBaseUrl ?? env.RIG_MEMORY_EMBEDDING_API_BASE_URL?.trim() ?? DEFAULT_EMBEDDING_API_BASE_URL,
+    fetchImpl: options.fetchImpl
+  });
+}
+
+// packages/runtime/src/control-plane/runtime/context.ts
+var DEFAULT_RUNTIME_MEMORY_RETRIEVAL = {
+  topK: 5,
+  lexicalWeight: 0.35,
+  vectorWeight: 0.45,
+  recencyWeight: 0.1,
+  confidenceWeight: 0.1
+};
+
+// packages/runtime/src/control-plane/memory-sync/query.ts
+var DEFAULT_RESULT_LIMIT = DEFAULT_RUNTIME_MEMORY_RETRIEVAL.topK;
+var DAY_MS = 24 * 60 * 60 * 1000;
+var MIN_VECTOR_MATCH_SCORE = 0.2;
+function tokenize(text) {
+  return (text.toLowerCase().match(/[a-z0-9_./:-]+/g) ?? []).flatMap((token) => {
+    const split = token.split(/[./:_-]+/).filter(Boolean);
+    return split.length > 0 ? [token, ...split] : [token];
+  });
+}
+function lexicalScore(query, item) {
+  const queryTokens = [...new Set(tokenize(query))];
+  if (queryTokens.length === 0) {
+    return 0;
+  }
+  const haystackTokens = new Set(tokenize(item.summary));
+  let matched = 0;
+  for (const token of queryTokens) {
+    if (haystackTokens.has(token)) {
+      matched += 1;
+    }
+  }
+  return matched / queryTokens.length;
+}
+function cosineSimilarity(left, right) {
+  if (left.length === 0 || left.length !== right.length) {
+    return 0;
+  }
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index = 0;index < left.length; index += 1) {
+    const l = left[index] ?? 0;
+    const r = right[index] ?? 0;
+    dot += l * r;
+    leftNorm += l * l;
+    rightNorm += r * r;
+  }
+  if (leftNorm === 0 || rightNorm === 0) {
+    return 0;
+  }
+  return dot / Math.sqrt(leftNorm * rightNorm);
+}
+function recencyScore(item, now) {
+  const updatedAt = Date.parse(item.updatedAt);
+  if (Number.isNaN(updatedAt)) {
+    return 0;
+  }
+  const ageMs = Math.max(0, now.getTime() - updatedAt);
+  return 1 / (1 + ageMs / DAY_MS);
+}
+async function maybeEmbedQuery(items, query, embedder) {
+  if (!items.some((item) => Array.isArray(item.embedding) && item.embedding.length > 0)) {
+    return null;
+  }
+  try {
+    const resolvedEmbedder = embedder ?? createConfiguredMemoryEmbedder();
+    const [queryEmbedding] = await resolvedEmbedder.embed([query]);
+    return queryEmbedding ?? null;
+  } catch {
+    return null;
+  }
+}
+async function queryRelevantMemory(db, input) {
+  const retrieval = input.retrieval ?? DEFAULT_RUNTIME_MEMORY_RETRIEVAL;
+  const now = input.now instanceof Date ? input.now : new Date(input.now ?? Date.now());
+  const items = await listActiveMemoryItems(db);
+  if (items.length === 0) {
+    return [];
+  }
+  const queryEmbedding = await maybeEmbedQuery(items, input.query, input.embedder);
+  const scored = items.map((item) => {
+    const lexical = lexicalScore(input.query, item);
+    const vector = queryEmbedding && item.embedding ? cosineSimilarity(queryEmbedding, item.embedding) : 0;
+    const recency = recencyScore(item, now);
+    const score = retrieval.lexicalWeight * lexical + retrieval.vectorWeight * vector + retrieval.recencyWeight * recency + retrieval.confidenceWeight * item.confidence;
+    return {
+      canonicalKey: item.canonicalKey,
+      summary: item.summary,
+      kind: item.kind,
+      category: item.category,
+      confidence: item.confidence,
+      updatedAt: item.updatedAt,
+      score,
+      lexicalScore: lexical,
+      vectorScore: vector,
+      recencyScore: recency
+    };
+  }).filter((item) => item.lexicalScore > 0 || item.vectorScore >= MIN_VECTOR_MATCH_SCORE).sort((left, right) => right.score - left.score || Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || right.confidence - left.confidence || left.canonicalKey.localeCompare(right.canonicalKey));
+  return scored.slice(0, input.limit ?? retrieval.topK ?? DEFAULT_RESULT_LIMIT);
+}
+function formatMemoryQueryResults(results) {
+  if (results.length === 0) {
+    return "No shared memories matched.";
+  }
+  return results.map((result, index) => `${index + 1}. [${result.canonicalKey}] ${result.summary} (confidence ${result.confidence.toFixed(2)})`).join(`
+`);
+}
+export {
+  queryRelevantMemory,
+  formatMemoryQueryResults
+};