grepmax 0.17.23 → 0.18.0

package/dist/commands/search-output.js

@@ -0,0 +1,531 @@
+"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.executeServerSearch = executeServerSearch;
+exports.renderSearchOutput = renderSearchOutput;
+const path = __importStar(require("node:path"));
+const agent_search_formatter_1 = require("../lib/output/agent-search-formatter");
+const compact_results_1 = require("../lib/output/compact-results");
+const index_state_footer_1 = require("../lib/output/index-state-footer");
+const cross_project_1 = require("../lib/utils/cross-project");
+const formatter_1 = require("../lib/utils/formatter");
+const import_extractor_1 = require("../lib/utils/import-extractor");
+const search_skeletons_1 = require("./search-skeletons");
+/**
+ * Standalone HTTP-server search path. The per-project server answers the query
+ * over HTTP and returns JSON; we render it here with the same presentation
+ * modes as the local path (minus the modes the server can't precompute).
+ *
+ * Returns `true` when the server answered and rendering is complete (the caller
+ * should return without touching the local path); `false` when the request
+ * failed (`!response.ok` or a thrown error) and the caller should fall back to
+ * the in-process / daemon-mediated path.
+ *
+ * Mirrors the original action's structure: a handled server search returns
+ * BEFORE the command's main try/finally, so it intentionally skips query
+ * logging and gracefulExit.
+ */
+function executeServerSearch(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { server, pattern, exec_path, projectRootForServer, options, minScore, } = params;
+        try {
+            const response = yield fetch(`http://localhost:${server.port}/search`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    query: pattern,
+                    limit: parseInt(options.m, 10),
+                    path: exec_path
+                        ? path.relative(projectRootForServer, path.resolve(exec_path))
+                        : undefined,
+                }),
+            });
+            if (response.ok) {
+                const body = (yield response.json());
+                const searchResult = { data: body.results };
+                const filteredData = searchResult.data.filter((r) => typeof r.score !== "number" || r.score >= minScore);
+                if (options.skeleton) {
+                    yield (0, search_skeletons_1.outputSkeletons)(filteredData, projectRootForServer, parseInt(options.m, 10), 
+                    // Server doesn't easily expose DB instance here in HTTP client mode,
+                    // but we are in client. Wait, this text implies "Server Search" block.
+                    // Client talks to server. The server returns JSON.
+                    // We don't have DB access here.
+                    // So we pass null, and it will fallback to generating local skeleton (if file exists locally).
+                    // This is acceptable for Phase 3.
+                    null);
+                    return true;
+                }
+                const compactHits = options.compact ? (0, compact_results_1.toCompactHits)(filteredData) : [];
+                if (options.compact) {
+                    if (!compactHits.length) {
+                        console.log("No matches found.");
+                        console.log("\nTry: broaden your query, use fewer keywords, or check `gmax status` to verify the project is indexed.");
+                        process.exitCode = 1;
+                    }
+                    else {
+                        console.log((0, compact_results_1.formatCompactTable)(compactHits, projectRootForServer, pattern, {
+                            isTTY: !!process.stdout.isTTY,
+                            plain: !!options.plain,
+                        }));
+                    }
+                    return true; // EXIT
+                }
+                if (!filteredData.length) {
+                    console.log("No matches found.");
+                    console.log("\nTry: broaden your query, use fewer keywords, or check `gmax status` to verify the project is indexed.");
+                    process.exitCode = 1;
+                    return true; // EXIT
+                }
+                if (options.agent) {
+                    const importCache = new Map();
+                    const getImportsForFile = (absPath) => {
+                        var _a;
+                        if (!options.imports || !absPath)
+                            return "";
+                        if (!importCache.has(absPath)) {
+                            importCache.set(absPath, (0, import_extractor_1.extractImports)(absPath));
+                        }
+                        return (_a = importCache.get(absPath)) !== null && _a !== void 0 ? _a : "";
+                    };
+                    console.log((0, agent_search_formatter_1.formatAgentSearchResults)(filteredData, projectRootForServer, {
+                        includeImports: options.imports,
+                        query: pattern,
+                        getImportsForFile,
+                        explain: options.explain,
+                    }));
+                    return true; // EXIT
+                }
+                const isTTY = process.stdout.isTTY;
+                const shouldBePlain = options.plain || !isTTY;
+                if (!options.agent && !options.compact) {
+                    console.log((0, compact_results_1.resultCountHeader)(filteredData, parseInt(options.m, 10)));
+                    console.log();
+                }
+                if (shouldBePlain) {
+                    const mappedResults = (0, compact_results_1.toTextResults)(filteredData);
+                    const output = (0, formatter_1.formatTextResults)(mappedResults, pattern, projectRootForServer, {
+                        isPlain: true,
+                        compact: options.compact,
+                        content: options.content,
+                        perFile: parseInt(options.perFile, 10),
+                        showScores: options.scores,
+                    });
+                    console.log(output);
+                }
+                else {
+                    const { formatResults } = yield Promise.resolve().then(() => __importStar(require("../lib/output/formatter")));
+                    const output = formatResults(filteredData, projectRootForServer, {
+                        content: options.content,
+                        explain: options.explain,
+                    });
+                    console.log(output);
+                }
+                return true; // EXIT successful server search
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG) {
+                console.error("[search] server request failed, falling back to local:", e);
+            }
+        }
+        return false;
+    });
+}
+/**
+ * Presentation stage shared by the daemon-mediated and in-process search paths.
+ * Applies the min-score + name-regex post-filters, then dispatches to one of the
+ * seven presentation modes (cross-project, agent, skeleton, no-results, compact,
+ * context-for-llm, standard). Writes directly to stdout/stderr and may set
+ * `process.exitCode`. Returns the post-filter result count for query logging.
+ */
+function renderSearchOutput(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const { searchResult, options, minScore, crossProject, pattern, effectiveRoot, projectRoot, vectorDb, precomputedSkeletons, precomputedGraph, indexState, } = params;
+        if (!options.agent && ((_a = searchResult.warnings) === null || _a === void 0 ? void 0 : _a.length)) {
+            for (const w of searchResult.warnings) {
+                console.warn(`Warning: ${w}`);
+            }
+        }
+        // Partial-index signal (Phase 6): when the index is mid-catchup, results
+        // may be incomplete. Non-agent renders it now as a warning; agent mode
+        // appends a machine-readable footer after the results below.
+        if (!options.agent) {
+            const footer = (0, index_state_footer_1.formatIndexStateFooter)(indexState, { agent: false });
+            if (footer)
+                console.warn(footer);
+        }
+        let filteredData = searchResult.data.filter((r) => typeof r.score !== "number" || r.score >= minScore);
+        // Post-filter by symbol name regex
+        if (options.name) {
+            try {
+                const regex = new RegExp(options.name, "i");
+                filteredData = filteredData.filter((r) => {
+                    const defs = Array.isArray(r.defined_symbols) ? r.defined_symbols : [];
+                    return defs.some((d) => regex.test(d));
+                });
+            }
+            catch (_h) {
+                // Invalid regex — skip
+            }
+        }
+        // Build import cache when --imports is requested
+        const importCache = new Map();
+        const getImportsForFile = (absPath) => {
+            var _a;
+            if (!options.imports || !absPath)
+                return "";
+            if (!importCache.has(absPath)) {
+                importCache.set(absPath, (0, import_extractor_1.extractImports)(absPath));
+            }
+            return (_a = importCache.get(absPath)) !== null && _a !== void 0 ? _a : "";
+        };
+        // Agent mode: ultra-compact one-line-per-result output
+        const resultCount = filteredData.length;
+        // Cross-project (Phase 6): render grouped by owning project so idioms
+        // from different stacks don't blur into one flat list. Only the
+        // string-formatter modes reach here — skeleton/context-for-llm/symbol
+        // were rejected up front.
+        if (crossProject.active) {
+            const emitFooter = () => {
+                const footer = (0, index_state_footer_1.formatIndexStateFooter)(indexState, {
+                    agent: !!options.agent,
+                });
+                if (footer) {
+                    if (options.agent)
+                        console.log(footer);
+                    else
+                        console.warn(footer);
+                }
+            };
+            if (!filteredData.length) {
+                console.log(options.agent ? "(none)" : "No matches found.");
+                process.exitCode = 1;
+                emitFooter();
+                return { resultCount };
+            }
+            const getPath = (r) => {
+                var _a, _b, _c;
+                return String((_c = (_a = r.path) !== null && _a !== void 0 ? _a : (_b = r.metadata) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : "");
+            };
+            const groups = (0, cross_project_1.groupResultsByProject)(filteredData, crossProject.roots, getPath);
+            const isTTY = process.stdout.isTTY;
+            const shouldBePlain = options.plain || !isTTY;
+            const blocks = [];
+            for (const g of groups) {
+                let body;
+                if (options.agent) {
+                    body = (0, agent_search_formatter_1.formatAgentSearchResults)(g.items, g.root, {
+                        includeImports: options.imports,
+                        query: pattern,
+                        getImportsForFile,
+                        explain: options.explain,
+                    });
+                }
+                else if (options.compact) {
+                    body = (0, compact_results_1.formatCompactTable)((0, compact_results_1.toCompactHits)(g.items), g.root, pattern, {
+                        isTTY: !!isTTY,
+                        plain: !!options.plain,
+                    });
+                }
+                else if (shouldBePlain) {
+                    body = (0, formatter_1.formatTextResults)((0, compact_results_1.toTextResults)(g.items), pattern, g.root, {
+                        isPlain: true,
+                        compact: options.compact,
+                        content: options.content,
+                        perFile: parseInt(options.perFile, 10),
+                        showScores: options.scores,
+                    });
+                }
+                else {
+                    const { formatResults } = yield Promise.resolve().then(() => __importStar(require("../lib/output/formatter")));
+                    body = formatResults(g.items, g.root, {
+                        content: options.content,
+                        explain: options.explain,
+                    });
+                }
+                const header = options.agent
+                    ? `## ${g.name} (${g.items.length})`
+                    : `=== ${g.name} (${g.items.length}) ===`;
+                blocks.push(`${header}\n${body}`);
+            }
+            console.log(blocks.join("\n\n"));
+            emitFooter();
+            return { resultCount };
+        }
+        if (options.agent) {
+            if (!filteredData.length) {
+                console.log("(none)");
+                process.exitCode = 1;
+            }
+            else {
+                console.log((0, agent_search_formatter_1.formatAgentSearchResults)(filteredData, effectiveRoot, {
+                    includeImports: options.imports,
+                    query: pattern,
+                    getImportsForFile,
+                    explain: options.explain,
+                }));
+            }
+            // Agent trace (compact)
+            if (options.symbol && filteredData.length > 0) {
+                try {
+                    let graph = precomputedGraph;
+                    if (!graph) {
+                        if (!vectorDb)
+                            throw new Error("no graph source");
+                        const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
+                        const builder = new GraphBuilder(vectorDb, effectiveRoot);
+                        graph = yield builder.buildGraphMultiHop(pattern, 1);
+                    }
+                    if (graph === null || graph === void 0 ? void 0 : graph.center) {
+                        console.log("---");
+                        for (const t of graph.callerTree) {
+                            const rel = t.node.file.startsWith(effectiveRoot)
+                                ? t.node.file.slice(effectiveRoot.length + 1)
+                                : t.node.file;
+                            console.log(`<- ${t.node.symbol} ${rel}:${t.node.line + 1}`);
+                        }
+                        for (const c of graph.callees.slice(0, 10)) {
+                            if (c.file) {
+                                const rel = c.file.startsWith(effectiveRoot)
+                                    ? c.file.slice(effectiveRoot.length + 1)
+                                    : c.file;
+                                console.log(`-> ${c.symbol} ${rel}:${c.line + 1}`);
+                            }
+                        }
+                    }
+                }
+                catch (_j) { }
+            }
+            // Partial-index footer last, so it's the final line the agent reads —
+            // and emitted even on "(none)", where an empty result may just mean the
+            // relevant files aren't indexed yet.
+            const footer = (0, index_state_footer_1.formatIndexStateFooter)(indexState, { agent: true });
+            if (footer)
+                console.log(footer);
+            return { resultCount };
+        }
+        if (options.skeleton) {
+            yield (0, search_skeletons_1.outputSkeletons)(filteredData, projectRoot, parseInt(options.m, 10), vectorDb, precomputedSkeletons);
+            return { resultCount };
+        }
+        if (!filteredData.length) {
+            console.log("No matches found.");
+            console.log("\nTry: broaden your query, use fewer keywords, or check `gmax status` to verify the project is indexed.");
+            process.exitCode = 1;
+            return { resultCount };
+        }
+        if (options.compact) {
+            const compactHits = (0, compact_results_1.toCompactHits)(filteredData);
+            console.log((0, compact_results_1.formatCompactTable)(compactHits, projectRoot, pattern, {
+                isTTY: !!process.stdout.isTTY,
+                plain: !!options.plain,
+            }));
+            return { resultCount };
+        }
+        // Context-for-LLM mode: full function body + imports per result
+        if (options.contextForLlm) {
+            const fs = yield Promise.resolve().then(() => __importStar(require("node:fs")));
+            const { extractImportsFromContent } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/import-extractor")));
+            const { packByBudget } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/budget-pack")));
+            const budget = parseInt(options.budget, 10) || 8000;
+            console.log((0, compact_results_1.resultCountHeader)(filteredData, parseInt(options.m, 10)));
+            // Build every candidate blob up front (token cost needs the rendered
+            // text), then pack to budget. Token-aware packing skips an oversized
+            // chunk and keeps filling with smaller, still-relevant ones rather than
+            // aborting the loop — recovering budget the old greedy `break` wasted.
+            const candidates = filteredData.map((r, idx) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+                const absP = (_c = (_a = r.path) !== null && _a !== void 0 ? _a : (_b = r.metadata) === null || _b === void 0 ? void 0 : _b.path) !== null && _c !== void 0 ? _c : "";
+                const startLine = (_g = (_e = (_d = r.startLine) !== null && _d !== void 0 ? _d : r.start_line) !== null && _e !== void 0 ? _e : (_f = r.generated_metadata) === null || _f === void 0 ? void 0 : _f.start_line) !== null && _g !== void 0 ? _g : 0;
+                const endLine = (_l = (_j = (_h = r.endLine) !== null && _h !== void 0 ? _h : r.end_line) !== null && _j !== void 0 ? _j : (_k = r.generated_metadata) === null || _k === void 0 ? void 0 : _k.end_line) !== null && _l !== void 0 ? _l : startLine;
+                const relPath = absP.startsWith(projectRoot)
+                    ? absP.slice(projectRoot.length + 1)
+                    : absP;
+                const role = r.role || "IMPLEMENTATION";
+                const symbol = Array.isArray(r.defined_symbols) &&
+                    r.defined_symbols.length > 0
+                    ? r.defined_symbols[0]
+                    : "";
+                let blobText;
+                try {
+                    const content = fs.readFileSync(absP, "utf-8");
+                    const allLines = content.split("\n");
+                    const body = allLines
+                        .slice(startLine, Math.min(endLine + 1, allLines.length))
+                        .join("\n");
+                    const imports = extractImportsFromContent(content);
+                    const blob = [
+                        `--- ${relPath}:${startLine + 1}${symbol ? ` ${symbol}` : ""} [${role}] ---`,
+                    ];
+                    if (imports)
+                        blob.push("[imports]", imports, "");
+                    blob.push("[body]", body);
+                    blobText = blob.join("\n");
+                }
+                catch (_m) {
+                    blobText = `--- ${relPath} (file not readable) ---`;
+                }
+                // Preserve relevance order when scores are absent (rank-derived
+                // fallback) so the density tiebreaker never reshuffles arbitrarily.
+                const score = typeof r.score === "number"
+                    ? r.score
+                    : (filteredData.length - idx) / filteredData.length;
+                return { blobText, tokens: Math.ceil(blobText.length / 4), score };
+            });
+            const pack = packByBudget(candidates.map((c) => ({ tokens: c.tokens, score: c.score })), budget);
+            for (const i of pack.selected) {
+                console.log(`\n${candidates[i].blobText}`);
+            }
+            if (pack.dropped > 0) {
+                console.log(`\n(budget: ~${pack.tokensUsed}/${budget} tokens, ${pack.dropped} lower-density result${pack.dropped > 1 ? "s" : ""} not shown)`);
+            }
+            return { resultCount };
+        }
+        const isTTY = process.stdout.isTTY;
+        const shouldBePlain = options.plain || !isTTY;
+        if (!options.agent && !options.compact) {
+            console.log((0, compact_results_1.resultCountHeader)(filteredData, parseInt(options.m, 10)));
+            console.log();
+        }
+        // Print imports per unique file before results when --imports is used
+        if (options.imports) {
+            const seenFiles = new Set();
+            for (const r of filteredData) {
+                const absP = (_d = (_b = r.path) !== null && _b !== void 0 ? _b : (_c = r.metadata) === null || _c === void 0 ? void 0 : _c.path) !== null && _d !== void 0 ? _d : "";
+                if (absP && !seenFiles.has(absP)) {
+                    seenFiles.add(absP);
+                    const imports = getImportsForFile(absP);
+                    if (imports) {
+                        const relP = absP.startsWith(effectiveRoot)
+                            ? absP.slice(effectiveRoot.length + 1)
+                            : absP;
+                        console.log(`--- imports: ${relP} ---\n${imports}\n`);
+                    }
+                }
+            }
+        }
+        if (shouldBePlain) {
+            const mappedResults = (0, compact_results_1.toTextResults)(filteredData);
+            const output = (0, formatter_1.formatTextResults)(mappedResults, pattern, projectRoot, {
+                isPlain: true,
+                compact: options.compact,
+                content: options.content,
+                perFile: parseInt(options.perFile, 10),
+                showScores: options.scores,
+            });
+            console.log(output);
+            if (options.explain) {
+                for (const r of filteredData) {
+                    const b = r.scoreBreakdown;
+                    if (b) {
+                        const absP = (_g = (_e = r.path) !== null && _e !== void 0 ? _e : (_f = r.metadata) === null || _f === void 0 ? void 0 : _f.path) !== null && _g !== void 0 ? _g : "";
+                        const relPath = absP.startsWith(projectRoot)
+                            ? absP.slice(projectRoot.length + 1)
+                            : absP;
+                        console.log(`  [explain ${relPath}] rerank=${b.rerank.toFixed(3)}  fused=${b.fused.toFixed(3)}  boost=${b.boost.toFixed(2)}x  final=${b.normalized.toFixed(3)}`);
+                    }
+                }
+            }
+        }
+        else {
+            // Use new holographic formatter for TTY
+            const { formatResults } = yield Promise.resolve().then(() => __importStar(require("../lib/output/formatter")));
+            const output = formatResults(filteredData, projectRoot, {
+                content: options.content,
+                explain: options.explain,
+            });
+            console.log(output);
+        }
+        // Symbol mode: append call graph
+        if (options.symbol) {
+            try {
+                let graph = precomputedGraph;
+                if (!graph) {
+                    if (!vectorDb)
+                        throw new Error("no graph source");
+                    const { GraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../lib/graph/graph-builder")));
+                    const builder = new GraphBuilder(vectorDb, effectiveRoot);
+                    graph = yield builder.buildGraphMultiHop(pattern, 1);
+                }
+                if (graph === null || graph === void 0 ? void 0 : graph.center) {
+                    const lines = ["\n--- Call graph ---"];
+                    const centerRel = path.relative(effectiveRoot, graph.center.file);
+                    lines.push(`${graph.center.symbol} [${graph.center.role}] ${centerRel}:${graph.center.line + 1}`);
+                    if (graph.importers.length > 0) {
+                        const filtered = graph.importers.filter((p) => p !== graph.center.file);
+                        if (filtered.length > 0) {
+                            lines.push("Imported by:");
+                            for (const imp of filtered.slice(0, 10)) {
+                                lines.push(`  ${path.relative(effectiveRoot, imp)}`);
+                            }
+                        }
+                    }
+                    if (graph.callerTree.length > 0) {
+                        lines.push("Callers:");
+                        for (const t of graph.callerTree) {
+                            lines.push(`  <- ${t.node.symbol} ${path.relative(effectiveRoot, t.node.file)}:${t.node.line + 1}`);
+                        }
+                    }
+                    if (graph.callees.length > 0) {
+                        lines.push("Calls:");
+                        for (const c of graph.callees.slice(0, 15)) {
+                            if (c.file) {
+                                lines.push(`  -> ${c.symbol} ${path.relative(effectiveRoot, c.file)}:${c.line + 1}`);
+                            }
+                            else {
+                                lines.push(`  -> ${c.symbol} (not indexed)`);
+                            }
+                        }
+                    }
+                    console.log(lines.join("\n"));
+                }
+            }
+            catch (_k) {
+                // Trace failed — skip silently
+            }
+        }
+        return { resultCount };
+    });
+}