grepmax 0.7.0

package/dist/lib/index/watcher.js

@@ -0,0 +1,245 @@
+"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.WATCHER_IGNORE_PATTERNS = void 0;
+exports.startWatcher = startWatcher;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const chokidar_1 = require("chokidar");
+const file_utils_1 = require("../utils/file-utils");
+const lock_1 = require("../utils/lock");
+const pool_1 = require("../workers/pool");
+// Chokidar ignored — must exclude heavy directories to keep FD count low.
+// On macOS, chokidar uses FSEvents (single FD) but falls back to fs.watch()
+// (one FD per directory) if FSEvents isn't available or for some subdirs.
+exports.WATCHER_IGNORE_PATTERNS = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.osgrep/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/out/**",
+    "**/target/**",
+    "**/__pycache__/**",
+    "**/coverage/**",
+    "**/venv/**",
+    "**/.next/**",
+    "**/lancedb/**",
+    /(^|[/\\])\../, // dotfiles
+];
+const DEBOUNCE_MS = 2000;
+const FTS_REBUILD_INTERVAL_MS = 5 * 60 * 1000;
+function startWatcher(opts) {
+    const { projectRoot, vectorDb, metaCache, osgrepDir, onReindex } = opts;
+    const pending = new Map();
+    let debounceTimer = null;
+    let processing = false;
+    let closed = false;
+    const watcher = (0, chokidar_1.watch)(projectRoot, {
+        ignored: exports.WATCHER_IGNORE_PATTERNS,
+        ignoreInitial: true,
+        persistent: true,
+        // Use polling to avoid EMFILE in large monorepos.
+        // fs.watch() uses one FD per directory (kqueue on macOS) and hits ulimit.
+        // Polling 2-3k source files every 5s is negligible CPU.
+        usePolling: true,
+        interval: 5000,
+        binaryInterval: 10000,
+    });
+    watcher.on("error", (err) => {
+        console.error("[watch] Watcher error:", err);
+    });
+    const scheduleBatch = () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => processBatch(), DEBOUNCE_MS);
+    };
+    const processBatch = () => __awaiter(this, void 0, void 0, function* () {
+        if (closed || processing || pending.size === 0)
+            return;
+        processing = true;
+        const batch = new Map(pending);
+        pending.clear();
+        const start = Date.now();
+        let reindexed = 0;
+        try {
+            const lock = yield (0, lock_1.acquireWriterLockWithRetry)(osgrepDir, {
+                maxRetries: 3,
+                retryDelayMs: 500,
+            });
+            try {
+                const pool = (0, pool_1.getWorkerPool)();
+                const deletes = [];
+                const vectors = [];
+                const metaUpdates = new Map();
+                const metaDeletes = [];
+                for (const [absPath, event] of batch) {
+                    const relPath = path.relative(projectRoot, absPath);
+                    if (event === "unlink") {
+                        deletes.push(relPath);
+                        metaDeletes.push(relPath);
+                        reindexed++;
+                        continue;
+                    }
+                    // change or add
+                    try {
+                        const stats = yield fs.promises.stat(absPath);
+                        if (!(0, file_utils_1.isIndexableFile)(absPath, stats.size))
+                            continue;
+                        // Check if content actually changed via hash
+                        const cached = metaCache.get(relPath);
+                        const result = yield pool.processFile({
+                            path: relPath,
+                            absolutePath: absPath,
+                        });
+                        const metaEntry = {
+                            hash: result.hash,
+                            mtimeMs: result.mtimeMs,
+                            size: result.size,
+                        };
+                        if (cached && cached.hash === result.hash) {
+                            // Content unchanged (mtime changed but hash same) — just update meta
+                            metaUpdates.set(relPath, metaEntry);
+                            continue;
+                        }
+                        if (result.shouldDelete) {
+                            deletes.push(relPath);
+                            metaUpdates.set(relPath, metaEntry);
+                            reindexed++;
+                            continue;
+                        }
+                        // Delete old vectors, insert new
+                        deletes.push(relPath);
+                        if (result.vectors.length > 0) {
+                            vectors.push(...result.vectors);
+                        }
+                        metaUpdates.set(relPath, metaEntry);
+                        reindexed++;
+                    }
+                    catch (err) {
+                        const code = err === null || err === void 0 ? void 0 : err.code;
+                        if (code === "ENOENT") {
+                            deletes.push(relPath);
+                            metaDeletes.push(relPath);
+                            reindexed++;
+                        }
+                        else {
+                            console.error(`[watch] Failed to process ${relPath}:`, err);
+                        }
+                    }
+                }
+                // Flush to VectorDB
+                if (deletes.length > 0) {
+                    yield vectorDb.deletePaths(deletes);
+                }
+                if (vectors.length > 0) {
+                    yield vectorDb.insertBatch(vectors);
+                }
+                // Update MetaCache
+                for (const [p, entry] of metaUpdates) {
+                    metaCache.put(p, entry);
+                }
+                for (const p of metaDeletes) {
+                    metaCache.delete(p);
+                }
+            }
+            finally {
+                yield lock.release();
+            }
+            if (reindexed > 0) {
+                const duration = Date.now() - start;
+                onReindex === null || onReindex === void 0 ? void 0 : onReindex(reindexed, duration);
+            }
+        }
+        catch (err) {
+            console.error("[watch] Batch processing failed:", err);
+            // Re-queue failed items for retry
+            for (const [absPath, event] of batch) {
+                if (!pending.has(absPath)) {
+                    pending.set(absPath, event);
+                }
+            }
+            scheduleBatch();
+        }
+        finally {
+            processing = false;
+            // Process any events that came in while we were processing
+            if (pending.size > 0) {
+                scheduleBatch();
+            }
+        }
+    });
+    const onFileEvent = (event, absPath) => {
+        if (closed)
+            return;
+        if (event !== "unlink" && !(0, file_utils_1.isIndexableFile)(absPath))
+            return;
+        pending.set(absPath, event);
+        scheduleBatch();
+    };
+    watcher.on("add", (p) => onFileEvent("change", p));
+    watcher.on("change", (p) => onFileEvent("change", p));
+    watcher.on("unlink", (p) => onFileEvent("unlink", p));
+    // Periodic FTS rebuild
+    const ftsInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+        if (closed)
+            return;
+        try {
+            yield vectorDb.createFTSIndex();
+        }
+        catch (err) {
+            console.error("[watch] FTS rebuild failed:", err);
+        }
+    }), FTS_REBUILD_INTERVAL_MS);
+    ftsInterval.unref();
+    return {
+        close: () => __awaiter(this, void 0, void 0, function* () {
+            closed = true;
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            clearInterval(ftsInterval);
+            yield watcher.close();
+        }),
+    };
+}

package/dist/lib/output/formatter.js

@@ -0,0 +1,161 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatResult = formatResult;
+exports.formatResults = formatResults;
+exports.formatTrace = formatTrace;
+const path = __importStar(require("node:path"));
+const cli_highlight_1 = require("cli-highlight");
+const languages_1 = require("../core/languages");
+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),
+    blue: (s) => (useColors ? `\x1b[34m${s}\x1b[39m` : s),
+    cyan: (s) => (useColors ? `\x1b[36m${s}\x1b[39m` : s),
+    gray: (s) => (useColors ? `\x1b[90m${s}\x1b[39m` : s),
+};
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath);
+    const lang = (0, languages_1.getLanguageByExtension)(ext);
+    return (lang === null || lang === void 0 ? void 0 : lang.id) || "plaintext";
+}
+function formatScore(score) {
+    if (typeof score !== "number")
+        return "";
+    const fixed = score.toFixed(3);
+    return fixed
+        .replace(/^0\./, ".")
+        .replace(/\.?0+$/, (m) => (m.startsWith(".") ? "" : m));
+}
+function formatResult(result, root, options = {}) {
+    var _a, _b;
+    const metadata = result.metadata;
+    const relPath = path.relative(root, metadata.path);
+    const line = ((_a = result.generated_metadata) === null || _a === void 0 ? void 0 : _a.start_line) || 0;
+    // Header: Role + File + Location
+    const role = result.role || "IMPLEMENTATION";
+    const roleColor = role === "DEFINITION"
+        ? style.green
+        : role === "ORCHESTRATION"
+            ? style.cyan
+            : style.blue;
+    const header = `${roleColor(role)} ${style.gray(relPath)}:${line}`;
+    // Breadcrumb
+    const breadcrumb = (_b = result.context) === null || _b === void 0 ? void 0 : _b.filter((c) => !c.startsWith("File:")).join(" > ");
+    const breadcrumbLine = breadcrumb ? `\n${style.dim(breadcrumb)}` : "";
+    // Context: What defines this, what it calls
+    const context = [];
+    if (Array.isArray(result.defined_symbols) &&
+        result.defined_symbols.length > 0) {
+        context.push(`Defines: ${result.defined_symbols.join(", ")}`);
+    }
+    if (Array.isArray(result.referenced_symbols) &&
+        result.referenced_symbols.length > 0) {
+        context.push(`Calls: ${result.referenced_symbols.slice(0, 3).join(", ")}${result.referenced_symbols.length > 3 ? "..." : ""}`);
+    }
+    // Add score if available
+    const scoreStr = formatScore(result.score);
+    if (scoreStr) {
+        context.push(`Score: ${scoreStr}`);
+    }
+    const contextLine = context.length > 0 ? `\n${style.gray(context.join(" | "))}` : "";
+    // Code snippet
+    let code = result.text || "";
+    // Clean up noise
+    code = code
+        .split("\n")
+        .filter((l) => !l.startsWith("// File:") && !l.startsWith("File:"))
+        .join("\n")
+        .trim();
+    if (!options.content && code.split("\n").length > 15) {
+        const lines = code.split("\n");
+        code = [...lines.slice(0, 15), style.dim(`...`)].join("\n");
+    }
+    try {
+        const lang = detectLanguage(metadata.path);
+        code = (0, cli_highlight_1.highlight)(code, { language: lang, ignoreIllegals: true });
+    }
+    catch (_c) {
+        // ignore
+    }
+    return `
+${header}${breadcrumbLine}${contextLine}
+
+${code}
+
+${style.dim("─".repeat(80))}
+`.trim();
+}
+function formatResults(results, root, options = {}) {
+    if (results.length === 0)
+        return "No results found.";
+    return results.map((r) => formatResult(r, root, options)).join("\n\n");
+}
+function formatTrace(graph) {
+    if (!graph.center) {
+        return style.dim("Symbol not found.");
+    }
+    const lines = [];
+    // 1. Callers (Upstream)
+    if (graph.callers.length > 0) {
+        lines.push(style.bold("Callers (Who calls this?):"));
+        graph.callers.forEach((caller) => {
+            lines.push(`  ${style.blue("↑")} ${style.green(caller.symbol)} ${style.dim(`(${caller.file}:${caller.line})`)}`);
+        });
+        lines.push("");
+    }
+    else {
+        lines.push(style.dim("No known callers."));
+        lines.push("");
+    }
+    // 2. Center (The Symbol)
+    lines.push(style.bold("▶ " + graph.center.symbol));
+    lines.push(`  ${style.dim(`Defined in ${graph.center.file}:${graph.center.line}`)}`);
+    lines.push(`  ${style.dim(`Role: ${graph.center.role}`)}`);
+    lines.push("");
+    // 3. Callees (Downstream)
+    if (graph.callees.length > 0) {
+        lines.push(style.bold("Callees (What does this call?):"));
+        graph.callees.forEach((callee) => {
+            lines.push(`  ${style.cyan("↓")} ${callee}`);
+        });
+    }
+    else {
+        lines.push(style.dim("No known callees."));
+    }
+    return lines.join("\n");
+}

package/dist/lib/output/json-formatter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatJson = formatJson;
+function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}

package/dist/lib/search/intent.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectIntent = detectIntent;
+function detectIntent(query) {
+    const normalized = query.toLowerCase();
+    // Definition queries
+    if (/where is|what is|define/.test(normalized)) {
+        return { type: "DEFINITION", filters: { definitionsOnly: true } };
+    }
+    // Implementation queries
+    if (/how does|how is|implementation/.test(normalized)) {
+        return { type: "FLOW", mode: "orchestration_first" };
+    }
+    // Usage queries
+    if (/example|how to use|usage/.test(normalized)) {
+        return { type: "USAGE", mode: "show_examples" };
+    }
+    // Architecture queries
+    if (/architecture|system|overview/.test(normalized)) {
+        return { type: "ARCHITECTURE", mode: "group_by_role" };
+    }
+    return { type: "GENERAL" };
+}