@office-ai/aioncli-core 0.26.0 → 0.30.0

package/dist/src/tools/grep.js

@@ -6,9 +6,10 @@
 import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'node:path';
-import { EOL } from 'node:os';
 import { spawn } from 'node:child_process';
 import { globStream } from 'glob';
+import { execStreaming } from '../utils/shell-utils.js';
+import { DEFAULT_TOTAL_MAX_MATCHES, DEFAULT_SEARCH_TIMEOUT_MS, } from './constants.js';
 import { BaseDeclarativeTool, BaseToolInvocation, Kind } from './tools.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { getErrorMessage, isNodeError } from '../utils/errors.js';
@@ -16,6 +17,8 @@ import { isGitRepository } from '../utils/gitUtils.js';
 import { ToolErrorType } from './tool-error.js';
 import { GREP_TOOL_NAME } from './tool-names.js';
 import { debugLogger } from '../utils/debugLogger.js';
+import { GREP_DEFINITION } from './definitions/coreTools.js';
+import { resolveToolDeclaration } from './definitions/resolver.js';
 class GrepToolInvocation extends BaseToolInvocation {
     config;
     fileExclusions;
@@ -25,43 +28,94 @@ class GrepToolInvocation extends BaseToolInvocation {
         this.fileExclusions = config.getFileExclusions();
     }
     /**
-     * Checks if a path is within the root directory and resolves it.
-     * @param relativePath Path relative to the root directory (or undefined for root).
-     * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
-     * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
+     * Parses a single line of grep-like output (git grep, system grep).
+     * Expects format: filePath:lineNumber:lineContent
+     * @param {string} line The line to parse.
+     * @param {string} basePath The absolute directory for path resolution.
+     * @returns {GrepMatch | null} Parsed match or null if malformed.
      */
-    resolveAndValidatePath(relativePath) {
-        // If no path specified, return null to indicate searching all workspace directories
-        if (!relativePath) {
+    parseGrepLine(line, basePath) {
+        if (!line.trim())
             return null;
-        }
-        const targetPath = path.resolve(this.config.getTargetDir(), relativePath);
-        // Security Check: Ensure the resolved path is within workspace boundaries
-        const workspaceContext = this.config.getWorkspaceContext();
-        if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-            const directories = workspaceContext.getDirectories();
-            throw new Error(`Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(', ')}`);
-        }
-        // Check existence and type after resolving
-        try {
-            const stats = fs.statSync(targetPath);
-            if (!stats.isDirectory()) {
-                throw new Error(`Path is not a directory: ${targetPath}`);
-            }
-        }
-        catch (error) {
-            if (isNodeError(error) && error.code !== 'ENOENT') {
-                throw new Error(`Path does not exist: ${targetPath}`);
+        // Use regex to locate the first occurrence of :<digits>:
+        // This allows filenames to contain colons, as long as they don't look like :<digits>:
+        // Note: This regex assumes filenames do not contain colons, or at least not followed by digits.
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (!match)
+            return null;
+        const [, filePathRaw, lineNumberStr, lineContent] = match;
+        const lineNumber = parseInt(lineNumberStr, 10);
+        if (!isNaN(lineNumber)) {
+            const absoluteFilePath = path.resolve(basePath, filePathRaw);
+            const relativeCheck = path.relative(basePath, absoluteFilePath);
+            if (relativeCheck === '..' ||
+                relativeCheck.startsWith(`..${path.sep}`) ||
+                path.isAbsolute(relativeCheck)) {
+                return null;
             }
-            throw new Error(`Failed to access path stats for ${targetPath}: ${error}`);
+            const relativeFilePath = path.relative(basePath, absoluteFilePath);
+            return {
+                filePath: relativeFilePath || path.basename(absoluteFilePath),
+                lineNumber,
+                line: lineContent,
+            };
         }
-        return targetPath;
+        return null;
     }
     async execute(signal) {
         try {
             const workspaceContext = this.config.getWorkspaceContext();
-            const searchDirAbs = this.resolveAndValidatePath(this.params.dir_path);
-            const searchDirDisplay = this.params.dir_path || '.';
+            const pathParam = this.params.dir_path;
+            let searchDirAbs = null;
+            if (pathParam) {
+                searchDirAbs = path.resolve(this.config.getTargetDir(), pathParam);
+                const validationError = this.config.validatePathAccess(searchDirAbs, 'read');
+                if (validationError) {
+                    return {
+                        llmContent: validationError,
+                        returnDisplay: 'Error: Path not in workspace.',
+                        error: {
+                            message: validationError,
+                            type: ToolErrorType.PATH_NOT_IN_WORKSPACE,
+                        },
+                    };
+                }
+                try {
+                    const stats = await fsPromises.stat(searchDirAbs);
+                    if (!stats.isDirectory()) {
+                        return {
+                            llmContent: `Path is not a directory: ${searchDirAbs}`,
+                            returnDisplay: 'Error: Path is not a directory.',
+                            error: {
+                                message: `Path is not a directory: ${searchDirAbs}`,
+                                type: ToolErrorType.PATH_IS_NOT_A_DIRECTORY,
+                            },
+                        };
+                    }
+                }
+                catch (error) {
+                    if (isNodeError(error) && error.code === 'ENOENT') {
+                        return {
+                            llmContent: `Path does not exist: ${searchDirAbs}`,
+                            returnDisplay: 'Error: Path does not exist.',
+                            error: {
+                                message: `Path does not exist: ${searchDirAbs}`,
+                                type: ToolErrorType.FILE_NOT_FOUND,
+                            },
+                        };
+                    }
+                    const errorMessage = getErrorMessage(error);
+                    return {
+                        llmContent: `Failed to access path stats for ${searchDirAbs}: ${errorMessage}`,
+                        returnDisplay: 'Error: Failed to access path.',
+                        error: {
+                            message: `Failed to access path stats for ${searchDirAbs}: ${errorMessage}`,
+                            type: ToolErrorType.GREP_EXECUTION_ERROR,
+                        },
+                    };
+                }
+            }
+            const searchDirDisplay = pathParam || '.';
             // Determine which directories to search
             let searchDirectories;
             if (searchDirAbs === null) {
@@ -74,21 +128,47 @@ class GrepToolInvocation extends BaseToolInvocation {
             }
             // Collect matches from all search directories
             let allMatches = [];
-            for (const searchDir of searchDirectories) {
-                const matches = await this.performGrepSearch({
-                    pattern: this.params.pattern,
-                    path: searchDir,
-                    include: this.params.include,
-                    signal,
-                });
-                // Add directory prefix if searching multiple directories
-                if (searchDirectories.length > 1) {
-                    const dirName = path.basename(searchDir);
-                    matches.forEach((match) => {
-                        match.filePath = path.join(dirName, match.filePath);
+            const totalMaxMatches = this.params.total_max_matches ?? DEFAULT_TOTAL_MAX_MATCHES;
+            // Create a timeout controller to prevent indefinitely hanging searches
+            const timeoutController = new AbortController();
+            const timeoutId = setTimeout(() => {
+                timeoutController.abort();
+            }, DEFAULT_SEARCH_TIMEOUT_MS);
+            // Link the passed signal to our timeout controller
+            const onAbort = () => timeoutController.abort();
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+            try {
+                for (const searchDir of searchDirectories) {
+                    const remainingLimit = totalMaxMatches - allMatches.length;
+                    if (remainingLimit <= 0)
+                        break;
+                    const matches = await this.performGrepSearch({
+                        pattern: this.params.pattern,
+                        path: searchDir,
+                        include: this.params.include,
+                        exclude_pattern: this.params.exclude_pattern,
+                        maxMatches: remainingLimit,
+                        max_matches_per_file: this.params.max_matches_per_file,
+                        signal: timeoutController.signal,
                     });
+                    // Add directory prefix if searching multiple directories
+                    if (searchDirectories.length > 1) {
+                        const dirName = path.basename(searchDir);
+                        matches.forEach((match) => {
+                            match.filePath = path.join(dirName, match.filePath);
+                        });
+                    }
+                    allMatches = allMatches.concat(matches);
                 }
-                allMatches = allMatches.concat(matches);
+            }
+            finally {
+                clearTimeout(timeoutId);
+                signal.removeEventListener('abort', onAbort);
             }
             let searchLocationDescription;
             if (searchDirAbs === null) {
@@ -105,6 +185,7 @@ class GrepToolInvocation extends BaseToolInvocation {
                 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 wasTruncated = allMatches.length >= totalMaxMatches;
             // Group matches by file
             const matchesByFile = allMatches.reduce((acc, match) => {
                 const fileKey = match.filePath;
@@ -117,11 +198,23 @@ class GrepToolInvocation extends BaseToolInvocation {
             }, {});
             const matchCount = allMatches.length;
             const matchTerm = matchCount === 1 ? 'match' : 'matches';
-            let llmContent = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}:
----
-`;
+            if (this.params.names_only) {
+                const filePaths = Object.keys(matchesByFile).sort();
+                let llmContent = `Found ${filePaths.length} files with matches for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}${wasTruncated ? ` (results limited to ${totalMaxMatches} matches for performance)` : ''}:\n`;
+                llmContent += filePaths.join('\n');
+                return {
+                    llmContent: llmContent.trim(),
+                    returnDisplay: `Found ${filePaths.length} files${wasTruncated ? ' (limited)' : ''}`,
+                };
+            }
+            let llmContent = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ''}`;
+            if (wasTruncated) {
+                llmContent += ` (results limited to ${totalMaxMatches} matches for performance)`;
+            }
+            llmContent += `:\n---\n`;
             for (const filePath in matchesByFile) {
-                llmContent += `File: ${filePath}\n`;
+                llmContent += `File: ${filePath}
+`;
                 matchesByFile[filePath].forEach((match) => {
                     const trimmedLine = match.line.trim();
                     llmContent += `L${match.lineNumber}: ${trimmedLine}\n`;
@@ -130,7 +223,7 @@ class GrepToolInvocation extends BaseToolInvocation {
             }
             return {
                 llmContent: llmContent.trim(),
-                returnDisplay: `Found ${matchCount} ${matchTerm}`,
+                returnDisplay: `Found ${matchCount} ${matchTerm}${wasTruncated ? ' (limited)' : ''}`,
             };
         }
         catch (error) {
@@ -171,86 +264,19 @@ class GrepToolInvocation extends BaseToolInvocation {
             }
         });
     }
-    /**
-     * 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
-        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}`;
-        }
-        if (this.params.dir_path) {
-            const resolvedPath = path.resolve(this.config.getTargetDir(), this.params.dir_path);
-            if (resolvedPath === this.config.getTargetDir() ||
-                this.params.dir_path === '.') {
-                description += ` within ./`;
-            }
-            else {
-                const relativePath = makeRelative(resolvedPath, this.config.getTargetDir());
-                description += ` within ${shortenPath(relativePath)}`;
-            }
-        }
-        else {
-            // When no path is specified, indicate searching all workspace directories
-            const workspaceContext = this.config.getWorkspaceContext();
-            const directories = workspaceContext.getDirectories();
-            if (directories.length > 1) {
-                description += ` across all workspace directories`;
-            }
-        }
-        return description;
-    }
     /**
      * Performs the actual search using the prioritized strategies.
      * @param options Search options including pattern, absolute path, and include glob.
      * @returns A promise resolving to an array of match objects.
      */
     async performGrepSearch(options) {
-        const { pattern, path: absolutePath, include } = options;
+        const { pattern, path: absolutePath, include, exclude_pattern, maxMatches, max_matches_per_file, } = options;
         let strategyUsed = 'none';
         try {
+            let excludeRegex = null;
+            if (exclude_pattern) {
+                excludeRegex = new RegExp(exclude_pattern, 'i');
+            }
             // --- Strategy 1: git grep ---
             const isGit = isGitRepository(absolutePath);
             const gitAvailable = isGit && (await this.isCommandAvailable('git'));
@@ -264,32 +290,32 @@ class GrepToolInvocation extends BaseToolInvocation {
                     '--ignore-case',
                     pattern,
                 ];
+                if (max_matches_per_file) {
+                    gitArgs.push('--max-count', max_matches_per_file.toString());
+                }
                 if (include) {
                     gitArgs.push('--', include);
                 }
                 try {
-                    const output = await new Promise((resolve, reject) => {
-                        const child = spawn('git', gitArgs, {
-                            cwd: absolutePath,
-                            windowsHide: true,
-                        });
-                        const stdoutChunks = [];
-                        const stderrChunks = [];
-                        child.stdout.on('data', (chunk) => stdoutChunks.push(chunk));
-                        child.stderr.on('data', (chunk) => stderrChunks.push(chunk));
-                        child.on('error', (err) => reject(new Error(`Failed to start git grep: ${err.message}`)));
-                        child.on('close', (code) => {
-                            const stdoutData = Buffer.concat(stdoutChunks).toString('utf8');
-                            const stderrData = Buffer.concat(stderrChunks).toString('utf8');
-                            if (code === 0)
-                                resolve(stdoutData);
-                            else if (code === 1)
-                                resolve(''); // No matches
-                            else
-                                reject(new Error(`git grep exited with code ${code}: ${stderrData}`));
-                        });
+                    const generator = execStreaming('git', gitArgs, {
+                        cwd: absolutePath,
+                        signal: options.signal,
+                        allowedExitCodes: [0, 1],
                     });
-                    return this.parseGrepOutput(output, absolutePath);
+                    const results = [];
+                    for await (const line of generator) {
+                        const match = this.parseGrepLine(line, absolutePath);
+                        if (match) {
+                            if (excludeRegex && excludeRegex.test(match.line)) {
+                                continue;
+                            }
+                            results.push(match);
+                            if (results.length >= maxMatches) {
+                                break;
+                            }
+                        }
+                    }
+                    return results;
                 }
                 catch (gitError) {
                     debugLogger.debug(`GrepLogic: git grep failed: ${getErrorMessage(gitError)}. Falling back...`);
@@ -323,66 +349,40 @@ class GrepToolInvocation extends BaseToolInvocation {
                 })
                     .filter((dir) => !!dir);
                 commonExcludes.forEach((dir) => grepArgs.push(`--exclude-dir=${dir}`));
+                if (max_matches_per_file) {
+                    grepArgs.push('--max-count', max_matches_per_file.toString());
+                }
                 if (include) {
                     grepArgs.push(`--include=${include}`);
                 }
                 grepArgs.push(pattern);
                 grepArgs.push('.');
+                const results = [];
                 try {
-                    const output = await new Promise((resolve, reject) => {
-                        const child = spawn('grep', grepArgs, {
-                            cwd: absolutePath,
-                            windowsHide: true,
-                        });
-                        const stdoutChunks = [];
-                        const stderrChunks = [];
-                        const onData = (chunk) => stdoutChunks.push(chunk);
-                        const onStderr = (chunk) => {
-                            const stderrStr = chunk.toString();
-                            // Suppress common harmless stderr messages
-                            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 generator = execStreaming('grep', grepArgs, {
+                        cwd: absolutePath,
+                        signal: options.signal,
+                        allowedExitCodes: [0, 1],
+                    });
+                    for await (const line of generator) {
+                        const match = this.parseGrepLine(line, absolutePath);
+                        if (match) {
+                            if (excludeRegex && excludeRegex.test(match.line)) {
+                                continue;
                             }
-                        };
-                        const cleanup = () => {
-                            child.stdout.removeListener('data', onData);
-                            child.stderr.removeListener('data', onStderr);
-                            child.removeListener('error', onError);
-                            child.removeListener('close', onClose);
-                            if (child.connected) {
-                                child.disconnect();
+                            results.push(match);
+                            if (results.length >= maxMatches) {
+                                break;
                             }
-                        };
-                        child.stdout.on('data', onData);
-                        child.stderr.on('data', onStderr);
-                        child.on('error', onError);
-                        child.on('close', onClose);
-                    });
-                    return this.parseGrepOutput(output, absolutePath);
+                        }
+                    }
+                    return results;
                 }
                 catch (grepError) {
+                    if (grepError instanceof Error &&
+                        /Permission denied|Is a directory/i.test(grepError.message)) {
+                        return results;
+                    }
                     debugLogger.debug(`GrepLogic: System grep failed: ${getErrorMessage(grepError)}. Falling back...`);
                 }
             }
@@ -402,20 +402,40 @@ class GrepToolInvocation extends BaseToolInvocation {
             const regex = new RegExp(pattern, 'i');
             const allMatches = [];
             for await (const filePath of filesStream) {
+                if (allMatches.length >= maxMatches)
+                    break;
                 const fileAbsolutePath = filePath;
+                // security check
+                const relativePath = path.relative(absolutePath, fileAbsolutePath);
+                if (relativePath === '..' ||
+                    relativePath.startsWith(`..${path.sep}`) ||
+                    path.isAbsolute(relativePath))
+                    continue;
                 try {
                     const content = await fsPromises.readFile(fileAbsolutePath, 'utf8');
                     const lines = content.split(/\r?\n/);
-                    lines.forEach((line, index) => {
+                    let matchesInFile = 0;
+                    for (let index = 0; index < lines.length; index++) {
+                        const line = lines[index];
                         if (regex.test(line)) {
+                            if (excludeRegex && excludeRegex.test(line)) {
+                                continue;
+                            }
                             allMatches.push({
                                 filePath: path.relative(absolutePath, fileAbsolutePath) ||
                                     path.basename(fileAbsolutePath),
                                 lineNumber: index + 1,
                                 line,
                             });
+                            matchesInFile++;
+                            if (allMatches.length >= maxMatches)
+                                break;
+                            if (max_matches_per_file &&
+                                matchesInFile >= max_matches_per_file) {
+                                break;
+                            }
                         }
-                    });
+                    }
                 }
                 catch (readError) {
                     // Ignore errors like permission denied or file gone during read
@@ -431,8 +451,33 @@ class GrepToolInvocation extends BaseToolInvocation {
             throw error; // Re-throw
         }
     }
+    getDescription() {
+        let description = `'${this.params.pattern}'`;
+        if (this.params.include) {
+            description += ` in ${this.params.include}`;
+        }
+        if (this.params.dir_path) {
+            const resolvedPath = path.resolve(this.config.getTargetDir(), this.params.dir_path);
+            if (resolvedPath === this.config.getTargetDir() ||
+                this.params.dir_path === '.') {
+                description += ` within ./`;
+            }
+            else {
+                const relativePath = makeRelative(resolvedPath, this.config.getTargetDir());
+                description += ` within ${shortenPath(relativePath)}`;
+            }
+        }
+        else {
+            // When no path is specified, indicate searching all workspace directories
+            const workspaceContext = this.config.getWorkspaceContext();
+            const directories = workspaceContext.getDirectories();
+            if (directories.length > 1) {
+                description += ` across all workspace directories`;
+            }
+        }
+        return description;
+    }
 }
-// --- GrepLogic Class ---
 /**
  * Implementation of the Grep tool logic (moved from CLI)
  */
@@ -440,59 +485,9 @@ export class GrepTool extends BaseDeclarativeTool {
     config;
     static Name = GREP_TOOL_NAME;
     constructor(config, messageBus) {
-        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.',
-                    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',
-                },
-            },
-            required: ['pattern'],
-            type: 'object',
-        }, messageBus, true, false);
+        super(GrepTool.Name, 'SearchText', GREP_DEFINITION.base.description, Kind.Search, GREP_DEFINITION.base.parametersJsonSchema, messageBus, true, false);
         this.config = config;
     }
-    /**
-     * Checks if a path is within the root directory and resolves it.
-     * @param relativePath Path relative to the root directory (or undefined for root).
-     * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
-     * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-     */
-    resolveAndValidatePath(relativePath) {
-        // If no path specified, return null to indicate searching all workspace directories
-        if (!relativePath) {
-            return null;
-        }
-        const targetPath = path.resolve(this.config.getTargetDir(), relativePath);
-        // Security Check: Ensure the resolved path is within workspace boundaries
-        const workspaceContext = this.config.getWorkspaceContext();
-        if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
-            const directories = workspaceContext.getDirectories();
-            throw new Error(`Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(', ')}`);
-        }
-        // Check existence and type after resolving
-        try {
-            const stats = fs.statSync(targetPath);
-            if (!stats.isDirectory()) {
-                throw new Error(`Path is not a directory: ${targetPath}`);
-            }
-        }
-        catch (error) {
-            if (isNodeError(error) && error.code !== 'ENOENT') {
-                throw new Error(`Path does not exist: ${targetPath}`);
-            }
-            throw new Error(`Failed to access path stats for ${targetPath}: ${error}`);
-        }
-        return targetPath;
-    }
     /**
      * Validates the parameters for the tool
      * @param params Parameters to validate
@@ -505,13 +500,41 @@ export class GrepTool extends BaseDeclarativeTool {
         catch (error) {
             return `Invalid regular expression pattern provided: ${params.pattern}. Error: ${getErrorMessage(error)}`;
         }
+        if (params.exclude_pattern) {
+            try {
+                new RegExp(params.exclude_pattern);
+            }
+            catch (error) {
+                return `Invalid exclude regular expression pattern provided: ${params.exclude_pattern}. Error: ${getErrorMessage(error)}`;
+            }
+        }
+        if (params.max_matches_per_file !== undefined &&
+            params.max_matches_per_file < 1) {
+            return 'max_matches_per_file must be at least 1.';
+        }
+        if (params.total_max_matches !== undefined &&
+            params.total_max_matches < 1) {
+            return 'total_max_matches must be at least 1.';
+        }
         // Only validate dir_path if one is provided
         if (params.dir_path) {
+            const resolvedPath = path.resolve(this.config.getTargetDir(), params.dir_path);
+            const validationError = this.config.validatePathAccess(resolvedPath, 'read');
+            if (validationError) {
+                return validationError;
+            }
+            // We still want to check if it's a directory
             try {
-                this.resolveAndValidatePath(params.dir_path);
+                const stats = fs.statSync(resolvedPath);
+                if (!stats.isDirectory()) {
+                    return `Path is not a directory: ${resolvedPath}`;
+                }
             }
             catch (error) {
-                return getErrorMessage(error);
+                if (isNodeError(error) && error.code === 'ENOENT') {
+                    return `Path does not exist: ${resolvedPath}`;
+                }
+                return `Failed to access path stats for ${resolvedPath}: ${getErrorMessage(error)}`;
             }
         }
         return null; // Parameters are valid
@@ -519,5 +542,8 @@ export class GrepTool extends BaseDeclarativeTool {
     createInvocation(params, messageBus, _toolName, _toolDisplayName) {
         return new GrepToolInvocation(this.config, params, messageBus, _toolName, _toolDisplayName);
     }
+    getSchema(modelId) {
+        return resolveToolDeclaration(GREP_DEFINITION, modelId);
+    }
 }
 //# sourceMappingURL=grep.js.map