erosolar-cli 1.7.344 → 1.7.346

package/dist/core/unified/tools.js

@@ -0,0 +1,1333 @@
+/**
+ * Unified Tool Implementations
+ *
+ * Complete implementation of all tools defined in the unified schema.
+ * Single source of truth for tool executors in TypeScript.
+ *
+ * Principal Investigator: Bo Shang
+ * Framework: erosolar-cli
+ */
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from 'node:fs';
+import { join, dirname, relative, resolve, isAbsolute } from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { performSurgicalEdit } from '../../tools/editTools.js';
+const execAsync = promisify(exec);
+// ============================================================================
+// Core Tools
+// ============================================================================
+/**
+ * Read tool - Read file contents
+ */
+export function createReadTool(workingDir) {
+    return {
+        name: 'Read',
+        description: 'Read file contents from the filesystem',
+        category: 'core',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Absolute path to the file' },
+                offset: { type: 'number', description: 'Line number to start from' },
+                limit: { type: 'number', description: 'Number of lines to read' },
+            },
+            required: ['file_path'],
+        },
+        execute: async (args) => {
+            const filePath = resolvePath(workingDir, args['file_path']);
+            const offset = args['offset'] || 0;
+            const limit = args['limit'] || 2000;
+            if (!existsSync(filePath)) {
+                return `Error: File not found: ${filePath}`;
+            }
+            try {
+                const content = readFileSync(filePath, 'utf-8');
+                const lines = content.split('\n');
+                const selectedLines = lines.slice(offset, offset + limit);
+                // Format with line numbers
+                const numbered = selectedLines.map((line, i) => {
+                    const lineNum = offset + i + 1;
+                    return `${String(lineNum).padStart(6)}→${line}`;
+                });
+                return numbered.join('\n');
+            }
+            catch (error) {
+                return `Error reading file: ${error}`;
+            }
+        },
+    };
+}
+/**
+ * Write tool - Write content to a file
+ */
+export function createWriteTool(workingDir) {
+    return {
+        name: 'Write',
+        description: 'Write content to a file (creates new file or overwrites existing). Use this for creating new files or completely replacing file contents. For making small changes to existing files, use Edit tool instead (Edit is faster and shows diffs). CRITICAL: For existing files, prefer Edit over Write to avoid accidental overwrites.',
+        category: 'core',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Absolute path to the file to create or overwrite' },
+                content: { type: 'string', description: 'Full content to write to the file (will replace existing content entirely)' },
+            },
+            required: ['file_path', 'content'],
+        },
+        execute: async (args) => {
+            const filePath = resolvePath(workingDir, args['file_path']);
+            const content = args['content'];
+            try {
+                const dir = dirname(filePath);
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                const existed = existsSync(filePath);
+                const newLines = content.split('\n').length;
+                // Safety check: Prevent accidental truncation when overwriting larger files
+                // This catches cases where AI output was cut off mid-generation
+                if (existed) {
+                    const existingContent = readFileSync(filePath, 'utf-8');
+                    const existingLines = existingContent.split('\n').length;
+                    // If new content is significantly smaller (less than 50% of original and at least 50 lines shorter),
+                    // this likely indicates truncation rather than intentional reduction
+                    const lineReduction = existingLines - newLines;
+                    const reductionRatio = newLines / existingLines;
+                    if (existingLines > 100 && lineReduction > 50 && reductionRatio < 0.5) {
+                        // Truncation detected - always succeed by appending missing content from original
+                        const existingLineArr = existingContent.split('\n');
+                        const newLineArr = content.split('\n');
+                        // Always append the remaining lines from original to preserve content
+                        // This ensures the file is never truncated - new content at start, original remainder preserved
+                        const mergedLines = [
+                            ...newLineArr,
+                            ...existingLineArr.slice(newLineArr.length)
+                        ];
+                        const mergedContent = mergedLines.join('\n');
+                        writeFileSync(filePath, mergedContent, 'utf-8');
+                        const preservedLines = existingLines - newLines;
+                        return `✓ Updated ${relative(workingDir, filePath)} (${mergedLines.length} lines) ` +
+                            `[Protected: preserved ${preservedLines} lines from original after truncation point]`;
+                    }
+                }
+                writeFileSync(filePath, content, 'utf-8');
+                const action = existed ? 'Updated' : 'Created';
+                return `✓ ${action} ${relative(workingDir, filePath)} (${newLines} lines)`;
+            }
+            catch (error) {
+                return `Error writing file: ${error}`;
+            }
+        },
+    };
+}
+/**
+ * Edit tool - Make surgical edits to a file
+ */
+export function createEditTool(workingDir) {
+    return {
+        name: 'Edit',
+        description: 'Performs exact string replacements in files. CRITICAL: For existing files, ALWAYS use Read tool FIRST to get exact text, then copy it (excluding line numbers) directly to old_string. Use Edit for small changes - faster than Write and shows diffs. To CREATE new file, use empty old_string (no prior read needed). To DELETE text, use empty new_string. Edit FAILS if old_string not unique unless replace_all is true.',
+        category: 'core',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Absolute path to the file to modify or create' },
+                old_string: { type: 'string', description: 'Exact text to replace. Use "" to create a new file.' },
+                new_string: {
+                    type: 'string',
+                    description: 'Replacement text. Use "" to delete the old_string. Defaults to "" when omitted.',
+                },
+                replace_all: { type: 'boolean', description: 'Replace all occurrences (default false)' },
+            },
+            required: ['file_path', 'old_string'],
+            additionalProperties: false,
+        },
+        execute: async (args) => performSurgicalEdit(workingDir, args),
+    };
+}
+/**
+ * Bash tool - Execute shell commands
+ */
+export function createBashTool(workingDir) {
+    return {
+        name: 'Bash',
+        description: 'Execute shell commands in the working directory. IMPORTANT: Always provide a clear description parameter explaining what the command does. Commands timeout after 2 minutes by default (auto-extended for npm/git/docker). For long-running commands, increase timeout or use background execution. Exit code 0 = success, non-zero = failure.',
+        category: 'core',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'The shell command to execute (e.g., "npm test", "git status")' },
+                timeout: { type: 'number', description: 'Timeout in milliseconds (default: 120000 = 2 minutes). Use higher for npm install/build (300000+)' },
+                description: { type: 'string', description: 'Clear description of what this command does (e.g., "Run unit tests", "Build the project")' },
+            },
+            required: ['command'],
+        },
+        execute: async (args) => {
+            const command = args['command'];
+            const userTimeout = args['timeout'];
+            // Smart timeout based on command type
+            const getSmartTimeout = (cmd) => {
+                const lower = cmd.toLowerCase().trim();
+                if (/\b(npm|yarn|pnpm)\s+(install|ci|i|add|update|build|test)\b/.test(lower))
+                    return 300000;
+                if (/\bnpx\s+create-\b/.test(lower))
+                    return 300000;
+                if (/\bdocker\s+(build|pull|push)\b/.test(lower))
+                    return 600000;
+                if (/\bgit\s+clone\b/.test(lower))
+                    return 180000;
+                if (/\bpip\s+install\b/.test(lower))
+                    return 180000;
+                return 120000;
+            };
+            const timeout = userTimeout ?? getSmartTimeout(command);
+            // Enhanced safety checks
+            const dangerousPatterns = [
+                { pattern: /rm\s+-rf\s+[\/~]/, message: 'Dangerous recursive delete of system directories' },
+                { pattern: />\s*\/dev\/sd/, message: 'Writing to raw disk device' },
+                { pattern: /mkfs\./, message: 'Filesystem formatting command' },
+                { pattern: /dd\s+if=.*of=\/dev/, message: 'Direct disk write operation' },
+                { pattern: /:(){ :|:& };:/, message: 'Fork bomb detected' },
+            ];
+            for (const { pattern, message } of dangerousPatterns) {
+                if (pattern.test(command)) {
+                    return `Error: Command blocked for safety - ${message}\n\nCommand: ${command}\n\nIf this operation is intentional, use a safer alternative or implement proper safeguards.`;
+                }
+            }
+            try {
+                const { stdout, stderr } = await execAsync(command, {
+                    cwd: workingDir,
+                    timeout,
+                    maxBuffer: 10 * 1024 * 1024, // 10MB
+                });
+                // Check for common error patterns even with exit code 0
+                const output = (stdout + stderr).toLowerCase();
+                const hasErrors = /\b(error|failed|fatal|exception)\b/i.test(output) &&
+                    !/\b0 (errors?|vulnerabilities)\b/i.test(output);
+                if (hasErrors) {
+                    return `⚠️  Command completed but output contains errors:\n\nCommand: ${command}\n\n${stdout}${stderr ? '\n' + stderr : ''}`;
+                }
+                const parts = [];
+                if (stdout)
+                    parts.push(stdout);
+                if (stderr)
+                    parts.push(stderr);
+                return parts.length > 0
+                    ? `✓ Command executed successfully\n\nCommand: ${command}\n\n${parts.join('\n')}`
+                    : `✓ Command executed successfully (no output)\n\nCommand: ${command}`;
+            }
+            catch (error) {
+                const exitCode = error.code ?? 1;
+                const errorOutput = [error.stdout, error.stderr, error.message].filter(Boolean).join('\n');
+                if (error.killed) {
+                    return `❌ Command timed out after ${timeout}ms\n\nCommand: ${command}\n\nThis command exceeded the timeout limit. Try:\n1. Increase the timeout parameter (e.g., timeout: ${timeout * 2})\n2. Check if the command is waiting for input\n3. Verify the command is valid\n\nPartial output:\n${errorOutput || '(none)'}`;
+                }
+                return `❌ Command failed with exit code ${exitCode}\n\nCommand: ${command}\n\nError output:\n${errorOutput || '(no error details available)'}\n\nTroubleshooting:\n1. Review the error message above\n2. Verify the command syntax is correct\n3. Check if required files/dependencies exist\n4. Ensure you have necessary permissions`;
+            }
+        },
+    };
+}
+/**
+ * Glob tool - Find files matching a pattern
+ */
+export function createGlobTool(workingDir) {
+    return {
+        name: 'Glob',
+        description: 'Find files matching a pattern',
+        category: 'core',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Glob pattern to match' },
+                path: { type: 'string', description: 'Directory to search in' },
+            },
+            required: ['pattern'],
+        },
+        execute: async (args) => {
+            const pattern = args['pattern'];
+            const searchPath = args['path'] ? resolvePath(workingDir, args['path']) : workingDir;
+            if (!pattern.trim()) {
+                return 'Error: pattern must be a non-empty string';
+            }
+            // Warn about overly broad patterns
+            if (['*', '.', '**/*'].includes(pattern.trim())) {
+                return `Warning: Pattern "${pattern}" is too broad. Use a more specific pattern.`;
+            }
+            try {
+                const matches = globSearch(searchPath, pattern);
+                const relativePaths = matches.map((p) => relative(workingDir, p));
+                if (relativePaths.length === 0) {
+                    return `No files found matching pattern: ${pattern}`;
+                }
+                // Limit results
+                const limit = 50;
+                const limited = relativePaths.slice(0, limit);
+                const truncated = relativePaths.length > limit;
+                let result = `${relativePaths.length} files found matching "${pattern}":\n\n${limited.join('\n')}`;
+                if (truncated) {
+                    result += `\n\n... [${relativePaths.length - limit} more files truncated]`;
+                }
+                return result;
+            }
+            catch (error) {
+                return `Error during glob search: ${error}`;
+            }
+        },
+    };
+}
+/**
+ * Grep tool - Search file contents with regex
+ */
+export function createGrepTool(workingDir) {
+    return {
+        name: 'Grep',
+        description: 'Search file contents with regex',
+        category: 'core',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                pattern: { type: 'string', description: 'Regex pattern to search for' },
+                path: { type: 'string', description: 'File or directory to search' },
+                output_mode: {
+                    type: 'string',
+                    enum: ['content', 'files_with_matches', 'count'],
+                    description: 'Output mode',
+                },
+            },
+            required: ['pattern'],
+        },
+        execute: async (args) => {
+            const pattern = args['pattern'];
+            const searchPath = args['path'] ? resolvePath(workingDir, args['path']) : workingDir;
+            const outputMode = args['output_mode'] || 'files_with_matches';
+            const caseInsensitive = args['-i'] === true;
+            try {
+                const flags = caseInsensitive ? 'gi' : 'g';
+                const regex = new RegExp(pattern, flags);
+                const matches = grepSearch(searchPath, regex);
+                if (matches.length === 0) {
+                    return 'No matches found.';
+                }
+                if (outputMode === 'files_with_matches') {
+                    const files = Array.from(new Set(matches.map((m) => m.file)));
+                    return files.map((f) => relative(workingDir, f)).join('\n');
+                }
+                if (outputMode === 'count') {
+                    const counts = new Map();
+                    for (const match of matches) {
+                        counts.set(match.file, (counts.get(match.file) || 0) + 1);
+                    }
+                    return Array.from(counts.entries())
+                        .map(([file, count]) => `${count}:${relative(workingDir, file)}`)
+                        .join('\n');
+                }
+                // content mode
+                const limit = 50;
+                const limited = matches.slice(0, limit);
+                const result = limited
+                    .map((m) => `${relative(workingDir, m.file)}:${m.line}:${m.content}`)
+                    .join('\n');
+                if (matches.length > limit) {
+                    return result + `\n\n... [${matches.length - limit} more matches truncated]`;
+                }
+                return result;
+            }
+            catch (error) {
+                return `Error during grep search: ${error}`;
+            }
+        },
+    };
+}
+// ============================================================================
+// Web Tools
+// ============================================================================
+/**
+ * WebSearch tool - Search the web
+ */
+export function createWebSearchTool() {
+    return {
+        name: 'WebSearch',
+        description: 'Search the web for information',
+        category: 'web',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+            },
+            required: ['query'],
+        },
+        execute: async (args) => {
+            const query = args['query'];
+            // Placeholder - actual implementation would use a search API
+            return `[WebSearch] Would search for: "${query}"\n\nNote: WebSearch requires API configuration.`;
+        },
+    };
+}
+/**
+ * WebFetch tool - Fetch and analyze web page content
+ */
+export function createWebFetchTool() {
+    return {
+        name: 'WebFetch',
+        description: 'Fetch and analyze web page content',
+        category: 'web',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to fetch' },
+                prompt: { type: 'string', description: 'What to extract from the page' },
+            },
+            required: ['url', 'prompt'],
+        },
+        execute: async (args) => {
+            const url = args['url'];
+            const prompt = args['prompt'];
+            // Placeholder - actual implementation would fetch and process the URL
+            return `[WebFetch] Would fetch: ${url}\nPrompt: ${prompt}\n\nNote: WebFetch requires network access.`;
+        },
+    };
+}
+// ============================================================================
+// Coding Tools
+// ============================================================================
+/**
+ * AnalyzeComplexity tool - Analyze code complexity
+ */
+export function createAnalyzeComplexityTool() {
+    return {
+        name: 'AnalyzeComplexity',
+        description: 'Analyze code complexity metrics',
+        category: 'coding',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to analyze' },
+                language: { type: 'string', description: 'Programming language' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const language = args['language'] || 'unknown';
+            const lines = code.split('\n');
+            const nonEmpty = lines.filter((l) => l.trim().length > 0);
+            const functions = (code.match(/function\s+\w+|const\s+\w+\s*=\s*(?:async\s*)?\(/g) || []).length;
+            const loops = (code.match(/\b(for|while|do)\b/g) || []).length;
+            const conditions = (code.match(/\b(if|else|switch|case|\?)\b/g) || []).length;
+            return `Code Complexity Analysis (${language}):
+- Total lines: ${lines.length}
+- Non-empty lines: ${nonEmpty.length}
+- Functions/methods: ${functions}
+- Loops: ${loops}
+- Conditionals: ${conditions}
+- Estimated cyclomatic complexity: ${1 + loops + conditions}`;
+        },
+    };
+}
+/**
+ * FindDependencies tool - Find imports and dependencies
+ */
+export function createFindDependenciesTool() {
+    return {
+        name: 'FindDependencies',
+        description: 'Find imports and dependencies in code',
+        category: 'coding',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to analyze' },
+                language: { type: 'string', description: 'Programming language' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const language = args['language'] || 'unknown';
+            const imports = [];
+            // JavaScript/TypeScript imports
+            const jsImports = code.match(/import\s+.*?from\s+['"]([^'"]+)['"]/g) || [];
+            const requireImports = code.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g) || [];
+            imports.push(...jsImports, ...requireImports);
+            // Python imports
+            const pyImports = code.match(/(?:from\s+\S+\s+)?import\s+\S+/g) || [];
+            imports.push(...pyImports);
+            if (imports.length === 0) {
+                return `No dependencies found in ${language} code.`;
+            }
+            return `Dependencies found (${language}):\n${imports.join('\n')}`;
+        },
+    };
+}
+/**
+ * GenerateDocstring tool - Generate documentation for code
+ */
+export function createGenerateDocstringTool() {
+    return {
+        name: 'GenerateDocstring',
+        description: 'Generate documentation for code',
+        category: 'coding',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to document' },
+                style: { type: 'string', enum: ['google', 'numpy', 'sphinx', 'jsdoc'], description: 'Doc style' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const style = args['style'] || 'google';
+            // Extract function signature if present
+            const funcMatch = code.match(/(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/);
+            const arrowMatch = code.match(/(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(([^)]*)\)/);
+            const match = funcMatch || arrowMatch;
+            if (!match) {
+                return 'Could not detect function signature. Provide a function to document.';
+            }
+            const [, name, params] = match;
+            const funcName = name || 'function';
+            const paramStr = params || '';
+            const paramList = paramStr
+                .split(',')
+                .map((p) => p.trim())
+                .filter(Boolean);
+            if (style === 'jsdoc') {
+                const paramDocs = paramList.map((p) => ` * @param {*} ${(p.split(':')[0] || '').trim()} - Description`);
+                return `/**
+ * ${funcName} - Description of what this function does
+ *
+${paramDocs.join('\n')}
+ * @returns {*} Description of return value
+ */`;
+            }
+            // Google style (Python)
+            const paramDocs = paramList.map((p) => `        ${(p.split(':')[0] || '').trim()}: Description`);
+            return `"""${funcName} - Description of what this function does
+
+    Args:
+${paramDocs.join('\n')}
+
+    Returns:
+        Description of return value
+    """`;
+        },
+    };
+}
+/**
+ * SuggestRefactorings tool - Suggest code refactoring improvements
+ */
+export function createSuggestRefactoringsTool() {
+    return {
+        name: 'SuggestRefactorings',
+        description: 'Suggest code refactoring improvements',
+        category: 'coding',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to analyze' },
+                focus: { type: 'array', items: { type: 'string' }, description: 'Areas to focus on' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const suggestions = [];
+            // Check for long functions
+            const lines = code.split('\n');
+            if (lines.length > 50) {
+                suggestions.push('- Consider breaking this into smaller functions (>50 lines)');
+            }
+            // Check for deeply nested code
+            const maxIndent = Math.max(...lines.map((l) => l.match(/^\s*/)?.[0].length || 0));
+            if (maxIndent > 16) {
+                suggestions.push('- Reduce nesting depth - consider early returns or extracting functions');
+            }
+            // Check for magic numbers
+            if (/[^a-zA-Z0-9_]\d{2,}[^a-zA-Z0-9_]/.test(code)) {
+                suggestions.push('- Extract magic numbers into named constants');
+            }
+            // Check for repeated code patterns
+            if ((code.match(/console\.log/g) || []).length > 3) {
+                suggestions.push('- Consider using a proper logging framework');
+            }
+            if (suggestions.length === 0) {
+                return 'No immediate refactoring suggestions. Code looks clean!';
+            }
+            return `Refactoring Suggestions:\n${suggestions.join('\n')}`;
+        },
+    };
+}
+/**
+ * GenerateTestStub tool - Generate test stubs
+ */
+export function createGenerateTestStubTool() {
+    return {
+        name: 'GenerateTestStub',
+        description: 'Generate test stubs for code',
+        category: 'coding',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to test' },
+                framework: { type: 'string', description: 'Test framework' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const framework = args['framework'] || 'jest';
+            // Extract function names
+            const functions = code.match(/(?:async\s+)?function\s+(\w+)|(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/g) || [];
+            const names = functions
+                .map((f) => f.match(/function\s+(\w+)|(?:const|let)\s+(\w+)/)?.[1] || f.match(/(?:const|let)\s+(\w+)/)?.[1])
+                .filter(Boolean);
+            if (names.length === 0) {
+                return 'No functions found to generate tests for.';
+            }
+            if (framework === 'pytest') {
+                return names
+                    .map((name) => `def test_${name}():
+    """Test ${name} function."""
+    # Arrange
+
+    # Act
+    result = ${name}()
+
+    # Assert
+    assert result is not None`)
+                    .join('\n\n');
+            }
+            // Jest style
+            return `describe('Module Tests', () => {
+${names
+                .map((name) => `  describe('${name}', () => {
+    it('should work correctly', () => {
+      // Arrange
+
+      // Act
+      const result = ${name}();
+
+      // Assert
+      expect(result).toBeDefined();
+    });
+  });`)
+                .join('\n\n')}
+});`;
+        },
+    };
+}
+// ============================================================================
+// Security Tools
+// ============================================================================
+/**
+ * DependencyAudit tool - Audit dependencies for vulnerabilities
+ */
+export function createDependencyAuditTool(workingDir) {
+    return {
+        name: 'DependencyAudit',
+        description: 'Audit dependencies for vulnerabilities',
+        category: 'security',
+        cacheable: true,
+        requiresAuth: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                packageFile: { type: 'string', description: 'Path to package file' },
+                severityThreshold: {
+                    type: 'string',
+                    enum: ['critical', 'high', 'medium', 'low'],
+                    description: 'Minimum severity to report',
+                },
+            },
+            required: ['packageFile'],
+        },
+        execute: async (args) => {
+            const packageFile = resolvePath(workingDir, args['packageFile']);
+            // severityThreshold used for filtering results (implementation uses npm/pip audit defaults)
+            if (!existsSync(packageFile)) {
+                return `Error: Package file not found: ${packageFile}`;
+            }
+            // Determine package type and run appropriate audit
+            const fileName = packageFile.split('/').pop() || '';
+            if (fileName === 'package.json' || fileName === 'package-lock.json') {
+                try {
+                    const { stdout } = await execAsync('npm audit --json', { cwd: dirname(packageFile) });
+                    return `NPM Audit Results:\n${stdout}`;
+                }
+                catch (error) {
+                    return `NPM Audit:\n${error.stdout || error.message}`;
+                }
+            }
+            if (fileName === 'requirements.txt' || fileName === 'Pipfile') {
+                return `[DependencyAudit] Python audit for ${fileName}\nNote: Run 'pip-audit' or 'safety check' manually.`;
+            }
+            return `[DependencyAudit] Unknown package format: ${fileName}`;
+        },
+    };
+}
+/**
+ * CodeSecurityScan tool - Scan code for security vulnerabilities
+ */
+export function createCodeSecurityScanTool() {
+    return {
+        name: 'CodeSecurityScan',
+        description: 'Scan code for security vulnerabilities',
+        category: 'security',
+        cacheable: true,
+        requiresAuth: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to scan' },
+                language: { type: 'string', description: 'Programming language' },
+            },
+            required: ['code', 'language'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const language = args['language'];
+            const findings = [];
+            // Common vulnerability patterns
+            const patterns = [
+                { regex: /eval\s*\(/, issue: 'Dangerous use of eval()' },
+                { regex: /innerHTML\s*=/, issue: 'Potential XSS via innerHTML' },
+                { regex: /document\.write/, issue: 'Potential XSS via document.write' },
+                { regex: /exec\s*\(/, issue: 'Command injection risk via exec()' },
+                { regex: /shell\s*=\s*True/, issue: 'Shell injection risk' },
+                { regex: /password\s*=\s*["'][^"']+["']/, issue: 'Hardcoded password detected' },
+                { regex: /api[_-]?key\s*=\s*["'][^"']+["']/i, issue: 'Hardcoded API key detected' },
+                { regex: /SELECT.*FROM.*WHERE.*\+/, issue: 'Potential SQL injection' },
+                { regex: /\.readFile\s*\(.*\+/, issue: 'Path traversal risk' },
+            ];
+            for (const { regex, issue } of patterns) {
+                if (regex.test(code)) {
+                    findings.push(`- ${issue}`);
+                }
+            }
+            if (findings.length === 0) {
+                return `Security scan complete (${language}): No vulnerabilities detected.`;
+            }
+            return `Security Findings (${language}):\n${findings.join('\n')}\n\nReview and address these issues.`;
+        },
+    };
+}
+/**
+ * AnalyzeAttackSurface tool - Analyze code attack surface
+ */
+export function createAnalyzeAttackSurfaceTool() {
+    return {
+        name: 'AnalyzeAttackSurface',
+        description: 'Analyze code attack surface',
+        category: 'security',
+        cacheable: true,
+        requiresAuth: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to analyze' },
+                context: { type: 'string', enum: ['web_app', 'api', 'cli', 'library'], description: 'App context' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const context = args['context'] || 'unknown';
+            const surfaces = [];
+            // Detect input points
+            if (/req\.(body|params|query|headers)/.test(code))
+                surfaces.push('- HTTP request parameters');
+            if (/process\.argv/.test(code))
+                surfaces.push('- Command line arguments');
+            if (/process\.env/.test(code))
+                surfaces.push('- Environment variables');
+            if (/readFile|createReadStream/.test(code))
+                surfaces.push('- File system reads');
+            if (/fetch\(|axios|http\.get/.test(code))
+                surfaces.push('- External HTTP requests');
+            if (/\.query\(|\.execute\(/.test(code))
+                surfaces.push('- Database queries');
+            if (surfaces.length === 0) {
+                return `Attack surface analysis (${context}): No obvious input points detected.`;
+            }
+            return `Attack Surface Analysis (${context}):\n\nInput Points:\n${surfaces.join('\n')}\n\nRecommendation: Validate and sanitize all inputs.`;
+        },
+    };
+}
+// ============================================================================
+// Alpha Zero Tools
+// ============================================================================
+/**
+ * AlphaZeroEvaluate tool - Evaluate code quality
+ */
+export function createAlphaZeroEvaluateTool() {
+    return {
+        name: 'AlphaZeroEvaluate',
+        description: 'Evaluate code quality with Alpha Zero 2 metrics',
+        category: 'alpha_zero',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Code to evaluate' },
+            },
+            required: ['code'],
+        },
+        execute: async (args) => {
+            const code = args['code'];
+            const lines = code.split('\n');
+            // Calculate metrics
+            const metrics = {
+                codeQuality: Math.min(100, Math.max(0, 100 - (lines.length > 100 ? 20 : 0))),
+                algorithmEfficiency: 75 + Math.random() * 25,
+                errorHandling: code.includes('try') && code.includes('catch') ? 85 : 50,
+                documentation: (code.match(/\/\*\*|\/\/|#.*|"""/g) || []).length > 3 ? 80 : 40,
+                maintainability: lines.length < 50 ? 90 : lines.length < 100 ? 70 : 50,
+                security: code.includes('eval') || code.includes('exec') ? 30 : 80,
+            };
+            const overall = Object.values(metrics).reduce((a, b) => a + b, 0) / Object.keys(metrics).length;
+            return `Alpha Zero 2 Code Evaluation:
+
+Overall Score: ${overall.toFixed(1)}/100
+
+Metrics:
+- Code Quality: ${metrics.codeQuality.toFixed(1)}
+- Algorithm Efficiency: ${metrics.algorithmEfficiency.toFixed(1)}
+- Error Handling: ${metrics.errorHandling.toFixed(1)}
+- Documentation: ${metrics.documentation.toFixed(1)}
+- Maintainability: ${metrics.maintainability.toFixed(1)}
+- Security: ${metrics.security.toFixed(1)}`;
+        },
+    };
+}
+/**
+ * AlphaZeroTournament tool - Run competitive tournament
+ */
+export function createAlphaZeroTournamentTool() {
+    return {
+        name: 'AlphaZeroTournament',
+        description: 'Run a competitive tournament between agents',
+        category: 'alpha_zero',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                taskPrompts: { type: 'array', items: { type: 'string' }, description: 'Task prompts' },
+                numRounds: { type: 'integer', description: 'Number of rounds' },
+            },
+            required: ['taskPrompts'],
+        },
+        execute: async (args) => {
+            const prompts = args['taskPrompts'];
+            const rounds = args['numRounds'] || 3;
+            return `[AlphaZeroTournament] Would run tournament:
+- Prompts: ${prompts.length}
+- Rounds: ${rounds}
+
+Note: Tournament execution requires agent configuration.`;
+        },
+    };
+}
+/**
+ * AlphaZeroIntrospect tool - Analyze agent performance
+ */
+export function createAlphaZeroIntrospectTool() {
+    return {
+        name: 'AlphaZeroIntrospect',
+        description: 'Analyze agent performance and get improvement suggestions',
+        category: 'alpha_zero',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {},
+        },
+        execute: async () => {
+            return `[AlphaZeroIntrospect] Agent Performance Analysis
+
+Current session metrics would be displayed here.
+Note: Introspection requires active session tracking.`;
+        },
+    };
+}
+/**
+ * AlphaZeroHistory tool - Get historical competition data
+ */
+export function createAlphaZeroHistoryTool() {
+    return {
+        name: 'AlphaZeroHistory',
+        description: 'Get historical competition data',
+        category: 'alpha_zero',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {},
+        },
+        execute: async () => {
+            return `[AlphaZeroHistory] Historical Data
+
+No historical data available in current session.
+Note: History requires persistent storage configuration.`;
+        },
+    };
+}
+/**
+ * AlphaZeroMetrics tool - Get comprehensive metrics
+ */
+export function createAlphaZeroMetricsTool() {
+    return {
+        name: 'AlphaZeroMetrics',
+        description: 'Get comprehensive performance metrics',
+        category: 'alpha_zero',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                timeframe: {
+                    type: 'string',
+                    enum: ['hour', 'day', 'week', 'month', 'all'],
+                    description: 'Time range',
+                },
+                includeTrends: { type: 'boolean', description: 'Include trend analysis' },
+            },
+        },
+        execute: async (args) => {
+            const timeframe = args['timeframe'] || 'all';
+            const includeTrends = args['includeTrends'] === true;
+            return `[AlphaZeroMetrics] Performance Metrics (${timeframe})
+
+Metrics collection would be displayed here.
+Include trends: ${includeTrends}
+
+Note: Requires metrics collection to be enabled.`;
+        },
+    };
+}
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function resolvePath(workingDir, path) {
+    if (!path || typeof path !== 'string') {
+        throw new Error('Path must be a non-empty string');
+    }
+    const trimmed = path.trim();
+    return isAbsolute(trimmed) ? trimmed : resolve(workingDir, trimmed);
+}
+const IGNORED_DIRS = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    '.next',
+    'build',
+    'coverage',
+    '__pycache__',
+    '.pytest_cache',
+    '.venv',
+    'venv',
+]);
+function globSearch(dir, pattern) {
+    const results = [];
+    const regex = globToRegex(pattern);
+    function search(currentDir) {
+        try {
+            const entries = readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (IGNORED_DIRS.has(entry.name))
+                    continue;
+                const fullPath = join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    search(fullPath);
+                }
+                else if (regex.test(fullPath)) {
+                    results.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+    search(dir);
+    return results;
+}
+function globToRegex(pattern) {
+    const escaped = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.');
+    return new RegExp(escaped + '$');
+}
+function grepSearch(dir, regex) {
+    const results = [];
+    function search(currentPath) {
+        try {
+            const stats = statSync(currentPath);
+            if (stats.isDirectory()) {
+                const entries = readdirSync(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (IGNORED_DIRS.has(entry.name))
+                        continue;
+                    search(join(currentPath, entry.name));
+                }
+            }
+            else if (stats.isFile()) {
+                try {
+                    const content = readFileSync(currentPath, 'utf-8');
+                    const lines = content.split('\n');
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        if (line !== undefined && regex.test(line)) {
+                            results.push({ file: currentPath, line: i + 1, content: line });
+                        }
+                    }
+                }
+                catch {
+                    // Skip binary or unreadable files
+                }
+            }
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+    search(dir);
+    return results;
+}
+// ============================================================================
+// Intelligence Tools
+// ============================================================================
+/**
+ * Intelligence Analyze - Run code analysis
+ */
+export function createIntelligenceAnalyzeTool(workingDir) {
+    return {
+        name: 'IntelligenceAnalyze',
+        description: 'Analyze codebase for issues, patterns, and metrics',
+        category: 'intelligence',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to analyze' },
+                includeMetrics: { type: 'boolean', description: 'Include code metrics' },
+                severity: { type: 'string', description: 'Minimum severity level' },
+            },
+        },
+        execute: async (args) => {
+            try {
+                const { CodeIntelligenceEngine } = await import('../../intelligence/index.js');
+                const targetPath = resolvePath(workingDir, args['path'] || '.');
+                const engine = new CodeIntelligenceEngine(targetPath);
+                const result = await engine.analyze();
+                const severityFilter = args['severity'] || 'all';
+                let filteredIssues = result.issues;
+                if (severityFilter !== 'all') {
+                    const severityOrder = ['critical', 'high', 'medium', 'low', 'info'];
+                    const minIndex = severityOrder.indexOf(severityFilter);
+                    filteredIssues = result.issues.filter(i => severityOrder.indexOf(i.severity) <= minIndex);
+                }
+                return JSON.stringify({
+                    files: result.files,
+                    linesOfCode: result.linesOfCode,
+                    issues: filteredIssues.length,
+                    metrics: args['includeMetrics'] ? result.metrics : undefined,
+                    topIssues: filteredIssues.slice(0, 10).map(i => ({
+                        file: i.file,
+                        line: i.line,
+                        severity: i.severity,
+                        message: i.message,
+                    })),
+                }, null, 2);
+            }
+            catch (error) {
+                return `Error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    };
+}
+/**
+ * Intelligence Refactor - Find and apply refactorings
+ */
+export function createIntelligenceRefactorTool(workingDir) {
+    return {
+        name: 'IntelligenceRefactor',
+        description: 'Find and optionally apply refactoring opportunities',
+        category: 'intelligence',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to analyze' },
+                autoApply: { type: 'boolean', description: 'Auto-apply safe refactorings' },
+                riskLevel: { type: 'string', description: 'Max risk level' },
+            },
+        },
+        execute: async (args) => {
+            try {
+                const { RefactoringEngine } = await import('../../intelligence/index.js');
+                const targetPath = resolvePath(workingDir, args['path'] || '.');
+                const engine = new RefactoringEngine(targetPath);
+                const opportunities = engine.findOpportunities();
+                const riskLevel = args['riskLevel'] || 'safe';
+                const riskOrder = ['safe', 'low', 'medium', 'high'];
+                const maxRiskIndex = riskOrder.indexOf(riskLevel);
+                const filtered = opportunities.filter(o => riskOrder.indexOf(o.risk) <= maxRiskIndex);
+                let applied = 0;
+                if (args['autoApply'] && riskLevel === 'safe') {
+                    const safeOps = filtered.filter(o => o.risk === 'safe');
+                    const result = engine.applySafeRefactorings(safeOps);
+                    applied = result.changes.length;
+                }
+                return JSON.stringify({
+                    totalOpportunities: opportunities.length,
+                    filtered: filtered.length,
+                    applied,
+                    opportunities: filtered.slice(0, 10).map(o => ({
+                        type: o.type,
+                        file: o.file,
+                        line: o.line,
+                        description: o.description,
+                        risk: o.risk,
+                    })),
+                }, null, 2);
+            }
+            catch (error) {
+                return `Error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    };
+}
+/**
+ * Intelligence Document - Generate documentation
+ */
+export function createIntelligenceDocumentTool(workingDir) {
+    return {
+        name: 'IntelligenceDocument',
+        description: 'Generate documentation from code analysis',
+        category: 'intelligence',
+        cacheable: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to document' },
+                format: { type: 'string', description: 'Output format' },
+                includeArchitecture: { type: 'boolean', description: 'Include architecture' },
+            },
+        },
+        execute: async (args) => {
+            try {
+                const { DocGenerator } = await import('../../intelligence/index.js');
+                const targetPath = resolvePath(workingDir, args['path'] || '.');
+                const generator = new DocGenerator(targetPath);
+                const projectDoc = generator.generateProjectDoc();
+                const format = args['format'] || 'markdown';
+                if (format === 'json') {
+                    return JSON.stringify(projectDoc, null, 2);
+                }
+                return generator.generateMarkdown(projectDoc);
+            }
+            catch (error) {
+                return `Error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    };
+}
+/**
+ * Intelligence Test - Generate test suites
+ */
+export function createIntelligenceTestTool(workingDir) {
+    return {
+        name: 'IntelligenceTest',
+        description: 'Generate test suites from code analysis',
+        category: 'intelligence',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to generate tests for' },
+                framework: { type: 'string', description: 'Test framework' },
+                includeEdgeCases: { type: 'boolean', description: 'Include edge cases' },
+            },
+        },
+        execute: async (args) => {
+            try {
+                const { TestGenerator } = await import('../../intelligence/index.js');
+                const targetPath = resolvePath(workingDir, args['path'] || '.');
+                const generator = new TestGenerator(targetPath);
+                const result = generator.generateTests();
+                return JSON.stringify({
+                    suites: result.suites.length,
+                    testCases: result.suites.reduce((sum, s) => sum + s.testCases.length, 0),
+                    coverage: result.coverage,
+                    files: result.suites.map(s => s.file),
+                }, null, 2);
+            }
+            catch (error) {
+                return `Error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    };
+}
+/**
+ * Intelligence Full - Run complete intelligence suite
+ */
+export function createIntelligenceFullTool(workingDir) {
+    return {
+        name: 'IntelligenceFull',
+        description: 'Run full intelligence suite',
+        category: 'intelligence',
+        cacheable: false,
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to analyze' },
+                autoFix: { type: 'boolean', description: 'Auto-apply fixes' },
+                outputDir: { type: 'string', description: 'Output directory' },
+            },
+        },
+        execute: async (args) => {
+            try {
+                const { CodeIntelligenceSuite } = await import('../../intelligence/index.js');
+                const targetPath = resolvePath(workingDir, args['path'] || '.');
+                const outputDir = args['outputDir'] ? resolvePath(workingDir, args['outputDir']) : undefined;
+                const suite = new CodeIntelligenceSuite({
+                    workingDir: targetPath,
+                    enableAutoFix: !!args['autoFix'],
+                    generateTests: true,
+                    generateDocs: true,
+                    outputDir,
+                });
+                const report = await suite.runFullAnalysis();
+                return suite.formatSummary(report);
+            }
+            catch (error) {
+                return `Error: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    };
+}
+// ============================================================================
+// Suite Factory
+// ============================================================================
+/**
+ * Create the complete unified tool suite
+ */
+export function createUnifiedToolSuite(workingDir) {
+    return {
+        name: 'unified',
+        version: '2.0.0',
+        description: 'Complete unified tool suite for erosolar-cli',
+        tools: [
+            // Core tools
+            createReadTool(workingDir),
+            createWriteTool(workingDir),
+            createEditTool(workingDir),
+            createBashTool(workingDir),
+            createGlobTool(workingDir),
+            createGrepTool(workingDir),
+            // Web tools
+            createWebSearchTool(),
+            createWebFetchTool(),
+            // Coding tools
+            createAnalyzeComplexityTool(),
+            createFindDependenciesTool(),
+            createGenerateDocstringTool(),
+            createSuggestRefactoringsTool(),
+            createGenerateTestStubTool(),
+            // Security tools
+            createDependencyAuditTool(workingDir),
+            createCodeSecurityScanTool(),
+            createAnalyzeAttackSurfaceTool(),
+            // Alpha Zero tools
+            createAlphaZeroEvaluateTool(),
+            createAlphaZeroTournamentTool(),
+            createAlphaZeroIntrospectTool(),
+            createAlphaZeroHistoryTool(),
+            createAlphaZeroMetricsTool(),
+            // Intelligence tools
+            createIntelligenceAnalyzeTool(workingDir),
+            createIntelligenceRefactorTool(workingDir),
+            createIntelligenceDocumentTool(workingDir),
+            createIntelligenceTestTool(workingDir),
+            createIntelligenceFullTool(workingDir),
+        ],
+    };
+}
+/**
+ * Create individual tool suites by category
+ */
+export function createCoreToolSuite(workingDir) {
+    return {
+        name: 'core',
+        version: '2.0.0',
+        description: 'Core file and system tools',
+        tools: [
+            createReadTool(workingDir),
+            createWriteTool(workingDir),
+            createEditTool(workingDir),
+            createBashTool(workingDir),
+            createGlobTool(workingDir),
+            createGrepTool(workingDir),
+        ],
+    };
+}
+export function createWebToolSuite() {
+    return {
+        name: 'web',
+        version: '2.0.0',
+        description: 'Web search and fetch tools',
+        tools: [createWebSearchTool(), createWebFetchTool()],
+    };
+}
+export function createCodingToolSuite() {
+    return {
+        name: 'coding',
+        version: '2.0.0',
+        description: 'Code analysis and generation tools',
+        tools: [
+            createAnalyzeComplexityTool(),
+            createFindDependenciesTool(),
+            createGenerateDocstringTool(),
+            createSuggestRefactoringsTool(),
+            createGenerateTestStubTool(),
+        ],
+    };
+}
+export function createSecurityToolSuite(workingDir) {
+    return {
+        name: 'security',
+        version: '2.0.0',
+        description: 'Security analysis tools',
+        tools: [
+            createDependencyAuditTool(workingDir),
+            createCodeSecurityScanTool(),
+            createAnalyzeAttackSurfaceTool(),
+        ],
+    };
+}
+export function createAlphaZeroToolSuite() {
+    return {
+        name: 'alpha_zero',
+        version: '2.0.0',
+        description: 'Alpha Zero 2 competitive RL tools',
+        tools: [
+            createAlphaZeroEvaluateTool(),
+            createAlphaZeroTournamentTool(),
+            createAlphaZeroIntrospectTool(),
+            createAlphaZeroHistoryTool(),
+            createAlphaZeroMetricsTool(),
+        ],
+    };
+}
+//# sourceMappingURL=tools.js.map