@kage-core/kage-graph-mcp 1.1.28 → 1.1.30

package/README.md

@@ -37,8 +37,9 @@ Restart your agent once after setup so MCP tools reload.
 - repo-local memory for decisions, runbooks, bug fixes, gotchas, conventions,
   and code explanations
 - a code graph for files, symbols, imports, calls, routes, tests, and packages,
-  including generic call/test signals and Python framework routes for
-  non-TypeScript repos
+  including generic call/test signals and mixed-language framework routes
+- conservative cleanup candidates for unreferenced files, unused exports, and
+  internal-looking unused symbols
 - 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

package/dist/index.js

@@ -221,7 +221,7 @@ function listTools() {
         },
         {
             name: "kage_cleanup_candidates",
-            description: "Find conservative cleanup candidates from Kage's code graph. Reports unreferenced source files with confidence and reasons; never auto-deletes.",
+            description: "Find conservative cleanup candidates from Kage's code graph. Reports unreferenced source files, unused exports, and internal-looking unused symbols with confidence and reasons; never auto-deletes.",
             inputSchema: {
                 type: "object",
                 properties: {

package/dist/kernel.js

@@ -2862,6 +2862,25 @@ function parsePythonMethodList(value) {
     const methods = [...value.matchAll(/["']([A-Za-z]+)["']/g)].map((match) => match[1].toUpperCase());
     return methods.length ? unique(methods) : ["GET"];
 }
+const SPRING_ROUTE_METHODS = {
+    GetMapping: "GET",
+    PostMapping: "POST",
+    PutMapping: "PUT",
+    PatchMapping: "PATCH",
+    DeleteMapping: "DELETE",
+    RequestMapping: "ANY",
+};
+const ASPNET_ROUTE_METHODS = {
+    Get: "GET",
+    Post: "POST",
+    Put: "PUT",
+    Patch: "PATCH",
+    Delete: "DELETE",
+};
+function routeHandlerNearLine(lines, startIndex, pattern) {
+    const handlerLine = lines.slice(startIndex + 1, Math.min(lines.length, startIndex + 8)).find((candidate) => pattern.test(candidate));
+    return handlerLine?.match(pattern)?.[1] ?? null;
+}
 function extractRoutes(path, text, symbols) {
     const routes = [];
     const addRoute = (method, routePath, offset, framework, handler = null) => {
@@ -2916,6 +2935,64 @@ function extractRoutes(path, text, symbols) {
             }
         }
     }
+    if (extensionOf(path) === ".rb") {
+        for (const match of text.matchAll(/\b(get|post|put|patch|delete)\s+["']([^"']+)["']/gi)) {
+            addRoute(match[1].toUpperCase(), match[2], match.index ?? 0, "rails");
+        }
+    }
+    if (extensionOf(path) === ".php") {
+        for (const match of text.matchAll(/\bRoute::(get|post|put|patch|delete|options|any)\s*\(\s*["']([^"']+)["']/gi)) {
+            addRoute(match[1].toUpperCase(), match[2], match.index ?? 0, "laravel");
+        }
+    }
+    if ([".java", ".kt"].includes(extensionOf(path))) {
+        const lines = text.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index];
+            const mapping = line.match(/@(GetMapping|PostMapping|PutMapping|PatchMapping|DeleteMapping|RequestMapping)\s*(?:\(\s*(?:value\s*=\s*)?["']([^"']+)["'])?/);
+            if (!mapping || !mapping[2])
+                continue;
+            let method = SPRING_ROUTE_METHODS[mapping[1]] ?? "ANY";
+            if (mapping[1] === "RequestMapping") {
+                const explicit = line.match(/RequestMethod\.(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)/);
+                if (explicit)
+                    method = explicit[1];
+            }
+            const handler = routeHandlerNearLine(lines, index, /^\s*(?:public|private|protected)?\s*[\w<>\[\], ?]+\s+([A-Za-z_][\w]*)\s*\(/);
+            addRoute(method, mapping[2], offsetForLine(text, index + 1), "spring", handler);
+        }
+    }
+    if (extensionOf(path) === ".go") {
+        for (const match of text.matchAll(/\b[A-Za-z_][\w]*\.(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\s*\(\s*["`]([^"`]+)["`]\s*,\s*([A-Za-z_][\w.]*)?/g)) {
+            addRoute(match[1], match[2], match.index ?? 0, "go-router", match[3]?.split(".").pop() ?? null);
+        }
+    }
+    if (extensionOf(path) === ".rs") {
+        for (const match of text.matchAll(/\.route\s*\(\s*["']([^"']+)["']\s*,\s*(get|post|put|patch|delete|options|head)\s*\(\s*([A-Za-z_][\w:]*)?/gi)) {
+            addRoute(match[2].toUpperCase(), match[1], match.index ?? 0, "rust-router", match[3]?.split("::").pop() ?? null);
+        }
+        const lines = text.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const attr = lines[index].match(/#\[(get|post|put|patch|delete|options|head)\(\s*["']([^"']+)["']\s*\)\]/i);
+            if (!attr)
+                continue;
+            const handler = routeHandlerNearLine(lines, index, /^\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_][\w]*)\s*\(/);
+            addRoute(attr[1].toUpperCase(), attr[2], offsetForLine(text, index + 1), "rust-router", handler);
+        }
+    }
+    if (extensionOf(path) === ".cs") {
+        for (const match of text.matchAll(/\bMap(Get|Post|Put|Patch|Delete)\s*\(\s*["']([^"']+)["']\s*,\s*([A-Za-z_][\w.]*)?/g)) {
+            addRoute(ASPNET_ROUTE_METHODS[match[1]] ?? match[1].toUpperCase(), match[2], match.index ?? 0, "aspnet", match[3]?.split(".").pop() ?? null);
+        }
+        const lines = text.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const attr = lines[index].match(/\[\s*Http(Get|Post|Put|Patch|Delete)?\s*\(\s*["']([^"']+)["']\s*\)\s*\]/);
+            if (!attr)
+                continue;
+            const handler = routeHandlerNearLine(lines, index, /^\s*(?:public|private|protected|internal)?\s*(?:async\s+)?[\w<>\[\], ?]+\s+([A-Za-z_][\w]*)\s*\(/);
+            addRoute(attr[1] ? ASPNET_ROUTE_METHODS[attr[1]] ?? attr[1].toUpperCase() : "ANY", attr[2], offsetForLine(text, index + 1), "aspnet", handler);
+        }
+    }
     if (/app\/api\//.test(path)) {
         for (const symbol of symbols.filter((symbol) => symbol.path === path && symbol.export && ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(symbol.name))) {
             const apiPath = `/${path.replace(/^.*app\/api\//, "").replace(/\/route\.[cm]?[jt]sx?$/, "").replace(/\[([^\]]+)\]/g, ":$1")}`;
@@ -5424,6 +5501,26 @@ function hasRuntimePathReference(projectDir, graph, target) {
     }
     return false;
 }
+function cleanupSymbolKind(symbol) {
+    return ["function", "method", "class", "constant"].includes(symbol.kind);
+}
+function symbolCleanupCandidate(symbol, kind, reasons, score, coveredByTests, git) {
+    return {
+        path: symbol.path,
+        kind,
+        symbol_id: symbol.id,
+        symbol_name: symbol.name,
+        line: symbol.line,
+        confidence: cleanupConfidence(score),
+        score,
+        reasons,
+        inbound_imports: 0,
+        source_inbound_imports: 0,
+        outbound_imports: 0,
+        covered_by_tests: coveredByTests,
+        last_commit_at: git?.last_commit_at ?? null,
+    };
+}
 function kageCleanupCandidates(projectDir) {
     const graph = readCurrentCodeGraph(projectDir) ?? buildCodeGraph(projectDir);
     const fileByPath = new Map(graph.files.map((file) => [file.path, file]));
@@ -5448,6 +5545,7 @@ function kageCleanupCandidates(projectDir) {
         warnings.push("Git history is unavailable, so cleanup confidence does not use recency.");
     const candidates = [];
     const skippedRuntimeReferences = [];
+    const wholeFileCandidates = new Set();
     for (const file of graph.files) {
         if (file.kind !== "source")
             continue;
@@ -5500,6 +5598,60 @@ function kageCleanupCandidates(projectDir) {
             covered_by_tests: coveredByTests,
             last_commit_at: git?.last_commit_at ?? null,
         });
+        wholeFileCandidates.add(file.path);
+    }
+    const calledSymbols = new Set(graph.calls.map((call) => call.to_symbol));
+    const routeHandlers = new Set(graph.routes.map((route) => route.handler_symbol).filter((value) => Boolean(value)));
+    const coveredSymbolNames = new Set(graph.tests.map((test) => test.covers_symbol?.toLowerCase()).filter((value) => Boolean(value)));
+    const symbolsByPath = new Map();
+    for (const symbol of graph.symbols.filter(cleanupSymbolKind)) {
+        const list = symbolsByPath.get(symbol.path) ?? [];
+        list.push(symbol);
+        symbolsByPath.set(symbol.path, list);
+    }
+    const importedNamesByPath = new Map();
+    for (const edge of graph.imports) {
+        if (!edge.to_path || !edge.imported.length)
+            continue;
+        const names = importedNamesByPath.get(edge.to_path) ?? new Set();
+        for (const name of edge.imported)
+            names.add(name);
+        importedNamesByPath.set(edge.to_path, names);
+    }
+    for (const file of graph.files) {
+        if (file.kind !== "source" || wholeFileCandidates.has(file.path))
+            continue;
+        if (isEntrypointLike(file.path) || routeFiles.has(file.path))
+            continue;
+        const fileSymbols = symbolsByPath.get(file.path) ?? [];
+        if (!fileSymbols.length)
+            continue;
+        const git = hasGit ? gitFileSignal(projectDir, file.path, graphPaths) : null;
+        const coveredByTests = hasTestCoverage(file.path, graph);
+        const importedNames = importedNamesByPath.get(file.path) ?? new Set();
+        const exportedSymbols = fileSymbols.filter((symbol) => symbol.export);
+        const hasMatchedNamedExport = exportedSymbols.some((symbol) => importedNames.has(symbol.name));
+        for (const symbol of fileSymbols) {
+            const symbolReferenced = calledSymbols.has(symbol.id) || routeHandlers.has(symbol.id) || coveredSymbolNames.has(symbol.name.toLowerCase());
+            if (symbolReferenced)
+                continue;
+            if (symbol.export) {
+                if (!hasMatchedNamedExport || importedNames.has(symbol.name))
+                    continue;
+                candidates.push(symbolCleanupCandidate(symbol, "unused_export", [
+                    `export "${symbol.name}" is not imported by current named import edges`,
+                    "symbol is not a known call target, route handler, or covered test target",
+                    "file has at least one other exported symbol imported by name",
+                ], 0.62, coveredByTests, git));
+            }
+            else if (/^_[A-Za-z0-9_]+/.test(symbol.name)) {
+                candidates.push(symbolCleanupCandidate(symbol, "unused_internal_symbol", [
+                    `internal-looking symbol "${symbol.name}" has no known call edge`,
+                    "symbol is not a route handler or covered test target",
+                    "candidate is review input only; dynamic references may exist",
+                ], 0.5, coveredByTests, git));
+            }
+        }
     }
     candidates.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
     return {

package/package.json

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