orquesta-cli 0.1.12

package/dist/tools/llm/simple/file-tools.js

@@ -0,0 +1,785 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { logger } from '../../../utils/logger.js';
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    '.next',
+    'coverage',
+    '.cache',
+    'build',
+    '__pycache__',
+]);
+const MAX_DEPTH = 5;
+const MAX_FILES = 100;
+const DEFAULT_LINE_LIMIT = 2000;
+const MAX_LINE_LIMIT = 10000;
+const MAX_FILE_SIZE = 100 * 1024 * 1024;
+const MAX_WRITE_SIZE = 50 * 1024 * 1024;
+const READ_FILE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'read_file',
+        description: `Read the contents of a file. Only text files are supported.
+By default, reads up to ${DEFAULT_LINE_LIMIT} lines. Use offset/limit for large files.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: `A natural, conversational explanation for the user about what you're doing.
+Write as if you're talking to the user directly. Use the same language as the user.
+Examples:
+- "Checking how the current authentication logic is implemented"
+- "Opening the file where the error occurred to find the problem"
+- "Checking package.json to understand the project setup"
+- "Looking at the existing code before making changes"`,
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Absolute or relative path of the file to read',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Starting line number (1-based, default: 1)',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Number of lines to read (default: ${DEFAULT_LINE_LIMIT}, max: ${MAX_LINE_LIMIT})`,
+                },
+            },
+            required: ['reason', 'file_path'],
+        },
+    },
+};
+async function _executeReadFile(args) {
+    const filePath = args['file_path'];
+    const offset = Math.max(1, args['offset'] || 1);
+    const limit = Math.min(MAX_LINE_LIMIT, Math.max(1, args['limit'] || DEFAULT_LINE_LIMIT));
+    logger.toolStart('read_file', args);
+    try {
+        const cleanPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+        const resolvedPath = path.resolve(cleanPath);
+        const displayPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+        const stats = await fs.stat(resolvedPath);
+        if (stats.size > MAX_FILE_SIZE) {
+            logger.warn('File too large to read', { path: displayPath, size: stats.size, max: MAX_FILE_SIZE });
+            return {
+                success: false,
+                error: `File too large to read (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum: ${MAX_FILE_SIZE / 1024 / 1024}MB`,
+            };
+        }
+        const content = await fs.readFile(resolvedPath, 'utf-8');
+        const allLines = content.split('\n');
+        const totalLines = allLines.length;
+        const startIdx = offset - 1;
+        const endIdx = Math.min(startIdx + limit, totalLines);
+        const selectedLines = allLines.slice(startIdx, endIdx);
+        const formattedLines = selectedLines.map((line, idx) => {
+            const lineNum = startIdx + idx + 1;
+            const padding = String(totalLines).length;
+            return `${String(lineNum).padStart(padding)}→${line}`;
+        });
+        let result = formattedLines.join('\n');
+        if (totalLines > limit || offset > 1) {
+            const header = `[File: ${displayPath} | Lines ${offset}-${endIdx} of ${totalLines}]`;
+            const hasMore = endIdx < totalLines;
+            const footer = hasMore
+                ? `\n[... ${totalLines - endIdx} more lines. Use offset=${endIdx + 1} to continue reading]`
+                : '';
+            result = `${header}\n${result}${footer}`;
+        }
+        logger.toolSuccess('read_file', args, { linesRead: selectedLines.length, totalLines }, 0);
+        return {
+            success: true,
+            result,
+        };
+    }
+    catch (error) {
+        const err = error;
+        const displayPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+        if (err.code === 'ENOENT') {
+            logger.toolError('read_file', args, err, 0);
+            return {
+                success: false,
+                error: `File not found: ${displayPath}`,
+            };
+        }
+        else if (err.code === 'EACCES') {
+            logger.toolError('read_file', args, err, 0);
+            return {
+                success: false,
+                error: `Permission denied reading file: ${displayPath}`,
+            };
+        }
+        else {
+            logger.toolError('read_file', args, err, 0);
+            return {
+                success: false,
+                error: `Failed to read file: ${err.message}`,
+            };
+        }
+    }
+}
+export const readFileTool = {
+    definition: READ_FILE_DEFINITION,
+    execute: _executeReadFile,
+    categories: ['llm-simple'],
+    description: 'Read file contents',
+};
+const CREATE_FILE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'create_file',
+        description: `Create a NEW file with the given content.
+IMPORTANT: Only use this for files that do NOT exist yet.
+For modifying existing files, use edit_file instead.
+If the file already exists, this tool will fail.`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: `A natural, conversational explanation for the user about what you're doing.
+Write as if you're talking to the user directly. Use the same language as the user.
+Examples:
+- "Creating a new file for the authentication service"
+- "Creating a new test config file since one doesn't exist"
+- "Creating a new file to separate the API router"
+- "Adding a new component file"`,
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Absolute or relative path of the new file to create',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Content to write to the new file',
+                },
+            },
+            required: ['reason', 'file_path', 'content'],
+        },
+    },
+};
+async function _executeCreateFile(args) {
+    const filePath = args['file_path'];
+    const content = args['content'];
+    logger.toolStart('create_file', { file_path: filePath, contentLength: content?.length || 0 });
+    try {
+        const cleanPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+        const resolvedPath = path.resolve(cleanPath);
+        const displayPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+        const contentSize = Buffer.byteLength(content, 'utf-8');
+        if (contentSize > MAX_WRITE_SIZE) {
+            logger.warn('Content too large to write', { path: displayPath, size: contentSize, max: MAX_WRITE_SIZE });
+            return {
+                success: false,
+                error: `Content too large to write (${(contentSize / 1024 / 1024).toFixed(2)}MB). Maximum: ${MAX_WRITE_SIZE / 1024 / 1024}MB`,
+            };
+        }
+        try {
+            await fs.access(resolvedPath);
+            logger.toolError('create_file', args, new Error('File already exists'), 0);
+            return {
+                success: false,
+                error: `File already exists: ${displayPath}. Use edit_file to modify existing files.`,
+            };
+        }
+        catch {
+        }
+        const dir = path.dirname(resolvedPath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(resolvedPath, content, 'utf-8');
+        const lines = content.split('\n').length;
+        logger.toolSuccess('create_file', args, { file: displayPath, lines }, 0);
+        return {
+            success: true,
+            result: JSON.stringify({
+                action: 'created',
+                file: displayPath,
+                lines: lines,
+                message: `Created ${displayPath} (${lines} lines)`,
+            }),
+        };
+    }
+    catch (error) {
+        const err = error;
+        const displayPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+        logger.toolError('create_file', args, err, 0);
+        return {
+            success: false,
+            error: `Failed to create file (${displayPath}): ${err.message}`,
+        };
+    }
+}
+export const createFileTool = {
+    definition: CREATE_FILE_DEFINITION,
+    execute: _executeCreateFile,
+    categories: ['llm-simple'],
+    description: 'Create a new file',
+};
+const EDIT_FILE_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'edit_file',
+        description: `Edit an EXISTING file by replacing a specific text block.
+IMPORTANT: Only use this for files that already exist. For new files, use create_file.
+
+HOW TO USE:
+1. First use read_file to see the current content
+2. Copy the EXACT text block you want to change (can be multiple lines)
+3. Provide old_string (text to find) and new_string (replacement)
+
+RULES:
+- old_string must match EXACTLY (including whitespace and indentation)
+- old_string must be UNIQUE in the file (if it appears multiple times, use replace_all: true)
+- Both old_string and new_string can be multi-line
+- To delete text, use empty string "" for new_string
+
+EXAMPLES:
+1. Change a single line:
+   old_string: "const x = 1;"
+   new_string: "const x = 2;"
+
+2. Change multiple lines at once:
+   old_string: "function foo() {\\n  return 1;\\n}"
+   new_string: "function foo() {\\n  return 2;\\n}"
+
+3. Delete a line:
+   old_string: "// delete this line\\n"
+   new_string: ""
+
+4. Replace all occurrences:
+   old_string: "oldName"
+   new_string: "newName"
+   replace_all: true`,
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: `A natural, conversational explanation for the user about what you're doing.
+Write as if you're talking to the user directly. Use the same language as the user.
+Examples:
+- "Fixing the buggy section"
+- "Changing the function name as requested"
+- "Adding the import statement"
+- "Fixing the type error"`,
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Absolute or relative path of the existing file to edit',
+                },
+                old_string: {
+                    type: 'string',
+                    description: 'The exact text to find and replace (can be multi-line)',
+                },
+                new_string: {
+                    type: 'string',
+                    description: 'The new text to replace with (can be multi-line, use "" to delete)',
+                },
+                replace_all: {
+                    type: 'boolean',
+                    description: 'If true, replace ALL occurrences of old_string. Default is false (requires unique match).',
+                },
+            },
+            required: ['reason', 'file_path', 'old_string', 'new_string'],
+        },
+    },
+};
+async function _executeEditFile(args) {
+    const filePath = args['file_path'];
+    const oldString = args['old_string'];
+    const newString = args['new_string'];
+    const replaceAll = args['replace_all'];
+    logger.toolStart('edit_file', { file_path: filePath, oldStringLength: oldString?.length || 0, newStringLength: newString?.length || 0, replaceAll });
+    const cleanPath = filePath.startsWith('@') ? filePath.slice(1) : filePath;
+    const displayPath = cleanPath;
+    try {
+        const resolvedPath = path.resolve(cleanPath);
+        if (!oldString) {
+            return {
+                success: false,
+                error: 'old_string cannot be empty.',
+            };
+        }
+        try {
+            await fs.access(resolvedPath);
+        }
+        catch {
+            return {
+                success: false,
+                error: `File does not exist: ${displayPath}. Use create_file to create new files.`,
+            };
+        }
+        const stats = await fs.stat(resolvedPath);
+        if (stats.size > MAX_FILE_SIZE) {
+            logger.warn('File too large to edit', { path: displayPath, size: stats.size, max: MAX_FILE_SIZE });
+            return {
+                success: false,
+                error: `File too large to edit (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum: ${MAX_FILE_SIZE / 1024 / 1024}MB`,
+            };
+        }
+        const originalContent = await fs.readFile(resolvedPath, 'utf-8');
+        if (!originalContent.includes(oldString)) {
+            const lines = originalContent.split('\n');
+            const preview = lines.slice(0, 20).map((l, i) => `${i + 1}: ${l}`).join('\n');
+            return {
+                success: false,
+                error: `old_string not found in file.\n\nSearched for:\n"${oldString.slice(0, 200)}${oldString.length > 200 ? '...' : ''}"\n\nFile preview (first 20 lines):\n${preview}\n\n💡 Use read_file to check the exact content and try again.`,
+            };
+        }
+        const occurrences = originalContent.split(oldString).length - 1;
+        if (!replaceAll && occurrences > 1) {
+            return {
+                success: false,
+                error: `old_string appears ${occurrences} times in the file. Either:\n1. Make old_string more specific (include more context)\n2. Use replace_all: true to replace all occurrences\n\n💡 Include surrounding lines to make the match unique.`,
+            };
+        }
+        let newContent;
+        if (replaceAll) {
+            newContent = originalContent.split(oldString).join(newString);
+        }
+        else {
+            newContent = originalContent.replace(oldString, newString);
+        }
+        const newContentSize = Buffer.byteLength(newContent, 'utf-8');
+        if (newContentSize > MAX_WRITE_SIZE) {
+            logger.warn('Modified content too large', { path: displayPath, size: newContentSize, max: MAX_WRITE_SIZE });
+            return {
+                success: false,
+                error: `Modified content too large (${(newContentSize / 1024 / 1024).toFixed(2)}MB). Maximum: ${MAX_WRITE_SIZE / 1024 / 1024}MB`,
+            };
+        }
+        await fs.writeFile(resolvedPath, newContent, 'utf-8');
+        const oldLinesArr = oldString.split('\n');
+        const newLinesArr = newString.split('\n');
+        const replacements = replaceAll ? occurrences : 1;
+        const diffPreview = [];
+        const oldPreview = oldLinesArr.slice(0, 5);
+        const newPreview = newLinesArr.slice(0, 5);
+        oldPreview.forEach(line => diffPreview.push(`- ${line}`));
+        if (oldLinesArr.length > 5)
+            diffPreview.push('- ...');
+        newPreview.forEach(line => diffPreview.push(`+ ${line}`));
+        if (newLinesArr.length > 5)
+            diffPreview.push('+ ...');
+        logger.toolSuccess('edit_file', args, { file: displayPath, replacements, oldLines: oldLinesArr.length, newLines: newLinesArr.length }, 0);
+        return {
+            success: true,
+            result: JSON.stringify({
+                action: 'edited',
+                file: displayPath,
+                replacements: replacements,
+                oldLines: oldLinesArr.length,
+                newLines: newLinesArr.length,
+                message: replaceAll
+                    ? `Replaced ${replacements} occurrence(s) in ${displayPath}`
+                    : `Updated ${displayPath}`,
+                diff: diffPreview,
+            }),
+        };
+    }
+    catch (error) {
+        const err = error;
+        logger.toolError('edit_file', args, err, 0);
+        return {
+            success: false,
+            error: `File edit failed (${displayPath}): ${err.message}`,
+        };
+    }
+}
+export const editFileTool = {
+    definition: EDIT_FILE_DEFINITION,
+    execute: _executeEditFile,
+    categories: ['llm-simple'],
+    description: 'Edit an existing file',
+};
+const LIST_FILES_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'list_files',
+        description: 'List files and folders in a directory.',
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: `A natural, conversational explanation for the user about what you're doing.
+Write as if you're talking to the user directly. Use the same language as the user.
+Examples:
+- "Looking at the folder structure to understand the project"
+- "Checking what files are available"
+- "Seeing what's inside the src folder"
+- "Checking the directory to find related files"`,
+                },
+                directory_path: {
+                    type: 'string',
+                    description: 'Directory path to list (default: current directory)',
+                },
+                recursive: {
+                    type: 'boolean',
+                    description: 'Whether to list subdirectories recursively (default: false)',
+                },
+            },
+            required: ['reason'],
+        },
+    },
+};
+async function getFilesRecursively(dirPath, baseDir = dirPath, depth = 0, fileCount = { count: 0 }) {
+    if (depth > MAX_DEPTH) {
+        return [];
+    }
+    if (fileCount.count >= MAX_FILES) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        if (fileCount.count >= MAX_FILES) {
+            break;
+        }
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const fullPath = path.join(dirPath, entry.name);
+        const relativePath = path.relative(baseDir, fullPath);
+        if (entry.isDirectory()) {
+            if (EXCLUDED_DIRS.has(entry.name)) {
+                continue;
+            }
+            files.push({
+                name: entry.name,
+                type: 'directory',
+                path: relativePath,
+            });
+            fileCount.count++;
+            const subFiles = await getFilesRecursively(fullPath, baseDir, depth + 1, fileCount);
+            files.push(...subFiles);
+        }
+        else {
+            files.push({
+                name: entry.name,
+                type: 'file',
+                path: relativePath,
+            });
+            fileCount.count++;
+        }
+    }
+    return files;
+}
+async function _executeListFilesInternal(args) {
+    const directoryPath = args['directory_path'] || '.';
+    const recursive = args['recursive'] || false;
+    logger.toolStart('list_files', { directory_path: directoryPath, recursive });
+    try {
+        const resolvedPath = path.resolve(directoryPath);
+        if (recursive) {
+            const files = await getFilesRecursively(resolvedPath);
+            logger.toolSuccess('list_files', args, { fileCount: files.length }, 0);
+            return {
+                success: true,
+                result: JSON.stringify(files, null, 2),
+            };
+        }
+        else {
+            const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
+            const files = entries.map((entry) => ({
+                name: entry.name,
+                type: entry.isDirectory() ? 'directory' : 'file',
+                path: path.join(directoryPath, entry.name),
+            }));
+            logger.toolSuccess('list_files', args, { fileCount: files.length }, 0);
+            return {
+                success: true,
+                result: JSON.stringify(files, null, 2),
+            };
+        }
+    }
+    catch (error) {
+        const err = error;
+        logger.toolError('list_files', args, err, 0);
+        if (err.code === 'ENOENT') {
+            return {
+                success: false,
+                error: `Directory not found: ${directoryPath}`,
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: `Failed to read directory: ${err.message}`,
+            };
+        }
+    }
+}
+export const listFilesTool = {
+    definition: LIST_FILES_DEFINITION,
+    execute: _executeListFilesInternal,
+    categories: ['llm-simple'],
+    description: 'List directory contents',
+};
+const FIND_FILES_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'find_files',
+        description: 'Search for files by filename pattern.',
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: `A natural, conversational explanation for the user about what you're doing (in user's language).
+Write as if you're talking to the user directly.
+Examples:
+- "Looking for where the config files are located"
+- "Searching for test files"
+- "Checking where TypeScript files are"
+- "Finding related component files"`,
+                },
+                pattern: {
+                    type: 'string',
+                    description: 'Filename pattern to search for (e.g., *.ts, package.json)',
+                },
+                directory_path: {
+                    type: 'string',
+                    description: 'Directory path to start search from (default: current directory)',
+                },
+            },
+            required: ['reason', 'pattern'],
+        },
+    },
+};
+async function findFilesRecursively(dirPath, regex, baseDir, depth = 0, fileCount = { count: 0 }) {
+    if (depth > MAX_DEPTH) {
+        return [];
+    }
+    if (fileCount.count >= MAX_FILES) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const matchedFiles = [];
+    for (const entry of entries) {
+        if (fileCount.count >= MAX_FILES) {
+            break;
+        }
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (EXCLUDED_DIRS.has(entry.name)) {
+                continue;
+            }
+            const subFiles = await findFilesRecursively(fullPath, regex, baseDir, depth + 1, fileCount);
+            matchedFiles.push(...subFiles);
+        }
+        else if (regex.test(entry.name)) {
+            const relativePath = path.relative(baseDir, fullPath);
+            matchedFiles.push({
+                name: entry.name,
+                path: relativePath,
+            });
+            fileCount.count++;
+        }
+    }
+    return matchedFiles;
+}
+async function _executeFindFilesInternal(args) {
+    const pattern = args['pattern'];
+    const directoryPath = args['directory_path'] || '.';
+    logger.toolStart('find_files', { pattern, directory_path: directoryPath });
+    try {
+        const resolvedPath = path.resolve(directoryPath);
+        const regexPattern = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`);
+        const matchedFiles = await findFilesRecursively(resolvedPath, regex, resolvedPath);
+        if (matchedFiles.length === 0) {
+            logger.toolSuccess('find_files', args, { matchCount: 0 }, 0);
+            return {
+                success: true,
+                result: `No files found matching pattern "${pattern}".`,
+            };
+        }
+        logger.toolSuccess('find_files', args, { matchCount: matchedFiles.length }, 0);
+        return {
+            success: true,
+            result: JSON.stringify(matchedFiles, null, 2),
+        };
+    }
+    catch (error) {
+        const err = error;
+        logger.toolError('find_files', args, err, 0);
+        return {
+            success: false,
+            error: `File search failed: ${err.message}`,
+        };
+    }
+}
+export const findFilesTool = {
+    definition: FIND_FILES_DEFINITION,
+    execute: _executeFindFilesInternal,
+    categories: ['llm-simple'],
+    description: 'Search files by pattern',
+};
+const SEARCH_CONTENT_DEFINITION = {
+    type: 'function',
+    function: {
+        name: 'search_content',
+        description: 'Search for text pattern inside files.',
+        parameters: {
+            type: 'object',
+            properties: {
+                reason: {
+                    type: 'string',
+                    description: `A natural, conversational explanation for the user about what you're doing.
+Write as if you're talking to the user directly. Use the same language as the user.
+Examples:
+- "Searching for usages of the function"
+- "Finding where the error message is defined"
+- "Looking for references to the API endpoint"`,
+                },
+                pattern: {
+                    type: 'string',
+                    description: 'Text or regex pattern to search for',
+                },
+                directory_path: {
+                    type: 'string',
+                    description: 'Directory path to search in (default: current directory)',
+                },
+                file_pattern: {
+                    type: 'string',
+                    description: 'File pattern to filter (e.g., *.ts)',
+                },
+                max_results: {
+                    type: 'number',
+                    description: 'Maximum number of results (default: 50)',
+                },
+            },
+            required: ['reason', 'pattern'],
+        },
+    },
+};
+const TEXT_EXTENSIONS = [
+    '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt', '.css', '.scss',
+    '.html', '.xml', '.yaml', '.yml', '.toml', '.ini', '.cfg', '.conf',
+    '.sh', '.bash', '.ps1', '.py', '.rb', '.go', '.rs', '.java', '.c',
+    '.cpp', '.h', '.hpp', '.cs', '.php', '.vue', '.svelte',
+];
+async function searchContentRecursively(dirPath, searchRegex, baseDir, fileRegex, resultCount, maxResults, depth = 0) {
+    if (depth > MAX_DEPTH || resultCount.count >= maxResults) {
+        return [];
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        if (resultCount.count >= maxResults)
+            break;
+        if (entry.name.startsWith('.'))
+            continue;
+        const fullPath = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            if (EXCLUDED_DIRS.has(entry.name))
+                continue;
+            const subResults = await searchContentRecursively(fullPath, searchRegex, baseDir, fileRegex, resultCount, maxResults, depth + 1);
+            results.push(...subResults);
+        }
+        else {
+            if (fileRegex && !fileRegex.test(entry.name))
+                continue;
+            const ext = path.extname(entry.name).toLowerCase();
+            if (!TEXT_EXTENSIONS.includes(ext))
+                continue;
+            try {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                const lines = content.split('\n');
+                const relativePath = path.relative(baseDir, fullPath);
+                for (let i = 0; i < lines.length && resultCount.count < maxResults; i++) {
+                    const line = lines[i] ?? '';
+                    if (searchRegex.test(line)) {
+                        results.push({
+                            file: relativePath,
+                            line: i + 1,
+                            content: line.trim().substring(0, 200),
+                        });
+                        resultCount.count++;
+                    }
+                }
+            }
+            catch {
+            }
+        }
+    }
+    return results;
+}
+async function executeSearchContent(args) {
+    const pattern = args['pattern'];
+    const directoryPath = args['directory_path'] || '.';
+    const filePattern = args['file_pattern'];
+    const maxResults = args['max_results'] || 50;
+    logger.toolStart('search_content', { pattern, directory_path: directoryPath, file_pattern: filePattern, maxResults });
+    try {
+        const resolvedPath = path.isAbsolute(directoryPath) ? directoryPath : path.resolve(process.cwd(), directoryPath);
+        const searchRegex = new RegExp(pattern, 'gi');
+        let fileRegex = null;
+        if (filePattern) {
+            const regexPattern = filePattern
+                .replace(/\./g, '\\.')
+                .replace(/\*/g, '.*')
+                .replace(/\?/g, '.');
+            fileRegex = new RegExp(`^${regexPattern}$`, 'i');
+        }
+        const results = await searchContentRecursively(resolvedPath, searchRegex, resolvedPath, fileRegex, { count: 0 }, maxResults);
+        logger.toolSuccess('search_content', args, { matchedCount: results.length }, 0);
+        if (results.length === 0) {
+            return { success: true, result: `No matches found for pattern "${pattern}".` };
+        }
+        return { success: true, result: JSON.stringify(results, null, 2) };
+    }
+    catch (error) {
+        const err = error;
+        logger.toolError('search_content', args, err, 0);
+        return { success: false, error: `Content search failed: ${err.message}` };
+    }
+}
+export const searchContentTool = {
+    definition: SEARCH_CONTENT_DEFINITION,
+    execute: executeSearchContent,
+    categories: ['llm-simple'],
+    description: 'Search content in files',
+};
+export const FILE_TOOLS = [
+    readFileTool,
+    createFileTool,
+    editFileTool,
+    listFilesTool,
+    findFilesTool,
+    searchContentTool,
+];
+export const SYSTEM_TOOLS = [];
+export { USER_INTERACTION_TOOLS, tellToUserTool, askToUserTool, setTellToUserCallback, setAskUserCallback, clearAskUserCallback, hasAskUserCallback, } from './user-interaction-tools.js';
+export { FILE_TOOLS as FILE_SIMPLE_TOOLS };
+export { setToolExecutionCallback, setToolResponseCallback, setPlanCreatedCallback, setTodoStartCallback, setTodoCompleteCallback, setTodoFailCallback, setToolApprovalCallback, setCompactCallback, setAssistantResponseCallback, setReasoningCallback, getToolExecutionCallback, requestToolApproval, emitPlanCreated, emitTodoStart, emitTodoComplete, emitTodoFail, emitCompact, emitAssistantResponse, emitReasoning, executeSimpleTool, executeFileTool, } from './simple-tool-executor.js';
+//# sourceMappingURL=file-tools.js.map