grepmax 0.17.11 → 0.17.12

package/dist/commands/mcp.js

@@ -257,6 +257,65 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: "get_neighbors",
+        description: "Graph primitive: symbols reachable from a node along call edges within N hops. direction 'callees' = what it calls (outbound), 'callers' = what calls it (inbound). Each result carries its hop distance and definition location. Static call graph — same caveats as `dead`/`audit`.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                symbol: { type: "string", description: "Starting symbol" },
+                direction: {
+                    type: "string",
+                    enum: ["callers", "callees"],
+                    description: "Edge direction (default callees)",
+                },
+                max_hops: {
+                    type: "number",
+                    description: "Max hops (default 2, max 5)",
+                },
+                root: { type: "string", description: "Project root (absolute path)" },
+            },
+            required: ["symbol"],
+        },
+    },
+    {
+        name: "find_paths",
+        description: "Graph primitive: shortest call-graph path between two symbols, as a symbol sequence. direction 'callees' searches outward from `from` (does `from` transitively call `to`?), 'callers' searches inward. Returns 'no path' if unreachable within max_hops.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                from: { type: "string", description: "Start symbol" },
+                to: { type: "string", description: "Target symbol" },
+                direction: {
+                    type: "string",
+                    enum: ["callers", "callees"],
+                    description: "Search direction (default callees)",
+                },
+                max_hops: {
+                    type: "number",
+                    description: "Max hops (default 6, max 10)",
+                },
+                root: { type: "string", description: "Project root (absolute path)" },
+            },
+            required: ["from", "to"],
+        },
+    },
+    {
+        name: "subgraph_for_files",
+        description: "Graph primitive: the local dependency subgraph for a set of files — symbols they define, the call edges among those symbols, and their outbound external dependencies. Paths may be absolute or project-root-relative.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                files: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "File paths (absolute or root-relative)",
+                },
+                root: { type: "string", description: "Project root (absolute path)" },
+            },
+            required: ["files"],
+        },
+    },
     {
         name: "list_symbols",
         description: "List indexed symbols with role and export status.",
@@ -1425,6 +1484,112 @@ exports.mcp = new commander_1.Command("mcp")
             }
         });
     }
+    function handleGetNeighbors(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const symbol = String(args.symbol || "");
+            if (!symbol)
+                return err("Missing required parameter: symbol");
+            const direction = args.direction === "callers" ? "callers" : "callees";
+            const maxHops = Math.min(Math.max(Number(args.max_hops) || 2, 1), 5);
+            try {
+                const root = typeof args.root === "string" && args.root ? args.root : projectRoot;
+                const builder = new graph_builder_1.GraphBuilder(getVectorDb(), root);
+                const hits = yield builder.getNeighbors(symbol, direction, maxHops);
+                if (hits.length === 0) {
+                    return ok(`No ${direction} found for '${symbol}' within ${maxHops} hop(s). Check it is indexed (\`gmax status\`) or try the \`dead\` tool.`);
+                }
+                const rel = (p) => p.startsWith(root) ? p.slice(root.length + 1) : p;
+                const lines = [
+                    `${direction} of ${symbol} (≤${maxHops} hops, ${hits.length} found):`,
+                ];
+                for (const h of hits.slice(0, 100)) {
+                    const loc = h.file ? ` ${rel(h.file)}:${h.line + 1}` : " (external)";
+                    lines.push(`  [${h.hops}h] ${h.symbol}${loc}`);
+                }
+                if (hits.length > 100)
+                    lines.push(`  … and ${hits.length - 100} more`);
+                return ok(lines.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`get_neighbors failed: ${msg}`);
+            }
+        });
+    }
+    function handleFindPaths(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const from = String(args.from || "");
+            const to = String(args.to || "");
+            if (!from || !to) {
+                return err("Missing required parameters: from and to");
+            }
+            const direction = args.direction === "callers" ? "callers" : "callees";
+            const maxHops = Math.min(Math.max(Number(args.max_hops) || 6, 1), 10);
+            try {
+                const root = typeof args.root === "string" && args.root ? args.root : projectRoot;
+                const builder = new graph_builder_1.GraphBuilder(getVectorDb(), root);
+                const pathSyms = yield builder.findPaths(from, to, direction, maxHops);
+                if (!pathSyms) {
+                    return ok(`No ${direction} path from '${from}' to '${to}' within ${maxHops} hops.`);
+                }
+                const arrow = direction === "callees" ? " → " : " ← ";
+                const hops = pathSyms.length - 1;
+                return ok(`Path (${hops} hop${hops === 1 ? "" : "s"}): ${pathSyms.join(arrow)}`);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`find_paths failed: ${msg}`);
+            }
+        });
+    }
+    function handleSubgraphForFiles(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const filesIn = Array.isArray(args.files)
+                ? args.files.map((f) => String(f)).filter(Boolean)
+                : [];
+            if (filesIn.length === 0) {
+                return err("Missing required parameter: files (non-empty array)");
+            }
+            try {
+                const root = typeof args.root === "string" && args.root ? args.root : projectRoot;
+                const abs = filesIn.map((f) => path.isAbsolute(f) ? f : path.resolve(root, f));
+                const builder = new graph_builder_1.GraphBuilder(getVectorDb(), root);
+                const sg = yield builder.subgraphForFiles(abs);
+                if (sg.symbols.length === 0) {
+                    return ok(`No indexed symbols found in: ${filesIn.join(", ")}. Check the paths and \`gmax status\`.`);
+                }
+                const rel = (p) => p.startsWith(root) ? p.slice(root.length + 1) : p;
+                const cap = (arr, n) => arr.length > n
+                    ? `${arr.slice(0, n).join(", ")} … (+${arr.length - n})`
+                    : arr.join(", ");
+                const lines = [];
+                lines.push(`Subgraph for ${sg.files.length} file(s): ${sg.symbols.length} symbols, ${sg.internalEdges.length} internal edges, ${sg.externalDeps.length} external deps`);
+                lines.push(`Files: ${sg.files.map(rel).join(", ")}`);
+                lines.push("");
+                lines.push(`Symbols: ${cap(sg.symbols, 50)}`);
+                lines.push("");
+                lines.push("Internal edges:");
+                for (const e of sg.internalEdges.slice(0, 80)) {
+                    lines.push(`  ${e.from} → ${e.to}`);
+                }
+                if (sg.internalEdges.length === 0)
+                    lines.push("  none");
+                if (sg.internalEdges.length > 80) {
+                    lines.push(`  … and ${sg.internalEdges.length - 80} more`);
+                }
+                lines.push("");
+                lines.push(`External deps: ${cap(sg.externalDeps, 50) || "none"}`);
+                return ok(lines.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`subgraph_for_files failed: ${msg}`);
+            }
+        });
+    }
     function handleListSymbols(args) {
         return __awaiter(this, void 0, void 0, function* () {
             ensureWatcher();
@@ -2170,6 +2335,15 @@ exports.mcp = new commander_1.Command("mcp")
             case "audit":
                 result = yield handleAudit(toolArgs);
                 break;
+            case "get_neighbors":
+                result = yield handleGetNeighbors(toolArgs);
+                break;
+            case "find_paths":
+                result = yield handleFindPaths(toolArgs);
+                break;
+            case "subgraph_for_files":
+                result = yield handleSubgraphForFiles(toolArgs);
+                break;
             case "list_symbols":
                 result = yield handleListSymbols(toolArgs);
                 break;

package/dist/lib/graph/graph-builder.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphBuilder = void 0;
 const filter_builder_1 = require("../utils/filter-builder");
+const graph_traversal_1 = require("./graph-traversal");
 class GraphBuilder {
     constructor(db, pathPrefix, excludePrefixes) {
         this.db = db;
@@ -185,6 +186,102 @@ class GraphBuilder {
             return trees;
         });
     }
+    // --- MCP graph primitives (Phase 7) -----------------------------------
+    /** Symbols the given symbol references (outbound edges). */
+    calleesOf(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getCallees(symbol);
+        });
+    }
+    /** Distinct symbols that reference the given symbol (inbound edges). */
+    callersOf(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodes = yield this.getCallers(symbol);
+            const out = [];
+            for (const n of nodes) {
+                if (n.symbol && n.symbol !== "unknown" && !out.includes(n.symbol)) {
+                    out.push(n.symbol);
+                }
+            }
+            return out;
+        });
+    }
+    neighborFn(direction) {
+        return direction === "callers"
+            ? (s) => this.callersOf(s)
+            : (s) => this.calleesOf(s);
+    }
+    /**
+     * Symbols reachable from `symbol` along `direction` within `maxHops`, each
+     * annotated with hop distance and resolved to a definition location when one
+     * is indexed.
+     */
+    getNeighbors(symbol, direction, maxHops) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const hits = yield (0, graph_traversal_1.bfsNeighbors)(symbol, this.neighborFn(direction), maxHops);
+            const out = [];
+            for (const h of hits) {
+                const loc = yield this.resolveLocation(h.symbol);
+                out.push(Object.assign(Object.assign({}, h), { file: (_a = loc === null || loc === void 0 ? void 0 : loc.file) !== null && _a !== void 0 ? _a : "", line: (_b = loc === null || loc === void 0 ? void 0 : loc.line) !== null && _b !== void 0 ? _b : 0 }));
+            }
+            return out;
+        });
+    }
+    /** Shortest path `[from, …, to]` along `direction`, or null. */
+    findPaths(from_1, to_1, direction_1) {
+        return __awaiter(this, arguments, void 0, function* (from, to, direction, maxHops = 6) {
+            return (0, graph_traversal_1.findPath)(from, to, this.neighborFn(direction), maxHops);
+        });
+    }
+    /** Resolve a symbol to its first defining chunk's file:line, if indexed. */
+    resolveLocation(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const table = yield this.db.ensureTable();
+            const escaped = (0, filter_builder_1.escapeSqlString)(symbol);
+            const rows = yield table
+                .query()
+                .select(["path", "start_line"])
+                .where(this.scopeWhere(`array_contains(defined_symbols, '${escaped}')`))
+                .limit(1)
+                .toArray();
+            if (rows.length === 0)
+                return null;
+            const r = rows[0];
+            return { file: String(r.path || ""), line: Number(r.start_line || 0) };
+        });
+    }
+    /**
+     * Build the local dependency subgraph for a set of files: every symbol they
+     * define, the edges among those symbols, and their outbound external deps.
+     */
+    subgraphForFiles(files) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (files.length === 0) {
+                return { files: [], symbols: [], internalEdges: [], externalDeps: [] };
+            }
+            const table = yield this.db.ensureTable();
+            const orClause = files
+                .map((f) => `path = '${(0, filter_builder_1.escapeSqlString)(f)}'`)
+                .join(" OR ");
+            const rows = yield table
+                .query()
+                .select(["path", "defined_symbols", "referenced_symbols"])
+                .where(this.scopeWhere(`(${orClause})`))
+                .limit(100000)
+                .toArray();
+            const toArray = (val) => {
+                if (val && typeof val.toArray === "function")
+                    return val.toArray();
+                return Array.isArray(val) ? val : [];
+            };
+            return (0, graph_traversal_1.buildFileSubgraph)(rows.map((r) => ({
+                path: String(r.path || ""),
+                defined_symbols: toArray(r.defined_symbols),
+                referenced_symbols: toArray(r.referenced_symbols),
+            })));
+        });
+    }
     mapRowToNode(row, targetSymbol, type) {
         // Helper to convert Arrow Vector to array if needed
         const toArray = (val) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.11",
+  "version": "0.17.12",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -37,7 +37,7 @@
     "prepublishOnly": "pnpm build",
     "preversion": "pnpm test && pnpm typecheck",
     "version": "bash scripts/sync-versions.sh && git add -A",
-    "postversion": "git push origin main && git push origin v$npm_package_version && gh release create v$npm_package_version --generate-notes --title v$npm_package_version && sleep 5 && gh run watch $(gh run list --workflow=release.yml --branch v$npm_package_version --limit 1 --json databaseId --jq '.[0].databaseId') --exit-status && sleep 30 && npm cache clean --force && npm install -g grepmax@$npm_package_version"
+    "postversion": "bash scripts/postrelease.sh"
   },
   "keywords": [
     "grepmax",

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.17.11",
+  "version": "0.17.12",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",