grepmax 0.13.5 → 0.13.6

package/dist/commands/investigate.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigateCmd = void 0;
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+exports.investigateCmd = new commander_1.Command("investigate")
+    .description("Ask a question about the codebase using local LLM + gmax tools")
+    .argument("<question>", "Natural language question about the codebase")
+    .option("--root <dir>", "Project root directory")
+    .option("--rounds <n>", "Max tool-call rounds (default 10)", "10")
+    .option("-v, --verbose", "Print tool calls and results to stderr", false)
+    .addHelpText("after", `
+Examples:
+  gmax investigate "how does the search command work?"
+  gmax investigate "what would break if I changed VectorDB?" -v
+  gmax investigate "where is authentication handled?" --root ~/project
+`)
+    .action((question, opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const root = opts.root ? path.resolve(opts.root) : process.cwd();
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const maxRounds = Math.min(Math.max(Number.parseInt(opts.rounds || "10", 10), 1), 20);
+        // Ensure LLM server is running
+        const { ensureDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+        if (!(yield ensureDaemonRunning())) {
+            console.error("Failed to start daemon");
+            process.exitCode = 1;
+            return;
+        }
+        const llmResp = yield sendDaemonCommand({ cmd: "llm-start" }, { timeoutMs: 90000 });
+        if (!llmResp.ok) {
+            console.error(`LLM server error: ${llmResp.error}`);
+            console.error("Run `gmax llm on` to enable the LLM server.");
+            process.exitCode = 1;
+            return;
+        }
+        const { investigate } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/investigate")));
+        const result = yield investigate({
+            question,
+            projectRoot,
+            maxRounds,
+            verbose: opts.verbose,
+        });
+        console.log(result.answer);
+        if (opts.verbose) {
+            process.stderr.write("\n--- metrics ---\n");
+            process.stderr.write(`rounds:     ${result.rounds}\n`);
+            process.stderr.write(`tool calls: ${result.toolCalls}\n`);
+            process.stderr.write(`wall time:  ${(result.wallMs / 1000).toFixed(1)}s\n`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Investigate failed: ${msg}`);
+        process.exitCode = 1;
+    }
+    finally {
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/commands/mcp.js

@@ -293,6 +293,18 @@ const TOOLS = [
             required: ["topic"],
         },
     },
+    {
+        name: "investigate",
+        description: "Agentic codebase Q&A: a local LLM answers questions using search, trace, peek, impact, and related tools. Requires LLM to be enabled (gmax llm on).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                question: { type: "string", description: "Natural language question about the codebase" },
+                max_rounds: { type: "number", description: "Max tool-call rounds (default 10)" },
+            },
+            required: ["question"],
+        },
+    },
 ];
 // ---------------------------------------------------------------------------
 // Helpers
@@ -1878,6 +1890,35 @@ exports.mcp = new commander_1.Command("mcp")
             case "build_context":
                 result = yield handleBuildContext(toolArgs);
                 break;
+            case "investigate": {
+                const question = String(toolArgs.question || "");
+                if (!question) {
+                    result = err("Missing required parameter: question");
+                    break;
+                }
+                const maxRounds = Math.min(Math.max(Number(toolArgs.max_rounds) || 10, 1), 15);
+                try {
+                    const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+                    if (yield isDaemonRunning()) {
+                        const llmResp = yield sendDaemonCommand({ cmd: "llm-start" }, { timeoutMs: 90000 });
+                        if (!llmResp.ok) {
+                            result = err(`LLM server not available: ${llmResp.error}. Run \`gmax llm on && gmax llm start\`.`);
+                            break;
+                        }
+                    }
+                    else {
+                        result = err("LLM server not available. Run `gmax llm on && gmax llm start`.");
+                        break;
+                    }
+                    const { investigate } = yield Promise.resolve().then(() => __importStar(require("../lib/llm/investigate")));
+                    const inv = yield investigate({ question, projectRoot, maxRounds });
+                    result = ok(inv.answer);
+                }
+                catch (e) {
+                    result = err(`Investigate failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                break;
+            }
             default:
                 return err(`Unknown tool: ${name}`);
         }

package/dist/index.js

@@ -49,6 +49,7 @@ const extract_1 = require("./commands/extract");
 const impact_1 = require("./commands/impact");
 const droid_1 = require("./commands/droid");
 const index_1 = require("./commands/index");
+const investigate_1 = require("./commands/investigate");
 const list_1 = require("./commands/list");
 const llm_1 = require("./commands/llm");
 const mcp_1 = require("./commands/mcp");
@@ -112,6 +113,7 @@ commander_1.program.addCommand(watch_1.watch);
 commander_1.program.addCommand(mcp_1.mcp);
 commander_1.program.addCommand(summarize_1.summarize);
 commander_1.program.addCommand(llm_1.llm);
+commander_1.program.addCommand(investigate_1.investigateCmd);
 // Setup & diagnostics
 commander_1.program.addCommand(setup_1.setup);
 commander_1.program.addCommand(config_1.config);

package/dist/lib/llm/investigate.js

@@ -0,0 +1,212 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.investigate = investigate;
+const path = __importStar(require("node:path"));
+const openai_1 = __importDefault(require("openai"));
+const graph_builder_1 = require("../graph/graph-builder");
+const searcher_1 = require("../search/searcher");
+const vector_db_1 = require("../store/vector-db");
+const project_root_1 = require("../utils/project-root");
+const config_1 = require("./config");
+const prompts_1 = require("./prompts");
+const tools_1 = require("./tools");
+function stripThinkTags(text) {
+    return text
+        .replace(/<think(?:ing)?>[\s\S]*?<\/think(?:ing)?>/g, "")
+        .trim();
+}
+function investigate(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const { question, projectRoot, verbose = false } = opts;
+        const maxRounds = (_a = opts.maxRounds) !== null && _a !== void 0 ? _a : prompts_1.MAX_ROUNDS;
+        const config = (0, config_1.getLlmConfig)();
+        const modelName = path.basename(config.model, path.extname(config.model));
+        const client = new openai_1.default({
+            baseURL: `http://${config.host}:${config.port}/v1`,
+            apiKey: "local",
+        });
+        // Health check
+        try {
+            yield client.models.list();
+        }
+        catch (_d) {
+            throw new Error("Cannot connect to LLM server. Run `gmax llm on && gmax llm start`.");
+        }
+        // Initialize gmax resources
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        const vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const searcher = new searcher_1.Searcher(vectorDb);
+        const graphBuilder = new graph_builder_1.GraphBuilder(vectorDb, projectRoot);
+        const ctx = { vectorDb, searcher, graphBuilder, projectRoot };
+        const messages = [
+            { role: "system", content: prompts_1.SYSTEM_PROMPT },
+            { role: "user", content: question },
+        ];
+        const wallStart = Date.now();
+        let searchCount = 0;
+        let totalToolCalls = 0;
+        let rounds = 0;
+        try {
+            for (let round = 0; round < maxRounds; round++) {
+                rounds = round + 1;
+                const roundStart = Date.now();
+                const response = yield client.chat.completions.create({
+                    model: modelName,
+                    messages,
+                    tools: tools_1.TOOLS,
+                    tool_choice: "auto",
+                    temperature: 0,
+                });
+                if (!((_b = response.choices) === null || _b === void 0 ? void 0 : _b.length)) {
+                    throw new Error("LLM returned empty response");
+                }
+                const message = response.choices[0].message;
+                const roundMs = Date.now() - roundStart;
+                // No tool calls — final answer
+                if (!message.tool_calls || message.tool_calls.length === 0) {
+                    if (verbose) {
+                        process.stderr.write(`[R${round}] Final answer (${roundMs}ms)\n`);
+                    }
+                    const answer = message.content
+                        ? stripThinkTags(message.content)
+                        : "(no response)";
+                    return {
+                        answer,
+                        rounds,
+                        toolCalls: totalToolCalls,
+                        wallMs: Date.now() - wallStart,
+                    };
+                }
+                if (verbose) {
+                    process.stderr.write(`[R${round}] ${roundMs}ms — ${message.tool_calls.length} tool call(s)\n`);
+                    if (message.content) {
+                        const reasoning = stripThinkTags(message.content);
+                        if (reasoning) {
+                            process.stderr.write(`  (reasoning) ${reasoning}\n`);
+                        }
+                    }
+                }
+                // Append assistant message (required before tool results)
+                messages.push(message);
+                // Execute each tool call
+                for (const tc of message.tool_calls) {
+                    // Only handle function-type tool calls
+                    if (tc.type !== "function")
+                        continue;
+                    const fn = tc.function;
+                    totalToolCalls++;
+                    let result;
+                    let args;
+                    try {
+                        args = JSON.parse(fn.arguments);
+                    }
+                    catch (_e) {
+                        args = {};
+                        result = `(error: malformed arguments: ${fn.arguments})`;
+                        messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+                        continue;
+                    }
+                    // Search count limit
+                    if (fn.name === "search") {
+                        searchCount++;
+                        if (searchCount > prompts_1.MAX_SEARCHES) {
+                            result = (0, prompts_1.searchLimitMessage)(prompts_1.MAX_SEARCHES);
+                            if (verbose) {
+                                process.stderr.write(`  ${fn.name}() — BLOCKED (limit)\n`);
+                            }
+                            messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+                            continue;
+                        }
+                    }
+                    if (verbose) {
+                        const argsStr = JSON.stringify(args);
+                        process.stderr.write(`  ${fn.name}(${argsStr})\n`);
+                    }
+                    result = yield (0, tools_1.executeTool)(fn.name, args, ctx);
+                    if (verbose) {
+                        const preview = result.split("\n").slice(0, 5).join("\n");
+                        const extra = result.split("\n").length - 5;
+                        for (const line of preview.split("\n")) {
+                            process.stderr.write(`    ${line}\n`);
+                        }
+                        if (extra > 0) {
+                            process.stderr.write(`    ... (${extra} more lines)\n`);
+                        }
+                    }
+                    messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+                }
+            }
+            // Round cap — force final answer
+            if (verbose) {
+                process.stderr.write(`[R${maxRounds}] Round cap reached, forcing final answer\n`);
+            }
+            messages.push({ role: "user", content: prompts_1.FORCE_FINAL_MESSAGE });
+            const response = yield client.chat.completions.create({
+                model: modelName,
+                messages,
+                temperature: 0,
+            });
+            if (!((_c = response.choices) === null || _c === void 0 ? void 0 : _c.length)) {
+                throw new Error("LLM returned empty response");
+            }
+            const answer = response.choices[0].message.content
+                ? stripThinkTags(response.choices[0].message.content)
+                : "(no response)";
+            return {
+                answer,
+                rounds: rounds + 1,
+                toolCalls: totalToolCalls,
+                wallMs: Date.now() - wallStart,
+            };
+        }
+        finally {
+            yield vectorDb.close();
+        }
+    });
+}

package/dist/lib/llm/prompts.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORCE_FINAL_MESSAGE = exports.SYSTEM_PROMPT = exports.MAX_SEARCHES = exports.MAX_ROUNDS = void 0;
+exports.searchLimitMessage = searchLimitMessage;
+exports.MAX_ROUNDS = 10;
+exports.MAX_SEARCHES = 3;
+exports.SYSTEM_PROMPT = `\
+You are a code investigation agent. You answer questions about codebases by \
+using tools to gather evidence, then synthesizing a clear answer.
+
+Tools (use the right tool for the job):
+- search: Find symbols and files by meaning. Use short, specific queries (e.g. "search handler" not "find the function that handles search requests"). Returns filepath:line symbol [ROLE] — snippet.
+- peek: BEST FIRST TOOL after finding a symbol. Shows signature + callers + callees in one call. Use this to understand a symbol quickly.
+- trace: Full call graph — all callers and callees with locations. Use when peek isn't detailed enough.
+- impact: What depends on this symbol/file? Use when the question is about change effects or breakage.
+- related: Files coupled by shared symbols. Use when the question is about file relationships.
+
+Strategy:
+1. Search once or twice to find the right symbol names and file locations.
+2. IMMEDIATELY switch to peek/trace/impact once you have a symbol name. Do NOT keep searching for the same thing with different queries.
+3. Use impact when the question involves "what would break" or "what depends on".
+4. Answer as soon as you have enough evidence. You do not need to use all rounds.
+
+Rules:
+- Never call search more than 3 times total. After 2 searches you should have symbol names — use peek/trace/impact from there.
+- If a tool returns "(not found)" or "(no results)", try a slightly different symbol name, not a longer description.
+- Cite specific files, line numbers, and symbol names in your answer.
+- If you cannot find the answer, say so. Do not hallucinate.
+- Be concise — 2-5 paragraphs maximum.`;
+exports.FORCE_FINAL_MESSAGE = "You have used all available tool rounds. Synthesize your final answer now from the evidence gathered.";
+function searchLimitMessage(max) {
+    return `(search limit reached — you have used ${max} searches. Use peek, trace, or impact to investigate the symbols you already found.)`;
+}

package/dist/lib/llm/tools.js

@@ -0,0 +1,384 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOLS = void 0;
+exports.executeTool = executeTool;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const impact_1 = require("../graph/impact");
+const arrow_1 = require("../utils/arrow");
+const filter_builder_1 = require("../utils/filter-builder");
+// ---------------------------------------------------------------------------
+// Tool definitions (OpenAI function-calling format)
+// ---------------------------------------------------------------------------
+exports.TOOLS = [
+    {
+        type: "function",
+        function: {
+            name: "search",
+            description: "Semantic code search — finds code by meaning. Returns filepath:line symbol [ROLE] — snippet.",
+            parameters: {
+                type: "object",
+                properties: {
+                    query: { type: "string", description: "Natural language search query" },
+                    max_count: { type: "integer", description: "Max results (default 5)" },
+                    lang: { type: "string", description: "Filter by extension (e.g. 'ts', 'py')" },
+                    file: { type: "string", description: "Filter to files matching this name" },
+                },
+                required: ["query"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "trace",
+            description: "Full call graph — all callers (<-) and callees (->) with locations.",
+            parameters: {
+                type: "object",
+                properties: {
+                    symbol: { type: "string", description: "Symbol name to trace" },
+                    depth: { type: "integer", description: "Caller depth 1-3 (default 1)" },
+                },
+                required: ["symbol"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "peek",
+            description: "Compact symbol overview — signature, callers, and callees.",
+            parameters: {
+                type: "object",
+                properties: {
+                    symbol: { type: "string", description: "Symbol name to peek at" },
+                    depth: { type: "integer", description: "Caller depth 1-3 (default 1)" },
+                },
+                required: ["symbol"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "impact",
+            description: "Change impact — files that depend on this symbol/file, and affected tests.",
+            parameters: {
+                type: "object",
+                properties: {
+                    target: { type: "string", description: "Symbol name or file path" },
+                    depth: { type: "integer", description: "Traversal depth 1-3 (default 1)" },
+                },
+                required: ["target"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "related",
+            description: "Find files related by shared symbol references.",
+            parameters: {
+                type: "object",
+                properties: {
+                    file: { type: "string", description: "File path relative to project root" },
+                },
+                required: ["file"],
+            },
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// Tool execution wrappers
+// ---------------------------------------------------------------------------
+function rel(absPath, root) {
+    return absPath.startsWith(root) ? absPath.slice(root.length + 1) : absPath;
+}
+function clampDepth(d) {
+    const n = Number(d) || 1;
+    return Math.min(Math.max(n, 1), 3);
+}
+function executeSearch(args, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const query = String(args.query || "");
+        if (!query)
+            return "(error: missing query)";
+        const limit = Math.min(Number(args.max_count) || 5, 10);
+        const filters = {};
+        if (args.lang)
+            filters.language = String(args.lang);
+        if (args.file)
+            filters.file = String(args.file);
+        const pathPrefix = `${ctx.projectRoot}/`;
+        const resp = yield ctx.searcher.search(query, limit, { rerank: true }, Object.keys(filters).length > 0 ? filters : undefined, pathPrefix);
+        if (!resp.data || resp.data.length === 0)
+            return "(no results)";
+        const lines = resp.data.map((r) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            const absPath = String((_c = (_b = (_a = r.metadata) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : r.path) !== null && _c !== void 0 ? _c : "");
+            const rp = rel(absPath, ctx.projectRoot);
+            const defs = (0, arrow_1.toArr)((_d = r.definedSymbols) !== null && _d !== void 0 ? _d : r.defined_symbols);
+            const sym = defs[0] || "(anonymous)";
+            const role = String((_e = r.role) !== null && _e !== void 0 ? _e : "IMPL").slice(0, 4).toUpperCase();
+            const startLine = (_j = (_h = (_f = r.startLine) !== null && _f !== void 0 ? _f : (_g = r.generated_metadata) === null || _g === void 0 ? void 0 : _g.start_line) !== null && _h !== void 0 ? _h : r.start_line) !== null && _j !== void 0 ? _j : 0;
+            const hint = String((_l = (_k = r.text) !== null && _k !== void 0 ? _k : r.content) !== null && _l !== void 0 ? _l : "").split("\n")[0].slice(0, 100);
+            return `${rp}:${startLine} ${sym} [${role}] — ${hint}`;
+        });
+        return lines.join("\n");
+    });
+}
+function executeTrace(args, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const symbol = String(args.symbol || "");
+        if (!symbol)
+            return "(error: missing symbol)";
+        const depth = clampDepth(args.depth);
+        const graph = yield ctx.graphBuilder.buildGraphMultiHop(symbol, depth);
+        if (!graph.center)
+            return "(not found)";
+        const lines = [];
+        lines.push(`${graph.center.symbol}\t${rel(graph.center.file, ctx.projectRoot)}:${graph.center.line}\t${graph.center.role}`);
+        function walkCallers(tree, d) {
+            for (const t of tree) {
+                lines.push(`${"  ".repeat(d)}<- ${t.node.symbol}\t${rel(t.node.file, ctx.projectRoot)}:${t.node.line}`);
+                walkCallers(t.callers, d + 1);
+            }
+        }
+        walkCallers(graph.callerTree, 0);
+        for (const c of graph.callees) {
+            if (c.file) {
+                lines.push(`-> ${c.symbol}\t${rel(c.file, ctx.projectRoot)}:${c.line}`);
+            }
+            else {
+                lines.push(`-> ${c.symbol}\t(not indexed)`);
+            }
+        }
+        return lines.join("\n");
+    });
+}
+function executePeek(args, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const symbol = String(args.symbol || "");
+        if (!symbol)
+            return "(error: missing symbol)";
+        const graph = yield ctx.graphBuilder.buildGraph(symbol);
+        if (!graph.center)
+            return "(not found)";
+        const center = graph.center;
+        const prefix = ctx.projectRoot.endsWith("/")
+            ? ctx.projectRoot
+            : `${ctx.projectRoot}/`;
+        // Get metadata
+        const table = yield ctx.vectorDb.ensureTable();
+        const metaRows = yield table
+            .query()
+            .select(["is_exported", "start_line", "end_line"])
+            .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+            .limit(1)
+            .toArray();
+        const exported = metaRows.length > 0 && Boolean(metaRows[0].is_exported);
+        const startLine = metaRows.length > 0 ? Number(metaRows[0].start_line || 0) : center.line;
+        const endLine = metaRows.length > 0 ? Number(metaRows[0].end_line || 0) : center.line;
+        // Extract signature
+        let sig = "(source not available)";
+        try {
+            const content = fs.readFileSync(center.file, "utf-8");
+            const fileLines = content.split("\n");
+            const chunk = fileLines.slice(startLine, endLine + 1);
+            const sigLines = [];
+            for (const line of chunk) {
+                sigLines.push(line);
+                if (line.includes("{") || line.includes("=>"))
+                    break;
+            }
+            sig = ((_a = sigLines[0]) === null || _a === void 0 ? void 0 : _a.trim()) || sig;
+        }
+        catch (_b) { }
+        const lines = [];
+        lines.push(`${center.symbol}\t${rel(center.file, ctx.projectRoot)}:${center.line + 1}\t${center.role}\t${exported ? "exported" : ""}`);
+        lines.push(`sig: ${sig}`);
+        for (const c of graph.callers.slice(0, 5)) {
+            lines.push(`<- ${c.symbol}\t${c.file ? `${rel(c.file, ctx.projectRoot)}:${c.line + 1}` : "(not indexed)"}`);
+        }
+        if (graph.callers.length > 5) {
+            lines.push(`<- ... ${graph.callers.length - 5} more`);
+        }
+        for (const c of graph.callees.slice(0, 8)) {
+            lines.push(`-> ${c.symbol}\t${c.file ? `${rel(c.file, ctx.projectRoot)}:${c.line + 1}` : "(not indexed)"}`);
+        }
+        if (graph.callees.length > 8) {
+            lines.push(`-> ... ${graph.callees.length - 8} more`);
+        }
+        return lines.join("\n");
+    });
+}
+function executeImpact(args, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const target = String(args.target || "");
+        if (!target)
+            return "(error: missing target)";
+        const depth = clampDepth(args.depth);
+        const { symbols, resolvedAsFile } = yield (0, impact_1.resolveTargetSymbols)(target, ctx.vectorDb, ctx.projectRoot);
+        if (symbols.length === 0)
+            return "(not found)";
+        const excludePaths = resolvedAsFile
+            ? new Set([path.resolve(ctx.projectRoot, target)])
+            : undefined;
+        const [deps, tests] = yield Promise.all([
+            (0, impact_1.findDependents)(symbols, ctx.vectorDb, ctx.projectRoot, excludePaths),
+            (0, impact_1.findTests)(symbols, ctx.vectorDb, ctx.projectRoot, depth),
+        ]);
+        if (deps.length === 0 && tests.length === 0)
+            return "(no impact detected)";
+        const lines = [];
+        for (const d of deps) {
+            lines.push(`dep: ${rel(d.file, ctx.projectRoot)}\t${d.sharedSymbols}`);
+        }
+        for (const t of tests) {
+            const hopLabel = t.hops === 0 ? "direct" : `${t.hops} hop${t.hops > 1 ? "s" : ""}`;
+            lines.push(`test: ${rel(t.file, ctx.projectRoot)}:${t.line}\t${t.symbol}\t${hopLabel}`);
+        }
+        return lines.join("\n");
+    });
+}
+function executeRelated(args, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filePath = String(args.file || "");
+        if (!filePath)
+            return "(error: missing file)";
+        const absPath = path.resolve(ctx.projectRoot, filePath);
+        const table = yield ctx.vectorDb.ensureTable();
+        // Get file's symbols
+        const fileChunks = yield table
+            .query()
+            .select(["defined_symbols", "referenced_symbols"])
+            .where(`path = '${(0, filter_builder_1.escapeSqlString)(absPath)}'`)
+            .toArray();
+        if (fileChunks.length === 0)
+            return "(file not indexed)";
+        const definedHere = new Set();
+        const referencedHere = new Set();
+        for (const chunk of fileChunks) {
+            for (const s of (0, arrow_1.toArr)(chunk.defined_symbols))
+                definedHere.add(s);
+            for (const s of (0, arrow_1.toArr)(chunk.referenced_symbols))
+                referencedHere.add(s);
+        }
+        // Dependencies: files that DEFINE symbols this file REFERENCES
+        const depCounts = new Map();
+        for (const sym of referencedHere) {
+            if (definedHere.has(sym))
+                continue;
+            const rows = yield table
+                .query()
+                .select(["path"])
+                .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}')`)
+                .limit(3)
+                .toArray();
+            for (const row of rows) {
+                const p = String(row.path || "");
+                if (p === absPath)
+                    continue;
+                depCounts.set(p, (depCounts.get(p) || 0) + 1);
+            }
+        }
+        // Dependents: files that REFERENCE symbols this file DEFINES
+        const revCounts = new Map();
+        for (const sym of definedHere) {
+            const rows = yield table
+                .query()
+                .select(["path"])
+                .where(`array_contains(referenced_symbols, '${(0, filter_builder_1.escapeSqlString)(sym)}')`)
+                .limit(20)
+                .toArray();
+            for (const row of rows) {
+                const p = String(row.path || "");
+                if (p === absPath)
+                    continue;
+                revCounts.set(p, (revCounts.get(p) || 0) + 1);
+            }
+        }
+        const topDeps = [...depCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+        const topRevs = [...revCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+        if (topDeps.length === 0 && topRevs.length === 0)
+            return "(none)";
+        const lines = [];
+        for (const [p, count] of topDeps) {
+            lines.push(`dep: ${rel(p, ctx.projectRoot)}\t${count}`);
+        }
+        for (const [p, count] of topRevs) {
+            lines.push(`rev: ${rel(p, ctx.projectRoot)}\t${count}`);
+        }
+        return lines.join("\n");
+    });
+}
+// ---------------------------------------------------------------------------
+// Dispatcher
+// ---------------------------------------------------------------------------
+function executeTool(name, args, ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            switch (name) {
+                case "search":
+                    return yield executeSearch(args, ctx);
+                case "trace":
+                    return yield executeTrace(args, ctx);
+                case "peek":
+                    return yield executePeek(args, ctx);
+                case "impact":
+                    return yield executeImpact(args, ctx);
+                case "related":
+                    return yield executeRelated(args, ctx);
+                default:
+                    return `(error: unknown tool: ${name})`;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `(error: ${msg})`;
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.13.5",
+  "version": "0.13.6",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {
@@ -46,6 +46,7 @@
     "ignore": "^7.0.5",
     "lmdb": "^3.5.2",
     "onnxruntime-node": "1.24.3",
+    "openai": "^6.33.0",
     "ora": "^9.3.0",
     "piscina": "^5.1.4",
     "proper-lockfile": "^4.1.2",

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

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