agent-sory 1.0.0

package/dist/tools/tools.js

@@ -0,0 +1,1015 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import fg from 'fast-glob';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { writeFile, createDirectory, displayTree } from '../utils/file-ops.js';
+import { setReadFilesTracker } from './validators.js';
+import { calculateReplacement } from './utils/edit-logic.js';
+import { runRipGrep } from './utils/ripgrep-runner.js';
+import { convert } from 'html-to-text';
+const execAsync = promisify(exec);
+// Global task state
+let currentTaskList = null;
+// Track which files have been read in the current session
+const readFiles = new Set();
+// Export readFiles for validator access
+export function getReadFilesTracker() {
+    return readFiles;
+}
+// Initialize validator with readFiles tracker
+setReadFilesTracker(readFiles);
+/**
+ * Format key parameters for tool call display
+ */
+export function formatToolParams(toolName, toolArgs, options = {}) {
+    const { includePrefix = true, separator = '=' } = options;
+    const paramMappings = {
+        read_file: ['file_path'],
+        create_file: ['file_path'],
+        edit_file: ['file_path'],
+        delete_file: ['file_path'],
+        list_files: ['directory'],
+        search_files: ['pattern'],
+        execute_command: ['command'],
+        create_tasks: [],
+        update_tasks: [],
+    };
+    const keyParams = paramMappings[toolName] || [];
+    const parts = [];
+    // First, add mapped key params
+    keyParams.forEach(param => {
+        if (param in toolArgs) {
+            let value = toolArgs[param];
+            if (typeof value === 'string' && value.length > 50)
+                value = value.substring(0, 47) + '...';
+            parts.push(`${param}${separator}${JSON.stringify(value)}`);
+        }
+    });
+    // Then, add any OTHER params that weren't mapped (except big ones like 'content')
+    Object.keys(toolArgs).forEach(key => {
+        if (!keyParams.includes(key) && key !== 'content' && key !== 'old_text' && key !== 'new_text') {
+            let value = toolArgs[key];
+            if (typeof value === 'string' && value.length > 30)
+                value = value.substring(0, 27) + '...';
+            parts.push(`${key}${separator}${JSON.stringify(value)}`);
+        }
+    });
+    if (parts.length === 0) {
+        // If we have arguments but nothing was formatted (e.g. only 'content'), show a summary
+        if (Object.keys(toolArgs).length > 0) {
+            return includePrefix ? `Args: ${Object.keys(toolArgs).join(', ')}` : Object.keys(toolArgs).join(', ');
+        }
+        return '';
+    }
+    const formatted = parts.join(', ');
+    return includePrefix ? `Params: ${formatted}` : formatted;
+}
+/**
+ * Create a standardized tool response format
+ */
+export function createToolResponse(success, data, message = '', error = '') {
+    const response = { success };
+    if (success) {
+        if (data !== undefined) {
+            response.content = data;
+        }
+        if (message) {
+            response.message = message;
+        }
+    }
+    else {
+        response.error = error;
+        if (message) {
+            response.message = message;
+        }
+    }
+    return response;
+}
+/**
+ * Read the contents of a file, optionally specifying line range
+ */
+export async function readFile(filePath, startLine, endLine) {
+    try {
+        const resolvedPath = path.resolve(filePath);
+        // Check if file exists
+        try {
+            await fs.promises.access(resolvedPath);
+        }
+        catch {
+            const parentDir = path.dirname(filePath);
+            const suggestions = await displayTree(parentDir, '*', false, false);
+            return createToolResponse(false, undefined, '', `Error: File '${filePath}' not found. Directory '${parentDir}' contains:\n${suggestions}`);
+        }
+        const stats = await fs.promises.stat(resolvedPath);
+        if (!stats.isFile()) {
+            return createToolResponse(false, undefined, '', `Error: '${filePath}' is not a file. If it is a directory, use list_files.`);
+        }
+        // Check file size (50MB limit)
+        if (stats.size > 50 * 1024 * 1024) {
+            return createToolResponse(false, undefined, '', 'Error: File too large (max 50MB)');
+        }
+        const content = await fs.promises.readFile(resolvedPath, 'utf-8');
+        const lines = content.split('\n');
+        // Handle line range if specified
+        if (startLine !== undefined) {
+            const startIdx = Math.max(0, startLine - 1); // Convert to 0-indexed
+            let endIdx = lines.length;
+            if (endLine !== undefined) {
+                endIdx = Math.min(lines.length, endLine);
+            }
+            if (startIdx >= lines.length) {
+                return createToolResponse(false, undefined, '', 'Error: Start line exceeds file length');
+            }
+            const selectedLines = lines.slice(startIdx, endIdx);
+            const selectedContent = selectedLines.join('\n');
+            // Add file to read tracking for partial reads too
+            readFiles.add(resolvedPath);
+            const message = `Read lines ${startLine}-${endIdx} from ${filePath}`;
+            return createToolResponse(true, selectedContent, message);
+        }
+        else {
+            // Add file to read tracking
+            readFiles.add(resolvedPath);
+            const message = `Read ${lines.length} lines from ${filePath}`;
+            return createToolResponse(true, content, message);
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return createToolResponse(false, undefined, '', 'Error: File not found');
+        }
+        return createToolResponse(false, undefined, '', 'Error: Failed to read file');
+    }
+}
+/**
+ * Read multiple files at once
+ */
+export async function readManyFiles(filePaths) {
+    try {
+        const results = await Promise.all(filePaths.map(async (filePath) => {
+            try {
+                const resolvedPath = path.resolve(filePath);
+                const content = await fs.promises.readFile(resolvedPath, 'utf-8');
+                readFiles.add(resolvedPath);
+                return { filePath, content, success: true };
+            }
+            catch (error) {
+                return { filePath, error: String(error), success: false };
+            }
+        }));
+        const successfulCount = results.filter(r => r.success).length;
+        return createToolResponse(true, results, `Successfully read ${successfulCount}/${filePaths.length} files`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Error: Failed to read multiple files - ${error}`);
+    }
+}
+/**
+ * Create a new file or directory with specified content
+ */
+export async function createFile(filePath, content, fileType = 'file', overwrite = false) {
+    try {
+        const targetPath = path.resolve(filePath);
+        // Check if file exists and handle overwrite
+        const exists = await fs.promises.access(targetPath).then(() => true).catch(() => false);
+        if (exists && !overwrite) {
+            return createToolResponse(false, undefined, '', 'Error: File already exists, use overwrite=true');
+        }
+        if (fileType === 'directory') {
+            const result = await createDirectory(targetPath);
+            if (result) {
+                return createToolResponse(true, { path: targetPath, type: 'directory' }, `Directory created: ${filePath}`);
+            }
+            else {
+                return createToolResponse(false, undefined, '', 'Error: Failed to create directory');
+            }
+        }
+        else if (fileType === 'file') {
+            const result = await writeFile(targetPath, content, overwrite, true);
+            if (result) {
+                return createToolResponse(true, undefined, `File created: ${filePath}`);
+            }
+            else {
+                return createToolResponse(false, undefined, '', 'Error: Failed to create file');
+            }
+        }
+        else {
+            return createToolResponse(false, undefined, '', "Error: Invalid file_type, must be 'file' or 'directory'");
+        }
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', 'Error: Failed to create file or directory');
+    }
+}
+/**
+ * Edit a file by replacing text strings using multiple strategies (exact, flexible, regex)
+ */
+export async function editFile(filePath, oldString, newString, expectedReplacements = 1) {
+    try {
+        const resolvedPath = path.resolve(filePath);
+        // Read current content
+        const originalContent = await fs.promises.readFile(resolvedPath, 'utf-8');
+        // Detect line endings
+        const isCRLF = originalContent.includes('\r\n');
+        const normalizedContent = originalContent.replace(/\r\n/g, '\n');
+        // Perform the replacement using advanced logic
+        const result = await calculateReplacement(normalizedContent, oldString, newString);
+        if (result.occurrences === 0) {
+            return createToolResponse(false, undefined, '', `Error: Could not find the string to replace in ${filePath}. Check whitespace and indentation.`);
+        }
+        if (expectedReplacements > 0 && result.occurrences !== expectedReplacements) {
+            return createToolResponse(false, undefined, '', `Error: Expected ${expectedReplacements} replacement(s) but found ${result.occurrences} in ${filePath}.`);
+        }
+        // Restore line endings if necessary
+        let finalContent = result.newContent;
+        if (isCRLF) {
+            finalContent = finalContent.replace(/\n/g, '\r\n');
+        }
+        // Write the updated content
+        const writeResult = await writeFile(filePath, finalContent, true, true);
+        if (writeResult) {
+            return createToolResponse(true, undefined, `Successfully modified ${filePath} (${result.occurrences} replacement(s)).`);
+        }
+        else {
+            return createToolResponse(false, undefined, '', 'Error: Failed to write changes to file');
+        }
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Error: Failed to edit file - ${error}`);
+    }
+}
+/**
+ * Delete a file or directory with safety checks
+ */
+export async function deleteFile(filePath, recursive = false) {
+    try {
+        const targetPath = path.resolve(filePath);
+        const currentWorkingDir = path.resolve(process.cwd());
+        // Safety check 1: Never delete the root directory itself
+        if (targetPath === currentWorkingDir) {
+            return createToolResponse(false, undefined, '', 'Error: Cannot delete the root project directory');
+        }
+        // Safety check 2: Never delete anything outside the current working directory
+        if (!targetPath.startsWith(currentWorkingDir)) {
+            return createToolResponse(false, undefined, '', 'Error: Cannot delete files outside the project directory');
+        }
+        const exists = await fs.promises.access(targetPath).then(() => true).catch(() => false);
+        if (!exists) {
+            return createToolResponse(false, undefined, '', 'Error: Path not found');
+        }
+        const stats = await fs.promises.stat(targetPath);
+        if (stats.isDirectory() && !recursive) {
+            // Check if directory is empty
+            const items = await fs.promises.readdir(targetPath);
+            if (items.length > 0) {
+                return createToolResponse(false, undefined, '', 'Error: Directory not empty, use recursive=true');
+            }
+        }
+        // Perform deletion
+        if (stats.isDirectory()) {
+            await fs.promises.rmdir(targetPath, { recursive });
+        }
+        else {
+            await fs.promises.unlink(targetPath);
+        }
+        const fileType = stats.isDirectory() ? 'directory' : 'file';
+        return createToolResponse(true, undefined, `Deleted ${fileType}: ${filePath}`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', 'Error: Failed to delete');
+    }
+}
+/**
+ * List files and directories in a path with tree-style display
+ */
+export async function listFiles(directory = '.', pattern = '*', recursive = false, showHidden = false) {
+    try {
+        const dirPath = path.resolve(directory);
+        const exists = await fs.promises.access(dirPath).then(() => true).catch(() => false);
+        if (!exists) {
+            const parentDir = path.dirname(directory);
+            const suggestions = await displayTree(parentDir === '.' ? '.' : parentDir, '*', false, false);
+            return createToolResponse(false, undefined, '', `Error: Directory '${directory}' not found. Current location contains:\n${suggestions}`);
+        }
+        const stats = await fs.promises.stat(dirPath);
+        if (!stats.isDirectory()) {
+            return createToolResponse(false, undefined, '', `Error: '${directory}' is a file, not a directory. Use read_file instead.`);
+        }
+        // Get tree display output
+        const treeOutput = await displayTree(directory, pattern, recursive, showHidden);
+        return createToolResponse(true, treeOutput, `Listed ${directory}`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Failed to list files: ${error}`);
+    }
+}
+/**
+ * Search for text patterns in files with advanced filtering and matching options
+ */
+export async function searchFiles(pattern, filePattern = '*', directory = '.', caseSensitive = false, patternType = 'substring', fileTypes, excludeDirs, excludeFiles, maxResults = 100, contextLines = 0, groupByFile = false) {
+    try {
+        const searchDir = path.resolve(directory);
+        // Check if directory exists
+        const exists = await fs.promises.access(searchDir).then(() => true).catch(() => false);
+        if (!exists) {
+            return createToolResponse(false, undefined, '', 'Error: Directory not found');
+        }
+        const stats = await fs.promises.stat(searchDir);
+        if (!stats.isDirectory()) {
+            return createToolResponse(false, undefined, '', 'Error: Path is not a directory');
+        }
+        // Default exclusions
+        const defaultExcludeDirs = ['.git', 'node_modules', '.next', 'dist', 'build', '.cache'];
+        const defaultExcludeFiles = ['*.log', '*.tmp', '*.cache', '*.lock'];
+        const finalExcludeDirs = [...defaultExcludeDirs, ...(excludeDirs || [])];
+        const finalExcludeFiles = [...defaultExcludeFiles, ...(excludeFiles || [])];
+        // Prepare search regex
+        let searchRegex;
+        try {
+            switch (patternType) {
+                case 'exact':
+                    searchRegex = new RegExp(escapeRegex(pattern), caseSensitive ? 'g' : 'gi');
+                    break;
+                case 'regex':
+                    searchRegex = new RegExp(pattern, caseSensitive ? 'g' : 'gi');
+                    break;
+                case 'fuzzy':
+                    // Simple fuzzy search, insert .* between characters
+                    const fuzzyPattern = pattern.split('').map(escapeRegex).join('.*');
+                    searchRegex = new RegExp(fuzzyPattern, caseSensitive ? 'g' : 'gi');
+                    break;
+                case 'substring':
+                default:
+                    searchRegex = new RegExp(escapeRegex(pattern), caseSensitive ? 'g' : 'gi');
+                    break;
+            }
+        }
+        catch (error) {
+            return createToolResponse(false, undefined, '', 'Error: Invalid regex pattern');
+        }
+        // Collect all files to search
+        const filesToSearch = await collectFiles(searchDir, filePattern, fileTypes, finalExcludeDirs, finalExcludeFiles);
+        if (filesToSearch.length === 0) {
+            return createToolResponse(true, [], 'No files found matching criteria');
+        }
+        // Search through files
+        const results = [];
+        let totalMatches = 0;
+        for (const filePath of filesToSearch) {
+            if (totalMatches >= maxResults) {
+                break;
+            }
+            try {
+                const content = await fs.promises.readFile(filePath, 'utf-8');
+                const lines = content.split('\n');
+                const fileMatches = [];
+                for (let i = 0; i < lines.length && totalMatches < maxResults; i++) {
+                    const line = lines[i];
+                    const matches = Array.from(line.matchAll(searchRegex));
+                    if (matches.length > 0) {
+                        const contextStart = Math.max(0, i - contextLines);
+                        const contextEnd = Math.min(lines.length - 1, i + contextLines);
+                        const contextLinesArray = [];
+                        for (let j = contextStart; j <= contextEnd; j++) {
+                            contextLinesArray.push(lines[j]);
+                        }
+                        fileMatches.push({
+                            lineNumber: i + 1,
+                            lineContent: line,
+                            contextLines: contextLines > 0 ? contextLinesArray : undefined,
+                            matchPositions: matches.map(match => ({
+                                start: match.index || 0,
+                                end: (match.index || 0) + match[0].length,
+                                text: match[0]
+                            }))
+                        });
+                        totalMatches++;
+                    }
+                }
+                if (fileMatches.length > 0) {
+                    results.push({
+                        filePath: path.relative(process.cwd(), filePath),
+                        matches: fileMatches,
+                        totalMatches: fileMatches.length
+                    });
+                }
+            }
+            catch (error) {
+                // Skip files that can't be read (binary files, permission issues, etc.)
+                continue;
+            }
+        }
+        // Format results
+        let formattedResults;
+        if (groupByFile) {
+            formattedResults = results;
+        }
+        else {
+            // Flatten results
+            formattedResults = results.flatMap(fileResult => fileResult.matches.map(match => ({
+                filePath: fileResult.filePath,
+                lineNumber: match.lineNumber,
+                lineContent: match.lineContent,
+                contextLines: match.contextLines,
+                matchPositions: match.matchPositions
+            })));
+        }
+        const message = `Found ${totalMatches} match(es) in ${results.length} file(s)`;
+        return createToolResponse(true, formattedResults, message);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', 'Error: Failed to search files');
+    }
+}
+// Helper function to escape regex special characters
+function escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// Helper function to collect files based on patterns and filters
+async function collectFiles(directory, filePattern, fileTypes, excludeDirs, excludeFiles) {
+    const files = [];
+    async function walkDirectory(dir) {
+        try {
+            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    // Check if directory should be excluded
+                    if (excludeDirs && excludeDirs.some(pattern => matchesPattern(entry.name, pattern))) {
+                        continue;
+                    }
+                    // Skip hidden directories unless explicitly included
+                    if (entry.name.startsWith('.') && !entry.name.match(/^\.(config|env)$/)) {
+                        continue;
+                    }
+                    await walkDirectory(fullPath);
+                }
+                else if (entry.isFile()) {
+                    // Check file type filters
+                    if (fileTypes && fileTypes.length > 0) {
+                        const ext = path.extname(entry.name).slice(1);
+                        if (!fileTypes.includes(ext)) {
+                            continue;
+                        }
+                    }
+                    // Check file pattern
+                    if (!matchesPattern(entry.name, filePattern)) {
+                        continue;
+                    }
+                    // Check exclusions
+                    if (excludeFiles && excludeFiles.some(pattern => matchesPattern(entry.name, pattern))) {
+                        continue;
+                    }
+                    // Skip obviously binary files
+                    if (isBinaryFile(entry.name)) {
+                        continue;
+                    }
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+        }
+    }
+    await walkDirectory(directory);
+    return files;
+}
+// Helper function to match glob-like patterns
+function matchesPattern(filename, pattern) {
+    if (pattern === '*')
+        return true;
+    // Simple glob matching, convert * to .* and ? to .
+    const regexPattern = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${regexPattern}$`, 'i').test(filename);
+}
+// Helper function to detect binary files
+function isBinaryFile(filename) {
+    const binaryExtensions = [
+        '.exe', '.dll', '.so', '.dylib', '.bin', '.obj', '.o', '.a', '.lib',
+        '.jpg', '.jpeg', '.png', '.gif', '.bmp', '.ico', '.svg', '.webp',
+        '.mp3', '.mp4', '.avi', '.mov', '.wmv', '.flv', '.webm',
+        '.zip', '.tar', '.gz', '.bz2', '.rar', '.7z',
+        '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx'
+    ];
+    const ext = path.extname(filename).toLowerCase();
+    return binaryExtensions.includes(ext);
+}
+/**
+ * Execute a shell command or run code
+ */
+export async function executeCommand(command, commandType, workingDirectory, timeout = 30000) {
+    try {
+        // Validate command type
+        if (!['bash', 'python', 'setup', 'run'].includes(commandType)) {
+            return createToolResponse(false, undefined, '', 'Error: Invalid command_type');
+        }
+        let originalCwd;
+        if (workingDirectory) {
+            const wdPath = path.resolve(workingDirectory);
+            const exists = await fs.promises.access(wdPath).then(() => true).catch(() => false);
+            if (!exists) {
+                return createToolResponse(false, undefined, '', 'Error: Working directory not found');
+            }
+            originalCwd = process.cwd();
+            process.chdir(workingDirectory);
+        }
+        try {
+            let execCommand;
+            if (commandType === 'python') {
+                execCommand = `python -c "${command.replace(/"/g, '\\"')}"`;
+            }
+            else {
+                execCommand = command;
+            }
+            const { stdout, stderr } = await execAsync(execCommand, { timeout });
+            const success = true; // If no error was thrown, consider it successful
+            return createToolResponse(success, `stdout: ${stdout}\nstderr: ${stderr}`, `Command executed successfully`);
+        }
+        finally {
+            // Restore original working directory
+            if (originalCwd) {
+                process.chdir(originalCwd);
+            }
+        }
+    }
+    catch (error) {
+        const isTimeout = error.killed && error.signal === 'SIGTERM';
+        if (isTimeout) {
+            return createToolResponse(false, undefined, '', 'Error: Command timed out');
+        }
+        return createToolResponse(false, undefined, '', 'Error: Failed to execute command');
+    }
+}
+/**
+ * Create a task list of subtasks to complete the user's request
+ */
+export async function createTasks(userQuery, tasks) {
+    try {
+        // Validate task structure
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            if (!task.id || !task.description) {
+                return createToolResponse(false, undefined, '', `Error: Task ${i} missing required fields (id, description)`);
+            }
+            // Set default status if not provided
+            if (!task.status) {
+                task.status = 'pending';
+            }
+            // Validate status
+            if (!['pending', 'in_progress', 'completed'].includes(task.status)) {
+                return createToolResponse(false, undefined, '', `Error: Invalid status '${task.status}' for task ${task.id}`);
+            }
+        }
+        // Store the task list globally
+        currentTaskList = {
+            user_query: userQuery,
+            tasks: tasks,
+            created_at: new Date().toISOString()
+        };
+        // Return a deep copy to prevent mutation of historical displays
+        const snapshot = {
+            user_query: currentTaskList.user_query,
+            tasks: currentTaskList.tasks.map(task => ({ ...task })),
+            created_at: currentTaskList.created_at
+        };
+        return createToolResponse(true, snapshot, `Created task list with ${tasks.length} tasks for: ${userQuery}`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Error: Failed to create tasks - ${error}`);
+    }
+}
+/**
+ * Update the status of one or more tasks in the task list
+ */
+export async function updateTasks(taskUpdates) {
+    try {
+        if (!currentTaskList) {
+            return createToolResponse(false, undefined, '', 'Error: No task list exists. Create tasks first.');
+        }
+        // Track updates made
+        const updatesMade = [];
+        for (const update of taskUpdates) {
+            if (!update.id || !update.status) {
+                return createToolResponse(false, undefined, '', 'Error: Task update missing required fields (id, status)');
+            }
+            // Validate status
+            if (!['pending', 'in_progress', 'completed'].includes(update.status)) {
+                return createToolResponse(false, undefined, '', `Error: Invalid status '${update.status}'`);
+            }
+            // Find and update the task
+            let taskFound = false;
+            for (const task of currentTaskList.tasks) {
+                if (task.id === update.id) {
+                    const oldStatus = task.status;
+                    task.status = update.status;
+                    // Add notes if provided
+                    if (update.notes) {
+                        task.notes = update.notes;
+                    }
+                    // Add update timestamp
+                    task.updated_at = new Date().toISOString();
+                    updatesMade.push({
+                        id: update.id,
+                        description: task.description,
+                        old_status: oldStatus,
+                        new_status: update.status
+                    });
+                    taskFound = true;
+                    break;
+                }
+            }
+            if (!taskFound) {
+                return createToolResponse(false, undefined, '', `Error: Task '${update.id}' not found`);
+            }
+        }
+        // Return a deep copy to prevent mutation of historical displays
+        const snapshot = {
+            user_query: currentTaskList.user_query,
+            tasks: currentTaskList.tasks.map(task => ({ ...task })),
+            created_at: currentTaskList.created_at
+        };
+        return createToolResponse(true, snapshot, `Updated ${updatesMade.length} task(s)`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Error: Failed to update tasks - ${error}`);
+    }
+}
+/**
+ * Find files matching a glob pattern
+ */
+export async function glob(pattern) {
+    try {
+        const files = await fg(pattern, {
+            ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/build/**'],
+            dot: true
+        });
+        return createToolResponse(true, files, `Found ${files.length} file(s) matching ${pattern}`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Glob error: ${error}`);
+    }
+}
+/**
+ * Search text in files using ripgrep
+ */
+export async function grep(pattern, include, context = 2, caseSensitive = false, directory = '.', fixedStrings = false) {
+    try {
+        const matches = await runRipGrep({
+            pattern,
+            directory,
+            include,
+            caseSensitive,
+            fixedStrings,
+            context
+        });
+        if (matches.length === 0) {
+            return createToolResponse(true, [], `No matches found for "${pattern}"`);
+        }
+        const wasTruncated = matches.length >= 1000;
+        const results = wasTruncated ? matches.slice(0, 1000) : matches;
+        const message = `Found ${matches.length} match(es)${wasTruncated ? ' (truncated to 1000)' : ''}`;
+        return createToolResponse(true, results, message);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Grep error: ${error}`);
+    }
+}
+/**
+ * Save a fact to the project's long-term memory (SORY.md)
+ */
+export async function saveMemory(fact) {
+    try {
+        const memoryFilePath = path.join(process.cwd(), 'SORY.md');
+        const timestamp = new Date().toISOString().split('T')[0];
+        const entry = `\n- [${timestamp}] ${fact}`;
+        let content = '';
+        if (fs.existsSync(memoryFilePath)) {
+            content = await fs.promises.readFile(memoryFilePath, 'utf-8');
+        }
+        if (!content.includes('# SORY MEMORY')) {
+            content = `# SORY MEMORY\nCette liste contient des faits importants mémorisés par l'IA pour ce projet.\n${content}`;
+        }
+        await fs.promises.writeFile(memoryFilePath, content + entry);
+        return createToolResponse(true, undefined, `J'ai mémorisé : "${fact}" dans SORY.md`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Erreur lors de la mémorisation : ${error}`);
+    }
+}
+/**
+ * Search Wikipedia (Free API)
+ */
+async function searchWikipedia(query) {
+    try {
+        const url = `https://fr.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&origin=*`;
+        const response = await fetch(url);
+        const data = await response.json();
+        return (data.query?.search || []).map((res) => ({
+            title: `[Wikipedia] ${res.title}`,
+            url: `https://fr.wikipedia.org/wiki/${encodeURIComponent(res.title)}`,
+            description: res.snippet.replace(/<[^>]*>/g, ''),
+            source: 'wikipedia'
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Search NPM Packages (Public API)
+ */
+async function searchNPM(query) {
+    try {
+        const url = `https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=5`;
+        const response = await fetch(url);
+        const data = await response.json();
+        return (data.objects || []).map((res) => ({
+            title: `[NPM Package] ${res.package.name} (v${res.package.version})`,
+            url: `https://www.npmjs.com/package/${res.package.name}`,
+            description: res.package.description,
+            source: 'npm'
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Search PyPI Packages (Python)
+ */
+async function searchPyPI(query) {
+    try {
+        const url = `https://pypi.org/pypi/${encodeURIComponent(query)}/json`;
+        const response = await fetch(url);
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return [{
+                title: `[PyPI Package] ${data.info.name} (v${data.info.version})`,
+                url: data.info.package_url,
+                description: data.info.summary,
+                source: 'pypi'
+            }];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Search GitHub with high inclusivity and version detection
+ */
+/**
+ * Search GitHub with high inclusivity and version detection
+ */
+async function searchGitHub(query) {
+    const results = [];
+    try {
+        // Nettoyage léger pour ne pas casser la recherche
+        const q = query.replace(/cli|version|dernier|latest/gi, '').trim();
+        // Recherche de dépôts par nom, description ou readme
+        const url = `https://api.github.com/search/repositories?q=${encodeURIComponent(q)}+in:name,description&sort=stars&order=desc&per_page=10`;
+        const response = await fetch(url, {
+            headers: {
+                'Accept': 'application/vnd.github.v3+json',
+                'User-Agent': 'Mozilla/5.0 (Sory-CLI)'
+            }
+        });
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        if (data.items) {
+            for (const repo of data.items) {
+                results.push({
+                    title: `[GitHub Repo] ${repo.full_name}`,
+                    url: repo.html_url,
+                    description: repo.description || "Pas de description disponible.",
+                    source: 'github'
+                });
+                // Tentative de récupération de la version si mentionnée
+                if (query.toLowerCase().match(/version|dernier|latest/)) {
+                    try {
+                        const relUrl = `https://api.github.com/repos/${repo.full_name}/releases/latest`;
+                        const relRes = await fetch(relUrl, { headers: { 'User-Agent': 'Sory-CLI' } });
+                        if (relRes.ok) {
+                            const relData = await relRes.json();
+                            results.push({
+                                title: `[GitHub Release] ${repo.full_name} ${relData.tag_name}`,
+                                url: relData.html_url,
+                                description: `Version : ${relData.name || relData.tag_name}. Publiée le ${new Date(relData.published_at).toLocaleDateString('fr-FR')}`,
+                                source: 'github'
+                            });
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+    }
+    catch { /* ignore error */ }
+    return results;
+}
+/**
+ * Search the web using multiple sources with technical prioritization and manual override
+ */
+export async function googleWebSearch(query, source = 'auto') {
+    try {
+        const isTechnical = /code|api|repo|git|version|framework|lib|package|software|install|dernier|cli|opencode/i.test(query);
+        let github = [], npm = [], pypi = [], wiki = [], ddg = [];
+        // Lancer toutes les sources spécialisées + web en parallèle
+        const tasks = [];
+        if (source === 'github' || source === 'auto')
+            tasks.push(searchGitHub(query).then(res => github = res));
+        if (source === 'npm' || source === 'auto')
+            tasks.push(searchNPM(query).then(res => npm = res));
+        if (source === 'pypi' || source === 'auto')
+            tasks.push(searchPyPI(query).then(res => pypi = res));
+        if (source === 'wikipedia' || source === 'auto')
+            tasks.push(searchWikipedia(query).then(res => wiki = res));
+        if (source === 'web' || source === 'auto')
+            tasks.push(fetchDuckDuckGo(query, isTechnical).then(res => ddg = res));
+        await Promise.all(tasks);
+        // Fusion intelligente : Priorité absolue aux paquets et repos
+        let combined = [...npm, ...github, ...pypi, ...ddg, ...wiki];
+        // Supprimer les doublons et filtrage drastique du bruit
+        const seenUrls = new Set();
+        combined = combined.filter(res => {
+            if (!res.url || seenUrls.has(res.url))
+                return false;
+            seenUrls.add(res.url);
+            // Si c'est une recherche technique et qu'on a des résultats tech, on vire le Wikipedia générique
+            if (res.source === 'wikipedia' && isTechnical && (github.length > 0 || npm.length > 0 || ddg.some(d => d.url.includes('github') || d.url.includes('npm')))) {
+                const queryLower = query.toLowerCase();
+                const firstWord = queryLower.split(' ')[0];
+                // On ne garde Wikipedia que si le titre correspond vraiment à l'outil
+                if (!res.title.toLowerCase().includes(firstWord))
+                    return false;
+            }
+            return true;
+        });
+        if (combined.length === 0) {
+            return createToolResponse(true, [], `Désolé, aucune information trouvée pour "${query}".`);
+        }
+        const sourceMsg = source === 'auto' ? "Analyse multi-sources" : `Recherche ciblée ${source.toUpperCase()}`;
+        return createToolResponse(true, combined.slice(0, 10), `${sourceMsg} pour "${query}"`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Erreur de recherche technique : ${error}`);
+    }
+}
+/**
+ * Enhanced DuckDuckGo Scraper with site-specific capabilities
+ */
+async function fetchDuckDuckGo(query, prioritizeTech) {
+    try {
+        // Si c'est technique, on ajoute des sites de confiance à la recherche
+        const enhancedQuery = prioritizeTech
+            ? `${query} (site:github.com OR site:npmjs.com OR site:pypi.org OR site:stackoverflow.com)`
+            : query;
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(enhancedQuery)}`;
+        const response = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8'
+            }
+        });
+        if (!response.ok)
+            return [];
+        const html = await response.text();
+        const results = [];
+        const resultRegex = /<a class="result__a" href="([^"]+)">([^<]+)<\/a>/g;
+        let match;
+        while ((match = resultRegex.exec(html)) !== null && results.length < 8) {
+            let link = match[1];
+            if (link.includes('uddg=')) {
+                const parts = link.split('uddg=');
+                if (parts[1])
+                    link = decodeURIComponent(parts[1].split('&')[0]);
+            }
+            if (!link.includes('w3.org') && !link.includes('dtd')) {
+                results.push({
+                    title: match[2].trim(),
+                    url: link,
+                    source: 'web'
+                });
+            }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Fetch and extract text from a website
+ */
+export async function webFetch(url) {
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+            },
+            redirect: 'follow'
+        });
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        const html = await response.text();
+        const text = convert(html, {
+            wordwrap: 130,
+            selectors: [
+                { selector: 'a', options: { ignoreHref: true } },
+                { selector: 'img', format: 'skip' },
+                { selector: 'nav', format: 'skip' },
+                { selector: 'footer', format: 'skip' },
+                { selector: 'script', format: 'skip' },
+                { selector: 'style', format: 'skip' }
+            ]
+        });
+        const cleanText = text.substring(0, 15000); // Augmentation de la limite à 15k
+        return createToolResponse(true, cleanText, `Contenu extrait de ${url}`);
+    }
+    catch (error) {
+        return createToolResponse(false, undefined, '', `Erreur de lecture web : ${error}`);
+    }
+}
+// Tool Registry: maps tool names to functions
+export const TOOL_REGISTRY = {
+    read_file: readFile,
+    create_file: createFile,
+    edit_file: editFile,
+    delete_file: deleteFile,
+    list_files: listFiles,
+    search_files: searchFiles,
+    execute_command: executeCommand,
+    create_tasks: createTasks,
+    update_tasks: updateTasks,
+    grep: grep,
+    glob: glob,
+    read_many_files: readManyFiles,
+    save_memory: saveMemory,
+    google_web_search: googleWebSearch,
+    web_fetch: webFetch,
+};
+/**
+ * Execute a tool by name with given arguments
+ */
+export async function executeTool(toolName, toolArgs) {
+    if (!(toolName in TOOL_REGISTRY)) {
+        return createToolResponse(false, undefined, '', 'Error: Unknown tool');
+    }
+    try {
+        const toolFunction = TOOL_REGISTRY[toolName];
+        // Call the function with the appropriate arguments based on the tool
+        switch (toolName) {
+            case 'read_file':
+                return await toolFunction(toolArgs.file_path, toolArgs.start_line, toolArgs.end_line);
+            case 'read_many_files':
+                return await toolFunction(toolArgs.file_paths);
+            case 'create_file':
+                return await toolFunction(toolArgs.file_path, toolArgs.content, toolArgs.file_type, toolArgs.overwrite);
+            case 'edit_file':
+                const oldText = toolArgs.old_string || toolArgs.old_text;
+                const newText = toolArgs.new_string || toolArgs.new_text;
+                const expected = toolArgs.expected_replacements !== undefined
+                    ? toolArgs.expected_replacements
+                    : (toolArgs.replace_all ? 0 : 1);
+                return await toolFunction(toolArgs.file_path, oldText, newText, expected);
+            case 'delete_file':
+                return await toolFunction(toolArgs.file_path, toolArgs.recursive);
+            case 'list_files':
+                return await toolFunction(toolArgs.directory, toolArgs.pattern, toolArgs.recursive, toolArgs.show_hidden);
+            case 'search_files':
+                return await toolFunction(toolArgs.pattern, toolArgs.file_pattern, toolArgs.directory, toolArgs.case_sensitive, toolArgs.pattern_type, toolArgs.file_types, toolArgs.exclude_dirs, toolArgs.exclude_files, toolArgs.max_results, toolArgs.context_lines, toolArgs.group_by_file);
+            case 'execute_command':
+                return await toolFunction(toolArgs.command, toolArgs.command_type, toolArgs.working_directory, toolArgs.timeout);
+            case 'create_tasks':
+                return await toolFunction(toolArgs.user_query, toolArgs.tasks);
+            case 'update_tasks':
+                return await toolFunction(toolArgs.task_updates);
+            case 'grep':
+                return await toolFunction(toolArgs.pattern, toolArgs.include, toolArgs.context, toolArgs.case_sensitive, toolArgs.dir_path || toolArgs.directory || '.', toolArgs.fixed_strings);
+            case 'glob':
+                return await toolFunction(toolArgs.pattern);
+            case 'save_memory':
+                return await toolFunction(toolArgs.fact);
+            case 'google_web_search':
+                return await toolFunction(toolArgs.query, toolArgs.source);
+            case 'web_fetch':
+                return await toolFunction(toolArgs.url);
+            default:
+                return createToolResponse(false, undefined, '', 'Error: Tool not implemented');
+        }
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            return createToolResponse(false, undefined, '', 'Error: Invalid tool arguments');
+        }
+        return createToolResponse(false, undefined, '', 'Error: Unexpected tool error');
+    }
+}
+//# sourceMappingURL=tools.js.map