grepmax 0.7.0

package/dist/commands/search.js

@@ -0,0 +1,539 @@
+"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.search = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const grammar_loader_1 = require("../lib/index/grammar-loader");
+const sync_helpers_1 = require("../lib/index/sync-helpers");
+const syncer_1 = require("../lib/index/syncer");
+const searcher_1 = require("../lib/search/searcher");
+const setup_helpers_1 = require("../lib/setup/setup-helpers");
+const skeleton_1 = require("../lib/skeleton");
+const retriever_1 = require("../lib/skeleton/retriever");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const formatter_1 = require("../lib/utils/formatter");
+const lock_1 = require("../lib/utils/lock");
+const project_root_1 = require("../lib/utils/project-root");
+const server_registry_1 = require("../lib/utils/server-registry");
+function toTextResults(data) {
+    return data.map((r) => {
+        var _a, _b, _c, _d, _e, _f;
+        const rawPath = typeof ((_a = r.metadata) === null || _a === void 0 ? void 0 : _a.path) === "string"
+            ? r.metadata.path
+            : "Unknown path";
+        const start = typeof ((_b = r.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) === "number"
+            ? r.generated_metadata.start_line
+            : 0;
+        const end = typeof ((_c = r.generated_metadata) === null || _c === void 0 ? void 0 : _c.end_line) === "number"
+            ? r.generated_metadata.end_line
+            : start + Math.max(0, ((_e = (_d = r.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines) !== null && _e !== void 0 ? _e : 1) - 1);
+        return {
+            path: rawPath,
+            score: r.score,
+            content: r.text || "",
+            chunk_type: (_f = r.generated_metadata) === null || _f === void 0 ? void 0 : _f.type,
+            start_line: start,
+            end_line: end,
+        };
+    });
+}
+function getPreviewText(chunk) {
+    var _a, _b, _c, _d, _e;
+    const maxLen = 140;
+    const lines = (_b = (_a = chunk.text) === null || _a === void 0 ? void 0 : _a.split("\n").map((l) => l.trim()).filter(Boolean)) !== null && _b !== void 0 ? _b : [];
+    let preview = (_c = lines[0]) !== null && _c !== void 0 ? _c : "";
+    if (!preview && ((_d = chunk.defined_symbols) === null || _d === void 0 ? void 0 : _d.length)) {
+        preview = (_e = chunk.defined_symbols[0]) !== null && _e !== void 0 ? _e : "";
+    }
+    if (preview.length > maxLen) {
+        preview = `${preview.slice(0, maxLen)}...`;
+    }
+    return preview;
+}
+function toCompactHits(data) {
+    return data.map((chunk) => {
+        var _a, _b, _c, _d, _e, _f;
+        const rawPath = typeof ((_a = chunk.metadata) === null || _a === void 0 ? void 0 : _a.path) === "string"
+            ? chunk.metadata.path
+            : "Unknown path";
+        const start = typeof ((_b = chunk.generated_metadata) === null || _b === void 0 ? void 0 : _b.start_line) === "number"
+            ? chunk.generated_metadata.start_line
+            : 0;
+        const end = typeof ((_c = chunk.generated_metadata) === null || _c === void 0 ? void 0 : _c.end_line) === "number"
+            ? chunk.generated_metadata.end_line
+            : start + Math.max(0, ((_e = (_d = chunk.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines) !== null && _e !== void 0 ? _e : 1) - 1);
+        return {
+            path: rawPath,
+            range: `${start + 1}-${end + 1}`,
+            start_line: start,
+            end_line: end,
+            role: chunk.role,
+            confidence: chunk.confidence,
+            score: chunk.score,
+            defined: Array.isArray(chunk.defined_symbols)
+                ? chunk.defined_symbols.slice(0, 3)
+                : typeof chunk.defined_symbols === "string"
+                    ? [chunk.defined_symbols]
+                    : typeof ((_f = chunk.defined_symbols) === null || _f === void 0 ? void 0 : _f.toArray) === "function"
+                        ? chunk.defined_symbols.toArray().slice(0, 3)
+                        : [],
+            preview: getPreviewText(chunk),
+        };
+    });
+}
+function compactRole(role) {
+    if (!role)
+        return "UNK";
+    if (role.startsWith("ORCH"))
+        return "ORCH";
+    if (role.startsWith("DEF"))
+        return "DEF";
+    if (role.startsWith("IMP"))
+        return "IMPL";
+    return role.slice(0, 4).toUpperCase();
+}
+function compactConf(conf) {
+    if (!conf)
+        return "U";
+    const c = conf.toUpperCase();
+    if (c.startsWith("H"))
+        return "H";
+    if (c.startsWith("M"))
+        return "M";
+    if (c.startsWith("L"))
+        return "L";
+    return "U";
+}
+function compactScore(score) {
+    if (typeof score !== "number")
+        return "";
+    const fixed = score.toFixed(3);
+    return fixed
+        .replace(/^0\./, ".")
+        .replace(/\.?0+$/, (m) => (m.startsWith(".") ? "" : m));
+}
+function truncateEnd(s, max) {
+    if (max <= 0)
+        return "";
+    if (s.length <= max)
+        return s;
+    if (max <= 3)
+        return s.slice(0, max);
+    return `${s.slice(0, max - 3)}...`;
+}
+function padR(s, w) {
+    const n = Math.max(0, w - s.length);
+    return s + " ".repeat(n);
+}
+function padL(s, w) {
+    const n = Math.max(0, w - s.length);
+    return " ".repeat(n) + s;
+}
+function formatCompactTSV(hits, projectRoot, query) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    const lines = [];
+    lines.push(`osgrep hits\tquery=${query}\tcount=${hits.length}`);
+    lines.push("path\tlines\tscore\trole\tconf\tdefined");
+    for (const hit of hits) {
+        const relPath = path.isAbsolute(hit.path)
+            ? path.relative(projectRoot, hit.path)
+            : hit.path;
+        const score = compactScore(hit.score);
+        const role = compactRole(hit.role);
+        const conf = compactConf(hit.confidence);
+        const defs = ((_a = hit.defined) !== null && _a !== void 0 ? _a : []).join(",");
+        lines.push([relPath, hit.range, score, role, conf, defs].join("\t"));
+    }
+    return lines.join("\n");
+}
+function formatCompactPretty(hits, projectRoot, query, termWidth, useAnsi) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    const dim = (s) => (useAnsi ? `\x1b[90m${s}\x1b[0m` : s);
+    const bold = (s) => (useAnsi ? `\x1b[1m${s}\x1b[0m` : s);
+    const wLines = 9;
+    const wScore = 6;
+    const wRole = 4;
+    const wConf = 1;
+    const wDef = 20;
+    const gutters = 5;
+    const fixed = wLines + wScore + wRole + wConf + wDef + gutters;
+    const wPath = Math.max(24, Math.min(64, termWidth - fixed));
+    const header = `osgrep hits  count=${hits.length}  query="${query}"`;
+    const cols = [
+        padR("path", wPath),
+        padR("lines", wLines),
+        padL("score", wScore),
+        padR("role", wRole),
+        padR("c", wConf),
+        padR("defined", wDef),
+    ].join(" ");
+    const out = [];
+    out.push(bold(header));
+    out.push(dim(cols));
+    for (const hit of hits) {
+        const relPath = path.isAbsolute(hit.path)
+            ? path.relative(projectRoot, hit.path)
+            : hit.path;
+        const score = compactScore(hit.score);
+        const role = compactRole(hit.role);
+        const conf = compactConf(hit.confidence);
+        const defs = ((_a = hit.defined) !== null && _a !== void 0 ? _a : []).join(",") || "-";
+        const displayPath = `${relPath}:${hit.start_line + 1}`;
+        const paddedPath = padR(displayPath, wPath);
+        const row = [
+            paddedPath,
+            padR(hit.range, wLines),
+            padL(score || "", wScore),
+            padR(role, wRole),
+            padR(conf, wConf),
+            padR(truncateEnd(defs, wDef), wDef),
+        ].join(" ");
+        out.push(row);
+    }
+    return out.join("\n");
+}
+function formatCompactTable(hits, projectRoot, query, opts) {
+    var _a;
+    if (!hits.length)
+        return "No matches found.";
+    if (!opts.isTTY || opts.plain) {
+        return formatCompactTSV(hits, projectRoot, query);
+    }
+    const termWidth = Math.max(80, (_a = process.stdout.columns) !== null && _a !== void 0 ? _a : 120);
+    return formatCompactPretty(hits, projectRoot, query, termWidth, true);
+}
+// Reuse Skeletonizer instance
+let globalSkeletonizer = null;
+function outputSkeletons(results, projectRoot, limit, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const seenPaths = new Set();
+        const filesToProcess = [];
+        for (const result of results) {
+            const p = (_a = result.metadata) === null || _a === void 0 ? void 0 : _a.path;
+            if (typeof p === "string" && !seenPaths.has(p)) {
+                seenPaths.add(p);
+                filesToProcess.push(p);
+                if (filesToProcess.length >= limit)
+                    break;
+            }
+        }
+        if (filesToProcess.length === 0) {
+            console.log("No skeleton matches found.");
+            return;
+        }
+        // Reuse or init skeletonizer for fallbacks
+        if (!globalSkeletonizer) {
+            globalSkeletonizer = new skeleton_1.Skeletonizer();
+            // Lazy init only if we actually fallback
+        }
+        const skeletonOpts = { includeSummary: true };
+        const skeletonResults = [];
+        for (const relPath of filesToProcess) {
+            // 1. Try DB cache
+            if (db) {
+                const cached = yield (0, retriever_1.getStoredSkeleton)(db, relPath);
+                if (cached) {
+                    skeletonResults.push({
+                        file: relPath,
+                        skeleton: cached,
+                        tokens: Math.ceil(cached.length / 4), // Rough estimate
+                    });
+                    continue;
+                }
+            }
+            // 2. Fallback to fresh generation
+            yield globalSkeletonizer.init();
+            const absPath = path.resolve(projectRoot, relPath);
+            if (!fs.existsSync(absPath)) {
+                skeletonResults.push({
+                    file: relPath,
+                    skeleton: `// File not found: ${relPath}`,
+                    tokens: 0,
+                    error: "File not found",
+                });
+                continue;
+            }
+            const content = fs.readFileSync(absPath, "utf-8");
+            const res = yield globalSkeletonizer.skeletonizeFile(relPath, content, skeletonOpts);
+            skeletonResults.push({
+                file: relPath,
+                skeleton: res.skeleton,
+                tokens: res.tokenEstimate,
+                error: res.error,
+            });
+        }
+        // Since search doesn't support --json explicitly yet, we just print text.
+        // But if we ever add it, we have the structure.
+        for (const res of skeletonResults) {
+            console.log(res.skeleton);
+            console.log(""); // Separator
+        }
+    });
+}
+exports.search = new commander_1.Command("search")
+    .description("File pattern searcher")
+    .option("-m <max_count>, --max-count <max_count>", "The maximum number of results to return (total)", "5")
+    .option("-c, --content", "Show full chunk content instead of snippets", false)
+    .option("--per-file <n>", "Number of matches to show per file", "3")
+    .option("--scores", "Show relevance scores", false)
+    .option("--min-score <score>", "Minimum relevance score (0-1) to include in results", "0")
+    .option("--compact", "Compact hits view (paths + line ranges + role/preview)", false)
+    .option("--plain", "Disable ANSI colors and use simpler formatting", false)
+    .option("-s, --sync", "Syncs the local files to the store before searching", false)
+    .option("-d, --dry-run", "Show what would be indexed without actually indexing", false)
+    .option("--skeleton", "Show code skeleton for matching files instead of snippets", false)
+    .argument("<pattern>", "The pattern to search for")
+    .argument("[path]", "The path to search in")
+    .action((pattern, exec_path, _options, cmd) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const options = cmd.optsWithGlobals();
+    const root = process.cwd();
+    const minScore = Number.isFinite(Number.parseFloat(options.minScore))
+        ? Number.parseFloat(options.minScore)
+        : 0;
+    let vectorDb = null;
+    // Check for running server
+    const execPathForServer = exec_path ? path.resolve(exec_path) : root;
+    const projectRootForServer = (_a = (0, project_root_1.findProjectRoot)(execPathForServer)) !== null && _a !== void 0 ? _a : execPathForServer;
+    const server = (0, server_registry_1.getServerForProject)(projectRootForServer);
+    if (server) {
+        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 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;
+                }
+                const compactHits = options.compact
+                    ? toCompactHits(filteredData)
+                    : [];
+                if (options.compact) {
+                    const compactText = compactHits.length
+                        ? formatCompactTable(compactHits, projectRootForServer, pattern, {
+                            isTTY: !!process.stdout.isTTY,
+                            plain: !!options.plain,
+                        })
+                        : "No matches found.";
+                    console.log(compactText);
+                    return; // EXIT
+                }
+                if (!filteredData.length) {
+                    console.log("No matches found.");
+                    return; // EXIT
+                }
+                const isTTY = process.stdout.isTTY;
+                const shouldBePlain = options.plain || !isTTY;
+                if (shouldBePlain) {
+                    const mappedResults = 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,
+                    });
+                    console.log(output);
+                }
+                return; // EXIT successful server search
+            }
+        }
+        catch (e) {
+            if (process.env.DEBUG) {
+                console.error("[search] server request failed, falling back to local:", e);
+            }
+        }
+    }
+    try {
+        yield (0, setup_helpers_1.ensureSetup)();
+        const searchRoot = exec_path ? path.resolve(exec_path) : root;
+        const projectRoot = (_b = (0, project_root_1.findProjectRoot)(searchRoot)) !== null && _b !== void 0 ? _b : searchRoot;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        // Propagate project root to worker processes
+        process.env.OSGREP_PROJECT_ROOT = projectRoot;
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        // Check for active indexing lock and warn if present
+        // This allows agents (via shim) to know results might be partial.
+        if ((0, lock_1.isLocked)(paths.osgrepDir)) {
+            console.warn("⚠️  Warning: Indexing in progress... search results may be incomplete.");
+        }
+        const hasRows = yield vectorDb.hasAnyRows();
+        const needsSync = options.sync || !hasRows;
+        if (needsSync) {
+            const isTTY = process.stdout.isTTY;
+            let abortController;
+            let signal;
+            if (!isTTY) {
+                abortController = new AbortController();
+                signal = abortController.signal;
+                setTimeout(() => {
+                    abortController === null || abortController === void 0 ? void 0 : abortController.abort();
+                }, 60000); // 60 seconds timeout for non-TTY auto-indexing
+            }
+            const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, options.sync ? "Indexing..." : "Indexing repository (first run)...");
+            try {
+                yield (0, grammar_loader_1.ensureGrammars)(console.log, { silent: true });
+                const result = yield (0, syncer_1.initialSync)({
+                    projectRoot,
+                    dryRun: options.dryRun,
+                    onProgress,
+                    signal,
+                });
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    spinner.warn(`Indexing timed out (${result.processed}/${result.total}). Results may be partial.`);
+                }
+                if (options.dryRun) {
+                    spinner.succeed(`Dry run complete (${result.processed}/${result.total}) • would have indexed ${result.indexed}`);
+                    console.log((0, sync_helpers_1.formatDryRunSummary)(result, {
+                        actionDescription: "would have indexed",
+                        includeTotal: true,
+                    }));
+                    return;
+                }
+                yield vectorDb.createFTSIndex();
+                const failedSuffix = result.failedFiles > 0 ? ` • ${result.failedFiles} failed` : "";
+                spinner.succeed(`${options.sync ? "Indexing" : "Initial indexing"} complete (${result.processed}/${result.total}) • indexed ${result.indexed}${failedSuffix}`);
+            }
+            catch (e) {
+                spinner.fail("Indexing failed");
+                throw e;
+            }
+        }
+        const searcher = new searcher_1.Searcher(vectorDb);
+        const searchResult = yield searcher.search(pattern, parseInt(options.m, 10), { rerank: true }, undefined, exec_path ? path.relative(projectRoot, path.resolve(exec_path)) : "");
+        const filteredData = searchResult.data.filter((r) => typeof r.score !== "number" || r.score >= minScore);
+        if (options.skeleton) {
+            yield outputSkeletons(filteredData, projectRoot, parseInt(options.m, 10), vectorDb);
+            return;
+        }
+        const compactHits = options.compact ? toCompactHits(filteredData) : [];
+        const compactText = options.compact && compactHits.length
+            ? formatCompactTable(compactHits, projectRoot, pattern, {
+                isTTY: !!process.stdout.isTTY,
+                plain: !!options.plain,
+            })
+            : options.compact
+                ? "No matches found."
+                : "";
+        if (!filteredData.length) {
+            console.log("No matches found.");
+            return;
+        }
+        if (options.compact) {
+            console.log(compactText);
+            return;
+        }
+        const isTTY = process.stdout.isTTY;
+        const shouldBePlain = options.plain || !isTTY;
+        if (shouldBePlain) {
+            const mappedResults = 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);
+        }
+        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,
+            });
+            console.log(output);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Search failed:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (err) {
+                console.error("Failed to close VectorDB:", err);
+            }
+        }
+        yield (0, exit_1.gracefulExit)();
+    }
+}));