cdk-cost-analyzer 0.1.41 → 0.1.43

package/dist/optimization/analyzers/NATGatewayOptimizationAnalyzer.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATGatewayOptimizationAnalyzer = void 0;
+const NAT_GATEWAY_HOURLY = 0.045;
+const NAT_INSTANCE_T3_NANO_HOURLY = 0.0052;
+const HOURS_PER_MONTH = 730;
+class NATGatewayOptimizationAnalyzer {
+    category = 'nat-gateway-optimization';
+    name = 'NAT Gateway Optimization';
+    isApplicable(resources) {
+        return resources.some((r) => r.type === 'AWS::EC2::NatGateway');
+    }
+    async analyze(resources, resourceCosts, _region) {
+        const recommendations = [];
+        const natGateways = resources.filter((r) => r.type === 'AWS::EC2::NatGateway');
+        for (const natGw of natGateways) {
+            recommendations.push(this.suggestNATInstanceForDev(natGw, resourceCosts));
+        }
+        const vpcEndpointRec = this.suggestVPCEndpoints(resources, natGateways);
+        if (vpcEndpointRec) {
+            recommendations.push(vpcEndpointRec);
+        }
+        if (natGateways.length > 1) {
+            const consolidationRec = this.suggestConsolidation(natGateways, resourceCosts);
+            if (consolidationRec) {
+                recommendations.push(consolidationRec);
+            }
+        }
+        return recommendations;
+    }
+    suggestNATInstanceForDev(natGw, resourceCosts) {
+        const natCost = this.findCost(natGw.logicalId, resourceCosts);
+        const natInstanceCost = NAT_INSTANCE_T3_NANO_HOURLY * HOURS_PER_MONTH;
+        const savings = natCost > 0
+            ? natCost - natInstanceCost
+            : (NAT_GATEWAY_HOURLY * HOURS_PER_MONTH) - natInstanceCost;
+        const savingsPercent = natCost > 0
+            ? Math.round((savings / natCost) * 100)
+            : 88;
+        return {
+            id: `nat-instance-${natGw.logicalId}`,
+            title: `Replace ${natGw.logicalId} with NAT instance (dev/test)`,
+            description: `NAT Gateways cost ~$${(NAT_GATEWAY_HOURLY * HOURS_PER_MONTH).toFixed(2)}/month. A t3.nano NAT instance costs ~$${natInstanceCost.toFixed(2)}/month. For non-production environments, a NAT instance provides significant savings.`,
+            category: this.category,
+            priority: 'medium',
+            estimatedMonthlySavings: Math.round(savings * 100) / 100,
+            estimatedSavingsPercent: savingsPercent,
+            affectedResources: [natGw.logicalId],
+            actionItems: [
+                'Replace NAT Gateway with a t3.nano or t4g.nano EC2 instance configured as NAT',
+                'Enable source/destination check disable on the NAT instance',
+                'Update route tables to point to the NAT instance',
+                'Configure auto-recovery for the NAT instance',
+            ],
+            caveats: [
+                'Not recommended for production (single point of failure)',
+                'Lower throughput and no built-in redundancy',
+                'Requires manual patching and maintenance',
+                'Only suitable for dev/test/staging environments',
+            ],
+        };
+    }
+    suggestVPCEndpoints(resources, natGateways) {
+        const hasS3 = resources.some((r) => r.type === 'AWS::S3::Bucket');
+        const hasDynamoDB = resources.some((r) => r.type === 'AWS::DynamoDB::Table');
+        if (!hasS3 && !hasDynamoDB)
+            return null;
+        const existingGatewayEndpoints = resources.filter((r) => {
+            if (r.type !== 'AWS::EC2::VPCEndpoint')
+                return false;
+            const vpcEndpointType = r.properties.VpcEndpointType;
+            return !vpcEndpointType || vpcEndpointType === 'Gateway';
+        });
+        const existingServices = existingGatewayEndpoints.map((r) => r.properties.ServiceName);
+        const missingEndpoints = [];
+        if (hasS3 &&
+            !existingServices.some((s) => s?.includes('s3'))) {
+            missingEndpoints.push('com.amazonaws.REGION.s3');
+        }
+        if (hasDynamoDB &&
+            !existingServices.some((s) => s?.includes('dynamodb'))) {
+            missingEndpoints.push('com.amazonaws.REGION.dynamodb');
+        }
+        if (missingEndpoints.length === 0)
+            return null;
+        const natIds = natGateways.map((n) => n.logicalId);
+        const services = missingEndpoints
+            .map((s) => s.split('.').pop())
+            .join(', ');
+        return {
+            id: 'vpc-gateway-endpoints',
+            title: `Add VPC Gateway Endpoints for ${services}`,
+            description: `S3 and DynamoDB Gateway Endpoints are free and route traffic directly to the service, bypassing NAT Gateway. This eliminates NAT Gateway data processing charges ($0.045/GB) for these services.`,
+            category: this.category,
+            priority: 'high',
+            estimatedMonthlySavings: 0,
+            estimatedSavingsPercent: 0,
+            affectedResources: natIds,
+            actionItems: missingEndpoints.map((ep) => `Add VPC Gateway Endpoint for ${ep}`),
+            caveats: [
+                'Savings depend on data transfer volume to S3/DynamoDB',
+                'Gateway Endpoints are free; savings come from reduced NAT Gateway data processing',
+                'Update route tables to include the Gateway Endpoint',
+            ],
+        };
+    }
+    suggestConsolidation(natGateways, resourceCosts) {
+        if (natGateways.length <= 1)
+            return null;
+        const totalCost = natGateways.reduce((sum, ng) => sum + this.findCost(ng.logicalId, resourceCosts), 0);
+        const perGatewayCost = totalCost > 0
+            ? totalCost / natGateways.length
+            : NAT_GATEWAY_HOURLY * HOURS_PER_MONTH;
+        const savings = perGatewayCost * (natGateways.length - 1);
+        return {
+            id: 'nat-consolidation',
+            title: `Consolidate ${natGateways.length} NAT Gateways (dev/test)`,
+            description: `${natGateways.length} NAT Gateways detected. For non-production environments, a single NAT Gateway may be sufficient, saving ~$${savings.toFixed(2)}/month.`,
+            category: this.category,
+            priority: savings >= 50 ? 'high' : 'medium',
+            estimatedMonthlySavings: Math.round(savings * 100) / 100,
+            estimatedSavingsPercent: Math.round(((natGateways.length - 1) / natGateways.length) * 100),
+            affectedResources: natGateways.map((n) => n.logicalId),
+            actionItems: [
+                'Evaluate if multi-AZ NAT Gateway redundancy is needed for this environment',
+                'Route all private subnets through a single NAT Gateway',
+                `Remove ${natGateways.length - 1} redundant NAT Gateways`,
+            ],
+            caveats: [
+                'Not recommended for production (single AZ failure risk)',
+                'Cross-AZ data transfer charges may apply (~$0.01/GB)',
+                'Only suitable for non-production environments',
+            ],
+        };
+    }
+    findCost(logicalId, resourceCosts) {
+        const cost = resourceCosts.find((c) => c.logicalId === logicalId);
+        return cost?.monthlyCost.amount ?? 0;
+    }
+}
+exports.NATGatewayOptimizationAnalyzer = NATGatewayOptimizationAnalyzer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATGatewayOptimizationAnalyzer.js","sourceRoot":"","sources":["../../../src/optimization/analyzers/NATGatewayOptimizationAnalyzer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCost } from '../../pricing/types';\nimport {\n  OptimizationAnalyzer,\n  OptimizationCategory,\n  Recommendation,\n} from '../types';\n\nconst NAT_GATEWAY_HOURLY = 0.045;\nconst NAT_INSTANCE_T3_NANO_HOURLY = 0.0052;\nconst HOURS_PER_MONTH = 730;\n\nexport class NATGatewayOptimizationAnalyzer implements OptimizationAnalyzer {\n  readonly category: OptimizationCategory = 'nat-gateway-optimization';\n  readonly name = 'NAT Gateway Optimization';\n\n  isApplicable(resources: ResourceWithId[]): boolean {\n    return resources.some((r) => r.type === 'AWS::EC2::NatGateway');\n  }\n\n  async analyze(\n    resources: ResourceWithId[],\n    resourceCosts: ResourceCost[],\n    _region: string,\n  ): Promise<Recommendation[]> {\n    const recommendations: Recommendation[] = [];\n    const natGateways = resources.filter(\n      (r) => r.type === 'AWS::EC2::NatGateway',\n    );\n\n    for (const natGw of natGateways) {\n      recommendations.push(\n        this.suggestNATInstanceForDev(natGw, resourceCosts),\n      );\n    }\n\n    const vpcEndpointRec = this.suggestVPCEndpoints(resources, natGateways);\n    if (vpcEndpointRec) {\n      recommendations.push(vpcEndpointRec);\n    }\n\n    if (natGateways.length > 1) {\n      const consolidationRec = this.suggestConsolidation(\n        natGateways,\n        resourceCosts,\n      );\n      if (consolidationRec) {\n        recommendations.push(consolidationRec);\n      }\n    }\n\n    return recommendations;\n  }\n\n  private suggestNATInstanceForDev(\n    natGw: ResourceWithId,\n    resourceCosts: ResourceCost[],\n  ): Recommendation {\n    const natCost = this.findCost(natGw.logicalId, resourceCosts);\n    const natInstanceCost = NAT_INSTANCE_T3_NANO_HOURLY * HOURS_PER_MONTH;\n    const savings = natCost > 0\n      ? natCost - natInstanceCost\n      : (NAT_GATEWAY_HOURLY * HOURS_PER_MONTH) - natInstanceCost;\n    const savingsPercent = natCost > 0\n      ? Math.round((savings / natCost) * 100)\n      : 88;\n\n    return {\n      id: `nat-instance-${natGw.logicalId}`,\n      title: `Replace ${natGw.logicalId} with NAT instance (dev/test)`,\n      description: `NAT Gateways cost ~$${(NAT_GATEWAY_HOURLY * HOURS_PER_MONTH).toFixed(2)}/month. A t3.nano NAT instance costs ~$${natInstanceCost.toFixed(2)}/month. For non-production environments, a NAT instance provides significant savings.`,\n      category: this.category,\n      priority: 'medium',\n      estimatedMonthlySavings: Math.round(savings * 100) / 100,\n      estimatedSavingsPercent: savingsPercent,\n      affectedResources: [natGw.logicalId],\n      actionItems: [\n        'Replace NAT Gateway with a t3.nano or t4g.nano EC2 instance configured as NAT',\n        'Enable source/destination check disable on the NAT instance',\n        'Update route tables to point to the NAT instance',\n        'Configure auto-recovery for the NAT instance',\n      ],\n      caveats: [\n        'Not recommended for production (single point of failure)',\n        'Lower throughput and no built-in redundancy',\n        'Requires manual patching and maintenance',\n        'Only suitable for dev/test/staging environments',\n      ],\n    };\n  }\n\n  private suggestVPCEndpoints(\n    resources: ResourceWithId[],\n    natGateways: ResourceWithId[],\n  ): Recommendation | null {\n    const hasS3 = resources.some((r) => r.type === 'AWS::S3::Bucket');\n    const hasDynamoDB = resources.some(\n      (r) => r.type === 'AWS::DynamoDB::Table',\n    );\n\n    if (!hasS3 && !hasDynamoDB) return null;\n\n    const existingGatewayEndpoints = resources.filter((r) => {\n      if (r.type !== 'AWS::EC2::VPCEndpoint') return false;\n      const vpcEndpointType = r.properties.VpcEndpointType as string;\n      return !vpcEndpointType || vpcEndpointType === 'Gateway';\n    });\n\n    const existingServices = existingGatewayEndpoints.map(\n      (r) => r.properties.ServiceName as string,\n    );\n    const missingEndpoints: string[] = [];\n\n    if (\n      hasS3 &&\n      !existingServices.some((s) => s?.includes('s3'))\n    ) {\n      missingEndpoints.push('com.amazonaws.REGION.s3');\n    }\n    if (\n      hasDynamoDB &&\n      !existingServices.some((s) => s?.includes('dynamodb'))\n    ) {\n      missingEndpoints.push('com.amazonaws.REGION.dynamodb');\n    }\n\n    if (missingEndpoints.length === 0) return null;\n\n    const natIds = natGateways.map((n) => n.logicalId);\n    const services = missingEndpoints\n      .map((s) => s.split('.').pop())\n      .join(', ');\n\n    return {\n      id: 'vpc-gateway-endpoints',\n      title: `Add VPC Gateway Endpoints for ${services}`,\n      description: `S3 and DynamoDB Gateway Endpoints are free and route traffic directly to the service, bypassing NAT Gateway. This eliminates NAT Gateway data processing charges ($0.045/GB) for these services.`,\n      category: this.category,\n      priority: 'high',\n      estimatedMonthlySavings: 0,\n      estimatedSavingsPercent: 0,\n      affectedResources: natIds,\n      actionItems: missingEndpoints.map(\n        (ep) => `Add VPC Gateway Endpoint for ${ep}`,\n      ),\n      caveats: [\n        'Savings depend on data transfer volume to S3/DynamoDB',\n        'Gateway Endpoints are free; savings come from reduced NAT Gateway data processing',\n        'Update route tables to include the Gateway Endpoint',\n      ],\n    };\n  }\n\n  private suggestConsolidation(\n    natGateways: ResourceWithId[],\n    resourceCosts: ResourceCost[],\n  ): Recommendation | null {\n    if (natGateways.length <= 1) return null;\n\n    const totalCost = natGateways.reduce(\n      (sum, ng) => sum + this.findCost(ng.logicalId, resourceCosts),\n      0,\n    );\n    const perGatewayCost =\n      totalCost > 0\n        ? totalCost / natGateways.length\n        : NAT_GATEWAY_HOURLY * HOURS_PER_MONTH;\n    const savings = perGatewayCost * (natGateways.length - 1);\n\n    return {\n      id: 'nat-consolidation',\n      title: `Consolidate ${natGateways.length} NAT Gateways (dev/test)`,\n      description: `${natGateways.length} NAT Gateways detected. For non-production environments, a single NAT Gateway may be sufficient, saving ~$${savings.toFixed(2)}/month.`,\n      category: this.category,\n      priority: savings >= 50 ? 'high' : 'medium',\n      estimatedMonthlySavings: Math.round(savings * 100) / 100,\n      estimatedSavingsPercent: Math.round(\n        ((natGateways.length - 1) / natGateways.length) * 100,\n      ),\n      affectedResources: natGateways.map((n) => n.logicalId),\n      actionItems: [\n        'Evaluate if multi-AZ NAT Gateway redundancy is needed for this environment',\n        'Route all private subnets through a single NAT Gateway',\n        `Remove ${natGateways.length - 1} redundant NAT Gateways`,\n      ],\n      caveats: [\n        'Not recommended for production (single AZ failure risk)',\n        'Cross-AZ data transfer charges may apply (~$0.01/GB)',\n        'Only suitable for non-production environments',\n      ],\n    };\n  }\n\n  private findCost(logicalId: string, resourceCosts: ResourceCost[]): number {\n    const cost = resourceCosts.find((c) => c.logicalId === logicalId);\n    return cost?.monthlyCost.amount ?? 0;\n  }\n}\n"]}

package/dist/optimization/analyzers/ReservedInstanceAnalyzer.d.ts

@@ -0,0 +1,13 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCost } from '../../pricing/types';
+import { OptimizationAnalyzer, OptimizationCategory, Recommendation } from '../types';
+export declare class ReservedInstanceAnalyzer implements OptimizationAnalyzer {
+    readonly category: OptimizationCategory;
+    readonly name = "Reserved Instance";
+    isApplicable(resources: ResourceWithId[]): boolean;
+    analyze(resources: ResourceWithId[], resourceCosts: ResourceCost[], _region: string): Promise<Recommendation[]>;
+    private createRecommendation;
+    private getServiceLabel;
+    private getInstanceInfo;
+    private findCost;
+}

package/dist/optimization/analyzers/ReservedInstanceAnalyzer.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReservedInstanceAnalyzer = void 0;
+/**
+ * Approximate RI discount percentages by term and payment option.
+ * These vary by instance type and region but provide reasonable estimates.
+ */
+const RI_DISCOUNTS = {
+    '1yr-no-upfront': 30,
+    '1yr-partial-upfront': 35,
+    '1yr-all-upfront': 40,
+    '3yr-no-upfront': 45,
+    '3yr-partial-upfront': 50,
+    '3yr-all-upfront': 60,
+};
+const DEFAULT_DISCOUNT_KEY = '1yr-no-upfront';
+const RI_ELIGIBLE_TYPES = [
+    'AWS::EC2::Instance',
+    'AWS::RDS::DBInstance',
+    'AWS::RDS::DBCluster',
+    'AWS::ElastiCache::CacheCluster',
+    'AWS::ElastiCache::ReplicationGroup',
+    'AWS::Redshift::Cluster',
+    'AWS::OpenSearchService::Domain',
+    'AWS::Elasticsearch::Domain',
+];
+const MINIMUM_MONTHLY_COST = 50;
+class ReservedInstanceAnalyzer {
+    category = 'reserved-instance';
+    name = 'Reserved Instance';
+    isApplicable(resources) {
+        return resources.some((r) => RI_ELIGIBLE_TYPES.includes(r.type));
+    }
+    async analyze(resources, resourceCosts, _region) {
+        const recommendations = [];
+        for (const resource of resources) {
+            if (!RI_ELIGIBLE_TYPES.includes(resource.type))
+                continue;
+            const cost = this.findCost(resource.logicalId, resourceCosts);
+            if (cost < MINIMUM_MONTHLY_COST)
+                continue;
+            recommendations.push(this.createRecommendation(resource, cost));
+        }
+        return recommendations;
+    }
+    createRecommendation(resource, currentCost) {
+        const discountPercent = RI_DISCOUNTS[DEFAULT_DISCOUNT_KEY];
+        const savings = currentCost * (discountPercent / 100);
+        const newCost = currentCost - savings;
+        const serviceLabel = this.getServiceLabel(resource.type);
+        const instanceInfo = this.getInstanceInfo(resource);
+        return {
+            id: `ri-${resource.logicalId}`,
+            title: `Purchase Reserved Instance for ${resource.logicalId}`,
+            description: `${serviceLabel} ${resource.logicalId}${instanceInfo} costs $${currentCost.toFixed(2)}/month on-demand. A 1-year No Upfront RI would reduce this to ~$${newCost.toFixed(2)}/month, saving ${discountPercent}%.`,
+            category: this.category,
+            priority: savings >= 100 ? 'high' : savings >= 50 ? 'medium' : 'low',
+            estimatedMonthlySavings: Math.round(savings * 100) / 100,
+            estimatedSavingsPercent: discountPercent,
+            affectedResources: [resource.logicalId],
+            actionItems: [
+                `Purchase a 1-year No Upfront Reserved Instance for ${serviceLabel}`,
+                'Evaluate if 3-year term or partial/all upfront payment yields better savings',
+                'Consider Convertible RIs for flexibility to change instance types',
+            ],
+            caveats: [
+                '1-year commitment; early termination may result in charges',
+                'Savings percentages are approximate and vary by region and instance type',
+                'Ensure workload will run for the full term to realize savings',
+                `Based on ${DEFAULT_DISCOUNT_KEY.replace(/-/g, ' ')} pricing`,
+            ],
+        };
+    }
+    getServiceLabel(resourceType) {
+        if (resourceType.startsWith('AWS::EC2::'))
+            return 'EC2 instance';
+        if (resourceType.startsWith('AWS::RDS::'))
+            return 'RDS instance';
+        if (resourceType.startsWith('AWS::ElastiCache::'))
+            return 'ElastiCache node';
+        if (resourceType.startsWith('AWS::Redshift::'))
+            return 'Redshift cluster';
+        if (resourceType.includes('OpenSearch') || resourceType.includes('Elasticsearch')) {
+            return 'OpenSearch domain';
+        }
+        return 'Resource';
+    }
+    getInstanceInfo(resource) {
+        const props = resource.properties;
+        const instanceType = props.InstanceType ||
+            props.DBInstanceClass ||
+            props.CacheNodeType ||
+            props.NodeType;
+        return instanceType ? ` (${instanceType})` : '';
+    }
+    findCost(logicalId, resourceCosts) {
+        const cost = resourceCosts.find((c) => c.logicalId === logicalId);
+        return cost?.monthlyCost.amount ?? 0;
+    }
+}
+exports.ReservedInstanceAnalyzer = ReservedInstanceAnalyzer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ReservedInstanceAnalyzer.js","sourceRoot":"","sources":["../../../src/optimization/analyzers/ReservedInstanceAnalyzer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCost } from '../../pricing/types';\nimport {\n  OptimizationAnalyzer,\n  OptimizationCategory,\n  Recommendation,\n} from '../types';\n\n/**\n * Approximate RI discount percentages by term and payment option.\n * These vary by instance type and region but provide reasonable estimates.\n */\nconst RI_DISCOUNTS: Record<string, number> = {\n  '1yr-no-upfront': 30,\n  '1yr-partial-upfront': 35,\n  '1yr-all-upfront': 40,\n  '3yr-no-upfront': 45,\n  '3yr-partial-upfront': 50,\n  '3yr-all-upfront': 60,\n};\n\nconst DEFAULT_DISCOUNT_KEY = '1yr-no-upfront';\n\nconst RI_ELIGIBLE_TYPES = [\n  'AWS::EC2::Instance',\n  'AWS::RDS::DBInstance',\n  'AWS::RDS::DBCluster',\n  'AWS::ElastiCache::CacheCluster',\n  'AWS::ElastiCache::ReplicationGroup',\n  'AWS::Redshift::Cluster',\n  'AWS::OpenSearchService::Domain',\n  'AWS::Elasticsearch::Domain',\n];\n\nconst MINIMUM_MONTHLY_COST = 50;\n\nexport class ReservedInstanceAnalyzer implements OptimizationAnalyzer {\n  readonly category: OptimizationCategory = 'reserved-instance';\n  readonly name = 'Reserved Instance';\n\n  isApplicable(resources: ResourceWithId[]): boolean {\n    return resources.some((r) => RI_ELIGIBLE_TYPES.includes(r.type));\n  }\n\n  async analyze(\n    resources: ResourceWithId[],\n    resourceCosts: ResourceCost[],\n    _region: string,\n  ): Promise<Recommendation[]> {\n    const recommendations: Recommendation[] = [];\n\n    for (const resource of resources) {\n      if (!RI_ELIGIBLE_TYPES.includes(resource.type)) continue;\n\n      const cost = this.findCost(resource.logicalId, resourceCosts);\n      if (cost < MINIMUM_MONTHLY_COST) continue;\n\n      recommendations.push(this.createRecommendation(resource, cost));\n    }\n\n    return recommendations;\n  }\n\n  private createRecommendation(\n    resource: ResourceWithId,\n    currentCost: number,\n  ): Recommendation {\n    const discountPercent = RI_DISCOUNTS[DEFAULT_DISCOUNT_KEY];\n    const savings = currentCost * (discountPercent / 100);\n    const newCost = currentCost - savings;\n    const serviceLabel = this.getServiceLabel(resource.type);\n    const instanceInfo = this.getInstanceInfo(resource);\n\n    return {\n      id: `ri-${resource.logicalId}`,\n      title: `Purchase Reserved Instance for ${resource.logicalId}`,\n      description: `${serviceLabel} ${resource.logicalId}${instanceInfo} costs $${currentCost.toFixed(2)}/month on-demand. A 1-year No Upfront RI would reduce this to ~$${newCost.toFixed(2)}/month, saving ${discountPercent}%.`,\n      category: this.category,\n      priority: savings >= 100 ? 'high' : savings >= 50 ? 'medium' : 'low',\n      estimatedMonthlySavings: Math.round(savings * 100) / 100,\n      estimatedSavingsPercent: discountPercent,\n      affectedResources: [resource.logicalId],\n      actionItems: [\n        `Purchase a 1-year No Upfront Reserved Instance for ${serviceLabel}`,\n        'Evaluate if 3-year term or partial/all upfront payment yields better savings',\n        'Consider Convertible RIs for flexibility to change instance types',\n      ],\n      caveats: [\n        '1-year commitment; early termination may result in charges',\n        'Savings percentages are approximate and vary by region and instance type',\n        'Ensure workload will run for the full term to realize savings',\n        `Based on ${DEFAULT_DISCOUNT_KEY.replace(/-/g, ' ')} pricing`,\n      ],\n    };\n  }\n\n  private getServiceLabel(resourceType: string): string {\n    if (resourceType.startsWith('AWS::EC2::')) return 'EC2 instance';\n    if (resourceType.startsWith('AWS::RDS::')) return 'RDS instance';\n    if (resourceType.startsWith('AWS::ElastiCache::')) return 'ElastiCache node';\n    if (resourceType.startsWith('AWS::Redshift::')) return 'Redshift cluster';\n    if (resourceType.includes('OpenSearch') || resourceType.includes('Elasticsearch')) {\n      return 'OpenSearch domain';\n    }\n    return 'Resource';\n  }\n\n  private getInstanceInfo(resource: ResourceWithId): string {\n    const props = resource.properties;\n    const instanceType =\n      (props.InstanceType as string) ||\n      (props.DBInstanceClass as string) ||\n      (props.CacheNodeType as string) ||\n      (props.NodeType as string);\n    return instanceType ? ` (${instanceType})` : '';\n  }\n\n  private findCost(logicalId: string, resourceCosts: ResourceCost[]): number {\n    const cost = resourceCosts.find((c) => c.logicalId === logicalId);\n    return cost?.monthlyCost.amount ?? 0;\n  }\n}\n"]}

package/dist/optimization/analyzers/RightSizingAnalyzer.d.ts

@@ -0,0 +1,13 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCost } from '../../pricing/types';
+import { OptimizationAnalyzer, OptimizationCategory, Recommendation } from '../types';
+export declare class RightSizingAnalyzer implements OptimizationAnalyzer {
+    readonly category: OptimizationCategory;
+    readonly name = "Right-Sizing";
+    isApplicable(resources: ResourceWithId[]): boolean;
+    analyze(resources: ResourceWithId[], resourceCosts: ResourceCost[], _region: string): Promise<Recommendation[]>;
+    private analyzeResource;
+    private getInstanceType;
+    private extractSize;
+    private findCost;
+}

package/dist/optimization/analyzers/RightSizingAnalyzer.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RightSizingAnalyzer = void 0;
+/**
+ * Instance sizes ordered from smallest to largest.
+ * Used to suggest one size down for right-sizing.
+ */
+const EC2_SIZES = [
+    'nano',
+    'micro',
+    'small',
+    'medium',
+    'large',
+    'xlarge',
+    '2xlarge',
+    '4xlarge',
+    '8xlarge',
+    '12xlarge',
+    '16xlarge',
+    '24xlarge',
+    '32xlarge',
+    '48xlarge',
+    'metal',
+];
+/**
+ * Instance sizes considered "large" enough to warrant right-sizing review.
+ * We only suggest downsizing for 2xlarge and above.
+ */
+const REVIEW_THRESHOLD_INDEX = EC2_SIZES.indexOf('2xlarge');
+class RightSizingAnalyzer {
+    category = 'right-sizing';
+    name = 'Right-Sizing';
+    isApplicable(resources) {
+        return resources.some((r) => r.type === 'AWS::EC2::Instance' ||
+            r.type === 'AWS::RDS::DBInstance' ||
+            r.type === 'AWS::ElastiCache::CacheCluster');
+    }
+    async analyze(resources, resourceCosts, _region) {
+        const recommendations = [];
+        for (const resource of resources) {
+            const rec = this.analyzeResource(resource, resourceCosts);
+            if (rec)
+                recommendations.push(rec);
+        }
+        return recommendations;
+    }
+    analyzeResource(resource, resourceCosts) {
+        const instanceType = this.getInstanceType(resource);
+        if (!instanceType)
+            return null;
+        const size = this.extractSize(instanceType);
+        const sizeIndex = EC2_SIZES.indexOf(size);
+        if (sizeIndex < REVIEW_THRESHOLD_INDEX)
+            return null;
+        const smallerSize = EC2_SIZES[sizeIndex - 1];
+        const family = instanceType.substring(0, instanceType.length - size.length);
+        const smallerType = `${family}${smallerSize}`;
+        const cost = this.findCost(resource.logicalId, resourceCosts);
+        // Downsizing by one step typically halves cost for compute instances
+        const savingsPercent = 50;
+        const savings = cost * (savingsPercent / 100);
+        return {
+            id: `rightsize-${resource.logicalId}`,
+            title: `Review sizing of ${resource.logicalId} (${instanceType})`,
+            description: `${resource.logicalId} uses ${instanceType}. Consider downsizing to ${smallerType} if utilization is consistently below 40%. This could save ~$${savings.toFixed(2)}/month.`,
+            category: this.category,
+            priority: savings >= 100 ? 'high' : savings >= 40 ? 'medium' : 'low',
+            estimatedMonthlySavings: Math.round(savings * 100) / 100,
+            estimatedSavingsPercent: savingsPercent,
+            affectedResources: [resource.logicalId],
+            actionItems: [
+                `Check CloudWatch metrics for CPU, memory, and network utilization`,
+                `If avg utilization < 40%, downsize from ${instanceType} to ${smallerType}`,
+                'Test in staging before applying to production',
+                'Monitor performance for at least 1 week after change',
+            ],
+            caveats: [
+                'Requires CloudWatch data to validate; this is a template-based estimate',
+                'Memory utilization requires CloudWatch Agent (not available by default)',
+                'Peak usage patterns may differ from average',
+                'Consider using AWS Compute Optimizer for data-driven recommendations',
+            ],
+        };
+    }
+    getInstanceType(resource) {
+        const props = resource.properties;
+        switch (resource.type) {
+            case 'AWS::EC2::Instance':
+                return props.InstanceType || null;
+            case 'AWS::RDS::DBInstance':
+                return props.DBInstanceClass || null;
+            case 'AWS::ElastiCache::CacheCluster':
+                return props.CacheNodeType || null;
+            default:
+                return null;
+        }
+    }
+    extractSize(instanceType) {
+        // "m5.2xlarge" -> "2xlarge", "db.r5.large" -> "large"
+        const parts = instanceType.split('.');
+        return parts[parts.length - 1] || '';
+    }
+    findCost(logicalId, resourceCosts) {
+        const cost = resourceCosts.find((c) => c.logicalId === logicalId);
+        return cost?.monthlyCost.amount ?? 0;
+    }
+}
+exports.RightSizingAnalyzer = RightSizingAnalyzer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RightSizingAnalyzer.js","sourceRoot":"","sources":["../../../src/optimization/analyzers/RightSizingAnalyzer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCost } from '../../pricing/types';\nimport {\n  OptimizationAnalyzer,\n  OptimizationCategory,\n  Recommendation,\n} from '../types';\n\n/**\n * Instance sizes ordered from smallest to largest.\n * Used to suggest one size down for right-sizing.\n */\nconst EC2_SIZES = [\n  'nano',\n  'micro',\n  'small',\n  'medium',\n  'large',\n  'xlarge',\n  '2xlarge',\n  '4xlarge',\n  '8xlarge',\n  '12xlarge',\n  '16xlarge',\n  '24xlarge',\n  '32xlarge',\n  '48xlarge',\n  'metal',\n];\n\n/**\n * Instance sizes considered \"large\" enough to warrant right-sizing review.\n * We only suggest downsizing for 2xlarge and above.\n */\nconst REVIEW_THRESHOLD_INDEX = EC2_SIZES.indexOf('2xlarge');\n\nexport class RightSizingAnalyzer implements OptimizationAnalyzer {\n  readonly category: OptimizationCategory = 'right-sizing';\n  readonly name = 'Right-Sizing';\n\n  isApplicable(resources: ResourceWithId[]): boolean {\n    return resources.some(\n      (r) =>\n        r.type === 'AWS::EC2::Instance' ||\n        r.type === 'AWS::RDS::DBInstance' ||\n        r.type === 'AWS::ElastiCache::CacheCluster',\n    );\n  }\n\n  async analyze(\n    resources: ResourceWithId[],\n    resourceCosts: ResourceCost[],\n    _region: string,\n  ): Promise<Recommendation[]> {\n    const recommendations: Recommendation[] = [];\n\n    for (const resource of resources) {\n      const rec = this.analyzeResource(resource, resourceCosts);\n      if (rec) recommendations.push(rec);\n    }\n\n    return recommendations;\n  }\n\n  private analyzeResource(\n    resource: ResourceWithId,\n    resourceCosts: ResourceCost[],\n  ): Recommendation | null {\n    const instanceType = this.getInstanceType(resource);\n    if (!instanceType) return null;\n\n    const size = this.extractSize(instanceType);\n    const sizeIndex = EC2_SIZES.indexOf(size);\n    if (sizeIndex < REVIEW_THRESHOLD_INDEX) return null;\n\n    const smallerSize = EC2_SIZES[sizeIndex - 1];\n    const family = instanceType.substring(\n      0,\n      instanceType.length - size.length,\n    );\n    const smallerType = `${family}${smallerSize}`;\n\n    const cost = this.findCost(resource.logicalId, resourceCosts);\n    // Downsizing by one step typically halves cost for compute instances\n    const savingsPercent = 50;\n    const savings = cost * (savingsPercent / 100);\n\n    return {\n      id: `rightsize-${resource.logicalId}`,\n      title: `Review sizing of ${resource.logicalId} (${instanceType})`,\n      description: `${resource.logicalId} uses ${instanceType}. Consider downsizing to ${smallerType} if utilization is consistently below 40%. This could save ~$${savings.toFixed(2)}/month.`,\n      category: this.category,\n      priority: savings >= 100 ? 'high' : savings >= 40 ? 'medium' : 'low',\n      estimatedMonthlySavings: Math.round(savings * 100) / 100,\n      estimatedSavingsPercent: savingsPercent,\n      affectedResources: [resource.logicalId],\n      actionItems: [\n        `Check CloudWatch metrics for CPU, memory, and network utilization`,\n        `If avg utilization < 40%, downsize from ${instanceType} to ${smallerType}`,\n        'Test in staging before applying to production',\n        'Monitor performance for at least 1 week after change',\n      ],\n      caveats: [\n        'Requires CloudWatch data to validate; this is a template-based estimate',\n        'Memory utilization requires CloudWatch Agent (not available by default)',\n        'Peak usage patterns may differ from average',\n        'Consider using AWS Compute Optimizer for data-driven recommendations',\n      ],\n    };\n  }\n\n  private getInstanceType(resource: ResourceWithId): string | null {\n    const props = resource.properties;\n    switch (resource.type) {\n      case 'AWS::EC2::Instance':\n        return (props.InstanceType as string) || null;\n      case 'AWS::RDS::DBInstance':\n        return (props.DBInstanceClass as string) || null;\n      case 'AWS::ElastiCache::CacheCluster':\n        return (props.CacheNodeType as string) || null;\n      default:\n        return null;\n    }\n  }\n\n  private extractSize(instanceType: string): string {\n    // \"m5.2xlarge\" -> \"2xlarge\", \"db.r5.large\" -> \"large\"\n    const parts = instanceType.split('.');\n    return parts[parts.length - 1] || '';\n  }\n\n  private findCost(logicalId: string, resourceCosts: ResourceCost[]): number {\n    const cost = resourceCosts.find((c) => c.logicalId === logicalId);\n    return cost?.monthlyCost.amount ?? 0;\n  }\n}\n"]}

package/dist/optimization/analyzers/SavingsPlansAnalyzer.d.ts

@@ -0,0 +1,11 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCost } from '../../pricing/types';
+import { OptimizationAnalyzer, OptimizationCategory, Recommendation } from '../types';
+export declare class SavingsPlansAnalyzer implements OptimizationAnalyzer {
+    readonly category: OptimizationCategory;
+    readonly name = "Savings Plans";
+    isApplicable(resources: ResourceWithId[]): boolean;
+    analyze(resources: ResourceWithId[], resourceCosts: ResourceCost[], _region: string): Promise<Recommendation[]>;
+    private hasMultipleComputeTypes;
+    private findCost;
+}

package/dist/optimization/analyzers/SavingsPlansAnalyzer.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SavingsPlansAnalyzer = void 0;
+const COMPUTE_SP_DISCOUNT = 30;
+const EC2_SP_DISCOUNT = 35;
+const COMPUTE_TYPES = [
+    'AWS::EC2::Instance',
+    'AWS::EC2::LaunchTemplate',
+    'AWS::AutoScaling::AutoScalingGroup',
+    'AWS::ECS::Service',
+    'AWS::ECS::TaskDefinition',
+    'AWS::Lambda::Function',
+];
+const EC2_ONLY_TYPES = [
+    'AWS::EC2::Instance',
+    'AWS::EC2::LaunchTemplate',
+    'AWS::AutoScaling::AutoScalingGroup',
+];
+const MINIMUM_AGGREGATE_COST = 100;
+class SavingsPlansAnalyzer {
+    category = 'savings-plan';
+    name = 'Savings Plans';
+    isApplicable(resources) {
+        return resources.some((r) => COMPUTE_TYPES.includes(r.type));
+    }
+    async analyze(resources, resourceCosts, _region) {
+        const computeResources = resources.filter((r) => COMPUTE_TYPES.includes(r.type));
+        if (computeResources.length === 0)
+            return [];
+        const totalComputeCost = computeResources.reduce((sum, r) => {
+            return sum + this.findCost(r.logicalId, resourceCosts);
+        }, 0);
+        if (totalComputeCost < MINIMUM_AGGREGATE_COST)
+            return [];
+        const recommendations = [];
+        const hasMultipleComputeTypes = this.hasMultipleComputeTypes(computeResources);
+        const ec2OnlyResources = computeResources.filter((r) => EC2_ONLY_TYPES.includes(r.type));
+        // Compute Savings Plan (works across EC2, Fargate, Lambda)
+        const computeSavings = totalComputeCost * (COMPUTE_SP_DISCOUNT / 100);
+        recommendations.push({
+            id: 'compute-savings-plan',
+            title: 'Purchase Compute Savings Plan',
+            description: `Total compute spend across ${computeResources.length} resources is $${totalComputeCost.toFixed(2)}/month. A 1-year Compute Savings Plan could save ~${COMPUTE_SP_DISCOUNT}%.${hasMultipleComputeTypes ? ' Compute Savings Plans apply across EC2, Fargate, and Lambda.' : ''}`,
+            category: this.category,
+            priority: computeSavings >= 200 ? 'high' : computeSavings >= 100 ? 'medium' : 'low',
+            estimatedMonthlySavings: Math.round(computeSavings * 100) / 100,
+            estimatedSavingsPercent: COMPUTE_SP_DISCOUNT,
+            affectedResources: computeResources.map((r) => r.logicalId),
+            actionItems: [
+                `Commit to $${Math.round(totalComputeCost * (1 - COMPUTE_SP_DISCOUNT / 100))}/month in compute usage`,
+                'Evaluate 1-year vs 3-year term based on workload stability',
+                'Use AWS Cost Explorer Savings Plans recommendations for exact pricing',
+            ],
+            caveats: [
+                '1-year minimum commitment',
+                `${COMPUTE_SP_DISCOUNT}% discount is approximate; actual savings vary by instance type and region`,
+                'Applies to EC2, Fargate, and Lambda compute usage',
+                'Cannot be cancelled or modified after purchase',
+            ],
+        });
+        // EC2 Instance Savings Plan (higher discount, less flexibility)
+        if (ec2OnlyResources.length > 0) {
+            const ec2Cost = ec2OnlyResources.reduce((sum, r) => sum + this.findCost(r.logicalId, resourceCosts), 0);
+            if (ec2Cost >= MINIMUM_AGGREGATE_COST) {
+                const ec2Savings = ec2Cost * (EC2_SP_DISCOUNT / 100);
+                recommendations.push({
+                    id: 'ec2-savings-plan',
+                    title: 'Purchase EC2 Instance Savings Plan',
+                    description: `EC2 spend is $${ec2Cost.toFixed(2)}/month across ${ec2OnlyResources.length} resources. An EC2 Instance Savings Plan offers ~${EC2_SP_DISCOUNT}% discount (higher than Compute SP) but only applies to EC2.`,
+                    category: this.category,
+                    priority: ec2Savings >= 200 ? 'high' : 'medium',
+                    estimatedMonthlySavings: Math.round(ec2Savings * 100) / 100,
+                    estimatedSavingsPercent: EC2_SP_DISCOUNT,
+                    affectedResources: ec2OnlyResources.map((r) => r.logicalId),
+                    actionItems: [
+                        'Compare Compute SP vs EC2 Instance SP savings in AWS Cost Explorer',
+                        'Choose EC2 Instance SP only if EC2 is the dominant compute spend',
+                        'Consider combining with Compute SP for non-EC2 workloads',
+                    ],
+                    caveats: [
+                        'Only applies to EC2 instance usage (not Fargate or Lambda)',
+                        'Locked to a specific instance family and region',
+                        `${EC2_SP_DISCOUNT}% discount is approximate`,
+                    ],
+                });
+            }
+        }
+        return recommendations;
+    }
+    hasMultipleComputeTypes(resources) {
+        const types = new Set(resources.map((r) => r.type));
+        const hasEC2 = [...types].some((t) => EC2_ONLY_TYPES.includes(t));
+        const hasNonEC2 = [...types].some((t) => COMPUTE_TYPES.includes(t) && !EC2_ONLY_TYPES.includes(t));
+        return hasEC2 && hasNonEC2;
+    }
+    findCost(logicalId, resourceCosts) {
+        const cost = resourceCosts.find((c) => c.logicalId === logicalId);
+        return cost?.monthlyCost.amount ?? 0;
+    }
+}
+exports.SavingsPlansAnalyzer = SavingsPlansAnalyzer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SavingsPlansAnalyzer.js","sourceRoot":"","sources":["../../../src/optimization/analyzers/SavingsPlansAnalyzer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ResourceWithId } from '../../diff/types';\nimport { ResourceCost } from '../../pricing/types';\nimport {\n  OptimizationAnalyzer,\n  OptimizationCategory,\n  Recommendation,\n} from '../types';\n\nconst COMPUTE_SP_DISCOUNT = 30;\nconst EC2_SP_DISCOUNT = 35;\n\nconst COMPUTE_TYPES = [\n  'AWS::EC2::Instance',\n  'AWS::EC2::LaunchTemplate',\n  'AWS::AutoScaling::AutoScalingGroup',\n  'AWS::ECS::Service',\n  'AWS::ECS::TaskDefinition',\n  'AWS::Lambda::Function',\n];\n\nconst EC2_ONLY_TYPES = [\n  'AWS::EC2::Instance',\n  'AWS::EC2::LaunchTemplate',\n  'AWS::AutoScaling::AutoScalingGroup',\n];\n\nconst MINIMUM_AGGREGATE_COST = 100;\n\nexport class SavingsPlansAnalyzer implements OptimizationAnalyzer {\n  readonly category: OptimizationCategory = 'savings-plan';\n  readonly name = 'Savings Plans';\n\n  isApplicable(resources: ResourceWithId[]): boolean {\n    return resources.some((r) => COMPUTE_TYPES.includes(r.type));\n  }\n\n  async analyze(\n    resources: ResourceWithId[],\n    resourceCosts: ResourceCost[],\n    _region: string,\n  ): Promise<Recommendation[]> {\n    const computeResources = resources.filter((r) =>\n      COMPUTE_TYPES.includes(r.type),\n    );\n    if (computeResources.length === 0) return [];\n\n    const totalComputeCost = computeResources.reduce((sum, r) => {\n      return sum + this.findCost(r.logicalId, resourceCosts);\n    }, 0);\n\n    if (totalComputeCost < MINIMUM_AGGREGATE_COST) return [];\n\n    const recommendations: Recommendation[] = [];\n    const hasMultipleComputeTypes = this.hasMultipleComputeTypes(computeResources);\n    const ec2OnlyResources = computeResources.filter((r) =>\n      EC2_ONLY_TYPES.includes(r.type),\n    );\n\n    // Compute Savings Plan (works across EC2, Fargate, Lambda)\n    const computeSavings = totalComputeCost * (COMPUTE_SP_DISCOUNT / 100);\n    recommendations.push({\n      id: 'compute-savings-plan',\n      title: 'Purchase Compute Savings Plan',\n      description: `Total compute spend across ${computeResources.length} resources is $${totalComputeCost.toFixed(2)}/month. A 1-year Compute Savings Plan could save ~${COMPUTE_SP_DISCOUNT}%.${hasMultipleComputeTypes ? ' Compute Savings Plans apply across EC2, Fargate, and Lambda.' : ''}`,\n      category: this.category,\n      priority: computeSavings >= 200 ? 'high' : computeSavings >= 100 ? 'medium' : 'low',\n      estimatedMonthlySavings: Math.round(computeSavings * 100) / 100,\n      estimatedSavingsPercent: COMPUTE_SP_DISCOUNT,\n      affectedResources: computeResources.map((r) => r.logicalId),\n      actionItems: [\n        `Commit to $${Math.round(totalComputeCost * (1 - COMPUTE_SP_DISCOUNT / 100))}/month in compute usage`,\n        'Evaluate 1-year vs 3-year term based on workload stability',\n        'Use AWS Cost Explorer Savings Plans recommendations for exact pricing',\n      ],\n      caveats: [\n        '1-year minimum commitment',\n        `${COMPUTE_SP_DISCOUNT}% discount is approximate; actual savings vary by instance type and region`,\n        'Applies to EC2, Fargate, and Lambda compute usage',\n        'Cannot be cancelled or modified after purchase',\n      ],\n    });\n\n    // EC2 Instance Savings Plan (higher discount, less flexibility)\n    if (ec2OnlyResources.length > 0) {\n      const ec2Cost = ec2OnlyResources.reduce(\n        (sum, r) => sum + this.findCost(r.logicalId, resourceCosts),\n        0,\n      );\n\n      if (ec2Cost >= MINIMUM_AGGREGATE_COST) {\n        const ec2Savings = ec2Cost * (EC2_SP_DISCOUNT / 100);\n        recommendations.push({\n          id: 'ec2-savings-plan',\n          title: 'Purchase EC2 Instance Savings Plan',\n          description: `EC2 spend is $${ec2Cost.toFixed(2)}/month across ${ec2OnlyResources.length} resources. An EC2 Instance Savings Plan offers ~${EC2_SP_DISCOUNT}% discount (higher than Compute SP) but only applies to EC2.`,\n          category: this.category,\n          priority: ec2Savings >= 200 ? 'high' : 'medium',\n          estimatedMonthlySavings: Math.round(ec2Savings * 100) / 100,\n          estimatedSavingsPercent: EC2_SP_DISCOUNT,\n          affectedResources: ec2OnlyResources.map((r) => r.logicalId),\n          actionItems: [\n            'Compare Compute SP vs EC2 Instance SP savings in AWS Cost Explorer',\n            'Choose EC2 Instance SP only if EC2 is the dominant compute spend',\n            'Consider combining with Compute SP for non-EC2 workloads',\n          ],\n          caveats: [\n            'Only applies to EC2 instance usage (not Fargate or Lambda)',\n            'Locked to a specific instance family and region',\n            `${EC2_SP_DISCOUNT}% discount is approximate`,\n          ],\n        });\n      }\n    }\n\n    return recommendations;\n  }\n\n  private hasMultipleComputeTypes(resources: ResourceWithId[]): boolean {\n    const types = new Set(resources.map((r) => r.type));\n    const hasEC2 = [...types].some((t) => EC2_ONLY_TYPES.includes(t));\n    const hasNonEC2 = [...types].some(\n      (t) => COMPUTE_TYPES.includes(t) && !EC2_ONLY_TYPES.includes(t),\n    );\n    return hasEC2 && hasNonEC2;\n  }\n\n  private findCost(logicalId: string, resourceCosts: ResourceCost[]): number {\n    const cost = resourceCosts.find((c) => c.logicalId === logicalId);\n    return cost?.monthlyCost.amount ?? 0;\n  }\n}\n"]}

package/dist/optimization/analyzers/SpotInstanceAnalyzer.d.ts

@@ -0,0 +1,12 @@
+import { ResourceWithId } from '../../diff/types';
+import { ResourceCost } from '../../pricing/types';
+import { OptimizationAnalyzer, OptimizationCategory, Recommendation } from '../types';
+export declare class SpotInstanceAnalyzer implements OptimizationAnalyzer {
+    readonly category: OptimizationCategory;
+    readonly name = "Spot Instances";
+    isApplicable(resources: ResourceWithId[]): boolean;
+    analyze(resources: ResourceWithId[], resourceCosts: ResourceCost[], _region: string): Promise<Recommendation[]>;
+    private analyzeASG;
+    private analyzeECSService;
+    private findCost;
+}