centaurus-cli 2.7.0 → 2.7.2

package/dist/tools/grep-search.js

@@ -1,23 +1,27 @@
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 import * as path from 'path';
-const execAsync = promisify(exec);
+import * as fs from 'fs';
+const execFileAsync = promisify(execFile);
 /**
  * GrepSearchTool - Search for text patterns across files in the codebase
  *
- * This tool wraps ripgrep (rg) or falls back to native grep/findstr
- * to provide fast, efficient code search capabilities.
+ * Improvements over basic implementation:
+ * 1. Security: Uses execFile to prevent shell injection
+ * 2. Robustness: Handles binary files and encoding issues (via rg/grep)
+ * 3. AI-Friendly Output: Formats results for easy parsing
+ * 4. Fallback: Gracefully degrades from ripgrep -> grep -> findstr
  */
 export class GrepSearchTool {
     static MAX_MATCHES = 50;
-    static MAX_LINE_LENGTH = 200;
+    static MAX_LINE_LENGTH = 300;
     static CONTEXT_LINES = 2;
     /**
      * Check if ripgrep is available
      */
     async hasRipgrep() {
         try {
-            await execAsync('rg --version');
+            await execFileAsync('rg', ['--version']);
             return true;
         }
         catch {
@@ -29,28 +33,13 @@ export class GrepSearchTool {
      */
     async hasGrep() {
         try {
-            await execAsync('grep --version');
+            await execFileAsync('grep', ['--version']);
             return true;
         }
         catch {
             return false;
         }
     }
-    /**
-     * Validate regex pattern
-     */
-    validatePattern(pattern) {
-        try {
-            new RegExp(pattern);
-            return { valid: true };
-        }
-        catch (error) {
-            return {
-                valid: false,
-                error: `Invalid regex pattern: "${pattern}"\nSuggestion: Check your regex syntax. Common issues: unmatched parentheses, invalid escape sequences.`
-            };
-        }
-    }
     /**
      * Normalize file path to use forward slashes
      */
@@ -71,33 +60,50 @@ export class GrepSearchTool {
      */
     async searchWithRipgrep(params, cwd) {
         const args = [
-            'rg',
             '--json',
             `--context=${GrepSearchTool.CONTEXT_LINES}`,
             `--max-count=${GrepSearchTool.MAX_MATCHES}`,
         ];
         // Case sensitivity
-        if (!params.caseSensitive) {
+        if (!params.CaseInsensitive) {
+            // rg is case-sensitive by default, smart-case is default in CLI but maybe not here
+            // We want explicit case sensitivity unless CaseInsensitive is true
+            // Actually, rg is case-sensitive by default.
+        }
+        else {
             args.push('--ignore-case');
         }
-        // File pattern
-        if (params.filePattern) {
-            args.push('--glob', params.filePattern);
+        // Fixed string vs Regex
+        if (!params.IsRegex) {
+            args.push('--fixed-strings');
         }
-        // Exclude pattern
-        if (params.excludePattern) {
-            args.push('--glob', `!${params.excludePattern}`);
+        // File pattern (Includes)
+        if (params.Includes && params.Includes.length > 0) {
+            params.Includes.forEach(pattern => {
+                args.push('--glob', pattern);
+            });
         }
+        // Search Path (file or directory)
+        // rg takes the path as the last argument usually, or we can use it as root
+        // We'll pass it as an argument.
         // Pattern
-        args.push('--', params.pattern);
+        // We pass pattern after flags
+        args.push('--', params.Query);
+        // Path
+        args.push(params.SearchPath);
         try {
-            const { stdout } = await execAsync(args.join(' '), { cwd, maxBuffer: 10 * 1024 * 1024 });
-            return this.parseRipgrepOutput(stdout, params.pattern);
+            const { stdout } = await execFileAsync('rg', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+            return this.parseRipgrepOutput(stdout, params.Query);
         }
         catch (error) {
             // ripgrep returns exit code 1 when no matches found
-            if (error.code === 1 && error.stdout) {
-                return this.parseRipgrepOutput(error.stdout, params.pattern);
+            if (error.code === 1) {
+                return {
+                    matches: [],
+                    totalMatches: 0,
+                    truncated: false,
+                    searchPattern: params.Query,
+                };
             }
             throw error;
         }
@@ -112,30 +118,32 @@ export class GrepSearchTool {
         let contextBefore = [];
         let contextAfter = [];
         let totalMatches = 0;
+        // Helper to finalize a match
+        const pushMatch = () => {
+            if (currentMatch && currentMatch.file && currentMatch.line !== undefined) {
+                matches.push({
+                    file: this.normalizePath(currentMatch.file),
+                    line: currentMatch.line,
+                    match: this.truncateLine(currentMatch.match || ''),
+                    contextBefore: contextBefore.map(l => this.truncateLine(l)),
+                    contextAfter: contextAfter.map(l => this.truncateLine(l)),
+                });
+                currentMatch = null;
+                contextBefore = [];
+                contextAfter = [];
+            }
+        };
         for (const line of lines) {
             try {
                 const data = JSON.parse(line);
                 if (data.type === 'match') {
-                    // Save previous match if exists
-                    if (currentMatch && currentMatch.file && currentMatch.line !== undefined) {
-                        matches.push({
-                            file: this.normalizePath(currentMatch.file),
-                            line: currentMatch.line,
-                            column: currentMatch.column || 1,
-                            match: this.truncateLine(currentMatch.match || ''),
-                            contextBefore: contextBefore.map(l => this.truncateLine(l)),
-                            contextAfter: contextAfter.map(l => this.truncateLine(l)),
-                        });
-                        contextBefore = [];
-                        contextAfter = [];
-                    }
+                    pushMatch(); // Push previous match if any
                     totalMatches++;
                     if (matches.length < GrepSearchTool.MAX_MATCHES) {
                         const matchData = data.data;
                         currentMatch = {
                             file: matchData.path.text,
                             line: matchData.line_number,
-                            column: matchData.submatches?.[0]?.start || 1,
                             match: matchData.lines.text.trimEnd(),
                         };
                     }
@@ -144,36 +152,38 @@ export class GrepSearchTool {
                     const contextData = data.data;
                     const contextLine = contextData.lines.text.trimEnd();
                     if (currentMatch && currentMatch.line !== undefined) {
-                        // Determine if this is before or after the match
-                        if (contextData.line_number < currentMatch.line) {
-                            contextBefore.push(contextLine);
-                            // Keep only last N lines
-                            if (contextBefore.length > GrepSearchTool.CONTEXT_LINES) {
-                                contextBefore.shift();
-                            }
-                        }
-                        else {
-                            contextAfter.push(contextLine);
+                        // This is context AFTER the current match
+                        contextAfter.push(contextLine);
+                    }
+                    else {
+                        // This is context BEFORE the next match (or we are between matches)
+                        // Since rg --json streams, context before a match usually comes before the match event.
+                        // But wait, if we just finished a match, 'context' could be after.
+                        // Actually, rg JSON output structure:
+                        // context (before) -> match -> context (after)
+                        // But if matches are close, context after match 1 might be context before match 2.
+                        // For simplicity in this parser: 
+                        // If we have a currentMatch, this is context AFTER.
+                        // If we don't, this is context BEFORE.
+                        contextBefore.push(contextLine);
+                        // Keep only last N lines for 'before' context
+                        if (contextBefore.length > GrepSearchTool.CONTEXT_LINES) {
+                            contextBefore.shift();
                         }
                     }
                 }
+                else if (data.type === 'end') {
+                    // End of a search result for a file?
+                    // rg emits 'end' stats.
+                    // We might need to flush the last match if context came after it.
+                    pushMatch();
+                }
             }
             catch (parseError) {
-                // Skip invalid JSON lines
                 continue;
             }
         }
-        // Save last match
-        if (currentMatch && currentMatch.file && currentMatch.line !== undefined) {
-            matches.push({
-                file: this.normalizePath(currentMatch.file),
-                line: currentMatch.line,
-                column: currentMatch.column || 1,
-                match: this.truncateLine(currentMatch.match || ''),
-                contextBefore: contextBefore.map(l => this.truncateLine(l)),
-                contextAfter: contextAfter.map(l => this.truncateLine(l)),
-            });
-        }
+        pushMatch(); // Ensure flush
         return {
             matches,
             totalMatches,
@@ -185,206 +195,200 @@ export class GrepSearchTool {
      * Execute search using native grep (Linux/Mac)
      */
     async searchWithGrep(params, cwd) {
-        const args = ['grep', '-rn'];
+        const args = ['-rn'];
         // Case sensitivity
-        if (!params.caseSensitive) {
+        if (params.CaseInsensitive) {
             args.push('-i');
         }
         // Context lines
         args.push(`--context=${GrepSearchTool.CONTEXT_LINES}`);
-        // File pattern
-        if (params.filePattern) {
-            args.push(`--include=${params.filePattern}`);
-        }
-        // Exclude pattern
-        if (params.excludePattern) {
-            args.push(`--exclude=${params.excludePattern}`);
-        }
-        // Pattern and directory
-        args.push(params.pattern, '.');
-        try {
-            const { stdout } = await execAsync(args.join(' '), { cwd, maxBuffer: 10 * 1024 * 1024 });
-            return this.parseGrepOutput(stdout, params.pattern);
-        }
-        catch (error) {
-            // grep returns exit code 1 when no matches found
-            if (error.code === 1 && error.stdout) {
-                return this.parseGrepOutput(error.stdout, params.pattern);
-            }
-            throw error;
+        // Includes
+        if (params.Includes && params.Includes.length > 0) {
+            params.Includes.forEach(pattern => {
+                args.push(`--include=${pattern}`);
+            });
         }
-    }
-    /**
-     * Execute search using findstr (Windows)
-     */
-    async searchWithFindstr(params, cwd) {
-        // findstr has limited capabilities, so we'll use a simpler approach
-        const pattern = params.pattern;
-        const filePattern = params.filePattern || '*.*';
-        // findstr doesn't support context lines, so we'll need to handle that separately
-        const args = [
-            'findstr',
-            '/S', // Search subdirectories
-            '/N', // Show line numbers
-        ];
-        if (!params.caseSensitive) {
-            args.push('/I'); // Case-insensitive
+        // Fixed string vs Regex
+        if (!params.IsRegex) {
+            args.push('-F');
         }
-        args.push(`/C:"${pattern}"`, filePattern);
+        // Pattern
+        args.push(params.Query);
+        // Path
+        args.push(params.SearchPath);
         try {
-            const { stdout } = await execAsync(args.join(' '), { cwd, maxBuffer: 10 * 1024 * 1024 });
-            return this.parseFindstrOutput(stdout, params.pattern, cwd);
+            const { stdout } = await execFileAsync('grep', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+            return this.parseGrepOutput(stdout, params.Query);
         }
         catch (error) {
-            // findstr returns exit code 1 when no matches found
-            if (error.code === 1 && (!error.stdout || error.stdout.trim() === '')) {
+            if (error.code === 1) {
                 return {
                     matches: [],
                     totalMatches: 0,
                     truncated: false,
-                    searchPattern: params.pattern,
+                    searchPattern: params.Query,
                 };
             }
-            if (error.stdout) {
-                return this.parseFindstrOutput(error.stdout, params.pattern, cwd);
-            }
             throw error;
         }
     }
-    /**
-     * Parse grep output
-     */
     parseGrepOutput(output, searchPattern) {
-        const lines = output.trim().split('\n').filter(line => line);
+        // Grep output with context:
+        // file:line:match
+        // file-line-context
+        // -- (separator)
+        const lines = output.trim().split('\n');
         const matches = [];
-        let i = 0;
-        while (i < lines.length && matches.length < GrepSearchTool.MAX_MATCHES) {
-            const line = lines[i];
-            // Skip separator lines
+        // Simple parsing strategy: group by file and proximity
+        // For robust parsing similar to rg, we'd need more complex logic.
+        // Given the constraints, we'll do a best-effort parse.
+        let currentMatch = null;
+        let contextBefore = [];
+        let contextAfter = [];
+        const pushMatch = () => {
+            if (currentMatch && currentMatch.file && currentMatch.line !== undefined) {
+                matches.push({
+                    file: this.normalizePath(currentMatch.file),
+                    line: currentMatch.line,
+                    match: this.truncateLine(currentMatch.match || ''),
+                    contextBefore: contextBefore.map(l => this.truncateLine(l)),
+                    contextAfter: contextAfter.map(l => this.truncateLine(l)),
+                });
+                currentMatch = null;
+                contextBefore = [];
+                contextAfter = [];
+            }
+        };
+        for (const line of lines) {
             if (line === '--') {
-                i++;
+                pushMatch();
                 continue;
             }
-            // Parse match line: filename:linenum:content or filename:linenum-content (for context)
+            // Match: file:line:content
             const matchRegex = /^([^:]+):(\d+):(.*)$/;
-            const contextRegex = /^([^:]+):(\d+)-(.*)$/;
-            const matchMatch = line.match(matchRegex);
-            if (matchMatch) {
-                const [, file, lineNum, content] = matchMatch;
-                const contextBefore = [];
-                const contextAfter = [];
-                // Look back for context
-                let j = i - 1;
-                while (j >= 0 && contextBefore.length < GrepSearchTool.CONTEXT_LINES) {
-                    const prevLine = lines[j];
-                    if (prevLine === '--')
-                        break;
-                    const contextMatch = prevLine.match(contextRegex);
-                    if (contextMatch && contextMatch[1] === file) {
-                        contextBefore.unshift(contextMatch[3]);
-                    }
-                    else {
-                        break;
-                    }
-                    j--;
+            // Context: file-line-content
+            const contextRegex = /^([^:]+)-(\d+)-(.*)$/;
+            const matchM = line.match(matchRegex);
+            const contextM = line.match(contextRegex);
+            if (matchM) {
+                pushMatch(); // Flush previous
+                currentMatch = {
+                    file: matchM[1],
+                    line: parseInt(matchM[2], 10),
+                    match: matchM[3]
+                };
+            }
+            else if (contextM) {
+                if (currentMatch) {
+                    contextAfter.push(contextM[3]);
                 }
-                // Look ahead for context
-                let k = i + 1;
-                while (k < lines.length && contextAfter.length < GrepSearchTool.CONTEXT_LINES) {
-                    const nextLine = lines[k];
-                    if (nextLine === '--')
-                        break;
-                    const contextMatch = nextLine.match(contextRegex);
-                    if (contextMatch && contextMatch[1] === file) {
-                        contextAfter.push(contextMatch[3]);
-                    }
-                    else {
-                        break;
-                    }
-                    k++;
+                else {
+                    contextBefore.push(contextM[3]);
+                    if (contextBefore.length > GrepSearchTool.CONTEXT_LINES)
+                        contextBefore.shift();
                 }
-                matches.push({
-                    file: this.normalizePath(file),
-                    line: parseInt(lineNum, 10),
-                    column: 1, // grep doesn't provide column info
-                    match: this.truncateLine(content),
-                    contextBefore: contextBefore.map(l => this.truncateLine(l)),
-                    contextAfter: contextAfter.map(l => this.truncateLine(l)),
-                });
             }
-            i++;
         }
+        pushMatch();
         return {
-            matches,
-            totalMatches: lines.filter(l => l.match(/^[^:]+:\d+:/)).length,
+            matches: matches.slice(0, GrepSearchTool.MAX_MATCHES),
+            totalMatches: matches.length, // grep doesn't give total easily without another run
             truncated: matches.length >= GrepSearchTool.MAX_MATCHES,
-            searchPattern,
+            searchPattern
         };
     }
     /**
-     * Parse findstr output
+     * Execute search using findstr (Windows)
+     * NOTE: Context is DISABLED for findstr to avoid performance/encoding issues.
      */
-    async parseFindstrOutput(output, searchPattern, cwd) {
-        const lines = output.trim().split('\n').filter(line => line);
+    async searchWithFindstr(params, cwd) {
+        const args = [
+            '/N', // Print line numbers
+            '/S', // Recursive
+        ];
+        if (params.CaseInsensitive) {
+            args.push('/I');
+        }
+        // findstr doesn't support full regex, only limited.
+        // If IsRegex is true, we might be limited.
+        if (!params.IsRegex) {
+            args.push('/L'); // Literal search
+        }
+        else {
+            args.push('/R'); // Regex search
+        }
+        // Pattern
+        args.push('/C:' + params.Query);
+        // File mask
+        // findstr [options] strings [drive:][path]filename[...]
+        // We can pass the path/mask at the end.
+        // If Includes is set, we can try to use it, but findstr is limited.
+        // We'll just use SearchPath and optional Includes if it's a simple extension.
+        let searchMask = '*.*';
+        if (params.Includes && params.Includes.length === 1 && params.Includes[0].startsWith('*.')) {
+            searchMask = params.Includes[0];
+        }
+        // If SearchPath is a directory, append mask. If file, use it.
+        let target = params.SearchPath;
+        try {
+            const stats = await fs.promises.stat(path.resolve(cwd, params.SearchPath));
+            if (stats.isDirectory()) {
+                target = path.join(params.SearchPath, searchMask);
+            }
+        }
+        catch {
+            // Assume it's a pattern or file that doesn't exist yet? 
+            // Just pass it as is.
+        }
+        args.push(target);
+        try {
+            // Use execFile with 'findstr'
+            const { stdout } = await execFileAsync('findstr', args, { cwd, maxBuffer: 10 * 1024 * 1024 });
+            return this.parseFindstrOutput(stdout, params.Query);
+        }
+        catch (error) {
+            if (error.code === 1) {
+                return { matches: [], totalMatches: 0, truncated: false, searchPattern: params.Query };
+            }
+            throw error;
+        }
+    }
+    parseFindstrOutput(output, searchPattern) {
+        const lines = output.trim().split('\r\n'); // Windows line endings
         const matches = [];
-        const fs = await import('fs/promises');
         for (const line of lines) {
-            if (matches.length >= GrepSearchTool.MAX_MATCHES)
-                break;
-            // Parse findstr output: filename:linenum:content
-            const match = line.match(/^([^:]+):(\d+):(.*)$/);
-            if (!match)
+            if (!line)
                 continue;
-            const [, file, lineNum, content] = match;
-            const lineNumber = parseInt(lineNum, 10);
-            // Read context lines from file
-            const contextBefore = [];
-            const contextAfter = [];
-            try {
-                const fullPath = path.resolve(cwd, file);
-                const fileContent = await fs.readFile(fullPath, 'utf-8');
-                const fileLines = fileContent.split('\n');
-                // Get context before
-                for (let i = Math.max(0, lineNumber - GrepSearchTool.CONTEXT_LINES - 1); i < lineNumber - 1; i++) {
-                    if (fileLines[i] !== undefined) {
-                        contextBefore.push(fileLines[i]);
-                    }
-                }
-                // Get context after
-                for (let i = lineNumber; i < Math.min(fileLines.length, lineNumber + GrepSearchTool.CONTEXT_LINES); i++) {
-                    if (fileLines[i] !== undefined) {
-                        contextAfter.push(fileLines[i]);
-                    }
-                }
-            }
-            catch (error) {
-                // If we can't read the file, just skip context
+            // Format: file:line:match
+            // But findstr output depends on args. /N /S gives:
+            // file:line:match
+            // Find first two colons
+            const firstColon = line.indexOf(':');
+            const secondColon = line.indexOf(':', firstColon + 1);
+            if (firstColon > -1 && secondColon > -1) {
+                const file = line.substring(0, firstColon);
+                const lineNum = parseInt(line.substring(firstColon + 1, secondColon), 10);
+                const content = line.substring(secondColon + 1);
+                matches.push({
+                    file: this.normalizePath(file),
+                    line: lineNum,
+                    match: this.truncateLine(content),
+                    contextBefore: [], // No context for findstr
+                    contextAfter: []
+                });
             }
-            matches.push({
-                file: this.normalizePath(file),
-                line: lineNumber,
-                column: 1, // findstr doesn't provide column info
-                match: this.truncateLine(content),
-                contextBefore: contextBefore.map(l => this.truncateLine(l)),
-                contextAfter: contextAfter.map(l => this.truncateLine(l)),
-            });
         }
         return {
-            matches,
-            totalMatches: lines.length,
+            matches: matches.slice(0, GrepSearchTool.MAX_MATCHES),
+            totalMatches: matches.length,
             truncated: matches.length >= GrepSearchTool.MAX_MATCHES,
-            searchPattern,
+            searchPattern
         };
     }
     /**
      * Execute the grep search
      */
     async execute(params, cwd) {
-        // Validate pattern
-        const validation = this.validatePattern(params.pattern);
-        if (!validation.valid) {
-            throw new Error(validation.error);
-        }
         // Try ripgrep first
         if (await this.hasRipgrep()) {
             return await this.searchWithRipgrep(params, cwd);
@@ -401,89 +405,114 @@ export class GrepSearchTool {
     }
 }
 /**
- * Format grep search results for display
+ * Format grep search results for AI consumption
+ *
+ * Format:
+ * filename
+ * line:   context
+ * line:>  match
+ * line:   context
  */
 function formatGrepResults(result) {
     if (result.matches.length === 0) {
-        return `No matches found for pattern "${result.searchPattern}"\nSuggestion: Try a broader search pattern or check spelling. Use case-insensitive search if needed.`;
+        return `No matches found for pattern "${result.searchPattern}"`;
     }
-    const lines = [];
-    lines.push(`Found ${result.totalMatches} match${result.totalMatches === 1 ? '' : 'es'} for pattern "${result.searchPattern}"`);
+    const output = [];
+    output.push(`Found ${result.totalMatches} match${result.totalMatches === 1 ? '' : 'es'} for pattern "${result.searchPattern}"`);
     if (result.truncated) {
-        lines.push(`(showing first ${result.matches.length} matches)`);
+        output.push(`(showing first ${result.matches.length} matches)`);
     }
-    lines.push('');
-    for (const match of result.matches) {
-        lines.push(`${match.file}:${match.line}:${match.column}`);
-        // Context before
-        if (match.contextBefore.length > 0) {
-            for (const ctx of match.contextBefore) {
-                lines.push(`  | ${ctx}`);
-            }
-        }
-        // The match itself
-        lines.push(`  > ${match.match}`);
-        // Context after
-        if (match.contextAfter.length > 0) {
-            for (const ctx of match.contextAfter) {
-                lines.push(`  | ${ctx}`);
-            }
-        }
-        lines.push('');
-    }
-    return lines.join('\n');
+    // Group by file
+    const matchesByFile = new Map();
+    result.matches.forEach(match => {
+        if (!matchesByFile.has(match.file)) {
+            matchesByFile.set(match.file, []);
+        }
+        matchesByFile.get(match.file)?.push(match);
+    });
+    matchesByFile.forEach((matches, file) => {
+        output.push(`\n${file}`);
+        matches.forEach(match => {
+            // Context Before
+            match.contextBefore.forEach((ctx, idx) => {
+                // Calculate line number for context if possible?
+                // rg json gives line numbers for context, but our interface simplified it.
+                // We'll just print it without line number or with a placeholder if we don't have it.
+                // Actually, for AI parsing, it's better to have line numbers.
+                // But if we don't have them (grep/findstr), we shouldn't fake them incorrectly.
+                // However, rg gives them. 
+                // Let's just indent context.
+                // Wait, user requested: "48:   function..."
+                // If we don't have line numbers for context, maybe we should skip context or just indent?
+                // "Use line numbers explicitly for every line."
+                // Since we might not have them for context in all cases, let's try to infer or just use indentation.
+                // For the match, we definitely have the line number.
+                // Let's assume context lines are immediately preceding.
+                const startLine = match.line - match.contextBefore.length;
+                output.push(`${startLine + idx}:   ${ctx}`);
+            });
+            // Match
+            output.push(`${match.line}:>  ${match.match}`);
+            // Context After
+            match.contextAfter.forEach((ctx, idx) => {
+                output.push(`${match.line + 1 + idx}:   ${ctx}`);
+            });
+            // Separator if needed? AI usually handles blocks well.
+        });
+    });
+    return output.join('\n');
 }
-/**
- * Grep search tool for the tool registry
- */
 export const grepSearchTool = {
     schema: {
         name: 'grep_search',
-        description: `Search for text patterns across files in the codebase using regex.
-
-USE THIS TOOL WHEN:
-- User asks "where is X defined"
-- You need to find all occurrences of a function, class, or variable
-- You need to locate TODO comments or specific code patterns
-- You want to understand how a feature is implemented across files
-
-BEFORE using read_file on multiple files, use this to find relevant files first.
+        description: `Use ripgrep to find exact pattern matches within files or directories.
+Results are returned in a parseable text format with line numbers:
+filename
+line:   context
+line:>  match
+line:   context
 
-EXAMPLES:
-- Find class definition: pattern="class User"
-- Find function calls: pattern="connectDatabase\\\\("
-- Find TODO comments: pattern="TODO.*auth"
-- Find imports: pattern="import.*express"`,
+Total results are capped at 50 matches. Use the Includes option to filter by file type or specific paths to refine your search.`,
         parameters: {
             type: 'object',
             properties: {
-                pattern: {
+                reason_text: {
                     type: 'string',
-                    description: 'Regex pattern to search for. Use \\\\ to escape special characters.',
+                    description: 'REQUIRED: A brief explanation of what you are searching for and why.',
                 },
-                caseSensitive: {
-                    type: 'boolean',
-                    description: 'Whether search should be case-sensitive. Default: false',
-                },
-                filePattern: {
+                Query: {
                     type: 'string',
-                    description: 'Glob pattern to filter files (e.g., "*.ts", "src/**/*.py"). Optional.',
+                    description: 'The search term or pattern to look for within files.',
                 },
-                excludePattern: {
+                SearchPath: {
                     type: 'string',
-                    description: 'Glob pattern to exclude files (e.g., "*.test.ts", "dist/**"). Optional.',
+                    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' }
+                },
+                CaseInsensitive: {
+                    type: 'boolean',
+                    description: 'If true, performs a case-insensitive search.',
+                },
+                IsRegex: {
+                    type: 'boolean',
+                    description: 'If true, treats Query as a regular expression.',
                 },
             },
-            required: ['pattern'],
+            required: ['reason_text', 'Query', 'SearchPath'],
         },
     },
     async execute(args, context) {
         const tool = new GrepSearchTool();
         const params = {
-            pattern: args.pattern,
-            caseSensitive: args.caseSensitive ?? false,
-            filePattern: args.filePattern,
-            excludePattern: args.excludePattern,
+            Query: args.Query,
+            SearchPath: args.SearchPath,
+            Includes: args.Includes,
+            CaseInsensitive: args.CaseInsensitive,
+            IsRegex: args.IsRegex,
         };
         try {
             const result = await tool.execute(params, context.cwd);