erosolar-cli 1.7.54 → 1.7.56

package/dist/bin/tools/notebookEditTools.js

@@ -1,196 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { buildError } from '../core/errors.js';
-/**
- * Creates the NotebookEdit tool for editing Jupyter .ipynb files
- *
- * This tool allows surgical editing of Jupyter notebook cells, supporting:
- * - Replacing cell content
- * - Inserting new cells
- * - Deleting cells
- * - Both code and markdown cells
- *
- * @param workingDir - The working directory for resolving paths
- * @returns Array containing the NotebookEdit tool definition
- */
-export function createNotebookEditTools(workingDir) {
-    return [
-        {
-            name: 'NotebookEdit',
-            description: 'Completely replaces or modifies cells in a Jupyter notebook (.ipynb file). Use edit_mode=replace (default) to replace a cell, edit_mode=insert to add a new cell, or edit_mode=delete to remove a cell.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    notebook_path: {
-                        type: 'string',
-                        description: 'The absolute path to the Jupyter notebook file to edit (must be .ipynb file)',
-                    },
-                    cell_id: {
-                        type: 'string',
-                        description: 'The ID of the cell to edit. When inserting a new cell, the new cell will be inserted after the cell with this ID, or at the beginning if not specified.',
-                    },
-                    new_source: {
-                        type: 'string',
-                        description: 'The new source for the cell (code or markdown content)',
-                    },
-                    cell_type: {
-                        type: 'string',
-                        description: 'The type of the cell (code or markdown). If not specified, defaults to current cell type. Required when using edit_mode=insert.',
-                    },
-                    edit_mode: {
-                        type: 'string',
-                        description: 'The type of edit to make: "replace" (default), "insert", or "delete"',
-                    },
-                },
-                required: ['notebook_path', 'new_source'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const notebookPath = args['notebook_path'];
-                const cellId = args['cell_id'];
-                const newSource = args['new_source'];
-                const cellType = args['cell_type'];
-                const editMode = args['edit_mode'] || 'replace';
-                // Validate inputs
-                if (typeof notebookPath !== 'string' || !notebookPath.trim()) {
-                    return 'Error: notebook_path must be a non-empty string.';
-                }
-                if (!notebookPath.endsWith('.ipynb')) {
-                    return 'Error: notebook_path must be a .ipynb file.';
-                }
-                if (typeof newSource !== 'string') {
-                    return 'Error: new_source must be a string.';
-                }
-                if (editMode !== 'replace' && editMode !== 'insert' && editMode !== 'delete') {
-                    return 'Error: edit_mode must be "replace", "insert", or "delete".';
-                }
-                if (editMode === 'insert' && !cellType) {
-                    return 'Error: cell_type is required when edit_mode=insert.';
-                }
-                if (cellType && cellType !== 'code' && cellType !== 'markdown') {
-                    return 'Error: cell_type must be "code" or "markdown".';
-                }
-                try {
-                    const filePath = resolveFilePath(workingDir, notebookPath);
-                    // Check file exists
-                    if (!existsSync(filePath)) {
-                        return `Error: Notebook file not found: ${filePath}`;
-                    }
-                    // Read and parse notebook
-                    const content = readFileSync(filePath, 'utf-8');
-                    let notebook;
-                    try {
-                        notebook = JSON.parse(content);
-                    }
-                    catch (parseError) {
-                        return `Error: Failed to parse notebook JSON: ${parseError}`;
-                    }
-                    // Validate notebook structure
-                    if (!notebook.cells || !Array.isArray(notebook.cells)) {
-                        return 'Error: Invalid notebook structure - missing cells array.';
-                    }
-                    // Perform the edit
-                    let resultMessage;
-                    switch (editMode) {
-                        case 'insert':
-                            resultMessage = insertCell(notebook, cellId, newSource, cellType);
-                            break;
-                        case 'delete':
-                            resultMessage = deleteCell(notebook, cellId);
-                            break;
-                        case 'replace':
-                        default:
-                            resultMessage = replaceCell(notebook, cellId, newSource, cellType);
-                            break;
-                    }
-                    // Write back to file
-                    const updatedContent = JSON.stringify(notebook, null, 2);
-                    writeFileSync(filePath, updatedContent, 'utf-8');
-                    return `✓ Notebook edited: ${filePath}\n${resultMessage}`;
-                }
-                catch (error) {
-                    return buildError('editing notebook', error, {
-                        notebook_path: notebookPath,
-                        edit_mode: editMode,
-                    });
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    const normalized = path.trim();
-    return normalized.startsWith('/') ? normalized : join(workingDir, normalized);
-}
-function replaceCell(notebook, cellId, newSource, cellType) {
-    let cellIndex;
-    if (cellId) {
-        // Find cell by ID
-        cellIndex = notebook.cells.findIndex(c => c.id === cellId);
-        if (cellIndex === -1) {
-            throw new Error(`Cell with id "${cellId}" not found.`);
-        }
-    }
-    else {
-        // Default to first cell
-        if (notebook.cells.length === 0) {
-            throw new Error('Notebook has no cells. Use edit_mode=insert to add a cell.');
-        }
-        cellIndex = 0;
-    }
-    const cell = notebook.cells[cellIndex];
-    const oldType = cell.cell_type;
-    const newType = cellType || oldType;
-    // Update cell
-    cell.cell_type = newType;
-    cell.source = newSource.split('\n');
-    // If changing from code to markdown, remove code-specific fields
-    if (oldType === 'code' && newType === 'markdown') {
-        delete cell.execution_count;
-        delete cell.outputs;
-    }
-    // If changing from markdown to code, add code-specific fields
-    if (oldType === 'markdown' && newType === 'code') {
-        cell.execution_count = null;
-        cell.outputs = [];
-    }
-    return `Replaced cell ${cellIndex} (${oldType} → ${newType})`;
-}
-function insertCell(notebook, afterCellId, newSource, cellType) {
-    let insertIndex = 0;
-    if (afterCellId) {
-        const afterIndex = notebook.cells.findIndex(c => c.id === afterCellId);
-        if (afterIndex === -1) {
-            throw new Error(`Cell with id "${afterCellId}" not found.`);
-        }
-        insertIndex = afterIndex + 1;
-    }
-    const newCell = {
-        cell_type: cellType,
-        id: generateCellId(),
-        metadata: {},
-        source: newSource.split('\n'),
-    };
-    if (cellType === 'code') {
-        newCell.execution_count = null;
-        newCell.outputs = [];
-    }
-    notebook.cells.splice(insertIndex, 0, newCell);
-    return `Inserted new ${cellType} cell at position ${insertIndex}`;
-}
-function deleteCell(notebook, cellId) {
-    if (!cellId) {
-        throw new Error('cell_id is required when edit_mode=delete.');
-    }
-    const cellIndex = notebook.cells.findIndex(c => c.id === cellId);
-    if (cellIndex === -1) {
-        throw new Error(`Cell with id "${cellId}" not found.`);
-    }
-    const cellType = notebook.cells[cellIndex].cell_type;
-    notebook.cells.splice(cellIndex, 1);
-    return `Deleted ${cellType} cell at position ${cellIndex}`;
-}
-function generateCellId() {
-    // Generate a random cell ID (simplified version)
-    return Math.random().toString(36).substring(2, 10);
-}

package/dist/bin/tools/planningTools.js

@@ -1,46 +0,0 @@
-/**
- * Creates planning workflow tools
- *
- * Tools:
- * - ExitPlanMode: Signal completion of planning phase
- *
- * These tools help structure agent workflows with explicit planning phases.
- */
-export function createPlanningTools() {
-    return [
-        {
-            name: 'ExitPlanMode',
-            description: 'Use this tool when you are in plan mode and have finished presenting your plan and are ready to code. This will prompt the user to exit plan mode. IMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you are gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    plan: {
-                        type: 'string',
-                        description: 'The plan you came up with, that you want to run by the user for approval. Supports markdown. The plan should be pretty concise.',
-                    },
-                },
-                required: ['plan'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                const plan = args['plan'];
-                if (typeof plan !== 'string' || !plan.trim()) {
-                    return 'Error: plan must be a non-empty string.';
-                }
-                // Format the plan output
-                const formattedPlan = [
-                    '='.repeat(70),
-                    'PLAN READY FOR APPROVAL',
-                    '='.repeat(70),
-                    '',
-                    plan.trim(),
-                    '',
-                    '='.repeat(70),
-                    'Ready to proceed? If you approve this plan, I will begin implementation.',
-                    '='.repeat(70),
-                ].join('\n');
-                return formattedPlan;
-            },
-        },
-    ];
-}

package/dist/bin/tools/refactoringTools.js

@@ -1,293 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { basename, join, relative } from 'node:path';
-import { performAdvancedAstAnalysis } from './codeAnalysisTools.js';
-const SOURCE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
-const IGNORED_DIRECTORIES = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo']);
-export function createRefactoringTools(workingDir) {
-    return [
-        {
-            name: 'detect_refactoring_hotspots',
-            description: 'Scan a file or directory for large/complex functions that merit refactoring.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'File or directory to inspect (relative to workspace).',
-                    },
-                    maxResults: {
-                        type: 'number',
-                        description: 'Limit the number of hotspots returned (default: 10).',
-                    },
-                },
-                required: ['path'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                try {
-                    const targetPath = resolveFilePath(workingDir, args['path']);
-                    if (!existsSync(targetPath)) {
-                        return `Error: Path not found: ${targetPath}`;
-                    }
-                    const files = collectSourceFiles(targetPath);
-                    if (files.length === 0) {
-                        return `No source files (.ts/.tsx/.js/.jsx) discovered under ${targetPath}.`;
-                    }
-                    const hotspots = [];
-                    for (const file of files) {
-                        const content = readFileSync(file, 'utf-8');
-                        const ast = performAdvancedAstAnalysis(content, file);
-                        for (const symbol of ast.symbols) {
-                            if (symbol.kind === 'class') {
-                                continue;
-                            }
-                            const reasons = [];
-                            if (symbol.statementCount > 40) {
-                                reasons.push(`long body (${symbol.statementCount} statements)`);
-                            }
-                            if (symbol.cyclomaticComplexity > 12) {
-                                reasons.push(`complex (CC ${symbol.cyclomaticComplexity})`);
-                            }
-                            const span = symbol.endLine - symbol.startLine + 1;
-                            if (span > 120) {
-                                reasons.push(`spans ${span} lines`);
-                            }
-                            if (reasons.length > 0) {
-                                hotspots.push({
-                                    file,
-                                    symbol,
-                                    reasons,
-                                    score: symbol.cyclomaticComplexity * 2 + symbol.statementCount,
-                                });
-                            }
-                        }
-                    }
-                    if (hotspots.length === 0) {
-                        return 'No refactoring hotspots detected.';
-                    }
-                    const maxResultsArg = args['maxResults'];
-                    const limit = typeof maxResultsArg === 'number' && Number.isFinite(maxResultsArg) && maxResultsArg > 0
-                        ? Math.floor(maxResultsArg)
-                        : 10;
-                    hotspots.sort((a, b) => b.score - a.score);
-                    const selection = hotspots.slice(0, limit);
-                    const output = [];
-                    output.push(`# Refactoring hotspots (${selection.length}/${hotspots.length})`);
-                    output.push('');
-                    selection.forEach((record, index) => {
-                        const relPath = relative(workingDir, record.file);
-                        const span = record.symbol.endLine - record.symbol.startLine + 1;
-                        output.push(`${index + 1}. ${record.symbol.name} in ${relPath} (lines ${record.symbol.startLine}-${record.symbol.endLine})`);
-                        output.push(`   - Severity score: ${record.score}`);
-                        output.push(`   - Reasons: ${record.reasons.join(', ')}`);
-                        output.push(`   - Statements: ${record.symbol.statementCount}, CC: ${record.symbol.cyclomaticComplexity}, span ${span} lines`);
-                    });
-                    return output.join('\n');
-                }
-                catch (error) {
-                    return `Error detecting hotspots: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-        {
-            name: 'generate_refactor_plan',
-            description: 'Create a structured refactor plan for the most complex symbol in a file (or a specific symbol).',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'File to analyze.',
-                    },
-                    symbol: {
-                        type: 'string',
-                        description: 'Optional symbol to target (defaults to the most complex function).',
-                    },
-                },
-                required: ['path'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                try {
-                    const filePath = resolveFilePath(workingDir, args['path']);
-                    if (!existsSync(filePath)) {
-                        return `Error: File not found: ${filePath}`;
-                    }
-                    const content = readFileSync(filePath, 'utf-8');
-                    const ast = performAdvancedAstAnalysis(content, filePath);
-                    if (ast.symbols.length === 0) {
-                        return `No analyzable symbols found in ${filePath}.`;
-                    }
-                    const targetSymbol = selectTargetSymbol(ast.symbols, args['symbol']);
-                    if (!targetSymbol) {
-                        return `Symbol "${String(args['symbol'])}" not found in ${filePath}.`;
-                    }
-                    const callOutputs = ast.callGraph.filter((edge) => edge.from === targetSymbol.name || edge.to === targetSymbol.name);
-                    const relPath = relative(workingDir, filePath);
-                    const plan = [];
-                    plan.push(`# Refactor plan for ${targetSymbol.name}`);
-                    plan.push(`File: ${relPath}`);
-                    plan.push('');
-                    plan.push('## Current metrics');
-                    plan.push(`- Statements: ${targetSymbol.statementCount}`);
-                    plan.push(`- Cyclomatic complexity: ${targetSymbol.cyclomaticComplexity}`);
-                    plan.push(`- Span: lines ${targetSymbol.startLine}-${targetSymbol.endLine}`);
-                    plan.push('');
-                    plan.push('## Recommended steps');
-                    plan.push('- Break the function into cohesive helpers grouped by responsibility.');
-                    if (targetSymbol.statementCount > 60) {
-                        plan.push('- Extract the initialization / setup logic into a dedicated helper.');
-                    }
-                    if (targetSymbol.cyclomaticComplexity > 14) {
-                        plan.push('- Replace deeply nested branching with guard clauses or strategy objects.');
-                    }
-                    plan.push('- Introduce descriptive interfaces/types to clarify inputs and return values.');
-                    plan.push('- Write focused unit tests for each new helper and for the refactored entry point.');
-                    plan.push('');
-                    plan.push('## Dependency considerations');
-                    if (callOutputs.length === 0) {
-                        plan.push('This symbol does not interact with other tracked functions inside the file.');
-                    }
-                    else {
-                        plan.push('Calls & referenced symbols:');
-                        callOutputs.forEach((edge) => {
-                            if (edge.from === targetSymbol.name) {
-                                plan.push(`- Calls ${edge.to} (${edge.count} time${edge.count === 1 ? '' : 's'})`);
-                            }
-                            else {
-                                plan.push(`- Invoked by ${edge.from} (${edge.count} call${edge.count === 1 ? '' : 's'})`);
-                            }
-                        });
-                    }
-                    return plan.join('\n');
-                }
-                catch (error) {
-                    return `Error generating refactor plan: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-        {
-            name: 'analyze_refactor_impact',
-            description: 'Summarize inbound/outbound calls for a symbol to estimate refactor blast radius.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    path: {
-                        type: 'string',
-                        description: 'File containing the symbol.',
-                    },
-                    symbol: {
-                        type: 'string',
-                        description: 'Symbol name to inspect. Defaults to the most connected symbol.',
-                    },
-                },
-                required: ['path'],
-                additionalProperties: false,
-            },
-            handler: async (args) => {
-                try {
-                    const filePath = resolveFilePath(workingDir, args['path']);
-                    if (!existsSync(filePath)) {
-                        return `Error: File not found: ${filePath}`;
-                    }
-                    const content = readFileSync(filePath, 'utf-8');
-                    const ast = performAdvancedAstAnalysis(content, filePath);
-                    if (ast.symbols.length === 0) {
-                        return `No analyzable symbols found in ${filePath}.`;
-                    }
-                    const fallbackSymbol = ast.symbols[0]?.name ?? '';
-                    const symbolArg = args['symbol'];
-                    const symbolName = typeof symbolArg === 'string' && symbolArg.trim()
-                        ? symbolArg.trim()
-                        : findMostConnectedSymbol(ast) ?? fallbackSymbol;
-                    const incoming = ast.callGraph.filter((edge) => edge.to === symbolName);
-                    const outgoing = ast.callGraph.filter((edge) => edge.from === symbolName);
-                    const summary = [];
-                    summary.push(`# Refactor impact for ${symbolName}`);
-                    summary.push('');
-                    summary.push('## Incoming references');
-                    if (incoming.length === 0) {
-                        summary.push('No recorded inbound calls inside this file.');
-                    }
-                    else {
-                        incoming.forEach((edge) => {
-                            summary.push(`- ${edge.from} (${edge.count} call${edge.count === 1 ? '' : 's'})`);
-                        });
-                    }
-                    summary.push('');
-                    summary.push('## Outgoing calls');
-                    if (outgoing.length === 0) {
-                        summary.push('No outbound calls recorded.');
-                    }
-                    else {
-                        outgoing.forEach((edge) => {
-                            summary.push(`- ${edge.to} (${edge.count} call${edge.count === 1 ? '' : 's'})`);
-                        });
-                    }
-                    return summary.join('\n');
-                }
-                catch (error) {
-                    return `Error analyzing refactor impact: ${error instanceof Error ? error.message : String(error)}`;
-                }
-            },
-        },
-    ];
-}
-function resolveFilePath(workingDir, path) {
-    if (typeof path !== 'string' || !path.trim()) {
-        throw new Error('Path must be a non-empty string.');
-    }
-    const value = path.trim();
-    return value.startsWith('/') ? value : join(workingDir, value);
-}
-function collectSourceFiles(targetPath) {
-    const stats = statSync(targetPath);
-    if (stats.isDirectory()) {
-        const directoryName = basename(targetPath);
-        if (IGNORED_DIRECTORIES.has(directoryName)) {
-            return [];
-        }
-        const entries = readdirSync(targetPath);
-        const files = [];
-        for (const entry of entries) {
-            files.push(...collectSourceFiles(join(targetPath, entry)));
-        }
-        return files;
-    }
-    if (!stats.isFile()) {
-        return [];
-    }
-    if (SOURCE_EXTENSIONS.some((ext) => targetPath.endsWith(ext))) {
-        return [targetPath];
-    }
-    return [];
-}
-function selectTargetSymbol(symbols, requestedSymbol) {
-    if (typeof requestedSymbol === 'string' && requestedSymbol.trim()) {
-        const match = symbols.find((symbol) => symbol.name === requestedSymbol.trim());
-        if (match) {
-            return match;
-        }
-        return null;
-    }
-    const sorted = [...symbols]
-        .filter((symbol) => symbol.kind !== 'class')
-        .sort((a, b) => b.cyclomaticComplexity - a.cyclomaticComplexity);
-    return sorted[0] ?? null;
-}
-function findMostConnectedSymbol(ast) {
-    const connectionWeights = new Map();
-    for (const edge of ast.callGraph) {
-        connectionWeights.set(edge.from, (connectionWeights.get(edge.from) ?? 0) + edge.count);
-        connectionWeights.set(edge.to, (connectionWeights.get(edge.to) ?? 0) + edge.count);
-    }
-    let bestSymbol = null;
-    let bestScore = -1;
-    for (const [symbol, weight] of connectionWeights.entries()) {
-        if (weight > bestScore) {
-            bestSymbol = symbol;
-            bestScore = weight;
-        }
-    }
-    return bestSymbol;
-}