grepmax 0.17.21 → 0.17.23

package/dist/commands/related.js

@@ -51,6 +51,7 @@ const filter_builder_1 = require("../lib/utils/filter-builder");
 const exit_1 = require("../lib/utils/exit");
 const project_registry_1 = require("../lib/utils/project-registry");
 const project_root_1 = require("../lib/utils/project-root");
+const query_timeout_1 = require("../lib/utils/query-timeout");
 const arrow_1 = require("../lib/utils/arrow");
 exports.related = new commander_1.Command("related")
     .description("Find files related by shared symbol references")
@@ -164,12 +165,13 @@ exports.related = new commander_1.Command("related")
                 basenameRejected = true;
             }
             else {
-                const rows = yield table
+                // No .limit() here: LIKE + limit deadlocks in @lancedb 0.27.x when
+                // more rows match than the limit (verified). The loop below caps.
+                const rows = yield (0, query_timeout_1.withQueryTimeout)(table
                     .query()
                     .select(["path"])
                     .where(`content LIKE '%${(0, filter_builder_1.escapeSqlString)(basename)}%' AND ${pathScope}`)
-                    .limit(limit * 4)
-                    .toArray();
+                    .toArray(), `content LIKE %${basename}% (related mentions)`);
                 const seen = new Set();
                 for (const row of rows) {
                     const p = String(row.path || "");

package/dist/commands/search-run.js

@@ -0,0 +1,227 @@
+"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.runSearch = runSearch;
+const path = __importStar(require("node:path"));
+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 vector_db_1 = require("../lib/store/vector-db");
+const lock_1 = require("../lib/utils/lock");
+/**
+ * Acquire search results, picking the path: daemon-mediated first (ships the
+ * query over IPC to the already-warm daemon), in-process fallback otherwise
+ * (opens VectorDB, ensures the index, runs Searcher). The presentation/render
+ * stage stays in the command action.
+ *
+ * On success/dry-run the opened VectorDB (if any) is returned for the caller to
+ * close after rendering; if indexing throws, it is closed here before rethrow.
+ */
+function runSearch(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { pattern, options, projectRoot, effectiveRoot, paths, projectStatus, searchFilters, pathFilter, seeds, } = params;
+        // Tracks a DB opened by the in-process path so it can be (a) returned to the
+        // caller for closing after render, or (b) closed here if indexing throws.
+        let openedDb = null;
+        try {
+            // Daemon-mediated search: ships query+args over IPC, daemon runs the
+            // hybrid+rerank against its already-warm VectorDB and worker pool.
+            // Drops cold-start cost (~17s wall, 6GB RAM in the CLI) to <1s. Falls
+            // back to in-process on any failure.
+            let searchResult = null;
+            let precomputedSkeletons;
+            let precomputedGraph;
+            let indexState;
+            if (!options.sync && !options.dryRun) {
+                try {
+                    const { isDaemonRunning, sendDaemonCommand } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/daemon-client")));
+                    if (yield isDaemonRunning()) {
+                        const resp = yield sendDaemonCommand({
+                            cmd: "search",
+                            projectRoot: effectiveRoot,
+                            query: pattern,
+                            limit: parseInt(options.m, 10),
+                            filters: Object.keys(searchFilters).length > 0
+                                ? searchFilters
+                                : undefined,
+                            pathPrefix: pathFilter,
+                            rerank: process.env.GMAX_RERANK === "1",
+                            explain: options.explain,
+                            seeds,
+                            includeSkeletons: options.skeleton,
+                            includeGraph: options.symbol,
+                        }, { timeoutMs: 60000 });
+                        if (resp.ok) {
+                            searchResult = {
+                                data: resp.data,
+                                warnings: resp.warnings,
+                            };
+                            precomputedSkeletons = resp.skeletons;
+                            precomputedGraph = resp.graph;
+                            indexState = resp.indexState;
+                        }
+                        else if (process.env.GMAX_DEBUG === "1") {
+                            console.error(`[search] daemon path unavailable: ${(_a = resp.error) !== null && _a !== void 0 ? _a : "unknown"}`);
+                        }
+                    }
+                }
+                catch (err) {
+                    if (process.env.GMAX_DEBUG === "1") {
+                        console.error("[search] daemon attempt threw:", err);
+                    }
+                }
+            }
+            // In-process fallback: open VectorDB, ensure index, run Searcher.
+            // Only entered when the daemon path didn't produce results.
+            if (!searchResult) {
+                const vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+                openedDb = vectorDb;
+                // Check for active indexing lock and warn if present
+                const locked = (0, lock_1.isLocked)(paths.dataDir);
+                if (!options.agent && locked) {
+                    console.warn("⚠️  Warning: Indexing in progress... search results may be incomplete.");
+                }
+                // No daemon here, so no precise pending count — surface the coarse
+                // signal (active lock or initial index not yet complete) so agent mode
+                // still gets a partial-index footer.
+                if (!indexState && (locked || projectStatus === "pending")) {
+                    indexState = { indexing: true, pendingFiles: 0 };
+                }
+                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 { kind: "dry-run", vectorDb: openedDb };
+                        }
+                        yield vectorDb.createFTSIndex();
+                        // Update registry after sync
+                        const { readGlobalConfig } = yield Promise.resolve().then(() => __importStar(require("../lib/index/index-config")));
+                        const { registerProject } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/project-registry")));
+                        const gc = readGlobalConfig();
+                        registerProject({
+                            root: projectRoot,
+                            name: path.basename(projectRoot),
+                            vectorDim: gc.vectorDim,
+                            modelTier: gc.modelTier,
+                            embedMode: gc.embedMode,
+                            lastIndexed: new Date().toISOString(),
+                            chunkCount: result.indexed,
+                            status: "indexed",
+                        });
+                        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;
+                    }
+                }
+                // Ensure a watcher is running for live reindexing
+                if (!process.env.VITEST && !((_b = process.env.NODE_ENV) === null || _b === void 0 ? void 0 : _b.includes("test"))) {
+                    const { launchWatcher } = yield Promise.resolve().then(() => __importStar(require("../lib/utils/watcher-launcher")));
+                    const launched = yield launchWatcher(projectRoot);
+                    if (!launched.ok && launched.reason === "spawn-failed") {
+                        console.warn(`[search] ${launched.message}`);
+                    }
+                }
+                const searcher = new searcher_1.Searcher(vectorDb);
+                searchResult = yield searcher.search(pattern, parseInt(options.m, 10), {
+                    rerank: process.env.GMAX_RERANK === "1",
+                    explain: options.explain,
+                    seeds,
+                }, Object.keys(searchFilters).length > 0
+                    ? searchFilters
+                    : undefined, pathFilter);
+            } // end if (!searchResult) — in-process fallback
+            return {
+                kind: "result",
+                vectorDb: openedDb,
+                searchResult,
+                precomputedSkeletons,
+                precomputedGraph,
+                indexState,
+            };
+        }
+        catch (e) {
+            // Mirror the original action's finally: close a DB opened mid-flight when
+            // indexing throws, before the error propagates to the caller.
+            if (openedDb) {
+                try {
+                    yield openedDb.close();
+                }
+                catch (_c) { }
+            }
+            throw e;
+        }
+    });
+}

package/dist/commands/search-skeletons.js

@@ -0,0 +1,133 @@
+"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.outputSkeletons = outputSkeletons;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const skeleton_1 = require("../lib/skeleton");
+const retriever_1 = require("../lib/skeleton/retriever");
+// Reuse Skeletonizer instance
+let globalSkeletonizer = null;
+function outputSkeletons(results, projectRoot, limit, db, precomputed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        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.");
+            console.log("\nTry: broaden your query, or use `gmax skeleton <path>` to view a specific file's structure.");
+            process.exitCode = 1;
+            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 filePath of filesToProcess) {
+            // Paths from search results are now absolute (centralized index)
+            const absPath = path.isAbsolute(filePath)
+                ? filePath
+                : path.resolve(projectRoot, filePath);
+            // 0. Daemon-supplied (preferred — already-warm DB lookup, no cold open)
+            const fromDaemon = (_b = precomputed === null || precomputed === void 0 ? void 0 : precomputed[absPath]) !== null && _b !== void 0 ? _b : precomputed === null || precomputed === void 0 ? void 0 : precomputed[filePath];
+            if (fromDaemon) {
+                skeletonResults.push({
+                    file: filePath,
+                    skeleton: fromDaemon,
+                    tokens: Math.ceil(fromDaemon.length / 4),
+                });
+                continue;
+            }
+            // 1. Try DB cache
+            if (db) {
+                const cached = yield (0, retriever_1.getStoredSkeleton)(db, absPath);
+                if (cached) {
+                    skeletonResults.push({
+                        file: filePath,
+                        skeleton: cached,
+                        tokens: Math.ceil(cached.length / 4), // Rough estimate
+                    });
+                    continue;
+                }
+            }
+            // 2. Fallback to fresh generation
+            yield globalSkeletonizer.init();
+            if (!fs.existsSync(absPath)) {
+                skeletonResults.push({
+                    file: filePath,
+                    skeleton: `// File not found: ${filePath}`,
+                    tokens: 0,
+                    error: "File not found",
+                });
+                continue;
+            }
+            const content = fs.readFileSync(absPath, "utf-8");
+            const res = yield globalSkeletonizer.skeletonizeFile(absPath, content, skeletonOpts);
+            skeletonResults.push({
+                file: filePath,
+                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
+        }
+    });
+}