erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/tools/devTools.js

@@ -1,238 +0,0 @@
-import { exec } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-const execAsync = promisify(exec);
-export function createDevTools(workingDir) {
-    return [
-        {
-            name: 'run_tests',
-            description: 'Execute test suite using npm test or other test runners',
-            parameters: {
-                type: 'object',
-                properties: {
-                    testPattern: {
-                        type: 'string',
-                        description: 'Optional test pattern or file to run specific tests',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds (default: 60000)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const testPatternArg = args['testPattern'];
-                const testPattern = typeof testPatternArg === 'string' && testPatternArg.trim() ? testPatternArg.trim() : undefined;
-                const timeoutArg = args['timeout'];
-                const timeout = typeof timeoutArg === 'number' && Number.isFinite(timeoutArg) && timeoutArg > 0 ? timeoutArg : 60000;
-                try {
-                    // Check if package.json exists
-                    const packageJsonPath = join(workingDir, 'package.json');
-                    if (!existsSync(packageJsonPath)) {
-                        return 'Error: package.json not found. Cannot run tests.';
-                    }
-                    // Build test command
-                    let command = 'npm test';
-                    if (testPattern) {
-                        // Try to detect test runner and build appropriate command
-                        const packageInfo = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                        const scripts = packageInfo.scripts || {};
-                        const testScript = scripts['test'] ?? '';
-                        if (testScript.includes('jest')) {
-                            command = `npx jest ${testPattern}`;
-                        }
-                        else if (testScript.includes('vitest')) {
-                            command = `npx vitest run ${testPattern}`;
-                        }
-                        else if (testScript.includes('mocha')) {
-                            command = `npx mocha ${testPattern}`;
-                        }
-                        else {
-                            // Fallback to npm test with pattern
-                            command = `npm test -- ${testPattern}`;
-                        }
-                    }
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10, // 10MB
-                    });
-                    let result = `Test command: ${command}\n\n`;
-                    if (stdout)
-                        result += `stdout:\n${stdout}\n`;
-                    if (stderr)
-                        result += `stderr:\n${stderr}\n`;
-                    return result || 'Tests completed (no output)';
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return `Error: Test command timed out after ${timeout}ms`;
-                    }
-                    return `Error running tests: ${error.message}\nstderr: ${error.stderr || 'none'}`;
-                }
-            },
-        },
-        {
-            name: 'install_dependencies',
-            description: 'Install project dependencies using npm, yarn, or pnpm',
-            parameters: {
-                type: 'object',
-                properties: {
-                    packageManager: {
-                        type: 'string',
-                        enum: ['npm', 'yarn', 'pnpm'],
-                        description: 'Package manager to use (default: npm)',
-                    },
-                    production: {
-                        type: 'boolean',
-                        description: 'Install only production dependencies',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const packageManager = typeof args['packageManager'] === 'string' ? args['packageManager'] : 'npm';
-                const production = args['production'] === true;
-                try {
-                    let command;
-                    if (packageManager === 'npm') {
-                        command = production ? 'npm ci --production' : 'npm ci';
-                    }
-                    else if (packageManager === 'yarn') {
-                        command = production ? 'yarn install --production' : 'yarn install';
-                    }
-                    else if (packageManager === 'pnpm') {
-                        command = production ? 'pnpm install --prod' : 'pnpm install';
-                    }
-                    else {
-                        return `Error: Unsupported package manager: ${packageManager}`;
-                    }
-                    const { stdout, stderr } = await execAsync(command, {
-                        cwd: workingDir,
-                        timeout: 300000, // 5 minutes
-                        maxBuffer: 1024 * 1024 * 10,
-                    });
-                    let result = `Dependency installation command: ${command}\n\n`;
-                    if (stdout)
-                        result += `stdout:\n${stdout}\n`;
-                    if (stderr)
-                        result += `stderr:\n${stderr}\n`;
-                    return result || 'Dependencies installed successfully (no output)';
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return 'Error: Dependency installation timed out';
-                    }
-                    return `Error installing dependencies: ${error.message}\nstderr: ${error.stderr || 'none'}`;
-                }
-            },
-        },
-        {
-            name: 'check_package_info',
-            description: 'Get information about project dependencies and scripts from package.json',
-            parameters: {
-                type: 'object',
-                properties: {
-                    detail: {
-                        type: 'string',
-                        enum: ['basic', 'dependencies', 'scripts', 'full'],
-                        description: 'Level of detail to include',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const detailArg = args['detail'];
-                const detail = typeof detailArg === 'string' && detailArg.trim() ? detailArg : 'basic';
-                try {
-                    const packageJsonPath = join(workingDir, 'package.json');
-                    if (!existsSync(packageJsonPath)) {
-                        return 'Error: package.json not found';
-                    }
-                    const packageInfo = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-                    const output = [];
-                    output.push(`# Package Info: ${packageInfo.name || 'Unnamed'} v${packageInfo.version || 'Unknown'}`);
-                    output.push('');
-                    if (detail === 'basic' || detail === 'full') {
-                        output.push('## Basic Info');
-                        output.push(`- Name: ${packageInfo.name || 'Not specified'}`);
-                        output.push(`- Version: ${packageInfo.version || 'Not specified'}`);
-                        output.push('');
-                    }
-                    if ((detail === 'scripts' || detail === 'full') && packageInfo.scripts) {
-                        output.push('## Scripts');
-                        Object.entries(packageInfo.scripts).forEach(([name, script]) => {
-                            output.push(`- ${name}: ${script}`);
-                        });
-                        output.push('');
-                    }
-                    if ((detail === 'dependencies' || detail === 'full') && packageInfo.dependencies) {
-                        output.push('## Dependencies');
-                        Object.entries(packageInfo.dependencies).forEach(([name, version]) => {
-                            output.push(`- ${name}: ${version}`);
-                        });
-                        output.push('');
-                    }
-                    if ((detail === 'dependencies' || detail === 'full') && packageInfo.devDependencies) {
-                        output.push('## Dev Dependencies');
-                        Object.entries(packageInfo.devDependencies).forEach(([name, version]) => {
-                            output.push(`- ${name}: ${version}`);
-                        });
-                        output.push('');
-                    }
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Error reading package.json: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-        {
-            name: 'run_build',
-            description: 'Execute build process using npm run build or other build commands',
-            parameters: {
-                type: 'object',
-                properties: {
-                    buildCommand: {
-                        type: 'string',
-                        description: 'Custom build command (defaults to npm run build)',
-                    },
-                    timeout: {
-                        type: 'number',
-                        description: 'Timeout in milliseconds (default: 300000)',
-                    },
-                },
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const buildCommandArg = args['buildCommand'];
-                const buildCommand = typeof buildCommandArg === 'string' && buildCommandArg.trim()
-                    ? buildCommandArg
-                    : 'npm run build';
-                const timeoutArg = args['timeout'];
-                const timeout = typeof timeoutArg === 'number' && Number.isFinite(timeoutArg) && timeoutArg > 0 ? timeoutArg : 300000; // 5 minutes
-                try {
-                    const { stdout, stderr } = await execAsync(buildCommand, {
-                        cwd: workingDir,
-                        timeout,
-                        maxBuffer: 1024 * 1024 * 10,
-                    });
-                    let result = `Build command: ${buildCommand}\n\n`;
-                    if (stdout)
-                        result += `stdout:\n${stdout}\n`;
-                    if (stderr)
-                        result += `stderr:\n${stderr}\n`;
-                    return result || 'Build completed (no output)';
-                }
-                catch (error) {
-                    if (error.killed) {
-                        return `Error: Build command timed out after ${timeout}ms`;
-                    }
-                    return `Error running build: ${error.message}\nstderr: ${error.stderr || 'none'}`;
-                }
-            },
-        },
-    ];
-}

package/dist/bin/tools/diffUtils.js

@@ -1,137 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-export function buildDiffSegments(previous, next) {
-    const before = normalizeNewlines(previous);
-    const after = normalizeNewlines(next);
-    if (before === after) {
-        return [];
-    }
-    const gitSegments = tryBuildWithGit(before, after);
-    if (gitSegments) {
-        return gitSegments;
-    }
-    return buildNaiveDiff(before, after);
-}
-export function formatDiffLines(diff) {
-    if (!diff.length) {
-        return [];
-    }
-    const width = Math.max(1, ...diff.map((entry) => Math.max(1, entry.lineNumber).toString().length));
-    return diff.map((entry) => {
-        const prefix = entry.type === 'added' ? '+' : '-';
-        const lineNumber = Math.max(1, entry.lineNumber);
-        const body = entry.content.length > 0 ? entry.content : '[empty line]';
-        const paddedNumber = lineNumber.toString().padStart(width, ' ');
-        return `${prefix} L${paddedNumber} | ${body}`;
-    });
-}
-function tryBuildWithGit(before, after) {
-    let tempDir = null;
-    try {
-        tempDir = mkdtempSync(join(tmpdir(), 'erosolar-diff-'));
-        const originalPath = join(tempDir, 'before.txt');
-        const updatedPath = join(tempDir, 'after.txt');
-        writeFileSync(originalPath, before, 'utf8');
-        writeFileSync(updatedPath, after, 'utf8');
-        const result = spawnSync('git', ['--no-pager', 'diff', '--no-index', '--unified=0', '--color=never', '--', originalPath, updatedPath], { encoding: 'utf8' });
-        if (result.error) {
-            const code = result.error.code;
-            if (code === 'ENOENT') {
-                return null;
-            }
-            return null;
-        }
-        if (typeof result.status === 'number' && result.status > 1) {
-            return null;
-        }
-        return parseUnifiedDiff(result.stdout);
-    }
-    catch {
-        return null;
-    }
-    finally {
-        if (tempDir) {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-    }
-}
-function parseUnifiedDiff(output) {
-    if (!output.trim()) {
-        return [];
-    }
-    const lines = output.split('\n');
-    const segments = [];
-    let oldLine = 0;
-    let newLine = 0;
-    for (const rawLine of lines) {
-        const line = rawLine.replace(/\r$/, '');
-        if (!line) {
-            continue;
-        }
-        if (line.startsWith('@@')) {
-            const match = /@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
-            if (match?.[1] && match?.[2]) {
-                oldLine = parseInt(match[1], 10);
-                newLine = parseInt(match[2], 10);
-            }
-            continue;
-        }
-        if (line.startsWith('+++') || line.startsWith('---') || line.startsWith('diff ') || line.startsWith('index ')) {
-            continue;
-        }
-        if (line.startsWith('Binary ')) {
-            continue;
-        }
-        if (line.startsWith('\\')) {
-            continue;
-        }
-        if (line.startsWith('+')) {
-            segments.push({ type: 'added', lineNumber: newLine, content: line.slice(1) });
-            newLine += 1;
-            continue;
-        }
-        if (line.startsWith('-')) {
-            segments.push({ type: 'removed', lineNumber: oldLine, content: line.slice(1) });
-            oldLine += 1;
-            continue;
-        }
-        if (line.startsWith(' ')) {
-            oldLine += 1;
-            newLine += 1;
-            continue;
-        }
-    }
-    return segments;
-}
-function buildNaiveDiff(before, after) {
-    const a = splitLines(before);
-    const b = splitLines(after);
-    const max = Math.max(a.length, b.length);
-    const segments = [];
-    for (let index = 0; index < max; index += 1) {
-        const left = a[index];
-        const right = b[index];
-        if (left === right) {
-            continue;
-        }
-        if (typeof left === 'string') {
-            segments.push({ type: 'removed', lineNumber: index + 1, content: left });
-        }
-        if (typeof right === 'string') {
-            segments.push({ type: 'added', lineNumber: index + 1, content: right });
-        }
-    }
-    return segments;
-}
-function normalizeNewlines(value) {
-    return value.replace(/\r\n/g, '\n');
-}
-function splitLines(value) {
-    if (!value) {
-        return [];
-    }
-    const normalized = normalizeNewlines(value);
-    return normalized.split('\n');
-}

package/dist/bin/tools/editTools.js

@@ -1,134 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { join, relative } from 'node:path';
-import { buildError } from '../core/errors.js';
-import { buildDiffSegments, formatDiffLines } from './diffUtils.js';
-/**
- * Creates the Edit tool for surgical file modifications using exact string replacement.
- *
- * This tool performs string-based edits without requiring full file rewrites,
- * making it ideal for targeted changes while preserving exact formatting and indentation.
- *
- * Features:
- * - Exact string matching (preserves indentation)
- * - Replace all occurrences or enforce uniqueness
- * - Unified diff preview
- * - Validation before writing
- *
- * @param workingDir - The working directory for resolving relative paths
- * @returns Array containing the Edit tool definition
- */
-export function createEditTools(workingDir) {
-    return [
-        {
-            name: 'Edit',
-            description: 'Performs exact string replacements in files. Use for surgical edits when you know the exact text to replace. The edit will FAIL if old_string is not unique unless replace_all is true.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    file_path: {
-                        type: 'string',
-                        description: 'The absolute path to the file to modify',
-                    },
-                    old_string: {
-                        type: 'string',
-                        description: 'The exact text to replace (must match precisely including indentation and whitespace)',
-                    },
-                    new_string: {
-                        type: 'string',
-                        description: 'The text to replace it with (must be different from old_string)',
-                    },
-                    replace_all: {
-                        type: 'boolean',
-                        description: 'Replace all occurrences of old_string (default false). When false, the edit fails if old_string appears multiple times.',
-                    },
-                },
-                required: ['file_path', 'old_string', 'new_string'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const pathArg = args['file_path'];
-                const oldString = args['old_string'];
-                const newString = args['new_string'];
-                const replaceAll = args['replace_all'] === true;
-                // Validate inputs
-                if (typeof pathArg !== 'string' || !pathArg.trim()) {
-                    return 'Error: file_path must be a non-empty string.';
-                }
-                if (typeof oldString !== 'string') {
-                    return 'Error: old_string must be a string.';
-                }
-                if (typeof newString !== 'string') {
-                    return 'Error: new_string must be a string.';
-                }
-                if (oldString === newString) {
-                    return 'Error: old_string and new_string must be different.';
-                }
-                try {
-                    const filePath = resolveFilePath(workingDir, pathArg);
-                    // Check file exists
-                    if (!existsSync(filePath)) {
-                        return `Error: File not found: ${filePath}`;
-                    }
-                    // Read current content
-                    const currentContent = readFileSync(filePath, 'utf-8');
-                    // Check if old_string exists in file
-                    if (!currentContent.includes(oldString)) {
-                        return `Error: old_string not found in file. The exact text must match including all whitespace and indentation.\n\nFile: ${filePath}\nSearching for: ${JSON.stringify(oldString.substring(0, 100))}...`;
-                    }
-                    // Count occurrences
-                    const occurrences = countOccurrences(currentContent, oldString);
-                    if (!replaceAll && occurrences > 1) {
-                        return `Error: old_string appears ${occurrences} times in the file. Either:\n1. Provide a larger unique string that includes more context\n2. Set replace_all: true to replace all ${occurrences} occurrences\n\nFile: ${filePath}`;
-                    }
-                    // Perform replacement
-                    const newContent = replaceAll
-                        ? currentContent.split(oldString).join(newString)
-                        : currentContent.replace(oldString, newString);
-                    // Generate diff
-                    const diffSegments = buildDiffSegments(currentContent, newContent);
-                    // Write file
-                    writeFileSync(filePath, newContent, 'utf-8');
-                    // Build summary
-                    const relativePath = relative(workingDir, filePath);
-                    const displayPath = relativePath && !relativePath.startsWith('..') ? relativePath : filePath;
-                    const addedLines = diffSegments.filter(s => s.type === 'added').length;
-                    const removedLines = diffSegments.filter(s => s.type === 'removed').length;
-                    const occurrencesText = replaceAll ? ` (${occurrences} occurrence${occurrences > 1 ? 's' : ''})` : '';
-                    const diffLines = formatDiffLines(diffSegments);
-                    const diffBlock = diffLines.length > 0
-                        ? ['```diff', ...diffLines, '```'].join('\n')
-                        : '(No visual diff - whitespace or formatting changes only)';
-                    return [
-                        `✓ Edited ${displayPath}${occurrencesText}`,
-                        `Lines changed: +${addedLines} / -${removedLines}`,
-                        '',
-                        'Diff preview:',
-                        diffBlock,
-                    ].join('\n');
-                }
-                catch (error) {
-                    return buildError('editing file', error, {
-                        file_path: pathArg,
-                        old_string_length: typeof oldString === 'string' ? oldString.length : 0,
-                        new_string_length: typeof newString === 'string' ? newString.length : 0,
-                    });
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    const normalized = path.trim();
-    return normalized.startsWith('/') ? normalized : join(workingDir, normalized);
-}
-function countOccurrences(text, search) {
-    if (!search)
-        return 0;
-    let count = 0;
-    let position = 0;
-    while ((position = text.indexOf(search, position)) !== -1) {
-        count++;
-        position += search.length;
-    }
-    return count;
-}