grepmax 0.7.0

package/dist/commands/mcp.js

@@ -0,0 +1,572 @@
+"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.mcp = void 0;
+exports.toStringArray = toStringArray;
+exports.ok = ok;
+exports.err = err;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const commander_1 = require("commander");
+const graph_builder_1 = require("../lib/graph/graph-builder");
+const retriever_1 = require("../lib/skeleton/retriever");
+const skeletonizer_1 = require("../lib/skeleton/skeletonizer");
+const vector_db_1 = require("../lib/store/vector-db");
+const filter_builder_1 = require("../lib/utils/filter-builder");
+const project_root_1 = require("../lib/utils/project-root");
+const server_registry_1 = require("../lib/utils/server-registry");
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+const TOOLS = [
+    {
+        name: "semantic_search",
+        description: "Search code by meaning. Use natural language queries like 'where do we validate permissions' or 'how does the booking flow work'. Returns ranked code snippets with file paths, line numbers, and relevance scores.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Natural language search query. Be specific — more words give better results.",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results to return (default 10, max 50)",
+                },
+                path: {
+                    type: "string",
+                    description: "Restrict search to files under this path prefix (e.g. 'src/auth/')",
+                },
+                min_score: {
+                    type: "number",
+                    description: "Minimum relevance score (0-1). Results below this threshold are filtered out. Default: 0 (no filtering)",
+                },
+                max_per_file: {
+                    type: "number",
+                    description: "Max results per file (default: no cap). Useful to get diversity across files.",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "code_skeleton",
+        description: "Show the structure of a source file — all function/class/method signatures with bodies collapsed. Useful for understanding large files without reading every line. Returns ~4x fewer tokens than the full file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                target: {
+                    type: "string",
+                    description: "File path relative to project root (e.g. 'src/services/booking.ts')",
+                },
+            },
+            required: ["target"],
+        },
+    },
+    {
+        name: "trace_calls",
+        description: "Trace the call graph for a symbol — who calls it (callers) and what it calls (callees). Useful for understanding how functions connect across files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                symbol: {
+                    type: "string",
+                    description: "The function, method, or class name to trace (e.g. 'handleAuth')",
+                },
+            },
+            required: ["symbol"],
+        },
+    },
+    {
+        name: "list_symbols",
+        description: "List indexed symbols (functions, classes, types) with their definition locations. Useful for finding where things are defined without knowing exact names.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: {
+                    type: "string",
+                    description: "Filter symbols by name (case-insensitive substring match)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max symbols to return (default 20, max 100)",
+                },
+                path: {
+                    type: "string",
+                    description: "Only include symbols defined under this path prefix",
+                },
+            },
+        },
+    },
+    {
+        name: "index_status",
+        description: "Check the status of the osgrep index and serve daemon. Returns file count, chunk count, embed mode, index age, and whether live watching is active.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+];
+// ---------------------------------------------------------------------------
+// Daemon lifecycle
+// ---------------------------------------------------------------------------
+let _daemonReady = null;
+function ensureDaemon(projectRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const existing = (0, server_registry_1.getServerForProject)(projectRoot);
+        if (existing && (0, server_registry_1.isProcessRunning)(existing.pid)) {
+            console.log(`[MCP] Serve daemon already running (PID: ${existing.pid}, Port: ${existing.port})`);
+            return true;
+        }
+        console.log("[MCP] Starting serve daemon...");
+        const child = (0, node_child_process_1.spawn)("osgrep", ["serve", "-b"], {
+            cwd: projectRoot,
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        // Poll for readiness — daemon registers in ~/.osgrep/servers.json once listening
+        for (let i = 0; i < 30; i++) {
+            yield new Promise((r) => setTimeout(r, 2000));
+            const server = (0, server_registry_1.getServerForProject)(projectRoot);
+            if (server && (0, server_registry_1.isProcessRunning)(server.pid)) {
+                console.log(`[MCP] Daemon ready (PID: ${server.pid}, Port: ${server.port})`);
+                return true;
+            }
+        }
+        console.error("[MCP] Daemon failed to become ready within 60s");
+        return false;
+    });
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function toStringArray(val) {
+    if (Array.isArray(val))
+        return val.filter((v) => typeof v === "string");
+    if (val && typeof val.toArray === "function") {
+        try {
+            const arr = val.toArray();
+            return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    return [];
+}
+function ok(text) {
+    return { content: [{ type: "text", text }] };
+}
+function err(text) {
+    return { content: [{ type: "text", text }], isError: true };
+}
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+exports.mcp = new commander_1.Command("mcp")
+    .description("Start MCP server for osgrep")
+    .action((_optsArg, _cmd) => __awaiter(void 0, void 0, void 0, function* () {
+    // --- Lifecycle ---
+    var _a;
+    let _vectorDb = null;
+    let _skeletonizer = null;
+    const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (_vectorDb) {
+            try {
+                yield _vectorDb.close();
+            }
+            catch (_a) { }
+            _vectorDb = null;
+        }
+    });
+    const exit = () => __awaiter(void 0, void 0, void 0, function* () {
+        yield cleanup();
+        process.exit(0);
+    });
+    process.on("SIGINT", exit);
+    process.on("SIGTERM", exit);
+    // MCP SDK doesn't handle stdin close — exit when the client disconnects
+    process.stdin.on("end", exit);
+    process.stdin.on("close", exit);
+    process.on("unhandledRejection", (reason, promise) => {
+        console.error("[ERROR] Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    // MCP uses stdout — redirect all logs to stderr
+    console.log = (...args) => {
+        process.stderr.write(`[LOG] ${args.join(" ")}\n`);
+    };
+    console.error = (...args) => {
+        process.stderr.write(`[ERROR] ${args.join(" ")}\n`);
+    };
+    console.debug = (..._args) => { };
+    // --- Project context ---
+    const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+    const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+    // Lazy resource accessors
+    function getVectorDb() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!_vectorDb)
+                _vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+            return _vectorDb;
+        });
+    }
+    function getSkeletonizer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!_skeletonizer) {
+                _skeletonizer = new skeletonizer_1.Skeletonizer();
+                yield _skeletonizer.init();
+            }
+            return _skeletonizer;
+        });
+    }
+    // --- Tool handlers ---
+    function ensureDaemonRunning() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (_daemonReady) {
+                const ready = yield _daemonReady;
+                if (!ready)
+                    return false;
+            }
+            const server = (0, server_registry_1.getServerForProject)(projectRoot);
+            if (server && (0, server_registry_1.isProcessRunning)(server.pid))
+                return true;
+            // Daemon died — restart it
+            console.log("[MCP] Daemon not running, restarting...");
+            _daemonReady = ensureDaemon(projectRoot);
+            return _daemonReady;
+        });
+    }
+    function handleSemanticSearch(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = String(args.query || "");
+            if (!query)
+                return err("Missing required parameter: query");
+            const limit = Math.min(Math.max(Number(args.limit) || 10, 1), 50);
+            const searchPath = typeof args.path === "string" ? args.path : undefined;
+            if (!(yield ensureDaemonRunning())) {
+                return err("Search daemon failed to start. Run 'osgrep serve -b' manually.");
+            }
+            const server = (0, server_registry_1.getServerForProject)(projectRoot);
+            if (!server || !(0, server_registry_1.isProcessRunning)(server.pid)) {
+                return err("Search daemon not running. Run 'osgrep serve -b' manually.");
+            }
+            try {
+                const response = yield fetch(`http://localhost:${server.port}/search`, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify({ query, limit, path: searchPath }),
+                    signal: AbortSignal.timeout(30000),
+                });
+                if (!response.ok) {
+                    const body = yield response.text();
+                    return err(`Search failed (${response.status}): ${body}`);
+                }
+                const { results } = (yield response.json());
+                if (!results || results.length === 0) {
+                    return ok("No matches found.");
+                }
+                const minScore = typeof args.min_score === "number" ? args.min_score : 0;
+                const maxPerFile = typeof args.max_per_file === "number" ? args.max_per_file : 0;
+                let compact = results.map((r) => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+                    return ({
+                        path: (_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 : "",
+                        startLine: (_e = (_d = r.generated_metadata) === null || _d === void 0 ? void 0 : _d.start_line) !== null && _e !== void 0 ? _e : 0,
+                        endLine: (_g = (_f = r.generated_metadata) === null || _f === void 0 ? void 0 : _f.end_line) !== null && _g !== void 0 ? _g : 0,
+                        score: typeof r.score === "number" ? +r.score.toFixed(3) : 0,
+                        role: (_h = r.role) !== null && _h !== void 0 ? _h : "IMPLEMENTATION",
+                        confidence: (_j = r.confidence) !== null && _j !== void 0 ? _j : "Unknown",
+                        definedSymbols: toStringArray(r.defined_symbols).slice(0, 5),
+                        snippet: typeof r.text === "string" ? r.text : "",
+                    });
+                });
+                if (minScore > 0) {
+                    compact = compact.filter((r) => r.score >= minScore);
+                }
+                if (maxPerFile > 0) {
+                    const counts = new Map();
+                    compact = compact.filter((r) => {
+                        const count = counts.get(r.path) || 0;
+                        if (count >= maxPerFile)
+                            return false;
+                        counts.set(r.path, count + 1);
+                        return true;
+                    });
+                }
+                return ok(JSON.stringify(compact, null, 2));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Search request failed: ${msg}`);
+            }
+        });
+    }
+    function handleCodeSkeleton(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const target = String(args.target || "");
+            if (!target)
+                return err("Missing required parameter: target");
+            const absPath = path.resolve(projectRoot, target);
+            const relPath = path.relative(projectRoot, absPath);
+            // Security: ensure path is within project
+            if (relPath.startsWith("..") || path.isAbsolute(relPath)) {
+                return err("Path must be within the project root.");
+            }
+            if (!fs.existsSync(absPath)) {
+                return err(`File not found: ${target}`);
+            }
+            // Try cached skeleton first
+            try {
+                const db = yield getVectorDb();
+                const cached = yield (0, retriever_1.getStoredSkeleton)(db, relPath);
+                if (cached) {
+                    const tokens = Math.ceil(cached.length / 4);
+                    return ok(`// ${relPath} (~${tokens} tokens)\n\n${cached}`);
+                }
+            }
+            catch (_a) {
+                // Index may not exist yet — fall through to live generation
+            }
+            // Generate skeleton from file
+            try {
+                const content = fs.readFileSync(absPath, "utf-8");
+                const skel = yield getSkeletonizer();
+                const result = yield skel.skeletonizeFile(relPath, content);
+                if (!result.success && result.error) {
+                    return err(`Skeleton generation failed: ${result.error}`);
+                }
+                return ok(`// ${relPath} (~${result.tokenEstimate} tokens)\n\n${result.skeleton}`);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Skeleton failed: ${msg}`);
+            }
+        });
+    }
+    function handleTraceCalls(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const symbol = String(args.symbol || "");
+            if (!symbol)
+                return err("Missing required parameter: symbol");
+            try {
+                const db = yield getVectorDb();
+                const builder = new graph_builder_1.GraphBuilder(db);
+                const graph = yield builder.buildGraph(symbol);
+                if (!graph.center) {
+                    return ok(`Symbol '${symbol}' not found in the index.`);
+                }
+                const lines = [];
+                // Callers
+                if (graph.callers.length > 0) {
+                    lines.push("Callers (who calls this?):");
+                    for (const caller of graph.callers) {
+                        lines.push(`  <- ${caller.symbol} (${caller.file}:${caller.line})`);
+                    }
+                }
+                else {
+                    lines.push("No known callers.");
+                }
+                lines.push("");
+                // Center
+                lines.push(`${graph.center.symbol}`);
+                lines.push(`  Defined in ${graph.center.file}:${graph.center.line}`);
+                lines.push(`  Role: ${graph.center.role}`);
+                lines.push("");
+                // Callees
+                if (graph.callees.length > 0) {
+                    lines.push("Callees (what does this call?):");
+                    for (const callee of graph.callees) {
+                        lines.push(`  -> ${callee}`);
+                    }
+                }
+                else {
+                    lines.push("No known callees.");
+                }
+                return ok(lines.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Trace failed: ${msg}`);
+            }
+        });
+    }
+    function handleListSymbols(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pattern = typeof args.pattern === "string" ? args.pattern : undefined;
+            const limit = Math.min(Math.max(Number(args.limit) || 20, 1), 100);
+            const pathPrefix = typeof args.path === "string" ? args.path : undefined;
+            try {
+                const db = yield getVectorDb();
+                const table = yield db.ensureTable();
+                let query = table
+                    .query()
+                    .select(["defined_symbols", "path", "start_line"])
+                    .where("array_length(defined_symbols) > 0")
+                    .limit(pattern ? 10000 : Math.max(limit * 50, 2000));
+                if (pathPrefix) {
+                    query = query.where(`path LIKE '${(0, filter_builder_1.escapeSqlString)((0, filter_builder_1.normalizePath)(pathPrefix))}%'`);
+                }
+                const rows = yield query.toArray();
+                const map = new Map();
+                for (const row of rows) {
+                    const defs = toStringArray(row.defined_symbols);
+                    const rowPath = String(row.path || "");
+                    const line = Number(row.start_line || 0);
+                    for (const sym of defs) {
+                        if (pattern && !sym.toLowerCase().includes(pattern.toLowerCase())) {
+                            continue;
+                        }
+                        const existing = map.get(sym);
+                        if (existing) {
+                            existing.count += 1;
+                        }
+                        else {
+                            map.set(sym, {
+                                symbol: sym,
+                                count: 1,
+                                path: rowPath,
+                                line: Math.max(1, line + 1),
+                            });
+                        }
+                    }
+                }
+                const entries = Array.from(map.values())
+                    .sort((a, b) => {
+                    if (b.count !== a.count)
+                        return b.count - a.count;
+                    return a.symbol.localeCompare(b.symbol);
+                })
+                    .slice(0, limit);
+                if (entries.length === 0) {
+                    return ok("No symbols found. Run 'osgrep index' to build the index.");
+                }
+                return ok(JSON.stringify(entries, null, 2));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Symbol listing failed: ${msg}`);
+            }
+        });
+    }
+    function handleIndexStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            yield ensureDaemonRunning();
+            const server = (0, server_registry_1.getServerForProject)(projectRoot);
+            if (!server || !(0, server_registry_1.isProcessRunning)(server.pid)) {
+                // Fall back to config file
+                const configPath = path.join(projectRoot, ".osgrep", "config.json");
+                try {
+                    const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+                    return ok(JSON.stringify({
+                        daemon: "stopped",
+                        embedMode: (_a = config.embedMode) !== null && _a !== void 0 ? _a : "unknown",
+                        model: (_c = (_b = config.embedModel) !== null && _b !== void 0 ? _b : config.mlxModel) !== null && _c !== void 0 ? _c : null,
+                        vectorDim: (_d = config.vectorDim) !== null && _d !== void 0 ? _d : null,
+                        indexedAt: (_e = config.indexedAt) !== null && _e !== void 0 ? _e : null,
+                    }, null, 2));
+                }
+                catch (_f) {
+                    return ok(JSON.stringify({ daemon: "stopped", indexed: false }));
+                }
+            }
+            try {
+                const response = yield fetch(`http://localhost:${server.port}/stats`, {
+                    signal: AbortSignal.timeout(5000),
+                });
+                if (!response.ok) {
+                    return err(`Stats request failed (${response.status})`);
+                }
+                const stats = yield response.json();
+                return ok(JSON.stringify(Object.assign({ daemon: "running", pid: server.pid, port: server.port }, stats), null, 2));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Failed to get status: ${msg}`);
+            }
+        });
+    }
+    // --- MCP server setup ---
+    const transport = new stdio_js_1.StdioServerTransport();
+    const server = new index_js_1.Server({
+        name: "osgrep",
+        version: JSON.parse(fs.readFileSync(path.join(__dirname, "../../package.json"), {
+            encoding: "utf-8",
+        })).version,
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, () => __awaiter(void 0, void 0, void 0, function* () {
+        return { tools: TOOLS };
+    }));
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, (request) => __awaiter(void 0, void 0, void 0, function* () {
+        const { name, arguments: args } = request.params;
+        const toolArgs = (args !== null && args !== void 0 ? args : {});
+        switch (name) {
+            case "semantic_search":
+                return handleSemanticSearch(toolArgs);
+            case "code_skeleton":
+                return handleCodeSkeleton(toolArgs);
+            case "trace_calls":
+                return handleTraceCalls(toolArgs);
+            case "list_symbols":
+                return handleListSymbols(toolArgs);
+            case "index_status":
+                return handleIndexStatus();
+            default:
+                return err(`Unknown tool: ${name}`);
+        }
+    }));
+    yield server.connect(transport);
+    // Ensure the serve daemon is running (handles indexing, GPU, live reindex).
+    // The MCP server owns daemon lifecycle — the SessionStart hook is read-only.
+    _daemonReady = ensureDaemon(projectRoot);
+}));