erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/tools/grepTools.js

@@ -1,332 +0,0 @@
-import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { join, relative, extname } from 'node:path';
-import { buildError } from '../core/errors.js';
-/**
- * Creates the Grep tool - a powerful search tool built on ripgrep patterns
- *
- * Features:
- * - Full regex syntax support
- * - Multiple output modes (content, files_with_matches, count)
- * - Context lines (-A, -B, -C)
- * - Case insensitivity
- * - Type filtering (js, ts, py, etc.)
- * - Glob pattern filtering
- * - Multiline matching
- * - Head/offset limiting
- *
- * @param workingDir - The working directory for searching
- * @returns Array containing the Grep tool definition
- */
-export function createGrepTools(workingDir) {
-    return [
-        {
-            name: 'Grep',
-            description: 'A powerful search tool built on ripgrep patterns. Supports full regex syntax, multiple output modes, and context lines. Use for searching file contents.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pattern: {
-                        type: 'string',
-                        description: 'The regular expression pattern to search for in file contents',
-                    },
-                    path: {
-                        type: 'string',
-                        description: 'File or directory to search in (defaults to current working directory)',
-                    },
-                    output_mode: {
-                        type: 'string',
-                        description: 'Output mode: "content" shows matching lines, "files_with_matches" shows file paths (default), "count" shows match counts',
-                    },
-                    '-i': {
-                        type: 'boolean',
-                        description: 'Case insensitive search',
-                    },
-                    '-n': {
-                        type: 'boolean',
-                        description: 'Show line numbers in output (requires output_mode: "content"). Defaults to true.',
-                    },
-                    '-A': {
-                        type: 'number',
-                        description: 'Number of lines to show after each match (requires output_mode: "content")',
-                    },
-                    '-B': {
-                        type: 'number',
-                        description: 'Number of lines to show before each match (requires output_mode: "content")',
-                    },
-                    '-C': {
-                        type: 'number',
-                        description: 'Number of lines to show before and after each match (requires output_mode: "content")',
-                    },
-                    glob: {
-                        type: 'string',
-                        description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")',
-                    },
-                    type: {
-                        type: 'string',
-                        description: 'File type to search (e.g. "js", "py", "rust", "go"). More efficient than glob for standard file types.',
-                    },
-                    multiline: {
-                        type: 'boolean',
-                        description: 'Enable multiline mode where . matches newlines and patterns can span lines. Default: false.',
-                    },
-                    head_limit: {
-                        type: 'number',
-                        description: 'Limit output to first N entries. Defaults: content=20, files=30, count=50. Always use low values to prevent context overflow.',
-                    },
-                    offset: {
-                        type: 'number',
-                        description: 'Skip first N lines/entries before applying head_limit. Defaults to 0.',
-                    },
-                },
-                required: ['pattern'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pattern = args['pattern'];
-                const pathArg = args['path'];
-                const outputMode = args['output_mode'] || 'files_with_matches';
-                const caseInsensitive = args['-i'] === true;
-                const showLineNumbers = args['-n'] !== false; // Default true
-                const afterContext = typeof args['-A'] === 'number' ? args['-A'] : 0;
-                const beforeContext = typeof args['-B'] === 'number' ? args['-B'] : 0;
-                const contextLines = typeof args['-C'] === 'number' ? args['-C'] : 0;
-                const globPattern = args['glob'];
-                const fileType = args['type'];
-                const multiline = args['multiline'] === true;
-                // CRITICAL: Much lower defaults based on output mode
-                const defaultLimit = outputMode === 'content' ? 20 : (outputMode === 'count' ? 50 : 30);
-                const headLimit = typeof args['head_limit'] === 'number' ? args['head_limit'] : defaultLimit;
-                const offset = typeof args['offset'] === 'number' ? args['offset'] : 0;
-                // Validate pattern
-                if (typeof pattern !== 'string' || !pattern.trim()) {
-                    return 'Error: pattern must be a non-empty string.';
-                }
-                // Validate output_mode
-                if (outputMode !== 'content' && outputMode !== 'files_with_matches' && outputMode !== 'count') {
-                    return 'Error: output_mode must be "content", "files_with_matches", or "count".';
-                }
-                try {
-                    const searchPath = pathArg && typeof pathArg === 'string'
-                        ? resolveFilePath(workingDir, pathArg)
-                        : workingDir;
-                    // Create regex with appropriate flags
-                    const flags = caseInsensitive ? 'gi' : 'g';
-                    const dotallFlags = multiline ? (caseInsensitive ? 'gis' : 'gs') : flags;
-                    const regex = new RegExp(pattern, dotallFlags);
-                    // Perform search
-                    const matches = searchFiles(searchPath, regex, {
-                        globPattern: typeof globPattern === 'string' ? globPattern : undefined,
-                        fileType: typeof fileType === 'string' ? fileType : undefined,
-                        multiline,
-                    });
-                    // Apply offset and head_limit
-                    const totalMatches = matches.length;
-                    const filteredMatches = applyOffsetAndLimit(matches, offset, headLimit);
-                    const truncated = totalMatches > filteredMatches.length;
-                    // Format output based on mode
-                    let result;
-                    switch (outputMode) {
-                        case 'content':
-                            result = formatContentOutput(filteredMatches, {
-                                showLineNumbers,
-                                beforeContext: contextLines || beforeContext,
-                                afterContext: contextLines || afterContext,
-                                searchPath,
-                            });
-                            break;
-                        case 'count':
-                            result = formatCountOutput(filteredMatches, searchPath);
-                            break;
-                        case 'files_with_matches':
-                        default:
-                            result = formatFilesOutput(filteredMatches, searchPath);
-                            break;
-                    }
-                    // Add truncation notice
-                    if (truncated) {
-                        result += `\n\n... [${totalMatches - filteredMatches.length} more matches truncated. Use head_limit parameter to see more]`;
-                    }
-                    return result;
-                }
-                catch (error) {
-                    return buildError('grep search', error, {
-                        pattern: String(pattern),
-                        path: pathArg ? String(pathArg) : undefined,
-                        output_mode: String(outputMode),
-                    });
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    const normalized = path.trim();
-    return normalized.startsWith('/') ? normalized : join(workingDir, normalized);
-}
-function searchFiles(searchPath, regex, options) {
-    const results = [];
-    const ignoredDirs = new Set([
-        '.git', 'node_modules', 'dist', '.next', 'build', 'coverage',
-        '.turbo', '.cache', '__pycache__', '.pytest_cache', '.venv', 'venv',
-    ]);
-    function search(currentPath) {
-        try {
-            const stat = statSync(currentPath);
-            if (stat.isDirectory()) {
-                const entries = readdirSync(currentPath);
-                for (const entry of entries) {
-                    if (ignoredDirs.has(entry))
-                        continue;
-                    search(join(currentPath, entry));
-                }
-            }
-            else if (stat.isFile()) {
-                // Filter by file type or glob
-                if (options.fileType && !matchesFileType(currentPath, options.fileType)) {
-                    return;
-                }
-                if (options.globPattern && !matchesGlob(currentPath, options.globPattern)) {
-                    return;
-                }
-                // Skip binary files
-                if (isBinaryFile(currentPath)) {
-                    return;
-                }
-                // Read and search file
-                const content = readFileSync(currentPath, 'utf-8');
-                if (options.multiline) {
-                    // Multiline mode: search entire content
-                    const matches = content.match(regex);
-                    if (matches) {
-                        for (const match of matches) {
-                            results.push({
-                                file: currentPath,
-                                line: 1, // In multiline, line numbers are approximate
-                                content: match,
-                                match,
-                            });
-                        }
-                    }
-                }
-                else {
-                    // Line-by-line mode
-                    const lines = content.split('\n');
-                    lines.forEach((line, index) => {
-                        const matches = line.match(regex);
-                        if (matches) {
-                            results.push({
-                                file: currentPath,
-                                line: index + 1,
-                                content: line,
-                                match: matches[0],
-                            });
-                        }
-                    });
-                }
-            }
-        }
-        catch (error) {
-            // Silently ignore permission errors
-        }
-    }
-    search(searchPath);
-    return results;
-}
-function applyOffsetAndLimit(matches, offset, headLimit) {
-    let result = matches;
-    if (offset > 0) {
-        result = result.slice(offset);
-    }
-    if (headLimit !== undefined && headLimit > 0) {
-        result = result.slice(0, headLimit);
-    }
-    return result;
-}
-function formatContentOutput(matches, options) {
-    if (matches.length === 0) {
-        return 'No matches found.';
-    }
-    const lines = [];
-    for (const match of matches) {
-        const relPath = relative(options.searchPath, match.file);
-        const displayPath = relPath && !relPath.startsWith('..') ? relPath : match.file;
-        if (options.showLineNumbers) {
-            lines.push(`${displayPath}:${match.line}:${match.content}`);
-        }
-        else {
-            lines.push(`${displayPath}:${match.content}`);
-        }
-    }
-    return lines.join('\n');
-}
-function formatFilesOutput(matches, searchPath) {
-    if (matches.length === 0) {
-        return 'No matches found.';
-    }
-    // Get unique file paths
-    const uniqueFiles = [...new Set(matches.map(m => m.file))];
-    const relativePaths = uniqueFiles.map(file => {
-        const rel = relative(searchPath, file);
-        return rel && !rel.startsWith('..') ? rel : file;
-    });
-    return relativePaths.join('\n');
-}
-function formatCountOutput(matches, searchPath) {
-    if (matches.length === 0) {
-        return 'No matches found.';
-    }
-    // Count matches per file
-    const counts = new Map();
-    for (const match of matches) {
-        counts.set(match.file, (counts.get(match.file) || 0) + 1);
-    }
-    const lines = [];
-    for (const [file, count] of counts) {
-        const relPath = relative(searchPath, file);
-        const displayPath = relPath && !relPath.startsWith('..') ? relPath : file;
-        lines.push(`${count}:${displayPath}`);
-    }
-    return lines.join('\n');
-}
-function matchesFileType(filePath, fileType) {
-    const ext = extname(filePath).toLowerCase();
-    const typeMap = {
-        js: ['.js', '.jsx', '.mjs', '.cjs'],
-        ts: ['.ts', '.tsx'],
-        py: ['.py'],
-        rust: ['.rs'],
-        go: ['.go'],
-        java: ['.java'],
-        cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.h'],
-        c: ['.c', '.h'],
-        ruby: ['.rb'],
-        php: ['.php'],
-        html: ['.html', '.htm'],
-        css: ['.css', '.scss', '.sass'],
-        json: ['.json'],
-        yaml: ['.yaml', '.yml'],
-        md: ['.md', '.markdown'],
-    };
-    const extensions = typeMap[fileType.toLowerCase()];
-    return extensions ? extensions.includes(ext) : false;
-}
-function matchesGlob(filePath, globPattern) {
-    const pattern = globPattern
-        .replace(/\./g, '\\.')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '.');
-    const regex = new RegExp(pattern + '$');
-    return regex.test(filePath);
-}
-function isBinaryFile(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    const binaryExts = new Set([
-        '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg',
-        '.pdf', '.zip', '.tar', '.gz', '.7z', '.rar',
-        '.exe', '.dll', '.so', '.dylib', '.bin',
-        '.mp3', '.mp4', '.avi', '.mov', '.flv',
-        '.woff', '.woff2', '.ttf', '.eot',
-    ]);
-    return binaryExts.has(ext);
-}

package/dist/bin/tools/interactionTools.js

@@ -1,170 +0,0 @@
-import * as readline from 'node:readline';
-export function createInteractionTools() {
-    return [
-        {
-            name: 'AskUserQuestion',
-            description: `Use this tool when you need to ask the user questions during execution. This allows you to:
-1. Gather user preferences or requirements
-2. Clarify ambiguous instructions
-3. Get decisions on implementation choices as you work
-4. Offer choices to the user about what direction to take
-
-Usage notes:
-- Users will always be able to select "Other" to provide custom text input
-- Use multiSelect: true to allow multiple answers to be selected for a question`,
-            parameters: {
-                type: 'object',
-                properties: {
-                    questions: {
-                        description: 'Questions to ask the user (1-4 questions)',
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                question: {
-                                    type: 'string',
-                                    description: 'The complete question to ask the user. Should be clear, specific, and end with a question mark. Example: "Which library should we use for date formatting?" If multiSelect is true, phrase it accordingly, e.g. "Which features do you want to enable?"',
-                                },
-                                header: {
-                                    type: 'string',
-                                    description: 'Very short label displayed as a chip/tag (max 12 chars). Examples: "Auth method", "Library", "Approach".',
-                                },
-                                options: {
-                                    type: 'array',
-                                    description: 'The available choices for this question. Must have 2-4 options. Each option should be a distinct, mutually exclusive choice (unless multiSelect is enabled). There should be no "Other" option, that will be provided automatically.',
-                                    items: {
-                                        type: 'object',
-                                        properties: {
-                                            label: {
-                                                type: 'string',
-                                                description: 'The display text for this option that the user will see and select. Should be concise (1-5 words) and clearly describe the choice.',
-                                            },
-                                            description: {
-                                                type: 'string',
-                                                description: 'Explanation of what this option means or what will happen if chosen. Useful for providing context about trade-offs or implications.',
-                                            },
-                                        },
-                                        required: ['label', 'description'],
-                                        additionalProperties: false,
-                                    },
-                                },
-                                multiSelect: {
-                                    type: 'boolean',
-                                    description: 'Set to true to allow the user to select multiple options instead of just one. Use when choices are not mutually exclusive.',
-                                },
-                            },
-                            required: ['question', 'header', 'options', 'multiSelect'],
-                            additionalProperties: false,
-                        },
-                    },
-                    answers: {
-                        type: 'object',
-                        description: 'User answers collected by the permission component',
-                    },
-                },
-                required: ['questions'],
-            },
-            handler: async (args) => {
-                const questions = args['questions'];
-                const answers = args['answers'];
-                if (!questions || !Array.isArray(questions)) {
-                    return 'Error: questions parameter is required and must be an array.';
-                }
-                if (answers) {
-                    // Answers were already provided (e.g., by an interactive UI layer)
-                    let output = '📋 User Responses:\n\n';
-                    for (const [key, value] of Object.entries(answers)) {
-                        output += `${key}: ${value}\n`;
-                    }
-                    return output;
-                }
-                // Interactive mode - ask questions via terminal
-                const rl = readline.createInterface({
-                    input: process.stdin,
-                    output: process.stdout,
-                });
-                const userAnswers = {};
-                try {
-                    for (let i = 0; i < questions.length; i++) {
-                        const q = questions[i];
-                        if (!q)
-                            continue;
-                        console.log(`\n[${q.header}] ${q.question}`);
-                        console.log('');
-                        q.options.forEach((opt, idx) => {
-                            console.log(`  ${idx + 1}. ${opt.label}`);
-                            console.log(`     ${opt.description}`);
-                        });
-                        console.log(`  ${q.options.length + 1}. Other (custom input)`);
-                        console.log('');
-                        const answer = await new Promise((resolve) => {
-                            rl.question(q.multiSelect
-                                ? `Select options (comma-separated numbers, e.g., "1,3"): `
-                                : `Select an option (1-${q.options.length + 1}): `, (input) => {
-                                resolve(input.trim());
-                            });
-                        });
-                        if (q.multiSelect) {
-                            // Handle multi-select
-                            const selections = answer
-                                .split(',')
-                                .map((s) => s.trim())
-                                .filter((s) => s.length > 0);
-                            const selectedOptions = [];
-                            for (const sel of selections) {
-                                const idx = parseInt(sel, 10);
-                                if (idx >= 1 && idx <= q.options.length) {
-                                    const option = q.options[idx - 1];
-                                    if (option) {
-                                        selectedOptions.push(option.label);
-                                    }
-                                }
-                                else if (idx === q.options.length + 1) {
-                                    const customAnswer = await new Promise((resolve) => {
-                                        rl.question('Enter custom value: ', (input) => {
-                                            resolve(input.trim());
-                                        });
-                                    });
-                                    selectedOptions.push(customAnswer);
-                                }
-                            }
-                            userAnswers[q.header] = selectedOptions.join(', ');
-                        }
-                        else {
-                            // Handle single select
-                            const idx = parseInt(answer, 10);
-                            if (idx >= 1 && idx <= q.options.length) {
-                                const option = q.options[idx - 1];
-                                if (option) {
-                                    userAnswers[q.header] = option.label;
-                                }
-                                else {
-                                    userAnswers[q.header] = 'Invalid selection';
-                                }
-                            }
-                            else if (idx === q.options.length + 1) {
-                                const customAnswer = await new Promise((resolve) => {
-                                    rl.question('Enter custom value: ', (input) => {
-                                        resolve(input.trim());
-                                    });
-                                });
-                                userAnswers[q.header] = customAnswer;
-                            }
-                            else {
-                                userAnswers[q.header] = 'Invalid selection';
-                            }
-                        }
-                    }
-                    let output = '\n📋 User Responses:\n\n';
-                    for (const [key, value] of Object.entries(userAnswers)) {
-                        output += `${key}: ${value}\n`;
-                    }
-                    return output;
-                }
-                finally {
-                    rl.close();
-                }
-            },
-        },
-    ];
-}