erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/tools/fileTools.js

@@ -1,282 +0,0 @@
-import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync } from 'node:fs';
-import { join, dirname, relative } from 'node:path';
-import { buildError } from '../core/errors.js';
-import { buildDiffSegments, formatDiffLines } from './diffUtils.js';
-export function createFileTools(workingDir) {
-    return [
-        {
-            name: 'read_file',
-            description: 'Read the contents of a file at the specified path',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'The file path (relative to working directory or absolute)',
-                        minLength: 1,
-                    },
-                },
-                required: ['path'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pathArg = args['path'];
-                const requestedPath = normalizePathContext(pathArg);
-                let resolvedPath;
-                try {
-                    const filePath = resolveFilePath(workingDir, pathArg);
-                    resolvedPath = filePath;
-                    if (!existsSync(filePath)) {
-                        return `Error: File not found: ${filePath}`;
-                    }
-                    const content = readFileSync(filePath, 'utf-8');
-                    return `File: ${filePath}\n\n${content}`;
-                }
-                catch (error) {
-                    return buildError('reading file', error, { path: requestedPath, resolvedPath });
-                }
-            },
-        },
-        {
-            name: 'write_file',
-            description: 'Write content to a file at the specified path (creates directories if needed)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'The file path (relative to working directory or absolute)',
-                        minLength: 1,
-                    },
-                    content: {
-                        type: 'string',
-                        description: 'The content to write to the file',
-                    },
-                },
-                required: ['path', 'content'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pathArg = args['path'];
-                const requestedPath = normalizePathContext(pathArg);
-                let resolvedPath;
-                try {
-                    const filePath = resolveFilePath(workingDir, pathArg);
-                    resolvedPath = filePath;
-                    const dir = dirname(filePath);
-                    if (!existsSync(dir)) {
-                        mkdirSync(dir, { recursive: true });
-                    }
-                    const nextContent = typeof args['content'] === 'string' ? args['content'] : '';
-                    const filePreviouslyExisted = existsSync(filePath);
-                    const previousContent = filePreviouslyExisted ? readFileSync(filePath, 'utf-8') : '';
-                    const diffSegments = buildDiffSegments(previousContent, nextContent);
-                    writeFileSync(filePath, nextContent, 'utf-8');
-                    return buildWriteSummary(filePath, diffSegments, workingDir, filePreviouslyExisted);
-                }
-                catch (error) {
-                    return buildError('writing file', error, { path: requestedPath, resolvedPath });
-                }
-            },
-        },
-        {
-            name: 'list_files',
-            description: 'List files and directories at the specified path',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'The directory path (defaults to current working directory)',
-                        minLength: 1,
-                    },
-                    recursive: {
-                        type: 'boolean',
-                        description: 'Whether to list files recursively',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pathArg = args['path'];
-                const requestedPath = normalizePathContext(pathArg);
-                let resolvedPath;
-                try {
-                    const dirPath = pathArg !== undefined && pathArg !== null ? resolveFilePath(workingDir, pathArg) : workingDir;
-                    resolvedPath = dirPath;
-                    const recursive = args['recursive'] === true;
-                    if (!existsSync(dirPath)) {
-                        return `Error: Directory not found: ${dirPath}`;
-                    }
-                    const files = listFilesRecursive(dirPath, recursive ? 5 : 1, workingDir);
-                    return `Directory: ${dirPath}\n\n${files.join('\n')}`;
-                }
-                catch (error) {
-                    return buildError('listing files', error, { path: requestedPath, resolvedPath });
-                }
-            },
-        },
-        {
-            name: 'search_files',
-            description: 'Search for files matching a pattern (supports glob patterns)',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pattern: {
-                        type: 'string',
-                        description: 'The search pattern (e.g., "*.ts", "src/**/*.js")',
-                        minLength: 1,
-                    },
-                    path: {
-                        type: 'string',
-                        description: 'The directory to search in (defaults to current working directory)',
-                        minLength: 1,
-                    },
-                },
-                required: ['pattern'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pathArg = args['path'];
-                const requestedPath = normalizePathContext(pathArg);
-                const patternArg = args['pattern'];
-                const requestedPattern = typeof patternArg === 'string' ? patternArg : undefined;
-                let resolvedPath;
-                try {
-                    const pattern = typeof patternArg === 'string' && patternArg.trim() ? patternArg : null;
-                    if (!pattern) {
-                        return 'Error: pattern must be a non-empty string.';
-                    }
-                    const searchPath = pathArg !== undefined && pathArg !== null ? resolveFilePath(workingDir, pathArg) : workingDir;
-                    resolvedPath = searchPath;
-                    const results = searchFilesGlob(searchPath, pattern);
-                    if (results.length === 0) {
-                        return `No files found matching pattern: ${pattern}`;
-                    }
-                    return `Found ${results.length} files:\n\n${results.map((f) => relative(workingDir, f)).join('\n')}`;
-                }
-                catch (error) {
-                    return buildError('searching files', error, {
-                        path: requestedPath,
-                        resolvedPath,
-                        pattern: requestedPattern,
-                    });
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    const validated = validatePathArg(path);
-    return validated.startsWith('/') ? validated : join(workingDir, validated);
-}
-function validatePathArg(path) {
-    if (typeof path !== 'string' || !path.trim()) {
-        throw new Error('Path must be a non-empty string.');
-    }
-    return path.trim();
-}
-function normalizePathContext(path) {
-    if (path === undefined || path === null) {
-        return undefined;
-    }
-    try {
-        return String(path);
-    }
-    catch {
-        return '(unprintable)';
-    }
-}
-function listFilesRecursive(dir, maxDepth, baseDir, currentDepth = 0) {
-    if (currentDepth >= maxDepth) {
-        return [];
-    }
-    const ignoredDirs = new Set(['.git', 'node_modules', 'dist', '.next', 'build', 'coverage']);
-    const results = [];
-    try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (ignoredDirs.has(entry.name)) {
-                continue;
-            }
-            const fullPath = join(dir, entry.name);
-            const indent = '  '.repeat(currentDepth);
-            if (entry.isDirectory()) {
-                results.push(`${indent}${entry.name}/`);
-                results.push(...listFilesRecursive(fullPath, maxDepth, baseDir, currentDepth + 1));
-            }
-            else {
-                const stats = statSync(fullPath);
-                const size = formatFileSize(stats.size);
-                results.push(`${indent}${entry.name} ${size}`);
-            }
-        }
-    }
-    catch (error) {
-    }
-    return results;
-}
-function searchFilesGlob(dir, pattern) {
-    const results = [];
-    const regex = globToRegex(pattern);
-    function search(currentDir) {
-        const ignoredDirs = new Set(['.git', 'node_modules', 'dist', '.next', 'build', 'coverage']);
-        try {
-            const entries = readdirSync(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (ignoredDirs.has(entry.name)) {
-                    continue;
-                }
-                const fullPath = join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    search(fullPath);
-                }
-                else if (regex.test(fullPath)) {
-                    results.push(fullPath);
-                }
-            }
-        }
-        catch (error) {
-        }
-    }
-    search(dir);
-    return results;
-}
-function buildWriteSummary(filePath, diffSegments, workingDir, filePreviouslyExisted) {
-    const readablePath = formatRelativeFilePath(filePath, workingDir);
-    const addedLines = diffSegments.filter((segment) => segment.type === 'added').length;
-    const removedLines = diffSegments.filter((segment) => segment.type === 'removed').length;
-    const hasChanges = diffSegments.length > 0;
-    const actionLabel = !filePreviouslyExisted ? 'Added' : hasChanges ? 'Edited' : 'Updated';
-    const header = `#### ${actionLabel} ${readablePath}`;
-    if (!hasChanges) {
-        return `${header}\nNo textual changes.`;
-    }
-    const statsLine = `Lines changed: +${addedLines} / -${removedLines}`;
-    const diffLines = formatDiffLines(diffSegments);
-    const diffBlock = ['```diff', ...diffLines, '```'].join('\n');
-    const sections = [header, statsLine, '', 'Diff preview:', diffBlock];
-    return sections.join('\n').trimEnd();
-}
-function formatRelativeFilePath(filePath, workingDir) {
-    const relPath = relative(workingDir, filePath);
-    if (!relPath || relPath.startsWith('..')) {
-        return filePath;
-    }
-    return relPath;
-}
-function globToRegex(pattern) {
-    const escaped = pattern
-        .replace(/\./g, '\\.')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '.');
-    return new RegExp(escaped);
-}
-function formatFileSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}

package/dist/bin/tools/globTools.js

@@ -1,173 +0,0 @@
-import { readdirSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { buildError } from '../core/errors.js';
-/**
- * Creates the Glob tool for fast file pattern matching
- *
- * Features:
- * - Supports glob patterns like wildcard recursion or directory matching
- * - Returns matching file paths sorted by modification time (newest first)
- * - Ignores common directories (.git, node_modules, dist)
- * - Fast pattern matching optimized for large codebases
- *
- * @param workingDir - The working directory for pattern matching
- * @returns Array containing the Glob tool definition
- */
-export function createGlobTools(workingDir) {
-    return [
-        {
-            name: 'Glob',
-            description: 'Fast file pattern matching tool that works with any codebase size. Supports glob patterns like "**/*.js" or "src/**/*.ts". Returns matching file paths sorted by modification time.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    pattern: {
-                        type: 'string',
-                        description: 'The glob pattern to match files against (e.g., "**/*.ts", "src/**/*.js", "*.md"). Avoid overly broad patterns like "." or "*" - be specific.',
-                    },
-                    path: {
-                        type: 'string',
-                        description: 'The directory to search in. If not specified, the current working directory will be used.',
-                    },
-                    head_limit: {
-                        type: 'number',
-                        description: 'Maximum number of files to return. Defaults to 20. Use higher values only when necessary to reduce context usage.',
-                    },
-                },
-                required: ['pattern'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pattern = args['pattern'];
-                const pathArg = args['path'];
-                const headLimit = typeof args['head_limit'] === 'number' ? args['head_limit'] : 20; // Default to 20 files
-                // Validate pattern
-                if (typeof pattern !== 'string' || !pattern.trim()) {
-                    return 'Error: pattern must be a non-empty string.';
-                }
-                // Warn about overly broad patterns
-                const trimmedPattern = pattern.trim();
-                if (trimmedPattern === '.' || trimmedPattern === '*' || trimmedPattern === '**/*') {
-                    return `Warning: Pattern "${pattern}" is too broad and will match many files. Please use a more specific pattern like "**/*.ts" or "src/**/*.js" to reduce context usage.`;
-                }
-                try {
-                    const searchPath = pathArg && typeof pathArg === 'string'
-                        ? resolveFilePath(workingDir, pathArg)
-                        : workingDir;
-                    // Perform glob search
-                    const matches = globSearch(searchPath, pattern);
-                    // Sort by modification time (newest first)
-                    const sorted = matches.sort((a, b) => {
-                        try {
-                            const statA = statSync(a);
-                            const statB = statSync(b);
-                            return statB.mtimeMs - statA.mtimeMs;
-                        }
-                        catch {
-                            return 0;
-                        }
-                    });
-                    // Convert to relative paths
-                    const relativePaths = sorted.map(filePath => {
-                        const rel = relative(workingDir, filePath);
-                        return rel && !rel.startsWith('..') ? rel : filePath;
-                    });
-                    if (relativePaths.length === 0) {
-                        return `No files found matching pattern: ${pattern}`;
-                    }
-                    // Apply head_limit
-                    const totalMatches = relativePaths.length;
-                    const limited = relativePaths.slice(0, headLimit);
-                    const truncated = totalMatches > headLimit;
-                    const summary = totalMatches === 1
-                        ? '1 file found'
-                        : `${totalMatches} file${totalMatches === 1 ? '' : 's'} found`;
-                    let result = `${summary} matching "${pattern}":`;
-                    if (truncated) {
-                        result += ` (showing first ${headLimit} of ${totalMatches})`;
-                    }
-                    result += `\n\n${limited.join('\n')}`;
-                    if (truncated) {
-                        result += `\n\n... [${totalMatches - headLimit} more files truncated. Use head_limit parameter to see more]`;
-                    }
-                    return result;
-                }
-                catch (error) {
-                    return buildError('glob search', error, {
-                        pattern: String(pattern),
-                        path: pathArg ? String(pathArg) : undefined,
-                    });
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    const normalized = path.trim();
-    return normalized.startsWith('/') ? normalized : join(workingDir, normalized);
-}
-function globSearch(baseDir, pattern) {
-    const results = [];
-    const regex = globToRegex(pattern);
-    const ignoredDirs = new Set([
-        '.git',
-        'node_modules',
-        'dist',
-        '.next',
-        'build',
-        'coverage',
-        '.turbo',
-        '.cache',
-        '__pycache__',
-        '.pytest_cache',
-        '.venv',
-        'venv',
-    ]);
-    function search(currentDir) {
-        try {
-            const entries = readdirSync(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (ignoredDirs.has(entry.name)) {
-                    continue;
-                }
-                const fullPath = join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    search(fullPath);
-                }
-                else {
-                    // Test the full path against the pattern
-                    if (regex.test(fullPath)) {
-                        results.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Silently ignore permission errors
-        }
-    }
-    search(baseDir);
-    return results;
-}
-function globToRegex(pattern) {
-    // Escape special regex characters except glob wildcards
-    let escaped = pattern
-        .replace(/\./g, '\\.')
-        .replace(/\+/g, '\\+')
-        .replace(/\^/g, '\\^')
-        .replace(/\$/g, '\\$')
-        .replace(/\(/g, '\\(')
-        .replace(/\)/g, '\\)')
-        .replace(/\[/g, '\\[')
-        .replace(/\]/g, '\\]')
-        .replace(/\{/g, '\\{')
-        .replace(/\}/g, '\\}')
-        .replace(/\|/g, '\\|');
-    // Convert glob patterns to regex
-    escaped = escaped
-        .replace(/\*\*/g, '<!GLOBSTAR!>') // Placeholder for **
-        .replace(/\*/g, '[^/]*') // * matches any characters except /
-        .replace(/<!GLOBSTAR!>/g, '.*') // ** matches any characters including /
-        .replace(/\?/g, '.'); // ? matches any single character
-    return new RegExp(escaped + '$');
-}