@cleocode/core 2026.4.38 → 2026.4.39

package/dist/index.js

@@ -42360,6 +42360,390 @@ var init_brain_consolidator = __esm({
   }
 });
 
+// packages/core/src/memory/graph-memory-bridge.ts
+var graph_memory_bridge_exports = {};
+__export(graph_memory_bridge_exports, {
+  autoLinkMemories: () => autoLinkMemories,
+  linkMemoryToCode: () => linkMemoryToCode,
+  listCodeLinks: () => listCodeLinks,
+  queryCodeForMemory: () => queryCodeForMemory,
+  queryMemoriesForCode: () => queryMemoriesForCode
+});
+function extractFilePaths(text3) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const m of text3.matchAll(FILE_PATH_PATTERN)) {
+    const p = m[1];
+    if (p) paths.add(p);
+  }
+  return Array.from(paths);
+}
+function extractSymbolCandidates(text3) {
+  const syms = /* @__PURE__ */ new Set();
+  for (const m of text3.matchAll(SYMBOL_PATTERN)) {
+    const s = m[1];
+    if (s && s.length >= 4 && !SYMBOL_STOP_WORDS.has(s.toLowerCase())) {
+      syms.add(s);
+    }
+  }
+  return Array.from(syms);
+}
+function metadataText(metaJson) {
+  if (!metaJson) return "";
+  try {
+    const obj = JSON.parse(metaJson);
+    return Object.values(obj).filter((v) => typeof v === "string").join(" ");
+  } catch {
+    return "";
+  }
+}
+async function linkMemoryToCode(projectRoot, memoryId, codeSymbol) {
+  try {
+    const brainDb = await getBrainDb(projectRoot);
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!nexusNative) return false;
+    const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(codeSymbol);
+    if (!nexusNode) return false;
+    const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const idParts = memoryId.split(":");
+    const nodeType = idParts[0] ?? "observation";
+    await brainDb.insert(brainPageNodes).values({
+      id: memoryId,
+      nodeType,
+      label: memoryId,
+      qualityScore: 0.5,
+      contentHash: null,
+      lastActivityAt: now,
+      createdAt: now,
+      updatedAt: now
+    }).onConflictDoUpdate({
+      target: brainPageNodes.id,
+      set: { lastActivityAt: now, updatedAt: now }
+    });
+    await brainDb.insert(brainPageEdges).values({
+      fromId: memoryId,
+      toId: codeSymbol,
+      edgeType: "code_reference",
+      weight: 1,
+      provenance: "manual",
+      createdAt: now
+    }).onConflictDoNothing();
+    return true;
+  } catch (err) {
+    console.warn("[graph-memory-bridge] linkMemoryToCode failed:", err);
+    return false;
+  }
+}
+async function autoLinkMemories(projectRoot) {
+  const result = { scanned: 0, linked: 0, alreadyLinked: 0, links: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return result;
+    const brainNodes = typedAll(
+      brainNative.prepare(`
+        SELECT id, node_type, label, quality_score, metadata_json
+        FROM brain_page_nodes
+        WHERE node_type IN ('observation', 'decision', 'pattern', 'learning')
+          AND quality_score >= 0.3
+        ORDER BY quality_score DESC
+        LIMIT 500
+      `)
+    );
+    result.scanned = brainNodes.length;
+    if (brainNodes.length === 0) return result;
+    const nexusNodes2 = typedAll(
+      nexusNative.prepare(`
+        SELECT id, label, name, file_path, kind
+        FROM nexus_nodes
+        WHERE kind NOT IN ('community', 'process', 'folder')
+        LIMIT 20000
+      `)
+    );
+    if (nexusNodes2.length === 0) return result;
+    const byFilePath = /* @__PURE__ */ new Map();
+    const byNameExact = /* @__PURE__ */ new Map();
+    const byNameLower = /* @__PURE__ */ new Map();
+    for (const node of nexusNodes2) {
+      if (node.file_path) {
+        const fp = node.file_path.toLowerCase();
+        const existing = byFilePath.get(fp) ?? [];
+        existing.push(node);
+        byFilePath.set(fp, existing);
+      }
+      if (node.name) {
+        const exact = byNameExact.get(node.name) ?? [];
+        exact.push(node);
+        byNameExact.set(node.name, exact);
+        const lower = node.name.toLowerCase();
+        const fuzzy = byNameLower.get(lower) ?? [];
+        fuzzy.push(node);
+        byNameLower.set(lower, fuzzy);
+      }
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+    const existingEdges = /* @__PURE__ */ new Set();
+    const rawEdges = typedAll(
+      brainNative.prepare(`
+        SELECT from_id, to_id FROM brain_page_edges WHERE edge_type = 'code_reference'
+      `)
+    );
+    for (const e of rawEdges) {
+      existingEdges.add(`${e.from_id}|${e.to_id}`);
+    }
+    for (const brainNode of brainNodes) {
+      const corpus = `${brainNode.label} ${metadataText(brainNode.metadata_json)}`;
+      const filePaths = extractFilePaths(corpus);
+      const symbolCandidates = extractSymbolCandidates(corpus);
+      const candidates = [];
+      for (const fp of filePaths) {
+        const matches = byFilePath.get(fp.toLowerCase());
+        if (matches) {
+          for (const n of matches) {
+            candidates.push({ nexusNode: n, strategy: "exact-file", weight: 1 });
+          }
+        }
+      }
+      for (const sym of symbolCandidates) {
+        const exactMatches = byNameExact.get(sym);
+        if (exactMatches) {
+          for (const n of exactMatches) {
+            candidates.push({ nexusNode: n, strategy: "exact-symbol", weight: 1 });
+          }
+        }
+      }
+      const exactSymSet = new Set(
+        symbolCandidates.flatMap((s) => byNameExact.get(s) ?? []).map((n) => n.id)
+      );
+      for (const sym of symbolCandidates) {
+        if (sym.length < 5) continue;
+        const lower = sym.toLowerCase();
+        const fuzzyMatches = byNameLower.get(lower);
+        if (fuzzyMatches) {
+          for (const n of fuzzyMatches) {
+            if (!exactSymSet.has(n.id)) {
+              candidates.push({ nexusNode: n, strategy: "fuzzy-symbol", weight: 0.6 });
+            }
+          }
+        }
+      }
+      const bestByNexusId = /* @__PURE__ */ new Map();
+      for (const c of candidates) {
+        const existing = bestByNexusId.get(c.nexusNode.id);
+        if (!existing || c.weight > existing.weight) {
+          bestByNexusId.set(c.nexusNode.id, c);
+        }
+      }
+      const sortedCandidates = Array.from(bestByNexusId.values()).sort((a, b) => b.weight - a.weight).slice(0, 10);
+      for (const { nexusNode, strategy, weight } of sortedCandidates) {
+        const edgeKey = `${brainNode.id}|${nexusNode.id}`;
+        if (existingEdges.has(edgeKey)) {
+          result.alreadyLinked++;
+          continue;
+        }
+        brainNative.prepare(`
+            INSERT OR IGNORE INTO brain_page_nodes
+              (id, node_type, label, quality_score, content_hash, metadata_json, last_activity_at, created_at, updated_at)
+            VALUES (?, ?, ?, ?, NULL, NULL, ?, ?, ?)
+          `).run(
+          brainNode.id,
+          brainNode.node_type,
+          brainNode.label,
+          brainNode.quality_score,
+          now,
+          now,
+          now
+        );
+        try {
+          brainNative.prepare(`
+              INSERT OR IGNORE INTO brain_page_edges
+                (from_id, to_id, edge_type, weight, provenance, created_at)
+              VALUES (?, ?, 'code_reference', ?, ?, ?)
+            `).run(brainNode.id, nexusNode.id, weight, `auto:${strategy}`, now);
+          existingEdges.add(edgeKey);
+          result.linked++;
+          result.links.push({
+            brainNodeId: brainNode.id,
+            nexusNodeId: nexusNode.id,
+            nexusLabel: nexusNode.label,
+            matchStrategy: strategy,
+            weight
+          });
+        } catch (edgeErr) {
+          console.warn("[graph-memory-bridge] edge insert failed:", edgeErr);
+        }
+      }
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] autoLinkMemories failed:", err);
+  }
+  return result;
+}
+async function queryMemoriesForCode(projectRoot, symbol2) {
+  const result = { nexusNodeId: symbol2, memories: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    if (!brainNative) return result;
+    const rows = typedAll(
+      brainNative.prepare(`
+        SELECT n.id, n.node_type, n.label, n.quality_score,
+               e.weight, e.provenance
+        FROM brain_page_edges e
+        JOIN brain_page_nodes n ON n.id = e.from_id
+        WHERE e.to_id = ?
+          AND e.edge_type = 'code_reference'
+        ORDER BY e.weight DESC, n.quality_score DESC
+        LIMIT 50
+      `),
+      symbol2
+    );
+    result.memories = rows.map((r) => ({
+      nodeId: r.id,
+      nodeType: r.node_type,
+      label: r.label,
+      qualityScore: r.quality_score,
+      edgeWeight: r.weight,
+      matchStrategy: r.provenance?.replace("auto:", "") ?? "manual"
+    }));
+  } catch (err) {
+    console.warn("[graph-memory-bridge] queryMemoriesForCode failed:", err);
+  }
+  return result;
+}
+async function queryCodeForMemory(projectRoot, memoryId) {
+  const result = { brainNodeId: memoryId, codeNodes: [] };
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return result;
+    const brainEdges = typedAll(
+      brainNative.prepare(`
+        SELECT to_id, weight, provenance
+        FROM brain_page_edges
+        WHERE from_id = ?
+          AND edge_type = 'code_reference'
+        ORDER BY weight DESC
+        LIMIT 50
+      `),
+      memoryId
+    );
+    if (brainEdges.length === 0) return result;
+    for (const edge of brainEdges) {
+      const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(edge.to_id);
+      if (nexusNode) {
+        result.codeNodes.push({
+          nexusNodeId: nexusNode.id,
+          label: nexusNode.label,
+          filePath: nexusNode.file_path,
+          kind: nexusNode.kind,
+          edgeWeight: edge.weight,
+          matchStrategy: edge.provenance?.replace("auto:", "") ?? "manual"
+        });
+      }
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] queryCodeForMemory failed:", err);
+  }
+  return result;
+}
+async function listCodeLinks(projectRoot, limit = 100) {
+  const entries = [];
+  try {
+    await getBrainDb(projectRoot);
+    const brainNative = getBrainNativeDb();
+    await getNexusDb();
+    const nexusNative = getNexusNativeDb();
+    if (!brainNative || !nexusNative) return entries;
+    const rows = typedAll(
+      brainNative.prepare(`
+        SELECT e.from_id, e.to_id, e.weight, e.created_at,
+               n.node_type, n.label
+        FROM brain_page_edges e
+        JOIN brain_page_nodes n ON n.id = e.from_id
+        WHERE e.edge_type = 'code_reference'
+        ORDER BY e.weight DESC, e.created_at DESC
+        LIMIT ?
+      `),
+      limit
+    );
+    for (const row of rows) {
+      const nexusNode = nexusNative.prepare("SELECT id, label, file_path, kind FROM nexus_nodes WHERE id = ? LIMIT 1").get(row.to_id);
+      entries.push({
+        brainNodeId: row.from_id,
+        brainNodeType: row.node_type,
+        brainNodeLabel: row.label,
+        nexusNodeId: row.to_id,
+        nexusNodeLabel: nexusNode?.label ?? row.to_id,
+        filePath: nexusNode?.file_path ?? null,
+        kind: nexusNode?.kind ?? "unknown",
+        weight: row.weight,
+        createdAt: row.created_at
+      });
+    }
+  } catch (err) {
+    console.warn("[graph-memory-bridge] listCodeLinks failed:", err);
+  }
+  return entries;
+}
+var FILE_PATH_PATTERN, SYMBOL_PATTERN, SYMBOL_STOP_WORDS;
+var init_graph_memory_bridge = __esm({
+  "packages/core/src/memory/graph-memory-bridge.ts"() {
+    "use strict";
+    init_brain_schema();
+    init_brain_sqlite();
+    init_nexus_sqlite();
+    init_typed_query();
+    FILE_PATH_PATTERN = /(?:^|\s|['"`(])([a-zA-Z0-9_\-./]+\.(?:ts|tsx|js|jsx|rs|go|py|mjs|cjs))(?:$|\s|['"`)])/g;
+    SYMBOL_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*(?:[A-Z][a-zA-Z0-9_]*)+|[a-zA-Z_]{4,}[a-zA-Z0-9_]*)\b/g;
+    SYMBOL_STOP_WORDS = /* @__PURE__ */ new Set([
+      "true",
+      "false",
+      "null",
+      "undefined",
+      "const",
+      "async",
+      "await",
+      "return",
+      "export",
+      "import",
+      "from",
+      "type",
+      "interface",
+      "function",
+      "class",
+      "this",
+      "super",
+      "extends",
+      "implements",
+      "with",
+      "that",
+      "then",
+      "when",
+      "have",
+      "been",
+      "will",
+      "should",
+      "could",
+      "would",
+      "error",
+      "result",
+      "value",
+      "data",
+      "info",
+      "note",
+      "todo",
+      "done",
+      "fail",
+      "pass"
+    ]);
+  }
+});
+
 // packages/core/src/memory/brain-lifecycle.ts
 var brain_lifecycle_exports = {};
 __export(brain_lifecycle_exports, {
@@ -42659,6 +43043,13 @@ async function runConsolidation(projectRoot) {
   } catch (err) {
     console.warn("[consolidation] Step 7 summary generation failed:", err);
   }
+  try {
+    const { autoLinkMemories: autoLinkMemories2 } = await Promise.resolve().then(() => (init_graph_memory_bridge(), graph_memory_bridge_exports));
+    const bridgeResult = await autoLinkMemories2(projectRoot);
+    result.graphLinksCreated = bridgeResult.linked;
+  } catch (err) {
+    console.warn("[consolidation] Step 8 graph memory bridge failed:", err);
+  }
   return result;
 }
 async function deduplicateByEmbedding(projectRoot) {
@@ -52171,6 +52562,19 @@ async function completeTask(options, cwd, accessor) {
     })()
   ).catch(() => {
   });
+  try {
+    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    await hooks2.dispatch("PostToolUse", cwd ?? process.cwd(), {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      taskId: options.taskId,
+      taskTitle: task.title,
+      previousStatus: before.status,
+      newStatus: "done",
+      unblockedCount: unblockedTasks.length
+    }).catch(() => {
+    });
+  } catch {
+  }
   return {
     task,
     ...autoCompleted.length > 0 && { autoCompleted },