kirograph 0.14.1 → 0.15.0

package/dist/mcp/tools.js

@@ -61,6 +61,19 @@ function writeSessionMarker(projectRoot) {
   } catch {
   }
 }
+function formatAge(timestamp) {
+  const diff = Date.now() - timestamp;
+  const minutes = Math.floor(diff / 6e4);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  if (days < 7) return `${days}d ago`;
+  const weeks = Math.floor(days / 7);
+  if (weeks < 5) return `${weeks}w ago`;
+  const months = Math.floor(days / 30);
+  return `${months}mo ago`;
+}
 const tools = [
   {
     name: "kirograph_search",
@@ -343,6 +356,66 @@ const tools = [
         projectPath: { type: "string", description: "Project root path (optional)" }
       }
     }
+  },
+  // ── Memory tools (require enableMemory=true) ────────────────────────────────
+  {
+    name: "kirograph_mem_search",
+    description: "Search project memory for past decisions, errors, patterns, and context. Returns observations ranked by relevance.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Natural language search query" },
+        kind: {
+          type: "string",
+          description: "Filter by observation kind",
+          enum: ["decision", "error", "pattern", "architecture", "summary", "note"]
+        },
+        limit: { type: "number", description: "Max results (default: 10)", default: 10 },
+        sessionId: { type: "string", description: "Filter to specific session" },
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "kirograph_mem_store",
+    description: "Store an observation in project memory. Content is automatically compressed (if caveman mode is on) and linked to relevant code symbols.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string", description: "Observation text" },
+        kind: {
+          type: "string",
+          description: "Observation kind",
+          enum: ["decision", "error", "pattern", "architecture", "summary", "note"],
+          default: "note"
+        },
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      },
+      required: ["content"]
+    }
+  },
+  {
+    name: "kirograph_mem_timeline",
+    description: "List recent sessions and their observations chronologically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of sessions to show (default: 5)", default: 5 },
+        sessionId: { type: "string", description: "Show observations for a specific session" },
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      }
+    }
+  },
+  {
+    name: "kirograph_mem_status",
+    description: "Memory subsystem health: session count, observations, embedding coverage, storage size.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string", description: "Project root path (optional)" }
+      }
+    }
   }
 ];
 class ToolHandler {
@@ -388,7 +461,11 @@ class ToolHandler {
           const naiveCost = estimateNaiveCost(toolName, outputTokens, args);
           if (naiveCost !== null && naiveCost > outputTokens) {
             const tracker = new import_tracker.TokenTracker(projectRoot);
-            tracker.recordGraphSaving(toolName, outputTokens, naiveCost);
+            if (toolName.startsWith("kirograph_mem_")) {
+              tracker.recordMemorySaving(toolName, outputTokens, naiveCost);
+            } else {
+              tracker.recordGraphSaving(toolName, outputTokens, naiveCost);
+            }
           }
         } catch {
         }
@@ -455,7 +532,7 @@ class ToolHandler {
         `  Tokens with KiroGraph:    ~${stats.totalCompressed.toLocaleString()}`,
         `  Saved: ${stats.totalSaved.toLocaleString()} tokens (${stats.savingsPercent}%)`
       ];
-      if (stats.bySource.exec.count > 0 || stats.bySource.graph.count > 0) {
+      if (stats.bySource.exec.count > 0 || stats.bySource.graph.count > 0 || stats.bySource.memory.count > 0) {
         lines.push("", "By source:");
         if (stats.bySource.graph.count > 0) {
           lines.push(`  Graph tools: ${stats.bySource.graph.count} calls, ~${stats.bySource.graph.saved.toLocaleString()} tokens saved (vs file reads/grep)`);
@@ -463,6 +540,9 @@ class ToolHandler {
         if (stats.bySource.exec.count > 0) {
           lines.push(`  Compression: ${stats.bySource.exec.count} calls, ~${stats.bySource.exec.saved.toLocaleString()} tokens saved (vs raw output)`);
         }
+        if (stats.bySource.memory.count > 0) {
+          lines.push(`  Memory: ${stats.bySource.memory.count} calls, ~${stats.bySource.memory.saved.toLocaleString()} tokens saved (vs re-discovering context)`);
+        }
       }
       if (Object.keys(stats.byFamily).length > 0) {
         lines.push("", "Top families:");
@@ -520,6 +600,36 @@ class ToolHandler {
             }
           }
         }
+        try {
+          const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+          const projectRoot = cg.getProjectRoot();
+          const config = await loadConfig(projectRoot);
+          if (config.enableMemory) {
+            const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+            const db = cg.getDatabase();
+            db.applyMemorySchema();
+            const mem = new MemoryManager(config, db.getRawDb());
+            mem.initialize();
+            const qualifiedNames = [
+              ...ctx.entryPoints.map((n) => n.qualifiedName),
+              ...ctx.relatedNodes.slice(0, 5).map((n) => n.qualifiedName)
+            ].filter(Boolean);
+            const contextLimit = config.memoryContextLimit ?? 3;
+            const contextThreshold = config.memoryContextThreshold ?? 0.3;
+            let memResults = mem.getLinkedObservations(qualifiedNames, contextLimit, contextThreshold);
+            if (memResults.length === 0) {
+              memResults = (await mem.search(args.task, { limit: contextLimit })).filter((r) => r.score >= contextThreshold);
+            }
+            if (memResults.length > 0) {
+              lines.push("", "## Related Memory");
+              for (const r of memResults.slice(0, contextLimit)) {
+                const age = formatAge(r.observation.createdAt);
+                lines.push(`- [${r.observation.kind}] ${r.observation.content} (${age})`);
+              }
+            }
+          }
+        } catch {
+        }
         return lines.join("\n");
       }
       case "kirograph_callers": {
@@ -552,8 +662,37 @@ class ToolHandler {
         const node = results[0].node;
         const affected = await cg.getImpactRadius(node.id, args.depth ?? 2);
         if (affected.length === 0) return `No dependents found for \`${node.name}\`.`;
-        return `Changing \`${node.name}\` may affect ${affected.length} symbol(s):
+        let output = `Changing \`${node.name}\` may affect ${affected.length} symbol(s):
 ` + affected.map((n) => `- ${mapKind(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`).join("\n");
+        try {
+          const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+          const projectRoot = cg.getProjectRoot();
+          const config = await loadConfig(projectRoot);
+          if (config.enableMemory) {
+            const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+            const db = cg.getDatabase();
+            db.applyMemorySchema();
+            const mem = new MemoryManager(config, db.getRawDb());
+            mem.initialize();
+            const contextLimit = config.memoryContextLimit ?? 3;
+            const contextThreshold = config.memoryContextThreshold ?? 0.3;
+            const memResults = mem.getLinkedObservations(
+              [node.qualifiedName],
+              contextLimit,
+              contextThreshold
+            );
+            if (memResults.length > 0) {
+              output += "\n\nRelated Memory:";
+              for (const r of memResults) {
+                const age = formatAge(r.observation.createdAt);
+                output += `
+- [${r.observation.kind}] ${r.observation.content} (${age})`;
+              }
+            }
+          }
+        } catch {
+        }
+        return output;
       }
       case "kirograph_node": {
         const results = cg.searchNodes(args.symbol, void 0, 5);
@@ -934,6 +1073,96 @@ class ToolHandler {
         }
         return lines.join("\n");
       }
+      // ── Memory tools ────────────────────────────────────────────────────────
+      case "kirograph_mem_search": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled. Set enableMemory: true in .kirograph/config.json";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const results = await mem.search(args.query, {
+          limit: args.limit ?? 10,
+          kind: args.kind,
+          sessionId: args.sessionId
+        });
+        if (results.length === 0) return `No memory observations found for "${args.query}".`;
+        return results.map((r, i) => {
+          const age = formatAge(r.observation.createdAt);
+          return `${i + 1}. [${r.observation.kind}] ${r.observation.content} (${age})`;
+        }).join("\n");
+      }
+      case "kirograph_mem_store": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled. Set enableMemory: true in .kirograph/config.json";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const id = await mem.store({
+          content: args.content,
+          kind: args.kind ?? "note",
+          source: "agent"
+        });
+        if (!id) return "Observation already exists (duplicate content).";
+        return `Stored observation ${id} [${args.kind ?? "note"}]`;
+      }
+      case "kirograph_mem_timeline": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled. Set enableMemory: true in .kirograph/config.json";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const { sessions, observations } = mem.timeline({
+          limit: args.limit ?? 5,
+          sessionId: args.sessionId
+        });
+        if (sessions.length === 0) return "No memory sessions found.";
+        const lines = [];
+        for (const session of sessions) {
+          const start = new Date(session.startedAt).toISOString().slice(0, 16).replace("T", " ");
+          const status = session.endedAt ? "ended" : "active";
+          const obs = observations.get(session.id) ?? [];
+          lines.push(`## ${start} [${session.ide ?? "unknown"}] (${status}, ${obs.length} observations)`);
+          for (const o of obs.slice(0, 5)) {
+            lines.push(`  - [${o.kind}] ${o.content.slice(0, 120)}`);
+          }
+          if (obs.length > 5) lines.push(`  \u2026and ${obs.length - 5} more`);
+        }
+        return lines.join("\n");
+      }
+      case "kirograph_mem_status": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled. Set enableMemory: true in .kirograph/config.json";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const stats = mem.getStats();
+        const lines = [
+          "KiroGraph Memory Status",
+          `  Sessions: ${stats.sessions} (${stats.activeSessions} active)`,
+          `  Observations: ${stats.observations}`,
+          `  Symbol links: ${stats.links}`,
+          `  Embeddings: ${stats.vectors} / ${stats.embeddableCount}`,
+          `  Model mismatch: ${stats.modelMismatch ? "\u26A0 yes \u2014 run kirograph mem reembed" : "no"}`,
+          `  Caveman compression: ${config.cavemanMode !== "off" ? config.cavemanMode : "off (storing raw)"}`
+        ];
+        return lines.join("\n");
+      }
       default:
         return `Unknown tool: ${toolName}`;
     }