grepmax 0.7.15 → 0.7.17

package/dist/commands/mcp.js

@@ -212,6 +212,10 @@ const TOOLS = [
                     type: "number",
                     description: "Max files for directory mode (default 10, max 20). Ignored for single files.",
                 },
+                format: {
+                    type: "string",
+                    description: "Output format: 'text' (default) or 'json' (structured symbol list with names, lines, signatures).",
+                },
             },
             required: ["target"],
         },
@@ -821,13 +825,16 @@ exports.mcp = new commander_1.Command("mcp")
                     targets = [target];
                 }
             }
+            const fmt = typeof args.format === "string" ? args.format : "text";
             // Generate skeletons for all targets
             const parts = [];
+            const jsonFiles = [];
             const skel = yield getSkeletonizer();
             for (const t of targets) {
                 const absPath = path.resolve(projectRoot, t);
                 if (!fs.existsSync(absPath)) {
-                    parts.push(`// ${t} — file not found`);
+                    if (fmt !== "json")
+                        parts.push(`// ${t} — file not found`);
                     continue;
                 }
                 // Read source for line annotations
@@ -836,39 +843,93 @@ exports.mcp = new commander_1.Command("mcp")
                     sourceContent = fs.readFileSync(absPath, "utf-8");
                 }
                 catch (_a) { }
+                let skeleton = "";
+                let language = "";
+                let tokenEstimate = 0;
                 // Try cached skeleton first
                 try {
                     const db = getVectorDb();
                     const cached = yield (0, retriever_1.getStoredSkeleton)(db, absPath);
                     if (cached) {
-                        const tokens = Math.ceil(cached.length / 4);
-                        const annotated = sourceContent
-                            ? annotateSkeletonLines(cached, sourceContent)
-                            : cached;
-                        parts.push(`// ${t} (~${tokens} tokens)\n\n${annotated}`);
-                        continue;
+                        skeleton = cached;
+                        tokenEstimate = Math.ceil(cached.length / 4);
                     }
                 }
-                catch (_b) {
-                    // Index may not exist yet — fall through to live generation
-                }
-                // Generate live
-                try {
-                    const content = sourceContent || fs.readFileSync(absPath, "utf-8");
-                    const result = yield skel.skeletonizeFile(absPath, content);
-                    if (result.success) {
-                        const annotated = annotateSkeletonLines(result.skeleton, content);
-                        parts.push(`// ${t} (~${result.tokenEstimate} tokens)\n\n${annotated}`);
+                catch (_b) { }
+                // Generate live if no cache
+                if (!skeleton) {
+                    try {
+                        const content = sourceContent || fs.readFileSync(absPath, "utf-8");
+                        const result = yield skel.skeletonizeFile(absPath, content);
+                        if (result.success) {
+                            skeleton = result.skeleton;
+                            tokenEstimate = result.tokenEstimate;
+                            language = result.language;
+                        }
+                        else {
+                            if (fmt !== "json")
+                                parts.push(`// ${t} — skeleton failed: ${result.error}`);
+                            continue;
+                        }
                     }
-                    else {
-                        parts.push(`// ${t} — skeleton failed: ${result.error}`);
+                    catch (e) {
+                        const msg = e instanceof Error ? e.message : String(e);
+                        if (fmt !== "json")
+                            parts.push(`// ${t} — error: ${msg}`);
+                        continue;
                     }
                 }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    parts.push(`// ${t} — error: ${msg}`);
+                if (fmt === "json") {
+                    // Extract structured symbols from annotated skeleton
+                    const annotated = sourceContent
+                        ? annotateSkeletonLines(skeleton, sourceContent)
+                        : skeleton;
+                    const symbols = annotated
+                        .split("\n")
+                        .filter((l) => /^\s*\d+│/.test(l))
+                        .map((l) => {
+                        var _a, _b, _c;
+                        const m = l.match(/^\s*(\d+)│(.+)/);
+                        if (!m)
+                            return null;
+                        const line = Number.parseInt(m[1], 10);
+                        const sig = m[2].trim();
+                        const exported = sig.includes("export ");
+                        const type = ((_a = sig.match(/\b(class|interface|type|function|def|fn|func)\b/)) === null || _a === void 0 ? void 0 : _a[1]) || "other";
+                        const name = ((_b = sig.match(/(?:function|class|interface|type|def|fn|func)\s+(\w+)/)) === null || _b === void 0 ? void 0 : _b[1]) ||
+                            ((_c = sig.match(/^(?:async\s+)?(\w+)\s*[(<]/)) === null || _c === void 0 ? void 0 : _c[1]) ||
+                            "unknown";
+                        return {
+                            name,
+                            line,
+                            signature: sig
+                                .replace(/\s*\{?\s*\/\/.*$/, "")
+                                .trim(),
+                            type,
+                            exported,
+                        };
+                    })
+                        .filter((s) => s !== null && s.name !== "unknown");
+                    jsonFiles.push({
+                        file: t,
+                        language: language || path.extname(t).slice(1),
+                        tokenEstimate,
+                        symbols,
+                    });
+                }
+                else {
+                    const annotated = sourceContent
+                        ? annotateSkeletonLines(skeleton, sourceContent)
+                        : skeleton;
+                    parts.push(`// ${t} (~${tokenEstimate} tokens)\n\n${annotated}`);
                 }
             }
+            if (fmt === "json") {
+                const output = jsonFiles.length === 1
+                    ? jsonFiles[0]
+                    : { files: jsonFiles };
+                return ok(JSON.stringify(output, null, 2));
+            }
             return ok(parts.join("\n\n---\n\n"));
         });
     }
@@ -891,6 +952,21 @@ exports.mcp = new commander_1.Command("mcp")
                 const lines = [];
                 // Center
                 lines.push(`${graph.center.symbol} [${graph.center.role}] ${graph.center.file}:${graph.center.line + 1}`);
+                // Importers
+                if (graph.importers.length > 0) {
+                    // Filter out the file where the symbol is defined
+                    const centerFile = graph.center.file;
+                    const filteredImporters = graph.importers.filter((p) => p !== centerFile);
+                    if (filteredImporters.length > 0) {
+                        lines.push("Imported by:");
+                        for (const imp of filteredImporters.slice(0, 10)) {
+                            const rel = imp.startsWith(projectRoot)
+                                ? imp.slice(projectRoot.length + 1)
+                                : imp;
+                            lines.push(`  ${rel}`);
+                        }
+                    }
+                }
                 // Callers (recursive tree)
                 function formatCallerTree(trees, indent) {
                     for (const t of trees) {

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

@@ -105,19 +105,40 @@ class GraphBuilder {
             return { center, callers, callees: calleeNodes };
         });
     }
+    getImporters(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"])
+                .where(`content LIKE '%import%${escaped}%'`)
+                .limit(100)
+                .toArray();
+            const files = new Set();
+            for (const row of rows) {
+                files.add(String(row.path || ""));
+            }
+            return Array.from(files);
+        });
+    }
     buildGraphMultiHop(symbol, depth) {
         return __awaiter(this, void 0, void 0, function* () {
-            const graph = yield this.buildGraph(symbol);
+            const [graph, importers] = yield Promise.all([
+                this.buildGraph(symbol),
+                this.getImporters(symbol),
+            ]);
             if (depth <= 1 || !graph.center) {
                 return {
                     center: graph.center,
                     callerTree: graph.callers.map((c) => ({ node: c, callers: [] })),
                     callees: graph.callees,
+                    importers,
                 };
             }
             const visited = new Set([symbol]);
             const callerTree = yield this.expandCallers(graph.callers, depth - 1, visited);
-            return { center: graph.center, callerTree, callees: graph.callees };
+            return { center: graph.center, callerTree, callees: graph.callees, importers };
         });
     }
     expandCallers(callers, remainingDepth, visited) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.7.15",
+  "version": "0.7.17",
   "author": "Robert Owens <robowens@me.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

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

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

package/plugins/grepmax/skills/grepmax/SKILL.md

@@ -67,12 +67,15 @@ Use sparingly. Prefer `semantic_search` when you know which directory to search.
 File or directory structure — signatures with bodies collapsed (~4x fewer tokens).
 - `target` (required): File path, directory path (e.g. "src/lib/search/"), or comma-separated files
 - `limit` (optional): Max files for directory mode (default 10, max 20)
+- `format` (optional): `"text"` (default) or `"json"` (structured symbol list with name, line, signature, type, exported)
 
 ### trace_calls
-Call graph — who calls a symbol and what it calls. Callers and callees include file:line locations. Unscoped — follows calls across all indexed directories.
+Call graph — who imports a symbol, who calls it, and what it calls. Includes file:line locations. Unscoped — follows calls across all indexed directories.
 - `symbol` (required): Function/method/class name
 - `depth` (optional): Traversal depth for callers (default 1, max 3). depth: 2 shows callers-of-callers with indentation.
 
+Output: definition, "Imported by" (files with import statements), "Callers" (functions that call it), "Calls" (what it calls).
+
 ### list_symbols
 List indexed symbols with definition locations, role, and export status.
 - `pattern` (optional): Filter by name (case-insensitive substring match)