cdk-cost-analyzer 0.1.1

package/dist/synthesis/SynthesisOrchestrator.js

@@ -0,0 +1,243 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynthesisOrchestrator = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+class SynthesisOrchestrator {
+    DEFAULT_OUTPUT_PATH = 'cdk.out';
+    /**
+     * Execute CDK synthesis
+     */
+    async synthesize(options) {
+        const startTime = Date.now();
+        try {
+            const outputPath = options.outputPath || this.DEFAULT_OUTPUT_PATH;
+            const command = options.customCommand || 'npx cdk synth';
+            await this.executeSynthesis(command, options.cdkAppPath, options.context, outputPath);
+            const fullOutputPath = path.join(options.cdkAppPath, outputPath);
+            const { templatePaths, stackNames } = await this.findTemplates(fullOutputPath);
+            const duration = Date.now() - startTime;
+            return {
+                success: true,
+                templatePaths,
+                stackNames,
+                duration,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (error instanceof types_1.SynthesisError) {
+                return {
+                    success: false,
+                    templatePaths: [],
+                    stackNames: [],
+                    error: errorMessage,
+                    duration,
+                };
+            }
+            return {
+                success: false,
+                templatePaths: [],
+                stackNames: [],
+                error: `Synthesis failed: ${errorMessage}`,
+                duration,
+            };
+        }
+    }
+    /**
+     * Execute synthesis command
+     *
+     * Uses shell: false for security to prevent command injection attacks.
+     * Arguments are passed as an array to avoid shell interpretation.
+     *
+     * Implements a 15-second timeout to prevent hanging processes in CI:
+     * - Sends SIGTERM for graceful termination
+     * - Follows up with SIGKILL after 1 second if process doesn't exit
+     * - Prevents duplicate resolution using isResolved flag
+     * - Ensures all event listeners are cleaned up
+     * - Uses process.kill as fallback for stubborn processes
+     */
+    async executeSynthesis(command, cdkAppPath, context, outputPath) {
+        return new Promise((resolve, reject) => {
+            const [cmd, ...args] = command.split(' ');
+            // Add context arguments
+            const allArgs = [...args];
+            if (context) {
+                for (const [key, value] of Object.entries(context)) {
+                    allArgs.push('-c', `${key}=${value}`);
+                }
+            }
+            // Add output path if specified
+            if (outputPath) {
+                allArgs.push('--output', outputPath);
+            }
+            // Use shell: false for security and pass arguments properly
+            const proc = (0, child_process_1.spawn)(cmd, allArgs, {
+                cwd: cdkAppPath,
+                shell: false,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                detached: false, // Ensure process is part of the same process group
+            });
+            let stdout = '';
+            let stderr = '';
+            let isResolved = false;
+            let killTimeout = null;
+            const cleanup = () => {
+                if (killTimeout) {
+                    clearTimeout(killTimeout);
+                    killTimeout = null;
+                }
+                // Remove all listeners to prevent memory leaks
+                proc.removeAllListeners();
+                proc.stdout?.removeAllListeners();
+                proc.stderr?.removeAllListeners();
+            };
+            const forceKill = () => {
+                try {
+                    // Try multiple kill methods for stubborn processes
+                    if (proc.pid && !proc.killed) {
+                        proc.kill('SIGKILL');
+                        // Also try process.kill as fallback
+                        try {
+                            process.kill(proc.pid, 'SIGKILL');
+                        }
+                        catch (killError) {
+                            // Ignore kill errors - process might already be dead
+                        }
+                    }
+                }
+                catch (error) {
+                    // Ignore errors during force kill
+                }
+            };
+            // Set up timeout to prevent hanging processes
+            const timeout = setTimeout(() => {
+                if (!isResolved) {
+                    isResolved = true;
+                    // First try graceful termination
+                    proc.kill('SIGTERM');
+                    // Force kill after 1 second if still running
+                    killTimeout = setTimeout(() => {
+                        forceKill();
+                    }, 1000);
+                    cleanup();
+                    reject(new types_1.SynthesisError('CDK synthesis timed out after 15 seconds', stderr || stdout || 'No output captured'));
+                }
+            }, 15000); // Reduced to 15 second timeout
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('error', (error) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    clearTimeout(timeout);
+                    cleanup();
+                    reject(new types_1.SynthesisError(`Failed to execute synthesis command: ${error.message}`, stderr || 'No error output captured'));
+                }
+            });
+            proc.on('close', (code) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    clearTimeout(timeout);
+                    cleanup();
+                    if (code !== 0) {
+                        reject(new types_1.SynthesisError(`CDK synthesis failed with exit code ${code}`, stderr || stdout || 'No output captured'));
+                    }
+                    else {
+                        resolve();
+                    }
+                }
+            });
+            // Additional safety: handle process exit
+            proc.on('exit', (code, signal) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    clearTimeout(timeout);
+                    cleanup();
+                    if (signal) {
+                        reject(new types_1.SynthesisError(`CDK synthesis terminated by signal ${signal}`, stderr || stdout || 'No output captured'));
+                    }
+                    else if (code !== 0) {
+                        reject(new types_1.SynthesisError(`CDK synthesis failed with exit code ${code}`, stderr || stdout || 'No output captured'));
+                    }
+                    else {
+                        resolve();
+                    }
+                }
+            });
+        });
+    }
+    /**
+     * Find all CloudFormation templates in output directory
+     */
+    async findTemplates(outputPath) {
+        try {
+            const files = await fs.readdir(outputPath);
+            const templatePaths = [];
+            const stackNames = [];
+            for (const file of files) {
+                // Match CloudFormation template files (stack-name.template.json or stack-name.template.yaml)
+                if (file.endsWith('.template.json') ||
+                    file.endsWith('.template.yaml') ||
+                    file.endsWith('.template.yml')) {
+                    const fullPath = path.join(outputPath, file);
+                    templatePaths.push(fullPath);
+                    // Extract stack name from filename
+                    const stackName = file
+                        .replace('.template.json', '')
+                        .replace('.template.yaml', '')
+                        .replace('.template.yml', '');
+                    stackNames.push(stackName);
+                }
+            }
+            if (templatePaths.length === 0) {
+                throw new Error('No CloudFormation templates found in output directory');
+            }
+            return { templatePaths, stackNames };
+        }
+        catch (error) {
+            throw new Error(`Failed to find templates: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+exports.SynthesisOrchestrator = SynthesisOrchestrator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SynthesisOrchestrator.js","sourceRoot":"","sources":["../../src/synthesis/SynthesisOrchestrator.ts"],"names":[],"mappings":"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","sourcesContent":["import { spawn } from 'child_process';\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { SynthesisOptions, SynthesisResult, SynthesisError } from './types';\n\nexport class SynthesisOrchestrator {\n  private readonly DEFAULT_OUTPUT_PATH = 'cdk.out';\n\n  /**\n   * Execute CDK synthesis\n   */\n  async synthesize(options: SynthesisOptions): Promise<SynthesisResult> {\n    const startTime = Date.now();\n\n    try {\n      const outputPath = options.outputPath || this.DEFAULT_OUTPUT_PATH;\n      const command = options.customCommand || 'npx cdk synth';\n\n      await this.executeSynthesis(command, options.cdkAppPath, options.context, outputPath);\n\n      const fullOutputPath = path.join(options.cdkAppPath, outputPath);\n      const { templatePaths, stackNames } = await this.findTemplates(fullOutputPath);\n\n      const duration = Date.now() - startTime;\n\n      return {\n        success: true,\n        templatePaths,\n        stackNames,\n        duration,\n      };\n    } catch (error) {\n      const duration = Date.now() - startTime;\n      const errorMessage = error instanceof Error ? error.message : String(error);\n\n      if (error instanceof SynthesisError) {\n        return {\n          success: false,\n          templatePaths: [],\n          stackNames: [],\n          error: errorMessage,\n          duration,\n        };\n      }\n\n      return {\n        success: false,\n        templatePaths: [],\n        stackNames: [],\n        error: `Synthesis failed: ${errorMessage}`,\n        duration,\n      };\n    }\n  }\n\n  /**\n   * Execute synthesis command\n   *\n   * Uses shell: false for security to prevent command injection attacks.\n   * Arguments are passed as an array to avoid shell interpretation.\n   * \n   * Implements a 15-second timeout to prevent hanging processes in CI:\n   * - Sends SIGTERM for graceful termination\n   * - Follows up with SIGKILL after 1 second if process doesn't exit\n   * - Prevents duplicate resolution using isResolved flag\n   * - Ensures all event listeners are cleaned up\n   * - Uses process.kill as fallback for stubborn processes\n   */\n  private async executeSynthesis(\n    command: string,\n    cdkAppPath: string,\n    context?: Record<string, string>,\n    outputPath?: string,\n  ): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const [cmd, ...args] = command.split(' ');\n\n      // Add context arguments\n      const allArgs = [...args];\n      if (context) {\n        for (const [key, value] of Object.entries(context)) {\n          allArgs.push('-c', `${key}=${value}`);\n        }\n      }\n\n      // Add output path if specified\n      if (outputPath) {\n        allArgs.push('--output', outputPath);\n      }\n\n      // Use shell: false for security and pass arguments properly\n      const proc = spawn(cmd, allArgs, {\n        cwd: cdkAppPath,\n        shell: false,\n        stdio: ['ignore', 'pipe', 'pipe'],\n        detached: false, // Ensure process is part of the same process group\n      });\n\n      let stdout = '';\n      let stderr = '';\n      let isResolved = false;\n      let killTimeout: NodeJS.Timeout | null = null;\n\n      const cleanup = (): void => {\n        if (killTimeout) {\n          clearTimeout(killTimeout);\n          killTimeout = null;\n        }\n        // Remove all listeners to prevent memory leaks\n        proc.removeAllListeners();\n        proc.stdout?.removeAllListeners();\n        proc.stderr?.removeAllListeners();\n      };\n\n      const forceKill = (): void => {\n        try {\n          // Try multiple kill methods for stubborn processes\n          if (proc.pid && !proc.killed) {\n            proc.kill('SIGKILL');\n            // Also try process.kill as fallback\n            try {\n              process.kill(proc.pid, 'SIGKILL');\n            } catch (killError) {\n              // Ignore kill errors - process might already be dead\n            }\n          }\n        } catch (error) {\n          // Ignore errors during force kill\n        }\n      };\n\n      // Set up timeout to prevent hanging processes\n      const timeout = setTimeout(() => {\n        if (!isResolved) {\n          isResolved = true;\n          \n          // First try graceful termination\n          proc.kill('SIGTERM');\n          \n          // Force kill after 1 second if still running\n          killTimeout = setTimeout(() => {\n            forceKill();\n          }, 1000);\n          \n          cleanup();\n          reject(\n            new SynthesisError(\n              'CDK synthesis timed out after 15 seconds',\n              stderr || stdout || 'No output captured',\n            ),\n          );\n        }\n      }, 15000); // Reduced to 15 second timeout\n\n      proc.stdout?.on('data', (data: Buffer) => {\n        stdout += data.toString();\n      });\n\n      proc.stderr?.on('data', (data: Buffer) => {\n        stderr += data.toString();\n      });\n\n      proc.on('error', (error: Error) => {\n        if (!isResolved) {\n          isResolved = true;\n          clearTimeout(timeout);\n          cleanup();\n          reject(\n            new SynthesisError(\n              `Failed to execute synthesis command: ${error.message}`,\n              stderr || 'No error output captured',\n            ),\n          );\n        }\n      });\n\n      proc.on('close', (code: number | null) => {\n        if (!isResolved) {\n          isResolved = true;\n          clearTimeout(timeout);\n          cleanup();\n          if (code !== 0) {\n            reject(\n              new SynthesisError(\n                `CDK synthesis failed with exit code ${code}`,\n                stderr || stdout || 'No output captured',\n              ),\n            );\n          } else {\n            resolve();\n          }\n        }\n      });\n\n      // Additional safety: handle process exit\n      proc.on('exit', (code: number | null, signal: string | null) => {\n        if (!isResolved) {\n          isResolved = true;\n          clearTimeout(timeout);\n          cleanup();\n          if (signal) {\n            reject(\n              new SynthesisError(\n                `CDK synthesis terminated by signal ${signal}`,\n                stderr || stdout || 'No output captured',\n              ),\n            );\n          } else if (code !== 0) {\n            reject(\n              new SynthesisError(\n                `CDK synthesis failed with exit code ${code}`,\n                stderr || stdout || 'No output captured',\n              ),\n            );\n          } else {\n            resolve();\n          }\n        }\n      });\n    });\n  }\n\n  /**\n   * Find all CloudFormation templates in output directory\n   */\n  private async findTemplates(\n    outputPath: string,\n  ): Promise<{ templatePaths: string[]; stackNames: string[] }> {\n    try {\n      const files = await fs.readdir(outputPath);\n\n      const templatePaths: string[] = [];\n      const stackNames: string[] = [];\n\n      for (const file of files) {\n        // Match CloudFormation template files (stack-name.template.json or stack-name.template.yaml)\n        if (\n          file.endsWith('.template.json') ||\n          file.endsWith('.template.yaml') ||\n          file.endsWith('.template.yml')\n        ) {\n          const fullPath = path.join(outputPath, file);\n          templatePaths.push(fullPath);\n\n          // Extract stack name from filename\n          const stackName = file\n            .replace('.template.json', '')\n            .replace('.template.yaml', '')\n            .replace('.template.yml', '');\n          stackNames.push(stackName);\n        }\n      }\n\n      if (templatePaths.length === 0) {\n        throw new Error('No CloudFormation templates found in output directory');\n      }\n\n      return { templatePaths, stackNames };\n    } catch (error) {\n      throw new Error(\n        `Failed to find templates: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n}\n"]}

package/dist/synthesis/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SynthesisOrchestrator';
+export * from './types';

package/dist/synthesis/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SynthesisOrchestrator"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3ludGhlc2lzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwREFBd0M7QUFDeEMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9TeW50aGVzaXNPcmNoZXN0cmF0b3InO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/dist/synthesis/types.d.ts

@@ -0,0 +1,17 @@
+export interface SynthesisOptions {
+    cdkAppPath: string;
+    outputPath?: string;
+    context?: Record<string, string>;
+    customCommand?: string;
+}
+export interface SynthesisResult {
+    success: boolean;
+    templatePaths: string[];
+    stackNames: string[];
+    error?: string;
+    duration: number;
+}
+export declare class SynthesisError extends Error {
+    cdkOutput: string;
+    constructor(message: string, cdkOutput: string);
+}

package/dist/synthesis/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynthesisError = void 0;
+class SynthesisError extends Error {
+    cdkOutput;
+    constructor(message, cdkOutput) {
+        super(message);
+        this.cdkOutput = cdkOutput;
+        this.name = 'SynthesisError';
+    }
+}
+exports.SynthesisError = SynthesisError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3ludGhlc2lzL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQWVBLE1BQWEsY0FBZSxTQUFRLEtBQUs7SUFHOUI7SUFGVCxZQUNFLE9BQWUsRUFDUixTQUFpQjtRQUV4QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFGUixjQUFTLEdBQVQsU0FBUyxDQUFRO1FBR3hCLElBQUksQ0FBQyxJQUFJLEdBQUcsZ0JBQWdCLENBQUM7SUFDL0IsQ0FBQztDQUNGO0FBUkQsd0NBUUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFN5bnRoZXNpc09wdGlvbnMge1xuICBjZGtBcHBQYXRoOiBzdHJpbmc7XG4gIG91dHB1dFBhdGg/OiBzdHJpbmc7XG4gIGNvbnRleHQ/OiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+O1xuICBjdXN0b21Db21tYW5kPzogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFN5bnRoZXNpc1Jlc3VsdCB7XG4gIHN1Y2Nlc3M6IGJvb2xlYW47XG4gIHRlbXBsYXRlUGF0aHM6IHN0cmluZ1tdO1xuICBzdGFja05hbWVzOiBzdHJpbmdbXTtcbiAgZXJyb3I/OiBzdHJpbmc7XG4gIGR1cmF0aW9uOiBudW1iZXI7XG59XG5cbmV4cG9ydCBjbGFzcyBTeW50aGVzaXNFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IoXG4gICAgbWVzc2FnZTogc3RyaW5nLFxuICAgIHB1YmxpYyBjZGtPdXRwdXQ6IHN0cmluZyxcbiAgKSB7XG4gICAgc3VwZXIobWVzc2FnZSk7XG4gICAgdGhpcy5uYW1lID0gJ1N5bnRoZXNpc0Vycm9yJztcbiAgfVxufVxuIl19

package/dist/threshold/ThresholdEnforcer.d.ts

@@ -0,0 +1,29 @@
+import { ThresholdEvaluation } from './types';
+import { ThresholdConfig } from '../config/types';
+import { ResourceCost, ModifiedResourceCost } from '../pricing/types';
+export declare class ThresholdEnforcer {
+    /**
+     * Evaluate cost delta against configured thresholds
+     */
+    evaluateThreshold(costDelta: number, addedResources: ResourceCost[], modifiedResources: ModifiedResourceCost[], config?: ThresholdConfig, environment?: string): ThresholdEvaluation;
+    /**
+     * Select appropriate threshold based on environment
+     */
+    private selectThresholds;
+    /**
+     * Get top cost contributors sorted by impact
+     */
+    private getTopContributors;
+    /**
+     * Format error threshold message
+     */
+    private formatErrorMessage;
+    /**
+     * Format warning threshold message
+     */
+    private formatWarningMessage;
+    /**
+     * Get recommendations based on threshold level and contributors
+     */
+    private getRecommendations;
+}

package/dist/threshold/ThresholdEnforcer.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThresholdEnforcer = void 0;
+class ThresholdEnforcer {
+    /**
+     * Evaluate cost delta against configured thresholds
+     */
+    evaluateThreshold(costDelta, addedResources, modifiedResources, config, environment) {
+        if (!config) {
+            return {
+                passed: true,
+                level: 'none',
+                delta: costDelta,
+                message: 'No thresholds configured',
+                recommendations: [],
+            };
+        }
+        const thresholds = this.selectThresholds(config, environment);
+        if (!thresholds) {
+            return {
+                passed: true,
+                level: 'none',
+                delta: costDelta,
+                message: 'No thresholds configured',
+                recommendations: [],
+            };
+        }
+        // Check error threshold first
+        if (thresholds.error !== undefined && costDelta > thresholds.error) {
+            const topContributors = this.getTopContributors(addedResources, modifiedResources, 5);
+            return {
+                passed: false,
+                level: 'error',
+                threshold: thresholds.error,
+                delta: costDelta,
+                message: this.formatErrorMessage(costDelta, thresholds.error),
+                recommendations: this.getRecommendations('error', topContributors),
+            };
+        }
+        // Check warning threshold
+        if (thresholds.warning !== undefined && costDelta > thresholds.warning) {
+            const topContributors = this.getTopContributors(addedResources, modifiedResources, 5);
+            return {
+                passed: true,
+                level: 'warning',
+                threshold: thresholds.warning,
+                delta: costDelta,
+                message: this.formatWarningMessage(costDelta, thresholds.warning),
+                recommendations: this.getRecommendations('warning', topContributors),
+            };
+        }
+        return {
+            passed: true,
+            level: 'none',
+            delta: costDelta,
+            message: `Cost delta $${costDelta.toFixed(2)}/month is within thresholds`,
+            recommendations: [],
+        };
+    }
+    /**
+     * Select appropriate threshold based on environment
+     */
+    selectThresholds(config, environment) {
+        if (environment && config.environments?.[environment]) {
+            return config.environments[environment];
+        }
+        return config.default;
+    }
+    /**
+     * Get top cost contributors sorted by impact
+     */
+    getTopContributors(addedResources, modifiedResources, limit) {
+        const allContributors = [
+            ...addedResources,
+            ...modifiedResources.map((r) => ({
+                logicalId: r.logicalId,
+                type: r.type,
+                monthlyCost: {
+                    amount: r.costDelta,
+                    currency: r.newMonthlyCost.currency,
+                    confidence: r.newMonthlyCost.confidence,
+                    assumptions: r.newMonthlyCost.assumptions,
+                },
+            })),
+        ];
+        return allContributors
+            .sort((a, b) => b.monthlyCost.amount - a.monthlyCost.amount)
+            .slice(0, limit);
+    }
+    /**
+     * Format error threshold message
+     */
+    formatErrorMessage(delta, threshold) {
+        const exceededBy = delta - threshold;
+        const percentage = ((exceededBy / threshold) * 100).toFixed(1);
+        return `Cost increase of $${delta.toFixed(2)}/month exceeds error threshold of $${threshold.toFixed(2)}/month by $${exceededBy.toFixed(2)} (${percentage}%)`;
+    }
+    /**
+     * Format warning threshold message
+     */
+    formatWarningMessage(delta, threshold) {
+        const exceededBy = delta - threshold;
+        const percentage = ((exceededBy / threshold) * 100).toFixed(1);
+        return `Cost increase of $${delta.toFixed(2)}/month exceeds warning threshold of $${threshold.toFixed(2)}/month by $${exceededBy.toFixed(2)} (${percentage}%)`;
+    }
+    /**
+     * Get recommendations based on threshold level and contributors
+     */
+    getRecommendations(level, topContributors) {
+        const recommendations = [];
+        if (level === 'error') {
+            recommendations.push('This change cannot be merged without approval due to cost impact.');
+            recommendations.push('Review the cost breakdown and consider optimizations before proceeding.');
+            recommendations.push('Contact your FinOps team for threshold override approval if this cost increase is necessary.');
+        }
+        else {
+            recommendations.push('Review this cost increase with your team before merging.');
+            recommendations.push('Consider whether all resources in this change are necessary.');
+        }
+        if (topContributors.length > 0) {
+            recommendations.push(`Top cost contributors: ${topContributors
+                .map((r) => `${r.type} (${r.logicalId}): $${r.monthlyCost.amount.toFixed(2)}/month`)
+                .join(', ')}`);
+            // Specific recommendations based on resource types
+            const resourceTypes = new Set(topContributors.map((r) => r.type));
+            if (resourceTypes.has('AWS::RDS::DBInstance')) {
+                recommendations.push('Consider using smaller RDS instance types or Aurora Serverless for lower costs.');
+            }
+            if (resourceTypes.has('AWS::EC2::Instance')) {
+                recommendations.push('Consider using smaller EC2 instance types, Spot instances, or Savings Plans.');
+            }
+            if (resourceTypes.has('AWS::EC2::NatGateway')) {
+                recommendations.push('NAT Gateways have high data processing costs. Consider using VPC endpoints or consolidating NAT Gateways.');
+            }
+            if (resourceTypes.has('AWS::ElasticLoadBalancingV2::LoadBalancer')) {
+                recommendations.push('Load Balancers have hourly costs. Consider sharing load balancers across services if possible.');
+            }
+        }
+        return recommendations;
+    }
+}
+exports.ThresholdEnforcer = ThresholdEnforcer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ThresholdEnforcer.js","sourceRoot":"","sources":["../../src/threshold/ThresholdEnforcer.ts"],"names":[],"mappings":"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","sourcesContent":["import { ThresholdEvaluation } from './types';\nimport { ThresholdConfig, ThresholdLevels } from '../config/types';\nimport { ResourceCost, ModifiedResourceCost } from '../pricing/types';\n\nexport class ThresholdEnforcer {\n  /**\n   * Evaluate cost delta against configured thresholds\n   */\n  evaluateThreshold(\n    costDelta: number,\n    addedResources: ResourceCost[],\n    modifiedResources: ModifiedResourceCost[],\n    config?: ThresholdConfig,\n    environment?: string,\n  ): ThresholdEvaluation {\n    if (!config) {\n      return {\n        passed: true,\n        level: 'none',\n        delta: costDelta,\n        message: 'No thresholds configured',\n        recommendations: [],\n      };\n    }\n\n    const thresholds = this.selectThresholds(config, environment);\n\n    if (!thresholds) {\n      return {\n        passed: true,\n        level: 'none',\n        delta: costDelta,\n        message: 'No thresholds configured',\n        recommendations: [],\n      };\n    }\n\n    // Check error threshold first\n    if (thresholds.error !== undefined && costDelta > thresholds.error) {\n      const topContributors = this.getTopContributors(\n        addedResources,\n        modifiedResources,\n        5,\n      );\n\n      return {\n        passed: false,\n        level: 'error',\n        threshold: thresholds.error,\n        delta: costDelta,\n        message: this.formatErrorMessage(costDelta, thresholds.error),\n        recommendations: this.getRecommendations('error', topContributors),\n      };\n    }\n\n    // Check warning threshold\n    if (thresholds.warning !== undefined && costDelta > thresholds.warning) {\n      const topContributors = this.getTopContributors(\n        addedResources,\n        modifiedResources,\n        5,\n      );\n\n      return {\n        passed: true,\n        level: 'warning',\n        threshold: thresholds.warning,\n        delta: costDelta,\n        message: this.formatWarningMessage(costDelta, thresholds.warning),\n        recommendations: this.getRecommendations('warning', topContributors),\n      };\n    }\n\n    return {\n      passed: true,\n      level: 'none',\n      delta: costDelta,\n      message: `Cost delta $${costDelta.toFixed(2)}/month is within thresholds`,\n      recommendations: [],\n    };\n  }\n\n  /**\n   * Select appropriate threshold based on environment\n   */\n  private selectThresholds(\n    config: ThresholdConfig,\n    environment?: string,\n  ): ThresholdLevels | undefined {\n    if (environment && config.environments?.[environment]) {\n      return config.environments[environment];\n    }\n    return config.default;\n  }\n\n  /**\n   * Get top cost contributors sorted by impact\n   */\n  private getTopContributors(\n    addedResources: ResourceCost[],\n    modifiedResources: ModifiedResourceCost[],\n    limit: number,\n  ): ResourceCost[] {\n    const allContributors: ResourceCost[] = [\n      ...addedResources,\n      ...modifiedResources.map((r) => ({\n        logicalId: r.logicalId,\n        type: r.type,\n        monthlyCost: {\n          amount: r.costDelta,\n          currency: r.newMonthlyCost.currency,\n          confidence: r.newMonthlyCost.confidence,\n          assumptions: r.newMonthlyCost.assumptions,\n        },\n      })),\n    ];\n\n    return allContributors\n      .sort((a, b) => b.monthlyCost.amount - a.monthlyCost.amount)\n      .slice(0, limit);\n  }\n\n  /**\n   * Format error threshold message\n   */\n  private formatErrorMessage(delta: number, threshold: number): string {\n    const exceededBy = delta - threshold;\n    const percentage = ((exceededBy / threshold) * 100).toFixed(1);\n\n    return `Cost increase of $${delta.toFixed(2)}/month exceeds error threshold of $${threshold.toFixed(2)}/month by $${exceededBy.toFixed(2)} (${percentage}%)`;\n  }\n\n  /**\n   * Format warning threshold message\n   */\n  private formatWarningMessage(delta: number, threshold: number): string {\n    const exceededBy = delta - threshold;\n    const percentage = ((exceededBy / threshold) * 100).toFixed(1);\n\n    return `Cost increase of $${delta.toFixed(2)}/month exceeds warning threshold of $${threshold.toFixed(2)}/month by $${exceededBy.toFixed(2)} (${percentage}%)`;\n  }\n\n  /**\n   * Get recommendations based on threshold level and contributors\n   */\n  private getRecommendations(\n    level: 'warning' | 'error',\n    topContributors: ResourceCost[],\n  ): string[] {\n    const recommendations: string[] = [];\n\n    if (level === 'error') {\n      recommendations.push(\n        'This change cannot be merged without approval due to cost impact.',\n      );\n      recommendations.push(\n        'Review the cost breakdown and consider optimizations before proceeding.',\n      );\n      recommendations.push(\n        'Contact your FinOps team for threshold override approval if this cost increase is necessary.',\n      );\n    } else {\n      recommendations.push(\n        'Review this cost increase with your team before merging.',\n      );\n      recommendations.push(\n        'Consider whether all resources in this change are necessary.',\n      );\n    }\n\n    if (topContributors.length > 0) {\n      recommendations.push(\n        `Top cost contributors: ${topContributors\n          .map((r) => `${r.type} (${r.logicalId}): $${r.monthlyCost.amount.toFixed(2)}/month`)\n          .join(', ')}`,\n      );\n\n      // Specific recommendations based on resource types\n      const resourceTypes = new Set(topContributors.map((r) => r.type));\n\n      if (resourceTypes.has('AWS::RDS::DBInstance')) {\n        recommendations.push(\n          'Consider using smaller RDS instance types or Aurora Serverless for lower costs.',\n        );\n      }\n\n      if (resourceTypes.has('AWS::EC2::Instance')) {\n        recommendations.push(\n          'Consider using smaller EC2 instance types, Spot instances, or Savings Plans.',\n        );\n      }\n\n      if (resourceTypes.has('AWS::EC2::NatGateway')) {\n        recommendations.push(\n          'NAT Gateways have high data processing costs. Consider using VPC endpoints or consolidating NAT Gateways.',\n        );\n      }\n\n      if (\n        resourceTypes.has('AWS::ElasticLoadBalancingV2::LoadBalancer')\n      ) {\n        recommendations.push(\n          'Load Balancers have hourly costs. Consider sharing load balancers across services if possible.',\n        );\n      }\n    }\n\n    return recommendations;\n  }\n}\n"]}

package/dist/threshold/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ThresholdEnforcer';
+export * from './types';

package/dist/threshold/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ThresholdEnforcer"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGhyZXNob2xkL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxzREFBb0M7QUFDcEMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9UaHJlc2hvbGRFbmZvcmNlcic7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/threshold/types.d.ts

@@ -0,0 +1,15 @@
+import { ResourceCost } from '../pricing/types';
+export interface ThresholdEvaluation {
+    passed: boolean;
+    level: 'none' | 'warning' | 'error';
+    threshold?: number;
+    delta: number;
+    message: string;
+    recommendations: string[];
+}
+export declare class ThresholdExceededError extends Error {
+    threshold: number;
+    actualDelta: number;
+    topContributors: ResourceCost[];
+    constructor(message: string, threshold: number, actualDelta: number, topContributors: ResourceCost[]);
+}

package/dist/threshold/types.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThresholdExceededError = void 0;
+class ThresholdExceededError extends Error {
+    threshold;
+    actualDelta;
+    topContributors;
+    constructor(message, threshold, actualDelta, topContributors) {
+        super(message);
+        this.threshold = threshold;
+        this.actualDelta = actualDelta;
+        this.topContributors = topContributors;
+        this.name = 'ThresholdExceededError';
+    }
+}
+exports.ThresholdExceededError = ThresholdExceededError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGhyZXNob2xkL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVdBLE1BQWEsc0JBQXVCLFNBQVEsS0FBSztJQUd0QztJQUNBO0lBQ0E7SUFKVCxZQUNFLE9BQWUsRUFDUixTQUFpQixFQUNqQixXQUFtQixFQUNuQixlQUErQjtRQUV0QyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7UUFKUixjQUFTLEdBQVQsU0FBUyxDQUFRO1FBQ2pCLGdCQUFXLEdBQVgsV0FBVyxDQUFRO1FBQ25CLG9CQUFlLEdBQWYsZUFBZSxDQUFnQjtRQUd0QyxJQUFJLENBQUMsSUFBSSxHQUFHLHdCQUF3QixDQUFDO0lBQ3ZDLENBQUM7Q0FDRjtBQVZELHdEQVVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmVzb3VyY2VDb3N0IH0gZnJvbSAnLi4vcHJpY2luZy90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGhyZXNob2xkRXZhbHVhdGlvbiB7XG4gIHBhc3NlZDogYm9vbGVhbjtcbiAgbGV2ZWw6ICdub25lJyB8ICd3YXJuaW5nJyB8ICdlcnJvcic7XG4gIHRocmVzaG9sZD86IG51bWJlcjtcbiAgZGVsdGE6IG51bWJlcjtcbiAgbWVzc2FnZTogc3RyaW5nO1xuICByZWNvbW1lbmRhdGlvbnM6IHN0cmluZ1tdO1xufVxuXG5leHBvcnQgY2xhc3MgVGhyZXNob2xkRXhjZWVkZWRFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgY29uc3RydWN0b3IoXG4gICAgbWVzc2FnZTogc3RyaW5nLFxuICAgIHB1YmxpYyB0aHJlc2hvbGQ6IG51bWJlcixcbiAgICBwdWJsaWMgYWN0dWFsRGVsdGE6IG51bWJlcixcbiAgICBwdWJsaWMgdG9wQ29udHJpYnV0b3JzOiBSZXNvdXJjZUNvc3RbXSxcbiAgKSB7XG4gICAgc3VwZXIobWVzc2FnZSk7XG4gICAgdGhpcy5uYW1lID0gJ1RocmVzaG9sZEV4Y2VlZGVkRXJyb3InO1xuICB9XG59XG4iXX0=