grepmax 0.7.0

package/dist/lib/utils/file-utils.js

@@ -0,0 +1,131 @@
+"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.computeBufferHash = computeBufferHash;
+exports.hasNullByte = hasNullByte;
+exports.readFileSnapshot = readFileSnapshot;
+exports.isIndexableFile = isIndexableFile;
+exports.isIndexablePath = isIndexablePath;
+exports.formatDenseSnippet = formatDenseSnippet;
+exports.isDevelopment = isDevelopment;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_path_1 = require("node:path");
+const config_1 = require("../../config");
+function computeBufferHash(buffer) {
+    return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
+}
+function hasNullByte(buffer, sampleLength = 1024) {
+    const length = Math.min(buffer.length, sampleLength);
+    for (let i = 0; i < length; i++) {
+        if (buffer[i] === 0)
+            return true;
+    }
+    return false;
+}
+function readFileSnapshot(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const handle = yield fs.promises.open(filePath, "r");
+        try {
+            const before = yield handle.stat();
+            if (before.size > config_1.MAX_FILE_SIZE_BYTES) {
+                throw new Error("File exceeds maximum allowed size");
+            }
+            const size = before.size;
+            const buffer = size > 0 ? Buffer.allocUnsafe(size) : Buffer.alloc(0);
+            if (size > 0) {
+                yield handle.read(buffer, 0, size, 0);
+            }
+            const after = yield handle.stat();
+            if (before.mtimeMs !== after.mtimeMs || before.size !== after.size) {
+                throw new Error("File changed during read");
+            }
+            return { buffer, mtimeMs: after.mtimeMs, size: after.size };
+        }
+        finally {
+            yield handle.close();
+        }
+    });
+}
+// Check if a file should be indexed (extension and size).
+function isIndexableFile(filePath, size) {
+    const ext = (0, node_path_1.extname)(filePath).toLowerCase();
+    const basename = path.basename(filePath).toLowerCase();
+    if (!config_1.INDEXABLE_EXTENSIONS.has(ext) && !config_1.INDEXABLE_EXTENSIONS.has(basename)) {
+        return false;
+    }
+    const withinSize = (s) => s > 0 && s <= config_1.MAX_FILE_SIZE_BYTES;
+    if (typeof size === "number") {
+        return withinSize(size);
+    }
+    try {
+        const stats = fs.statSync(filePath);
+        return withinSize(stats.size);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function isIndexablePath(filePath) {
+    return isIndexableFile(filePath);
+}
+function formatDenseSnippet(text, maxLength = 1500) {
+    const clean = text !== null && text !== void 0 ? text : "";
+    if (clean.length <= maxLength)
+        return clean;
+    return `${clean.slice(0, maxLength)}...`;
+}
+function isDevelopment() {
+    // Return false when running from within node_modules
+    if (__dirname.includes("node_modules")) {
+        return false;
+    }
+    // Return true only when NODE_ENV is explicitly "development"
+    if (process.env.NODE_ENV === "development") {
+        return true;
+    }
+    // Otherwise return false (production/other environments)
+    return false;
+}

package/dist/lib/utils/filter-builder.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeSqlString = escapeSqlString;
+exports.normalizePath = normalizePath;
+function escapeSqlString(str) {
+    // LanceDB (via DataFusion) treats backslashes literally in standard strings.
+    // We only need to escape single quotes by doubling them.
+    return str.replace(/'/g, "''");
+}
+/**
+ * Normalizes a path to use forward slashes, ensuring consistency across platforms.
+ * @param p The path to normalize
+ * @returns The normalized path with forward slashes
+ */
+function normalizePath(p) {
+    return p.replace(/\\/g, "/");
+}

package/dist/lib/utils/formatter.js

@@ -0,0 +1,230 @@
+"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.formatTextResults = formatTextResults;
+const path = __importStar(require("node:path"));
+const cli_highlight_1 = require("cli-highlight");
+const style = {
+    bold: (s) => `\x1b[1m${s}\x1b[22m`,
+    dim: (s) => `\x1b[2m${s}\x1b[22m`,
+    green: (s) => `\x1b[32m${s}\x1b[39m`,
+    blue: (s) => `\x1b[34m${s}\x1b[39m`,
+};
+const languages_1 = require("../core/languages");
+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 cleanSnippetLines(snippet) {
+    const NOISE_PREFIXES = [
+        "File:",
+        "Top comments:",
+        "Preamble:",
+        "(anchor)",
+        "Imports:",
+        "Exports:",
+        "---",
+    ];
+    return snippet
+        .split("\n")
+        .map((line) => {
+        let next = line.trimEnd();
+        // Strip inline metadata that sometimes gets glued onto code lines
+        const fileIdx = next.indexOf("File:");
+        if (fileIdx !== -1) {
+            next = next.slice(0, fileIdx).trimEnd();
+        }
+        return next;
+    })
+        .filter((line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return false;
+        return !NOISE_PREFIXES.some((p) => trimmed.startsWith(p));
+    })
+        .map((line) => {
+        const limit = 140;
+        if (line.length <= limit)
+            return line;
+        return `${line.slice(0, limit)}${style.dim(" ...")}`;
+    });
+}
+/**
+ * Formats search results for display (agent plain mode or human pretty mode).
+ * Supports compact (paths only), score display, and content truncation options.
+ */
+function formatTextResults(results, query, root, options) {
+    var _a, _b, _c;
+    if (results.length === 0)
+        return `osgrep: No results found for "${query}".`;
+    // --- MODE: COMPACT (File paths only) ---
+    if (options.compact) {
+        const uniquePaths = Array.from(new Set(results.map((r) => r.path))).sort();
+        return uniquePaths.map((p) => path.relative(root, p)).join("\n");
+    }
+    const fileGroups = new Map();
+    results.forEach((r) => {
+        const existing = fileGroups.get(r.path) || [];
+        existing.push(r);
+        fileGroups.set(r.path, existing);
+    });
+    const fileCount = fileGroups.size;
+    // --- MODE A: AGENT (Hyper-Dense) ---
+    // Goal: Max information density per token.
+    // --- MODE A: AGENT (Hyper-Dense) ---
+    // Goal: Max information density per token.
+    if (options.isPlain) {
+        let output = "";
+        // Keep snippets compact but present so agents still see the code.
+        const maxLines = 20;
+        results.forEach((item) => {
+            const relPath = path.relative(root, item.path);
+            const line = Math.max(1, item.start_line + 1);
+            // 1. Semantic Tags (The Agent's Guide)
+            const tags = [];
+            const type = item.chunk_type || "";
+            if (type.match(/function|class|method/))
+                tags.push("Definition");
+            const isTestPath = /(^|\/)(__tests__|tests?|specs?)(\/|$)/i.test(relPath) ||
+                /\.(test|spec)\.[cm]?[jt]sx?$/i.test(relPath);
+            if (isTestPath)
+                tags.push("Test");
+            const tagStr = tags.length > 0 ? ` [${tags.join(",")}]` : "";
+            const lines = cleanSnippetLines(item.content);
+            const truncated = !options.content && lines.length > maxLines
+                ? [
+                    ...lines.slice(0, maxLines),
+                    `... (+${lines.length - maxLines} more lines)`,
+                ]
+                : lines;
+            const scoreStr = options.showScores
+                ? ` ${style.dim(`(score: ${item.score.toFixed(3)})`)}`
+                : "";
+            output += `${relPath}:${line}${scoreStr}${tagStr}\n`;
+            truncated.forEach((ln) => {
+                output += `  ${ln}\n`;
+            });
+            output += "\n";
+        });
+        output += `osgrep results (${results.length} matches across ${fileCount} files)`;
+        return output.trim();
+    }
+    // --- MODE B: HUMAN (Pretty) ---
+    // First pass: merge chunks and count actual displayed results
+    const mergedGroups = [];
+    for (const [filePath, chunks] of fileGroups) {
+        // 1. Sort by score descending (best matches first)
+        chunks.sort((a, b) => b.score - a.score);
+        // 2. Apply per-file limit
+        const limit = (_a = options.perFile) !== null && _a !== void 0 ? _a : 1000;
+        const limitedChunks = chunks.slice(0, limit);
+        // 3. Re-sort by line number for display
+        limitedChunks.sort((a, b) => a.start_line - b.start_line);
+        // Smart Stitching Logic
+        const merged = [];
+        if (limitedChunks.length > 0) {
+            let current = limitedChunks[0];
+            for (let i = 1; i < limitedChunks.length; i++) {
+                const next = limitedChunks[i];
+                if (next.start_line <= current.end_line + 10) {
+                    current.content += `\n   // ...\n${next.content}`;
+                    current.end_line = next.end_line;
+                    if ((_b = next.chunk_type) === null || _b === void 0 ? void 0 : _b.match(/function|class/))
+                        current.chunk_type = next.chunk_type;
+                }
+                else {
+                    merged.push(current);
+                    current = Object.assign({}, next);
+                }
+            }
+            merged.push(current);
+        }
+        mergedGroups.push({ filePath, merged });
+    }
+    const displayedCount = mergedGroups.reduce((sum, g) => sum + g.merged.length, 0);
+    let output = `\n${style.bold(`osgrep results (query: "${query}", ${displayedCount} matches across ${fileCount} files)`)}\n`;
+    let rank = 1;
+    for (const { filePath, merged } of mergedGroups) {
+        const relPath = path.relative(root, filePath);
+        for (const item of merged) {
+            const tags = [];
+            if ((_c = item.chunk_type) === null || _c === void 0 ? void 0 : _c.match(/function|class/))
+                tags.push("Definition");
+            const tagStr = tags.length > 0 ? ` ${style.blue(`[${tags.join(", ")}]`)}` : "";
+            const line = Math.max(1, item.start_line + 1);
+            const snippet = item.content
+                .trim()
+                .replace(/^File:.*\n/, "")
+                .replace(/^Function:.*\n/, "")
+                .trim();
+            const lines = cleanSnippetLines(snippet);
+            const maxLines = 12;
+            const truncated = !options.content && lines.length > maxLines
+                ? [
+                    ...lines.slice(0, maxLines),
+                    style.dim(`... (+${lines.length - maxLines} more lines)`),
+                ]
+                : lines;
+            // Apply syntax highlighting for humans
+            let rendered = truncated.join("\n");
+            try {
+                const lang = detectLanguage(filePath);
+                rendered = (0, cli_highlight_1.highlight)(rendered, {
+                    language: lang,
+                    ignoreIllegals: true,
+                });
+            }
+            catch (_d) {
+                // fall back to non-highlighted text
+            }
+            const scoreStr = options.showScores
+                ? ` ${style.dim(`(score: ${item.score.toFixed(3)})`)}`
+                : "";
+            output += `${rank}) 📂 ${style.green(relPath)}${style.dim(`:${line}`)}${tagStr}${scoreStr}\n`;
+            const numbered = rendered.split("\n").map((ln, idx) => {
+                const num = style.dim(`${line + idx}`.padStart(4));
+                return `${num} │ ${ln}`;
+            });
+            numbered.forEach((ln) => {
+                output += `${ln}\n`;
+            });
+            output += "\n";
+            rank++;
+        }
+    }
+    output += style.dim(`${displayedCount} matches across ${fileCount} files`);
+    return output.trimEnd();
+}

package/dist/lib/utils/git.js

@@ -0,0 +1,83 @@
+"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.isWorktree = isWorktree;
+exports.getGitCommonDir = getGitCommonDir;
+exports.getMainRepoRoot = getMainRepoRoot;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function isWorktree(dir) {
+    const gitPath = path.join(dir, ".git");
+    try {
+        const stats = fs.statSync(gitPath);
+        return stats.isFile();
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function getGitCommonDir(worktreeRoot) {
+    const gitPath = path.join(worktreeRoot, ".git");
+    try {
+        const content = fs.readFileSync(gitPath, "utf-8").trim();
+        if (!content.startsWith("gitdir: "))
+            return null;
+        const gitDir = content.slice(8).trim();
+        const absGitDir = path.resolve(worktreeRoot, gitDir);
+        const commonDirFile = path.join(absGitDir, "commondir");
+        if (fs.existsSync(commonDirFile)) {
+            const commonPath = fs.readFileSync(commonDirFile, "utf-8").trim();
+            return path.resolve(absGitDir, commonPath);
+        }
+        // Fallback: assume standard structure
+        return path.resolve(absGitDir, "../../");
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/**
+ * Resolves the main repository root from a worktree root.
+ */
+function getMainRepoRoot(worktreeRoot) {
+    if (!isWorktree(worktreeRoot))
+        return null;
+    const commonDir = getGitCommonDir(worktreeRoot);
+    if (!commonDir)
+        return null;
+    // The common dir is usually .git inside the main repo root.
+    // So the main repo root is the parent of commonDir.
+    return path.dirname(commonDir);
+}

package/dist/lib/utils/lock.js

@@ -0,0 +1,157 @@
+"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.acquireWriterLock = acquireWriterLock;
+exports.acquireWriterLockWithRetry = acquireWriterLockWithRetry;
+exports.isLocked = isLocked;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+function parseLock(lockPath) {
+    try {
+        const contents = fs.readFileSync(lockPath, "utf-8").trim();
+        const [pidLine, ts] = contents.split("\n");
+        const pid = Number.parseInt(pidLine !== null && pidLine !== void 0 ? pidLine : "", 10);
+        return { pid: Number.isFinite(pid) ? pid : null, startedAt: ts };
+    }
+    catch (_a) {
+        return { pid: null };
+    }
+}
+function isProcessAlive(pid) {
+    if (!pid || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        const code = err === null || err === void 0 ? void 0 : err.code;
+        // ESRCH: no such process. EPERM means the process exists but we lack permission.
+        if (code === "ESRCH")
+            return false;
+        return true;
+    }
+}
+function removeLock(lockPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield fs.promises.unlink(lockPath);
+        }
+        catch (err) {
+            if ((err === null || err === void 0 ? void 0 : err.code) !== "ENOENT") {
+                throw err;
+            }
+        }
+    });
+}
+function acquireWriterLock(lockDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const lockPath = path.join(lockDir, "LOCK");
+        const writeLock = () => __awaiter(this, void 0, void 0, function* () {
+            yield fs.promises.writeFile(lockPath, `${process.pid}\n${new Date().toISOString()}`, { flag: "wx" });
+        });
+        try {
+            yield writeLock();
+        }
+        catch (err) {
+            const code = err === null || err === void 0 ? void 0 : err.code;
+            if (code !== "EEXIST")
+                throw err;
+            const { pid, startedAt } = parseLock(lockPath);
+            const alive = isProcessAlive(pid);
+            if (!alive) {
+                yield removeLock(lockPath);
+                yield writeLock();
+            }
+            else {
+                const holderDesc = pid
+                    ? `${pid}${startedAt ? ` @ ${startedAt}` : ""}`
+                    : "unknown";
+                throw new Error(`.osgrep lock already held (${holderDesc}). Another indexing process is running or the lock must be cleared.`);
+            }
+        }
+        return {
+            release: () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield removeLock(lockPath);
+                }
+                catch (err) {
+                    console.warn("[lock] Failed to remove lock:", err);
+                }
+            }),
+        };
+    });
+}
+function acquireWriterLockWithRetry(lockDir, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const maxRetries = (_a = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _a !== void 0 ? _a : 5;
+        const retryDelayMs = (_b = options === null || options === void 0 ? void 0 : options.retryDelayMs) !== null && _b !== void 0 ? _b : 1000;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                return yield acquireWriterLock(lockDir);
+            }
+            catch (err) {
+                const isLockHeld = err instanceof Error && err.message.includes("lock already held");
+                if (!isLockHeld || attempt === maxRetries - 1) {
+                    throw err;
+                }
+                yield new Promise((resolve) => setTimeout(resolve, retryDelayMs * (attempt + 1)));
+            }
+        }
+        throw new Error("Failed to acquire lock after retries");
+    });
+}
+function isLocked(lockDir) {
+    try {
+        const lockPath = path.join(lockDir, "LOCK");
+        if (!fs.existsSync(lockPath))
+            return false;
+        const { pid } = parseLock(lockPath);
+        return isProcessAlive(pid);
+    }
+    catch (_a) {
+        return false;
+    }
+}