@travisennis/acai 0.0.9 → 0.0.11

package/dist/tools/grep.js

@@ -1,7 +1,8 @@
-import { execSync } from "node:child_process";
+import { execFile, } from "node:child_process";
 import { inspect } from "node:util";
 import { z } from "zod";
 import style from "../terminal/style.js";
+import { toDisplayPath } from "../utils/filesystem/path-display.js";
 import { convertNullString } from "../utils/zod.js";
 // default limit
 const DEFAULT_MAX_RESULTS = 100;
@@ -38,7 +39,7 @@ const inputSchema = z.object({
 export const createGrepTool = () => {
     return {
         toolDef: {
-            description: `Search files for patterns using ripgrep (rg). Uses glob patterns for file filtering (e.g., "*.ts", "**/*.test.ts"). Auto-detects unbalanced regex patterns and falls back to fixed-string search for safety. Results are automatically limited to prevent overwhelming output using a hybrid approach: ripgrep's --max-count flag limits matches per file for efficiency, and post-processing ensures reasonable result counts. Default limit is ${DEFAULT_MAX_RESULTS} matches. Use maxResults parameter to override this limit.`,
+            description: "Search file contents using ripgrep.",
             inputSchema,
         },
         display({ pattern, path, filePattern, recursive, ignoreCase, contextLines, }) {
@@ -47,7 +48,8 @@ export const createGrepTool = () => {
                 ? null
                 : filePattern;
             // Enhanced tool-init with detailed search parameters
-            let initMessage = `${style.cyan(inspect(pattern))} in ${style.cyan(path)}`;
+            const displayPath = toDisplayPath(path);
+            let initMessage = `${style.cyan(inspect(pattern))} in ${style.cyan(displayPath)}`;
             if (safeFilePattern) {
                 initMessage += ` ${style.dim(`(filter: ${safeFilePattern})`)}`;
             }
@@ -66,7 +68,11 @@ export const createGrepTool = () => {
             if (abortSignal?.aborted) {
                 throw new Error("Grep search aborted");
             }
+            // Validate path - default to cwd if not provided
+            const effectivePath = typeof path === "string" && path.trim() !== "" ? path : process.cwd();
             try {
+                // Compute likelyUnbalancedRegex once and pass through
+                const isLikelyUnbalanced = likelyUnbalancedRegex(pattern);
                 let effectiveLiteral = null;
                 if (literal === true) {
                     effectiveLiteral = true;
@@ -75,23 +81,13 @@ export const createGrepTool = () => {
                     effectiveLiteral = false;
                 }
                 else {
-                    try {
-                        if (likelyUnbalancedRegex(pattern)) {
-                            effectiveLiteral = true;
-                        }
-                        else {
-                            effectiveLiteral = false;
-                        }
-                    }
-                    catch (_err) {
-                        effectiveLiteral = false;
-                    }
+                    effectiveLiteral = isLikelyUnbalanced;
                 }
                 const effectiveMaxResults = maxResults ?? DEFAULT_MAX_RESULTS;
                 const safeFilePattern = filePattern === "null" || filePattern === "undefined"
                     ? null
                     : filePattern;
-                const grepResult = grepFilesStructured(pattern, path, {
+                const grepResult = await grepFilesStructured(pattern, effectivePath, {
                     recursive,
                     ignoreCase,
                     filePattern: safeFilePattern,
@@ -99,21 +95,22 @@ export const createGrepTool = () => {
                     searchIgnored,
                     literal: effectiveLiteral,
                     maxResults: effectiveMaxResults,
-                });
+                    likelyUnbalanced: isLikelyUnbalanced,
+                }, abortSignal);
                 return grepResult.rawOutput;
             }
             catch (error) {
                 const errorMessage = error.message;
-                let userFriendlyError = `Error searching for "${pattern}" in ${path}: ${errorMessage}`;
+                let userFriendlyError = `Error searching for "${pattern}" in ${effectivePath}: ${errorMessage}`;
                 if (errorMessage.includes("No such file or directory")) {
-                    userFriendlyError = `Path not found: "${path}"`;
+                    userFriendlyError = `Path not found: "${effectivePath}"`;
                     if (filePattern) {
                         userFriendlyError += ` with file pattern "${filePattern}"`;
                     }
                     userFriendlyError += " - check if the path exists and is accessible";
                 }
                 else if (errorMessage.includes("permission denied")) {
-                    userFriendlyError = `Permission denied accessing "${path}"`;
+                    userFriendlyError = `Permission denied accessing "${effectivePath}"`;
                 }
                 else if (errorMessage.includes("Regex parse error")) {
                     userFriendlyError = `Invalid search pattern "${pattern}" - try using literal=true for fixed-string search`;
@@ -123,7 +120,107 @@ export const createGrepTool = () => {
         },
     };
 };
-export function likelyUnbalancedRegex(pattern) {
+/**
+ * Skips past a character class [...], handling escaped characters.
+ * Returns the new index after the character class.
+ */
+function skipCharacterClass(pattern, startIndex) {
+    let i = startIndex + 1;
+    while (i < pattern.length && pattern[i] !== "]") {
+        if (pattern[i] === "\\")
+            i++;
+        i++;
+    }
+    return i;
+}
+/**
+ * Checks if a character is valid inside braces (digits 0-9 or comma).
+ */
+function isValidBraceChar(c) {
+    return (c >= "0" && c <= "9") || c === ",";
+}
+/**
+ * Checks if empty braces have a preceding atom.
+ * Empty braces with no preceding atom are treated as literal.
+ */
+function hasPrecedingAtom(pattern, startIndex) {
+    if (startIndex === 0)
+        return false;
+    const prev = pattern[startIndex - 1];
+    return /\S/.test(prev);
+}
+/**
+ * Parses and validates the content inside braces {..}.
+ * Returns true if the brace content is invalid.
+ */
+function isInvalidBraceContent(pattern, startIndex) {
+    const j = startIndex + 1;
+    // Find closing brace and check for invalid characters
+    let hasDigits = false;
+    let k = j;
+    while (k < pattern.length && pattern[k] !== "}") {
+        if (!isValidBraceChar(pattern[k])) {
+            return true;
+        }
+        if (pattern[k] >= "0" && pattern[k] <= "9") {
+            hasDigits = true;
+        }
+        k++;
+    }
+    // No closing brace found
+    if (k >= pattern.length) {
+        return true;
+    }
+    // Empty braces {} with preceding atom are invalid
+    if (!hasDigits && hasPrecedingAtom(pattern, startIndex)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Check for invalid repetition operators (e.g., {n}, {n,}, {n,m}) outside of character classes.
+ * Returns true if any invalid repetition operators are found.
+ */
+function hasInvalidRepetition(pattern) {
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === "\\") {
+            i++; // Skip the next character (escaped)
+            continue;
+        }
+        if (ch === "[") {
+            i = skipCharacterClass(pattern, i);
+            continue;
+        }
+        // Unmatched closing brace is invalid
+        if (ch === "}") {
+            return true;
+        }
+        // Handle opening brace
+        if (ch === "{") {
+            if (isInvalidBraceContent(pattern, i)) {
+                return true;
+            }
+            i = findClosingBrace(pattern, i);
+        }
+    }
+    return false;
+}
+/**
+ * Finds the index of the closing brace matching an opening brace.
+ * Returns the index of the closing brace, or the last index of pattern if not found.
+ */
+function findClosingBrace(pattern, startIndex) {
+    let j = startIndex + 1;
+    while (j < pattern.length && pattern[j] !== "}") {
+        j++;
+    }
+    return j;
+}
+/**
+ * Count bracket/paren/brace pairs in a regex pattern, excluding character classes.
+ */
+function countBrackets(pattern) {
     const counts = {
         openParen: 0,
         closeParen: 0,
@@ -175,91 +272,56 @@ export function likelyUnbalancedRegex(pattern) {
             }
         }
     }
+    return counts;
+}
+/**
+ * Check if a pattern contains regex metacharacters.
+ * Returns true if the pattern likely needs regex mode.
+ */
+function containsRegexMetacharacters(pattern) {
+    // Regex metacharacters: ^ $ . * + ? [ ] ( ) { } | \
+    const metacharacterPattern = /[\^$.*+?[\](){}|\\]/;
+    return metacharacterPattern.test(pattern);
+}
+export function likelyUnbalancedRegex(pattern) {
+    // First check: unbalanced brackets/parentheses/braces = likely a typo, use literal
+    const counts = countBrackets(pattern);
     // Check for unbalanced brackets, parentheses, and braces
     const hasUnbalancedBrackets = counts.openBracket !== counts.closeBracket;
     const hasUnbalancedParens = counts.openParen !== counts.closeParen;
     const hasUnbalancedBraces = counts.openBrace !== counts.closeBrace;
-    // Also check for invalid repetition operators (e.g., {n}, {n,}, {n,m}) outside of character classes
-    let hasInvalidRepetition = false;
-    {
-        let escaped2 = false;
-        let inClass2 = false;
-        for (let i = 0; i < pattern.length; i++) {
-            const ch = pattern[i];
-            if (escaped2) {
-                escaped2 = false;
-                continue;
-            }
-            if (ch === "\\") {
-                escaped2 = true;
-                continue;
-            }
-            if (ch === "[" && !inClass2) {
-                inClass2 = true;
-                continue;
-            }
-            if (ch === "]" && inClass2) {
-                inClass2 = false;
-                continue;
-            }
-            if (inClass2) {
-                continue;
-            }
-            if (ch === "{") {
-                let j = i + 1;
-                let hasDigits = false;
-                let hasComma = false;
-                while (j < pattern.length && pattern[j] !== "}") {
-                    const c = pattern[j];
-                    if (c >= "0" && c <= "9") {
-                        hasDigits = true;
-                    }
-                    else if (c === "," && !hasComma) {
-                        hasComma = true;
-                    }
-                    else {
-                        break;
-                    }
-                    j++;
-                }
-                if (j >= pattern.length || pattern[j] !== "}") {
-                    hasInvalidRepetition = true;
-                    break;
-                }
-                // At this point we have a closing brace at j
-                if (!hasDigits) {
-                    // Heuristic: treat empty {} as non-quantifier when it doesn't follow a likely atom
-                    const prev = i > 0 ? pattern[i - 1] : undefined;
-                    if (prev !== undefined && /\S/.test(prev)) {
-                        hasInvalidRepetition = true;
-                        break;
-                    }
-                    // else ignore as literal braces
-                }
-            }
-        }
-    }
-    return (hasUnbalancedBrackets ||
+    // Also check for invalid repetition operators
+    const hasInvalidRepetitionFlag = hasInvalidRepetition(pattern);
+    // If pattern has unbalanced syntax, treat as literal (user probably meant to type literal)
+    if (hasUnbalancedBrackets ||
         hasUnbalancedParens ||
         hasUnbalancedBraces ||
-        hasInvalidRepetition);
+        hasInvalidRepetitionFlag) {
+        return true;
+    }
+    // Second check: if pattern has regex metacharacters, treat as regex (return false)
+    // This allows ripgrep to handle the pattern as a proper regex
+    if (containsRegexMetacharacters(pattern)) {
+        return false;
+    }
+    // Default: simple alphanumeric strings should use literal mode
+    return true;
 }
 /**
- * Search files for patterns using ripgrep
+ * Build grep command args array directly
  *
  * @param pattern - The regex pattern to search for
  * @param path - The path to search in
  * @param options - Additional options for the grep command
- * @returns The result of the grep command
+ * @returns The args array for the grep command
  */
-export function buildGrepCommand(pattern, path, options = {}) {
+export function buildGrepArgs(pattern, path, options = {}) {
     const effectiveRecursive = options.recursive === null ? true : options.recursive;
     const effectiveIgnoreCase = options.ignoreCase === null ? false : options.ignoreCase;
     const effectiveSearchIgnored = options.searchIgnored === null ? false : options.searchIgnored;
     const effectiveFilePattern = options.filePattern;
     const effectiveContextLines = options.contextLines;
-    // Determine literal handling: if options.literal is explicitly provided, use it.
-    // If null/undefined, auto-detect unbalanced regexes and prefer fixed-strings.
+    // Use the pre-computed likelyUnbalanced result if available
     let effectiveLiteral;
     if (options.literal === true) {
         effectiveLiteral = true;
@@ -267,27 +329,30 @@ export function buildGrepCommand(pattern, path, options = {}) {
     else if (options.literal === false) {
         effectiveLiteral = false;
     }
+    else if (options.likelyUnbalanced !== undefined) {
+        effectiveLiteral = options.likelyUnbalanced;
+    }
     else {
         effectiveLiteral = likelyUnbalancedRegex(pattern);
     }
-    let command = "rg --line-number";
+    const args = ["--json"];
     if (effectiveRecursive === false) {
-        command += " --max-depth=0";
+        args.push("--max-depth=0");
     }
     if (effectiveIgnoreCase) {
-        command += " --ignore-case";
+        args.push("--ignore-case");
     }
     if (effectiveContextLines !== null && effectiveContextLines !== undefined) {
-        command += ` --context=${effectiveContextLines}`;
+        args.push(`--context=${effectiveContextLines}`);
     }
     if (effectiveFilePattern !== null && effectiveFilePattern !== undefined) {
-        command += ` --glob=${JSON.stringify(effectiveFilePattern)}`;
+        args.push(`--glob=${effectiveFilePattern}`);
     }
     if (effectiveSearchIgnored) {
-        command += " --no-ignore";
+        args.push("--no-ignore");
     }
     if (effectiveLiteral) {
-        command += " -F";
+        args.push("-F");
     }
     // Use ripgrep's --max-count flag to limit matches per file for efficiency
     // This helps prevent any single file from dominating results
@@ -296,82 +361,88 @@ export function buildGrepCommand(pattern, path, options = {}) {
         options.maxResults > 0) {
         // Use a reasonable per-file limit (max 100 per file) to balance efficiency and completeness
         const perFileLimit = Math.min(options.maxResults, 100);
-        command += ` --max-count=${perFileLimit}`;
+        args.push(`--max-count=${perFileLimit}`);
     }
-    command += ` ${JSON.stringify(pattern)}`;
-    command += ` ${JSON.stringify(path)}`;
-    return command;
+    args.push(pattern);
+    args.push(path);
+    return args;
 }
 /**
- * Parse ripgrep output and extract structured match information
+ * Parse ripgrep JSON output and extract structured match information
  */
-export function parseRipgrepOutput(content) {
-    if (content === "No matches found.") {
+export function parseRipgrepJsonOutput(content) {
+    if (!content || content.trim() === "") {
         return [];
     }
-    const lines = content.trim().split("\n");
     const parsed = [];
+    const lines = content.trim().split("\n");
     for (const line of lines) {
-        if (line === "--") {
-            // Separator between file groups - skip
-            continue;
-        }
-        if (line.trim() === "") {
-            // Empty line - skip
+        if (!line.trim()) {
             continue;
         }
-        // Try multi-file format: file:line:content
-        const multiFileMatch = line.match(/^([^:]+):(\d+):(.+)$/);
-        if (multiFileMatch) {
-            parsed.push({
-                file: multiFileMatch[1],
-                line: Number.parseInt(multiFileMatch[2], 10),
-                content: multiFileMatch[3],
-                isMatch: true,
-            });
-            continue;
-        }
-        // Try single-file format: line:content
-        const singleFileMatch = line.match(/^(\d+):(.+)$/);
-        if (singleFileMatch) {
-            parsed.push({
-                line: Number.parseInt(singleFileMatch[1], 10),
-                content: singleFileMatch[2],
-                isMatch: true,
-            });
-            continue;
+        try {
+            const rgResult = JSON.parse(line);
+            // Handle different ripgrep message types
+            if (rgResult.type === "match") {
+                const data = rgResult.data;
+                parsed.push({
+                    file: data.path?.text ?? data.path?.bytes?.toString(),
+                    line: data.line_number ?? 0,
+                    content: data.lines?.text ?? data.line ?? "",
+                    isMatch: true,
+                    lineNumber: data.line_number,
+                    absolutePath: data.absolute_path?.text ?? data.absolute_path?.bytes?.toString(),
+                    submatches: data.submatches?.map((sm) => ({
+                        start: sm.start,
+                        end: sm.end,
+                        text: sm.text,
+                    })),
+                });
+            }
+            else if (rgResult.type === "context") {
+                const data = rgResult.data;
+                parsed.push({
+                    file: data.path?.text ?? data.path?.bytes?.toString(),
+                    line: data.line_number ?? 0,
+                    content: data.lines?.text ?? data.line ?? "",
+                    isMatch: false,
+                    isContext: true,
+                    lineNumber: data.line_number,
+                    absolutePath: data.absolute_path?.text ?? data.absolute_path?.bytes?.toString(),
+                });
+            }
+            // Ignore other message types like "begin", "end", "summary"
         }
-        // Try context line format: file-line-context
-        const contextMatch = line.match(/^([^:]+)-(\d+)-(.+)$/);
-        if (contextMatch) {
-            parsed.push({
-                file: contextMatch[1],
-                line: Number.parseInt(contextMatch[2], 10),
-                content: contextMatch[3],
-                isMatch: false,
-                isContext: true,
-            });
-            continue;
+        catch { }
+    }
+    return parsed;
+}
+/**
+ * Convert parsed JSON matches back to legacy line-number format for backwards compatibility
+ */
+function matchesToLegacyFormat(matches) {
+    const lines = [];
+    for (const match of matches) {
+        const lineNum = match.lineNumber ?? match.line;
+        const file = match.file ?? match.absolutePath;
+        if (file) {
+            if (match.isMatch) {
+                lines.push(`${file}:${lineNum}:${match.content}`);
+            }
+            else if (match.isContext) {
+                lines.push(`${file}-${lineNum}-${match.content}`);
+            }
         }
-        // Try context line format without file: line-context
-        const contextNoFileMatch = line.match(/^(\d+)-(.+)$/);
-        if (contextNoFileMatch) {
-            parsed.push({
-                line: Number.parseInt(contextNoFileMatch[1], 10),
-                content: contextNoFileMatch[2],
-                isMatch: false,
-                isContext: true,
-            });
-            continue;
+        else {
+            if (match.isMatch) {
+                lines.push(`${lineNum}:${match.content}`);
+            }
+            else if (match.isContext) {
+                lines.push(`${lineNum}-${match.content}`);
+            }
         }
-        // If we get here, it's an unrecognized format - treat as match for backwards compatibility
-        parsed.push({
-            content: line,
-            line: 0,
-            isMatch: true,
-        });
     }
-    return parsed;
+    return lines.join("\n");
 }
 /**
  * Count actual matches (excluding context lines)
@@ -385,81 +456,134 @@ export function countActualMatches(parsed) {
 export function countContextLines(parsed) {
     return parsed.filter((match) => match.isContext).length;
 }
+function isContextNearKeptMatch(matches, index, indicesToKeep, contextWindow) {
+    for (let j = index - 1; j >= Math.max(0, index - contextWindow); j--) {
+        if (matches[j].isMatch && !matches[j].isContext && indicesToKeep.has(j)) {
+            return true;
+        }
+    }
+    for (let j = index + 1; j < Math.min(matches.length, index + contextWindow + 1); j++) {
+        if (matches[j].isMatch && !matches[j].isContext && indicesToKeep.has(j)) {
+            return true;
+        }
+    }
+    return false;
+}
 /**
- * Truncate matches to a maximum number of results
+ * Truncate matches to a maximum number of results, preserving context lines for kept matches
  */
 export function truncateMatches(matches, maxResults) {
     if (!maxResults || maxResults <= 0) {
         return { truncated: matches, isTruncated: false };
     }
-    const actualMatches = matches.filter((m) => m.isMatch && !m.isContext);
-    if (actualMatches.length <= maxResults) {
+    // Find indices of actual matches (excluding context lines)
+    const matchIndices = [];
+    for (let i = 0; i < matches.length; i++) {
+        if (matches[i].isMatch && !matches[i].isContext) {
+            matchIndices.push(i);
+        }
+    }
+    if (matchIndices.length <= maxResults) {
         return { truncated: matches, isTruncated: false };
     }
+    // Get the indices of matches we want to keep
+    const indicesToKeep = new Set();
+    for (let i = 0; i < maxResults; i++) {
+        indicesToKeep.add(matchIndices[i]);
+    }
+    // Build truncated result: include all kept matches AND their associated context lines
     const truncated = [];
     let matchesKept = 0;
-    for (const match of matches) {
+    const contextWindow = 3; // Include up to 3 context lines around each match
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
         if (match.isMatch && !match.isContext) {
+            // This is an actual match
             if (matchesKept < maxResults) {
                 truncated.push(match);
                 matchesKept++;
             }
             else {
-                break;
             }
         }
+        else if (match.isContext) {
+            if (isContextNearKeptMatch(matches, i, indicesToKeep, contextWindow)) {
+                truncated.push(match);
+            }
+        }
+        else {
+            // Other types, include them
+            truncated.push(match);
+        }
     }
     return {
         truncated,
         isTruncated: true,
     };
 }
-/**
- * Extract matches from content (backwards compatibility wrapper)
- */
-export function extractMatches(content) {
-    const parsed = parseRipgrepOutput(content);
-    const matches = parsed.filter((match) => match.isMatch && !match.isContext);
-    // Convert back to original string format for backwards compatibility
-    return matches.map((match) => {
-        if (match.file) {
-            return `${match.file}:${match.line}:${match.content}`;
-        }
-        return `${match.line}:${match.content}`;
-    });
-}
-export function grepFiles(pattern, path, options = {}) {
-    const result = grepFilesStructured(pattern, path, options);
-    return result.rawOutput;
-}
-export function grepFilesStructured(pattern, path, options = {}) {
+export async function grepFilesStructured(pattern, path, options = {}, abortSignal) {
     try {
-        const command = buildGrepCommand(pattern, path, options);
-        const rawOutput = execSync(command, {
-            encoding: "utf-8",
-            stdio: ["pipe", "pipe", "pipe"],
+        const args = buildGrepArgs(pattern, path, options);
+        // Use execFile for async execution with proper abort signal handling
+        const rawOutput = await new Promise((resolve, reject) => {
+            const child = execFile("rg", args, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.on("data", (data) => {
+                stdout += data;
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data;
+            });
+            child.on("close", (code) => {
+                if (code === 0 || code === 1) {
+                    resolve(stdout);
+                }
+                else {
+                    reject(new Error(stderr || `ripgrep exited with code ${code}`));
+                }
+            });
+            child.on("error", (err) => {
+                reject(err);
+            });
+            if (abortSignal) {
+                abortSignal.addEventListener("abort", () => {
+                    child.kill("SIGTERM");
+                    reject(new Error("Grep search aborted"));
+                });
+            }
         });
-        const parsedMatches = parseRipgrepOutput(rawOutput);
+        // Parse JSON output from ripgrep
+        const parsedMatches = parseRipgrepJsonOutput(rawOutput);
+        // If JSON parsing resulted in no matches, check if it's a "no matches" case
+        // (ripgrep --json returns empty for no matches)
+        const hasMatches = parsedMatches.length > 0;
         const matchCount = countActualMatches(parsedMatches);
         // Use the maxResults from options (which will be set by the execute function)
         const maxResults = options.maxResults;
         const { truncated, isTruncated } = truncateMatches(parsedMatches, maxResults);
         const displayedCount = countActualMatches(truncated);
         const displayedContextCount = countContextLines(truncated);
+        // Convert to legacy format for backwards compatibility
+        const legacyOutput = matchesToLegacyFormat(truncated);
+        const finalOutput = legacyOutput || "No matches found.";
         return {
-            rawOutput,
+            rawOutput: finalOutput,
             parsedMatches: truncated,
             matchCount,
             displayedCount,
             contextCount: displayedContextCount,
-            hasMatches: matchCount > 0,
+            hasMatches,
             isTruncated,
         };
     }
     catch (error) {
         const execError = error;
-        const exitCode = execError?.status;
-        if (exitCode === 1) {
+        const exitCode = execError.code;
+        if (exitCode === "1") {
             return {
                 rawOutput: "No matches found.",
                 parsedMatches: [],
@@ -468,10 +592,8 @@ export function grepFilesStructured(pattern, path, options = {}) {
                 hasMatches: false,
             };
         }
-        if (exitCode === 2) {
-            const stderrStr = typeof execError.stderr === "string"
-                ? execError.stderr
-                : (execError.stderr?.toString("utf-8") ?? execError.message);
+        if (exitCode === "2") {
+            const stderrStr = execError.message;
             throw new Error(`Regex parse error in pattern "${pattern}": ${stderrStr}`);
         }
         throw new Error(`Error executing ripgrep: ${execError.message}`);