grepmax 0.9.5 → 0.10.1

package/dist/commands/config.js

@@ -19,11 +19,13 @@ exports.config = new commander_1.Command("config")
     .description("View or update gmax configuration")
     .option("--embed-mode <mode>", "Set embedding mode: cpu or gpu")
     .option("--model-tier <tier>", "Set model tier: small (384d) or standard (768d)")
+    .option("--query-log <on|off>", "Enable/disable query logging to ~/.gmax/logs/queries.jsonl")
     .addHelpText("after", `
 Examples:
   gmax config                          Show current configuration
   gmax config --embed-mode cpu         Switch to CPU embeddings
   gmax config --model-tier standard    Switch to standard model (768d)
+  gmax config --query-log on           Enable query logging
 `)
     .action((_opts, cmd) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d;
@@ -31,7 +33,9 @@ Examples:
     const globalConfig = (0, index_config_1.readGlobalConfig)();
     const paths = (0, project_root_1.ensureProjectPaths)(process.cwd());
     const indexConfig = (0, index_config_1.readIndexConfig)(paths.configPath);
-    const hasUpdates = options.embedMode !== undefined || options.modelTier !== undefined;
+    const hasUpdates = options.embedMode !== undefined ||
+        options.modelTier !== undefined ||
+        options.queryLog !== undefined;
     if (!hasUpdates) {
         // Show current config
         const tier = (_a = config_1.MODEL_TIERS[globalConfig.modelTier]) !== null && _a !== void 0 ? _a : config_1.MODEL_TIERS.small;
@@ -39,10 +43,11 @@ Examples:
         console.log(`  Model tier:  ${globalConfig.modelTier} (${tier.vectorDim}d, ${tier.params})`);
         console.log(`  Embed mode:  ${globalConfig.embedMode}`);
         console.log(`  Embed model: ${globalConfig.embedMode === "gpu" ? tier.mlxModel : tier.onnxModel}`);
+        console.log(`  Query log:   ${globalConfig.queryLog ? "on" : "off"}`);
         if (indexConfig === null || indexConfig === void 0 ? void 0 : indexConfig.indexedAt) {
             console.log(`  Last indexed: ${indexConfig.indexedAt}`);
         }
-        console.log(`\nTo change: gmax config --embed-mode <cpu|gpu> --model-tier <small|standard>`);
+        console.log(`\nTo change: gmax config --embed-mode <cpu|gpu> --model-tier <small|standard> --query-log <on|off>`);
         yield (0, exit_1.gracefulExit)();
         return;
     }
@@ -57,6 +62,24 @@ Examples:
         yield (0, exit_1.gracefulExit)(1);
         return;
     }
+    // Handle query-log toggle (independent of model/embed changes)
+    if (options.queryLog !== undefined) {
+        if (!["on", "off"].includes(options.queryLog)) {
+            console.error(`Invalid query-log value: ${options.queryLog} (use on or off)`);
+            yield (0, exit_1.gracefulExit)(1);
+            return;
+        }
+        const enabled = options.queryLog === "on";
+        (0, index_config_1.writeGlobalConfig)(Object.assign(Object.assign({}, globalConfig), { queryLog: enabled }));
+        console.log(`Query logging ${enabled ? "enabled" : "disabled"}. Logs at ~/.gmax/logs/queries.jsonl`);
+        // If only query-log was changed, skip model updates
+        if (!options.embedMode && !options.modelTier) {
+            yield (0, exit_1.gracefulExit)();
+            return;
+        }
+        // Reload config after queryLog write
+        Object.assign(globalConfig, (0, index_config_1.readGlobalConfig)());
+    }
     const newTier = (_b = options.modelTier) !== null && _b !== void 0 ? _b : globalConfig.modelTier;
     const newMode = (_c = options.embedMode) !== null && _c !== void 0 ? _c : globalConfig.embedMode;
     const tier = (_d = config_1.MODEL_TIERS[newTier]) !== null && _d !== void 0 ? _d : config_1.MODEL_TIERS.small;
@@ -66,6 +89,7 @@ Examples:
         vectorDim: tier.vectorDim,
         embedMode: newMode,
         mlxModel: newMode === "gpu" ? tier.mlxModel : undefined,
+        queryLog: globalConfig.queryLog,
     });
     (0, index_config_1.writeSetupConfig)(paths.configPath, {
         embedMode: newMode,

package/dist/commands/extract.js

@@ -0,0 +1,195 @@
+"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.extract = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const filter_builder_1 = require("../lib/utils/filter-builder");
+const import_extractor_1 = require("../lib/utils/import-extractor");
+const project_root_1 = require("../lib/utils/project-root");
+const useColors = process.stdout.isTTY && !process.env.NO_COLOR;
+const style = {
+    bold: (s) => (useColors ? `\x1b[1m${s}\x1b[22m` : s),
+    dim: (s) => (useColors ? `\x1b[2m${s}\x1b[22m` : s),
+    green: (s) => (useColors ? `\x1b[32m${s}\x1b[39m` : s),
+    cyan: (s) => (useColors ? `\x1b[36m${s}\x1b[39m` : s),
+};
+const ROLE_PRIORITY = {
+    ORCHESTRATION: 3,
+    DEFINITION: 2,
+    IMPLEMENTATION: 1,
+};
+function findSymbolChunks(symbol, db, projectRoot) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const table = yield db.ensureTable();
+        const prefix = projectRoot.endsWith("/") ? projectRoot : `${projectRoot}/`;
+        const rows = yield table
+            .query()
+            .select([
+            "path",
+            "start_line",
+            "end_line",
+            "role",
+            "is_exported",
+            "defined_symbols",
+        ])
+            .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+            .limit(10)
+            .toArray();
+        return rows.map((row) => ({
+            path: String(row.path || ""),
+            startLine: Number(row.start_line || 0),
+            endLine: Number(row.end_line || 0),
+            role: String(row.role || "IMPLEMENTATION"),
+            exported: Boolean(row.is_exported),
+            definedSymbols: Array.isArray(row.defined_symbols)
+                ? row.defined_symbols
+                : [],
+        }));
+    });
+}
+function pickBestMatch(chunks, symbol) {
+    // Prefer chunks where the symbol is first in defined_symbols, then by role priority
+    return chunks.sort((a, b) => {
+        const aFirst = a.definedSymbols[0] === symbol ? 1 : 0;
+        const bFirst = b.definedSymbols[0] === symbol ? 1 : 0;
+        if (bFirst !== aFirst)
+            return bFirst - aFirst;
+        return (ROLE_PRIORITY[b.role] || 0) - (ROLE_PRIORITY[a.role] || 0);
+    })[0];
+}
+exports.extract = new commander_1.Command("extract")
+    .description("Extract full function/class body by symbol name")
+    .argument("<symbol>", "The symbol to extract")
+    .option("--root <dir>", "Project root directory")
+    .option("--agent", "Compact output for AI agents", false)
+    .option("--imports", "Prepend file imports", false)
+    .action((symbol, opts) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    let vectorDb = null;
+    const root = opts.root ? path.resolve(opts.root) : process.cwd();
+    try {
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const chunks = yield findSymbolChunks(symbol, vectorDb, projectRoot);
+        if (chunks.length === 0) {
+            const lines = [
+                `Symbol not found: ${opts.agent ? symbol : style.bold(symbol)}`,
+            ];
+            if (!opts.agent) {
+                lines.push("", style.dim("Possible reasons:"), style.dim("  \u2022 The symbol doesn't exist in any indexed project"), style.dim("  \u2022 The containing file hasn't been indexed yet"), style.dim("  \u2022 The name is spelled differently in the source"), "", style.dim("Try:"), style.dim("  gmax status          \u2014 see which projects are indexed"), style.dim("  gmax search <name>   \u2014 fuzzy search for similar symbols"));
+            }
+            console.log(lines.join("\n"));
+            process.exitCode = 1;
+            return;
+        }
+        const best = pickBestMatch(chunks, symbol);
+        const content = fs.readFileSync(best.path, "utf-8");
+        const allLines = content.split("\n");
+        const startLine = best.startLine; // 0-based
+        const endLine = Math.min(best.endLine, allLines.length - 1);
+        const body = allLines.slice(startLine, endLine + 1);
+        const relPath = best.path.startsWith(projectRoot)
+            ? best.path.slice(projectRoot.length + 1)
+            : best.path;
+        if (opts.agent) {
+            // Compact: path:start-end header then raw code
+            if (opts.imports) {
+                const imports = (0, import_extractor_1.extractImportsFromContent)(content);
+                if (imports)
+                    console.log(imports);
+            }
+            console.log(`${relPath}:${startLine + 1}-${endLine + 1}`);
+            console.log(body.join("\n"));
+        }
+        else {
+            // Rich output with line numbers
+            if (opts.imports) {
+                const imports = (0, import_extractor_1.extractImportsFromContent)(content);
+                if (imports) {
+                    console.log(style.dim(imports));
+                    console.log();
+                }
+            }
+            const exportedStr = best.exported ? ", exported" : "";
+            console.log(style.dim(`// ${relPath}:${startLine + 1}-${endLine + 1} [${best.role}${exportedStr}]`));
+            const lineNumWidth = String(endLine + 1).length;
+            for (let i = 0; i < body.length; i++) {
+                const lineNum = String(startLine + 1 + i).padStart(lineNumWidth);
+                console.log(`${style.dim(`${lineNum}\u2502`)} ${body[i]}`);
+            }
+        }
+        // Show other definitions if symbol exists in multiple files
+        const others = chunks.filter((c) => c !== best).slice(0, 3);
+        if (others.length > 0 && !opts.agent) {
+            const otherLocs = others
+                .map((c) => {
+                const r = c.path.startsWith(projectRoot)
+                    ? c.path.slice(projectRoot.length + 1)
+                    : c.path;
+                return `${r}:${c.startLine + 1}`;
+            })
+                .join(", ");
+            console.log(`\n${style.dim(`Also defined in: ${otherLocs}`)}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Extract failed:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (_b) { }
+        }
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/commands/mcp.js

@@ -136,6 +136,32 @@ const TOOLS = [
             required: ["symbol"],
         },
     },
+    {
+        name: "extract_symbol",
+        description: "Extract complete function/class body by symbol name.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                symbol: { type: "string", description: "Symbol name to extract" },
+                root: { type: "string", description: "Project root (absolute path)" },
+                include_imports: { type: "boolean", description: "Prepend file imports" },
+            },
+            required: ["symbol"],
+        },
+    },
+    {
+        name: "peek_symbol",
+        description: "Compact symbol overview: signature + callers + callees.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                symbol: { type: "string", description: "Symbol name" },
+                root: { type: "string", description: "Project root (absolute path)" },
+                depth: { type: "number", description: "Caller depth (default 1, max 3)" },
+            },
+            required: ["symbol"],
+        },
+    },
     {
         name: "list_symbols",
         description: "List indexed symbols with role and export status.",
@@ -810,6 +836,226 @@ exports.mcp = new commander_1.Command("mcp")
             }
         });
     }
+    function handleExtractSymbol(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const symbol = String(args.symbol || "");
+            if (!symbol)
+                return err("Missing required parameter: symbol");
+            try {
+                const root = typeof args.root === "string" && args.root
+                    ? args.root
+                    : projectRoot;
+                const db = getVectorDb();
+                const table = yield db.ensureTable();
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                const rows = yield table
+                    .query()
+                    .select([
+                    "path",
+                    "start_line",
+                    "end_line",
+                    "role",
+                    "is_exported",
+                    "defined_symbols",
+                ])
+                    .where(`array_contains(defined_symbols, '${(0, filter_builder_1.escapeSqlString)(symbol)}') AND path LIKE '${(0, filter_builder_1.escapeSqlString)(prefix)}%'`)
+                    .limit(10)
+                    .toArray();
+                if (rows.length === 0) {
+                    return ok(`Symbol '${symbol}' not found in the index. Check \`gmax status\` to see which projects are indexed, or try \`gmax search ${symbol}\` to find similar symbols.`);
+                }
+                // Pick best match: prefer exact first-defined, then highest role
+                const ROLE_PRI = {
+                    ORCHESTRATION: 3,
+                    DEFINITION: 2,
+                    IMPLEMENTATION: 1,
+                };
+                const sorted = rows.sort((a, b) => {
+                    const aDefs = Array.isArray(a.defined_symbols)
+                        ? a.defined_symbols
+                        : [];
+                    const bDefs = Array.isArray(b.defined_symbols)
+                        ? b.defined_symbols
+                        : [];
+                    const aFirst = aDefs[0] === symbol ? 1 : 0;
+                    const bFirst = bDefs[0] === symbol ? 1 : 0;
+                    if (bFirst !== aFirst)
+                        return bFirst - aFirst;
+                    return ((ROLE_PRI[String(b.role)] || 0) - (ROLE_PRI[String(a.role)] || 0));
+                });
+                const best = sorted[0];
+                const filePath = String(best.path);
+                const startLine = Number(best.start_line || 0);
+                const endLine = Number(best.end_line || 0);
+                const role = String(best.role || "IMPLEMENTATION");
+                const exported = Boolean(best.is_exported);
+                const fs = yield Promise.resolve().then(() => __importStar(require("node:fs")));
+                const content = fs.readFileSync(filePath, "utf-8");
+                const allLines = content.split("\n");
+                const body = allLines
+                    .slice(startLine, Math.min(endLine + 1, allLines.length))
+                    .join("\n");
+                const relPath = filePath.startsWith(root)
+                    ? filePath.slice(root.length + 1)
+                    : filePath;
+                const exportedStr = exported ? ", exported" : "";
+                const parts = [];
+                if (args.include_imports) {
+                    const { extractImportsFromContent } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/import-extractor")));
+                    const imports = extractImportsFromContent(content);
+                    if (imports)
+                        parts.push(imports, "");
+                }
+                parts.push(`// ${relPath}:${startLine + 1}-${endLine + 1} [${role}${exportedStr}]`);
+                parts.push(body);
+                // Note other definitions
+                const others = sorted.slice(1, 4);
+                if (others.length > 0) {
+                    const otherLocs = others
+                        .map((r) => {
+                        const p = String(r.path);
+                        const rel = p.startsWith(root) ? p.slice(root.length + 1) : p;
+                        return `${rel}:${Number(r.start_line || 0) + 1}`;
+                    })
+                        .join(", ");
+                    parts.push("", `Also defined in: ${otherLocs}`);
+                }
+                return ok(parts.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Extract failed: ${msg}`);
+            }
+        });
+    }
+    function handlePeekSymbol(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            ensureWatcher();
+            const symbol = String(args.symbol || "");
+            if (!symbol)
+                return err("Missing required parameter: symbol");
+            try {
+                const root = typeof args.root === "string" && args.root
+                    ? args.root
+                    : projectRoot;
+                const depth = Math.min(Math.max(Number(args.depth || 1), 1), 3);
+                const db = getVectorDb();
+                const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
+                const builder = new GraphBuilder(db, root);
+                const graph = yield builder.buildGraph(symbol);
+                if (!graph.center) {
+                    return ok(`Symbol '${symbol}' not found in the index. Check \`gmax status\` to see which projects are indexed, or try \`gmax search ${symbol}\` to find similar symbols.`);
+                }
+                const center = graph.center;
+                const rel = (p) => p.startsWith(root) ? p.slice(root.length + 1) : p;
+                // Get chunk metadata for is_exported and end_line
+                const table = yield db.ensureTable();
+                const prefix = root.endsWith("/") ? root : `${root}/`;
+                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;
+                // Get signature from source
+                const fs = yield Promise.resolve().then(() => __importStar(require("node:fs")));
+                let sigText = "(source not available)";
+                let bodyLines = 0;
+                try {
+                    const content = fs.readFileSync(center.file, "utf-8");
+                    const lines = content.split("\n");
+                    const chunk = lines.slice(startLine, endLine + 1);
+                    bodyLines = chunk.length;
+                    const sigLines = [];
+                    for (const line of chunk) {
+                        sigLines.push(line);
+                        if (line.includes("{") || line.includes("=>"))
+                            break;
+                    }
+                    sigText = sigLines.join("\n").trim();
+                }
+                catch (_a) { }
+                // Get callers
+                let callerList;
+                if (depth > 1) {
+                    const multiHop = yield builder.buildGraphMultiHop(symbol, depth);
+                    const flat = [];
+                    function walkCallers(tree) {
+                        for (const t of tree) {
+                            flat.push({
+                                symbol: t.node.symbol,
+                                file: t.node.file,
+                                line: t.node.line,
+                            });
+                            walkCallers(t.callers);
+                        }
+                    }
+                    walkCallers(multiHop.callerTree);
+                    callerList = flat;
+                }
+                else {
+                    callerList = graph.callers;
+                }
+                const exportedStr = exported ? ", exported" : "";
+                const parts = [];
+                parts.push(`${center.symbol}  ${rel(center.file)}:${center.line + 1}  [${center.role}${exportedStr}]`);
+                parts.push("");
+                parts.push(`  ${sigText}`);
+                if (bodyLines > 3) {
+                    parts.push(`    // ... (${bodyLines} lines total)`);
+                }
+                parts.push("");
+                // Callers
+                const maxCallers = 5;
+                if (callerList.length > 0) {
+                    parts.push(`callers (${callerList.length}):`);
+                    for (const c of callerList.slice(0, maxCallers)) {
+                        const loc = c.file
+                            ? `${rel(c.file)}:${c.line + 1}`
+                            : "(not indexed)";
+                        parts.push(`  <- ${c.symbol}  ${loc}`);
+                    }
+                    if (callerList.length > maxCallers) {
+                        parts.push(`  ... and ${callerList.length - maxCallers} more`);
+                    }
+                }
+                else {
+                    parts.push("No known callers.");
+                }
+                parts.push("");
+                // Callees
+                const maxCallees = 8;
+                if (graph.callees.length > 0) {
+                    parts.push(`callees (${graph.callees.length}):`);
+                    for (const c of graph.callees.slice(0, maxCallees)) {
+                        const loc = c.file
+                            ? `${rel(c.file)}:${c.line + 1}`
+                            : "(not indexed)";
+                        parts.push(`  -> ${c.symbol}  ${loc}`);
+                    }
+                    if (graph.callees.length > maxCallees) {
+                        parts.push(`  ... and ${graph.callees.length - maxCallees} more`);
+                    }
+                }
+                else {
+                    parts.push("No known callees.");
+                }
+                return ok(parts.join("\n"));
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return err(`Peek failed: ${msg}`);
+            }
+        });
+    }
     function handleListSymbols(args) {
         return __awaiter(this, void 0, void 0, function* () {
             ensureWatcher();
@@ -1277,32 +1523,69 @@ exports.mcp = new commander_1.Command("mcp")
         return { tools: TOOLS };
     }));
     server.setRequestHandler(types_js_1.CallToolRequestSchema, (request) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
         const { name, arguments: args } = request.params;
         const toolArgs = (args !== null && args !== void 0 ? args : {});
+        const startMs = Date.now();
+        let result;
         switch (name) {
             case "semantic_search":
-                return handleSemanticSearch(toolArgs, false);
+                result = yield handleSemanticSearch(toolArgs, false);
+                break;
             case "search_all":
-                return handleSemanticSearch(toolArgs, true);
+                result = yield handleSemanticSearch(toolArgs, true);
+                break;
             case "code_skeleton":
-                return handleCodeSkeleton(toolArgs);
+                result = yield handleCodeSkeleton(toolArgs);
+                break;
             case "trace_calls":
-                return handleTraceCalls(toolArgs);
+                result = yield handleTraceCalls(toolArgs);
+                break;
+            case "extract_symbol":
+                result = yield handleExtractSymbol(toolArgs);
+                break;
+            case "peek_symbol":
+                result = yield handlePeekSymbol(toolArgs);
+                break;
             case "list_symbols":
-                return handleListSymbols(toolArgs);
+                result = yield handleListSymbols(toolArgs);
+                break;
             case "index_status":
-                return handleIndexStatus();
+                result = yield handleIndexStatus();
+                break;
             case "summarize_directory":
-                return handleSummarizeDirectory(toolArgs);
+                result = yield handleSummarizeDirectory(toolArgs);
+                break;
             case "summarize_project":
-                return handleSummarizeProject(toolArgs);
+                result = yield handleSummarizeProject(toolArgs);
+                break;
             case "related_files":
-                return handleRelatedFiles(toolArgs);
+                result = yield handleRelatedFiles(toolArgs);
+                break;
             case "recent_changes":
-                return handleRecentChanges(toolArgs);
+                result = yield handleRecentChanges(toolArgs);
+                break;
             default:
                 return err(`Unknown tool: ${name}`);
         }
+        // Best-effort query logging
+        try {
+            const { logQuery } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/query-log")));
+            const text = (_c = (_b = (_a = result.content) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.text) !== null && _c !== void 0 ? _c : "";
+            const resultLines = text.split("\n").filter((l) => l.trim()).length;
+            logQuery({
+                ts: new Date().toISOString(),
+                source: "mcp",
+                tool: name,
+                query: String((_f = (_e = (_d = toolArgs.query) !== null && _d !== void 0 ? _d : toolArgs.symbol) !== null && _e !== void 0 ? _e : toolArgs.target) !== null && _f !== void 0 ? _f : ""),
+                project: projectRoot,
+                results: resultLines,
+                ms: Date.now() - startMs,
+                error: result.isError ? text.slice(0, 200) : undefined,
+            });
+        }
+        catch (_g) { }
+        return result;
     }));
     yield server.connect(transport);
     // Kick off index readiness check and watcher in background