@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-EDMVA3PT.js

@@ -0,0 +1,727 @@
+import {
+  chunkSourceFile,
+  languageForFile
+} from "./chunk-I7AW4237.js";
+import {
+  resolveType
+} from "./chunk-GUMRIUI5.js";
+
+// src/lib/graph-rag.ts
+import crypto from "crypto";
+var AST_EXTRACTABLE_LANGUAGES = /* @__PURE__ */ new Set(["typescript", "javascript"]);
+var ENTITY_TYPES = [
+  "person",
+  "tool",
+  "project",
+  "decision",
+  "concept",
+  "file",
+  // Cross-repo contract entities (v1.2)
+  "repo",
+  "api_contract",
+  "mcp_tool",
+  "protocol",
+  "schema"
+];
+var RELATIONSHIP_TYPES = [
+  "implemented",
+  "superseded_by",
+  "depends_on",
+  "blocked_by",
+  "worked_on",
+  "uses",
+  "decided",
+  "related_to",
+  // Cross-repo contract relationships (v1.2)
+  "implements_contract",
+  // repo/service implements an API contract
+  "exposes_api",
+  // repo exposes an API endpoint/MCP tool
+  "consumes_api",
+  // repo consumes another repo's API
+  "shares_schema",
+  // repos share a DB schema or data contract
+  "depends_on_repo"
+  // repo-level dependency
+];
+async function tableHasColumn(client, table, column) {
+  try {
+    const result = await client.execute(`PRAGMA table_info(${table})`);
+    return result.rows.some((row) => String(row.name) === column);
+  } catch {
+    return false;
+  }
+}
+var GRAPH_EXTRACTION_CONTENT_LIMIT = 4e3;
+function normalizeEntityName(name) {
+  return name.replace(/\s*\([^)]*\)\s*/g, "").trim().replace(/\s+/g, " ").toLowerCase();
+}
+function entityId(name, type) {
+  const normalized = normalizeEntityName(name);
+  const resolvedType = resolveType(type).type.toLowerCase();
+  return crypto.createHash("sha256").update(`${normalized}::${resolvedType}`).digest("hex").slice(0, 16);
+}
+async function resolveAlias(client, name) {
+  const normalized = normalizeEntityName(name);
+  try {
+    const result = await client.execute({
+      sql: "SELECT canonical_entity_id FROM entity_aliases WHERE alias = ?",
+      args: [normalized]
+    });
+    if (result.rows.length > 0) {
+      return String(result.rows[0].canonical_entity_id);
+    }
+  } catch {
+  }
+  return null;
+}
+async function registerAlias(client, alias, canonicalEntityId) {
+  const normalized = normalizeEntityName(alias);
+  await client.execute({
+    sql: `INSERT OR REPLACE INTO entity_aliases (alias, canonical_entity_id) VALUES (?, ?)`,
+    args: [normalized, canonicalEntityId]
+  });
+}
+async function selectActualEntityId(client, name, type, fallbackId) {
+  const result = await client.execute({
+    sql: "SELECT id FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1",
+    args: [normalizeEntityName(name), type]
+  });
+  return result.rows[0]?.id ? String(result.rows[0].id) : fallbackId;
+}
+async function cleanupGraphLinksForMemories(client, memoryIds) {
+  const uniqueIds = [...new Set(memoryIds)].filter(Boolean);
+  if (uniqueIds.length === 0) {
+    return { entityLinksDeleted: 0, relationshipLinksDeleted: 0 };
+  }
+  const placeholders = uniqueIds.map(() => "?").join(",");
+  const entityLinks = await client.execute({
+    sql: `DELETE FROM entity_memories WHERE memory_id IN (${placeholders})`,
+    args: uniqueIds
+  });
+  const relationshipLinks = await client.execute({
+    sql: `DELETE FROM relationship_memories WHERE memory_id IN (${placeholders})`,
+    args: uniqueIds
+  });
+  return {
+    entityLinksDeleted: entityLinks.rowsAffected ?? 0,
+    relationshipLinksDeleted: relationshipLinks.rowsAffected ?? 0
+  };
+}
+async function mergeEntities(client, sourceEntityId, targetEntityId) {
+  if (sourceEntityId === targetEntityId) {
+    return { relationshipsMoved: 0, memoriesMoved: 0 };
+  }
+  const sourceResult = await client.execute({
+    sql: "SELECT name FROM entities WHERE id = ?",
+    args: [sourceEntityId]
+  });
+  if (sourceResult.rows.length === 0) {
+    throw new Error(`Source entity ${sourceEntityId} not found`);
+  }
+  const targetResult = await client.execute({
+    sql: "SELECT id FROM entities WHERE id = ?",
+    args: [targetEntityId]
+  });
+  if (targetResult.rows.length === 0) {
+    throw new Error(`Target entity ${targetEntityId} not found`);
+  }
+  const sourceName = String(sourceResult.rows[0].name);
+  const relsSource = await client.execute({
+    sql: `UPDATE relationships SET source_entity_id = ?
+          WHERE source_entity_id = ?
+          AND NOT EXISTS (
+            SELECT 1 FROM relationships r2
+            WHERE r2.source_entity_id = ? AND r2.target_entity_id = relationships.target_entity_id AND r2.type = relationships.type
+          )`,
+    args: [targetEntityId, sourceEntityId, targetEntityId]
+  });
+  const relsTarget = await client.execute({
+    sql: `UPDATE relationships SET target_entity_id = ?
+          WHERE target_entity_id = ?
+          AND NOT EXISTS (
+            SELECT 1 FROM relationships r2
+            WHERE r2.target_entity_id = ? AND r2.source_entity_id = relationships.source_entity_id AND r2.type = relationships.type
+          )`,
+    args: [targetEntityId, sourceEntityId, targetEntityId]
+  });
+  await client.execute({
+    sql: "DELETE FROM relationships WHERE source_entity_id = ? OR target_entity_id = ?",
+    args: [sourceEntityId, sourceEntityId]
+  });
+  await client.execute({
+    sql: "DELETE FROM relationships WHERE source_entity_id = target_entity_id",
+    args: []
+  });
+  const mems = await client.execute({
+    sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+          SELECT ?, memory_id FROM entity_memories WHERE entity_id = ?`,
+    args: [targetEntityId, sourceEntityId]
+  });
+  await client.execute({
+    sql: "DELETE FROM entity_memories WHERE entity_id = ?",
+    args: [sourceEntityId]
+  });
+  try {
+    await client.execute({
+      sql: "UPDATE entity_aliases SET canonical_entity_id = ? WHERE canonical_entity_id = ?",
+      args: [targetEntityId, sourceEntityId]
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `INSERT OR IGNORE INTO hyperedge_nodes (hyperedge_id, entity_id)
+            SELECT hyperedge_id, ? FROM hyperedge_nodes WHERE entity_id = ?`,
+      args: [targetEntityId, sourceEntityId]
+    });
+    await client.execute({
+      sql: "DELETE FROM hyperedge_nodes WHERE entity_id = ?",
+      args: [sourceEntityId]
+    });
+  } catch {
+  }
+  await registerAlias(client, sourceName, targetEntityId);
+  await client.execute({
+    sql: "DELETE FROM entities WHERE id = ?",
+    args: [sourceEntityId]
+  });
+  return {
+    relationshipsMoved: (relsSource.rowsAffected ?? 0) + (relsTarget.rowsAffected ?? 0),
+    memoriesMoved: mems.rowsAffected ?? 0
+  };
+}
+var EXTRACT_TOOL = {
+  name: "extract_entities_and_relationships",
+  description: "Extract entities, relationships, and group connections from a memory record. Include confidence scoring.",
+  input_schema: {
+    type: "object",
+    properties: {
+      entities: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Entity name" },
+            type: { type: "string", enum: ["person", "human", "agent", "vendor", "customer", "tool", "software", "hardware", "service", "project", "sprint", "epic", "repo", "decision", "architectural", "operational", "business", "concept", "pattern", "principle", "standard", "file", "rationale", "product", "company", "location", "order", "supplier", "category"] }
+          },
+          required: ["name", "type"]
+        }
+      },
+      relationships: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            source: { type: "string" },
+            source_type: { type: "string" },
+            target: { type: "string" },
+            target_type: { type: "string" },
+            relationship: {
+              type: "string",
+              enum: [
+                // Engineering
+                "implemented",
+                "superseded_by",
+                "depends_on",
+                "blocked_by",
+                "worked_on",
+                "uses",
+                "decided",
+                "created",
+                "fixed",
+                "reviewed",
+                "rationale_for",
+                // Business / organizational
+                "supplies",
+                "ordered_from",
+                "reports_to",
+                "manages",
+                "located_at",
+                "ships_to",
+                "categorized_as",
+                "priced_at",
+                "partnered_with",
+                "contracted_by",
+                // General purpose
+                "related_to",
+                "part_of",
+                "owns",
+                "communicates_with"
+              ]
+            },
+            confidence: { type: "number", description: "0.0-1.0. 1.0=explicitly stated, 0.6-0.9=inferred, 0.1-0.3=ambiguous" },
+            confidence_label: { type: "string", enum: ["extracted", "inferred", "ambiguous"] }
+          },
+          required: ["source", "source_type", "target", "target_type", "relationship", "confidence", "confidence_label"]
+        }
+      },
+      hyperedges: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            label: { type: "string", description: "Group label (e.g., 'auth flow files', 'v1.3 contributors')" },
+            relation: { type: "string", description: "What connects them (e.g., 'part_of', 'contributed_to')" },
+            entity_names: { type: "array", items: { type: "string" }, description: "3+ entity names in this group" },
+            confidence: { type: "number" }
+          },
+          required: ["label", "relation", "entity_names", "confidence"]
+        },
+        description: "Group relationships connecting 3+ entities"
+      }
+    },
+    required: ["entities", "relationships", "hyperedges"]
+  }
+};
+var READ_MEMORY_PATH_PATTERN = /^Read\s+(\S+\.(?:ts|tsx|js|jsx))\s*\n/;
+function parseImportPaths(importText) {
+  const paths = [];
+  const fromRegex = /from\s+["']([^"']+)["']/g;
+  let match;
+  while ((match = fromRegex.exec(importText)) !== null) {
+    paths.push(match[1]);
+  }
+  const bareRegex = /^import\s+["']([^"']+)["']/gm;
+  while ((match = bareRegex.exec(importText)) !== null) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+  return paths;
+}
+function moduleNameFromPath(importPath) {
+  const base = importPath.split("/").pop() ?? importPath;
+  return base.replace(/\.\w+$/, "") || base;
+}
+function extractFromCode(source, filePath) {
+  let chunks;
+  try {
+    chunks = chunkSourceFile(source, filePath);
+  } catch {
+    return { entities: [], relationships: [], hyperedges: [] };
+  }
+  if (chunks.length === 0) {
+    return { entities: [], relationships: [], hyperedges: [] };
+  }
+  const entities = [];
+  const relationships = [];
+  const fileName = filePath.split("/").pop() ?? filePath;
+  entities.push({ name: fileName, type: "file" });
+  for (const chunk of chunks) {
+    if (chunk.kind === "import") {
+      const importPaths = parseImportPaths(chunk.text);
+      for (const importPath of importPaths) {
+        const moduleName = moduleNameFromPath(importPath);
+        entities.push({ name: moduleName, type: "file" });
+        relationships.push({
+          source: fileName,
+          sourceType: "file",
+          target: moduleName,
+          targetType: "file",
+          relationship: "depends_on",
+          confidence: 1,
+          confidenceLabel: "extracted"
+        });
+      }
+      continue;
+    }
+    if (chunk.kind === "other" || chunk.name === "(unknown)") continue;
+    entities.push({ name: chunk.name, type: "concept" });
+    relationships.push({
+      source: fileName,
+      sourceType: "file",
+      target: chunk.name,
+      targetType: "concept",
+      relationship: "uses",
+      confidence: 1,
+      confidenceLabel: "extracted"
+    });
+  }
+  return { entities, relationships, hyperedges: [] };
+}
+function pushUniqueEntity(entities, seen, name, type) {
+  const normalized = normalizeEntityName(name);
+  if (!normalized || normalized.length < 2) return;
+  const key = `${normalized.toLowerCase()}::${type.toLowerCase()}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  entities.push({ name: normalized.slice(0, 160), type });
+}
+function pushHeuristicRelationship(relationships, source, sourceType, target, targetType, relationship, confidence = 0.6) {
+  if (!source || !target || source === target) return;
+  relationships.push({
+    source,
+    sourceType,
+    target,
+    targetType,
+    relationship,
+    confidence,
+    confidenceLabel: "inferred"
+  });
+}
+function extractHeuristicMemoryGraph(content, agentId) {
+  const entities = [];
+  const relationships = [];
+  const seen = /* @__PURE__ */ new Set();
+  pushUniqueEntity(entities, seen, agentId, "person");
+  const toolMatch = content.match(/^(Bash|Read|Edit|Write|Grep|Glob|AssistantResponse|Tool|Ran|Wrote|Edited):/m);
+  if (toolMatch?.[1]) {
+    pushUniqueEntity(entities, seen, toolMatch[1], "tool");
+    pushHeuristicRelationship(relationships, agentId, "person", toolMatch[1], "tool", "uses", 0.75);
+  }
+  const repoMatches = [...content.matchAll(/\/Users\/[^/\s]+\/([A-Za-z0-9_.-]+)|\/opt\/([A-Za-z0-9_.-]+)/g)].map((m) => m[1] ?? m[2]).filter((repo) => Boolean(repo)).slice(0, 6);
+  for (const repo of repoMatches) {
+    pushUniqueEntity(entities, seen, repo, "project");
+    pushHeuristicRelationship(relationships, agentId, "person", repo, "project", "worked_on", 0.7);
+  }
+  const pathMatches = new Set(
+    (content.match(/(?:\/[\w .@-]+)+(?:\.[A-Za-z0-9]{1,10})|(?:[\w@.-]+\/)+[\w@.-]+\.(?:ts|tsx|js|jsx|json|md|yml|yaml|sql|py|go|rs|sh|css|html)/g) ?? []).slice(0, 10)
+  );
+  for (const filePath of pathMatches) {
+    pushUniqueEntity(entities, seen, filePath, "file");
+    pushHeuristicRelationship(relationships, agentId, "person", filePath, "file", "uses", 0.65);
+  }
+  const backtickTerms = [...content.matchAll(/`([^`\n]{2,80})`/g)].map((m) => m[1]).slice(0, 10);
+  for (const term of backtickTerms) {
+    if (!term || term.length < 2) continue;
+    const type = term.includes("/") || /\.[A-Za-z0-9]{1,10}$/.test(term) ? "file" : "concept";
+    pushUniqueEntity(entities, seen, term, type);
+    pushHeuristicRelationship(relationships, agentId, "person", term, type, "uses", 0.55);
+  }
+  return { entities, relationships, hyperedges: [] };
+}
+async function extractFromMemory(content, agentId, model = "claude-haiku-4-5-20251001", filePath) {
+  if (content.length < 50) {
+    return { entities: [], relationships: [], hyperedges: [] };
+  }
+  const lang = filePath ? languageForFile(filePath) : void 0;
+  if (filePath && lang && AST_EXTRACTABLE_LANGUAGES.has(lang)) {
+    const astResult = extractFromCode(content, filePath);
+    if (astResult.entities.length > 0) {
+      return astResult;
+    }
+  }
+  try {
+    const Anthropic = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic();
+    const response = await client.messages.create({
+      model,
+      max_tokens: 512,
+      system: `Extract entities and relationships from this AI agent work memory. Agent: ${agentId}. Focus on: people, tools, projects, decisions, files, rationale \u2014 and for business contexts: products, companies, suppliers, locations, orders, categories. Only extract what's clearly stated \u2014 don't infer. Use the simplest form of names (e.g., "Lenny" not "Lenny (HYGO)"). When content says "we chose X because Y", extract a rationale entity with rationale_for edge. Business examples: "Lenny supplies organic flour to HYGO" \u2192 (Lenny, supplies, HYGO). "Order #1234 shipped to Auckland" \u2192 (Order #1234, ships_to, Auckland).`,
+      messages: [{ role: "user", content: content.slice(0, GRAPH_EXTRACTION_CONTENT_LIMIT) }],
+      tools: [EXTRACT_TOOL],
+      tool_choice: { type: "tool", name: "extract_entities_and_relationships" }
+    });
+    const toolBlock = response.content.find((b) => b.type === "tool_use");
+    if (toolBlock && toolBlock.type === "tool_use") {
+      const input = toolBlock.input;
+      const rawEntities = input.entities ?? [];
+      const rawRels = input.relationships ?? [];
+      const rawHyperedges = input.hyperedges ?? [];
+      return {
+        entities: rawEntities.map((e) => ({
+          name: e.name ?? "",
+          type: e.type ?? "concept"
+        })).filter((e) => e.name.length > 0),
+        relationships: rawRels.map((r) => ({
+          source: r.source ?? "",
+          sourceType: r.source_type ?? "concept",
+          target: r.target ?? "",
+          targetType: r.target_type ?? "concept",
+          relationship: r.relationship ?? "uses",
+          confidence: Number(r.confidence ?? 1),
+          confidenceLabel: String(r.confidence_label ?? "extracted")
+        })).filter((r) => r.source.length > 0 && r.target.length > 0),
+        hyperedges: rawHyperedges.map((h) => ({
+          label: String(h.label ?? ""),
+          relation: String(h.relation ?? ""),
+          entityNames: h.entity_names ?? [],
+          confidence: Number(h.confidence ?? 1)
+        })).filter((h) => h.label.length > 0 && h.entityNames.length >= 3)
+      };
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[graph-rag] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  return extractHeuristicMemoryGraph(content, agentId);
+}
+async function storeExtraction(client, extraction, memoryId, timestamp) {
+  let entitiesStored = 0;
+  let relationshipsStored = 0;
+  const entitiesHaveParentType = await tableHasColumn(client, "entities", "parent_type");
+  const relationshipsHaveValidFrom = await tableHasColumn(client, "relationships", "valid_from");
+  const actualEntityIds = /* @__PURE__ */ new Map();
+  for (const e of extraction.entities) {
+    const aliasTarget = await resolveAlias(client, e.name);
+    const resolved = resolveType(e.type);
+    const id = aliasTarget ?? entityId(e.name, resolved.type);
+    const normalizedName = normalizeEntityName(e.name);
+    try {
+      const newProps = e.properties ?? {};
+      let mergedPropsJson = JSON.stringify(newProps);
+      if (newProps.provenance) {
+        const existing = await client.execute({
+          sql: "SELECT properties FROM entities WHERE id = ?",
+          args: [aliasTarget ?? id]
+        });
+        const existingProps = existing.rows.length > 0 ? JSON.parse(String(existing.rows[0].properties ?? "{}")) : {};
+        const existingProvenance = Array.isArray(existingProps.provenance) ? existingProps.provenance : existingProps.provenance ? [existingProps.provenance] : [];
+        mergedPropsJson = JSON.stringify({
+          ...existingProps,
+          ...newProps,
+          provenance: [...existingProvenance, newProps.provenance]
+        });
+      }
+      if (aliasTarget) {
+        await client.execute({
+          sql: `UPDATE entities SET last_seen = ?, properties = ? WHERE id = ?`,
+          args: [timestamp, mergedPropsJson, aliasTarget]
+        });
+      } else {
+        if (entitiesHaveParentType) {
+          await client.execute({
+            sql: `INSERT INTO entities (id, name, type, parent_type, first_seen, last_seen, properties)
+                  VALUES (?, ?, ?, ?, ?, ?, ?)
+                  ON CONFLICT(name, type) DO UPDATE SET last_seen = ?, properties = ?,
+                    parent_type = COALESCE(excluded.parent_type, entities.parent_type)`,
+            args: [
+              id,
+              normalizedName,
+              resolved.type,
+              resolved.parentType ?? null,
+              timestamp,
+              timestamp,
+              mergedPropsJson,
+              timestamp,
+              mergedPropsJson
+            ]
+          });
+        } else {
+          await client.execute({
+            sql: `INSERT INTO entities (id, name, type, first_seen, last_seen, properties)
+                  VALUES (?, ?, ?, ?, ?, ?)
+                  ON CONFLICT(name, type) DO UPDATE SET last_seen = ?, properties = ?`,
+            args: [
+              id,
+              normalizedName,
+              resolved.type,
+              timestamp,
+              timestamp,
+              mergedPropsJson,
+              timestamp,
+              mergedPropsJson
+            ]
+          });
+        }
+      }
+      const actualId = aliasTarget ?? await selectActualEntityId(client, normalizedName, resolved.type, id);
+      actualEntityIds.set(`${resolved.type}:${normalizedName}`, actualId);
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+              VALUES (?, ?)`,
+        args: [actualId, memoryId]
+      });
+      entitiesStored++;
+    } catch {
+    }
+  }
+  for (const r of extraction.relationships) {
+    const resolvedSourceType = resolveType(r.sourceType);
+    const resolvedTargetType = resolveType(r.targetType);
+    const normalizedSourceName = normalizeEntityName(r.source);
+    const normalizedTargetName = normalizeEntityName(r.target);
+    const sourceAlias = await resolveAlias(client, r.source);
+    const targetAlias = await resolveAlias(client, r.target);
+    const sourceId = sourceAlias ?? entityId(r.source, resolvedSourceType.type);
+    const targetId = targetAlias ?? entityId(r.target, resolvedTargetType.type);
+    const relId = crypto.randomUUID().slice(0, 16);
+    try {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen)
+              VALUES (?, ?, ?, ?, ?)`,
+        args: [sourceId, normalizedSourceName, resolvedSourceType.type, timestamp, timestamp]
+      });
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen)
+              VALUES (?, ?, ?, ?, ?)`,
+        args: [targetId, normalizedTargetName, resolvedTargetType.type, timestamp, timestamp]
+      });
+      const actualSourceId = sourceAlias ?? actualEntityIds.get(`${resolvedSourceType.type}:${normalizedSourceName}`) ?? await selectActualEntityId(client, normalizedSourceName, resolvedSourceType.type, sourceId);
+      const actualTargetId = targetAlias ?? actualEntityIds.get(`${resolvedTargetType.type}:${normalizedTargetName}`) ?? await selectActualEntityId(client, normalizedTargetName, resolvedTargetType.type, targetId);
+      if (actualSourceId === actualTargetId) continue;
+      const relProps = r.properties ?? {};
+      let relPropsJson = JSON.stringify(relProps);
+      if (relProps.provenance) {
+        const existingRels = await client.execute({
+          sql: "SELECT properties FROM relationships WHERE source_entity_id = ? AND target_entity_id = ? AND type = ?",
+          args: [actualSourceId, actualTargetId, r.relationship]
+        });
+        const existingRelProps = existingRels.rows.length > 0 ? JSON.parse(String(existingRels.rows[0].properties ?? "{}")) : {};
+        const existingProvenance = Array.isArray(existingRelProps.provenance) ? existingRelProps.provenance : existingRelProps.provenance ? [existingRelProps.provenance] : [];
+        relPropsJson = JSON.stringify({
+          ...existingRelProps,
+          ...relProps,
+          provenance: [...existingProvenance, relProps.provenance]
+        });
+      }
+      if (relationshipsHaveValidFrom) {
+        await client.execute({
+          sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, confidence, confidence_label, properties, valid_from)
+                VALUES (?, ?, ?, ?, 1.0, ?, ?, ?, ?, ?)
+                ON CONFLICT(source_entity_id, target_entity_id, type)
+                DO UPDATE SET weight = MIN(weight + 0.1, 2.0), timestamp = ?,
+                  confidence = MAX(confidence, ?), confidence_label = ?, properties = ?`,
+          args: [
+            relId,
+            actualSourceId,
+            actualTargetId,
+            r.relationship,
+            timestamp,
+            r.confidence,
+            r.confidenceLabel,
+            relPropsJson,
+            timestamp,
+            timestamp,
+            r.confidence,
+            r.confidenceLabel,
+            relPropsJson
+          ]
+        });
+      } else {
+        await client.execute({
+          sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, confidence, confidence_label, properties)
+                VALUES (?, ?, ?, ?, 1.0, ?, ?, ?, ?)
+                ON CONFLICT(source_entity_id, target_entity_id, type)
+                DO UPDATE SET weight = MIN(weight + 0.1, 2.0), timestamp = ?,
+                  confidence = MAX(confidence, ?), confidence_label = ?, properties = ?`,
+          args: [
+            relId,
+            actualSourceId,
+            actualTargetId,
+            r.relationship,
+            timestamp,
+            r.confidence,
+            r.confidenceLabel,
+            relPropsJson,
+            timestamp,
+            r.confidence,
+            r.confidenceLabel,
+            relPropsJson
+          ]
+        });
+      }
+      const existingRel = await client.execute({
+        sql: `SELECT id FROM relationships WHERE source_entity_id = ? AND target_entity_id = ? AND type = ?`,
+        args: [actualSourceId, actualTargetId, r.relationship]
+      });
+      const actualRelId = existingRel.rows[0]?.id ? String(existingRel.rows[0].id) : relId;
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO relationship_memories (relationship_id, memory_id)
+              VALUES (?, ?)`,
+        args: [actualRelId, memoryId]
+      });
+      relationshipsStored++;
+    } catch {
+    }
+  }
+  for (const h of extraction.hyperedges) {
+    const hId = crypto.randomUUID().slice(0, 16);
+    try {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO hyperedges (id, label, relation, confidence, timestamp)
+              VALUES (?, ?, ?, ?, ?)`,
+        args: [hId, h.label, h.relation, h.confidence, timestamp]
+      });
+      for (const entityName of h.entityNames) {
+        const rawType = extraction.entities.find((e) => e.name === entityName)?.type ?? "concept";
+        const resolvedEType = resolveType(rawType);
+        const normalizedEName = normalizeEntityName(entityName);
+        const eId = entityId(entityName, resolvedEType.type);
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen)
+                VALUES (?, ?, ?, ?, ?)`,
+          args: [eId, normalizedEName, resolvedEType.type, timestamp, timestamp]
+        });
+        const actualEId = actualEntityIds.get(`${resolvedEType.type}:${normalizedEName}`) ?? await selectActualEntityId(client, normalizedEName, resolvedEType.type, eId);
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO hyperedge_nodes (hyperedge_id, entity_id) VALUES (?, ?)`,
+          args: [hId, actualEId]
+        });
+      }
+    } catch {
+    }
+  }
+  return { entitiesStored, relationshipsStored };
+}
+async function extractBatch(client, batchSize = 50, model = "claude-haiku-4-5-20251001") {
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, tool_name, timestamp, content_hash, graph_extracted_hash
+          FROM memories
+          WHERE (COALESCE(graph_extracted, 0) = 0
+                 OR (content_hash IS NOT NULL AND content_hash != COALESCE(graph_extracted_hash, '')))
+            AND COALESCE(status, 'active') = 'active'
+            AND LENGTH(raw_text) >= 50
+          ORDER BY timestamp DESC
+          LIMIT ?`,
+    args: [batchSize]
+  });
+  if (result.rows.length === 0) {
+    return { processed: 0, entities: 0, relationships: 0 };
+  }
+  let totalEntities = 0;
+  let totalRelationships = 0;
+  for (const row of result.rows) {
+    const memoryId = String(row.id);
+    const agentId = String(row.agent_id);
+    const rawContent = String(row.raw_text);
+    const toolName = String(row.tool_name ?? "");
+    const timestamp = String(row.timestamp);
+    let extractionContent = rawContent;
+    let detectedFilePath;
+    if (toolName === "Read") {
+      const pathMatch = rawContent.match(READ_MEMORY_PATH_PATTERN);
+      if (pathMatch) {
+        detectedFilePath = pathMatch[1];
+        extractionContent = rawContent.slice(pathMatch[0].length);
+      }
+    }
+    try {
+      const extraction = await extractFromMemory(extractionContent, agentId, model, detectedFilePath);
+      if (extraction.entities.length > 0 || extraction.relationships.length > 0) {
+        const stored = await storeExtraction(client, extraction, memoryId, timestamp);
+        totalEntities += stored.entitiesStored;
+        totalRelationships += stored.relationshipsStored;
+      }
+      const contentHash = crypto.createHash("sha256").update(rawContent).digest("hex").slice(0, 32);
+      await client.execute({
+        sql: "UPDATE memories SET graph_extracted = 1, content_hash = ?, graph_extracted_hash = ? WHERE id = ?",
+        args: [contentHash, contentHash, memoryId]
+      });
+    } catch (err) {
+      process.stderr.write(
+        `[graph-rag] Batch extraction failed for ${memoryId}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return { processed: result.rows.length, entities: totalEntities, relationships: totalRelationships };
+}
+
+export {
+  ENTITY_TYPES,
+  RELATIONSHIP_TYPES,
+  normalizeEntityName,
+  entityId,
+  resolveAlias,
+  registerAlias,
+  cleanupGraphLinksForMemories,
+  mergeEntities,
+  EXTRACT_TOOL,
+  extractFromCode,
+  extractHeuristicMemoryGraph,
+  extractFromMemory,
+  storeExtraction,
+  extractBatch
+};