atena-cli 0.1.0

package/dist/tools/index.js

@@ -0,0 +1,2139 @@
+import { promises as fs } from 'node:fs';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { slackTools } from './slack.js';
+import { googleTools } from './google.js';
+import { githubTools } from './github.js';
+import { discordTools } from './discord.js';
+import { telegramTools } from './telegram.js';
+import { colors } from '../ui.js';
+// File operations tool
+const readFileTool = {
+    definition: {
+        name: 'read_file',
+        description: 'Read the contents of a file at the specified path. Returns the file content as text.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path to the file to read',
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Optional line offset to start reading from (1-indexed)',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional maximum number of lines to read',
+                },
+            },
+            required: ['file_path'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const filePath = String(args.file_path);
+            const offset = args.offset ? Number(args.offset) : undefined;
+            const limit = args.limit ? Number(args.limit) : undefined;
+            let content = await fs.readFile(filePath, 'utf8');
+            if (offset !== undefined || limit !== undefined) {
+                const lines = content.split('\n');
+                const start = offset ? Math.max(0, offset - 1) : 0;
+                const end = limit ? Math.min(lines.length, start + limit) : lines.length;
+                content = lines.slice(start, end).join('\n');
+            }
+            return {
+                status: 'success',
+                output: content,
+                metadata: { file_path: filePath },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Write file tool
+const writeFileTool = {
+    definition: {
+        name: 'write_file',
+        description: 'Write content to a file at the specified path. Creates the file if it does not exist.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path to the file to write',
+                },
+                content: {
+                    type: 'string',
+                    description: 'The content to write to the file',
+                },
+            },
+            required: ['file_path', 'content'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            let filePath = String(args.file_path);
+            const content = String(args.content);
+            // Fix paths that reference non-existent home directories
+            if (filePath.startsWith('/home/user') || filePath.startsWith('/root')) {
+                const relativePath = filePath.replace(/^\/home\/user\//, '').replace(/^\/root\//, '');
+                filePath = path.join(process.cwd(), relativePath);
+            }
+            // Ensure directory exists
+            const dir = path.dirname(filePath);
+            try {
+                await fs.mkdir(dir, { recursive: true });
+            }
+            catch (mkdirErr) {
+                // If we can't create the directory, fallback to current directory
+                if (mkdirErr.code === 'EACCES' || mkdirErr.code === 'EPERM') {
+                    const basename = path.basename(filePath);
+                    filePath = path.join(process.cwd(), basename);
+                }
+            }
+            await fs.writeFile(filePath, content, 'utf8');
+            return {
+                status: 'success',
+                output: `File written successfully: ${filePath}`,
+                metadata: { file_path: filePath, bytes: content.length },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Edit file tool (search and replace)
+const editFileTool = {
+    definition: {
+        name: 'edit_file',
+        description: 'Edit a file by replacing occurrences of old_string with new_string.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The absolute path to the file to edit',
+                },
+                old_string: {
+                    type: 'string',
+                    description: 'The text to search for and replace',
+                },
+                new_string: {
+                    type: 'string',
+                    description: 'The replacement text',
+                },
+                replace_all: {
+                    type: 'boolean',
+                    description: 'If true, replace all occurrences instead of just the first one',
+                },
+            },
+            required: ['file_path', 'old_string', 'new_string'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const filePath = String(args.file_path);
+            const oldString = String(args.old_string);
+            const newString = String(args.new_string);
+            const replaceAll = Boolean(args.replace_all);
+            const content = await fs.readFile(filePath, 'utf8');
+            if (!content.includes(oldString)) {
+                return {
+                    status: 'error',
+                    error: `Could not find the string to replace in ${filePath}`,
+                };
+            }
+            const newContent = replaceAll
+                ? content.split(oldString).join(newString)
+                : content.replace(oldString, newString);
+            await fs.writeFile(filePath, newContent, 'utf8');
+            return {
+                status: 'success',
+                output: `File edited successfully: ${filePath}`,
+                metadata: { file_path: filePath, replacements: replaceAll ? 'all' : 'first' },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// List directory tool
+const listDirTool = {
+    definition: {
+        name: 'list_dir',
+        description: 'List files and directories at the specified path. Returns file names, sizes, and modification times.',
+        parameters: {
+            type: 'object',
+            properties: {
+                directory_path: {
+                    type: 'string',
+                    description: 'The absolute path to the directory to list',
+                },
+                recursive: {
+                    type: 'boolean',
+                    description: 'If true, list recursively',
+                },
+            },
+            required: ['directory_path'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const dirPath = String(args.directory_path);
+            const recursive = Boolean(args.recursive);
+            const entries = [];
+            if (recursive) {
+                const walk = async (currentPath, prefix) => {
+                    const items = await fs.readdir(currentPath, { withFileTypes: true });
+                    for (const item of items) {
+                        const fullPath = path.join(currentPath, item.name);
+                        const stat = await fs.stat(fullPath);
+                        const size = stat.isFile() ? ` (${stat.size} bytes)` : ' (dir)';
+                        entries.push(`${prefix}${item.name}${size}`);
+                        if (item.isDirectory()) {
+                            await walk(fullPath, prefix + '  ');
+                        }
+                    }
+                };
+                await walk(dirPath, '');
+            }
+            else {
+                const items = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const item of items) {
+                    const fullPath = path.join(dirPath, item.name);
+                    const stat = await fs.stat(fullPath);
+                    const size = stat.isFile() ? ` (${stat.size} bytes)` : ' (dir)';
+                    entries.push(`${item.name}${size}`);
+                }
+            }
+            return {
+                status: 'success',
+                output: entries.join('\n'),
+                metadata: { directory: dirPath, count: entries.length },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Grep search tool
+const grepSearchTool = {
+    definition: {
+        name: 'grep_search',
+        description: 'Search for text patterns in files using ripgrep-style matching.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search pattern or text to find',
+                },
+                path: {
+                    type: 'string',
+                    description: 'The directory or file path to search in',
+                },
+                file_pattern: {
+                    type: 'string',
+                    description: 'Optional glob pattern to filter files (e.g., "*.ts", "*.js")',
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'If false, perform case-insensitive search',
+                },
+                fixed_strings: {
+                    type: 'boolean',
+                    description: 'If true, treat query as literal string instead of regex',
+                },
+            },
+            required: ['query', 'path'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const query = String(args.query);
+            const searchPath = String(args.path);
+            const filePattern = args.file_pattern ? String(args.file_pattern) : undefined;
+            const caseSensitive = args.case_sensitive !== false;
+            const fixedStrings = Boolean(args.fixed_strings);
+            // Build grep/ripgrep command
+            const args_list = [];
+            if (!caseSensitive)
+                args_list.push('-i');
+            if (fixedStrings)
+                args_list.push('-F');
+            if (filePattern) {
+                args_list.push('--include', filePattern);
+            }
+            args_list.push(query, searchPath);
+            const result = execSync(`rg ${args_list.join(' ')} 2>/dev/null || grep -r ${args_list.join(' ')} 2>/dev/null || echo "No matches found"`, {
+                encoding: 'utf8',
+                maxBuffer: 1024 * 1024,
+            });
+            const lines = result.trim().split('\n').filter(Boolean);
+            const truncated = lines.length > 50;
+            const output = truncated ? lines.slice(0, 50).join('\n') + '\n... (truncated)' : result;
+            return {
+                status: 'success',
+                output,
+                metadata: {
+                    matches: lines.length,
+                    truncated,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Run command tool - improved with better output handling and suggestions
+const runCommandTool = {
+    definition: {
+        name: 'run_command',
+        description: 'Execute a shell command. Returns stdout and stderr output. Shows suggestions if command fails or has no output.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The command to execute',
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Optional working directory for the command',
+                },
+                timeout_sec: {
+                    type: 'number',
+                    description: 'Optional timeout in seconds (default: 60)',
+                },
+            },
+            required: ['command'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const command = String(args.command);
+            const cwd = args.cwd ? String(args.cwd) : process.cwd();
+            const timeoutSec = args.timeout_sec ? Number(args.timeout_sec) : 60;
+            return new Promise((resolve) => {
+                // Stop spinner so we don't clobber live output
+                console.log(); // Add a newline before output
+                const child = spawn('bash', ['-c', command], {
+                    cwd,
+                    stdio: ['inherit', 'pipe', 'pipe'],
+                });
+                let stdout = '';
+                let stderr = '';
+                let timeout = null;
+                if (timeoutSec > 0) {
+                    timeout = setTimeout(() => {
+                        child.kill('SIGTERM');
+                        setTimeout(() => {
+                            if (!child.killed)
+                                child.kill('SIGKILL');
+                        }, 5000);
+                    }, timeoutSec * 1000);
+                }
+                child.stdout?.on('data', (data) => {
+                    process.stdout.write(colors.muted(String(data)));
+                    stdout += String(data);
+                });
+                child.stderr?.on('data', (data) => {
+                    process.stderr.write(colors.error(String(data)));
+                    stderr += String(data);
+                });
+                child.on('close', (code) => {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    console.log(); // End visual block of command stream
+                    const isError = code !== 0;
+                    const hasStdout = stdout.trim().length > 0;
+                    const hasStderr = stderr.trim().length > 0;
+                    // Build comprehensive output
+                    let output = '';
+                    let suggestions = [];
+                    if (hasStdout) {
+                        output += stdout;
+                    }
+                    if (hasStderr) {
+                        if (output)
+                            output += '\n\n';
+                        output += `STDERR:\n${stderr}`;
+                    }
+                    // Handle silent success cases (mkdir, touch, etc.)
+                    if (!isError && !hasStdout && !hasStderr) {
+                        // Check what command was run and provide context
+                        const cmdBase = command.trim().split(' ')[0];
+                        const silentCommands = ['mkdir', 'touch', 'rm', 'cp', 'mv', 'chmod', 'chown'];
+                        if (silentCommands.includes(cmdBase)) {
+                            output = `✓ Comando ejecutado exitosamente (sin output)`;
+                            // Show what was created/modified
+                            if (cmdBase === 'mkdir') {
+                                const match = command.match(/mkdir\s+-?p?\s+(.*)/);
+                                if (match) {
+                                    output += `\nDirectorios creados: ${match[1]}`;
+                                }
+                            }
+                        }
+                        else {
+                            output = '(comando completado sin output)';
+                        }
+                    }
+                    // Generate suggestions for common errors
+                    if (isError) {
+                        const errorText = stderr.toLowerCase();
+                        if (errorText.includes('command not found') || errorText.includes('no such file')) {
+                            suggestions.push('Verifica que el comando esté instalado: `which <comando>`');
+                            suggestions.push('Alternativa: Instala con tu package manager (apt, npm, etc.)');
+                        }
+                        if (errorText.includes('permission denied') || errorText.includes('eacces')) {
+                            suggestions.push('Intenta con sudo o verifica permisos: `ls -la`');
+                            suggestions.push('Alternativa: Cambia permisos con `chmod` o cambia de directorio');
+                        }
+                        if (errorText.includes('file exists') || errorText.includes('eexist')) {
+                            suggestions.push('El archivo/directorio ya existe');
+                            suggestions.push('Alternativa: Usa `-f` (force) o elimina primero con `rm`');
+                        }
+                        if (errorText.includes('no such file or directory')) {
+                            suggestions.push('Verifica que la ruta existe con `ls -la`');
+                            suggestions.push('Alternativa: Crea directorios padre primero con `mkdir -p`');
+                        }
+                        if (errorText.includes('connection refused') || errorText.includes('timeout')) {
+                            suggestions.push('Verifica conectividad de red');
+                            suggestions.push('Alternativa: Revisa firewall o intenta más tarde');
+                        }
+                        if (suggestions.length === 0) {
+                            suggestions.push('Verifica el comando con `--help` o man pages');
+                            suggestions.push('Alternativa: Busca ejemplos en documentación oficial');
+                        }
+                    }
+                    // Build final response
+                    let finalOutput = output;
+                    if (suggestions.length > 0) {
+                        finalOutput += '\n\n💡 Sugerencias:\n' + suggestions.map(s => `  • ${s}`).join('\n');
+                    }
+                    resolve({
+                        status: isError ? 'error' : 'success',
+                        output: finalOutput || '(no output)',
+                        error: isError ? `Exit code: ${code}` : undefined,
+                        metadata: {
+                            exit_code: code,
+                            stdout_length: stdout.length,
+                            stderr_length: stderr.length,
+                            command: command.slice(0, 100), // Truncate for safety
+                            suggestions_count: suggestions.length,
+                        },
+                    });
+                });
+                child.on('error', (err) => {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    resolve({
+                        status: 'error',
+                        output: '',
+                        error: `Failed to execute: ${err.message}\n\n💡 Sugerencias:\n  • Verifica que el shell esté disponible\n  • Alternativa: Intenta con el comando completo (ej: /bin/ls)`,
+                    });
+                });
+            });
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                output: '',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Find files by name tool
+const findByNameTool = {
+    definition: {
+        name: 'find_by_name',
+        description: 'Find files and directories by name pattern.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'The glob pattern to match (e.g., "*.ts", "package.json")',
+                },
+                directory: {
+                    type: 'string',
+                    description: 'The directory to search in',
+                },
+                max_depth: {
+                    type: 'number',
+                    description: 'Maximum directory depth to search',
+                },
+            },
+            required: ['pattern', 'directory'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const pattern = String(args.pattern);
+            const directory = String(args.directory);
+            const maxDepth = args.max_depth ? Number(args.max_depth) : undefined;
+            let command = `find "${directory}" -name "${pattern}" -type f`;
+            if (maxDepth) {
+                command += ` -maxdepth ${maxDepth}`;
+            }
+            const result = execSync(command, { encoding: 'utf8' });
+            const files = result.trim().split('\n').filter(Boolean);
+            return {
+                status: 'success',
+                output: files.join('\n') || '(no files found)',
+                metadata: { count: files.length },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// View URL content tool
+const viewUrlTool = {
+    definition: {
+        name: 'view_url',
+        description: 'Fetch and view content from a URL.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL to fetch',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const url = String(args.url);
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const content = await response.text();
+            const truncated = content.length > 10000;
+            const output = truncated ? content.slice(0, 10000) + '\n... (truncated)' : content;
+            return {
+                status: 'success',
+                output,
+                metadata: {
+                    url,
+                    content_type: response.headers.get('content-type'),
+                    content_length: content.length,
+                    truncated,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Ask user question tool
+const askUserTool = {
+    definition: {
+        name: 'ask_user',
+        description: 'Ask the user a question with predefined options.',
+        parameters: {
+            type: 'object',
+            properties: {
+                question: {
+                    type: 'string',
+                    description: 'The question to ask',
+                },
+                options: {
+                    type: 'array',
+                    description: 'Array of option objects with label and description',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            label: { type: 'string' },
+                            description: { type: 'string' },
+                        },
+                    },
+                },
+                allow_multiple: {
+                    type: 'boolean',
+                    description: 'Allow selecting multiple options',
+                },
+            },
+            required: ['question', 'options'],
+        },
+    },
+    handler: (args) => {
+        const question = String(args.question);
+        const options = Array.isArray(args.options) ? args.options : [];
+        const allowMultiple = Boolean(args.allow_multiple);
+        const formatted = options.map((opt, i) => {
+            const o = opt;
+            return `${i + 1}. ${o.label || '?'}: ${o.description || ''}`;
+        }).join('\n');
+        return {
+            status: 'success',
+            output: `USER QUESTION: ${question}\n\nOptions (${allowMultiple ? 'select multiple' : 'select one'}):\n${formatted}\n\nPlease respond with the number(s) of your choice.`,
+            metadata: { requires_user_input: true },
+        };
+    },
+};
+// Create memory tool
+const createMemoryTool = {
+    definition: {
+        name: 'create_memory',
+        description: 'Save important context to the memory database.',
+        parameters: {
+            type: 'object',
+            properties: {
+                content: {
+                    type: 'string',
+                    description: 'The content to remember',
+                },
+                tags: {
+                    type: 'array',
+                    description: 'Tags to associate with the memory',
+                    items: { type: 'string' },
+                },
+                title: {
+                    type: 'string',
+                    description: 'Title for the memory',
+                },
+            },
+            required: ['content', 'title'],
+        },
+    },
+    handler: (args) => {
+        const content = String(args.content);
+        const title = String(args.title);
+        const tags = Array.isArray(args.tags) ? args.tags : [];
+        // In a real implementation, this would write to a database
+        // For now, we just acknowledge the memory was created
+        return {
+            status: 'success',
+            output: `Memory saved: "${title}"\n\n${content}\n\nTags: ${tags.join(', ') || 'none'}`,
+            metadata: { title, tags },
+        };
+    },
+};
+// Vision/Image analysis tool - analyze images using Ollama vision models
+const analyzeImageTool = {
+    definition: {
+        name: 'analyze_image',
+        description: 'Analyze an image file using vision AI. Returns a description of what the image contains.',
+        parameters: {
+            type: 'object',
+            properties: {
+                image_path: {
+                    type: 'string',
+                    description: 'The absolute path to the image file',
+                },
+                prompt: {
+                    type: 'string',
+                    description: 'Optional specific question about the image (default: "Describe this image in detail")',
+                },
+            },
+            required: ['image_path'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const imagePath = String(args.image_path);
+            const prompt = args.prompt ? String(args.prompt) : 'Describe this image in detail';
+            // Read image as base64
+            const imageBuffer = await fs.readFile(imagePath);
+            const base64Image = imageBuffer.toString('base64');
+            // Determine mime type from extension
+            const ext = path.extname(imagePath).toLowerCase();
+            const mimeType = ext === '.png' ? 'image/png' :
+                ext === '.gif' ? 'image/gif' :
+                    ext === '.webp' ? 'image/webp' : 'image/jpeg';
+            // Call Ollama with vision capabilities
+            const ollamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+            const model = process.env.VISION_MODEL || 'llava';
+            const response = await fetch(`${ollamaUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model,
+                    prompt,
+                    images: [base64Image],
+                    stream: false,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status}`);
+            }
+            const result = await response.json();
+            return {
+                status: 'success',
+                output: result.response,
+                metadata: { image_path: imagePath, model, prompt },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Text embedding tool - generate embeddings for text similarity
+const embeddingTool = {
+    definition: {
+        name: 'generate_embedding',
+        description: 'Generate vector embeddings for text using Ollama. Useful for semantic search and similarity comparisons.',
+        parameters: {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'The text to generate embeddings for',
+                },
+                model: {
+                    type: 'string',
+                    description: 'Embedding model to use (default: nomic-embed-text)',
+                },
+            },
+            required: ['text'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const text = String(args.text);
+            const model = args.model ? String(args.model) : 'nomic-embed-text';
+            const ollamaUrl = process.env.OLLAMA_HOST || 'http://localhost:11434';
+            const response = await fetch(`${ollamaUrl}/api/embeddings`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model,
+                    prompt: text,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`Ollama API error: ${response.status}`);
+            }
+            const result = await response.json();
+            return {
+                status: 'success',
+                output: `Generated ${result.embedding.length} dimensional embedding`,
+                metadata: {
+                    embedding: result.embedding,
+                    dimensions: result.embedding.length,
+                    model,
+                    text_preview: text.slice(0, 100) + (text.length > 100 ? '...' : ''),
+                },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Web search/research tool - search the web using various search APIs
+const webSearchTool = {
+    definition: {
+        name: 'web_search',
+        description: 'Search the web for information. Uses DuckDuckGo or other search providers.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The search query',
+                },
+                num_results: {
+                    type: 'number',
+                    description: 'Number of results to return (default: 5, max: 10)',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const query = encodeURIComponent(String(args.query));
+            const numResults = Math.min(args.num_results ? Number(args.num_results) : 5, 10);
+            // Try DuckDuckGo HTML first
+            try {
+                const response = await fetch(`https://html.duckduckgo.com/html/?q=${query}`, {
+                    headers: {
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                    },
+                });
+                if (response.ok) {
+                    const html = await response.text();
+                    // Parse results from HTML
+                    const results = [];
+                    // Simple regex-based extraction
+                    const resultBlocks = html.match(/<div class="result[^"]*">[\s\S]*?<\/div>/g) || [];
+                    for (const block of resultBlocks.slice(0, numResults)) {
+                        const titleMatch = block.match(/<a[^>]*class="result__a"[^>]*>([\s\S]*?)<\/a>/);
+                        const urlMatch = block.match(/<a[^>]*href="([^"]*)"/);
+                        const snippetMatch = block.match(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/);
+                        if (titleMatch && urlMatch) {
+                            results.push({
+                                title: titleMatch[1].replace(/<[^>]*>/g, '').trim(),
+                                url: urlMatch[1],
+                                snippet: snippetMatch ? snippetMatch[1].replace(/<[^>]*>/g, '').trim() : '',
+                            });
+                        }
+                    }
+                    if (results.length > 0) {
+                        const formatted = results.map((r, i) => `${i + 1}. ${r.title}\n   URL: ${r.url}\n   ${r.snippet}`).join('\n\n');
+                        return {
+                            status: 'success',
+                            output: formatted,
+                            metadata: { results_count: results.length, source: 'duckduckgo' },
+                        };
+                    }
+                }
+            }
+            catch {
+                // Fallback to alternative search or error
+            }
+            return {
+                status: 'error',
+                error: 'Web search failed. The search service may be unavailable or rate-limited.',
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Browser automation tool - fetch and extract content from web pages
+const browserTool = {
+    definition: {
+        name: 'browse_webpage',
+        description: 'Fetch a webpage and extract its main content, removing ads and navigation. Useful for reading articles.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL to browse',
+                },
+                extract_main_content: {
+                    type: 'boolean',
+                    description: 'Extract main content only (default: true)',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const url = String(args.url);
+            const extractMain = args.extract_main_content !== false;
+            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,*/*;q=0.8',
+                    'Accept-Language': 'en-US,en;q=0.5',
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const html = await response.text();
+            if (!extractMain) {
+                // Return raw HTML (truncated)
+                const truncated = html.length > 10000 ? html.slice(0, 10000) + '\n... (truncated)' : html;
+                return {
+                    status: 'success',
+                    output: truncated,
+                    metadata: { url, content_length: html.length, truncated: html.length > 10000 },
+                };
+            }
+            // Extract title
+            const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+            const title = titleMatch ? titleMatch[1].trim() : 'No title';
+            // Extract main content - remove scripts, styles, nav, etc.
+            let content = html
+                .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, '')
+                .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, '')
+                .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, '')
+                .replace(/<aside[^>]*>[\s\S]*?<\/aside>/gi, '')
+                .replace(/<[^>]*>/g, ' ') // Remove remaining tags
+                .replace(/\s+/g, ' ') // Normalize whitespace
+                .trim();
+            // Truncate if too long
+            const maxLength = 8000;
+            const truncated = content.length > maxLength;
+            if (truncated) {
+                content = content.slice(0, maxLength) + '\n... (content truncated)';
+            }
+            return {
+                status: 'success',
+                output: `Title: ${title}\n\nContent:\n${content}`,
+                metadata: {
+                    url,
+                    title,
+                    content_length: content.length,
+                    truncated,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Code execution tool - run code in various languages
+const codeExecutionTool = {
+    definition: {
+        name: 'execute_code',
+        description: 'Execute code in various programming languages (JavaScript, Python, Bash). Returns stdout, stderr, and exit code.',
+        parameters: {
+            type: 'object',
+            properties: {
+                code: {
+                    type: 'string',
+                    description: 'The code to execute',
+                },
+                language: {
+                    type: 'string',
+                    description: 'Programming language (javascript, python, bash/shell)',
+                    enum: ['javascript', 'python', 'bash', 'shell'],
+                },
+                timeout_sec: {
+                    type: 'number',
+                    description: 'Timeout in seconds (default: 30)',
+                },
+            },
+            required: ['code', 'language'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const code = String(args.code);
+            const language = String(args.language).toLowerCase();
+            const timeoutSec = args.timeout_sec ? Number(args.timeout_sec) : 30;
+            let command;
+            let args_list;
+            switch (language) {
+                case 'javascript':
+                case 'js':
+                    command = 'node';
+                    args_list = ['-e', code];
+                    break;
+                case 'python':
+                case 'py':
+                    command = 'python3';
+                    args_list = ['-c', code];
+                    break;
+                case 'bash':
+                case 'shell':
+                case 'sh':
+                    command = 'bash';
+                    args_list = ['-c', code];
+                    break;
+                default:
+                    return {
+                        status: 'error',
+                        error: `Unsupported language: ${language}. Supported: javascript, python, bash`,
+                    };
+            }
+            return new Promise((resolve) => {
+                const child = spawn(command, args_list, {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                let stdout = '';
+                let stderr = '';
+                let timeout = null;
+                if (timeoutSec > 0) {
+                    timeout = setTimeout(() => {
+                        child.kill('SIGTERM');
+                        setTimeout(() => {
+                            if (!child.killed)
+                                child.kill('SIGKILL');
+                        }, 5000);
+                    }, timeoutSec * 1000);
+                }
+                child.stdout?.on('data', (data) => {
+                    stdout += String(data);
+                });
+                child.stderr?.on('data', (data) => {
+                    stderr += String(data);
+                });
+                child.on('close', (code) => {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    const output = stdout || stderr || '(no output)';
+                    const isError = code !== 0;
+                    resolve({
+                        status: isError ? 'error' : 'success',
+                        output,
+                        error: isError ? `Exit code: ${code}${stderr ? '\n' + stderr : ''}` : undefined,
+                        metadata: {
+                            language,
+                            exit_code: code,
+                            stdout_length: stdout.length,
+                            stderr_length: stderr.length,
+                        },
+                    });
+                });
+                child.on('error', (err) => {
+                    if (timeout)
+                        clearTimeout(timeout);
+                    resolve({
+                        status: 'error',
+                        error: `Failed to execute: ${err.message}`,
+                    });
+                });
+            });
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Semantic search tool - search within files using embeddings
+const semanticSearchTool = {
+    definition: {
+        name: 'semantic_search',
+        description: 'Search for semantically similar content in files. Uses embeddings to find conceptually related content, not just keyword matches.',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The semantic query (what concept you are looking for)',
+                },
+                directory: {
+                    type: 'string',
+                    description: 'Directory to search in',
+                },
+                file_pattern: {
+                    type: 'string',
+                    description: 'File pattern to limit search (e.g., "*.md", "*.txt")',
+                },
+                top_k: {
+                    type: 'number',
+                    description: 'Number of top results to return (default: 5)',
+                },
+            },
+            required: ['query', 'directory'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const query = String(args.query);
+            const directory = String(args.directory);
+            const filePattern = args.file_pattern ? String(args.file_pattern) : '*';
+            const topK = args.top_k ? Number(args.top_k) : 5;
+            // For now, fallback to grep-based semantic-ish search
+            // In a full implementation, this would use embeddings
+            const keywords = query.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+            const pattern = keywords.join('|');
+            if (!pattern) {
+                return {
+                    status: 'error',
+                    error: 'Query too short for semantic search',
+                };
+            }
+            try {
+                const command = `find "${directory}" -name "${filePattern}" -type f -exec grep -l -i -E "${pattern}" {} \\; 2>/dev/null | head -20`;
+                const files = execSync(command, { encoding: 'utf8', timeout: 30000 }).trim().split('\n').filter(Boolean);
+                if (files.length === 0) {
+                    return {
+                        status: 'success',
+                        output: 'No files found matching the semantic query.',
+                        metadata: { query, directory, matches: 0 },
+                    };
+                }
+                // Get excerpts from each file
+                const results = [];
+                for (const file of files.slice(0, topK)) {
+                    try {
+                        const content = await fs.readFile(file, 'utf8');
+                        // Find relevant excerpt
+                        const lines = content.split('\n');
+                        for (let i = 0; i < lines.length; i++) {
+                            const line = lines[i].toLowerCase();
+                            if (keywords.some(k => line.includes(k))) {
+                                const excerpt = lines.slice(Math.max(0, i - 2), i + 3).join('\n');
+                                results.push(`File: ${file}\n${excerpt}\n---`);
+                                break;
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip files that can't be read
+                    }
+                }
+                return {
+                    status: 'success',
+                    output: results.join('\n\n') || 'Found files but could not extract excerpts.',
+                    metadata: {
+                        query,
+                        directory,
+                        files_searched: files.length,
+                        results_returned: results.length,
+                    },
+                };
+            }
+            catch (err) {
+                return {
+                    status: 'error',
+                    error: `Search failed: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Git tools - various git operations
+const gitStatusTool = {
+    definition: {
+        name: 'git_status',
+        description: 'Check git repository status. Shows modified, staged, and untracked files.',
+        parameters: {
+            type: 'object',
+            properties: {
+                repository_path: {
+                    type: 'string',
+                    description: 'Path to the git repository (default: current directory)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const repoPath = args.repository_path ? String(args.repository_path) : process.cwd();
+            const result = execSync('git status -sb', {
+                cwd: repoPath,
+                encoding: 'utf8',
+                timeout: 10000,
+            });
+            return {
+                status: 'success',
+                output: result.trim() || 'No changes',
+                metadata: { repository: repoPath },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: `Not a git repository or git not available: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    },
+};
+const gitDiffTool = {
+    definition: {
+        name: 'git_diff',
+        description: 'Show git diff for modified files. Can show staged or unstaged changes.',
+        parameters: {
+            type: 'object',
+            properties: {
+                repository_path: {
+                    type: 'string',
+                    description: 'Path to the git repository',
+                },
+                staged: {
+                    type: 'boolean',
+                    description: 'Show staged changes instead of unstaged',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Show diff for specific file only',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const repoPath = args.repository_path ? String(args.repository_path) : process.cwd();
+            const staged = Boolean(args.staged);
+            const filePath = args.file_path ? String(args.file_path) : undefined;
+            let command = 'git diff';
+            if (staged)
+                command += ' --cached';
+            if (filePath)
+                command += ` -- "${filePath}"`;
+            const result = execSync(command, {
+                cwd: repoPath,
+                encoding: 'utf8',
+                timeout: 10000,
+            });
+            return {
+                status: 'success',
+                output: result.trim() || 'No changes',
+                metadata: { repository: repoPath, staged, file: filePath },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+const gitLogTool = {
+    definition: {
+        name: 'git_log',
+        description: 'Show git commit history with customizable format.',
+        parameters: {
+            type: 'object',
+            properties: {
+                repository_path: {
+                    type: 'string',
+                    description: 'Path to the git repository',
+                },
+                num_commits: {
+                    type: 'number',
+                    description: 'Number of commits to show (default: 10)',
+                },
+                oneline: {
+                    type: 'boolean',
+                    description: 'Show one line per commit',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const repoPath = args.repository_path ? String(args.repository_path) : process.cwd();
+            const numCommits = args.num_commits ? Number(args.num_commits) : 10;
+            const oneline = Boolean(args.oneline);
+            let command = `git log -n ${numCommits}`;
+            if (oneline)
+                command += ' --oneline';
+            const result = execSync(command, {
+                cwd: repoPath,
+                encoding: 'utf8',
+                timeout: 10000,
+            });
+            return {
+                status: 'success',
+                output: result.trim(),
+                metadata: { repository: repoPath, commits_shown: numCommits },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// HTTP API tool - make HTTP requests
+const httpRequestTool = {
+    definition: {
+        name: 'http_request',
+        description: 'Make HTTP requests (GET, POST, PUT, DELETE, PATCH). Supports JSON body and custom headers.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: {
+                    type: 'string',
+                    description: 'The URL to request',
+                },
+                method: {
+                    type: 'string',
+                    description: 'HTTP method',
+                    enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'],
+                },
+                headers: {
+                    type: 'object',
+                    description: 'Custom headers as key-value pairs',
+                },
+                body: {
+                    type: 'string',
+                    description: 'Request body (for POST, PUT, PATCH)',
+                },
+                body_json: {
+                    type: 'object',
+                    description: 'JSON body as object (will be serialized)',
+                },
+            },
+            required: ['url'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const url = String(args.url);
+            const method = args.method ? String(args.method).toUpperCase() : 'GET';
+            const headers = args.headers || {};
+            let body;
+            if (args.body_json) {
+                body = JSON.stringify(args.body_json);
+                headers['Content-Type'] = headers['Content-Type'] || 'application/json';
+            }
+            else if (args.body) {
+                body = String(args.body);
+            }
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: body && method !== 'GET' && method !== 'HEAD' ? body : undefined,
+            });
+            const responseBody = await response.text();
+            const truncated = responseBody.length > 10000;
+            const output = truncated ? responseBody.slice(0, 10000) + '\n... (truncated)' : responseBody;
+            // Try to parse as JSON for metadata
+            let jsonBody = null;
+            try {
+                jsonBody = JSON.parse(responseBody);
+            }
+            catch {
+                // Not JSON
+            }
+            // Collect headers
+            const headersObj = {};
+            response.headers.forEach((value, key) => {
+                headersObj[key] = value;
+            });
+            return {
+                status: response.ok ? 'success' : 'error',
+                output,
+                error: response.ok ? undefined : `HTTP ${response.status}: ${response.statusText}`,
+                metadata: {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: headersObj,
+                    body_truncated: truncated,
+                    body_length: responseBody.length,
+                    json_parsed: jsonBody !== null,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// JSON/YAML tools - parsing and conversion
+const parseJsonTool = {
+    definition: {
+        name: 'parse_json',
+        description: 'Parse and validate JSON. Returns formatted JSON or error details.',
+        parameters: {
+            type: 'object',
+            properties: {
+                text: {
+                    type: 'string',
+                    description: 'JSON text to parse',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Path to JSON file (alternative to text)',
+                },
+                format_output: {
+                    type: 'boolean',
+                    description: 'Format output with indentation (default: true)',
+                },
+            },
+            required: [],
+        },
+    },
+    handler: async (args) => {
+        try {
+            let text;
+            if (args.file_path) {
+                text = await fs.readFile(String(args.file_path), 'utf8');
+            }
+            else if (args.text) {
+                text = String(args.text);
+            }
+            else {
+                return {
+                    status: 'error',
+                    error: 'Either text or file_path must be provided',
+                };
+            }
+            const parsed = JSON.parse(text);
+            const formatOutput = args.format_output !== false;
+            const output = formatOutput ? JSON.stringify(parsed, null, 2) : JSON.stringify(parsed);
+            // Get type info
+            const type = Array.isArray(parsed) ? 'array' : typeof parsed;
+            const keys = type === 'object' && parsed !== null ? Object.keys(parsed) : null;
+            return {
+                status: 'success',
+                output,
+                metadata: {
+                    type,
+                    keys: keys,
+                    length: Array.isArray(parsed) ? parsed.length : undefined,
+                },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    },
+};
+const jsonToYamlTool = {
+    definition: {
+        name: 'convert_json_yaml',
+        description: 'Convert between JSON and YAML formats.',
+        parameters: {
+            type: 'object',
+            properties: {
+                input: {
+                    type: 'string',
+                    description: 'Input text (JSON or YAML)',
+                },
+                file_path: {
+                    type: 'string',
+                    description: 'Path to file (alternative to input)',
+                },
+                to: {
+                    type: 'string',
+                    description: 'Target format',
+                    enum: ['json', 'yaml'],
+                },
+            },
+            required: ['to'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const targetFormat = String(args.to).toLowerCase();
+            let input;
+            if (args.file_path) {
+                input = await fs.readFile(String(args.file_path), 'utf8');
+            }
+            else if (args.input) {
+                input = String(args.input);
+            }
+            else {
+                return {
+                    status: 'error',
+                    error: 'Either input or file_path must be provided',
+                };
+            }
+            // Detect input format and parse
+            let data;
+            try {
+                data = JSON.parse(input);
+            }
+            catch {
+                // Try YAML-like parsing (simplified - just handles basic cases)
+                // For full YAML support, would need js-yaml library
+                const lines = input.split('\n');
+                data = {};
+                let currentKey = '';
+                for (const line of lines) {
+                    const match = line.match(/^(\w+):\s*(.*)$/);
+                    if (match) {
+                        currentKey = match[1];
+                        data[currentKey] = match[2] || '';
+                    }
+                }
+            }
+            let output;
+            if (targetFormat === 'json') {
+                output = JSON.stringify(data, null, 2);
+            }
+            else {
+                // Simple YAML serialization
+                output = Object.entries(data)
+                    .map(([k, v]) => `${k}: ${typeof v === 'string' ? v : JSON.stringify(v)}`)
+                    .join('\n');
+            }
+            return {
+                status: 'success',
+                output,
+                metadata: { source_format: targetFormat === 'json' ? 'yaml' : 'json', target_format: targetFormat },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// File diff tool - compare two files
+const diffFilesTool = {
+    definition: {
+        name: 'diff_files',
+        description: 'Compare two files and show differences. Uses unified diff format.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file1: {
+                    type: 'string',
+                    description: 'Path to first file',
+                },
+                file2: {
+                    type: 'string',
+                    description: 'Path to second file',
+                },
+                unified_lines: {
+                    type: 'number',
+                    description: 'Number of context lines (default: 3)',
+                },
+            },
+            required: ['file1', 'file2'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const file1 = String(args.file1);
+            const file2 = String(args.file2);
+            const context = args.unified_lines ? Number(args.unified_lines) : 3;
+            const content1 = await fs.readFile(file1, 'utf8');
+            const content2 = await fs.readFile(file2, 'utf8');
+            // Simple line-by-line diff
+            const lines1 = content1.split('\n');
+            const lines2 = content2.split('\n');
+            const diff = [];
+            const maxLen = Math.max(lines1.length, lines2.length);
+            for (let i = 0; i < maxLen; i++) {
+                const line1 = lines1[i];
+                const line2 = lines2[i];
+                if (line1 !== line2) {
+                    if (line1 !== undefined)
+                        diff.push(`-${line1}`);
+                    if (line2 !== undefined)
+                        diff.push(`+${line2}`);
+                }
+                else {
+                    diff.push(` ${line1}`);
+                }
+            }
+            const output = diff.slice(0, 200).join('\n'); // Limit output
+            const truncated = diff.length > 200;
+            return {
+                status: 'success',
+                output: truncated ? output + '\n... (truncated)' : output,
+                metadata: { file1, file2, differences: diff.length },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Compression tools - create/extract archives
+const createArchiveTool = {
+    definition: {
+        name: 'create_archive',
+        description: 'Create a zip or tar archive from files or directories.',
+        parameters: {
+            type: 'object',
+            properties: {
+                output_path: {
+                    type: 'string',
+                    description: 'Path for the output archive',
+                },
+                source_paths: {
+                    type: 'array',
+                    description: 'Array of file or directory paths to include',
+                    items: { type: 'string' },
+                },
+                format: {
+                    type: 'string',
+                    description: 'Archive format',
+                    enum: ['zip', 'tar', 'tar.gz', 'tgz'],
+                },
+            },
+            required: ['output_path', 'source_paths'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const outputPath = String(args.output_path);
+            const sourcePaths = Array.isArray(args.source_paths) ? args.source_paths.map(String) : [];
+            const format = args.format ? String(args.format) : 'zip';
+            let command;
+            const sources = sourcePaths.map(p => `"${p}"`).join(' ');
+            switch (format) {
+                case 'zip':
+                    command = `zip -r "${outputPath}" ${sources}`;
+                    break;
+                case 'tar':
+                    command = `tar -cf "${outputPath}" ${sources}`;
+                    break;
+                case 'tar.gz':
+                case 'tgz':
+                    command = `tar -czf "${outputPath}" ${sources}`;
+                    break;
+                default:
+                    return {
+                        status: 'error',
+                        error: `Unsupported format: ${format}`,
+                    };
+            }
+            execSync(command, { timeout: 60000 });
+            const stats = await fs.stat(outputPath);
+            return {
+                status: 'success',
+                output: `Archive created: ${outputPath} (${(stats.size / 1024).toFixed(2)} KB)`,
+                metadata: { output_path: outputPath, format, files_included: sourcePaths.length, size_bytes: stats.size },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+const extractArchiveTool = {
+    definition: {
+        name: 'extract_archive',
+        description: 'Extract a zip or tar archive.',
+        parameters: {
+            type: 'object',
+            properties: {
+                archive_path: {
+                    type: 'string',
+                    description: 'Path to the archive file',
+                },
+                output_directory: {
+                    type: 'string',
+                    description: 'Directory to extract to (default: same as archive)',
+                },
+            },
+            required: ['archive_path'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const archivePath = String(args.archive_path);
+            const outputDir = args.output_directory ? String(args.output_directory) : path.dirname(archivePath);
+            // Detect format from extension
+            const ext = path.extname(archivePath).toLowerCase();
+            const baseName = path.basename(archivePath);
+            let command;
+            if (ext === '.zip') {
+                command = `unzip -o "${archivePath}" -d "${outputDir}"`;
+            }
+            else if (ext === '.gz' || baseName.endsWith('.tar.gz') || baseName.endsWith('.tgz')) {
+                command = `tar -xzf "${archivePath}" -C "${outputDir}"`;
+            }
+            else if (ext === '.tar') {
+                command = `tar -xf "${archivePath}" -C "${outputDir}"`;
+            }
+            else {
+                return {
+                    status: 'error',
+                    error: `Could not detect archive format from: ${archivePath}`,
+                };
+            }
+            execSync(command, { timeout: 60000 });
+            return {
+                status: 'success',
+                output: `Archive extracted to: ${outputDir}`,
+                metadata: { archive: archivePath, output_directory: outputDir },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// PDF text extraction tool
+const extractPdfTool = {
+    definition: {
+        name: 'extract_pdf_text',
+        description: 'Extract text content from a PDF file. Requires pdftotext or similar tool.',
+        parameters: {
+            type: 'object',
+            properties: {
+                pdf_path: {
+                    type: 'string',
+                    description: 'Path to the PDF file',
+                },
+                page_range: {
+                    type: 'string',
+                    description: 'Page range to extract (e.g., "1-5" or "1,3,5", default: all)',
+                },
+            },
+            required: ['pdf_path'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const pdfPath = String(args.pdf_path);
+            const pageRange = args.page_range ? String(args.page_range) : undefined;
+            let command = `pdftotext -layout`;
+            if (pageRange) {
+                command += ` -f ${pageRange.split('-')[0]} -l ${pageRange.split('-')[1] || pageRange.split('-')[0]}`;
+            }
+            command += ` "${pdfPath}" -`; // Output to stdout
+            const output = execSync(command, { encoding: 'utf8', timeout: 30000 });
+            const truncated = output.length > 15000;
+            return {
+                status: 'success',
+                output: truncated ? output.slice(0, 15000) + '\n... (truncated)' : output,
+                metadata: { pdf_path: pdfPath, page_range: pageRange, text_length: output.length, truncated },
+            };
+        }
+        catch (err) {
+            // Fallback: try Python with PyPDF2
+            try {
+                const pythonScript = `
+import sys
+from PyPDF2 import PdfReader
+reader = PdfReader("${args.pdf_path}")
+text = ""
+for page in reader.pages:
+    text += page.extract_text() + "\\n"
+print(text)
+`;
+                const output = execSync(`python3 -c "${pythonScript}"`, { encoding: 'utf8', timeout: 30000 });
+                return {
+                    status: 'success',
+                    output,
+                    metadata: { pdf_path: args.pdf_path, method: 'pypdf2' },
+                };
+            }
+            catch {
+                return {
+                    status: 'error',
+                    error: `Failed to extract PDF text. Ensure pdftotext (poppler-utils) or PyPDF2 is installed. Original error: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+    },
+};
+// Network tools - ping, port check, DNS
+const pingTool = {
+    definition: {
+        name: 'ping_host',
+        description: 'Ping a host to check network connectivity.',
+        parameters: {
+            type: 'object',
+            properties: {
+                host: {
+                    type: 'string',
+                    description: 'Hostname or IP to ping',
+                },
+                count: {
+                    type: 'number',
+                    description: 'Number of pings (default: 4)',
+                },
+            },
+            required: ['host'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const host = String(args.host);
+            const count = args.count ? Number(args.count) : 4;
+            const output = execSync(`ping -c ${count} "${host}"`, {
+                encoding: 'utf8',
+                timeout: 30000,
+            });
+            return {
+                status: 'success',
+                output,
+                metadata: { host, count },
+            };
+        }
+        catch (err) {
+            // ping returns non-zero on some failures but still has output
+            const output = err.stdout;
+            if (output) {
+                return {
+                    status: 'error',
+                    output,
+                    error: 'Host unreachable or ping failed',
+                    metadata: { host: args.host },
+                };
+            }
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+const checkPortTool = {
+    definition: {
+        name: 'check_port',
+        description: 'Check if a port is open on a host.',
+        parameters: {
+            type: 'object',
+            properties: {
+                host: {
+                    type: 'string',
+                    description: 'Hostname or IP',
+                },
+                port: {
+                    type: 'number',
+                    description: 'Port number to check',
+                },
+                timeout_sec: {
+                    type: 'number',
+                    description: 'Timeout in seconds (default: 5)',
+                },
+            },
+            required: ['host', 'port'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const host = String(args.host);
+            const port = Number(args.port);
+            const timeout = args.timeout_sec ? Number(args.timeout_sec) : 5;
+            // Try using nc (netcat)
+            try {
+                execSync(`nc -z -w ${timeout} "${host}" ${port}`, { timeout: timeout * 1000 + 1000 });
+                return {
+                    status: 'success',
+                    output: `Port ${port} on ${host} is OPEN`,
+                    metadata: { host, port, open: true },
+                };
+            }
+            catch {
+                return {
+                    status: 'success',
+                    output: `Port ${port} on ${host} is CLOSED or filtered`,
+                    metadata: { host, port, open: false },
+                };
+            }
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Docker tool - manage containers
+const dockerTool = {
+    definition: {
+        name: 'docker',
+        description: 'Run Docker commands. Supports ps, images, logs, exec, run, build.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'Docker command (ps, images, logs, exec, run, build, stop, rm)',
+                    enum: ['ps', 'images', 'logs', 'exec', 'run', 'build', 'stop', 'rm', 'compose-up', 'compose-down'],
+                },
+                container: {
+                    type: 'string',
+                    description: 'Container name or ID (for logs, exec, stop, rm)',
+                },
+                args: {
+                    type: 'string',
+                    description: 'Additional arguments',
+                },
+            },
+            required: ['command'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const command = String(args.command);
+            const container = args.container ? String(args.container) : '';
+            const extraArgs = args.args ? String(args.args) : '';
+            let dockerCmd;
+            switch (command) {
+                case 'ps':
+                    dockerCmd = 'docker ps -a';
+                    break;
+                case 'images':
+                    dockerCmd = 'docker images';
+                    break;
+                case 'logs':
+                    if (!container)
+                        return { status: 'error', error: 'Container name required for logs' };
+                    dockerCmd = `docker logs --tail 100 ${container}`;
+                    break;
+                case 'exec':
+                    if (!container)
+                        return { status: 'error', error: 'Container name required for exec' };
+                    dockerCmd = `docker exec ${container} ${extraArgs || 'sh'}`;
+                    break;
+                case 'stop':
+                    if (!container)
+                        return { status: 'error', error: 'Container name required for stop' };
+                    dockerCmd = `docker stop ${container}`;
+                    break;
+                case 'rm':
+                    if (!container)
+                        return { status: 'error', error: 'Container name required for rm' };
+                    dockerCmd = `docker rm ${container}`;
+                    break;
+                case 'compose-up':
+                    dockerCmd = 'docker compose up -d';
+                    break;
+                case 'compose-down':
+                    dockerCmd = 'docker compose down';
+                    break;
+                default:
+                    dockerCmd = `docker ${command} ${extraArgs}`;
+            }
+            const output = execSync(dockerCmd, { encoding: 'utf8', timeout: 60000 });
+            return {
+                status: 'success',
+                output: output.trim(),
+                metadata: { command: dockerCmd },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// CSV processing tool
+const csvTool = {
+    definition: {
+        name: 'process_csv',
+        description: 'Process CSV files - view, filter, convert to JSON, get statistics.',
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'Path to CSV file',
+                },
+                action: {
+                    type: 'string',
+                    description: 'Action to perform',
+                    enum: ['view', 'head', 'stats', 'to_json'],
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Number of rows to show (default: 10)',
+                },
+            },
+            required: ['file_path', 'action'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const filePath = String(args.file_path);
+            const action = String(args.action);
+            const limit = args.limit ? Number(args.limit) : 10;
+            const content = await fs.readFile(filePath, 'utf8');
+            const lines = content.split('\n').filter(l => l.trim());
+            if (lines.length === 0) {
+                return { status: 'error', error: 'Empty CSV file' };
+            }
+            const headers = lines[0].split(',').map(h => h.trim());
+            switch (action) {
+                case 'head':
+                case 'view': {
+                    const rows = lines.slice(1, limit + 1).map(line => {
+                        const cells = line.split(',').map(c => c.trim());
+                        return cells.map((c, i) => `${headers[i]}: ${c}`).join(' | ');
+                    });
+                    return {
+                        status: 'success',
+                        output: `Headers: ${headers.join(', ')}\n\n${rows.join('\n')}`,
+                        metadata: { total_rows: lines.length - 1, shown: rows.length },
+                    };
+                }
+                case 'stats': {
+                    const colStats = {};
+                    headers.forEach(h => colStats[h] = { count: 0, unique: new Set(), numeric: [] });
+                    for (const line of lines.slice(1)) {
+                        const cells = line.split(',').map(c => c.trim());
+                        cells.forEach((cell, i) => {
+                            const h = headers[i];
+                            colStats[h].count++;
+                            colStats[h].unique.add(cell);
+                            const num = parseFloat(cell);
+                            if (!isNaN(num))
+                                colStats[h].numeric.push(num);
+                        });
+                    }
+                    const stats = headers.map(h => {
+                        const s = colStats[h];
+                        const numericInfo = s.numeric.length > 0
+                            ? ` | min: ${Math.min(...s.numeric)} | max: ${Math.max(...s.numeric)} | avg: ${(s.numeric.reduce((a, b) => a + b, 0) / s.numeric.length).toFixed(2)}`
+                            : '';
+                        return `${h}: ${s.count} rows, ${s.unique.size} unique${numericInfo}`;
+                    });
+                    return {
+                        status: 'success',
+                        output: stats.join('\n'),
+                        metadata: { columns: headers.length, rows: lines.length - 1 },
+                    };
+                }
+                case 'to_json': {
+                    const rows = lines.slice(1).map(line => {
+                        const cells = line.split(',').map(c => c.trim());
+                        const obj = {};
+                        headers.forEach((h, i) => obj[h] = cells[i] || '');
+                        return obj;
+                    });
+                    return {
+                        status: 'success',
+                        output: JSON.stringify(rows, null, 2),
+                        metadata: { rows: rows.length },
+                    };
+                }
+                default:
+                    return { status: 'error', error: `Unknown action: ${action}` };
+            }
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// SQLite database tool
+const sqliteTool = {
+    definition: {
+        name: 'query_sqlite',
+        description: 'Execute SQL queries on SQLite databases.',
+        parameters: {
+            type: 'object',
+            properties: {
+                database_path: {
+                    type: 'string',
+                    description: 'Path to SQLite database file',
+                },
+                query: {
+                    type: 'string',
+                    description: 'SQL query to execute',
+                },
+            },
+            required: ['database_path', 'query'],
+        },
+    },
+    handler: async (args) => {
+        try {
+            const dbPath = String(args.database_path);
+            const query = String(args.query);
+            const output = execSync(`sqlite3 "${dbPath}" "${query.replace(/"/g, '""')}"`, {
+                encoding: 'utf8',
+                timeout: 30000,
+            });
+            return {
+                status: 'success',
+                output: output.trim(),
+                metadata: { database: dbPath, query },
+            };
+        }
+        catch (err) {
+            return {
+                status: 'error',
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    },
+};
+// Export all tools
+export const tools = [
+    // Core file/system tools
+    readFileTool,
+    writeFileTool,
+    editFileTool,
+    listDirTool,
+    grepSearchTool,
+    runCommandTool,
+    findByNameTool,
+    viewUrlTool,
+    askUserTool,
+    createMemoryTool,
+    analyzeImageTool,
+    embeddingTool,
+    webSearchTool,
+    browserTool,
+    codeExecutionTool,
+    semanticSearchTool,
+    gitStatusTool,
+    gitDiffTool,
+    gitLogTool,
+    httpRequestTool,
+    parseJsonTool,
+    jsonToYamlTool,
+    diffFilesTool,
+    createArchiveTool,
+    extractArchiveTool,
+    extractPdfTool,
+    pingTool,
+    checkPortTool,
+    dockerTool,
+    csvTool,
+    sqliteTool,
+    // API integrations
+    ...slackTools,
+    ...googleTools,
+    ...githubTools,
+    ...discordTools,
+    ...telegramTools,
+];
+// Create a map for quick lookup
+export const toolMap = new Map(tools.map(t => [t.definition.name, t]));
+//# sourceMappingURL=index.js.map