@frontpoint/aws-infra-mcp 0.1.0

package/dist/core/cdk-generator.js

@@ -0,0 +1,790 @@
+/**
+ * CDK Generator - Generate AWS CDK TypeScript code from configuration
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { templateEngine } from './template-engine.js';
+// CDK Templates
+const CDK_APP_TEMPLATE = `#!/usr/bin/env node
+import 'source-map-support/register';
+import * as cdk from 'aws-cdk-lib';
+{{#if stacks.network}}
+import { NetworkStack } from '../lib/stacks/network-stack';
+{{/if}}
+{{#if stacks.database}}
+import { DatabaseStack } from '../lib/stacks/database-stack';
+{{/if}}
+{{#if stacks.storage}}
+import { StorageStack } from '../lib/stacks/storage-stack';
+{{/if}}
+{{#if stacks.compute}}
+import { ComputeStack } from '../lib/stacks/compute-stack';
+{{/if}}
+
+const app = new cdk.App();
+
+const env = {
+  account: process.env.CDK_DEFAULT_ACCOUNT || '{{account}}',
+  region: process.env.CDK_DEFAULT_REGION || '{{region}}',
+};
+
+const tags = {
+  Project: '{{projectName}}',
+  Environment: '{{environment}}',
+  ManagedBy: 'CDK',
+};
+
+{{#if stacks.network}}
+const networkStack = new NetworkStack(app, '{{pascalCase projectName}}NetworkStack', {
+  env,
+  tags,
+});
+
+{{/if}}
+{{#if stacks.database}}
+const databaseStack = new DatabaseStack(app, '{{pascalCase projectName}}DatabaseStack', {
+  env,
+  tags,
+{{#if stacks.network}}
+  vpc: networkStack.vpc,
+{{/if}}
+});
+{{#if stacks.network}}
+databaseStack.addDependency(networkStack);
+{{/if}}
+
+{{/if}}
+{{#if stacks.storage}}
+const storageStack = new StorageStack(app, '{{pascalCase projectName}}StorageStack', {
+  env,
+  tags,
+});
+
+{{/if}}
+{{#if stacks.compute}}
+const computeStack = new ComputeStack(app, '{{pascalCase projectName}}ComputeStack', {
+  env,
+  tags,
+{{#if stacks.network}}
+  vpc: networkStack.vpc,
+{{/if}}
+{{#if stacks.storage}}
+  ecrRepositories: storageStack.ecrRepositories,
+{{/if}}
+});
+{{#if stacks.network}}
+computeStack.addDependency(networkStack);
+{{/if}}
+{{#if stacks.storage}}
+computeStack.addDependency(storageStack);
+{{/if}}
+{{/if}}
+
+app.synth();
+`;
+const NETWORK_STACK_TEMPLATE = `import * as cdk from 'aws-cdk-lib';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as apigateway from 'aws-cdk-lib/aws-apigatewayv2';
+import { Construct } from 'constructs';
+
+export interface NetworkStackProps extends cdk.StackProps {}
+
+export class NetworkStack extends cdk.Stack {
+  public readonly vpc: ec2.IVpc;
+
+  constructor(scope: Construct, id: string, props?: NetworkStackProps) {
+    super(scope, id, props);
+
+{{#each vpcs}}
+    // VPC: {{name}}
+    const {{camelCase name}}Vpc = new ec2.Vpc(this, '{{pascalCase name}}Vpc', {
+      ipAddresses: ec2.IpAddresses.cidr('{{cidrBlock}}'),
+      maxAzs: {{length subnets}},
+      enableDnsSupport: {{enableDnsSupport}},
+      enableDnsHostnames: {{enableDnsHostnames}},
+      natGateways: {{length natGateways}},
+      subnetConfiguration: [
+        {
+          name: 'Public',
+          subnetType: ec2.SubnetType.PUBLIC,
+          cidrMask: 20,
+        },
+        {
+          name: 'Private',
+          subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
+          cidrMask: 20,
+        },
+      ],
+    });
+
+{{#if ../isFirst}}
+    this.vpc = {{camelCase name}}Vpc;
+{{/if}}
+
+    // Security Groups
+{{#each securityGroups}}
+    const {{camelCase name}} = new ec2.SecurityGroup(this, '{{pascalCase name}}', {
+      vpc: {{camelCase ../name}}Vpc,
+      description: '{{description}}',
+      allowAllOutbound: true,
+    });
+{{#each ingressRules}}
+    {{camelCase ../name}}.addIngressRule(
+      ec2.Peer.ipv4('{{cidrBlocks.[0]}}'),
+      ec2.Port.tcp({{toPort}}),
+      '{{description}}'
+    );
+{{/each}}
+{{/each}}
+{{/each}}
+
+{{#each apiGateways}}
+    // API Gateway: {{name}}
+    const {{camelCase name}}Api = new apigateway.CfnApi(this, '{{pascalCase name}}Api', {
+      name: '{{name}}',
+      protocolType: '{{type}}',
+      description: '{{description}}',
+{{#if cors}}
+      corsConfiguration: {
+        allowOrigins: {{{jsonInline cors.allowOrigins}}},
+        allowMethods: {{{jsonInline cors.allowMethods}}},
+        allowHeaders: {{{jsonInline cors.allowHeaders}}},
+        maxAge: {{cors.maxAge}},
+      },
+{{/if}}
+    });
+
+{{#each stages}}
+    new apigateway.CfnStage(this, '{{pascalCase ../name}}{{pascalCase name}}Stage', {
+      apiId: {{camelCase ../name}}Api.ref,
+      stageName: '{{name}}',
+      autoDeploy: {{autoDeploy}},
+    });
+{{/each}}
+{{/each}}
+
+    // Outputs
+{{#each vpcs}}
+    new cdk.CfnOutput(this, '{{pascalCase name}}VpcId', {
+      value: {{camelCase name}}Vpc.vpcId,
+      description: 'VPC ID for {{name}}',
+    });
+{{/each}}
+  }
+}
+`;
+const DATABASE_STACK_TEMPLATE = `import * as cdk from 'aws-cdk-lib';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as rds from 'aws-cdk-lib/aws-rds';
+import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
+import { Construct } from 'constructs';
+
+export interface DatabaseStackProps extends cdk.StackProps {
+  vpc?: ec2.IVpc;
+}
+
+export class DatabaseStack extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: DatabaseStackProps) {
+    super(scope, id, props);
+
+    const vpc = props?.vpc;
+
+{{#each rdsInstances}}
+    // RDS Instance: {{name}}
+    new rds.DatabaseInstance(this, '{{pascalCase name}}', {
+      engine: rds.DatabaseInstanceEngine.{{uppercase engine}}({
+        version: rds.{{pascalCase engine}}EngineVersion.VER_{{snakeCase engineVersion}},
+      }),
+      instanceType: ec2.InstanceType.of(
+        ec2.InstanceClass.{{uppercase (substring instanceClass 3 4)}},
+        ec2.InstanceSize.{{uppercase (substring instanceClass 5)}}
+      ),
+      vpc: vpc!,
+      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+      allocatedStorage: {{allocatedStorage}},
+      storageType: rds.StorageType.GP3,
+      multiAz: {{multiAZ}},
+      publiclyAccessible: {{publiclyAccessible}},
+      deletionProtection: {{deletionProtection}},
+      backupRetention: cdk.Duration.days({{backupRetentionPeriod}}),
+      enablePerformanceInsights: {{performanceInsightsEnabled}},
+      removalPolicy: cdk.RemovalPolicy.SNAPSHOT,
+    });
+
+{{/each}}
+{{#each auroraClusters}}
+    // Aurora Cluster: {{name}}
+{{#if serverlessV2ScalingConfiguration}}
+    new rds.DatabaseCluster(this, '{{pascalCase name}}', {
+      engine: rds.DatabaseClusterEngine.{{camelCase engine}}({
+        version: rds.Aurora{{pascalCase (substring engine 7)}}EngineVersion.VER_3_04_0,
+      }),
+      vpc: vpc!,
+      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+      serverlessV2MinCapacity: {{serverlessV2ScalingConfiguration.minCapacity}},
+      serverlessV2MaxCapacity: {{serverlessV2ScalingConfiguration.maxCapacity}},
+      writer: rds.ClusterInstance.serverlessV2('writer'),
+      deletionProtection: {{deletionProtection}},
+      backup: { retention: cdk.Duration.days({{backupRetentionPeriod}}) },
+      removalPolicy: cdk.RemovalPolicy.SNAPSHOT,
+    });
+{{else}}
+    new rds.DatabaseCluster(this, '{{pascalCase name}}', {
+      engine: rds.DatabaseClusterEngine.{{camelCase engine}}({
+        version: rds.Aurora{{pascalCase (substring engine 7)}}EngineVersion.VER_3_04_0,
+      }),
+      vpc: vpc!,
+      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+      writer: rds.ClusterInstance.provisioned('writer', {
+        instanceType: ec2.InstanceType.of(ec2.InstanceClass.R5, ec2.InstanceSize.LARGE),
+      }),
+      readers: [
+{{#times (dec instances) }}
+        rds.ClusterInstance.provisioned('reader{{index}}', {
+          instanceType: ec2.InstanceType.of(ec2.InstanceClass.R5, ec2.InstanceSize.LARGE),
+        }),
+{{/times}}
+      ],
+      deletionProtection: {{deletionProtection}},
+      backup: { retention: cdk.Duration.days({{backupRetentionPeriod}}) },
+      removalPolicy: cdk.RemovalPolicy.SNAPSHOT,
+    });
+{{/if}}
+
+{{/each}}
+{{#each dynamoDBTables}}
+    // DynamoDB Table: {{name}}
+    new dynamodb.Table(this, '{{pascalCase name}}', {
+      tableName: '{{name}}',
+      partitionKey: { name: '{{partitionKey.name}}', type: dynamodb.AttributeType.{{partitionKey.type}} },
+{{#if sortKey}}
+      sortKey: { name: '{{sortKey.name}}', type: dynamodb.AttributeType.{{sortKey.type}} },
+{{/if}}
+{{#ifEquals billingMode "PAY_PER_REQUEST"}}
+      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
+{{else}}
+      billingMode: dynamodb.BillingMode.PROVISIONED,
+      readCapacity: {{readCapacity}},
+      writeCapacity: {{writeCapacity}},
+{{/ifEquals}}
+      pointInTimeRecovery: {{pointInTimeRecovery}},
+      removalPolicy: cdk.RemovalPolicy.RETAIN,
+    });
+
+{{/each}}
+  }
+}
+`;
+const STORAGE_STACK_TEMPLATE = `import * as cdk from 'aws-cdk-lib';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as ecr from 'aws-cdk-lib/aws-ecr';
+import { Construct } from 'constructs';
+
+export interface StorageStackProps extends cdk.StackProps {}
+
+export class StorageStack extends cdk.Stack {
+  public readonly ecrRepositories: Map<string, ecr.IRepository> = new Map();
+
+  constructor(scope: Construct, id: string, props?: StorageStackProps) {
+    super(scope, id, props);
+
+{{#each s3Buckets}}
+    // S3 Bucket: {{name}}
+    new s3.Bucket(this, '{{pascalCase name}}', {
+      bucketName: '{{name}}',
+      versioned: {{versioning}},
+      encryption: s3.BucketEncryption.{{#ifEquals encryption.type "AES256"}}S3_MANAGED{{else}}KMS_MANAGED{{/ifEquals}},
+{{#if publicAccessBlock}}
+      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
+{{/if}}
+{{#if websiteConfiguration}}
+      websiteIndexDocument: '{{websiteConfiguration.indexDocument}}',
+      websiteErrorDocument: '{{websiteConfiguration.errorDocument}}',
+      publicReadAccess: true,
+{{/if}}
+{{#ifNotEmpty lifecycleRules}}
+      lifecycleRules: [
+{{#each lifecycleRules}}
+        {
+          id: '{{id}}',
+          enabled: {{enabled}},
+{{#if expiration}}
+          expiration: cdk.Duration.days({{expiration.days}}),
+{{/if}}
+        },
+{{/each}}
+      ],
+{{/ifNotEmpty}}
+      removalPolicy: cdk.RemovalPolicy.RETAIN,
+    });
+
+{{/each}}
+{{#each ecrRepositories}}
+    // ECR Repository: {{name}}
+    const {{camelCase name}}Repo = new ecr.Repository(this, '{{pascalCase name}}', {
+      repositoryName: '{{name}}',
+      imageScanOnPush: {{imageScanningEnabled}},
+      imageTagMutability: ecr.TagMutability.{{imageTagMutability}},
+      encryption: ecr.RepositoryEncryption.AES_256,
+{{#if lifecyclePolicy}}
+      lifecycleRules: [
+{{#each lifecyclePolicy.rules}}
+        {
+          rulePriority: {{rulePriority}},
+          description: '{{description}}',
+          maxImageCount: {{selection.countNumber}},
+        },
+{{/each}}
+      ],
+{{/if}}
+      removalPolicy: cdk.RemovalPolicy.RETAIN,
+    });
+    this.ecrRepositories.set('{{name}}', {{camelCase name}}Repo);
+
+{{/each}}
+  }
+}
+`;
+const COMPUTE_STACK_TEMPLATE = `import * as cdk from 'aws-cdk-lib';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as eks from 'aws-cdk-lib/aws-eks';
+import * as ecr from 'aws-cdk-lib/aws-ecr';
+import { Construct } from 'constructs';
+
+export interface ComputeStackProps extends cdk.StackProps {
+  vpc?: ec2.IVpc;
+  ecrRepositories?: Map<string, ecr.IRepository>;
+}
+
+export class ComputeStack extends cdk.Stack {
+  constructor(scope: Construct, id: string, props?: ComputeStackProps) {
+    super(scope, id, props);
+
+    const vpc = props?.vpc;
+
+{{#each ec2Instances}}
+    // EC2 Instance: {{name}}
+    new ec2.Instance(this, '{{pascalCase name}}', {
+      instanceName: '{{name}}',
+      vpc: vpc!,
+      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+      instanceType: new ec2.InstanceType('{{instanceType}}'),
+      machineImage: ec2.MachineImage.latestAmazonLinux2023(),
+    });
+
+{{/each}}
+{{#each lambdaFunctions}}
+    // Lambda Function: {{name}}
+    new lambda.Function(this, '{{pascalCase name}}', {
+      functionName: '{{name}}',
+      runtime: lambda.Runtime.{{uppercase (replace runtime "." "_")}},
+      handler: '{{handler}}',
+      code: lambda.Code.fromAsset('lambda/{{kebabCase name}}'),
+      memorySize: {{memorySize}},
+      timeout: cdk.Duration.seconds({{timeout}}),
+{{#if vpcConfig}}
+      vpc: vpc,
+      vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+{{/if}}
+    });
+
+{{/each}}
+{{#each ecsClusters}}
+    // ECS Cluster: {{name}}
+    const {{camelCase name}}Cluster = new ecs.Cluster(this, '{{pascalCase name}}Cluster', {
+      clusterName: '{{name}}',
+      vpc: vpc!,
+      containerInsights: {{containerInsights}},
+      enableFargateCapacityProviders: true,
+    });
+
+{{/each}}
+{{#each ecsServices}}
+    // ECS Service: {{name}}
+    const {{camelCase name}}TaskDef = new ecs.FargateTaskDefinition(this, '{{pascalCase name}}TaskDef', {
+      memoryLimitMiB: 512,
+      cpu: 256,
+    });
+
+    {{camelCase name}}TaskDef.addContainer('{{name}}-container', {
+      image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'),
+      portMappings: [{ containerPort: 80 }],
+    });
+
+    new ecs.FargateService(this, '{{pascalCase name}}Service', {
+      serviceName: '{{name}}',
+      cluster: {{camelCase clusterId}}Cluster,
+      taskDefinition: {{camelCase name}}TaskDef,
+      desiredCount: {{desiredCount}},
+    });
+
+{{/each}}
+{{#each eksClusters}}
+    // EKS Cluster: {{name}}
+    const {{camelCase name}}Cluster = new eks.Cluster(this, '{{pascalCase name}}', {
+      clusterName: '{{name}}',
+      vpc: vpc!,
+      version: eks.KubernetesVersion.V1_29,
+      defaultCapacity: 0,
+      endpointAccess: eks.EndpointAccess.PUBLIC_AND_PRIVATE,
+    });
+
+{{#each nodeGroups}}
+    {{camelCase ../name}}Cluster.addNodegroupCapacity('{{pascalCase name}}', {
+      nodegroupName: '{{name}}',
+      instanceTypes: [{{#each instanceTypes}}new ec2.InstanceType('{{this}}'){{#unless @last}}, {{/unless}}{{/each}}],
+      minSize: {{scalingConfig.minSize}},
+      maxSize: {{scalingConfig.maxSize}},
+      desiredSize: {{scalingConfig.desiredSize}},
+      diskSize: {{diskSize}},
+    });
+{{/each}}
+{{/each}}
+  }
+}
+`;
+const PACKAGE_JSON_TEMPLATE = `{
+  "name": "{{kebabCase projectName}}-cdk",
+  "version": "0.1.0",
+  "bin": {
+    "{{kebabCase projectName}}-cdk": "bin/app.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "cdk": "cdk",
+    "synth": "cdk synth",
+    "diff": "cdk diff",
+    "deploy": "cdk deploy --all",
+    "destroy": "cdk destroy --all"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "aws-cdk": "^2.120.0",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {
+    "aws-cdk-lib": "^2.120.0",
+    "constructs": "^10.3.0",
+    "source-map-support": "^0.5.21"
+  }
+}
+`;
+const CDK_JSON_TEMPLATE = `{
+  "app": "npx ts-node --prefer-ts-exts bin/app.ts",
+  "watch": {
+    "include": ["**"],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "**/*.d.ts",
+      "**/*.js",
+      "tsconfig.json",
+      "package*.json",
+      "node_modules"
+    ]
+  },
+  "context": {
+    "@aws-cdk/aws-lambda:recognizeVersionProps": true,
+    "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true,
+    "@aws-cdk/core:checkSecretUsage": true,
+    "@aws-cdk/core:target-partitions": ["aws", "aws-cn"]
+  }
+}
+`;
+const TSCONFIG_TEMPLATE = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "experimentalDecorators": true,
+    "strictPropertyInitialization": false,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "."
+  },
+  "exclude": ["node_modules", "cdk.out"]
+}
+`;
+// Register additional helpers for CDK templates
+Handlebars.registerHelper('substring', (str, start, end) => {
+    return str?.substring(start, end) ?? '';
+});
+Handlebars.registerHelper('replace', (str, search, replace) => {
+    return str?.replace(new RegExp(search, 'g'), replace) ?? '';
+});
+Handlebars.registerHelper('dec', (num) => {
+    return num - 1;
+});
+export class CDKGenerator {
+    config;
+    outputDir;
+    constructor(config, outputDir) {
+        this.config = config;
+        this.outputDir = outputDir;
+    }
+    async generate() {
+        const files = [];
+        const stacks = [];
+        try {
+            // Create directory structure
+            this.createDirectories();
+            // Determine which stacks to generate
+            const stackFlags = {
+                network: this.hasNetworkResources(),
+                database: this.hasDatabaseResources(),
+                storage: this.hasStorageResources(),
+                compute: this.hasComputeResources(),
+            };
+            // Create template context
+            const context = {
+                projectName: this.config.projectName,
+                region: this.config.region,
+                account: this.config.account,
+                environment: this.config.environment || 'default',
+                stacks: stackFlags,
+                config: this.config,
+            };
+            // Generate CDK app
+            const appContent = templateEngine.renderString(CDK_APP_TEMPLATE, context);
+            const appPath = path.join(this.outputDir, 'bin', 'app.ts');
+            fs.writeFileSync(appPath, appContent);
+            files.push(appPath);
+            // Generate stack files
+            const now = new Date().toISOString();
+            if (stackFlags.network) {
+                const networkContext = {
+                    ...context,
+                    vpcs: (this.config.network.vpcs || []).map((vpc, i) => ({
+                        ...vpc,
+                        isFirst: i === 0,
+                    })),
+                    apiGateways: this.config.network.apiGateways || [],
+                };
+                const networkContent = templateEngine.renderString(NETWORK_STACK_TEMPLATE, networkContext);
+                const networkPath = path.join(this.outputDir, 'lib', 'stacks', 'network-stack.ts');
+                fs.writeFileSync(networkPath, networkContent);
+                files.push(networkPath);
+                stacks.push({
+                    name: 'NetworkStack',
+                    path: networkPath,
+                    type: 'network',
+                    generatedAt: now,
+                    contentHash: this.hashContent(networkContent),
+                });
+            }
+            if (stackFlags.database) {
+                const dbContext = {
+                    ...context,
+                    rdsInstances: this.config.database.rdsInstances || [],
+                    auroraClusters: this.config.database.auroraClusters || [],
+                    dynamoDBTables: this.config.database.dynamoDBTables || [],
+                };
+                const dbContent = templateEngine.renderString(DATABASE_STACK_TEMPLATE, dbContext);
+                const dbPath = path.join(this.outputDir, 'lib', 'stacks', 'database-stack.ts');
+                fs.writeFileSync(dbPath, dbContent);
+                files.push(dbPath);
+                stacks.push({
+                    name: 'DatabaseStack',
+                    path: dbPath,
+                    type: 'database',
+                    generatedAt: now,
+                    contentHash: this.hashContent(dbContent),
+                });
+            }
+            if (stackFlags.storage) {
+                const storageContext = {
+                    ...context,
+                    s3Buckets: this.config.storage.s3Buckets || [],
+                    ecrRepositories: this.config.storage.ecrRepositories || [],
+                };
+                const storageContent = templateEngine.renderString(STORAGE_STACK_TEMPLATE, storageContext);
+                const storagePath = path.join(this.outputDir, 'lib', 'stacks', 'storage-stack.ts');
+                fs.writeFileSync(storagePath, storageContent);
+                files.push(storagePath);
+                stacks.push({
+                    name: 'StorageStack',
+                    path: storagePath,
+                    type: 'storage',
+                    generatedAt: now,
+                    contentHash: this.hashContent(storageContent),
+                });
+            }
+            if (stackFlags.compute) {
+                const computeContext = {
+                    ...context,
+                    ec2Instances: this.config.compute.ec2Instances || [],
+                    lambdaFunctions: this.config.compute.lambdaFunctions || [],
+                    ecsClusters: this.config.compute.ecsClusters || [],
+                    ecsServices: this.config.compute.ecsServices || [],
+                    eksClusters: this.config.compute.eksClusters || [],
+                };
+                const computeContent = templateEngine.renderString(COMPUTE_STACK_TEMPLATE, computeContext);
+                const computePath = path.join(this.outputDir, 'lib', 'stacks', 'compute-stack.ts');
+                fs.writeFileSync(computePath, computeContent);
+                files.push(computePath);
+                stacks.push({
+                    name: 'ComputeStack',
+                    path: computePath,
+                    type: 'compute',
+                    generatedAt: now,
+                    contentHash: this.hashContent(computeContent),
+                });
+            }
+            // Generate config files
+            const packageJsonContent = templateEngine.renderString(PACKAGE_JSON_TEMPLATE, context);
+            const packageJsonPath = path.join(this.outputDir, 'package.json');
+            fs.writeFileSync(packageJsonPath, packageJsonContent);
+            files.push(packageJsonPath);
+            const cdkJsonContent = templateEngine.renderString(CDK_JSON_TEMPLATE, context);
+            const cdkJsonPath = path.join(this.outputDir, 'cdk.json');
+            fs.writeFileSync(cdkJsonPath, cdkJsonContent);
+            files.push(cdkJsonPath);
+            const tsconfigContent = templateEngine.renderString(TSCONFIG_TEMPLATE, context);
+            const tsconfigPath = path.join(this.outputDir, 'tsconfig.json');
+            fs.writeFileSync(tsconfigPath, tsconfigContent);
+            files.push(tsconfigPath);
+            // Create README
+            const readmeContent = this.generateReadme(context, stackFlags);
+            const readmePath = path.join(this.outputDir, 'README.md');
+            fs.writeFileSync(readmePath, readmeContent);
+            files.push(readmePath);
+            return {
+                success: true,
+                outputDir: this.outputDir,
+                stacks,
+                files,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                outputDir: this.outputDir,
+                stacks: [],
+                files: [],
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    createDirectories() {
+        const dirs = [
+            this.outputDir,
+            path.join(this.outputDir, 'bin'),
+            path.join(this.outputDir, 'lib'),
+            path.join(this.outputDir, 'lib', 'stacks'),
+        ];
+        for (const dir of dirs) {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    hasNetworkResources() {
+        return ((this.config.network.vpcs?.length ?? 0) > 0 ||
+            (this.config.network.apiGateways?.length ?? 0) > 0);
+    }
+    hasDatabaseResources() {
+        return ((this.config.database.rdsInstances?.length ?? 0) > 0 ||
+            (this.config.database.auroraClusters?.length ?? 0) > 0 ||
+            (this.config.database.dynamoDBTables?.length ?? 0) > 0);
+    }
+    hasStorageResources() {
+        return ((this.config.storage.s3Buckets?.length ?? 0) > 0 ||
+            (this.config.storage.ecrRepositories?.length ?? 0) > 0);
+    }
+    hasComputeResources() {
+        return ((this.config.compute.ec2Instances?.length ?? 0) > 0 ||
+            (this.config.compute.lambdaFunctions?.length ?? 0) > 0 ||
+            (this.config.compute.ecsClusters?.length ?? 0) > 0 ||
+            (this.config.compute.ecsServices?.length ?? 0) > 0 ||
+            (this.config.compute.eksClusters?.length ?? 0) > 0);
+    }
+    hashContent(content) {
+        const crypto = require('crypto');
+        return crypto.createHash('md5').update(content).digest('hex');
+    }
+    generateReadme(context, stacks) {
+        const activeStacks = Object.entries(stacks)
+            .filter(([, active]) => active)
+            .map(([name]) => name);
+        return `# ${context.projectName} CDK Infrastructure
+
+AWS CDK 인프라 프로젝트입니다. AWS Infra MCP로 자동 생성되었습니다.
+
+## 구조
+
+\`\`\`
+${context.projectName}-cdk/
+├── bin/
+│   └── app.ts          # CDK 앱 진입점
+├── lib/
+│   └── stacks/
+${activeStacks.map(s => `│       └── ${s}-stack.ts`).join('\n')}
+├── cdk.json
+├── package.json
+└── tsconfig.json
+\`\`\`
+
+## 생성된 스택
+
+${activeStacks.map(s => `- **${s.charAt(0).toUpperCase() + s.slice(1)}Stack**: ${this.getStackDescription(s)}`).join('\n')}
+
+## 배포 방법
+
+\`\`\`bash
+# 의존성 설치
+npm install
+
+# CDK 부트스트랩 (최초 1회)
+npx cdk bootstrap
+
+# 변경사항 확인
+npx cdk diff
+
+# 모든 스택 배포
+npx cdk deploy --all
+
+# 특정 스택만 배포
+npx cdk deploy ${context.projectName}NetworkStack
+\`\`\`
+
+## 삭제
+
+\`\`\`bash
+npx cdk destroy --all
+\`\`\`
+
+## 환경 변수
+
+- \`CDK_DEFAULT_ACCOUNT\`: AWS 계정 ID (기본값: ${context.account || 'unknown'})
+- \`CDK_DEFAULT_REGION\`: AWS 리전 (기본값: ${context.region})
+
+---
+🤖 Generated with [AWS Infra MCP](https://github.com/frontpoint/aws-infra-mcp)
+`;
+    }
+    getStackDescription(stackType) {
+        const descriptions = {
+            network: 'VPC, 서브넷, NAT Gateway, API Gateway',
+            database: 'RDS, Aurora, DynamoDB',
+            storage: 'S3, ECR',
+            compute: 'EC2, Lambda, ECS, EKS',
+        };
+        return descriptions[stackType] || stackType;
+    }
+}
+//# sourceMappingURL=cdk-generator.js.map