@kage-core/kage-graph-mcp 1.1.31 → 1.1.32

package/README.md

@@ -44,8 +44,9 @@ Restart your agent once after setup so MCP tools reload.
 - memory-code links so project knowledge points at the code it affects
 - decision intelligence for why-memory coverage, stale/weak packets, and
   important files that still lack linked repo knowledge
-- lightweight workspace recall across sibling repos, including package and
-  route-contract links when existing code graphs expose them
+- lightweight workspace recall across sibling repos, including package,
+  route-contract, and topic/event contract links when existing code graphs
+  expose them
 - local git intelligence for risk, reviewers, contributor profiles, co-change
   warnings, ownership silos, and module health
 - `AGENTS.md` bootstrap instructions so agents recall context automatically

package/dist/cli.js

@@ -849,6 +849,12 @@ async function main() {
                 console.log(`- ${contract.provider_repo} ${contract.method} ${contract.path} -> ${contract.consumer_repo}/${contract.consumer_file}`);
             }
         }
+        if (result.topic_contracts.length) {
+            console.log("Topic/event contracts:");
+            for (const contract of result.topic_contracts.slice(0, 10)) {
+                console.log(`- ${contract.producer_repo} ${contract.topic} -> ${contract.consumer_repo}/${contract.consumer_file}`);
+            }
+        }
         if (result.warnings.length)
             console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
         return;

package/dist/index.js

@@ -322,7 +322,7 @@ function listTools() {
         },
         {
             name: "kage_workspace",
-            description: "Summarize a local multi-repo workspace: discovered git repos, Kage memory coverage, code graph counts, and package dependencies between repos. Use when a task spans multiple sibling repos.",
+            description: "Summarize a local multi-repo workspace: discovered git repos, Kage memory coverage, code graph counts, package dependencies, route contracts, and topic/event contracts between repos. Use when a task spans multiple sibling repos.",
             inputSchema: {
                 type: "object",
                 properties: {

package/dist/kernel.js

@@ -6487,6 +6487,96 @@ function workspaceRouteContracts(workspaceDir, repos) {
         .sort((a, b) => a.provider_repo.localeCompare(b.provider_repo) || a.path.localeCompare(b.path) || a.consumer_repo.localeCompare(b.consumer_repo))
         .slice(0, 50);
 }
+const TOPIC_PRODUCER_METHODS = "publish|produce|send|emit|enqueue|dispatch";
+const TOPIC_CONSUMER_METHODS = "subscribe|consume|listen|handle";
+function likelyWorkspaceTopic(value) {
+    const topic = value.trim();
+    if (topic.length < 3 || topic.length > 120)
+        return false;
+    if (topic.startsWith("/") || /^https?:\/\//i.test(topic))
+        return false;
+    if (/\s/.test(topic))
+        return false;
+    if (/[.:-]/.test(topic))
+        return true;
+    if (/_/.test(topic) && /^[a-z0-9_]+$/i.test(topic))
+        return true;
+    return /\b(created|updated|deleted|requested|completed|failed|received|changed)$/i.test(topic);
+}
+function extractWorkspaceTopicMentions(repo, file, text) {
+    const mentions = [];
+    const patterns = [
+        { role: "producer", regex: new RegExp(`\\b(?:${TOPIC_PRODUCER_METHODS})\\s*\\(\\s*["'\`]([^"'\`]+)["'\`]`, "gi") },
+        { role: "producer", regex: new RegExp(`\\.(?:${TOPIC_PRODUCER_METHODS})\\s*\\(\\s*["'\`]([^"'\`]+)["'\`]`, "gi") },
+        { role: "consumer", regex: new RegExp(`\\b(?:${TOPIC_CONSUMER_METHODS})\\s*\\(\\s*["'\`]([^"'\`]+)["'\`]`, "gi") },
+        { role: "consumer", regex: new RegExp(`\\.(?:${TOPIC_CONSUMER_METHODS})\\s*\\(\\s*["'\`]([^"'\`]+)["'\`]`, "gi") },
+    ];
+    for (const pattern of patterns) {
+        for (const match of text.matchAll(pattern.regex)) {
+            const topic = match[1]?.trim();
+            if (!topic || !likelyWorkspaceTopic(topic))
+                continue;
+            mentions.push({
+                repo,
+                file,
+                topic,
+                role: pattern.role,
+                evidence: `${file} ${pattern.role === "producer" ? "publishes" : "subscribes to"} ${topic}`,
+            });
+        }
+    }
+    return mentions;
+}
+function workspaceTopicContracts(workspaceDir, repos) {
+    const mentions = [];
+    for (const repo of repos) {
+        const repoRoot = repo.path === "." ? workspaceDir : (0, node_path_1.join)(workspaceDir, repo.path);
+        const graph = readCurrentCodeGraph(repoRoot);
+        if (!graph)
+            continue;
+        for (const file of graph.files) {
+            if (!["source", "config", "manifest"].includes(file.kind))
+                continue;
+            if (file.size_bytes > MAX_CODE_FILE_BYTES)
+                continue;
+            const absolutePath = (0, node_path_1.join)(repoRoot, file.path);
+            if (!(0, node_fs_1.existsSync)(absolutePath))
+                continue;
+            try {
+                mentions.push(...extractWorkspaceTopicMentions(repo.alias, file.path, (0, node_fs_1.readFileSync)(absolutePath, "utf8")));
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    const producers = mentions.filter((mention) => mention.role === "producer");
+    const consumers = mentions.filter((mention) => mention.role === "consumer");
+    const contracts = [];
+    const seen = new Set();
+    for (const producer of producers) {
+        for (const consumer of consumers) {
+            if (producer.topic !== consumer.topic || producer.repo === consumer.repo)
+                continue;
+            const key = `${producer.repo}\0${producer.file}\0${consumer.repo}\0${consumer.file}\0${producer.topic}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            contracts.push({
+                topic: producer.topic,
+                producer_repo: producer.repo,
+                producer_file: producer.file,
+                consumer_repo: consumer.repo,
+                consumer_file: consumer.file,
+                confidence: /[.:/-]/.test(producer.topic) ? "high" : "medium",
+                evidence: `${producer.evidence}; ${consumer.evidence}`,
+            });
+        }
+    }
+    return contracts
+        .sort((a, b) => a.topic.localeCompare(b.topic) || a.producer_repo.localeCompare(b.producer_repo) || a.consumer_repo.localeCompare(b.consumer_repo))
+        .slice(0, 50);
+}
 function kageWorkspace(projectDir) {
     const root = (0, node_path_1.resolve)(projectDir);
     const warnings = [];
@@ -6512,6 +6602,7 @@ function kageWorkspace(projectDir) {
         return { ...rest, dependencies_on_workspace_repos: deps };
     });
     const routeContracts = workspaceRouteContracts(root, repos);
+    const topicContracts = workspaceTopicContracts(root, repos);
     if (repos.length && repos.every((repo) => !repo.indexed))
         warnings.push("Workspace repos were found, but none has .agent_memory yet. Run kage init or kage refresh in each repo you want searchable.");
     return {
@@ -6521,8 +6612,9 @@ function kageWorkspace(projectDir) {
         repos,
         package_dependencies: packageDependencies.sort((a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to)),
         route_contracts: routeContracts,
+        topic_contracts: topicContracts,
         warnings,
-        summary: `${repos.length} repo(s), ${repos.filter((repo) => repo.indexed).length} with Kage memory, ${packageDependencies.length} workspace package dependenc${packageDependencies.length === 1 ? "y" : "ies"}, ${routeContracts.length} route contract link(s).`,
+        summary: `${repos.length} repo(s), ${repos.filter((repo) => repo.indexed).length} with Kage memory, ${packageDependencies.length} workspace package dependenc${packageDependencies.length === 1 ? "y" : "ies"}, ${routeContracts.length} route contract link(s), ${topicContracts.length} topic contract link(s).`,
     };
 }
 function kageWorkspaceRecall(projectDir, query, limit = 8) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kage-core/kage-graph-mcp",
-  "version": "1.1.31",
+  "version": "1.1.32",
   "description": "Local-first repo memory, code graph, and recall MCP server for coding agents",
   "main": "dist/index.js",
   "files": [

package/viewer/app.js

@@ -2619,6 +2619,7 @@
       var repos = Array.isArray(workspace.repos) ? workspace.repos : [];
       var deps = Array.isArray(workspace.package_dependencies) ? workspace.package_dependencies : [];
       var contracts = Array.isArray(workspace.route_contracts) ? workspace.route_contracts : [];
+      var topics = Array.isArray(workspace.topic_contracts) ? workspace.topic_contracts : [];
       cards.push({
         title: "Workspace",
         kicker: "multi-repo memory",
@@ -2627,7 +2628,8 @@
           ["Repos", String(repos.length)],
           ["Indexed", String(repos.filter(function (repo) { return repo.indexed; }).length)],
           ["Package deps", String(deps.length)],
-          ["Route links", String(contracts.length)]
+          ["Route links", String(contracts.length)],
+          ["Topic links", String(topics.length)]
         ].concat(repos.slice(0, 2).map(function (repo) { return [repo.alias, repo.approved_packets + " packets, " + repo.code_files + " files"]; }))
       });
     }