@vybestack/llxprt-code-tools 0.10.0-nightly.260613.1adad3b34

package/dist/src/tools/grep.js

@@ -0,0 +1,883 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/* eslint-disable complexity, sonarjs/cognitive-complexity, max-lines -- Phase 5: legacy core boundary retained while larger decomposition continues. */
+import fsPromises from 'fs/promises';
+import path from 'path';
+import { EOL } from 'os';
+import { spawn } from 'child_process';
+import { globStream } from 'glob';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind, } from './tools.js';
+import { makeRelative, shortenPath } from '../utils/paths.js';
+import { getErrorMessage, isNodeError } from '../utils/errors.js';
+import { isGitRepository } from '../utils/gitUtils.js';
+import { resolveTextSearchTarget, } from '../utils/resolveTextSearchTarget.js';
+import { ToolErrorType } from '../types/tool-error.js';
+import { limitOutputTokens, formatLimitedOutput, } from '../utils/toolOutputLimiter.js';
+import { debugLogger } from '../utils/debugLogger.js';
+/**
+ * Checks if a glob pattern contains brace expansion syntax that git grep doesn't support.
+ * Git grep pathspecs don't support shell-style brace expansion like {ts,tsx,js}.
+ * Uses indexOf for O(n) complexity instead of regex to avoid ReDoS vulnerability.
+ */
+function hasBraceExpansion(pattern) {
+    const braceStart = pattern.indexOf('{');
+    if (braceStart === -1)
+        return false;
+    const braceEnd = pattern.indexOf('}', braceStart);
+    if (braceEnd === -1)
+        return false;
+    const commaPos = pattern.indexOf(',', braceStart);
+    return commaPos !== -1 && commaPos < braceEnd;
+}
+// --- Interfaces ---
+/**
+ * Default timeout for grep operations in milliseconds (1 minute)
+ */
+const DEFAULT_TIMEOUT_MS = 60_000;
+/**
+ * Maximum allowed timeout for grep operations in milliseconds (5 minutes)
+ */
+const MAX_TIMEOUT_MS = 300_000;
+class GrepToolInvocation extends BaseToolInvocation {
+    host;
+    fileExclusions;
+    constructor(host, params, messageBus) {
+        super(params, messageBus);
+        this.host = host;
+        this.fileExclusions = host.getFileExclusions();
+    }
+    getDirPath() {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: dir_path and path are optional strings, empty string should fall through
+        return this.params.dir_path || this.params.path;
+    }
+    resolveTarget(relativePath) {
+        return resolveTextSearchTarget(this.host.getTargetDir(), this.host.getWorkspaceRoots(), relativePath);
+    }
+    /**
+     * Executes a single-file search and returns a formatted ToolResult.
+     */
+    async executeSingleFileSearch(resolved, combinedSignal, searchDirDisplay) {
+        const fileResult = await this.performSingleFileSearch(this.params.pattern, resolved.filePath, resolved.basename, combinedSignal);
+        let includeNote = '';
+        if (this.params.include) {
+            includeNote =
+                '\nNote: include filter ignored because a specific file path was provided.';
+        }
+        if (fileResult.length === 0) {
+            const noMatchMsg = `No matches found for pattern "${this.params.pattern}" in file "${searchDirDisplay}".${includeNote}`;
+            return { llmContent: noMatchMsg, returnDisplay: 'No matches found' };
+        }
+        const matchTerm = fileResult.length === 1 ? 'match' : 'matches';
+        let llmContent = `Found ${fileResult.length} ${matchTerm} for pattern "${this.params.pattern}" in file "${searchDirDisplay}":${includeNote}
+---
+File: ${resolved.basename}
+`;
+        for (const match of fileResult) {
+            llmContent += `L${match.lineNumber}: ${match.line.trim()}
+`;
+        }
+        llmContent += '---';
+        const limited = limitOutputTokens(llmContent.trim(), this.host, 'SearchText');
+        if (limited.wasTruncated) {
+            const formatted = formatLimitedOutput(limited);
+            return {
+                llmContent: formatted.llmContent,
+                returnDisplay: formatted.returnDisplay,
+            };
+        }
+        return {
+            llmContent: llmContent.trim(),
+            returnDisplay: `Found ${fileResult.length} ${matchTerm}`,
+        };
+    }
+    /**
+     * Collects matches across multiple search directories.
+     */
+    async collectDirectoryMatches(searchDirectories, combinedSignal, maxResults, maxFiles, maxPerFile, filesWithMatches) {
+        let allMatches = [];
+        let totalMatchesFound = 0;
+        let wasLimited = false;
+        for (const searchDir of searchDirectories) {
+            if (allMatches.length >= maxResults) {
+                wasLimited = true;
+                break;
+            }
+            const matches = await this.performGrepSearch({
+                pattern: this.params.pattern,
+                path: searchDir,
+                include: this.params.include,
+                signal: combinedSignal,
+                maxResults: maxResults - allMatches.length,
+                maxFiles: maxFiles - filesWithMatches.size,
+                maxPerFile,
+            });
+            if (matches.wasLimited === true) {
+                wasLimited = true;
+            }
+            if (searchDirectories.length > 1) {
+                const dirName = path.basename(searchDir);
+                matches.results.forEach((match) => {
+                    match.filePath = path.join(dirName, match.filePath);
+                });
+            }
+            matches.results.forEach((match) => {
+                filesWithMatches.add(match.filePath);
+            });
+            totalMatchesFound += matches.totalFound ?? matches.results.length;
+            allMatches = allMatches.concat(matches.results);
+        }
+        return { allMatches, totalMatchesFound, wasLimited };
+    }
+    /**
+     * Applies max_files and max_per_file limits, returning grouped matches,
+     * match count, and any limit message.
+     */
+    applyFileLimits(allMatches, filesWithMatches, maxFiles, maxPerFile) {
+        let limitedMatches = allMatches;
+        let limitMessage = '';
+        let wasLimited = false;
+        if (filesWithMatches.size > maxFiles) {
+            const filesToKeep = Array.from(filesWithMatches).slice(0, maxFiles);
+            limitedMatches = allMatches.filter((match) => filesToKeep.includes(match.filePath));
+            limitMessage = `
+
+**Note: Results limited to ${maxFiles} files out of ${filesWithMatches.size} files with matches.**`;
+            wasLimited = true;
+        }
+        const matchesByFile = limitedMatches.reduce((acc, match) => {
+            const fileKey = match.filePath;
+            if (!(fileKey in acc)) {
+                acc[fileKey] = [];
+            }
+            if (acc[fileKey].length < maxPerFile) {
+                acc[fileKey].push(match);
+            }
+            acc[fileKey].sort((a, b) => a.lineNumber - b.lineNumber);
+            return acc;
+        }, {});
+        const matchCount = Object.values(matchesByFile).reduce((sum, matches) => sum + matches.length, 0);
+        return {
+            matchesByFile,
+            matchCount,
+            limitedMatches,
+            limitMessage,
+            wasLimited,
+        };
+    }
+    /**
+     * Builds the formatted LLM content string from grouped matches.
+     */
+    formatMatchOutput(matchesByFile, limitMessage, totalMatchesFound, matchCount, wasLimited, searchLocationDescription) {
+        let llmContent = '';
+        if (wasLimited || totalMatchesFound > matchCount) {
+            llmContent = `Found ${totalMatchesFound} total matches, showing ${matchCount} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}:
+---
+`;
+        }
+        else {
+            const matchTerm = matchCount === 1 ? 'match' : 'matches';
+            llmContent = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}:
+---
+`;
+        }
+        for (const filePath in matchesByFile) {
+            llmContent += `File: ${filePath}
+`;
+            matchesByFile[filePath].forEach((match) => {
+                const trimmedLine = match.line.trim();
+                llmContent += `L${match.lineNumber}: ${trimmedLine}
+`;
+            });
+            llmContent += '---\n';
+        }
+        if (limitMessage) {
+            llmContent += limitMessage;
+        }
+        return llmContent;
+    }
+    /**
+     * Applies file and per-file limits to matches and builds the output content.
+     */
+    buildDirectorySearchResult(allMatches, totalMatchesFound, wasLimited, filesWithMatches, searchLocationDescription, maxFiles, maxPerFile) {
+        if (allMatches.length === 0) {
+            const noMatchMsg = `No matches found for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}.`;
+            return { llmContent: noMatchMsg, returnDisplay: `No matches found` };
+        }
+        const { matchesByFile, matchCount, limitMessage, wasLimited: limited, } = this.applyFileLimits(allMatches, filesWithMatches, maxFiles, maxPerFile);
+        const effectiveWasLimited = wasLimited || limited;
+        const llmContent = this.formatMatchOutput(matchesByFile, limitMessage, totalMatchesFound, matchCount, effectiveWasLimited, searchLocationDescription);
+        // Apply token limiting as final safety check
+        const limitedOutput = limitOutputTokens(llmContent.trim(), this.host, 'SearchText');
+        if (limitedOutput.wasTruncated) {
+            const formatted = formatLimitedOutput(limitedOutput);
+            return {
+                llmContent: formatted.llmContent,
+                returnDisplay: formatted.returnDisplay,
+            };
+        }
+        const displayCount = effectiveWasLimited || totalMatchesFound > matchCount
+            ? `Found ${totalMatchesFound} matches (showing ${matchCount})`
+            : // eslint-disable-next-line sonarjs/no-nested-conditional -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+                `Found ${matchCount} ${matchCount === 1 ? 'match' : 'matches'}`;
+        return {
+            llmContent: llmContent.trim(),
+            returnDisplay: displayCount,
+        };
+    }
+    /**
+     * Handles abort/timeout errors from execute, returning appropriate ToolResult.
+     */
+    handleExecuteError(error, timeoutController, timeoutMs, signal) {
+        const isAbortError = error instanceof Error &&
+            (error.name === 'AbortError' ||
+                error.message.includes('aborted') ||
+                error.message.includes('This operation was aborted'));
+        if (isAbortError) {
+            // Check if it was a timeout (our controller aborted but user's didn't)
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- caller AbortSignal can change asynchronously outside this stack
+            if (timeoutController.signal.aborted && !signal.aborted) {
+                const timeoutMessage = `Search operation timed out after ${timeoutMs}ms. To resolve this, you can either:
+` +
+                    `1. Increase the timeout (max ${MAX_TIMEOUT_MS}ms) by adding timeout_ms parameter
+` +
+                    `2. Use a more specific pattern to reduce search scope
+` +
+                    `3. Use a narrower path or include filter`;
+                return {
+                    llmContent: timeoutMessage,
+                    returnDisplay: `Timed out after ${timeoutMs}ms`,
+                    error: {
+                        message: timeoutMessage,
+                        type: ToolErrorType.TIMEOUT,
+                    },
+                };
+            }
+            return {
+                llmContent: 'Search operation was cancelled by user.',
+                returnDisplay: 'Cancelled',
+                error: {
+                    message: 'Search operation was cancelled by user.',
+                    type: ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+        debugLogger.error(`Error during GrepLogic execution: ${error}`);
+        const errorMessage = getErrorMessage(error);
+        return {
+            llmContent: `Error during grep search operation: ${errorMessage}`,
+            returnDisplay: `Error: ${errorMessage}`,
+            error: {
+                message: errorMessage,
+                type: ToolErrorType.GREP_EXECUTION_ERROR,
+            },
+        };
+    }
+    /**
+     * Executes the directory search after resolving the target.
+     */
+    async executeDirectorySearch(resolved, workspaceContext, combinedSignal, searchDirDisplay) {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: dirPath is optional string, empty string should fall through
+        const ephemeralSettings = this.host.getEphemeralSettings();
+        const maxResults = this.params.max_results ??
+            ephemeralSettings['tool-output-max-items'] ??
+            1000;
+        const maxFiles = this.params.max_files ?? 100;
+        const maxPerFile = this.params.max_per_file ?? 50;
+        if (resolved.kind === 'file') {
+            return this.executeSingleFileSearch(resolved, combinedSignal, searchDirDisplay);
+        }
+        // Determine which directories to search
+        let searchDirectories;
+        if (resolved.kind === 'all-workspaces') {
+            searchDirectories = workspaceContext;
+        }
+        else {
+            searchDirectories = [resolved.searchDir];
+        }
+        const filesWithMatches = new Set();
+        const { allMatches, totalMatchesFound, wasLimited } = await this.collectDirectoryMatches(searchDirectories, combinedSignal, maxResults, maxFiles, maxPerFile, filesWithMatches);
+        let searchLocationDescription;
+        if (resolved.kind === 'all-workspaces') {
+            const numDirs = workspaceContext.length;
+            searchLocationDescription =
+                numDirs > 1
+                    ? `across ${numDirs} workspace directories`
+                    : `in the workspace directory`;
+        }
+        else {
+            searchLocationDescription = `in path "${searchDirDisplay}"`;
+        }
+        return this.buildDirectorySearchResult(allMatches, totalMatchesFound, wasLimited, filesWithMatches, searchLocationDescription, maxFiles, maxPerFile);
+    }
+    async execute(signal) {
+        // Set up timeout handling
+        const timeoutMs = Math.min(this.params.timeout_ms ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+        const timeoutController = new AbortController();
+        const timeoutId = setTimeout(() => timeoutController.abort(), timeoutMs);
+        // Combine user abort with timeout abort
+        const onUserAbort = () => {
+            clearTimeout(timeoutId);
+            timeoutController.abort();
+        };
+        if (signal.aborted) {
+            clearTimeout(timeoutId);
+            timeoutController.abort();
+            return {
+                llmContent: 'Search operation was cancelled by user.',
+                returnDisplay: 'Cancelled',
+                error: {
+                    message: 'Search operation was cancelled by user.',
+                    type: ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+        signal.addEventListener('abort', onUserAbort, { once: true });
+        const combinedSignal = timeoutController.signal;
+        try {
+            const workspaceContext = this.host.getWorkspaceRoots();
+            const dirPath = this.getDirPath();
+            const resolved = this.resolveTarget(dirPath);
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: dirPath is optional string, empty string should fall through
+            const searchDirDisplay = dirPath || '.';
+            return await this.executeDirectorySearch(resolved, workspaceContext, combinedSignal, searchDirDisplay);
+        }
+        catch (error) {
+            return this.handleExecuteError(error, timeoutController, timeoutMs, signal);
+        }
+        finally {
+            clearTimeout(timeoutId);
+            signal.removeEventListener('abort', onUserAbort);
+        }
+    }
+    /**
+     * Checks if a command is available in the system's PATH.
+     * @param {string} command The command name (e.g., 'git', 'grep').
+     * @returns {Promise<boolean>} True if the command is available, false otherwise.
+     */
+    isCommandAvailable(command) {
+        return new Promise((resolve) => {
+            const checkCommand = process.platform === 'win32' ? 'where' : 'command';
+            const checkArgs = process.platform === 'win32' ? [command] : ['-v', command];
+            try {
+                // eslint-disable-next-line sonarjs/os-command -- Project intentionally invokes platform tooling at this trusted boundary; arguments remain explicit and behavior is preserved.
+                const child = spawn(checkCommand, checkArgs, {
+                    stdio: 'ignore',
+                    shell: true,
+                });
+                child.on('close', (code) => resolve(code === 0));
+                child.on('error', (err) => {
+                    debugLogger.debug(`[GrepTool] Failed to start process for '${command}':`, err.message);
+                    resolve(false);
+                });
+            }
+            catch {
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Apply limits to search results
+     */
+    applyLimits(matches, maxResults, maxFiles, maxPerFile) {
+        const filesWithMatches = new Map();
+        const totalFound = matches.length;
+        // Group by file and apply per-file limits
+        for (const match of matches) {
+            if (!filesWithMatches.has(match.filePath)) {
+                filesWithMatches.set(match.filePath, []);
+            }
+            const fileMatches = filesWithMatches.get(match.filePath);
+            if (fileMatches.length < maxPerFile) {
+                fileMatches.push(match);
+            }
+        }
+        // Apply file limit
+        const limitedFiles = Array.from(filesWithMatches.entries()).slice(0, maxFiles);
+        // Flatten and apply total results limit
+        const results = [];
+        for (const [, fileMatches] of limitedFiles) {
+            for (const match of fileMatches) {
+                if (results.length >= maxResults) {
+                    break;
+                }
+                results.push(match);
+            }
+            if (results.length >= maxResults) {
+                break;
+            }
+        }
+        return {
+            results,
+            wasLimited: results.length < totalFound || filesWithMatches.size > maxFiles,
+            totalFound: totalFound > results.length ? totalFound : undefined,
+        };
+    }
+    /**
+     * Parses the standard output of grep-like commands (git grep, system grep).
+     * Expects format: filePath:lineNumber:lineContent
+     * Handles colons within file paths and line content correctly.
+     * @param {string} output The raw stdout string.
+     * @param {string} basePath The absolute directory the search was run from, for relative paths.
+     * @returns {GrepMatch[]} Array of match objects.
+     */
+    parseGrepOutput(output, basePath) {
+        const results = [];
+        if (!output)
+            return results;
+        const lines = output.split(EOL); // Use OS-specific end-of-line
+        // eslint-disable-next-line sonarjs/too-many-break-or-continue-in-loop -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            // Find the index of the first colon.
+            const firstColonIndex = line.indexOf(':');
+            if (firstColonIndex === -1)
+                continue; // Malformed
+            // Find the index of the second colon, searching *after* the first one.
+            const secondColonIndex = line.indexOf(':', firstColonIndex + 1);
+            if (secondColonIndex === -1)
+                continue; // Malformed
+            // Extract parts based on the found colon indices
+            const filePathRaw = line.substring(0, firstColonIndex);
+            const lineNumberStr = line.substring(firstColonIndex + 1, secondColonIndex);
+            const lineContent = line.substring(secondColonIndex + 1);
+            const lineNumber = parseInt(lineNumberStr, 10);
+            if (!isNaN(lineNumber)) {
+                const absoluteFilePath = path.resolve(basePath, filePathRaw);
+                const relativeFilePath = path.relative(basePath, absoluteFilePath);
+                results.push({
+                    filePath: relativeFilePath || path.basename(absoluteFilePath),
+                    lineNumber,
+                    line: lineContent,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Gets a description of the grep operation
+     * @returns A string describing the grep
+     */
+    getDescription() {
+        let description = `'${this.params.pattern}'`;
+        if (this.params.include) {
+            description += ` in ${this.params.include}`;
+        }
+        const dirPath = this.getDirPath();
+        if (dirPath) {
+            try {
+                const resolved = this.resolveTarget(dirPath);
+                if (resolved.kind === 'file') {
+                    const relativePath = makeRelative(resolved.filePath, this.host.getTargetDir());
+                    description += ` in ${shortenPath(relativePath)}`;
+                    return description;
+                }
+            }
+            catch {
+                // Fall through to default path display on validation errors
+            }
+            const resolvedPath = path.resolve(this.host.getTargetDir(), dirPath);
+            if (resolvedPath === this.host.getTargetDir() || dirPath === '.') {
+                description += ` within ./`;
+            }
+            else {
+                const relativePath = makeRelative(resolvedPath, this.host.getTargetDir());
+                description += ` within ${shortenPath(relativePath)}`;
+            }
+        }
+        else {
+            const workspaceContext = this.host.getWorkspaceRoots();
+            const directories = workspaceContext;
+            if (directories.length > 1) {
+                description += ` across all workspace directories`;
+            }
+        }
+        return description;
+    }
+    async performSingleFileSearch(pattern, filePath, _basename, signal) {
+        if (signal.aborted) {
+            return [];
+        }
+        const regex = new RegExp(pattern, 'i');
+        const content = await fsPromises.readFile(filePath, 'utf8');
+        const lines = content.split(/\r?\n/);
+        const matches = [];
+        for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+                matches.push({
+                    filePath: path.basename(filePath),
+                    lineNumber: i + 1,
+                    line: lines[i],
+                });
+            }
+        }
+        return matches;
+    }
+    /**
+     * Runs git grep as Strategy 1.
+     */
+    async tryGitGrep(pattern, absolutePath, include, abortSignal, maxResults, maxFiles, maxPerFile, hasBracePattern) {
+        const isGit = !hasBracePattern && isGitRepository(absolutePath);
+        const gitAvailable = isGit && (await this.isCommandAvailable('git'));
+        if (!gitAvailable)
+            return null;
+        const gitArgs = [
+            'grep',
+            '--untracked',
+            '-n',
+            '-E',
+            '--ignore-case',
+            pattern,
+        ];
+        if (include) {
+            gitArgs.push('--', include);
+        }
+        try {
+            const output = await new Promise((resolve, reject) => {
+                // eslint-disable-next-line sonarjs/no-os-command-from-path -- Project intentionally invokes platform tooling at this trusted boundary; arguments remain explicit and behavior is preserved.
+                const child = spawn('git', gitArgs, {
+                    cwd: absolutePath,
+                    windowsHide: true,
+                });
+                const stdoutChunks = [];
+                const stderrChunks = [];
+                const abortHandler = () => {
+                    // eslint-disable-next-line sonarjs/nested-control-flow -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+                    if (!child.killed) {
+                        child.kill('SIGTERM');
+                    }
+                    reject(new Error('git grep aborted'));
+                };
+                abortSignal.addEventListener('abort', abortHandler);
+                child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
+                child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
+                child.on('error', (err) => {
+                    abortSignal.removeEventListener('abort', abortHandler);
+                    reject(new Error(`Failed to start git grep: ${err.message}`));
+                });
+                child.on('close', (code) => {
+                    abortSignal.removeEventListener('abort', abortHandler);
+                    const stdoutData = Buffer.concat(stdoutChunks).toString('utf8');
+                    const stderrData = Buffer.concat(stderrChunks).toString('utf8');
+                    // eslint-disable-next-line sonarjs/nested-control-flow -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+                    if (code === 0)
+                        resolve(stdoutData);
+                    else if (code === 1)
+                        resolve(''); // No matches
+                    else
+                        reject(new Error(`git grep exited with code ${code}: ${stderrData}`));
+                });
+            });
+            const matches = this.parseGrepOutput(output, absolutePath);
+            return this.applyLimits(matches, maxResults, maxFiles, maxPerFile);
+        }
+        catch (gitError) {
+            debugLogger.debug(`GrepLogic: git grep failed: ${getErrorMessage(gitError)}. Falling back...`);
+            return null;
+        }
+    }
+    /**
+     * Builds the grep args for system grep, including exclusion patterns.
+     */
+    buildSystemGrepArgs(pattern, include) {
+        const grepArgs = ['-r', '-n', '-H', '-E', '-I'];
+        const globExcludes = this.fileExclusions;
+        const commonExcludes = globExcludes
+            .map((pattern) => {
+            let dir = pattern;
+            if (dir.startsWith('**/')) {
+                dir = dir.substring(3);
+            }
+            if (dir.endsWith('/**')) {
+                dir = dir.slice(0, -3);
+            }
+            else if (dir.endsWith('/')) {
+                dir = dir.slice(0, -1);
+            }
+            // Only consider patterns that are likely directories
+            if (dir && !dir.includes('/') && !dir.includes('*')) {
+                return dir;
+            }
+            return null;
+        })
+            .filter((dir) => !!dir);
+        commonExcludes.forEach((dir) => grepArgs.push(`--exclude-dir=${dir}`));
+        if (include) {
+            grepArgs.push(`--include=${include}`);
+        }
+        grepArgs.push(pattern);
+        grepArgs.push('.');
+        return grepArgs;
+    }
+    /**
+     * Sets up event handlers for a spawned grep child process.
+     */
+    setupSystemGrepHandlers(child, abortSignal, stdoutChunks, stderrChunks, resolve, reject) {
+        const abortHandler = () => {
+            if (!child.killed) {
+                child.kill('SIGTERM');
+            }
+            cleanup();
+            reject(new Error('system grep aborted'));
+        };
+        abortSignal.addEventListener('abort', abortHandler);
+        const onData = (chunk) => stdoutChunks.push(chunk);
+        const onStderr = (chunk) => {
+            const stderrStr = chunk.toString();
+            if (!stderrStr.includes('Permission denied') &&
+                !/grep:.*: Is a directory/i.test(stderrStr)) {
+                stderrChunks.push(chunk);
+            }
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(new Error(`Failed to start system grep: ${err.message}`));
+        };
+        const onClose = (code) => {
+            const stdoutData = Buffer.concat(stdoutChunks).toString('utf8');
+            const stderrData = Buffer.concat(stderrChunks).toString('utf8').trim();
+            cleanup();
+            if (code === 0)
+                resolve(stdoutData);
+            else if (code === 1)
+                resolve(''); // No matches
+            else if (stderrData)
+                reject(new Error(`System grep exited with code ${code}: ${stderrData}`));
+            else
+                resolve(''); // Exit code > 1 but no stderr, likely just suppressed errors
+        };
+        const cleanup = () => {
+            abortSignal.removeEventListener('abort', abortHandler);
+            child.stdout.removeListener('data', onData);
+            child.stderr.removeListener('data', onStderr);
+            child.removeListener('error', onError);
+            child.removeListener('close', onClose);
+            if (child.connected) {
+                child.disconnect();
+            }
+        };
+        child.stdout.on('data', onData);
+        child.stderr.on('data', onStderr);
+        child.on('error', onError);
+        child.on('close', onClose);
+        return cleanup;
+    }
+    /**
+     * Runs system grep as Strategy 2.
+     */
+    async trySystemGrep(grepArgs, absolutePath, abortSignal, maxResults, maxFiles, maxPerFile) {
+        try {
+            const output = await new Promise((resolve, reject) => {
+                // eslint-disable-next-line sonarjs/no-os-command-from-path -- Project intentionally invokes platform tooling at this trusted boundary; arguments remain explicit and behavior is preserved.
+                const child = spawn('grep', grepArgs, {
+                    cwd: absolutePath,
+                    windowsHide: true,
+                });
+                const stdoutChunks = [];
+                const stderrChunks = [];
+                this.setupSystemGrepHandlers(child, abortSignal, stdoutChunks, stderrChunks, resolve, reject);
+            });
+            const matches = this.parseGrepOutput(output, absolutePath);
+            return this.applyLimits(matches, maxResults, maxFiles, maxPerFile);
+        }
+        catch (grepError) {
+            debugLogger.debug(`GrepLogic: System grep failed: ${getErrorMessage(grepError)}. Falling back...`);
+            return null;
+        }
+    }
+    /**
+     * Extracts matches from a single file's content lines.
+     */
+    extractMatchesFromFile(lines, fileAbsolutePath, absolutePath, regex, maxPerFile, maxResults, allMatches, filesWithMatches) {
+        let matchesInFile = 0;
+        let totalFound = 0;
+        lines.forEach((line, index) => {
+            if (regex.test(line)) {
+                totalFound++;
+                if (matchesInFile < maxPerFile && allMatches.length < maxResults) {
+                    allMatches.push({
+                        filePath: path.relative(absolutePath, fileAbsolutePath) ||
+                            path.basename(fileAbsolutePath),
+                        lineNumber: index + 1,
+                        line,
+                    });
+                    matchesInFile++;
+                    filesWithMatches.add(fileAbsolutePath);
+                }
+            }
+        });
+        return totalFound;
+    }
+    /**
+     * Pure JavaScript fallback for grep (Strategy 3).
+     */
+    async javascriptGrepFallback(pattern, absolutePath, include, abortSignal, maxResults, maxFiles, maxPerFile) {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: include is optional string, empty string should fall through to default glob
+        const globPattern = include ? include : '**/*';
+        const ignorePatterns = this.fileExclusions;
+        const filesStream = globStream(globPattern, {
+            cwd: absolutePath,
+            dot: true,
+            ignore: ignorePatterns,
+            absolute: true,
+            nodir: true,
+            signal: abortSignal,
+        });
+        const regex = new RegExp(pattern, 'i');
+        const allMatches = [];
+        const filesWithMatches = new Set();
+        let totalFound = 0;
+        // eslint-disable-next-line sonarjs/too-many-break-or-continue-in-loop -- Existing structure is intentionally preserved; refactoring this boundary is outside the lint slice.
+        for await (const filePath of filesStream) {
+            // Check if we've hit file limit
+            if (filesWithMatches.size >= maxFiles &&
+                !filesWithMatches.has(filePath)) {
+                continue;
+            }
+            // Check if we've hit total results limit
+            if (allMatches.length >= maxResults) {
+                break;
+            }
+            const fileAbsolutePath = filePath;
+            try {
+                const content = await fsPromises.readFile(fileAbsolutePath, 'utf8');
+                const lines = content.split(/\r?\n/);
+                totalFound += this.extractMatchesFromFile(lines, fileAbsolutePath, absolutePath, regex, maxPerFile, maxResults, allMatches, filesWithMatches);
+            }
+            catch (readError) {
+                // Ignore errors like permission denied or file gone during read
+                if (!isNodeError(readError) || readError.code !== 'ENOENT') {
+                    debugLogger.debug(`GrepLogic: Could not read/process ${fileAbsolutePath}: ${getErrorMessage(readError)}`);
+                }
+            }
+        }
+        return {
+            results: allMatches,
+            wasLimited: totalFound > allMatches.length,
+            totalFound: totalFound > allMatches.length ? totalFound : undefined,
+        };
+    }
+    /**
+     * Attempts system grep (Strategy 2), returning null to fall through.
+     */
+    async trySystemGrepStrategy(pattern, absolutePath, include, signal, maxResults, maxFiles, maxPerFile) {
+        debugLogger.debug('GrepLogic: System grep is being considered as fallback strategy.');
+        const grepAvailable = await this.isCommandAvailable('grep');
+        if (!grepAvailable)
+            return null;
+        const grepArgs = this.buildSystemGrepArgs(pattern, include);
+        return this.trySystemGrep(grepArgs, absolutePath, signal, maxResults, maxFiles, maxPerFile);
+    }
+    /**
+     * Performs the actual search using the prioritized strategies.
+     * @param options Search options including pattern, absolute path, and include glob.
+     * @returns A promise resolving to search results with limit information.
+     */
+    async performGrepSearch(options) {
+        const { pattern, path: absolutePath, include, maxResults = 1000, maxFiles = 100, maxPerFile = 50, } = options;
+        let strategyUsed = 'none';
+        try {
+            // --- Strategy 1: git grep ---
+            const hasBracePattern = typeof include === 'string' &&
+                include.length > 0 &&
+                hasBraceExpansion(include);
+            const gitResult = await this.tryGitGrep(pattern, absolutePath, include, options.signal, maxResults, maxFiles, maxPerFile, hasBracePattern);
+            if (gitResult !== null) {
+                return gitResult;
+            }
+            // --- Strategy 2: System grep ---
+            strategyUsed = 'system grep';
+            const sysResult = await this.trySystemGrepStrategy(pattern, absolutePath, include, options.signal, maxResults, maxFiles, maxPerFile);
+            if (sysResult !== null) {
+                return sysResult;
+            }
+            // --- Strategy 3: Pure JavaScript Fallback ---
+            debugLogger.debug('GrepLogic: Falling back to JavaScript grep implementation.');
+            strategyUsed = 'javascript fallback';
+            return await this.javascriptGrepFallback(pattern, absolutePath, include, options.signal, maxResults, maxFiles, maxPerFile);
+        }
+        catch (error) {
+            debugLogger.error(`GrepLogic: Error in performGrepSearch (Strategy: ${strategyUsed}): ${getErrorMessage(error)}`);
+            throw error; // Re-throw
+        }
+    }
+}
+// --- GrepLogic Class ---
+/**
+ * Implementation of the Grep tool logic (moved from CLI)
+ */
+export class GrepTool extends BaseDeclarativeTool {
+    host;
+    static Name = 'search_file_content'; // Keep static name
+    constructor(host) {
+        super(GrepTool.Name, 'SearchText', 'Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers.', Kind.Search, {
+            properties: {
+                pattern: {
+                    description: "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').",
+                    type: 'string',
+                },
+                dir_path: {
+                    description: 'Optional: The absolute path to the directory to search within. If omitted, searches the current working directory. Can also be a path to a specific file (will search only that file).',
+                    type: 'string',
+                },
+                path: {
+                    description: 'Alternative parameter name for dir_path (for backward compatibility).',
+                    type: 'string',
+                },
+                include: {
+                    description: "Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores).",
+                    type: 'string',
+                },
+                max_results: {
+                    description: 'Optional: Maximum number of total matches to return. Defaults to tool-output-max-items setting or 1000.',
+                    type: 'number',
+                },
+                max_files: {
+                    description: 'Optional: Maximum number of files to include in results. Defaults to 100.',
+                    type: 'number',
+                },
+                max_per_file: {
+                    description: 'Optional: Maximum number of matches per file to return. Defaults to 50.',
+                    type: 'number',
+                },
+                timeout_ms: {
+                    description: 'Optional: Timeout in milliseconds (default: 60000ms = 1 minute, max: 300000ms = 5 minutes). If the operation times out, an error is returned with suggestions.',
+                    type: 'number',
+                },
+            },
+            required: ['pattern'],
+            type: 'object',
+        });
+        this.host = host;
+    }
+    validateToolParamValues(params) {
+        try {
+            new RegExp(params.pattern);
+        }
+        catch (error) {
+            return `Invalid regular expression pattern provided: ${params.pattern}. Error: ${getErrorMessage(error)}`;
+        }
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- intentional falsy coalescing: dir_path and path are optional strings, empty string should fall through
+        const dirPath = params.dir_path || params.path;
+        if (dirPath) {
+            try {
+                resolveTextSearchTarget(this.host.getTargetDir(), this.host.getWorkspaceRoots(), dirPath);
+            }
+            catch (error) {
+                return getErrorMessage(error);
+            }
+        }
+        return null;
+    }
+    createInvocation(params, messageBus) {
+        const normalizedParams = { ...params };
+        if (!normalizedParams.dir_path && normalizedParams.path) {
+            normalizedParams.dir_path = normalizedParams.path;
+        }
+        return new GrepToolInvocation(this.host, normalizedParams, messageBus);
+    }
+}
+//# sourceMappingURL=grep.js.map