@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/demo/scenarios/terraform-vpc.js

@@ -0,0 +1,167 @@
+/**
+ * Terraform VPC Demo Scenario
+ *
+ * Demonstrates creating a VPC with Terraform
+ */
+export const terraformVpcScenario = {
+    id: 'terraform-vpc',
+    name: 'Create AWS VPC with Terraform',
+    description: 'Deploy a complete VPC infrastructure using Nimbus and Terraform',
+    category: 'terraform',
+    duration: 10,
+    prerequisites: [
+        'AWS CLI configured with credentials',
+        'Terraform installed (v1.0+)',
+        'Nimbus CLI installed',
+    ],
+    tags: ['terraform', 'aws', 'vpc', 'networking'],
+    steps: [
+        {
+            id: 'init-project',
+            title: 'Initialize Nimbus Project',
+            description: 'Scan the current directory and set up Nimbus configuration',
+            command: 'nimbus init',
+            showOutput: true,
+            waitForInput: true,
+            mockResponse: `
+Nimbus Initialization
+
+Scanning project...
+
+Project Summary:
+  Type: infrastructure
+  Languages: HCL
+  IaC Tools: Terraform
+  Cloud: AWS
+
+Created .nimbus/project.yaml
+Created .nimbus/config.yaml
+
+Project initialized successfully!
+      `.trim(),
+        },
+        {
+            id: 'start-questionnaire',
+            title: 'Start Terraform Questionnaire',
+            description: 'Use the interactive wizard to configure VPC settings',
+            command: 'nimbus questionnaire terraform',
+            showOutput: true,
+            waitForInput: true,
+            mockResponse: `
+Terraform Configuration Wizard
+
+Starting local questionnaire...
+
+Step 1/3: Provider Configuration
+  Provider: aws
+  Region: us-east-1
+
+Step 2/3: Component Selection
+  Components: vpc
+
+Step 3/3: VPC Configuration
+  CIDR Block: 10.0.0.0/16
+  Availability Zones: 3
+
+Questionnaire completed!
+Generating code...
+
+Generated files:
+  ● main.tf
+  ● variables.tf
+  ● outputs.tf
+
+Output directory: ./terraform
+      `.trim(),
+        },
+        {
+            id: 'preview-plan',
+            title: 'Preview Terraform Plan',
+            description: 'See what changes will be made before applying',
+            command: 'nimbus preview terraform ./terraform',
+            showOutput: true,
+            waitForInput: true,
+            mockResponse: `
+Preview Terraform Changes
+
+Directory: ./terraform
+
+Creating execution plan...
+Plan created
+
+Plan Summary:
+
+  + 6 to add
+  ~ 0 to change
+  - 0 to destroy
+
+  Safety Check Summary:
+
+    🟡 [MEDIUM]  This operation will modify infrastructure
+
+All safety checks passed
+      `.trim(),
+        },
+        {
+            id: 'apply-terraform',
+            title: 'Apply Terraform Configuration',
+            description: 'Deploy the VPC infrastructure with safety approval',
+            command: 'nimbus apply terraform ./terraform',
+            showOutput: true,
+            waitForInput: true,
+            mockResponse: `
+Terraform Apply
+
+Directory: ./terraform
+
+Creating execution plan...
+Plan created
+
+Plan Summary:
+  + 6 to add
+
+╔══════════════════════════════════════════════════════════╗
+║               APPROVAL REQUIRED                          ║
+╠══════════════════════════════════════════════════════════╣
+║  Operation: terraform apply                              ║
+╚══════════════════════════════════════════════════════════╝
+
+  Identified Risks:
+
+    🟡 [MEDIUM]  This operation will modify infrastructure
+
+Do you want to proceed with this operation? Yes
+
+Operation approved
+
+Applying changes...
+Apply complete!
+
+Apply complete! Resources: 6 added, 0 changed, 0 destroyed.
+
+Outputs:
+  vpc_id = "vpc-0abc123def456789"
+  private_subnets = ["subnet-001", "subnet-002", "subnet-003"]
+  public_subnets = ["subnet-101", "subnet-102", "subnet-103"]
+      `.trim(),
+        },
+        {
+            id: 'verify-vpc',
+            title: 'Verify VPC Creation',
+            description: 'List VPCs to confirm our new VPC was created',
+            command: 'nimbus aws vpc list',
+            showOutput: true,
+            waitForInput: false,
+            mockResponse: `
+VPCs
+
+Found 2 VPC(s)
+
+VPC ID                Name           CIDR           State      Default
+─────────────────────────────────────────────────────────────────────
+vpc-default           default        172.31.0.0/16  available  Yes
+vpc-0abc123def456789  my-project     10.0.0.0/16    available  No
+      `.trim(),
+        },
+    ],
+};

package/dist/src/demo/types.js

@@ -0,0 +1,6 @@
+/**
+ * Demo Framework Types
+ *
+ * Type definitions for the demo scenarios framework
+ */
+export {};

package/dist/src/engine/cost-estimator.js

@@ -0,0 +1,334 @@
+/**
+ * Cost Estimator
+ *
+ * Standalone module for estimating monthly and annual infrastructure costs
+ * based on component type, environment, region, and usage patterns.
+ *
+ * Extracted from the cost estimation logic in verifier.ts and planner.ts,
+ * with expanded capabilities for detailed breakdowns and recommendations.
+ */
+import { logger } from '../utils';
+// ==========================================
+// Constants
+// ==========================================
+/**
+ * Base monthly component costs in USD.
+ *
+ * These are intentionally conservative estimates for the most common
+ * instance sizes and usage patterns. Extracted directly from the
+ * original verifier.ts cost table and expanded for additional components.
+ *
+ * Sources:
+ *   vpc: NAT Gateway ($0.045/h * 730h) ~= $32
+ *   eks: Control plane only ($0.10/h * 730h) ~= $73
+ *   rds: db.t3.micro ($0.017/h) + 20GB storage (~$2.30) ~= $15; rounded to $50 with Multi-AZ
+ *   s3:  Minimal storage estimate (< 100GB) ~= $5
+ */
+const BASE_COMPONENT_COSTS = {
+    // AWS Compute
+    vpc: 32,
+    eks: 73,
+    ecs: 30,
+    lambda: 2,
+    // EC2 instance types (monthly on-demand us-east-1)
+    't3.micro': 8,
+    't3.small': 16,
+    't3.medium': 32,
+    't3.large': 65,
+    'm5.large': 70,
+    'm5.xlarge': 140,
+    'm5.2xlarge': 280,
+    'c5.large': 62,
+    'c5.xlarge': 124,
+    'r5.large': 91,
+    'r5.xlarge': 182,
+    // RDS instance types (monthly, single-AZ)
+    'db.t3.micro': 14,
+    'db.t3.small': 28,
+    'db.t3.medium': 56,
+    'db.r5.large': 175,
+    'db.r5.xlarge': 350,
+    // AWS Data
+    rds: 50,
+    s3: 5,
+    elasticache: 25,
+    sqs: 1,
+    sns: 1,
+    cloudfront: 10,
+    // AWS Network/LB
+    'aws_nat_gateway': 32,
+    'aws_lb': 25,
+    'aws_alb': 25,
+    'aws_instance': 30,
+    'aws_db_instance': 50,
+    'aws_s3_bucket': 5,
+    'aws_eks_cluster': 73,
+    'aws_elasticache_cluster': 25,
+    'aws_rds_cluster': 50,
+    'aws_lambda_function': 2,
+    'aws_cloudfront_distribution': 10,
+    // GCP
+    'google_compute_instance': 30,
+    'google_container_cluster': 73,
+    'google_sql_database_instance': 50,
+    'google_storage_bucket': 5,
+    // Azure
+    'azurerm_virtual_machine': 30,
+    'azurerm_kubernetes_cluster': 73,
+    'azurerm_sql_database': 50,
+    'azurerm_storage_account': 5,
+};
+/**
+ * Regional cost multipliers relative to us-east-1 (base = 1.0).
+ * Approximate — derived from AWS published pricing differentials.
+ */
+const REGIONAL_MULTIPLIERS = {
+    'us-east-1': 1.0,
+    'us-east-2': 1.0,
+    'us-west-1': 1.08,
+    'us-west-2': 1.0,
+    'eu-west-1': 1.06,
+    'eu-west-2': 1.1,
+    'eu-central-1': 1.08,
+    'ap-southeast-1': 1.14,
+    'ap-northeast-1': 1.16,
+    'ap-south-1': 1.05,
+    'sa-east-1': 1.2,
+    'ca-central-1': 1.06,
+    // GCP regions (approximate relative costs)
+    'us-central1': 1.0,
+    'us-east1': 1.0,
+    'europe-west1': 1.08,
+    'asia-east1': 1.12,
+    // Azure regions
+    eastus: 1.0,
+    westus: 1.05,
+    westeurope: 1.1,
+    southeastasia: 1.12,
+};
+/**
+ * Environment multipliers.
+ * Production typically uses larger, HA-ready instances; dev uses minimal sizes.
+ */
+const ENVIRONMENT_MULTIPLIERS = {
+    development: 0.5,
+    staging: 0.75,
+    production: 1.0,
+    prod: 1.0,
+    dev: 0.5,
+    staging_: 0.75,
+};
+/**
+ * Human-readable notes per component explaining the cost assumption.
+ */
+const COMPONENT_NOTES = {
+    vpc: 'NAT Gateway ($0.045/h) — one AZ; add $32/mo per additional AZ',
+    eks: 'EKS control plane only ($0.10/h); node group EC2 costs are additive',
+    rds: 'db.t3.micro Multi-AZ estimated; scales significantly with instance class',
+    s3: 'Minimal estimate (<100GB, <1M requests); review lifecycle policies for long-term savings',
+    ecs: 'Fargate minimal workload; scales linearly with vCPU and memory allocation',
+    lambda: 'Under 1M invocations/month; free tier may apply',
+    cloudfront: 'Under 1TB egress/month; varies heavily with traffic patterns',
+    elasticache: 'cache.t3.micro; consider Reserved Nodes for >30% savings in production',
+    sqs: 'Under 1M requests/month; near-zero cost at small scale',
+    sns: 'Under 1M notifications/month; near-zero cost at small scale',
+};
+// ==========================================
+// CostEstimator
+// ==========================================
+export class CostEstimator {
+    /**
+     * Estimate the monthly and annual cost for a given set of components.
+     */
+    estimate(input) {
+        const environment = input.environment || 'production';
+        const provider = input.provider || 'aws';
+        const region = input.region || this.defaultRegion(provider);
+        const budgetLimit = input.budgetLimit;
+        logger.info(`Estimating cost for ${input.components.length} components ` +
+            `(env=${environment}, provider=${provider}, region=${region})`);
+        const envMultiplier = this.resolveEnvironmentMultiplier(environment);
+        const regionMultiplier = this.resolveRegionalMultiplier(region);
+        const breakdown = [];
+        for (const component of input.components) {
+            const baseCost = this.resolveBaseCost(component, input.customCosts);
+            const adjustedCost = Math.round(baseCost * envMultiplier * regionMultiplier * 100) / 100;
+            breakdown.push({
+                component,
+                baseMonthlyCost: baseCost,
+                adjustedMonthlyCost: adjustedCost,
+                environmentMultiplier: envMultiplier,
+                regionalMultiplier: regionMultiplier,
+                notes: COMPONENT_NOTES[component] ||
+                    `Estimate for ${component}; verify against provider pricing`,
+            });
+        }
+        const totalMonthlyCost = Math.round(breakdown.reduce((sum, b) => sum + b.adjustedMonthlyCost, 0) * 100) / 100;
+        const totalAnnualCost = Math.round(totalMonthlyCost * 12 * 100) / 100;
+        const withinBudget = budgetLimit !== undefined ? totalMonthlyCost <= budgetLimit : true;
+        const recommendations = this.generateRecommendations(input, breakdown, totalMonthlyCost);
+        logger.info(`Cost estimate: $${totalMonthlyCost}/mo ($${totalAnnualCost}/yr); ` +
+            `${withinBudget ? 'within' : 'exceeds'} budget`);
+        return {
+            totalMonthlyCost,
+            totalAnnualCost,
+            breakdown,
+            withinBudget,
+            budgetLimit,
+            recommendations,
+            environment,
+            provider,
+            generatedAt: new Date(),
+        };
+    }
+    /**
+     * Estimate cost from a flat context object (compatible with verifier/planner usage).
+     *
+     * This is a convenience wrapper that accepts the same `context` shape used
+     * by the Verifier's `runCostChecks` method, allowing the CostEstimator to
+     * serve as a drop-in replacement.
+     */
+    estimateFromContext(context) {
+        const components = context.components || [];
+        const result = this.estimate({
+            components,
+            environment: context.environment || 'production',
+            provider: context.provider || 'aws',
+            region: context.region,
+            budgetLimit: context.budget_limit,
+        });
+        return result.totalMonthlyCost;
+    }
+    /**
+     * Format a CostEstimate as a Markdown report.
+     */
+    formatAsMarkdown(estimate) {
+        const lines = [
+            `# Infrastructure Cost Estimate`,
+            ``,
+            `**Environment:** ${estimate.environment}`,
+            `**Provider:** ${estimate.provider}`,
+            `**Generated:** ${estimate.generatedAt.toISOString()}`,
+            ``,
+            `## Summary`,
+            ``,
+            `| Metric | Value |`,
+            `|--------|-------|`,
+            `| Monthly Cost | $${estimate.totalMonthlyCost.toFixed(2)} |`,
+            `| Annual Cost | $${estimate.totalAnnualCost.toFixed(2)} |`,
+        ];
+        if (estimate.budgetLimit !== undefined) {
+            lines.push(`| Budget Limit | $${estimate.budgetLimit.toFixed(2)} |`, `| Status | ${estimate.withinBudget ? 'Within Budget' : 'Over Budget'} |`);
+        }
+        lines.push(``, `## Component Breakdown`, ``, `| Component | Base ($/mo) | Adjusted ($/mo) | Notes |`, `|-----------|------------|----------------|-------|`);
+        for (const b of estimate.breakdown) {
+            lines.push(`| ${b.component} | $${b.baseMonthlyCost.toFixed(2)} | $${b.adjustedMonthlyCost.toFixed(2)} | ${b.notes} |`);
+        }
+        if (estimate.recommendations.length > 0) {
+            lines.push(``, `## Recommendations`, ``);
+            for (const rec of estimate.recommendations) {
+                lines.push(`- ${rec}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate cost optimisation recommendations based on the estimate inputs and results.
+     */
+    generateRecommendations(input, breakdown, totalMonthlyCost) {
+        const recommendations = [];
+        const env = (input.environment || 'production').toLowerCase();
+        const components = input.components.map(c => c.toLowerCase());
+        // Production: Reserved instances
+        if (env === 'production' || env === 'prod') {
+            const hasExpensive = components.some(c => ['eks', 'rds', 'elasticache'].includes(c));
+            if (hasExpensive) {
+                recommendations.push('Consider Reserved Instances or Savings Plans for EKS nodes, RDS, and ElastiCache — ' +
+                    'typically 30-40% savings over on-demand pricing with 1-year commitments.');
+            }
+        }
+        // Non-production: Single NAT gateway
+        if (env !== 'production' && env !== 'prod' && components.includes('vpc')) {
+            recommendations.push('Use a single NAT Gateway in non-production environments to save ~$32/mo per additional AZ.');
+        }
+        // S3 lifecycle policies
+        if (components.includes('s3')) {
+            recommendations.push('Configure S3 Lifecycle policies to transition infrequently accessed objects to ' +
+                'S3 Intelligent-Tiering or Glacier; can reduce storage costs by 40-60%.');
+        }
+        // Development: spot instances
+        if (env === 'development' || env === 'dev') {
+            if (components.some(c => ['eks', 'ecs'].includes(c))) {
+                recommendations.push('Use Spot Instances for development EKS node groups and ECS Fargate Spot — ' +
+                    'up to 90% savings with appropriate interruption handling.');
+            }
+        }
+        // High overall cost warning
+        if (totalMonthlyCost > 1000) {
+            recommendations.push(`Total monthly cost $${totalMonthlyCost.toFixed(2)} is significant. ` +
+                'Review instance types, enable autoscaling, and run AWS Cost Explorer or GCP Cost Management ' +
+                'to identify unexpected spend.');
+        }
+        // Lambda: evaluate if replacing always-on compute
+        if (components.includes('lambda') &&
+            !components.includes('ecs') &&
+            !components.includes('eks')) {
+            recommendations.push('Lambda-only architecture is cost-efficient at low request volumes. ' +
+                'Monitor concurrency limits and cold-start latency as traffic grows.');
+        }
+        // EKS without VPC
+        if (components.includes('eks') && !components.includes('vpc')) {
+            recommendations.push('EKS clusters require a VPC. If using an existing VPC, ensure its NAT Gateway costs are ' +
+                'accounted for separately (typically +$32/mo per AZ).');
+        }
+        return recommendations;
+    }
+    /**
+     * Resolve base cost for a component, respecting custom overrides.
+     */
+    resolveBaseCost(component, customCosts) {
+        if (customCosts && component in customCosts) {
+            return customCosts[component];
+        }
+        return BASE_COMPONENT_COSTS[component.toLowerCase()] ?? 0;
+    }
+    /**
+     * Resolve environment multiplier from an environment string.
+     */
+    resolveEnvironmentMultiplier(environment) {
+        const key = environment.toLowerCase();
+        return ENVIRONMENT_MULTIPLIERS[key] ?? 1.0;
+    }
+    /**
+     * Resolve regional multiplier from a region string.
+     */
+    resolveRegionalMultiplier(region) {
+        return REGIONAL_MULTIPLIERS[region] ?? 1.0;
+    }
+    /**
+     * Return the default region for a given provider.
+     */
+    defaultRegion(provider) {
+        switch (provider.toLowerCase()) {
+            case 'gcp':
+                return 'us-central1';
+            case 'azure':
+                return 'eastus';
+            case 'aws':
+            default:
+                return 'us-east-1';
+        }
+    }
+    /**
+     * Get the base cost table (useful for display or testing).
+     */
+    getBaseCostTable() {
+        return { ...BASE_COMPONENT_COSTS };
+    }
+    /**
+     * Get the regional multiplier table (useful for display or testing).
+     */
+    getRegionalMultiplierTable() {
+        return { ...REGIONAL_MULTIPLIERS };
+    }
+}

package/dist/src/engine/diagram-generator.js

@@ -0,0 +1,192 @@
+/**
+ * ASCII Diagram Generator
+ *
+ * Generates architecture diagrams using box-drawing characters.
+ * No external dependencies — pure string manipulation.
+ *
+ * Embedded version: identical to services/core-engine-service/src/components/diagram-generator.ts
+ */
+/**
+ * Generates real ASCII architecture diagrams from component/connection data.
+ */
+export class DiagramGenerator {
+    boxWidth;
+    constructor(options = {}) {
+        this.boxWidth = options.boxWidth || 24;
+    }
+    /**
+     * Generate an ASCII architecture diagram.
+     */
+    generate(components, connections, title) {
+        if (components.length === 0) {
+            return '(no components)';
+        }
+        const lines = [];
+        // Title
+        if (title) {
+            lines.push(title);
+            lines.push('='.repeat(title.length));
+            lines.push('');
+        }
+        // Build adjacency for topological ordering
+        const adj = new Map();
+        const inDegree = new Map();
+        for (const c of components) {
+            adj.set(c.id, []);
+            inDegree.set(c.id, 0);
+        }
+        for (const conn of connections) {
+            adj.get(conn.from)?.push(conn.to);
+            inDegree.set(conn.to, (inDegree.get(conn.to) || 0) + 1);
+        }
+        // Topological sort (Kahn's algorithm) to determine row placement
+        const rows = [];
+        let queue = components.filter(c => (inDegree.get(c.id) || 0) === 0);
+        const placed = new Set();
+        while (queue.length > 0) {
+            rows.push([...queue]);
+            const nextQueue = [];
+            for (const node of queue) {
+                placed.add(node.id);
+                for (const neighbor of adj.get(node.id) || []) {
+                    inDegree.set(neighbor, (inDegree.get(neighbor) || 0) - 1);
+                    if (inDegree.get(neighbor) === 0 && !placed.has(neighbor)) {
+                        const comp = components.find(c => c.id === neighbor);
+                        if (comp) {
+                            nextQueue.push(comp);
+                        }
+                    }
+                }
+            }
+            queue = nextQueue;
+        }
+        // Add any unplaced components (cycles) to the last row
+        for (const c of components) {
+            if (!placed.has(c.id)) {
+                if (rows.length === 0) {
+                    rows.push([]);
+                }
+                rows[rows.length - 1].push(c);
+            }
+        }
+        // Track center positions for drawing connections
+        const colWidth = this.boxWidth + 4;
+        // Render rows of boxes
+        for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+            const row = rows[rowIdx];
+            const rowLines = this.renderBoxRow(row, colWidth);
+            for (const line of rowLines) {
+                lines.push(line);
+            }
+            // Draw vertical connection arrows between rows
+            if (rowIdx < rows.length - 1) {
+                const nextRow = rows[rowIdx + 1];
+                const arrowLines = this.renderArrows(row, nextRow, connections, colWidth);
+                for (const line of arrowLines) {
+                    lines.push(line);
+                }
+            }
+        }
+        // Legend for connections
+        if (connections.length > 0) {
+            lines.push('');
+            lines.push('Connections:');
+            for (const conn of connections) {
+                const fromComp = components.find(c => c.id === conn.from);
+                const toComp = components.find(c => c.id === conn.to);
+                if (fromComp && toComp) {
+                    const label = conn.label ? ` (${conn.label})` : '';
+                    lines.push(`  ${fromComp.label} --> ${toComp.label}${label}`);
+                }
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Render a row of component boxes.
+     */
+    renderBoxRow(components, colWidth) {
+        const w = this.boxWidth;
+        const top = `+${'-'.repeat(w)}+`;
+        const bot = `+${'-'.repeat(w)}+`;
+        const topLine = [];
+        const labelLine = [];
+        const typeLine = [];
+        const botLine = [];
+        for (const comp of components) {
+            const padding = colWidth - w - 2;
+            const pad = ' '.repeat(Math.max(0, padding / 2));
+            topLine.push(pad + top + pad);
+            const truncLabel = comp.label.length > w - 2 ? `${comp.label.substring(0, w - 5)}...` : comp.label;
+            const labelPadded = truncLabel.padStart(Math.floor((w + truncLabel.length) / 2)).padEnd(w);
+            labelLine.push(`${pad}|${labelPadded}|${pad}`);
+            if (comp.type) {
+                const truncType = comp.type.length > w - 2 ? `${comp.type.substring(0, w - 5)}...` : comp.type;
+                const typePadded = truncType.padStart(Math.floor((w + truncType.length) / 2)).padEnd(w);
+                typeLine.push(`${pad}|${typePadded}|${pad}`);
+            }
+            else {
+                typeLine.push(`${pad}|${' '.repeat(w)}|${pad}`);
+            }
+            botLine.push(pad + bot + pad);
+        }
+        return [topLine.join(''), labelLine.join(''), typeLine.join(''), botLine.join('')];
+    }
+    /**
+     * Render vertical arrows between two rows of components.
+     */
+    renderArrows(fromRow, toRow, connections, colWidth) {
+        const totalCols = Math.max(fromRow.length, toRow.length);
+        const lineWidth = totalCols * colWidth;
+        // Find which connections go between these rows
+        const fromIds = new Set(fromRow.map(c => c.id));
+        const toIds = new Set(toRow.map(c => c.id));
+        const activeConns = connections.filter(c => fromIds.has(c.from) && toIds.has(c.to));
+        if (activeConns.length === 0) {
+            return [''];
+        }
+        // Draw simple vertical arrows at the center of each from-component
+        const arrowRow1 = new Array(lineWidth).fill(' ');
+        const arrowRow2 = new Array(lineWidth).fill(' ');
+        const arrowRow3 = new Array(lineWidth).fill(' ');
+        for (const conn of activeConns) {
+            const fromIdx = fromRow.findIndex(c => c.id === conn.from);
+            if (fromIdx >= 0) {
+                const center = Math.floor(fromIdx * colWidth + colWidth / 2);
+                if (center < lineWidth) {
+                    arrowRow1[center] = '|';
+                    arrowRow2[center] = '|';
+                    arrowRow3[center] = 'V';
+                }
+            }
+        }
+        return [
+            arrowRow1.join('').trimEnd(),
+            arrowRow2.join('').trimEnd(),
+            arrowRow3.join('').trimEnd(),
+        ];
+    }
+    /**
+     * Generate a diagram for infrastructure components.
+     * Convenience method that maps common infra component names to diagram elements.
+     */
+    generateInfrastructureDiagram(componentNames, provider = 'aws') {
+        const components = componentNames.map(name => ({
+            id: name,
+            label: name.toUpperCase(),
+            type: provider.toUpperCase(),
+        }));
+        // Infer common connections
+        const connections = [];
+        const hasVpc = componentNames.includes('vpc');
+        for (const name of componentNames) {
+            if (hasVpc && name !== 'vpc' && ['eks', 'rds', 'ecs', 'lambda'].includes(name)) {
+                connections.push({ from: 'vpc', to: name, label: 'network' });
+            }
+            if (name === 'eks' && componentNames.includes('rds')) {
+                connections.push({ from: 'eks', to: 'rds', label: 'database' });
+            }
+        }
+        return this.generate(components, connections, `${provider.toUpperCase()} Infrastructure Architecture`);
+    }
+}