@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/fix.js

@@ -0,0 +1,263 @@
+/**
+ * Fix Command
+ *
+ * AI-assisted error fixing
+ *
+ * Usage: nimbus fix <error-or-file> [options]
+ */
+import { logger } from '../utils';
+import { ui, confirm } from '../wizard';
+import { llmClient } from '../clients';
+/**
+ * Parse fix response from AI
+ */
+function parseFixResponse(response) {
+    // Try to extract structured sections from the response
+    const problemMatch = response.match(/(?:problem|issue|error):\s*(.+?)(?=\n(?:explanation|fix|solution)|$)/is);
+    const explanationMatch = response.match(/(?:explanation|cause|reason):\s*(.+?)(?=\n(?:fix|solution)|$)/is);
+    const fixMatch = response.match(/(?:fix|solution|resolution):\s*(.+?)(?=\n(?:original|fixed)|$)/is);
+    const originalMatch = response.match(/(?:original|before)[^:]*:\s*```[\w]*\n([\s\S]*?)```/i);
+    const fixedMatch = response.match(/(?:fixed|after|corrected)[^:]*:\s*```[\w]*\n([\s\S]*?)```/i);
+    return {
+        problem: problemMatch?.[1]?.trim() || 'Unable to parse problem description',
+        explanation: explanationMatch?.[1]?.trim() || response.split('\n').slice(0, 3).join('\n'),
+        fix: fixMatch?.[1]?.trim() || 'See suggested code below',
+        originalCode: originalMatch?.[1]?.trim(),
+        fixedCode: fixedMatch?.[1]?.trim(),
+    };
+}
+/**
+ * Build the fix prompt
+ */
+function buildFixPrompt(errorContent, fileContent, filePath) {
+    let prompt = `Please help fix this error. Analyze the problem and provide a solution.
+
+Error:
+\`\`\`
+${errorContent}
+\`\`\`
+`;
+    if (fileContent && filePath) {
+        prompt += `
+Source file (${filePath}):
+\`\`\`
+${fileContent}
+\`\`\`
+`;
+    }
+    prompt += `
+Please provide:
+1. **Problem**: A brief description of what's wrong
+2. **Explanation**: Why this error occurs
+3. **Fix**: How to fix it
+
+If you can provide code changes, please show:
+- **Original**: The problematic code
+- **Fixed**: The corrected code
+
+Format your response with clear section headers.`;
+    return prompt;
+}
+/**
+ * Display fix suggestion
+ */
+function displayFixSuggestion(suggestion) {
+    ui.newLine();
+    // Problem
+    ui.print(ui.color('Problem:', 'yellow'));
+    ui.print(`  ${suggestion.problem}`);
+    ui.newLine();
+    // Explanation
+    ui.print(ui.color('Explanation:', 'blue'));
+    for (const line of suggestion.explanation.split('\n')) {
+        ui.print(`  ${line}`);
+    }
+    ui.newLine();
+    // Fix
+    ui.print(ui.color('Suggested Fix:', 'green'));
+    for (const line of suggestion.fix.split('\n')) {
+        ui.print(`  ${line}`);
+    }
+    // Show diff if we have original and fixed code
+    if (suggestion.originalCode && suggestion.fixedCode) {
+        ui.newLine();
+        ui.print(ui.color('Code Changes:', 'cyan'));
+        ui.newLine();
+        // Show original
+        ui.print(ui.color('Before:', 'red'));
+        ui.print('```');
+        for (const line of suggestion.originalCode.split('\n')) {
+            ui.print(ui.color(`- ${line}`, 'red'));
+        }
+        ui.print('```');
+        ui.newLine();
+        // Show fixed
+        ui.print(ui.color('After:', 'green'));
+        ui.print('```');
+        for (const line of suggestion.fixedCode.split('\n')) {
+            ui.print(ui.color(`+ ${line}`, 'green'));
+        }
+        ui.print('```');
+    }
+}
+/**
+ * Apply the fix to a file
+ */
+async function applyFix(suggestion, filePath) {
+    if (!suggestion.originalCode || !suggestion.fixedCode) {
+        ui.warning('Cannot auto-apply: No code diff provided');
+        return false;
+    }
+    try {
+        const fs = await import('fs/promises');
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Try to find and replace the original code
+        if (content.includes(suggestion.originalCode)) {
+            const newContent = content.replace(suggestion.originalCode, suggestion.fixedCode);
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            return true;
+        }
+        else {
+            ui.warning('Could not find the original code in the file');
+            ui.info('The file may have been modified since the analysis');
+            return false;
+        }
+    }
+    catch (error) {
+        ui.error(`Failed to apply fix: ${error.message}`);
+        return false;
+    }
+}
+/**
+ * Run the fix command
+ */
+export async function fixCommand(errorOrFile, options = {}) {
+    logger.info('Running fix command', { errorOrFile, options });
+    let errorContent;
+    let fileContent;
+    let filePath;
+    // Determine what we're fixing
+    if (options.file) {
+        // Error content with explicit file
+        errorContent = errorOrFile;
+        filePath = options.file;
+        try {
+            const fs = await import('fs/promises');
+            fileContent = await fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            ui.warning(`Could not read file ${filePath}: ${error.message}`);
+        }
+    }
+    else if (errorOrFile) {
+        // Check if it's a file path
+        try {
+            const fs = await import('fs/promises');
+            const stat = await fs.stat(errorOrFile);
+            if (stat.isFile()) {
+                filePath = errorOrFile;
+                fileContent = await fs.readFile(errorOrFile, 'utf-8');
+                // For a file without explicit error, we'll analyze the whole file
+                errorContent = `Please analyze this file for potential issues and errors:\n${errorOrFile}`;
+            }
+            else {
+                errorContent = errorOrFile;
+            }
+        }
+        catch {
+            // Not a file, treat as error message
+            errorContent = errorOrFile;
+        }
+    }
+    else {
+        ui.error('Please provide an error message or file to fix');
+        ui.newLine();
+        ui.print('Usage: nimbus fix <error-or-file> [options]');
+        ui.newLine();
+        ui.print('Examples:');
+        ui.print('  nimbus fix "Error: undefined variable"');
+        ui.print('  nimbus fix ./broken.tf');
+        ui.print('  nimbus fix "Error: invalid syntax" --file ./app.py');
+        ui.print('  nimbus fix ./config.yaml --auto-apply');
+        process.exit(1);
+    }
+    // Display header
+    ui.header('Nimbus Fix');
+    if (filePath) {
+        ui.info(`File: ${filePath}`);
+    }
+    ui.info(`Error: ${errorContent.slice(0, 100)}${errorContent.length > 100 ? '...' : ''}`);
+    ui.newLine();
+    // Check if LLM is available
+    const llmAvailable = await llmClient.isAvailable();
+    if (!llmAvailable) {
+        ui.error('LLM service is not available');
+        ui.info('Make sure you have configured an LLM provider with "nimbus login"');
+        process.exit(1);
+    }
+    // Build prompt
+    const prompt = buildFixPrompt(errorContent, fileContent, filePath);
+    ui.startSpinner({ message: 'Analyzing error...' });
+    try {
+        let response = '';
+        for await (const chunk of llmClient.chat(prompt, [])) {
+            if (chunk.type === 'content' && chunk.content) {
+                response += chunk.content;
+            }
+            else if (chunk.type === 'error') {
+                ui.stopSpinnerFail('Error');
+                ui.error(chunk.message || chunk.error || 'Unknown error');
+                process.exit(1);
+            }
+        }
+        ui.stopSpinnerSuccess('Analysis complete');
+        // Parse and display the suggestion
+        const suggestion = parseFixResponse(response);
+        suggestion.filePath = filePath;
+        displayFixSuggestion(suggestion);
+        // JSON output mode
+        if (options.json) {
+            console.log(JSON.stringify(suggestion, null, 2));
+            return;
+        }
+        // Dry run - don't apply
+        if (options.dryRun) {
+            ui.newLine();
+            ui.info('Dry run mode - no changes applied');
+            return;
+        }
+        // Apply the fix if requested and possible
+        if (filePath && suggestion.originalCode && suggestion.fixedCode) {
+            ui.newLine();
+            const shouldApply = options.autoApply ||
+                (await confirm({
+                    message: 'Apply this fix?',
+                    defaultValue: false,
+                }));
+            if (shouldApply) {
+                ui.startSpinner({ message: 'Applying fix...' });
+                const applied = await applyFix(suggestion, filePath);
+                if (applied) {
+                    ui.stopSpinnerSuccess('Fix applied successfully!');
+                    ui.newLine();
+                    ui.info(`File updated: ${filePath}`);
+                    ui.info('Please review the changes and test your code');
+                }
+                else {
+                    ui.stopSpinnerFail('Could not apply fix automatically');
+                    ui.info('Please apply the suggested changes manually');
+                }
+            }
+            else {
+                ui.info('Fix not applied');
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed');
+        ui.error(error.message);
+        process.exit(1);
+    }
+}
+// Export as default
+export default fixCommand;

package/dist/src/commands/fs/index.js

@@ -0,0 +1,338 @@
+/**
+ * File System Commands
+ *
+ * CLI commands for file system operations via FS Tools Service
+ */
+import { ToolsClient } from '../../clients';
+import { ui } from '../../wizard/ui';
+const toolsClient = new ToolsClient();
+/**
+ * List directory contents
+ */
+export async function fsListCommand(dirPath, options = {}) {
+    ui.header('Files List');
+    ui.info(`Path: ${dirPath}`);
+    if (options.recursive) {
+        ui.info('Recursive: yes');
+    }
+    ui.startSpinner({ message: `Listing ${dirPath}...` });
+    try {
+        const result = await toolsClient.fs.list(dirPath, {
+            recursive: options.recursive,
+            pattern: options.pattern,
+        });
+        if (result.success) {
+            const data = result.data;
+            const entries = data?.entries || [];
+            ui.stopSpinnerSuccess(`Found ${entries.length} entries`);
+            if (entries.length > 0) {
+                for (const entry of entries) {
+                    const icon = entry.type === 'directory' ? '📁' : '📄';
+                    const size = entry.size ? ` (${formatSize(entry.size)})` : '';
+                    ui.print(`  ${icon} ${entry.name}${size}`);
+                }
+            }
+            else {
+                ui.info('Directory is empty');
+            }
+        }
+        else {
+            ui.stopSpinnerFail('Failed to list directory');
+            if (result.error) {
+                ui.error(result.error.message);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Error listing directory');
+        ui.error(error.message);
+    }
+}
+/**
+ * Search for files
+ */
+export async function fsSearchCommand(pattern, searchPath = '.', options = {}) {
+    ui.header('Files Search');
+    ui.info(`Pattern: ${pattern}`);
+    ui.info(`Path: ${searchPath}`);
+    ui.startSpinner({ message: `Searching for ${pattern}...` });
+    try {
+        const result = await toolsClient.fs.search(pattern, {
+            path: searchPath,
+            maxResults: options.maxResults,
+        });
+        if (result.success) {
+            const data = result.data;
+            const matches = data?.matches || data?.entries || [];
+            ui.stopSpinnerSuccess(`Found ${matches.length} match(es)`);
+            if (matches.length > 0) {
+                for (const match of matches) {
+                    const name = typeof match === 'string' ? match : match.path || match.name;
+                    ui.print(`  ${ui.color('•', 'green')} ${name}`);
+                }
+            }
+        }
+        else {
+            ui.stopSpinnerFail('Search failed');
+            if (result.error) {
+                ui.error(result.error.message);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Error searching files');
+        ui.error(error.message);
+    }
+}
+/**
+ * Read file contents
+ */
+export async function fsReadCommand(filePath, _options = {}) {
+    ui.header('Files Read');
+    ui.info(`File: ${filePath}`);
+    ui.startSpinner({ message: `Reading ${filePath}...` });
+    try {
+        const result = await toolsClient.fs.read(filePath);
+        if (result.success) {
+            ui.stopSpinnerSuccess('File read successfully');
+            const data = result.data;
+            if (data?.content !== undefined) {
+                console.log(data.content);
+            }
+        }
+        else {
+            ui.stopSpinnerFail('Failed to read file');
+            if (result.error) {
+                ui.error(result.error.message);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Error reading file');
+        ui.error(error.message);
+    }
+}
+/**
+ * Display directory tree using the dedicated tree endpoint
+ */
+export async function fsTreeCommand(dirPath, options = {}) {
+    ui.header('File Tree');
+    ui.info(`Path: ${dirPath}`);
+    if (options.maxDepth) {
+        ui.info(`Max depth: ${options.maxDepth}`);
+    }
+    ui.startSpinner({ message: `Building tree for ${dirPath}...` });
+    try {
+        const result = await toolsClient.fs.tree(dirPath, {
+            maxDepth: options.maxDepth,
+            includeFiles: true,
+        });
+        if (result.success) {
+            const data = result.data;
+            const tree = data?.tree || data?.entries || [];
+            ui.stopSpinnerSuccess(`Tree for ${dirPath}`);
+            const printTree = (nodes, prefix = '') => {
+                for (let i = 0; i < nodes.length; i++) {
+                    const node = nodes[i];
+                    const isLast = i === nodes.length - 1;
+                    const connector = isLast ? '└── ' : '├── ';
+                    const icon = node.type === 'directory' ? '📁' : '📄';
+                    ui.print(`${prefix}${connector}${icon} ${node.name}`);
+                    if (node.children && node.children.length > 0) {
+                        const childPrefix = prefix + (isLast ? '    ' : '│   ');
+                        printTree(node.children, childPrefix);
+                    }
+                }
+            };
+            if (tree.length > 0) {
+                printTree(tree);
+            }
+            else {
+                ui.info('Directory is empty');
+            }
+        }
+        else {
+            ui.stopSpinnerFail('Failed to build tree');
+            if (result.error) {
+                ui.error(result.error.message);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Error building tree');
+        ui.error(error.message);
+    }
+}
+/**
+ * Write content to a file
+ */
+export async function fsWriteCommand(filePath, content, options = {}) {
+    ui.header('Files Write');
+    ui.info(`File: ${filePath}`);
+    ui.startSpinner({ message: `Writing to ${filePath}...` });
+    try {
+        const result = await toolsClient.fs.write(filePath, content, {
+            createDirs: options.createDirs,
+        });
+        if (result.success) {
+            ui.stopSpinnerSuccess(`File written successfully: ${filePath}`);
+        }
+        else {
+            ui.stopSpinnerFail('Failed to write file');
+            if (result.error) {
+                ui.error(result.error.message);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Error writing file');
+        ui.error(error.message);
+    }
+}
+/**
+ * Show diff between two files
+ */
+export async function fsDiffCommand(file1, file2) {
+    ui.header('Files Diff');
+    ui.info(`File 1: ${file1}`);
+    ui.info(`File 2: ${file2}`);
+    ui.startSpinner({ message: 'Computing diff...' });
+    try {
+        // Read both files and compare via the FS tools service diff endpoint
+        const result = await toolsClient.fs.read(file1);
+        const result2 = await toolsClient.fs.read(file2);
+        if (!result.success) {
+            ui.stopSpinnerFail(`Failed to read file: ${file1}`);
+            if (result.error) {
+                ui.error(result.error.message);
+            }
+            return;
+        }
+        if (!result2.success) {
+            ui.stopSpinnerFail(`Failed to read file: ${file2}`);
+            if (result2.error) {
+                ui.error(result2.error.message);
+            }
+            return;
+        }
+        const data1 = result.data;
+        const data2 = result2.data;
+        const content1 = data1?.content || '';
+        const content2 = data2?.content || '';
+        if (content1 === content2) {
+            ui.stopSpinnerSuccess('Files are identical');
+        }
+        else {
+            ui.stopSpinnerSuccess('Diff computed');
+            // Simple line-by-line diff display
+            const lines1 = content1.split('\n');
+            const lines2 = content2.split('\n');
+            const maxLines = Math.max(lines1.length, lines2.length);
+            const diffLines = [];
+            for (let i = 0; i < maxLines; i++) {
+                const l1 = lines1[i];
+                const l2 = lines2[i];
+                if (l1 === undefined) {
+                    diffLines.push(ui.color(`+ ${l2}`, 'green'));
+                }
+                else if (l2 === undefined) {
+                    diffLines.push(ui.color(`- ${l1}`, 'red'));
+                }
+                else if (l1 !== l2) {
+                    diffLines.push(ui.color(`- ${l1}`, 'red'));
+                    diffLines.push(ui.color(`+ ${l2}`, 'green'));
+                }
+            }
+            if (diffLines.length > 0) {
+                ui.box({ title: 'Diff', content: diffLines.join('\n') });
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Error computing diff');
+        ui.error(error.message);
+    }
+}
+/**
+ * Main fs command router
+ */
+export async function fsCommand(subcommand, args) {
+    const options = {};
+    const positionalArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-r' || arg === '--recursive') {
+            options.recursive = true;
+        }
+        else if (arg === '-p' || arg === '--pattern') {
+            options.pattern = args[++i];
+        }
+        else if (arg === '-n' || arg === '--max-results') {
+            options.maxResults = parseInt(args[++i], 10);
+        }
+        else if (arg === '--depth') {
+            options.maxDepth = parseInt(args[++i], 10);
+        }
+        else if (arg === '--create-dirs') {
+            options.createDirs = true;
+        }
+        else if (!arg.startsWith('-')) {
+            positionalArgs.push(arg);
+        }
+    }
+    switch (subcommand) {
+        case 'list':
+        case 'ls':
+            await fsListCommand(positionalArgs[0] || '.', options);
+            break;
+        case 'tree':
+            await fsTreeCommand(positionalArgs[0] || '.', options);
+            break;
+        case 'search':
+        case 'find':
+            if (positionalArgs.length < 1) {
+                ui.error('Usage: nimbus fs search <pattern> [path]');
+                return;
+            }
+            await fsSearchCommand(positionalArgs[0], positionalArgs[1] || '.', options);
+            break;
+        case 'read':
+        case 'cat':
+            if (positionalArgs.length < 1) {
+                ui.error('Usage: nimbus fs read <file>');
+                return;
+            }
+            await fsReadCommand(positionalArgs[0], options);
+            break;
+        case 'write':
+            if (positionalArgs.length < 2) {
+                ui.error('Usage: nimbus fs write <path> <content>');
+                return;
+            }
+            await fsWriteCommand(positionalArgs[0], positionalArgs.slice(1).join(' '), options);
+            break;
+        case 'diff':
+            if (positionalArgs.length < 2) {
+                ui.error('Usage: nimbus fs diff <file1> <file2>');
+                return;
+            }
+            await fsDiffCommand(positionalArgs[0], positionalArgs[1]);
+            break;
+        default:
+            ui.error(`Unknown fs subcommand: ${subcommand}`);
+            ui.info('Available commands: list, tree, search, read, write, diff');
+    }
+}
+/**
+ * Format file size in human-readable format
+ */
+function formatSize(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    return `${size.toFixed(unitIndex > 0 ? 1 : 0)} ${units[unitIndex]}`;
+}