@oflow-ai/core 0.1.0 → 0.1.1

package/dist/tools/replace.js

@@ -39,50 +39,55 @@ const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 class ReplaceTool extends base_1.BaseTool {
     name = 'replace';
-    description = 'Replaces text within a file. Requires exact matching of the old_string.';
+    description = 'Replaces text within a file. Replaces a single occurrence. This tool requires providing significant context around the change to ensure precise targeting. Always use the read_file tool to examine the file current content before attempting a text replacement.';
     parameters = {
         type: 'object',
         properties: {
             file_path: {
                 type: 'string',
-                description: 'The absolute path to the file to modify'
+                description: 'The absolute path to the file to modify. Must start with /'
             },
             old_string: {
                 type: 'string',
-                description: 'The exact literal text to replace'
+                description: 'The exact literal text to replace. Include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely.'
             },
             new_string: {
                 type: 'string',
-                description: 'The exact literal text to replace with'
+                description: 'The exact literal text to replace old_string with. Also including all whitespace, indentation, newlines, and surrounding code etc.'
             },
             instruction: {
                 type: 'string',
-                description: 'Detailed instruction of what needs to be changed'
+                description: 'A clear, semantic instruction for the code change, acting as a high-quality prompt for an expert LLM assistant.'
             }
         },
-        required: ['file_path', 'old_string', 'new_string']
+        required: ['file_path', 'old_string', 'new_string'],
+        additionalProperties: false
     };
     async execute(params, options) {
         this.validateRequired(params, ['file_path', 'old_string', 'new_string']);
+        const filePath = params.file_path;
         const workingDir = options?.workingDirectory || process.cwd();
-        const filePath = path.isAbsolute(params.file_path)
-            ? params.file_path
-            : path.join(workingDir, params.file_path);
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(workingDir, filePath);
+        if (!path.isAbsolute(filePath)) {
+            return `Error: file_path must be an absolute path. Received: ${filePath}`;
+        }
+        if (params.old_string === params.new_string) {
+            return `Error: old_string and new_string are identical. No changes made.`;
+        }
         try {
-            const content = await fs.readFile(filePath, 'utf-8');
-            // Check if old_string exists
-            if (!content.includes(params.old_string)) {
-                return `Error: The old_string was not found in ${filePath}. Please read the file first to ensure exact matching.`;
-            }
-            // Check for multiple occurrences
+            const content = await fs.readFile(resolvedPath, 'utf-8');
+            // Count occurrences
             const occurrences = content.split(params.old_string).length - 1;
+            if (occurrences === 0) {
+                return `Error: old_string not found in file ${resolvedPath}. Please read the file first to see its current content.`;
+            }
             if (occurrences > 1) {
-                return `Error: Found ${occurrences} occurrences of old_string. The old_string must uniquely identify a single instance. Please include more context to make it unique.`;
+                return `Error: Found ${occurrences} occurrences of old_string. The string must uniquely identify a single location. Please include more context lines to make it unique.`;
             }
             // Perform replacement
             const newContent = content.replace(params.old_string, params.new_string);
-            await fs.writeFile(filePath, newContent, 'utf-8');
-            return `Successfully replaced text in ${filePath}`;
+            await fs.writeFile(resolvedPath, newContent, 'utf-8');
+            return `Successfully replaced text in ${resolvedPath}`;
         }
         catch (error) {
             return (0, base_1.formatToolError)(error);
@@ -90,4 +95,4 @@ class ReplaceTool extends base_1.BaseTool {
     }
 }
 exports.ReplaceTool = ReplaceTool;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/run-shell-command.d.ts

@@ -3,7 +3,6 @@ interface RunShellCommandParams {
     command: string;
     description?: string;
     timeout?: number;
-    run_in_bg?: boolean;
 }
 export declare class RunShellCommandTool extends BaseTool<RunShellCommandParams> {
     name: string;
@@ -23,13 +22,11 @@ export declare class RunShellCommandTool extends BaseTool<RunShellCommandParams>
                 type: string;
                 description: string;
             };
-            run_in_bg: {
-                type: string;
-                description: string;
-            };
         };
         required: string[];
+        additionalProperties: boolean;
     };
     execute(params: RunShellCommandParams, options?: ToolExecuteOptions): Promise<string>;
+    private runCommand;
 }
 export {};

package/dist/tools/run-shell-command.js

@@ -5,77 +5,101 @@ const base_1 = require("./base");
 const child_process_1 = require("child_process");
 class RunShellCommandTool extends base_1.BaseTool {
     name = 'run_shell_command';
-    description = 'Executes a shell command in the terminal. Supports both foreground and background execution.';
+    description = `This tool executes a given shell command as \`powershell.exe -NoProfile -Command <command>\` on Windows, or \`bash -c <command>\` on Unix. Command can start background processes using PowerShell constructs such as \`Start-Process -NoNewWindow\` or \`Start-Job\`.
+      
+Usage notes:
+- The command argument is required.
+- It is very helpful if you write a clear, concise description of what this command does in 5-10 words.
+- You can use the \`run_in_bg\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the BashOutput tool as it becomes available.
+- The following information is returned:
+  Command: Executed command.
+  Directory: Directory where command was executed, or \`(root)\`.
+  Stdout: Output on stdout stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+  Stderr: Output on stderr stream. Can be \`(empty)\` or partial on error and for any unwaited background processes.
+  Error: Error or \`(none)\` if no error was reported for the subprocess.
+  Exit Code: Exit code or \`(none)\` if terminated by signal.
+  Signal: Signal number or \`(none)\` if no signal was received.
+  Background PIDs: List of background processes started or \`(none)\`.
+  Process Group PGID: Process group started or \`(none)\`.`;
     parameters = {
         type: 'object',
         properties: {
             command: {
                 type: 'string',
-                description: 'The shell command to execute'
+                description: 'Exact command to execute as powershell.exe -NoProfile -Command <command> on Windows or bash -c <command> on Unix'
             },
             description: {
                 type: 'string',
-                description: 'Brief description of what the command does'
+                description: 'Brief description of the command for the user. Be specific and concise. Ideally a single sentence. Can be up to 3 sentences for clarity. No line breaks.'
             },
             timeout: {
                 type: 'number',
-                description: 'Timeout in seconds (default: 120)'
-            },
-            run_in_bg: {
-                type: 'boolean',
-                description: 'If true, run command in background'
+                description: 'Optional: Timeout in seconds for the command execution. If not provided, uses the default timeout of 120s.'
             }
         },
-        required: ['command']
+        required: ['command'],
+        additionalProperties: false
     };
     async execute(params, options) {
         this.validateRequired(params, ['command']);
-        const timeout = (params.timeout || 120) * 1000;
         const workingDir = options?.workingDirectory || process.cwd();
+        const timeout = params.timeout || options?.timeout || 120000; // Default 120 seconds
+        try {
+            const result = await this.runCommand(params.command, workingDir, timeout);
+            return result;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    async runCommand(command, cwd, timeout) {
         return new Promise((resolve) => {
             const isWindows = process.platform === 'win32';
-            const shell = isWindows ? 'powershell.exe' : '/bin/bash';
-            const shellArgs = isWindows
-                ? ['-NoProfile', '-Command', params.command]
-                : ['-c', params.command];
-            const proc = (0, child_process_1.spawn)(shell, shellArgs, {
-                cwd: workingDir,
-                env: process.env,
-                timeout: timeout
+            const shell = isWindows ? 'powershell.exe' : 'bash';
+            const args = isWindows ? ['-NoProfile', '-Command', command] : ['-c', command];
+            const proc = (0, child_process_1.spawn)(shell, args, {
+                cwd,
+                shell: false,
+                windowsHide: true
             });
             let stdout = '';
             let stderr = '';
-            let timeoutId = null;
+            let timedOut = false;
+            const timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill();
+            }, timeout);
             proc.stdout.on('data', (data) => {
                 stdout += data.toString();
             });
             proc.stderr.on('data', (data) => {
                 stderr += data.toString();
             });
-            proc.on('error', (error) => {
-                resolve((0, base_1.formatToolError)(error));
-            });
-            proc.on('close', (code, signal) => {
-                if (timeoutId)
-                    clearTimeout(timeoutId);
-                let output = `Command: ${params.command}\n`;
-                output += `Directory: ${workingDir}\n`;
-                output += `Exit Code: ${code}\n\n`;
+            proc.on('close', (code) => {
+                clearTimeout(timeoutId);
+                let result = `Command: ${command}\n`;
+                result += `Directory: ${cwd}\n`;
+                result += `Exit Code: ${code ?? '(none)'}\n`;
                 if (stdout) {
-                    output += `Stdout:\n${stdout}\n`;
+                    result += `\nStdout:\n${stdout}`;
+                }
+                else {
+                    result += `\nStdout: (empty)`;
                 }
                 if (stderr) {
-                    output += `Stderr:\n${stderr}\n`;
+                    result += `\n\nStderr:\n${stderr}`;
+                }
+                if (timedOut) {
+                    result += `\n\n⚠️ Command timed out after ${timeout / 1000} seconds`;
                 }
-                resolve(output);
+                resolve(result);
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timeoutId);
+                resolve(`Error executing command: ${err.message}`);
             });
-            // Handle timeout
-            timeoutId = setTimeout(() => {
-                proc.kill();
-                resolve(`Command timed out after ${timeout / 1000} seconds`);
-            }, timeout);
         });
     }
 }
 exports.RunShellCommandTool = RunShellCommandTool;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run-shell-command.js","sourceRoot":"","sources":["../../src/tools/run-shell-command.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport { spawn } from 'child_process';\n\ninterface RunShellCommandParams {\n  command: string;\n  description?: string;\n  timeout?: number;\n}\n\nexport class RunShellCommandTool extends BaseTool<RunShellCommandParams> {\n  name = 'run_shell_command';\n  description = `This tool executes a given shell command as \\`powershell.exe -NoProfile -Command <command>\\` on Windows, or \\`bash -c <command>\\` on Unix. Command can start background processes using PowerShell constructs such as \\`Start-Process -NoNewWindow\\` or \\`Start-Job\\`.\n      \nUsage notes:\n- The command argument is required.\n- It is very helpful if you write a clear, concise description of what this command does in 5-10 words.\n- You can use the \\`run_in_bg\\` parameter to run the command in the background, which allows you to continue working while the command runs. You can monitor the output using the BashOutput tool as it becomes available.\n- The following information is returned:\n  Command: Executed command.\n  Directory: Directory where command was executed, or \\`(root)\\`.\n  Stdout: Output on stdout stream. Can be \\`(empty)\\` or partial on error and for any unwaited background processes.\n  Stderr: Output on stderr stream. Can be \\`(empty)\\` or partial on error and for any unwaited background processes.\n  Error: Error or \\`(none)\\` if no error was reported for the subprocess.\n  Exit Code: Exit code or \\`(none)\\` if terminated by signal.\n  Signal: Signal number or \\`(none)\\` if no signal was received.\n  Background PIDs: List of background processes started or \\`(none)\\`.\n  Process Group PGID: Process group started or \\`(none)\\`.`;\n  parameters = {\n    type: 'object',\n    properties: {\n      command: {\n        type: 'string',\n        description: 'Exact command to execute as powershell.exe -NoProfile -Command <command> on Windows or bash -c <command> on Unix'\n      },\n      description: {\n        type: 'string',\n        description: 'Brief description of the command for the user. Be specific and concise. Ideally a single sentence. Can be up to 3 sentences for clarity. No line breaks.'\n      },\n      timeout: {\n        type: 'number',\n        description: 'Optional: Timeout in seconds for the command execution. If not provided, uses the default timeout of 120s.'\n      }\n    },\n    required: ['command'],\n    additionalProperties: false\n  };\n\n  async execute(params: RunShellCommandParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['command']);\n\n    const workingDir = options?.workingDirectory || process.cwd();\n    const timeout = params.timeout || options?.timeout || 120000; // Default 120 seconds\n\n    try {\n      const result = await this.runCommand(params.command, workingDir, timeout);\n      return result;\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private async runCommand(command: string, cwd: string, timeout: number): Promise<string> {\n    return new Promise((resolve) => {\n      const isWindows = process.platform === 'win32';\n      const shell = isWindows ? 'powershell.exe' : 'bash';\n      const args = isWindows ? ['-NoProfile', '-Command', command] : ['-c', command];\n\n      const proc = spawn(shell, args, {\n        cwd,\n        shell: false,\n        windowsHide: true\n      });\n\n      let stdout = '';\n      let stderr = '';\n      let timedOut = false;\n\n      const timeoutId = setTimeout(() => {\n        timedOut = true;\n        proc.kill();\n      }, timeout);\n\n      proc.stdout.on('data', (data) => {\n        stdout += data.toString();\n      });\n\n      proc.stderr.on('data', (data) => {\n        stderr += data.toString();\n      });\n\n      proc.on('close', (code) => {\n        clearTimeout(timeoutId);\n        \n        let result = `Command: ${command}\\n`;\n        result += `Directory: ${cwd}\\n`;\n        result += `Exit Code: ${code ?? '(none)'}\\n`;\n        \n        if (stdout) {\n          result += `\\nStdout:\\n${stdout}`;\n        } else {\n          result += `\\nStdout: (empty)`;\n        }\n        \n        if (stderr) {\n          result += `\\n\\nStderr:\\n${stderr}`;\n        }\n        \n        if (timedOut) {\n          result += `\\n\\n⚠️ Command timed out after ${timeout / 1000} seconds`;\n        }\n        \n        resolve(result);\n      });\n\n      proc.on('error', (err) => {\n        clearTimeout(timeoutId);\n        resolve(`Error executing command: ${err.message}`);\n      });\n    });\n  }\n}"]}

package/dist/tools/search-file-content.d.ts

@@ -34,9 +34,9 @@ export declare class SearchFileContentTool extends BaseTool<SearchFileContentPar
             };
         };
         required: string[];
+        additionalProperties: boolean;
     };
     execute(params: SearchFileContentParams, options?: ToolExecuteOptions): Promise<string>;
-    private searchInDir;
-    private shouldInclude;
+    private runSearch;
 }
 export {};

package/dist/tools/search-file-content.js

@@ -35,119 +35,141 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SearchFileContentTool = void 0;
 const base_1 = require("./base");
-const fs = __importStar(require("fs/promises"));
+const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 class SearchFileContentTool extends base_1.BaseTool {
     name = 'search_file_content';
-    description = 'Searches for a pattern within files in a directory using regex.';
+    description = 'Searches for a regular expression pattern within the content of files or directories. Returns the lines containing matches, along with their file paths and line numbers.';
     parameters = {
         type: 'object',
         properties: {
             pattern: {
                 type: 'string',
-                description: 'The regular expression pattern to search for'
+                description: 'The regular expression (regex) pattern to search for within file contents'
             },
             path: {
                 type: 'string',
-                description: 'Optional: The path to search within'
+                description: 'Optional: The absolute path to the file or directory to search within. If omitted, searches the current working directory.'
             },
             include: {
                 type: 'string',
-                description: 'Optional: A glob pattern to filter files'
+                description: 'Optional: A glob pattern to filter which files are searched (e.g., *.js, *.{ts,tsx}, src/**)'
             },
             case_sensitive: {
                 type: 'boolean',
-                description: 'If true, search is case-sensitive'
+                description: 'If true, search is case-sensitive. Defaults to false.'
             },
             context: {
                 type: 'number',
-                description: 'Number of lines of context around matches'
+                description: 'Show this many lines of context around each match. Defaults to 0.'
             }
         },
-        required: ['pattern']
+        required: ['pattern'],
+        additionalProperties: false
     };
     async execute(params, options) {
         this.validateRequired(params, ['pattern']);
         const workingDir = options?.workingDirectory || process.cwd();
         const searchPath = params.path || workingDir;
-        const caseSensitive = params.case_sensitive ?? false;
         try {
-            const regex = new RegExp(params.pattern, caseSensitive ? 'g' : 'gi');
-            const results = [];
-            const maxResults = 500;
-            await this.searchInDir(searchPath, regex, params.include, results, maxResults);
-            if (results.length === 0) {
-                return `No matches found for pattern: ${params.pattern}`;
-            }
-            const output = results.map(r => {
-                return `${r.file}:${r.line}: ${r.content}`;
-            }).join('\n');
-            return `Found ${results.length} matches:\n\n${output}`;
+            const results = await this.runSearch(params, searchPath);
+            return results;
         }
         catch (error) {
             return (0, base_1.formatToolError)(error);
         }
     }
-    async searchInDir(dir, regex, include, results, maxResults) {
-        if (results.length >= maxResults)
-            return;
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (results.length >= maxResults)
-                return;
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {
-                    continue;
+    async runSearch(params, searchPath) {
+        const isWindows = process.platform === 'win32';
+        const pattern = params.case_sensitive
+            ? new RegExp(params.pattern, 'g')
+            : new RegExp(params.pattern, 'gi');
+        const results = [];
+        const contextLines = params.context || 0;
+        const searchFile = (filePath) => {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    if (pattern.test(line)) {
+                        // Add context before
+                        if (contextLines > 0) {
+                            for (let j = Math.max(0, i - contextLines); j < i; j++) {
+                                results.push(`  ${filePath}:${j + 1}: ${lines[j]}`);
+                            }
+                        }
+                        // Add matching line
+                        results.push(`> ${filePath}:${i + 1}: ${line}`);
+                        // Add context after
+                        if (contextLines > 0) {
+                            for (let j = i + 1; j <= Math.min(lines.length - 1, i + contextLines); j++) {
+                                results.push(`  ${filePath}:${j + 1}: ${lines[j]}`);
+                            }
+                        }
+                        results.push(''); // Empty line between matches
+                    }
                 }
-                await this.searchInDir(fullPath, regex, include, results, maxResults);
             }
-            else if (entry.isFile()) {
-                if (!this.shouldInclude(fullPath, include)) {
-                    continue;
-                }
-                try {
-                    const content = await fs.readFile(fullPath, 'utf-8');
-                    const lines = content.split('\n');
-                    lines.forEach((line, index) => {
-                        if (results.length >= maxResults)
-                            return;
-                        const match = line.match(regex);
-                        if (match) {
-                            results.push({
-                                file: fullPath,
-                                line: index + 1,
-                                content: line.trim(),
-                                match: match[0]
-                            });
+            catch {
+                // Skip files that can't be read as text
+            }
+        };
+        const searchDir = (dirPath) => {
+            try {
+                const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dirPath, entry.name);
+                    if (entry.isDirectory()) {
+                        // Skip hidden directories and common ignore patterns
+                        if (!entry.name.startsWith('.') &&
+                            entry.name !== 'node_modules' &&
+                            entry.name !== 'dist' &&
+                            entry.name !== 'build') {
+                            searchDir(fullPath);
                         }
-                    });
-                }
-                catch {
-                    // Skip files that can't be read as text
+                    }
+                    else if (entry.isFile()) {
+                        // Apply include filter if provided
+                        if (params.include) {
+                            const minimatch = require('minimatch');
+                            if (!minimatch(entry.name, params.include)) {
+                                continue;
+                            }
+                        }
+                        searchFile(fullPath);
+                    }
                 }
             }
+            catch {
+                // Skip directories that can't be accessed
+            }
+        };
+        try {
+            const stat = fs.statSync(searchPath);
+            if (stat.isDirectory()) {
+                searchDir(searchPath);
+            }
+            else {
+                searchFile(searchPath);
+            }
         }
-    }
-    shouldInclude(filePath, include) {
-        if (!include) {
-            // Default: only text files
-            const ext = path.extname(filePath).toLowerCase();
-            const textExts = [
-                '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt',
-                '.py', '.java', '.c', '.cpp', '.h', '.go', '.rs',
-                '.yaml', '.yml', '.toml', '.ini', '.env', '.sh',
-                '.html', '.css', '.scss', '.less', '.vue', '.svelte'
-            ];
-            return textExts.includes(ext) || ext === '';
+        catch (error) {
+            return `Error: Could not access ${searchPath}: ${error}`;
+        }
+        if (results.length === 0) {
+            return `No matches found for pattern "${params.pattern}" in ${searchPath}`;
         }
-        // Simple include pattern matching
-        if (include.startsWith('*.')) {
-            const ext = include.slice(1);
-            return filePath.endsWith(ext);
+        // Limit results to prevent overwhelming output
+        const maxResults = 500;
+        const limitedResults = results.slice(0, maxResults);
+        let output = `Found ${results.length} matches for "${params.pattern}":\n\n`;
+        output += limitedResults.join('\n');
+        if (results.length > maxResults) {
+            output += `\n\n... and ${results.length - maxResults} more matches (truncated)`;
         }
-        return filePath.includes(include);
+        return output;
     }
 }
 exports.SearchFileContentTool = SearchFileContentTool;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-file-content.js","sourceRoot":"","sources":["../../src/tools/search-file-content.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\n\ninterface SearchFileContentParams {\n  pattern: string;\n  path?: string;\n  include?: string;\n  case_sensitive?: boolean;\n  context?: number;\n}\n\ninterface SearchResult {\n  file: string;\n  line: number;\n  content: string;\n  match: string;\n}\n\nexport class SearchFileContentTool extends BaseTool<SearchFileContentParams> {\n  name = 'search_file_content';\n  description = 'Searches for a pattern within files in a directory using regex.';\n  parameters = {\n    type: 'object',\n    properties: {\n      pattern: {\n        type: 'string',\n        description: 'The regular expression pattern to search for'\n      },\n      path: {\n        type: 'string',\n        description: 'Optional: The path to search within'\n      },\n      include: {\n        type: 'string',\n        description: 'Optional: A glob pattern to filter files'\n      },\n      case_sensitive: {\n        type: 'boolean',\n        description: 'If true, search is case-sensitive'\n      },\n      context: {\n        type: 'number',\n        description: 'Number of lines of context around matches'\n      }\n    },\n    required: ['pattern']\n  };\n\n  async execute(params: SearchFileContentParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['pattern']);\n\n    const workingDir = options?.workingDirectory || process.cwd();\n    const searchPath = params.path || workingDir;\n    const caseSensitive = params.case_sensitive ?? false;\n\n    try {\n      const regex = new RegExp(params.pattern, caseSensitive ? 'g' : 'gi');\n      const results: SearchResult[] = [];\n      const maxResults = 500;\n\n      await this.searchInDir(searchPath, regex, params.include, results, maxResults);\n\n      if (results.length === 0) {\n        return `No matches found for pattern: ${params.pattern}`;\n      }\n\n      const output = results.map(r => {\n        return `${r.file}:${r.line}: ${r.content}`;\n      }).join('\\n');\n\n      return `Found ${results.length} matches:\\n\\n${output}`;\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private async searchInDir(\n    dir: string,\n    regex: RegExp,\n    include: string | undefined,\n    results: SearchResult[],\n    maxResults: number\n  ): Promise<void> {\n    if (results.length >= maxResults) return;\n\n    const entries = await fs.readdir(dir, { withFileTypes: true });\n\n    for (const entry of entries) {\n      if (results.length >= maxResults) return;\n\n      const fullPath = path.join(dir, entry.name);\n\n      if (entry.isDirectory()) {\n        if (['node_modules', '.git', 'dist', 'build', '.next'].includes(entry.name)) {\n          continue;\n        }\n        await this.searchInDir(fullPath, regex, include, results, maxResults);\n      } else if (entry.isFile()) {\n        if (!this.shouldInclude(fullPath, include)) {\n          continue;\n        }\n\n        try {\n          const content = await fs.readFile(fullPath, 'utf-8');\n          const lines = content.split('\\n');\n\n          lines.forEach((line, index) => {\n            if (results.length >= maxResults) return;\n\n            const match = line.match(regex);\n            if (match) {\n              results.push({\n                file: fullPath,\n                line: index + 1,\n                content: line.trim(),\n                match: match[0]\n              });\n            }\n          });\n        } catch {\n          // Skip files that can't be read as text\n        }\n      }\n    }\n  }\n\n  private shouldInclude(filePath: string, include: string | undefined): boolean {\n    if (!include) {\n      // Default: only text files\n      const ext = path.extname(filePath).toLowerCase();\n      const textExts = [\n        '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt',\n        '.py', '.java', '.c', '.cpp', '.h', '.go', '.rs',\n        '.yaml', '.yml', '.toml', '.ini', '.env', '.sh',\n        '.html', '.css', '.scss', '.less', '.vue', '.svelte'\n      ];\n      return textExts.includes(ext) || ext === '';\n    }\n\n    // Simple include pattern matching\n    if (include.startsWith('*.')) {\n      const ext = include.slice(1);\n      return filePath.endsWith(ext);\n    }\n    return filePath.includes(include);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search-file-content.js","sourceRoot":"","sources":["../../src/tools/search-file-content.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTool, ToolExecuteOptions, formatToolError } from './base';\nimport { spawn } from 'child_process';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\ninterface SearchFileContentParams {\n  pattern: string;\n  path?: string;\n  include?: string;\n  case_sensitive?: boolean;\n  context?: number;\n}\n\nexport class SearchFileContentTool extends BaseTool<SearchFileContentParams> {\n  name = 'search_file_content';\n  description = 'Searches for a regular expression pattern within the content of files or directories. Returns the lines containing matches, along with their file paths and line numbers.';\n  parameters = {\n    type: 'object',\n    properties: {\n      pattern: {\n        type: 'string',\n        description: 'The regular expression (regex) pattern to search for within file contents'\n      },\n      path: {\n        type: 'string',\n        description: 'Optional: The absolute path to the file or directory to search within. If omitted, searches the current working directory.'\n      },\n      include: {\n        type: 'string',\n        description: 'Optional: A glob pattern to filter which files are searched (e.g., *.js, *.{ts,tsx}, src/**)'\n      },\n      case_sensitive: {\n        type: 'boolean',\n        description: 'If true, search is case-sensitive. Defaults to false.'\n      },\n      context: {\n        type: 'number',\n        description: 'Show this many lines of context around each match. Defaults to 0.'\n      }\n    },\n    required: ['pattern'],\n    additionalProperties: false\n  };\n\n  async execute(params: SearchFileContentParams, options?: ToolExecuteOptions): Promise<string> {\n    this.validateRequired(params, ['pattern']);\n\n    const workingDir = options?.workingDirectory || process.cwd();\n    const searchPath = params.path || workingDir;\n\n    try {\n      const results = await this.runSearch(params, searchPath);\n      return results;\n    } catch (error) {\n      return formatToolError(error);\n    }\n  }\n\n  private async runSearch(params: SearchFileContentParams, searchPath: string): Promise<string> {\n    const isWindows = process.platform === 'win32';\n    const pattern = params.case_sensitive \n      ? new RegExp(params.pattern, 'g')\n      : new RegExp(params.pattern, 'gi');\n\n    const results: string[] = [];\n    const contextLines = params.context || 0;\n\n    const searchFile = (filePath: string): void => {\n      try {\n        const content = fs.readFileSync(filePath, 'utf-8');\n        const lines = content.split('\\n');\n\n        for (let i = 0; i < lines.length; i++) {\n          const line = lines[i];\n          if (pattern.test(line)) {\n            // Add context before\n            if (contextLines > 0) {\n              for (let j = Math.max(0, i - contextLines); j < i; j++) {\n                results.push(`  ${filePath}:${j + 1}: ${lines[j]}`);\n              }\n            }\n            // Add matching line\n            results.push(`> ${filePath}:${i + 1}: ${line}`);\n            // Add context after\n            if (contextLines > 0) {\n              for (let j = i + 1; j <= Math.min(lines.length - 1, i + contextLines); j++) {\n                results.push(`  ${filePath}:${j + 1}: ${lines[j]}`);\n              }\n            }\n            results.push(''); // Empty line between matches\n          }\n        }\n      } catch {\n        // Skip files that can't be read as text\n      }\n    };\n\n    const searchDir = (dirPath: string): void => {\n      try {\n        const entries = fs.readdirSync(dirPath, { withFileTypes: true });\n\n        for (const entry of entries) {\n          const fullPath = path.join(dirPath, entry.name);\n\n          if (entry.isDirectory()) {\n            // Skip hidden directories and common ignore patterns\n            if (!entry.name.startsWith('.') && \n                entry.name !== 'node_modules' && \n                entry.name !== 'dist' &&\n                entry.name !== 'build') {\n              searchDir(fullPath);\n            }\n          } else if (entry.isFile()) {\n            // Apply include filter if provided\n            if (params.include) {\n              const minimatch = require('minimatch');\n              if (!minimatch(entry.name, params.include)) {\n                continue;\n              }\n            }\n            searchFile(fullPath);\n          }\n        }\n      } catch {\n        // Skip directories that can't be accessed\n      }\n    };\n\n    try {\n      const stat = fs.statSync(searchPath);\n      if (stat.isDirectory()) {\n        searchDir(searchPath);\n      } else {\n        searchFile(searchPath);\n      }\n    } catch (error) {\n      return `Error: Could not access ${searchPath}: ${error}`;\n    }\n\n    if (results.length === 0) {\n      return `No matches found for pattern \"${params.pattern}\" in ${searchPath}`;\n    }\n\n    // Limit results to prevent overwhelming output\n    const maxResults = 500;\n    const limitedResults = results.slice(0, maxResults);\n\n    let output = `Found ${results.length} matches for \"${params.pattern}\":\\n\\n`;\n    output += limitedResults.join('\\n');\n\n    if (results.length > maxResults) {\n      output += `\\n\\n... and ${results.length - maxResults} more matches (truncated)`;\n    }\n\n    return output;\n  }\n}\n"]}

package/dist/tools/write-file.d.ts

@@ -19,6 +19,7 @@ export declare class WriteFileTool extends BaseTool<WriteFileParams> {
             };
         };
         required: string[];
+        additionalProperties: boolean;
     };
     execute(params: WriteFileParams, options?: ToolExecuteOptions): Promise<string>;
 }