erosolar-cli 1.5.2 → 1.5.4

package/dist/bin/tools/devTools.js

@@ -0,0 +1,238 @@
+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

@@ -0,0 +1,137 @@
+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

@@ -0,0 +1,134 @@
+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;
+}