centaurus-cli 3.0.0 → 3.1.0

package/dist/tools/grep-search.js

@@ -1,1005 +1,1023 @@
-import { spawn } from 'child_process';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as readline from 'readline';
+import { spawn } from "child_process";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import * as path from "path";
+import * as fs from "fs";
+import * as readline from "readline";
 const execFileAsync = promisify(execFile);
-// ============================================================================
-// GREP SEARCH TOOL CLASS - CROSS-PLATFORM ROBUST IMPLEMENTATION
-// ============================================================================
-/**
- * GrepSearchTool - Cross-platform text search with multiple backends
- *
- * Backend priority:
- * 1. ripgrep (fastest, cross-platform)
- * 2. grep (Linux/macOS native)
- * 3. PowerShell Select-String (Windows, good Unicode support)
- * 4. Pure Node.js (universal fallback, no dependencies)
- *
- * Features:
- * - Streaming output to handle large repos
- * - Early abort when MAX_MATCHES reached
- * - Proper encoding handling (UTF-8 with fallback)
- * - CRLF normalization
- * - Windows path support (drive letters, UNC)
- */
-export class GrepSearchTool {
-    static DEFAULT_MAX_MATCHES = 50;
-    static MAX_LINE_LENGTH = 300;
-    static CONTEXT_LINES = 2;
-    static SEARCH_TIMEOUT = 30000;
-    // Cache tool availability to avoid repeated checks
-    static toolCache = new Map();
-    /**
-     * Check if a command is available
-     */
-    async hasCommand(cmd, args = ['--version']) {
-        const cacheKey = `${cmd}:${args.join(',')}`;
-        if (GrepSearchTool.toolCache.has(cacheKey)) {
-            return GrepSearchTool.toolCache.get(cacheKey);
-        }
-        try {
-            await Promise.race([
-                execFileAsync(cmd, args, { timeout: 2000 }),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 2000))
-            ]);
-            GrepSearchTool.toolCache.set(cacheKey, true);
-            return true;
-        }
-        catch {
-            GrepSearchTool.toolCache.set(cacheKey, false);
-            return false;
-        }
+function hasUnescapedChar(value, targetChar) {
+  let escaped = false;
+  for (const ch of value) {
+    if (escaped) {
+      escaped = false;
+      continue;
     }
-    async hasRipgrep() {
-        return this.hasCommand('rg', ['--version']);
+    if (ch === "\\") {
+      escaped = true;
+      continue;
     }
-    async hasGrep() {
-        return this.hasCommand('grep', ['--version']);
+    if (ch === targetChar) {
+      return true;
     }
-    async hasPowerShell() {
-        // Try pwsh first (PowerShell Core), then powershell (Windows PowerShell)
-        if (await this.hasCommand('pwsh', ['-Version']))
-            return true;
-        if (process.platform === 'win32') {
-            return this.hasCommand('powershell', ['-Version']);
-        }
-        return false;
+  }
+  return false;
+}
+function looksLikeRegexPattern(value) {
+  const query = value.trim();
+  if (!query) {
+    return false;
+  }
+  if (hasUnescapedChar(query, "|")) {
+    return true;
+  }
+  if (/\\[dDsSwWbBAZzGQEnrtvf0(){}[\].+*?^$|\\]/.test(query)) {
+    return true;
+  }
+  if (query.startsWith("^") || /(^|[^\\])\$$/.test(query)) {
+    return true;
+  }
+  if (/(^|[^\\])\[[^\]]+\]/.test(query)) {
+    return true;
+  }
+  if (/(^|[^\\])\((\?:|\?=|\?!|\?<=|\?<!)/.test(query)) {
+    return true;
+  }
+  if (/(^|[^\\])\{[0-9]+(,[0-9]*)?\}/.test(query)) {
+    return true;
+  }
+  return false;
+}
+function usesRegexFeaturesUnsupportedByGrep(value) {
+  const query = value.trim();
+  if (!query) {
+    return false;
+  }
+  if (/\\[bBkK]/.test(query)) {
+    return true;
+  }
+  if (/\\[pPkK]\{/.test(query)) {
+    return true;
+  }
+  if (/\(\?(?::|=|!|<=|<!|<[^>]+>)/.test(query)) {
+    return true;
+  }
+  if (/(?:\*\?|\+\?|\?\?|\{\d+(?:,\d*)?\}\?)/.test(query)) {
+    return true;
+  }
+  return false;
+}
+function normalizeRegexForGrep(pattern) {
+  let out = "";
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch !== "\\") {
+      out += ch;
+      continue;
     }
-    /**
-     * Get the PowerShell executable name
-     */
-    async getPowerShellExe() {
-        if (await this.hasCommand('pwsh', ['-Version']))
-            return 'pwsh';
-        return 'powershell';
+    if (i + 1 >= pattern.length) {
+      out += "\\";
+      break;
     }
-    /**
-     * Normalize file path to forward slashes
-     */
-    normalizePath(filePath) {
-        return filePath.replace(/\\/g, '/');
+    const next = pattern[i + 1];
+    switch (next) {
+      case "d":
+        out += "[0-9]";
+        break;
+      case "D":
+        out += "[^0-9]";
+        break;
+      case "s":
+        out += "[[:space:]]";
+        break;
+      case "S":
+        out += "[^[:space:]]";
+        break;
+      case "w":
+        out += "[[:alnum:]_]";
+        break;
+      case "W":
+        out += "[^[:alnum:]_]";
+        break;
+      default:
+        out += `\\${next}`;
+        break;
     }
-    /**
-     * Truncate long lines
-     */
-    truncateLine(line) {
-        if (line.length <= GrepSearchTool.MAX_LINE_LENGTH) {
-            return line;
-        }
-        return line.substring(0, GrepSearchTool.MAX_LINE_LENGTH) + ' [truncated]';
+    i++;
+  }
+  return out;
+}
+function escapePowerShellSingleQuoted(value) {
+  return value.replace(/'/g, "''");
+}
+class GrepSearchTool {
+  static DEFAULT_MAX_MATCHES = 50;
+  static MAX_LINE_LENGTH = 300;
+  static CONTEXT_LINES = 2;
+  static SEARCH_TIMEOUT = 3e4;
+  // Cache tool availability to avoid repeated checks
+  static toolCache = /* @__PURE__ */ new Map();
+  /**
+   * Check if a command is available
+   */
+  async hasCommand(cmd, args = ["--version"]) {
+    const cacheKey = `${cmd}:${args.join(",")}`;
+    if (GrepSearchTool.toolCache.has(cacheKey)) {
+      return GrepSearchTool.toolCache.get(cacheKey);
     }
-    /**
-     * Normalize line endings (CRLF -> LF)
-     */
-    normalizeLineEndings(text) {
-        return text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    try {
+      await Promise.race([
+        execFileAsync(cmd, args, { timeout: 2e3 }),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), 2e3))
+      ]);
+      GrepSearchTool.toolCache.set(cacheKey, true);
+      return true;
+    } catch {
+      GrepSearchTool.toolCache.set(cacheKey, false);
+      return false;
     }
-    /**
-     * Parse file:line:content format robustly, handling Windows paths
-     * E.g., "C:\foo\bar.ts:42:content" or "/foo/bar.ts:42:content"
-     */
-    parseGrepLine(line) {
-        // Windows absolute path: C:\path\to\file:line:content
-        const m1 = line.match(/^([A-Za-z]:\\.+?):(\d+):(.*)$/);
-        if (m1)
-            return { file: m1[1], lineNum: +m1[2], content: m1[3] };
-        // UNC path: \\server\share\path:line:content
-        const m2 = line.match(/^(\\\\.+?):(\d+):(.*)$/);
-        if (m2)
-            return { file: m2[1], lineNum: +m2[2], content: m2[3] };
-        // Unix / relative path: /path/to/file:line:content or path/to/file:line:content
-        const m3 = line.match(/^(.+?):(\d+):(.*)$/);
-        if (m3)
-            return { file: m3[1], lineNum: +m3[2], content: m3[3] };
-        return null;
+  }
+  async hasRipgrep() {
+    return this.hasCommand("rg", ["--version"]);
+  }
+  async hasGrep() {
+    return this.hasCommand("grep", ["--version"]);
+  }
+  async hasPowerShell() {
+    if (await this.hasCommand("pwsh", ["-Version"])) return true;
+    if (process.platform === "win32") {
+      return this.hasCommand("powershell", ["-Version"]);
     }
-    /**
-     * Create regex from pattern
-     */
-    createSearchRegex(pattern, isRegex, caseInsensitive) {
-        const flags = caseInsensitive ? 'gi' : 'g';
-        if (isRegex) {
-            try {
-                return new RegExp(pattern, flags);
-            }
-            catch {
-                // Invalid regex, escape and use as literal
-                return new RegExp(this.escapeRegex(pattern), flags);
-            }
-        }
+    return false;
+  }
+  /**
+   * Get the PowerShell executable name
+   */
+  async getPowerShellExe() {
+    if (await this.hasCommand("pwsh", ["-Version"])) return "pwsh";
+    return "powershell";
+  }
+  /**
+   * Normalize file path to forward slashes
+   */
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, "/");
+  }
+  /**
+   * Truncate long lines
+   */
+  truncateLine(line) {
+    if (line.length <= GrepSearchTool.MAX_LINE_LENGTH) {
+      return line;
+    }
+    return line.substring(0, GrepSearchTool.MAX_LINE_LENGTH) + " [truncated]";
+  }
+  /**
+   * Normalize line endings (CRLF -> LF)
+   */
+  normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  }
+  /**
+   * Parse file:line:content format robustly, handling Windows paths
+   * E.g., "C:\foo\bar.ts:42:content" or "/foo/bar.ts:42:content"
+   */
+  parseGrepLine(line) {
+    const m1 = line.match(/^([A-Za-z]:\\.+?):(\d+):(.*)$/);
+    if (m1) return { file: m1[1], lineNum: +m1[2], content: m1[3] };
+    const m2 = line.match(/^(\\\\.+?):(\d+):(.*)$/);
+    if (m2) return { file: m2[1], lineNum: +m2[2], content: m2[3] };
+    const m3 = line.match(/^(.+?):(\d+):(.*)$/);
+    if (m3) return { file: m3[1], lineNum: +m3[2], content: m3[3] };
+    return null;
+  }
+  /**
+   * Create regex from pattern
+   */
+  createSearchRegex(pattern, isRegex, caseInsensitive) {
+    const flags = caseInsensitive ? "gi" : "g";
+    if (isRegex) {
+      try {
+        return new RegExp(pattern, flags);
+      } catch {
         return new RegExp(this.escapeRegex(pattern), flags);
+      }
     }
-    /**
-     * Escape regex special characters
-     */
-    escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(this.escapeRegex(pattern), flags);
+  }
+  /**
+   * Escape regex special characters
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Check if file matches include patterns
+   */
+  matchesIncludesFilter(filePath, includes) {
+    if (!includes || includes.length === 0) {
+      return true;
     }
-    /**
-     * Check if file matches include patterns
-     */
-    matchesIncludesFilter(filePath, includes) {
-        if (!includes || includes.length === 0) {
-            return true;
+    const fileName = path.basename(filePath);
+    const normalizedPath = this.normalizePath(filePath);
+    for (const pattern of includes) {
+      if (pattern.startsWith("*.")) {
+        const ext = pattern.substring(1);
+        if (fileName.endsWith(ext)) {
+          return true;
         }
-        const fileName = path.basename(filePath);
-        const normalizedPath = this.normalizePath(filePath);
-        for (const pattern of includes) {
-            if (pattern.startsWith('*.')) {
-                const ext = pattern.substring(1);
-                if (fileName.endsWith(ext)) {
-                    return true;
-                }
-            }
-            else if (pattern.includes('**')) {
-                const ext = pattern.replace('**/', '').replace('*', '');
-                if (fileName.endsWith(ext) || normalizedPath.includes(ext)) {
-                    return true;
-                }
-            }
-            else if (fileName === pattern || normalizedPath.includes(pattern)) {
-                return true;
-            }
+      } else if (pattern.includes("**")) {
+        const ext = pattern.replace("**/", "").replace("*", "");
+        if (fileName.endsWith(ext) || normalizedPath.includes(ext)) {
+          return true;
         }
-        return false;
+      } else if (fileName === pattern || normalizedPath.includes(pattern)) {
+        return true;
+      }
     }
-    /**
-     * Check if file is likely binary
-     */
-    async isBinaryFile(filePath) {
-        try {
-            const fd = await fs.promises.open(filePath, 'r');
-            const buffer = Buffer.alloc(8192);
-            const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
-            await fd.close();
-            // Check for null bytes (common in binary files)
-            for (let i = 0; i < bytesRead; i++) {
-                if (buffer[i] === 0)
-                    return true;
-            }
-            return false;
-        }
-        catch {
-            return true; // Assume binary on error
-        }
+    return false;
+  }
+  /**
+   * Check if file is likely binary
+   */
+  async isBinaryFile(filePath) {
+    try {
+      const fd = await fs.promises.open(filePath, "r");
+      const buffer = Buffer.alloc(8192);
+      const { bytesRead } = await fd.read(buffer, 0, 8192, 0);
+      await fd.close();
+      for (let i = 0; i < bytesRead; i++) {
+        if (buffer[i] === 0) return true;
+      }
+      return false;
+    } catch {
+      return true;
     }
-    // ========================================================================
-    // RIPGREP BACKEND (Streaming)
-    // ========================================================================
-    async searchWithRipgrepStreaming(params, cwd) {
-        return new Promise((resolve, reject) => {
-            const args = [
-                '--json',
-                `--context=${GrepSearchTool.CONTEXT_LINES}`,
-            ];
-            if (params.CaseInsensitive) {
-                args.push('--ignore-case');
-            }
-            if (!params.IsRegex) {
-                args.push('--fixed-strings');
-            }
-            if (params.Includes && params.Includes.length > 0) {
-                params.Includes.forEach(pattern => {
-                    args.push('--glob', pattern);
-                });
-            }
-            args.push('--', params.Query, params.SearchPath);
-            const matches = [];
-            let truncated = false;
-            let currentFile = null;
-            let contextQueue = [];
-            let pendingMatch = null;
-            let contextAfterCount = 0;
-            // RACECONDITION FIX: Guard against double-resolution
-            let finished = false;
-            const child = spawn('rg', args, {
-                cwd,
-                env: { ...process.env, LANG: 'en_US.UTF-8' }
-            });
-            const rl = readline.createInterface({ input: child.stdout });
-            // Robust cleanup function
-            const done = (result) => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timer);
-                // TERMINATION FIX: Use simple kill() for Windows compatibility
-                child.kill();
-                rl.close();
-                resolve(result);
-            };
-            const fail = (err) => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timer);
-                child.kill();
-                rl.close();
-                reject(err);
-            };
-            const timer = setTimeout(() => {
-                done({
-                    matches,
-                    totalMatches: matches.length,
-                    truncated: true,
-                    truncationReason: 'timeout',
-                    searchPattern: params.Query
-                });
-            }, GrepSearchTool.SEARCH_TIMEOUT);
-            rl.on('line', (line) => {
-                if (finished)
-                    return;
-                const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-                if (matches.length >= maxMatches) {
-                    truncated = true;
-                    // ABORT FIX: Immediately stop and resolve
-                    done({
-                        matches,
-                        totalMatches: matches.length,
-                        truncated,
-                        truncationReason: 'max_matches',
-                        searchPattern: params.Query
-                    });
-                    return;
-                }
-                try {
-                    const event = JSON.parse(line);
-                    if (event.type === 'begin' && event.data?.path?.text) {
-                        currentFile = this.normalizePath(event.data.path.text);
-                        contextQueue = [];
-                        pendingMatch = null;
-                        contextAfterCount = 0;
-                    }
-                    else if (event.type === 'context' && event.data?.lines?.text) {
-                        const ctxLine = {
-                            lineNumber: event.data.line_number,
-                            text: this.truncateLine(this.normalizeLineEndings(event.data.lines.text).trimEnd())
-                        };
-                        if (pendingMatch && contextAfterCount < GrepSearchTool.CONTEXT_LINES) {
-                            pendingMatch.contextAfter.push(ctxLine);
-                            contextAfterCount++;
-                        }
-                        else {
-                            contextQueue.push(ctxLine);
-                            if (contextQueue.length > GrepSearchTool.CONTEXT_LINES) {
-                                contextQueue.shift();
-                            }
-                        }
-                    }
-                    else if (event.type === 'match' && event.data) {
-                        // Finalize previous match
-                        if (pendingMatch) {
-                            matches.push(pendingMatch);
-                        }
-                        const lineText = event.data.lines?.text || '';
-                        const submatches = event.data.submatches || [];
-                        pendingMatch = {
-                            file: currentFile || this.normalizePath(event.data.path?.text || ''),
-                            line: event.data.line_number,
-                            column: submatches.length > 0 ? submatches[0].start + 1 : undefined,
-                            byteOffset: event.data.absolute_offset,
-                            match: this.truncateLine(this.normalizeLineEndings(lineText).trimEnd()),
-                            matchIndices: submatches.map((s) => [s.start, s.end]),
-                            contextBefore: [...contextQueue],
-                            contextAfter: []
-                        };
-                        contextQueue = [];
-                        contextAfterCount = 0;
-                    }
-                }
-                catch {
-                    // Ignore parse errors
-                }
-            });
-            child.on('close', (code) => {
-                if (finished)
-                    return;
-                // Finalize last match
-                const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-                if (pendingMatch && matches.length < maxMatches) {
-                    matches.push(pendingMatch);
-                }
-                done({
-                    matches,
-                    totalMatches: matches.length,
-                    truncated,
-                    truncationReason: truncated ? 'max_matches' : undefined,
-                    searchPattern: params.Query
-                });
-            });
-            child.on('error', (err) => {
-                fail(err);
-            });
+  }
+  // ========================================================================
+  // RIPGREP BACKEND (Streaming)
+  // ========================================================================
+  async searchWithRipgrepStreaming(params, cwd) {
+    return new Promise((resolve, reject) => {
+      const args = [
+        "--json",
+        `--context=${GrepSearchTool.CONTEXT_LINES}`
+      ];
+      if (params.CaseInsensitive) {
+        args.push("--ignore-case");
+      }
+      if (!params.IsRegex) {
+        args.push("--fixed-strings");
+      }
+      if (params.Includes && params.Includes.length > 0) {
+        params.Includes.forEach((pattern) => {
+          args.push("--glob", pattern);
         });
-    }
-    // ========================================================================
-    // GREP BACKEND (Streaming)
-    // ========================================================================
-    async searchWithGrepStreaming(params, cwd) {
-        return new Promise((resolve, reject) => {
-            const args = [
-                '-n', // line numbers
-                '-r', // recursive
-                `--context=${GrepSearchTool.CONTEXT_LINES}`,
-            ];
-            if (params.CaseInsensitive) {
-                args.push('-i');
-            }
-            if (!params.IsRegex) {
-                args.push('-F'); // fixed strings
-            }
-            else {
-                args.push('-E'); // extended regex (supports |)
-            }
-            if (params.Includes && params.Includes.length > 0) {
-                params.Includes.forEach(pattern => {
-                    args.push('--include', pattern);
-                });
-            }
-            args.push(params.Query, params.SearchPath);
-            const matches = [];
-            let truncated = false;
-            let finished = false;
-            const child = spawn('grep', args, {
-                cwd,
-                env: { ...process.env, LANG: 'en_US.UTF-8' }
-            });
-            const rl = readline.createInterface({ input: child.stdout });
-            const done = (result) => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timer);
-                child.kill();
-                rl.close();
-                resolve(result);
-            };
-            const fail = (err) => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timer);
-                child.kill();
-                rl.close();
-                reject(err);
-            };
-            const timer = setTimeout(() => {
-                done({
-                    matches,
-                    totalMatches: matches.length,
-                    truncated: true,
-                    truncationReason: 'timeout',
-                    searchPattern: params.Query
-                });
-            }, GrepSearchTool.SEARCH_TIMEOUT);
-            rl.on('line', (line) => {
-                if (finished)
-                    return;
-                const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-                if (matches.length >= maxMatches) {
-                    truncated = true;
-                    done({
-                        matches,
-                        totalMatches: matches.length,
-                        truncated,
-                        truncationReason: 'max_matches',
-                        searchPattern: params.Query
-                    });
-                    return;
-                }
-                const normalizedLine = this.normalizeLineEndings(line);
-                // Skip separator lines
-                if (normalizedLine === '--')
-                    return;
-                const parsed = this.parseGrepLine(normalizedLine);
-                if (parsed) {
-                    // For grep, we treat each line as a match (context handling is simpler)
-                    matches.push({
-                        file: this.normalizePath(parsed.file),
-                        line: parsed.lineNum,
-                        match: this.truncateLine(parsed.content),
-                        contextBefore: [],
-                        contextAfter: []
-                    });
-                }
-            });
-            child.on('close', () => {
-                if (finished)
-                    return;
-                done({
-                    matches,
-                    totalMatches: matches.length,
-                    truncated,
-                    truncationReason: truncated ? 'max_matches' : undefined,
-                    searchPattern: params.Query
-                });
-            });
-            child.on('error', (err) => fail(err));
+      }
+      args.push("--", params.Query, params.SearchPath);
+      const matches = [];
+      let truncated = false;
+      let currentFile = null;
+      let contextQueue = [];
+      let pendingMatch = null;
+      let contextAfterCount = 0;
+      let finished = false;
+      const child = spawn("rg", args, {
+        cwd,
+        env: { ...process.env, LANG: "en_US.UTF-8" }
+      });
+      const rl = readline.createInterface({ input: child.stdout });
+      const done = (result) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        child.kill();
+        rl.close();
+        resolve(result);
+      };
+      const fail = (err) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        child.kill();
+        rl.close();
+        reject(err);
+      };
+      const timer = setTimeout(() => {
+        done({
+          matches,
+          totalMatches: matches.length,
+          truncated: true,
+          truncationReason: "timeout",
+          searchPattern: params.Query
         });
-    }
-    // ========================================================================
-    // POWERSHELL BACKEND (Windows)
-    // ========================================================================
-    async searchWithPowerShell(params, cwd) {
-        const psExe = await this.getPowerShellExe();
-        // Build the PowerShell command
-        // Select-String supports regex by default, -SimpleMatch for literal
-        const patternArg = params.IsRegex ? params.Query : params.Query.replace(/'/g, "''");
-        const searchPath = path.resolve(cwd, params.SearchPath);
-        let psCommand;
-        // Check if searching a file or directory
-        const stats = await fs.promises.stat(searchPath).catch(() => null);
-        const isDirectory = stats?.isDirectory() ?? false;
-        // PATH FIX: Use $_.Path instead of $_.Filename for absolute paths
-        if (isDirectory) {
-            // Search directory recursively
-            const includePattern = params.Includes && params.Includes.length > 0
-                ? params.Includes.map(p => `'${p}'`).join(',')
-                : "'*'";
-            const max = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-            psCommand = params.IsRegex
-                ? `Get-ChildItem -Path '${searchPath}' -Recurse -File -Include ${includePattern} -ErrorAction SilentlyContinue | Select-String -Pattern '${patternArg}'${params.CaseInsensitive ? '' : ' -CaseSensitive'} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }`
-                : `Get-ChildItem -Path '${searchPath}' -Recurse -File -Include ${includePattern} -ErrorAction SilentlyContinue | Select-String -Pattern '${patternArg}' -SimpleMatch${params.CaseInsensitive ? '' : ' -CaseSensitive'} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }`;
-        }
-        else {
-            // Search single file
-            const max = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-            psCommand = params.IsRegex
-                ? `Select-String -Path '${searchPath}' -Pattern '${patternArg}'${params.CaseInsensitive ? '' : ' -CaseSensitive'} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }`
-                : `Select-String -Path '${searchPath}' -Pattern '${patternArg}' -SimpleMatch${params.CaseInsensitive ? '' : ' -CaseSensitive'} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }`;
+      }, GrepSearchTool.SEARCH_TIMEOUT);
+      rl.on("line", (line) => {
+        if (finished) return;
+        const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+        if (matches.length >= maxMatches) {
+          truncated = true;
+          done({
+            matches,
+            totalMatches: matches.length,
+            truncated,
+            truncationReason: "max_matches",
+            searchPattern: params.Query
+          });
+          return;
         }
-        return new Promise((resolve, reject) => {
-            const matches = [];
-            let truncated = false;
-            let finished = false;
-            const child = spawn(psExe, ['-NoProfile', '-Command', psCommand], {
-                cwd,
-                env: { ...process.env }
-            });
-            // Robust cleanup function
-            const done = (result) => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timer);
-                child.kill();
-                resolve(result);
+        try {
+          const event = JSON.parse(line);
+          if (event.type === "begin" && event.data?.path?.text) {
+            currentFile = this.normalizePath(event.data.path.text);
+            contextQueue = [];
+            pendingMatch = null;
+            contextAfterCount = 0;
+          } else if (event.type === "context" && event.data?.lines?.text) {
+            const ctxLine = {
+              lineNumber: event.data.line_number,
+              text: this.truncateLine(this.normalizeLineEndings(event.data.lines.text).trimEnd())
             };
-            const fail = (err) => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timer);
-                child.kill();
-                reject(err);
+            if (pendingMatch && contextAfterCount < GrepSearchTool.CONTEXT_LINES) {
+              pendingMatch.contextAfter.push(ctxLine);
+              contextAfterCount++;
+            } else {
+              contextQueue.push(ctxLine);
+              if (contextQueue.length > GrepSearchTool.CONTEXT_LINES) {
+                contextQueue.shift();
+              }
+            }
+          } else if (event.type === "match" && event.data) {
+            if (pendingMatch) {
+              matches.push(pendingMatch);
+            }
+            const lineText = event.data.lines?.text || "";
+            const submatches = event.data.submatches || [];
+            pendingMatch = {
+              file: currentFile || this.normalizePath(event.data.path?.text || ""),
+              line: event.data.line_number,
+              column: submatches.length > 0 ? submatches[0].start + 1 : void 0,
+              byteOffset: event.data.absolute_offset,
+              match: this.truncateLine(this.normalizeLineEndings(lineText).trimEnd()),
+              matchIndices: submatches.map((s) => [s.start, s.end]),
+              contextBefore: [...contextQueue],
+              contextAfter: []
             };
-            const timer = setTimeout(() => {
-                done({
-                    matches,
-                    totalMatches: matches.length,
-                    truncated: true,
-                    truncationReason: 'timeout',
-                    searchPattern: params.Query
-                });
-            }, GrepSearchTool.SEARCH_TIMEOUT);
-            let stdout = '';
-            let stderr = '';
-            child.stdout.on('data', (data) => {
-                stdout += data.toString();
-            });
-            child.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-            child.on('close', (code) => {
-                if (finished)
-                    return;
-                const lines = this.normalizeLineEndings(stdout).split('\n').filter(l => l.trim());
-                for (const line of lines) {
-                    const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-                    if (matches.length >= maxMatches) {
-                        truncated = true;
-                        break;
-                    }
-                    const parsed = this.parseGrepLine(line);
-                    if (parsed) {
-                        matches.push({
-                            file: this.normalizePath(parsed.file),
-                            line: parsed.lineNum,
-                            match: this.truncateLine(parsed.content),
-                            contextBefore: [],
-                            contextAfter: []
-                        });
-                    }
-                }
-                done({
-                    matches,
-                    totalMatches: matches.length,
-                    truncated,
-                    truncationReason: truncated ? 'max_matches' : undefined,
-                    searchPattern: params.Query
-                });
-            });
-            child.on('error', (err) => fail(err));
-        });
-    }
-    // ========================================================================
-    // PURE NODE.JS BACKEND (Universal Fallback)
-    // ========================================================================
-    async searchWithNodeJS(params, cwd) {
-        const matches = [];
-        let truncated = false;
-        let filesSearched = 0;
-        let encodingFallback = false;
-        const searchPath = path.resolve(cwd, params.SearchPath);
-        const regex = this.createSearchRegex(params.Query, params.IsRegex ?? false, params.CaseInsensitive ?? false);
-        // Collect files to search
-        const filesToSearch = [];
-        const stats = await fs.promises.stat(searchPath).catch(() => null);
-        if (!stats) {
-            return { matches: [], totalMatches: 0, truncated: false, searchPattern: params.Query };
-        }
-        if (stats.isFile()) {
-            filesToSearch.push(searchPath);
+            contextQueue = [];
+            contextAfterCount = 0;
+          }
+        } catch {
         }
-        else if (stats.isDirectory()) {
-            await this.collectFiles(searchPath, filesToSearch, params.Includes);
-        }
-        // Search each file
+      });
+      child.on("close", (code) => {
+        if (finished) return;
         const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-        for (const filePath of filesToSearch) {
-            if (matches.length >= maxMatches) {
-                truncated = true;
-                break;
-            }
-            // Skip binary files
-            if (await this.isBinaryFile(filePath)) {
-                continue;
-            }
-            filesSearched++;
-            try {
-                let content;
-                const buffer = await fs.promises.readFile(filePath);
-                // Try UTF-8 first
-                try {
-                    content = buffer.toString('utf8');
-                    // Check for replacement characters indicating decode failure
-                    if (content.includes('\uFFFD')) {
-                        content = buffer.toString('latin1');
-                        encodingFallback = true;
-                    }
-                }
-                catch {
-                    content = buffer.toString('latin1');
-                    encodingFallback = true;
-                }
-                const lines = this.normalizeLineEndings(content).split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    if (matches.length >= maxMatches) {
-                        truncated = true;
-                        break;
-                    }
-                    const line = lines[i];
-                    regex.lastIndex = 0; // Reset regex state
-                    // LOOP FIX: Capture all matches in the line, not just the first
-                    let matchResult;
-                    while ((matchResult = regex.exec(line)) !== null) {
-                        // Prevent infinite loops with zero-width matches
-                        if (matchResult.index === regex.lastIndex) {
-                            regex.lastIndex++;
-                        }
-                        const relativePath = path.relative(cwd, filePath);
-                        // Collect context
-                        const contextBefore = [];
-                        const contextAfter = [];
-                        for (let j = Math.max(0, i - GrepSearchTool.CONTEXT_LINES); j < i; j++) {
-                            contextBefore.push({
-                                lineNumber: j + 1,
-                                text: this.truncateLine(lines[j])
-                            });
-                        }
-                        for (let j = i + 1; j <= Math.min(lines.length - 1, i + GrepSearchTool.CONTEXT_LINES); j++) {
-                            contextAfter.push({
-                                lineNumber: j + 1,
-                                text: this.truncateLine(lines[j])
-                            });
-                        }
-                        matches.push({
-                            file: this.normalizePath(relativePath),
-                            line: i + 1,
-                            column: matchResult.index + 1,
-                            match: this.truncateLine(line),
-                            contextBefore,
-                            contextAfter
-                        });
-                        if (matches.length >= maxMatches) {
-                            truncated = true;
-                            break;
-                        }
-                    }
-                    if (truncated)
-                        break;
-                }
-            }
-            catch {
-                // Skip files that can't be read
-            }
+        if (pendingMatch && matches.length < maxMatches) {
+          matches.push(pendingMatch);
         }
-        return {
+        done({
+          matches,
+          totalMatches: matches.length,
+          truncated,
+          truncationReason: truncated ? "max_matches" : void 0,
+          searchPattern: params.Query
+        });
+      });
+      child.on("error", (err) => {
+        fail(err);
+      });
+    });
+  }
+  // ========================================================================
+  // GREP BACKEND (Streaming)
+  // ========================================================================
+  async searchWithGrepStreaming(params, cwd) {
+    return new Promise((resolve, reject) => {
+      const query = params.IsRegex ? normalizeRegexForGrep(params.Query) : params.Query;
+      const args = [
+        "-n",
+        // line numbers
+        "-r",
+        // recursive
+        `--context=${GrepSearchTool.CONTEXT_LINES}`
+      ];
+      if (params.CaseInsensitive) {
+        args.push("-i");
+      }
+      if (!params.IsRegex) {
+        args.push("-F");
+      } else {
+        args.push("-E");
+      }
+      if (params.Includes && params.Includes.length > 0) {
+        params.Includes.forEach((pattern) => {
+          args.push("--include", pattern);
+        });
+      }
+      args.push(query, params.SearchPath);
+      const matches = [];
+      let truncated = false;
+      let finished = false;
+      const child = spawn("grep", args, {
+        cwd,
+        env: { ...process.env, LANG: "en_US.UTF-8" }
+      });
+      const rl = readline.createInterface({ input: child.stdout });
+      const done = (result) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        child.kill();
+        rl.close();
+        resolve(result);
+      };
+      const fail = (err) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        child.kill();
+        rl.close();
+        reject(err);
+      };
+      const timer = setTimeout(() => {
+        done({
+          matches,
+          totalMatches: matches.length,
+          truncated: true,
+          truncationReason: "timeout",
+          searchPattern: params.Query
+        });
+      }, GrepSearchTool.SEARCH_TIMEOUT);
+      rl.on("line", (line) => {
+        if (finished) return;
+        const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+        if (matches.length >= maxMatches) {
+          truncated = true;
+          done({
             matches,
             totalMatches: matches.length,
             truncated,
-            truncationReason: truncated ? 'max_matches' : undefined,
-            searchPattern: params.Query,
-            filesSearched,
-            encodingFallback
-        };
-    }
-    /**
-     * Recursively collect files from directory
-     */
-    async collectFiles(dir, files, includes, maxFiles = 10000) {
-        if (files.length >= maxFiles)
-            return;
-        try {
-            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (files.length >= maxFiles)
-                    break;
-                const fullPath = path.join(dir, entry.name);
-                // Skip common non-code directories
-                if (entry.isDirectory()) {
-                    if (['node_modules', '.git', 'dist', 'build', '__pycache__', '.vscode', '.idea'].includes(entry.name)) {
-                        continue;
-                    }
-                    await this.collectFiles(fullPath, files, includes, maxFiles);
-                }
-                else if (entry.isFile()) {
-                    if (this.matchesIncludesFilter(fullPath, includes)) {
-                        files.push(fullPath);
-                    }
-                }
-            }
+            truncationReason: "max_matches",
+            searchPattern: params.Query
+          });
+          return;
         }
-        catch {
-            // Ignore directories that can't be read
+        const normalizedLine = this.normalizeLineEndings(line);
+        if (normalizedLine === "--") return;
+        const parsed = this.parseGrepLine(normalizedLine);
+        if (parsed) {
+          matches.push({
+            file: this.normalizePath(parsed.file),
+            line: parsed.lineNum,
+            match: this.truncateLine(parsed.content),
+            contextBefore: [],
+            contextAfter: []
+          });
         }
+      });
+      child.on("close", () => {
+        if (finished) return;
+        done({
+          matches,
+          totalMatches: matches.length,
+          truncated,
+          truncationReason: truncated ? "max_matches" : void 0,
+          searchPattern: params.Query
+        });
+      });
+      child.on("error", (err) => fail(err));
+    });
+  }
+  // ========================================================================
+  // POWERSHELL BACKEND (Windows)
+  // ========================================================================
+  async searchWithPowerShell(params, cwd) {
+    const psExe = await this.getPowerShellExe();
+    const patternArg = escapePowerShellSingleQuoted(params.Query);
+    const searchPath = path.resolve(cwd, params.SearchPath);
+    const escapedSearchPath = escapePowerShellSingleQuoted(searchPath);
+    let psCommand;
+    const stats = await fs.promises.stat(searchPath).catch(() => null);
+    const isDirectory = stats?.isDirectory() ?? false;
+    if (isDirectory) {
+      const includePattern = params.Includes && params.Includes.length > 0 ? params.Includes.map((p) => `'${escapePowerShellSingleQuoted(p)}'`).join(",") : "'*'";
+      const max = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+      psCommand = params.IsRegex ? `Get-ChildItem -Path '${escapedSearchPath}' -Recurse -File -Include ${includePattern} -ErrorAction SilentlyContinue | Select-String -Pattern '${patternArg}'${params.CaseInsensitive ? "" : " -CaseSensitive"} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }` : `Get-ChildItem -Path '${escapedSearchPath}' -Recurse -File -Include ${includePattern} -ErrorAction SilentlyContinue | Select-String -Pattern '${patternArg}' -SimpleMatch${params.CaseInsensitive ? "" : " -CaseSensitive"} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }`;
+    } else {
+      const max = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+      psCommand = params.IsRegex ? `Select-String -Path '${escapedSearchPath}' -Pattern '${patternArg}'${params.CaseInsensitive ? "" : " -CaseSensitive"} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }` : `Select-String -Path '${escapedSearchPath}' -Pattern '${patternArg}' -SimpleMatch${params.CaseInsensitive ? "" : " -CaseSensitive"} -Context ${GrepSearchTool.CONTEXT_LINES} | Select-Object -First ${max} | ForEach-Object { $_.Path + ':' + $_.LineNumber + ':' + $_.Line }`;
+    }
+    return new Promise((resolve, reject) => {
+      const matches = [];
+      let truncated = false;
+      let finished = false;
+      const child = spawn(psExe, ["-NoProfile", "-Command", psCommand], {
+        cwd,
+        env: { ...process.env }
+      });
+      const done = (result) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        child.kill();
+        resolve(result);
+      };
+      const fail = (err) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        child.kill();
+        reject(err);
+      };
+      const timer = setTimeout(() => {
+        done({
+          matches,
+          totalMatches: matches.length,
+          truncated: true,
+          truncationReason: "timeout",
+          searchPattern: params.Query
+        });
+      }, GrepSearchTool.SEARCH_TIMEOUT);
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        if (finished) return;
+        const lines = this.normalizeLineEndings(stdout).split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+          if (matches.length >= maxMatches) {
+            truncated = true;
+            break;
+          }
+          const parsed = this.parseGrepLine(line);
+          if (parsed) {
+            matches.push({
+              file: this.normalizePath(parsed.file),
+              line: parsed.lineNum,
+              match: this.truncateLine(parsed.content),
+              contextBefore: [],
+              contextAfter: []
+            });
+          }
+        }
+        done({
+          matches,
+          totalMatches: matches.length,
+          truncated,
+          truncationReason: truncated ? "max_matches" : void 0,
+          searchPattern: params.Query
+        });
+      });
+      child.on("error", (err) => fail(err));
+    });
+  }
+  // ========================================================================
+  // PURE NODE.JS BACKEND (Universal Fallback)
+  // ========================================================================
+  async searchWithNodeJS(params, cwd) {
+    const matches = [];
+    let truncated = false;
+    let filesSearched = 0;
+    let encodingFallback = false;
+    const searchPath = path.resolve(cwd, params.SearchPath);
+    const regex = this.createSearchRegex(params.Query, params.IsRegex ?? false, params.CaseInsensitive ?? false);
+    const filesToSearch = [];
+    const stats = await fs.promises.stat(searchPath).catch(() => null);
+    if (!stats) {
+      return { matches: [], totalMatches: 0, truncated: false, searchPattern: params.Query };
+    }
+    if (stats.isFile()) {
+      filesToSearch.push(searchPath);
+    } else if (stats.isDirectory()) {
+      await this.collectFiles(searchPath, filesToSearch, params.Includes);
     }
-    // ========================================================================
-    // MAIN EXECUTE METHOD
-    // ========================================================================
-    async execute(params, cwd) {
-        let result;
-        let backend;
+    const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+    for (const filePath of filesToSearch) {
+      if (matches.length >= maxMatches) {
+        truncated = true;
+        break;
+      }
+      if (await this.isBinaryFile(filePath)) {
+        continue;
+      }
+      filesSearched++;
+      try {
+        let content;
+        const buffer = await fs.promises.readFile(filePath);
         try {
-            // Try backends in order of preference
-            if (await this.hasRipgrep()) {
-                backend = 'ripgrep';
-                result = await this.searchWithRipgrepStreaming(params, cwd);
+          content = buffer.toString("utf8");
+          if (content.includes("\uFFFD")) {
+            content = buffer.toString("latin1");
+            encodingFallback = true;
+          }
+        } catch {
+          content = buffer.toString("latin1");
+          encodingFallback = true;
+        }
+        const lines = this.normalizeLineEndings(content).split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (matches.length >= maxMatches) {
+            truncated = true;
+            break;
+          }
+          const line = lines[i];
+          regex.lastIndex = 0;
+          let matchResult;
+          while ((matchResult = regex.exec(line)) !== null) {
+            if (matchResult.index === regex.lastIndex) {
+              regex.lastIndex++;
             }
-            else if (await this.hasGrep()) {
-                backend = 'grep';
-                result = await this.searchWithGrepStreaming(params, cwd);
+            const relativePath = path.relative(cwd, filePath);
+            const contextBefore = [];
+            const contextAfter = [];
+            for (let j = Math.max(0, i - GrepSearchTool.CONTEXT_LINES); j < i; j++) {
+              contextBefore.push({
+                lineNumber: j + 1,
+                text: this.truncateLine(lines[j])
+              });
             }
-            else if (process.platform === 'win32' && await this.hasPowerShell()) {
-                backend = 'powershell';
-                result = await this.searchWithPowerShell(params, cwd);
+            for (let j = i + 1; j <= Math.min(lines.length - 1, i + GrepSearchTool.CONTEXT_LINES); j++) {
+              contextAfter.push({
+                lineNumber: j + 1,
+                text: this.truncateLine(lines[j])
+              });
             }
-            else {
-                // Universal Node.js fallback
-                backend = 'nodejs';
-                result = await this.searchWithNodeJS(params, cwd);
+            matches.push({
+              file: this.normalizePath(relativePath),
+              line: i + 1,
+              column: matchResult.index + 1,
+              match: this.truncateLine(line),
+              contextBefore,
+              contextAfter
+            });
+            if (matches.length >= maxMatches) {
+              truncated = true;
+              break;
             }
+          }
+          if (truncated) break;
         }
-        catch (error) {
-            // If primary backend fails, try fallback
-            try {
-                backend = 'nodejs';
-                result = await this.searchWithNodeJS(params, cwd);
-            }
-            catch (fallbackError) {
-                throw new Error(`Search failed: ${error.message}. Fallback also failed: ${fallbackError.message}`);
-            }
+      } catch {
+      }
+    }
+    return {
+      matches,
+      totalMatches: matches.length,
+      truncated,
+      truncationReason: truncated ? "max_matches" : void 0,
+      searchPattern: params.Query,
+      filesSearched,
+      encodingFallback
+    };
+  }
+  /**
+   * Recursively collect files from directory
+   */
+  async collectFiles(dir, files, includes, maxFiles = 1e4) {
+    if (files.length >= maxFiles) return;
+    try {
+      const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (files.length >= maxFiles) break;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (["node_modules", ".git", "dist", "build", "__pycache__", ".vscode", ".idea"].includes(entry.name)) {
+            continue;
+          }
+          await this.collectFiles(fullPath, files, includes, maxFiles);
+        } else if (entry.isFile()) {
+          if (this.matchesIncludesFilter(fullPath, includes)) {
+            files.push(fullPath);
+          }
         }
-        // Apply post-filtering for Includes if backend didn't support it
-        if (params.Includes && params.Includes.length > 0 && backend === 'nodejs') {
-            const filteredMatches = result.matches.filter(match => this.matchesIncludesFilter(match.file, params.Includes));
-            return {
-                ...result,
-                matches: filteredMatches,
-                totalMatches: filteredMatches.length,
-                backend
-            };
+      }
+    } catch {
+    }
+  }
+  // ========================================================================
+  // MAIN EXECUTE METHOD
+  // ========================================================================
+  async executeWithPreferredBackends(params, cwd) {
+    let result;
+    let backend;
+    try {
+      if (await this.hasRipgrep()) {
+        backend = "ripgrep";
+        result = await this.searchWithRipgrepStreaming(params, cwd);
+      } else if (await this.hasGrep()) {
+        if (params.IsRegex && usesRegexFeaturesUnsupportedByGrep(params.Query)) {
+          backend = "nodejs";
+          result = await this.searchWithNodeJS(params, cwd);
+        } else {
+          backend = "grep";
+          result = await this.searchWithGrepStreaming(params, cwd);
         }
-        return { ...result, backend };
+      } else if (process.platform === "win32" && await this.hasPowerShell()) {
+        backend = "powershell";
+        result = await this.searchWithPowerShell(params, cwd);
+      } else {
+        backend = "nodejs";
+        result = await this.searchWithNodeJS(params, cwd);
+      }
+    } catch (error) {
+      try {
+        backend = "nodejs";
+        result = await this.searchWithNodeJS(params, cwd);
+      } catch (fallbackError) {
+        throw new Error(`Search failed: ${error.message}. Fallback also failed: ${fallbackError.message}`);
+      }
+    }
+    if (params.Includes && params.Includes.length > 0 && backend === "nodejs") {
+      const filteredMatches = result.matches.filter(
+        (match) => this.matchesIncludesFilter(match.file, params.Includes)
+      );
+      return {
+        ...result,
+        matches: filteredMatches,
+        totalMatches: filteredMatches.length,
+        backend
+      };
+    }
+    return { ...result, backend };
+  }
+  async execute(params, cwd) {
+    const shouldRetryAsRegex = params.IsRegex === void 0 && looksLikeRegexPattern(params.Query);
+    const primaryParams = {
+      ...params,
+      IsRegex: params.IsRegex ?? false
+    };
+    const primaryResult = await this.executeWithPreferredBackends(primaryParams, cwd);
+    if (shouldRetryAsRegex && primaryResult.matches.length === 0) {
+      const regexParams = {
+        ...params,
+        IsRegex: true
+      };
+      const regexResult = await this.executeWithPreferredBackends(regexParams, cwd);
+      if (regexResult.matches.length > 0) {
+        return regexResult;
+      }
     }
+    return primaryResult;
+  }
 }
-// ============================================================================
-// FORMATTING FUNCTION
-// ============================================================================
 function formatGrepResults(result) {
-    if (result.matches.length === 0) {
-        return `No matches found for pattern "${result.searchPattern}"`;
+  if (result.matches.length === 0) {
+    return `No matches found for pattern "${result.searchPattern}"`;
+  }
+  const uniqueFiles = /* @__PURE__ */ new Set();
+  result.matches.forEach((match) => uniqueFiles.add(match.file));
+  const fileCount = uniqueFiles.size;
+  const output = [];
+  output.push(`Found ${result.uniqueMatchesCount} match${result.uniqueMatchesCount === 1 ? "" : "es"} in ${fileCount} file${fileCount === 1 ? "" : "s"} for pattern "${result.searchPattern}"`);
+  if (result.truncated) {
+    const reason = result.truncationReason === "timeout" ? "(timed out)" : "";
+    output.push(`(showing first ${result.matches.length} matches${reason ? " " + reason : ""})`);
+  }
+  const matchesByFile = /* @__PURE__ */ new Map();
+  result.matches.forEach((match) => {
+    if (!matchesByFile.has(match.file)) {
+      matchesByFile.set(match.file, []);
     }
-    const uniqueFiles = new Set();
-    result.matches.forEach(match => uniqueFiles.add(match.file));
-    const fileCount = uniqueFiles.size;
-    const output = [];
-    output.push(`Found ${result.uniqueMatchesCount} match${result.uniqueMatchesCount === 1 ? '' : 'es'} in ${fileCount} file${fileCount === 1 ? '' : 's'} for pattern "${result.searchPattern}"`);
-    if (result.truncated) {
-        const reason = result.truncationReason === 'timeout' ? '(timed out)' : '';
-        output.push(`(showing first ${result.matches.length} matches${reason ? ' ' + reason : ''})`);
-    }
-    const matchesByFile = new Map();
-    result.matches.forEach(match => {
-        if (!matchesByFile.has(match.file)) {
-            matchesByFile.set(match.file, []);
-        }
-        matchesByFile.get(match.file)?.push(match);
+    matchesByFile.get(match.file)?.push(match);
+  });
+  matchesByFile.forEach((matches, file) => {
+    output.push(`
+${file}`);
+    matches.forEach((match) => {
+      match.contextBefore.forEach((ctx) => {
+        output.push(`${ctx.lineNumber}:   ${ctx.text}`);
+      });
+      const columnInfo = match.column ? ` (col ${match.column})` : "";
+      output.push(`${match.line}:>  ${match.match}${columnInfo}`);
+      match.contextAfter.forEach((ctx) => {
+        output.push(`${ctx.lineNumber}:   ${ctx.text}`);
+      });
     });
-    matchesByFile.forEach((matches, file) => {
-        output.push(`\n${file}`);
-        matches.forEach(match => {
-            match.contextBefore.forEach(ctx => {
-                output.push(`${ctx.lineNumber}:   ${ctx.text}`);
-            });
-            const columnInfo = match.column ? ` (col ${match.column})` : '';
-            output.push(`${match.line}:>  ${match.match}${columnInfo}`);
-            match.contextAfter.forEach(ctx => {
-                output.push(`${ctx.lineNumber}:   ${ctx.text}`);
-            });
-        });
-    });
-    return output.join('\n');
+  });
+  return output.join("\n");
 }
-// ============================================================================
-// REMOTE SEARCH HELPER
-// ============================================================================
-/**
- * Execute grep search on a remote system via ContextManager
- * Used for SSH/Docker/WSL environments
- */
 async function searchRemote(params, contextManager) {
-    const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-    // Escape the query for shell usage
-    const escapedQuery = params.Query.replace(/'/g, "'\\''");
-    // First, check if the path is a file or directory to use correct grep flags
-    // Use test -d to check if it's a directory
-    const checkResult = await contextManager.executeCommand(`test -d "${params.SearchPath}" && echo "dir" || echo "file"`, 5000);
-    const isDirectory = checkResult.stdout.trim() === 'dir';
-    // Build grep command - use -r only for directories, -H to always show filename
-    let grepArgs = isDirectory ? '-rn' : '-Hn'; // -H for filename, -n for line numbers, -r for recursive
-    if (params.CaseInsensitive) {
-        grepArgs += 'i';
-    }
-    if (!params.IsRegex) {
-        grepArgs += 'F'; // fixed strings (literal)
-    }
-    // Add include patterns if specified (only useful for directories)
-    let includeArgs = '';
-    if (isDirectory && params.Includes && params.Includes.length > 0) {
-        includeArgs = params.Includes.map(p => `--include='${p}'`).join(' ');
-    }
-    // Build the full command with result limit
-    const command = `grep ${grepArgs} ${includeArgs} '${escapedQuery}' "${params.SearchPath}" 2>/dev/null | head -n ${maxMatches}`;
-    try {
-        const result = await contextManager.executeCommand(command, 30000);
-        const matches = [];
-        const lines = result.stdout.split('\n').filter(line => line.trim());
-        for (const line of lines) {
-            // Parse grep output: file:line:content
-            const match = line.match(/^(.+?):(\d+):(.+)$/);
-            if (match) {
-                // Truncate long lines
-                let content = match[3];
-                if (content.length > 300) {
-                    content = content.substring(0, 300) + ' [truncated]';
-                }
-                matches.push({
-                    file: match[1],
-                    line: parseInt(match[2], 10),
-                    match: content,
-                    contextBefore: [],
-                    contextAfter: [],
-                });
-            }
+  const maxMatches = params.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+  const remoteQuery = params.IsRegex ? normalizeRegexForGrep(params.Query) : params.Query;
+  const escapedQuery = remoteQuery.replace(/'/g, "'\\''");
+  const checkResult = await contextManager.executeCommand(`test -d "${params.SearchPath}" && echo "dir" || echo "file"`, 5e3);
+  const isDirectory = checkResult.stdout.trim() === "dir";
+  let grepArgs = isDirectory ? "-rn" : "-Hn";
+  if (params.CaseInsensitive) {
+    grepArgs += "i";
+  }
+  if (params.IsRegex) {
+    grepArgs += "E";
+  } else {
+    grepArgs += "F";
+  }
+  let includeArgs = "";
+  if (isDirectory && params.Includes && params.Includes.length > 0) {
+    includeArgs = params.Includes.map((p) => `--include='${p}'`).join(" ");
+  }
+  const command = `grep ${grepArgs} ${includeArgs} '${escapedQuery}' "${params.SearchPath}" 2>/dev/null | head -n ${maxMatches}`;
+  try {
+    const result = await contextManager.executeCommand(command, 3e4);
+    const matches = [];
+    const lines = result.stdout.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const match = line.match(/^(.+?):(\d+):(.+)$/);
+      if (match) {
+        let content = match[3];
+        if (content.length > 300) {
+          content = content.substring(0, 300) + " [truncated]";
         }
-        return {
-            matches,
-            totalMatches: matches.length,
-            truncated: matches.length >= maxMatches,
-            truncationReason: matches.length >= maxMatches ? 'max_matches' : undefined,
-            searchPattern: params.Query,
-            backend: 'remote',
-        };
-    }
-    catch (error) {
-        // If grep fails (command not found, permission denied, etc.), return empty result
-        return {
-            matches: [],
-            totalMatches: 0,
-            truncated: false,
-            searchPattern: params.Query,
-            backend: 'remote',
-        };
+        matches.push({
+          file: match[1],
+          line: parseInt(match[2], 10),
+          match: content,
+          contextBefore: [],
+          contextAfter: []
+        });
+      }
     }
+    return {
+      matches,
+      totalMatches: matches.length,
+      truncated: matches.length >= maxMatches,
+      truncationReason: matches.length >= maxMatches ? "max_matches" : void 0,
+      searchPattern: params.Query,
+      backend: "remote"
+    };
+  } catch (error) {
+    return {
+      matches: [],
+      totalMatches: 0,
+      truncated: false,
+      searchPattern: params.Query,
+      backend: "remote"
+    };
+  }
 }
-// ============================================================================
-// TOOL EXPORT
-// ============================================================================
-export const grepSearchTool = {
-    schema: {
-        name: 'grep_search',
-        description: `Search FILE CONTENTS for text patterns using ripgrep.
-
-USE THIS TOOL WHEN:
-- Searching for text/code INSIDE files (function names, variable names, error messages, etc.)
-- Looking for where something is defined or used in the codebase
-- Finding all files that contain a specific string or pattern
-
-MULTI-WORD SEARCH: When you search for "control system", this tool will automatically:
-1. Search for the exact phrase "control system"
-2. ALSO search for files containing just "control" or just "system"
-3. Merge and deduplicate all results
-
-Results are returned with file paths and line numbers:
-filename
-line:   context
-line:>  match (col X)
-line:   context
-
-NOT for: Finding files/folders by NAME. Use find_files for that instead.
+const grepSearchTool = {
+  schema: {
+    name: "grep_search",
+    description: `Search FILE CONTENTS for text patterns using ripgrep.
+
+USE THIS TOOL WHEN:
+- Searching for text/code INSIDE files (function names, variable names, error messages, etc.)
+- Looking for where something is defined or used in the codebase
+- Finding all files that contain a specific string or pattern
+
+MULTI-WORD SEARCH: When you search for "control system", this tool will automatically:
+1. Search for the exact phrase "control system"
+2. ALSO search for files containing just "control" or just "system"
+3. Merge and deduplicate all results
+
+Results are returned with file paths and line numbers:
+filename
+line:   context
+line:>  match (col X)
+line:   context
+
+NOT for: Finding files/folders by NAME. Use find_files for that instead.
 Total results are capped at 50 matches. Use Includes to filter by file type.`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of what you are searching for and why.',
-                },
-                Query: {
-                    type: 'string',
-                    description: 'The search term or pattern. For multi-word queries like "control system", individual words will also be searched.',
-                },
-                SearchPath: {
-                    type: 'string',
-                    description: 'The path to search. This can be a directory or a file.',
-                },
-                Includes: {
-                    type: 'array',
-                    description: 'Glob patterns to filter files (e.g. ["*.ts"]).',
-                    items: { type: 'string' }
-                },
-                MaxResults: {
-                    type: 'number',
-                    description: 'Optional: Maximum number of results to return. Default is 50. Increase this if you need to see more matches.',
-                },
-                CaseInsensitive: {
-                    type: 'boolean',
-                    description: 'If true, performs a case-insensitive search. Default: false (case-sensitive)',
-                },
-                IsRegex: {
-                    type: 'boolean',
-                    description: 'If true, treats Query as a regular expression. Default: false',
-                },
-            },
-            required: ['reason_text', 'Query', 'SearchPath'],
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: "REQUIRED: A brief explanation of what you are searching for and why."
         },
-    },
-    async execute(args, context) {
-        const tool = new GrepSearchTool();
-        const startTime = Date.now();
-        const query = args.Query;
-        const words = query.trim().split(/\s+/).filter(w => w.length > 2);
-        const allMatches = [];
-        const seenMatches = new Set();
-        const matchesPerQuery = {};
-        const queriesExecuted = [];
-        let rawTotalMatches = 0;
-        let backend = 'ripgrep';
-        let truncated = false;
-        let truncationReason;
-        let encodingFallback = false;
-        const queries = [query];
-        if (words.length > 1 && !args.IsRegex) {
-            for (const word of words) {
-                if (word !== query) {
-                    queries.push(word);
-                }
-            }
+        Query: {
+          type: "string",
+          description: 'The search term or pattern. For multi-word queries like "control system", individual words will also be searched.'
+        },
+        SearchPath: {
+          type: "string",
+          description: "The path to search. This can be a directory or a file."
+        },
+        Includes: {
+          type: "array",
+          description: 'Glob patterns to filter files (e.g. ["*.ts"]).',
+          items: { type: "string" }
+        },
+        MaxResults: {
+          type: "number",
+          description: "Optional: Maximum number of results to return. Default is 50. Increase this if you need to see more matches."
+        },
+        CaseInsensitive: {
+          type: "boolean",
+          description: "If true, performs a case-insensitive search. Default: false (case-sensitive)"
+        },
+        IsRegex: {
+          type: "boolean",
+          description: "If true, treats Query as regex. If omitted, the tool starts with literal search and auto-retries regex for regex-like patterns (e.g. a|b, loadChat\\()."
         }
-        // Check if we're in a remote context (SSH, Docker, WSL)
-        const contextManager = context.contextManager;
-        const currentContext = contextManager?.getCurrentContext();
-        const isRemote = currentContext && currentContext.type !== 'local';
+      },
+      required: ["reason_text", "Query", "SearchPath"]
+    }
+  },
+  async execute(args, context) {
+    const tool = new GrepSearchTool();
+    const startTime = Date.now();
+    const query = args.Query;
+    const queryLooksRegexLike = looksLikeRegexPattern(query);
+    const words = query.trim().split(/\s+/).filter((w) => w.length > 2);
+    const allMatches = [];
+    const seenMatches = /* @__PURE__ */ new Set();
+    const matchesPerQuery = {};
+    const queriesExecuted = [];
+    let rawTotalMatches = 0;
+    let backend = "ripgrep";
+    let truncated = false;
+    let truncationReason;
+    let encodingFallback = false;
+    const queries = [query];
+    if (words.length > 1 && args.IsRegex !== true && !queryLooksRegexLike) {
+      for (const word of words) {
+        if (word !== query) {
+          queries.push(word);
+        }
+      }
+    }
+    const contextManager = context.contextManager;
+    const currentContext = contextManager?.getCurrentContext();
+    const isRemote = currentContext && currentContext.type !== "local";
+    try {
+      for (const searchQuery of queries) {
+        queriesExecuted.push(searchQuery);
+        const params = {
+          Query: searchQuery,
+          SearchPath: args.SearchPath,
+          Includes: args.Includes,
+          MaxResults: args.MaxResults,
+          CaseInsensitive: args.CaseInsensitive ?? false,
+          IsRegex: args.IsRegex
+        };
         try {
-            for (const searchQuery of queries) {
-                queriesExecuted.push(searchQuery);
-                const params = {
-                    Query: searchQuery,
-                    SearchPath: args.SearchPath,
-                    Includes: args.Includes,
-                    MaxResults: args.MaxResults,
-                    CaseInsensitive: args.CaseInsensitive ?? false,
-                    IsRegex: args.IsRegex,
-                };
-                try {
-                    // Use remote search for SSH/Docker/WSL, local search otherwise
-                    const result = isRemote
-                        ? await searchRemote(params, contextManager)
-                        : await tool.execute(params, context.cwd);
-                    backend = result.backend;
-                    matchesPerQuery[searchQuery] = result.totalMatches;
-                    rawTotalMatches += result.totalMatches;
-                    if (result.truncated) {
-                        truncated = true;
-                        truncationReason = result.truncationReason;
-                    }
-                    if (result.encodingFallback) {
-                        encodingFallback = true;
-                    }
-                    // Add unique matches with improved dedupe key
-                    for (const match of result.matches) {
-                        // Use file:line:column:matchText for more accurate deduplication
-                        const key = `${match.file}:${match.line}:${match.column ?? 0}:${match.match.substring(0, 50)}`;
-                        const maxMatches = args.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-                        if (!seenMatches.has(key) && allMatches.length < maxMatches) {
-                            seenMatches.add(key);
-                            allMatches.push(match);
-                        }
-                    }
-                }
-                catch {
-                    matchesPerQuery[searchQuery] = 0;
-                    continue;
-                }
-            }
-            const endTime = Date.now();
-            const uniqueMatchesCount = allMatches.length;
-            const max = args.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
-            const finalResult = {
-                matches: allMatches,
-                totalMatches: rawTotalMatches,
-                uniqueMatchesCount,
-                truncated: truncated || allMatches.length >= max,
-                truncationReason: allMatches.length >= max ? 'max_matches' : truncationReason,
-                searchPattern: queries.length > 1 ? `"${query}" (+ individual words)` : query,
-                metadata: {
-                    backend,
-                    searchDurationMs: endTime - startTime,
-                    queriesExecuted,
-                    matchesPerQuery,
-                    encodingFallback
-                },
-                formattedOutput: '',
+          let result = isRemote ? await searchRemote(params, contextManager) : await tool.execute(params, context.cwd);
+          if (isRemote && args.IsRegex === void 0 && looksLikeRegexPattern(searchQuery) && result.matches.length === 0) {
+            const regexRetryParams = {
+              ...params,
+              IsRegex: true
             };
-            finalResult.formattedOutput = formatGrepResults(finalResult);
-            return finalResult.formattedOutput;
-        }
-        catch (error) {
-            throw new Error(`Grep search failed: ${error.message}`);
+            const regexRetryResult = await searchRemote(regexRetryParams, contextManager);
+            if (regexRetryResult.matches.length > 0) {
+              result = regexRetryResult;
+            }
+          }
+          backend = result.backend;
+          matchesPerQuery[searchQuery] = result.totalMatches;
+          rawTotalMatches += result.totalMatches;
+          if (result.truncated) {
+            truncated = true;
+            truncationReason = result.truncationReason;
+          }
+          if (result.encodingFallback) {
+            encodingFallback = true;
+          }
+          for (const match of result.matches) {
+            const key = `${match.file}:${match.line}:${match.column ?? 0}:${match.match.substring(0, 50)}`;
+            const maxMatches = args.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+            if (!seenMatches.has(key) && allMatches.length < maxMatches) {
+              seenMatches.add(key);
+              allMatches.push(match);
+            }
+          }
+        } catch {
+          matchesPerQuery[searchQuery] = 0;
+          continue;
         }
-    },
+      }
+      const endTime = Date.now();
+      const uniqueMatchesCount = allMatches.length;
+      const max = args.MaxResults || GrepSearchTool.DEFAULT_MAX_MATCHES;
+      const finalResult = {
+        matches: allMatches,
+        totalMatches: rawTotalMatches,
+        uniqueMatchesCount,
+        truncated: truncated || allMatches.length >= max,
+        truncationReason: allMatches.length >= max ? "max_matches" : truncationReason,
+        searchPattern: queries.length > 1 ? `"${query}" (+ individual words)` : query,
+        metadata: {
+          backend,
+          searchDurationMs: endTime - startTime,
+          queriesExecuted,
+          matchesPerQuery,
+          encodingFallback
+        },
+        formattedOutput: ""
+      };
+      finalResult.formattedOutput = formatGrepResults(finalResult);
+      return finalResult.formattedOutput;
+    } catch (error) {
+      throw new Error(`Grep search failed: ${error.message}`);
+    }
+  }
+};
+export {
+  GrepSearchTool,
+  grepSearchTool
 };
 //# sourceMappingURL=grep-search.js.map