cdk-cost-analyzer 0.1.1

package/dist/api/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXBpL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZXNvdXJjZUNvc3QsIE1vZGlmaWVkUmVzb3VyY2VDb3N0IH0gZnJvbSAnLi4vcHJpY2luZy90eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQW5hbHl6ZU9wdGlvbnMge1xuICBiYXNlVGVtcGxhdGU6IHN0cmluZztcbiAgdGFyZ2V0VGVtcGxhdGU6IHN0cmluZztcbiAgcmVnaW9uPzogc3RyaW5nO1xuICBmb3JtYXQ/OiAndGV4dCcgfCAnanNvbicgfCAnbWFya2Rvd24nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvc3RBbmFseXNpc1Jlc3VsdCB7XG4gIHRvdGFsRGVsdGE6IG51bWJlcjtcbiAgY3VycmVuY3k6IHN0cmluZztcbiAgYWRkZWRSZXNvdXJjZXM6IFJlc291cmNlQ29zdFtdO1xuICByZW1vdmVkUmVzb3VyY2VzOiBSZXNvdXJjZUNvc3RbXTtcbiAgbW9kaWZpZWRSZXNvdXJjZXM6IE1vZGlmaWVkUmVzb3VyY2VDb3N0W107XG4gIHN1bW1hcnk6IHN0cmluZztcbn1cbiJdfQ==

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+"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 });
+const fs = __importStar(require("fs"));
+const commander_1 = require("commander");
+const api_1 = require("../api");
+const GitLabIntegration_1 = require("../integrations/GitLabIntegration");
+const PipelineOrchestrator_1 = require("../pipeline/PipelineOrchestrator");
+const program = new commander_1.Command();
+program
+    .name('cdk-cost-analyzer')
+    .description('Analyze AWS CDK infrastructure changes and provide cost impact summaries')
+    .version('1.0.0');
+// Original command for direct template comparison
+program
+    .command('compare')
+    .description('Compare two CloudFormation templates')
+    .argument('<base>', 'Path to base CloudFormation template')
+    .argument('<target>', 'Path to target CloudFormation template')
+    .option('--region <region>', 'AWS region', 'eu-central-1')
+    .option('--format <format>', 'Output format: text|json|markdown', 'text')
+    .option('--config <path>', 'Path to configuration file')
+    .action(async (basePath, targetPath, options) => {
+    try {
+        if (!fs.existsSync(basePath)) {
+            console.error(`Error: Base template file not found: ${basePath}`);
+            process.exit(1);
+        }
+        if (!fs.existsSync(targetPath)) {
+            console.error(`Error: Target template file not found: ${targetPath}`);
+            process.exit(1);
+        }
+        const baseTemplate = fs.readFileSync(basePath, 'utf-8');
+        const targetTemplate = fs.readFileSync(targetPath, 'utf-8');
+        const result = await (0, api_1.analyzeCosts)({
+            baseTemplate,
+            targetTemplate,
+            region: options.region,
+            format: options.format,
+        });
+        if (options.format === 'json') {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(result.summary);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+        }
+        else {
+            console.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+    }
+});
+// New pipeline command for CI/CD integration with synthesis
+program
+    .command('pipeline')
+    .description('Run cost analysis in CI/CD pipeline with automatic synthesis')
+    .option('--base <path>', 'Path to base template (if not using synthesis)')
+    .option('--target <path>', 'Path to target template (if not using synthesis)')
+    .option('--synth', 'Enable automatic CDK synthesis')
+    .option('--cdk-app-path <path>', 'Path to CDK application directory')
+    .option('--region <region>', 'AWS region', 'eu-central-1')
+    .option('--config <path>', 'Path to configuration file')
+    .option('--environment <env>', 'Environment name for threshold selection')
+    .option('--format <format>', 'Output format: text|json|markdown', 'text')
+    .option('--post-to-gitlab', 'Post results to GitLab merge request')
+    .action(async (options) => {
+    try {
+        // Check AWS credentials
+        if (!process.env.AWS_ACCESS_KEY_ID && !process.env.AWS_PROFILE) {
+            console.error('Error: AWS credentials not configured');
+            console.error('');
+            console.error('Please set AWS credentials using one of:');
+            console.error('  - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables');
+            console.error('  - AWS_PROFILE environment variable');
+            console.error('  - AWS credentials file (~/.aws/credentials)');
+            console.error('');
+            console.error('For GitLab CI, configure AWS credentials in CI/CD variables:');
+            console.error('  Settings > CI/CD > Variables');
+            console.error('  Add: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION');
+            process.exit(1);
+        }
+        const orchestrator = new PipelineOrchestrator_1.PipelineOrchestrator();
+        const result = await orchestrator.runPipelineAnalysis({
+            baseTemplate: options.base,
+            targetTemplate: options.target,
+            synthesize: options.synth,
+            cdkAppPath: options.cdkAppPath,
+            region: options.region,
+            configPath: options.config,
+            environment: options.environment,
+        });
+        // Display results
+        if (options.format === 'json') {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(result.costAnalysis.summary);
+            console.log('');
+            // Display threshold status
+            if (result.thresholdStatus.level !== 'none') {
+                console.log('='.repeat(80));
+                console.log('THRESHOLD STATUS');
+                console.log('='.repeat(80));
+                console.log(result.thresholdStatus.message);
+                console.log('');
+                if (result.thresholdStatus.recommendations.length > 0) {
+                    console.log('Recommendations:');
+                    result.thresholdStatus.recommendations.forEach((rec, i) => {
+                        console.log(`${i + 1}. ${rec}`);
+                    });
+                    console.log('');
+                }
+            }
+            // Display config summary
+            if (result.configUsed.configPath || result.configUsed.thresholds) {
+                console.log('='.repeat(80));
+                console.log('CONFIGURATION');
+                console.log('='.repeat(80));
+                if (result.configUsed.configPath) {
+                    console.log(`Config file: ${result.configUsed.configPath}`);
+                }
+                if (result.configUsed.thresholds) {
+                    console.log(`Thresholds: warning=$${result.configUsed.thresholds.warning || 'none'}, error=$${result.configUsed.thresholds.error || 'none'}`);
+                    if (result.configUsed.thresholds.environment) {
+                        console.log(`Environment: ${result.configUsed.thresholds.environment}`);
+                    }
+                }
+                if (result.configUsed.excludedResourceTypes?.length) {
+                    console.log(`Excluded resources: ${result.configUsed.excludedResourceTypes.join(', ')}`);
+                }
+                console.log('');
+            }
+        }
+        // Post to GitLab if requested
+        if (options.postToGitlab) {
+            const gitlabToken = process.env.GITLAB_TOKEN || process.env.CI_JOB_TOKEN;
+            const projectId = process.env.CI_PROJECT_ID;
+            const mergeRequestIid = process.env.CI_MERGE_REQUEST_IID;
+            const gitlabUrl = process.env.CI_SERVER_URL;
+            if (!gitlabToken || !projectId || !mergeRequestIid || !gitlabUrl) {
+                console.error('Warning: GitLab environment variables not found. Skipping GitLab post.');
+                console.error('Required: CI_JOB_TOKEN, CI_PROJECT_ID, CI_MERGE_REQUEST_IID, CI_SERVER_URL');
+            }
+            else {
+                try {
+                    const gitlab = new GitLabIntegration_1.GitLabIntegration({
+                        token: gitlabToken,
+                        apiUrl: gitlabUrl,
+                    });
+                    await gitlab.postMergeRequestComment(projectId, mergeRequestIid, result.costAnalysis.summary);
+                    console.log('Results posted to GitLab merge request');
+                }
+                catch (error) {
+                    console.error(`Warning: Failed to post to GitLab: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        // Exit with appropriate code based on threshold
+        if (result.thresholdStatus.level === 'error' && !result.thresholdStatus.passed) {
+            console.error('Pipeline failed: Cost threshold exceeded');
+            process.exit(2);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+        }
+        else {
+            console.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+    }
+});
+// Default to compare command for backward compatibility
+program
+    .argument('[base]', 'Path to base CloudFormation template')
+    .argument('[target]', 'Path to target CloudFormation template')
+    .option('--region <region>', 'AWS region', 'eu-central-1')
+    .option('--format <format>', 'Output format: text|json|markdown', 'text')
+    .option('--config <path>', 'Path to configuration file')
+    .action(async (basePath, targetPath, options) => {
+    if (!basePath || !targetPath) {
+        program.help();
+        return;
+    }
+    try {
+        if (!fs.existsSync(basePath)) {
+            console.error(`Error: Base template file not found: ${basePath}`);
+            process.exit(1);
+        }
+        if (!fs.existsSync(targetPath)) {
+            console.error(`Error: Target template file not found: ${targetPath}`);
+            process.exit(1);
+        }
+        const baseTemplate = fs.readFileSync(basePath, 'utf-8');
+        const targetTemplate = fs.readFileSync(targetPath, 'utf-8');
+        const result = await (0, api_1.analyzeCosts)({
+            baseTemplate,
+            targetTemplate,
+            region: options?.region || 'eu-central-1',
+            format: options?.format || 'text',
+        });
+        if (options?.format === 'json') {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else {
+            console.log(result.summary);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(`Error: ${error.message}`);
+        }
+        else {
+            console.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+    }
+});
+program.parse();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\n\nimport * as fs from 'fs';\nimport { Command } from 'commander';\nimport { analyzeCosts } from '../api';\nimport { GitLabIntegration } from '../integrations/GitLabIntegration';\nimport { PipelineOrchestrator } from '../pipeline/PipelineOrchestrator';\n\nconst program = new Command();\n\nprogram\n  .name('cdk-cost-analyzer')\n  .description('Analyze AWS CDK infrastructure changes and provide cost impact summaries')\n  .version('1.0.0');\n\n// Original command for direct template comparison\nprogram\n  .command('compare')\n  .description('Compare two CloudFormation templates')\n  .argument('<base>', 'Path to base CloudFormation template')\n  .argument('<target>', 'Path to target CloudFormation template')\n  .option('--region <region>', 'AWS region', 'eu-central-1')\n  .option('--format <format>', 'Output format: text|json|markdown', 'text')\n  .option('--config <path>', 'Path to configuration file')\n  .action(async (basePath: string, targetPath: string, options: { region: string; format: string; config?: string }) => {\n    try {\n      if (!fs.existsSync(basePath)) {\n        console.error(`Error: Base template file not found: ${basePath}`);\n        process.exit(1);\n      }\n\n      if (!fs.existsSync(targetPath)) {\n        console.error(`Error: Target template file not found: ${targetPath}`);\n        process.exit(1);\n      }\n\n      const baseTemplate = fs.readFileSync(basePath, 'utf-8');\n      const targetTemplate = fs.readFileSync(targetPath, 'utf-8');\n\n      const result = await analyzeCosts({\n        baseTemplate,\n        targetTemplate,\n        region: options.region,\n        format: options.format as 'text' | 'json' | 'markdown',\n      });\n\n      if (options.format === 'json') {\n        console.log(JSON.stringify(result, null, 2));\n      } else {\n        console.log(result.summary);\n      }\n\n      process.exit(0);\n    } catch (error) {\n      if (error instanceof Error) {\n        console.error(`Error: ${error.message}`);\n      } else {\n        console.error(`Error: ${String(error)}`);\n      }\n      process.exit(1);\n    }\n  });\n\n// New pipeline command for CI/CD integration with synthesis\nprogram\n  .command('pipeline')\n  .description('Run cost analysis in CI/CD pipeline with automatic synthesis')\n  .option('--base <path>', 'Path to base template (if not using synthesis)')\n  .option('--target <path>', 'Path to target template (if not using synthesis)')\n  .option('--synth', 'Enable automatic CDK synthesis')\n  .option('--cdk-app-path <path>', 'Path to CDK application directory')\n  .option('--region <region>', 'AWS region', 'eu-central-1')\n  .option('--config <path>', 'Path to configuration file')\n  .option('--environment <env>', 'Environment name for threshold selection')\n  .option('--format <format>', 'Output format: text|json|markdown', 'text')\n  .option('--post-to-gitlab', 'Post results to GitLab merge request')\n  .action(async (options: {\n    base?: string;\n    target?: string;\n    synth?: boolean;\n    cdkAppPath?: string;\n    region: string;\n    config?: string;\n    environment?: string;\n    format: string;\n    postToGitlab?: boolean;\n  }) => {\n    try {\n      // Check AWS credentials\n      if (!process.env.AWS_ACCESS_KEY_ID && !process.env.AWS_PROFILE) {\n        console.error('Error: AWS credentials not configured');\n        console.error('');\n        console.error('Please set AWS credentials using one of:');\n        console.error('  - AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables');\n        console.error('  - AWS_PROFILE environment variable');\n        console.error('  - AWS credentials file (~/.aws/credentials)');\n        console.error('');\n        console.error('For GitLab CI, configure AWS credentials in CI/CD variables:');\n        console.error('  Settings > CI/CD > Variables');\n        console.error('  Add: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION');\n        process.exit(1);\n      }\n\n      const orchestrator = new PipelineOrchestrator();\n\n      const result = await orchestrator.runPipelineAnalysis({\n        baseTemplate: options.base,\n        targetTemplate: options.target,\n        synthesize: options.synth,\n        cdkAppPath: options.cdkAppPath,\n        region: options.region,\n        configPath: options.config,\n        environment: options.environment,\n      });\n\n      // Display results\n      if (options.format === 'json') {\n        console.log(JSON.stringify(result, null, 2));\n      } else {\n        console.log(result.costAnalysis.summary);\n        console.log('');\n\n        // Display threshold status\n        if (result.thresholdStatus.level !== 'none') {\n          console.log('='.repeat(80));\n          console.log('THRESHOLD STATUS');\n          console.log('='.repeat(80));\n          console.log(result.thresholdStatus.message);\n          console.log('');\n\n          if (result.thresholdStatus.recommendations.length > 0) {\n            console.log('Recommendations:');\n            result.thresholdStatus.recommendations.forEach((rec, i) => {\n              console.log(`${i + 1}. ${rec}`);\n            });\n            console.log('');\n          }\n        }\n\n        // Display config summary\n        if (result.configUsed.configPath || result.configUsed.thresholds) {\n          console.log('='.repeat(80));\n          console.log('CONFIGURATION');\n          console.log('='.repeat(80));\n          if (result.configUsed.configPath) {\n            console.log(`Config file: ${result.configUsed.configPath}`);\n          }\n          if (result.configUsed.thresholds) {\n            console.log(`Thresholds: warning=$${result.configUsed.thresholds.warning || 'none'}, error=$${result.configUsed.thresholds.error || 'none'}`);\n            if (result.configUsed.thresholds.environment) {\n              console.log(`Environment: ${result.configUsed.thresholds.environment}`);\n            }\n          }\n          if (result.configUsed.excludedResourceTypes?.length) {\n            console.log(`Excluded resources: ${result.configUsed.excludedResourceTypes.join(', ')}`);\n          }\n          console.log('');\n        }\n      }\n\n      // Post to GitLab if requested\n      if (options.postToGitlab) {\n        const gitlabToken = process.env.GITLAB_TOKEN || process.env.CI_JOB_TOKEN;\n        const projectId = process.env.CI_PROJECT_ID;\n        const mergeRequestIid = process.env.CI_MERGE_REQUEST_IID;\n        const gitlabUrl = process.env.CI_SERVER_URL;\n\n        if (!gitlabToken || !projectId || !mergeRequestIid || !gitlabUrl) {\n          console.error('Warning: GitLab environment variables not found. Skipping GitLab post.');\n          console.error('Required: CI_JOB_TOKEN, CI_PROJECT_ID, CI_MERGE_REQUEST_IID, CI_SERVER_URL');\n        } else {\n          try {\n            const gitlab = new GitLabIntegration({\n              token: gitlabToken,\n              apiUrl: gitlabUrl,\n            });\n            await gitlab.postMergeRequestComment(\n              projectId,\n              mergeRequestIid,\n              result.costAnalysis.summary,\n            );\n            console.log('Results posted to GitLab merge request');\n          } catch (error) {\n            console.error(`Warning: Failed to post to GitLab: ${error instanceof Error ? error.message : String(error)}`);\n          }\n        }\n      }\n\n      // Exit with appropriate code based on threshold\n      if (result.thresholdStatus.level === 'error' && !result.thresholdStatus.passed) {\n        console.error('Pipeline failed: Cost threshold exceeded');\n        process.exit(2);\n      }\n\n      process.exit(0);\n    } catch (error) {\n      if (error instanceof Error) {\n        console.error(`Error: ${error.message}`);\n      } else {\n        console.error(`Error: ${String(error)}`);\n      }\n      process.exit(1);\n    }\n  });\n\n// Default to compare command for backward compatibility\nprogram\n  .argument('[base]', 'Path to base CloudFormation template')\n  .argument('[target]', 'Path to target CloudFormation template')\n  .option('--region <region>', 'AWS region', 'eu-central-1')\n  .option('--format <format>', 'Output format: text|json|markdown', 'text')\n  .option('--config <path>', 'Path to configuration file')\n  .action(async (basePath?: string, targetPath?: string, options?: { region: string; format: string; config?: string }) => {\n    if (!basePath || !targetPath) {\n      program.help();\n      return;\n    }\n\n    try {\n      if (!fs.existsSync(basePath)) {\n        console.error(`Error: Base template file not found: ${basePath}`);\n        process.exit(1);\n      }\n\n      if (!fs.existsSync(targetPath)) {\n        console.error(`Error: Target template file not found: ${targetPath}`);\n        process.exit(1);\n      }\n\n      const baseTemplate = fs.readFileSync(basePath, 'utf-8');\n      const targetTemplate = fs.readFileSync(targetPath, 'utf-8');\n\n      const result = await analyzeCosts({\n        baseTemplate,\n        targetTemplate,\n        region: options?.region || 'eu-central-1',\n        format: (options?.format as 'text' | 'json' | 'markdown') || 'text',\n      });\n\n      if (options?.format === 'json') {\n        console.log(JSON.stringify(result, null, 2));\n      } else {\n        console.log(result.summary);\n      }\n\n      process.exit(0);\n    } catch (error) {\n      if (error instanceof Error) {\n        console.error(`Error: ${error.message}`);\n      } else {\n        console.error(`Error: ${String(error)}`);\n      }\n      process.exit(1);\n    }\n  });\n\nprogram.parse();\n"]}

package/dist/config/ConfigManager.d.ts

@@ -0,0 +1,40 @@
+import { CostAnalyzerConfig, ValidationResult } from './types';
+export declare class ConfigManager {
+    private static readonly CONFIG_FILE_NAMES;
+    /**
+     * Load configuration from file or return default configuration
+     */
+    loadConfig(configPath?: string): Promise<CostAnalyzerConfig>;
+    /**
+     * Validate configuration structure and values
+     */
+    validateConfig(config: CostAnalyzerConfig): ValidationResult;
+    /**
+     * Resolve configuration file path using search order
+     */
+    private resolveConfigPath;
+    /**
+     * Read and parse configuration file (YAML or JSON)
+     */
+    private readConfigFile;
+    /**
+     * Check if file exists
+     */
+    private fileExists;
+    /**
+     * Validate threshold configuration
+     */
+    private validateThresholds;
+    /**
+     * Validate usage assumptions
+     */
+    private validateUsageAssumptions;
+    /**
+     * Get default configuration
+     */
+    private getDefaultConfig;
+    /**
+     * Merge user configuration with defaults
+     */
+    private mergeWithDefaults;
+}

package/dist/config/ConfigManager.js

@@ -0,0 +1,238 @@
+"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.ConfigManager = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const types_1 = require("./types");
+class ConfigManager {
+    static CONFIG_FILE_NAMES = [
+        '.cdk-cost-analyzer.yml',
+        '.cdk-cost-analyzer.yaml',
+        '.cdk-cost-analyzer.json',
+    ];
+    /**
+     * Load configuration from file or return default configuration
+     */
+    async loadConfig(configPath) {
+        try {
+            const resolvedPath = await this.resolveConfigPath(configPath);
+            if (!resolvedPath) {
+                return this.getDefaultConfig();
+            }
+            const config = await this.readConfigFile(resolvedPath);
+            const validation = this.validateConfig(config);
+            if (!validation.valid) {
+                throw new types_1.ConfigurationError('Invalid configuration', resolvedPath, validation.errors);
+            }
+            return this.mergeWithDefaults(config);
+        }
+        catch (error) {
+            if (error instanceof types_1.ConfigurationError) {
+                throw error;
+            }
+            throw new types_1.ConfigurationError(`Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`, configPath || 'unknown', []);
+        }
+    }
+    /**
+     * Validate configuration structure and values
+     */
+    validateConfig(config) {
+        const errors = [];
+        const warnings = [];
+        if (config.thresholds) {
+            this.validateThresholds(config.thresholds, errors, warnings);
+        }
+        if (config.usageAssumptions) {
+            this.validateUsageAssumptions(config.usageAssumptions, errors);
+        }
+        if (config.cache?.durationHours !== undefined) {
+            if (config.cache.durationHours <= 0) {
+                errors.push('cache.durationHours must be positive');
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Resolve configuration file path using search order
+     */
+    async resolveConfigPath(configPath) {
+        if (configPath) {
+            const exists = await this.fileExists(configPath);
+            if (!exists) {
+                throw new Error(`Configuration file not found: ${configPath}`);
+            }
+            return configPath;
+        }
+        // Search in current directory
+        for (const fileName of ConfigManager.CONFIG_FILE_NAMES) {
+            const filePath = path.join(process.cwd(), fileName);
+            if (await this.fileExists(filePath)) {
+                return filePath;
+            }
+        }
+        return null;
+    }
+    /**
+     * Read and parse configuration file (YAML or JSON)
+     */
+    async readConfigFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const ext = path.extname(filePath).toLowerCase();
+        try {
+            if (ext === '.json') {
+                return JSON.parse(content);
+            }
+            else {
+                return yaml.load(content);
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to parse configuration file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Check if file exists
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Validate threshold configuration
+     */
+    validateThresholds(thresholds, errors, warnings) {
+        const validateLevels = (levels, prefix) => {
+            if (levels.warning !== undefined && levels.warning < 0) {
+                errors.push(`${prefix}.warning must be non-negative`);
+            }
+            if (levels.error !== undefined && levels.error < 0) {
+                errors.push(`${prefix}.error must be non-negative`);
+            }
+            if (levels.warning !== undefined &&
+                levels.error !== undefined &&
+                levels.warning > levels.error) {
+                warnings.push(`${prefix}.warning (${levels.warning}) is greater than ${prefix}.error (${levels.error})`);
+            }
+        };
+        if (thresholds.default) {
+            validateLevels(thresholds.default, 'thresholds.default');
+        }
+        if (thresholds.environments) {
+            for (const [env, levels] of Object.entries(thresholds.environments)) {
+                validateLevels(levels, `thresholds.environments.${env}`);
+            }
+        }
+    }
+    /**
+     * Validate usage assumptions
+     */
+    validateUsageAssumptions(assumptions, errors) {
+        const validatePositive = (value, configPath) => {
+            if (value !== undefined && value < 0) {
+                errors.push(`${configPath} must be non-negative`);
+            }
+        };
+        if (assumptions.s3) {
+            validatePositive(assumptions.s3.storageGB, 'usageAssumptions.s3.storageGB');
+            validatePositive(assumptions.s3.getRequests, 'usageAssumptions.s3.getRequests');
+            validatePositive(assumptions.s3.putRequests, 'usageAssumptions.s3.putRequests');
+        }
+        if (assumptions.lambda) {
+            validatePositive(assumptions.lambda.invocationsPerMonth, 'usageAssumptions.lambda.invocationsPerMonth');
+            validatePositive(assumptions.lambda.averageDurationMs, 'usageAssumptions.lambda.averageDurationMs');
+        }
+        if (assumptions.natGateway) {
+            validatePositive(assumptions.natGateway.dataProcessedGB, 'usageAssumptions.natGateway.dataProcessedGB');
+        }
+        if (assumptions.alb) {
+            validatePositive(assumptions.alb.newConnectionsPerSecond, 'usageAssumptions.alb.newConnectionsPerSecond');
+            validatePositive(assumptions.alb.activeConnectionsPerMinute, 'usageAssumptions.alb.activeConnectionsPerMinute');
+            validatePositive(assumptions.alb.processedBytesGB, 'usageAssumptions.alb.processedBytesGB');
+        }
+        if (assumptions.nlb) {
+            validatePositive(assumptions.nlb.newConnectionsPerSecond, 'usageAssumptions.nlb.newConnectionsPerSecond');
+            validatePositive(assumptions.nlb.activeConnectionsPerMinute, 'usageAssumptions.nlb.activeConnectionsPerMinute');
+            validatePositive(assumptions.nlb.processedBytesGB, 'usageAssumptions.nlb.processedBytesGB');
+        }
+        if (assumptions.cloudfront) {
+            validatePositive(assumptions.cloudfront.dataTransferGB, 'usageAssumptions.cloudfront.dataTransferGB');
+            validatePositive(assumptions.cloudfront.requests, 'usageAssumptions.cloudfront.requests');
+        }
+        if (assumptions.apiGateway) {
+            validatePositive(assumptions.apiGateway.requestsPerMonth, 'usageAssumptions.apiGateway.requestsPerMonth');
+        }
+        if (assumptions.vpcEndpoint) {
+            validatePositive(assumptions.vpcEndpoint.dataProcessedGB, 'usageAssumptions.vpcEndpoint.dataProcessedGB');
+        }
+    }
+    /**
+     * Get default configuration
+     */
+    getDefaultConfig() {
+        return {
+            cache: {
+                enabled: true,
+                durationHours: 24,
+            },
+        };
+    }
+    /**
+     * Merge user configuration with defaults
+     */
+    mergeWithDefaults(config) {
+        const defaults = this.getDefaultConfig();
+        return {
+            ...defaults,
+            ...config,
+            cache: {
+                ...defaults.cache,
+                ...config.cache,
+            },
+        };
+    }
+}
+exports.ConfigManager = ConfigManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConfigManager.js","sourceRoot":"","sources":["../../src/config/ConfigManager.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\nimport * as path from 'path';\nimport * as yaml from 'js-yaml';\nimport {\n  CostAnalyzerConfig,\n  ValidationResult,\n  ConfigurationError,\n  ThresholdLevels,\n} from './types';\n\nexport class ConfigManager {\n  private static readonly CONFIG_FILE_NAMES = [\n    '.cdk-cost-analyzer.yml',\n    '.cdk-cost-analyzer.yaml',\n    '.cdk-cost-analyzer.json',\n  ];\n\n  /**\n   * Load configuration from file or return default configuration\n   */\n  async loadConfig(configPath?: string): Promise<CostAnalyzerConfig> {\n    try {\n      const resolvedPath = await this.resolveConfigPath(configPath);\n\n      if (!resolvedPath) {\n        return this.getDefaultConfig();\n      }\n\n      const config = await this.readConfigFile(resolvedPath);\n      const validation = this.validateConfig(config);\n\n      if (!validation.valid) {\n        throw new ConfigurationError(\n          'Invalid configuration',\n          resolvedPath,\n          validation.errors,\n        );\n      }\n\n      return this.mergeWithDefaults(config);\n    } catch (error) {\n      if (error instanceof ConfigurationError) {\n        throw error;\n      }\n      throw new ConfigurationError(\n        `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`,\n        configPath || 'unknown',\n        [],\n      );\n    }\n  }\n\n  /**\n   * Validate configuration structure and values\n   */\n  validateConfig(config: CostAnalyzerConfig): ValidationResult {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n\n    if (config.thresholds) {\n      this.validateThresholds(config.thresholds, errors, warnings);\n    }\n\n    if (config.usageAssumptions) {\n      this.validateUsageAssumptions(config.usageAssumptions, errors);\n    }\n\n    if (config.cache?.durationHours !== undefined) {\n      if (config.cache.durationHours <= 0) {\n        errors.push('cache.durationHours must be positive');\n      }\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n    };\n  }\n\n  /**\n   * Resolve configuration file path using search order\n   */\n  private async resolveConfigPath(configPath?: string): Promise<string | null> {\n    if (configPath) {\n      const exists = await this.fileExists(configPath);\n      if (!exists) {\n        throw new Error(`Configuration file not found: ${configPath}`);\n      }\n      return configPath;\n    }\n\n    // Search in current directory\n    for (const fileName of ConfigManager.CONFIG_FILE_NAMES) {\n      const filePath = path.join(process.cwd(), fileName);\n      if (await this.fileExists(filePath)) {\n        return filePath;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Read and parse configuration file (YAML or JSON)\n   */\n  private async readConfigFile(filePath: string): Promise<CostAnalyzerConfig> {\n    const content = await fs.readFile(filePath, 'utf-8');\n    const ext = path.extname(filePath).toLowerCase();\n\n    try {\n      if (ext === '.json') {\n        return JSON.parse(content);\n      } else {\n        return yaml.load(content) as CostAnalyzerConfig;\n      }\n    } catch (error) {\n      throw new Error(\n        `Failed to parse configuration file: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n\n  /**\n   * Check if file exists\n   */\n  private async fileExists(filePath: string): Promise<boolean> {\n    try {\n      await fs.access(filePath);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Validate threshold configuration\n   */\n  private validateThresholds(\n    thresholds: NonNullable<CostAnalyzerConfig['thresholds']>,\n    errors: string[],\n    warnings: string[],\n  ): void {\n    const validateLevels = (levels: ThresholdLevels, prefix: string) => {\n      if (levels.warning !== undefined && levels.warning < 0) {\n        errors.push(`${prefix}.warning must be non-negative`);\n      }\n      if (levels.error !== undefined && levels.error < 0) {\n        errors.push(`${prefix}.error must be non-negative`);\n      }\n      if (\n        levels.warning !== undefined &&\n        levels.error !== undefined &&\n        levels.warning > levels.error\n      ) {\n        warnings.push(\n          `${prefix}.warning (${levels.warning}) is greater than ${prefix}.error (${levels.error})`,\n        );\n      }\n    };\n\n    if (thresholds.default) {\n      validateLevels(thresholds.default, 'thresholds.default');\n    }\n\n    if (thresholds.environments) {\n      for (const [env, levels] of Object.entries(thresholds.environments)) {\n        validateLevels(levels, `thresholds.environments.${env}`);\n      }\n    }\n  }\n\n  /**\n   * Validate usage assumptions\n   */\n  private validateUsageAssumptions(\n    assumptions: NonNullable<CostAnalyzerConfig['usageAssumptions']>,\n    errors: string[],\n  ): void {\n    const validatePositive = (value: number | undefined, configPath: string) => {\n      if (value !== undefined && value < 0) {\n        errors.push(`${configPath} must be non-negative`);\n      }\n    };\n\n    if (assumptions.s3) {\n      validatePositive(assumptions.s3.storageGB, 'usageAssumptions.s3.storageGB');\n      validatePositive(assumptions.s3.getRequests, 'usageAssumptions.s3.getRequests');\n      validatePositive(assumptions.s3.putRequests, 'usageAssumptions.s3.putRequests');\n    }\n\n    if (assumptions.lambda) {\n      validatePositive(\n        assumptions.lambda.invocationsPerMonth,\n        'usageAssumptions.lambda.invocationsPerMonth',\n      );\n      validatePositive(\n        assumptions.lambda.averageDurationMs,\n        'usageAssumptions.lambda.averageDurationMs',\n      );\n    }\n\n    if (assumptions.natGateway) {\n      validatePositive(\n        assumptions.natGateway.dataProcessedGB,\n        'usageAssumptions.natGateway.dataProcessedGB',\n      );\n    }\n\n    if (assumptions.alb) {\n      validatePositive(\n        assumptions.alb.newConnectionsPerSecond,\n        'usageAssumptions.alb.newConnectionsPerSecond',\n      );\n      validatePositive(\n        assumptions.alb.activeConnectionsPerMinute,\n        'usageAssumptions.alb.activeConnectionsPerMinute',\n      );\n      validatePositive(\n        assumptions.alb.processedBytesGB,\n        'usageAssumptions.alb.processedBytesGB',\n      );\n    }\n\n    if (assumptions.nlb) {\n      validatePositive(\n        assumptions.nlb.newConnectionsPerSecond,\n        'usageAssumptions.nlb.newConnectionsPerSecond',\n      );\n      validatePositive(\n        assumptions.nlb.activeConnectionsPerMinute,\n        'usageAssumptions.nlb.activeConnectionsPerMinute',\n      );\n      validatePositive(\n        assumptions.nlb.processedBytesGB,\n        'usageAssumptions.nlb.processedBytesGB',\n      );\n    }\n\n    if (assumptions.cloudfront) {\n      validatePositive(\n        assumptions.cloudfront.dataTransferGB,\n        'usageAssumptions.cloudfront.dataTransferGB',\n      );\n      validatePositive(\n        assumptions.cloudfront.requests,\n        'usageAssumptions.cloudfront.requests',\n      );\n    }\n\n    if (assumptions.apiGateway) {\n      validatePositive(\n        assumptions.apiGateway.requestsPerMonth,\n        'usageAssumptions.apiGateway.requestsPerMonth',\n      );\n    }\n\n    if (assumptions.vpcEndpoint) {\n      validatePositive(\n        assumptions.vpcEndpoint.dataProcessedGB,\n        'usageAssumptions.vpcEndpoint.dataProcessedGB',\n      );\n    }\n  }\n\n  /**\n   * Get default configuration\n   */\n  private getDefaultConfig(): CostAnalyzerConfig {\n    return {\n      cache: {\n        enabled: true,\n        durationHours: 24,\n      },\n    };\n  }\n\n  /**\n   * Merge user configuration with defaults\n   */\n  private mergeWithDefaults(config: CostAnalyzerConfig): CostAnalyzerConfig {\n    const defaults = this.getDefaultConfig();\n    return {\n      ...defaults,\n      ...config,\n      cache: {\n        ...defaults.cache,\n        ...config.cache,\n      },\n    };\n  }\n}\n"]}

package/dist/config/index.d.ts

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

package/dist/config/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("./ConfigManager"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uZmlnL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxrREFBZ0M7QUFDaEMsMENBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9Db25maWdNYW5hZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuIl19