@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/aws-terraform.js

@@ -0,0 +1,618 @@
+/**
+ * AWS Terraform Command
+ *
+ * Generate Terraform configurations from AWS infrastructure
+ *
+ * Usage: nimbus aws terraform [options]
+ */
+import { logger } from '../utils';
+import { createWizard, ui, select, confirm, pathInput, } from '../wizard';
+import { awsDiscoverCommand } from './aws-discover';
+import { generateTerraformProject } from '../generator/terraform';
+import { readFile, writeFile } from 'node:fs/promises';
+import * as path from 'path';
+import * as fs from 'fs';
+/**
+ * Run the AWS terraform command
+ */
+export async function awsTerraformCommand(options = {}) {
+    logger.info('Starting AWS Terraform generation');
+    // Non-interactive mode
+    if (options.nonInteractive) {
+        await runNonInteractive(options);
+        return;
+    }
+    // Check if we have resources to generate from
+    let resources;
+    let discoverySessionId;
+    // Option 1: Use existing discovery session
+    if (options.sessionId) {
+        discoverySessionId = options.sessionId;
+        ui.info(`Using existing discovery session: ${options.sessionId}`);
+    }
+    // Option 2: Load resources from file
+    else if (options.resourcesFile) {
+        ui.startSpinner({ message: 'Loading resources from file...' });
+        try {
+            const fileContent = await readFile(options.resourcesFile, 'utf-8');
+            const data = JSON.parse(fileContent);
+            resources = data.resources || data;
+            ui.stopSpinnerSuccess(`Loaded ${resources.length} resources from file`);
+        }
+        catch (error) {
+            ui.stopSpinnerFail(`Failed to load resources: ${error.message}`);
+            return;
+        }
+    }
+    // Option 3: Run discovery first
+    else if (!options.skipDiscovery) {
+        const discoveryOptions = {
+            profile: options.profile,
+            regions: options.regions,
+            services: options.services,
+            nonInteractive: false,
+        };
+        ui.header('nimbus aws terraform', 'Step 1: Infrastructure Discovery');
+        ui.newLine();
+        const inventory = await awsDiscoverCommand(discoveryOptions);
+        if (!inventory) {
+            ui.error('Discovery failed, cannot generate Terraform');
+            return;
+        }
+        resources = inventory.resources;
+        ui.newLine();
+        ui.header('nimbus aws terraform', 'Step 2: Terraform Generation');
+        ui.newLine();
+    }
+    // Interactive wizard for generation options
+    const wizard = createWizard({
+        title: 'Terraform Generation',
+        description: 'Configure Terraform generation options',
+        initialContext: {
+            discoverySessionId,
+            resources,
+            outputPath: options.output,
+            organizeByService: options.organizeByService ?? true,
+            generateImportBlocks: options.importBlocks ?? true,
+            generateImportScript: options.importScript ?? true,
+            terraformVersion: options.terraformVersion,
+            awsProviderVersion: options.awsProviderVersion,
+            includeReadme: options.includeReadme ?? options.includeStarterKit,
+            includeGitignore: options.includeGitignore ?? options.includeStarterKit,
+            includeMakefile: options.includeMakefile ?? options.includeStarterKit,
+        },
+        steps: createWizardSteps(!!discoverySessionId || !!resources),
+        onEvent: event => {
+            logger.debug('Wizard event', { type: event.type });
+        },
+    });
+    const result = await wizard.run();
+    if (result.success) {
+        displayCompletionMessage(result.context);
+    }
+    else {
+        ui.error(`Generation failed: ${result.error?.message || 'Unknown error'}`);
+        process.exit(1);
+    }
+}
+/**
+ * Create wizard steps
+ */
+function createWizardSteps(_hasResources) {
+    const steps = [];
+    // Step 1: Generation Options
+    steps.push({
+        id: 'generation-options',
+        title: 'Generation Options',
+        description: 'Configure how Terraform files should be generated',
+        execute: generationOptionsStep,
+    });
+    // Step 2: Output Location
+    steps.push({
+        id: 'output-location',
+        title: 'Output Location',
+        description: 'Where should the Terraform files be saved?',
+        execute: outputLocationStep,
+    });
+    // Step 3: Generate
+    steps.push({
+        id: 'generate',
+        title: 'Generate Terraform',
+        description: 'Generating Terraform configurations...',
+        execute: generateStep,
+    });
+    // Step 4: Write Files
+    steps.push({
+        id: 'write-files',
+        title: 'Write Files',
+        description: 'Writing files to disk...',
+        execute: writeFilesStep,
+    });
+    return steps;
+}
+/**
+ * Step 1: Generation Options
+ */
+async function generationOptionsStep(ctx) {
+    // Organization style
+    const organizeChoice = await select({
+        message: 'How should Terraform files be organized?',
+        options: [
+            {
+                value: 'service',
+                label: 'By service (Recommended)',
+                description: 'Separate files for each AWS service (ec2.tf, s3.tf, etc.)',
+            },
+            {
+                value: 'single',
+                label: 'Single file',
+                description: 'All resources in main.tf',
+            },
+        ],
+        defaultValue: ctx.organizeByService !== false ? 'service' : 'single',
+    });
+    // Import method
+    ui.newLine();
+    const importMethod = await select({
+        message: 'How should imports be generated?',
+        options: [
+            {
+                value: 'both',
+                label: 'Both import blocks and shell script (Recommended)',
+                description: 'Maximum compatibility with all Terraform versions',
+            },
+            {
+                value: 'blocks',
+                label: 'Import blocks only (Terraform 1.5+)',
+                description: 'Modern declarative imports in .tf files',
+            },
+            {
+                value: 'script',
+                label: 'Shell script only',
+                description: 'Traditional terraform import commands',
+            },
+            {
+                value: 'none',
+                label: 'No imports',
+                description: 'Generate resource definitions only',
+            },
+        ],
+        defaultValue: 'both',
+    });
+    // Terraform version
+    ui.newLine();
+    const terraformVersion = await select({
+        message: 'Target Terraform version:',
+        options: [
+            { value: '1.5.0', label: '1.5.0+', description: 'Supports import blocks' },
+            { value: '1.4.0', label: '1.4.0', description: 'Latest stable without import blocks' },
+            { value: '1.3.0', label: '1.3.0', description: 'Older version' },
+        ],
+        defaultValue: ctx.terraformVersion || '1.5.0',
+    });
+    // Starter kit
+    ui.newLine();
+    const includeStarterKit = await confirm({
+        message: 'Include starter kit (README, .gitignore, Makefile)?',
+        defaultValue: true,
+    });
+    return {
+        success: true,
+        data: {
+            organizeByService: organizeChoice === 'service',
+            generateImportBlocks: importMethod === 'both' || importMethod === 'blocks',
+            generateImportScript: importMethod === 'both' || importMethod === 'script',
+            terraformVersion,
+            includeReadme: includeStarterKit,
+            includeGitignore: includeStarterKit,
+            includeMakefile: includeStarterKit,
+        },
+    };
+}
+/**
+ * Step 2: Output Location
+ */
+async function outputLocationStep(ctx) {
+    const outputPath = await pathInput('Where should the Terraform files be saved?', ctx.outputPath || './terraform-aws');
+    if (!outputPath) {
+        return { success: false, error: 'Output path is required' };
+    }
+    // Check if directory exists
+    const exists = fs.existsSync(outputPath);
+    if (exists) {
+        const files = fs.readdirSync(outputPath);
+        if (files.length > 0) {
+            ui.newLine();
+            ui.warning(`Directory ${outputPath} is not empty (${files.length} files)`);
+            const overwrite = await confirm({
+                message: 'Overwrite existing files?',
+                defaultValue: false,
+            });
+            if (!overwrite) {
+                return { success: false, error: 'User cancelled - directory not empty' };
+            }
+        }
+    }
+    return {
+        success: true,
+        data: { outputPath },
+    };
+}
+/**
+ * Step 3: Generate Terraform using local generator
+ */
+async function generateStep(ctx) {
+    ui.startSpinner({ message: 'Generating Terraform configurations...' });
+    try {
+        // Derive components from discovered resources
+        const resourceTypes = (ctx.resources ?? []).map(r => r.type);
+        const components = [];
+        if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet')))
+            components.push('vpc');
+        if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance')))
+            components.push('ec2');
+        if (resourceTypes.some(t => t.includes('S3')))
+            components.push('s3');
+        if (resourceTypes.some(t => t.includes('RDS')))
+            components.push('rds');
+        if (resourceTypes.some(t => t.includes('EKS')))
+            components.push('eks');
+        if (components.length === 0)
+            components.push('vpc', 's3');
+        const generatedProject = await generateTerraformProject({
+            projectName: 'infrastructure',
+            provider: 'aws',
+            region: ctx.resources?.[0]?.region || 'us-east-1',
+            components,
+        });
+        const fileMap = {};
+        for (const file of generatedProject.files) {
+            fileMap[file.path] = file.content;
+        }
+        const summary = {
+            totalResources: ctx.resources?.length ?? 0,
+            mappedResources: ctx.resources?.length ?? 0,
+            unmappedResources: 0,
+            filesGenerated: generatedProject.files.length,
+            servicesIncluded: components,
+            regionsIncluded: [...new Set((ctx.resources ?? []).map(r => r.region).filter(Boolean))],
+        };
+        ui.stopSpinnerSuccess(`Generated ${Object.keys(fileMap).length} file(s)`);
+        // Add starter kit files if requested
+        if (ctx.includeReadme)
+            fileMap['README.md'] = generateReadme(summary);
+        if (ctx.includeGitignore)
+            fileMap['.gitignore'] = generateGitignore();
+        if (ctx.includeMakefile)
+            fileMap['Makefile'] = generateMakefile();
+        return {
+            success: true,
+            data: {
+                generatedFiles: fileMap,
+                summary,
+            },
+        };
+    }
+    catch (error) {
+        ui.stopSpinnerFail(`Generation failed: ${error.message}`);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Step 4: Write Files
+ */
+async function writeFilesStep(ctx) {
+    if (!ctx.generatedFiles || !ctx.outputPath) {
+        return { success: false, error: 'No files to write' };
+    }
+    ui.startSpinner({ message: 'Writing files to disk...' });
+    try {
+        // Create output directory
+        if (!fs.existsSync(ctx.outputPath)) {
+            fs.mkdirSync(ctx.outputPath, { recursive: true });
+        }
+        // Write each file
+        const fileNames = Object.keys(ctx.generatedFiles);
+        for (const fileName of fileNames) {
+            const filePath = path.join(ctx.outputPath, fileName);
+            const content = ctx.generatedFiles[fileName];
+            // Create subdirectories if needed
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            await writeFile(filePath, content, 'utf-8');
+        }
+        // Make import script executable
+        if (ctx.generatedFiles['import.sh']) {
+            const scriptPath = path.join(ctx.outputPath, 'import.sh');
+            fs.chmodSync(scriptPath, '755');
+        }
+        ui.stopSpinnerSuccess(`Wrote ${fileNames.length} files to ${ctx.outputPath}`);
+        return {
+            success: true,
+            data: { filesWritten: fileNames.length },
+        };
+    }
+    catch (error) {
+        ui.stopSpinnerFail(`Failed to write files: ${error.message}`);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Generate README.md content
+ */
+function generateReadme(summary) {
+    return `# Terraform AWS Infrastructure
+
+Generated by Nimbus CLI
+
+## Summary
+
+- **Total Resources**: ${summary.totalResources}
+- **Mapped Resources**: ${summary.mappedResources}
+- **Unmapped Resources**: ${summary.unmappedResources}
+- **Files Generated**: ${summary.filesGenerated}
+
+### Services
+
+${summary.servicesIncluded.map(s => `- ${s}`).join('\n')}
+
+### Regions
+
+${summary.regionsIncluded.map(r => `- ${r}`).join('\n')}
+
+## Getting Started
+
+1. **Initialize Terraform**:
+   \`\`\`bash
+   terraform init
+   \`\`\`
+
+2. **Import existing resources** (choose one):
+
+   Using import blocks (Terraform 1.5+):
+   \`\`\`bash
+   terraform plan -generate-config-out=generated.tf
+   \`\`\`
+
+   Using import script:
+   \`\`\`bash
+   ./import.sh
+   \`\`\`
+
+3. **Review the plan**:
+   \`\`\`bash
+   terraform plan
+   \`\`\`
+
+4. **Apply changes** (should show no changes if imports were successful):
+   \`\`\`bash
+   terraform apply
+   \`\`\`
+
+## File Structure
+
+- \`providers.tf\` - AWS provider configuration
+- \`variables.tf\` - Input variables
+- \`outputs.tf\` - Output values
+- \`*.tf\` - Resource definitions by service
+- \`import.sh\` - Import script for existing resources
+
+## Notes
+
+- Review all generated configurations before applying
+- Some sensitive values may need to be filled in manually
+- Consider using Terraform workspaces for different environments
+`;
+}
+/**
+ * Generate .gitignore content
+ */
+function generateGitignore() {
+    return `# Terraform
+*.tfstate
+*.tfstate.*
+.terraform/
+.terraform.lock.hcl
+crash.log
+crash.*.log
+*.tfvars
+*.tfvars.json
+override.tf
+override.tf.json
+*_override.tf
+*_override.tf.json
+
+# Sensitive files
+*.pem
+*.key
+.env
+.env.*
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+`;
+}
+/**
+ * Generate Makefile content
+ */
+function generateMakefile() {
+    return `# Terraform Makefile
+
+.PHONY: init plan apply destroy fmt validate import clean
+
+# Initialize Terraform
+init:
+	terraform init
+
+# Plan changes
+plan:
+	terraform plan
+
+# Apply changes
+apply:
+	terraform apply
+
+# Destroy infrastructure
+destroy:
+	terraform destroy
+
+# Format code
+fmt:
+	terraform fmt -recursive
+
+# Validate configuration
+validate:
+	terraform validate
+
+# Import existing resources
+import:
+	./import.sh
+
+# Clean up
+clean:
+	rm -rf .terraform
+	rm -f .terraform.lock.hcl
+
+# Full workflow
+all: init fmt validate plan
+`;
+}
+/**
+ * Display completion message
+ */
+function displayCompletionMessage(ctx) {
+    ui.newLine();
+    ui.box({
+        title: 'Terraform Generation Complete!',
+        content: [
+            `Output: ${ctx.outputPath}`,
+            `Files: ${Object.keys(ctx.generatedFiles || {}).length}`,
+            '',
+            'Summary:',
+            `  Resources: ${ctx.summary?.mappedResources || 0} mapped, ${ctx.summary?.unmappedResources || 0} unmapped`,
+            `  Services: ${ctx.summary?.servicesIncluded?.join(', ') || 'N/A'}`,
+            '',
+            'Next steps:',
+            `  1. cd ${ctx.outputPath}`,
+            '  2. terraform init',
+            '  3. ./import.sh   # Import existing resources',
+            '  4. terraform plan',
+        ],
+        style: 'rounded',
+        borderColor: 'green',
+        padding: 1,
+    });
+}
+/**
+ * Run in non-interactive mode
+ */
+async function runNonInteractive(options) {
+    ui.header('nimbus aws terraform', 'Non-interactive mode');
+    // Must have either session ID, resources file, or profile for discovery
+    if (!options.sessionId && !options.resourcesFile && !options.profile) {
+        ui.error('One of --session-id, --resources-file, or --profile is required');
+        process.exit(1);
+    }
+    let resources;
+    // Load from file if specified
+    if (options.resourcesFile) {
+        ui.startSpinner({ message: 'Loading resources from file...' });
+        try {
+            const fileContent = await readFile(options.resourcesFile, 'utf-8');
+            const data = JSON.parse(fileContent);
+            resources = data.resources || data;
+            ui.stopSpinnerSuccess(`Loaded ${resources.length} resources`);
+        }
+        catch (error) {
+            ui.stopSpinnerFail(`Failed to load resources: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    // Run discovery if profile specified
+    else if (options.profile && !options.sessionId) {
+        const discoveryOptions = {
+            profile: options.profile,
+            regions: options.regions,
+            services: options.services,
+            nonInteractive: true,
+        };
+        const inventory = await awsDiscoverCommand(discoveryOptions);
+        if (!inventory) {
+            ui.error('Discovery failed');
+            process.exit(1);
+        }
+        resources = inventory.resources;
+    }
+    // Generate Terraform using local generator
+    ui.startSpinner({ message: 'Generating Terraform configurations...' });
+    try {
+        const resourceTypes = (resources ?? []).map(r => r.type);
+        const components = [];
+        if (resourceTypes.some(t => t.includes('VPC') || t.includes('Subnet')))
+            components.push('vpc');
+        if (resourceTypes.some(t => t.includes('EC2') || t.includes('Instance')))
+            components.push('ec2');
+        if (resourceTypes.some(t => t.includes('S3')))
+            components.push('s3');
+        if (resourceTypes.some(t => t.includes('RDS')))
+            components.push('rds');
+        if (resourceTypes.some(t => t.includes('EKS')))
+            components.push('eks');
+        if (components.length === 0)
+            components.push('vpc', 's3');
+        const generatedProject = await generateTerraformProject({
+            projectName: 'infrastructure',
+            provider: 'aws',
+            region: resources?.[0]?.region || 'us-east-1',
+            components,
+        });
+        const files = {};
+        for (const file of generatedProject.files) {
+            files[file.path] = file.content;
+        }
+        const summary = {
+            totalResources: resources?.length ?? 0,
+            mappedResources: resources?.length ?? 0,
+            unmappedResources: 0,
+            filesGenerated: generatedProject.files.length,
+            servicesIncluded: components,
+            regionsIncluded: [...new Set((resources ?? []).map(r => r.region).filter(Boolean))],
+        };
+        ui.stopSpinnerSuccess(`Generated ${Object.keys(files).length} file(s)`);
+        // Write files
+        const outputPath = options.output || './terraform-aws';
+        ui.startSpinner({ message: 'Writing files...' });
+        if (!fs.existsSync(outputPath)) {
+            fs.mkdirSync(outputPath, { recursive: true });
+        }
+        if (options.includeStarterKit || options.includeReadme)
+            files['README.md'] = generateReadme(summary);
+        if (options.includeStarterKit || options.includeGitignore)
+            files['.gitignore'] = generateGitignore();
+        if (options.includeStarterKit || options.includeMakefile)
+            files['Makefile'] = generateMakefile();
+        for (const [fileName, content] of Object.entries(files)) {
+            const filePath = path.join(outputPath, fileName);
+            await writeFile(filePath, content, 'utf-8');
+        }
+        ui.stopSpinnerSuccess(`Wrote ${Object.keys(files).length} files to ${outputPath}`);
+        ui.newLine();
+        ui.success('Generation complete!');
+        ui.print(`  Output: ${outputPath}`);
+        ui.print(`  Resources: ${summary.mappedResources} mapped`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail(`Generation failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+export default awsTerraformCommand;