cdk-cost-analyzer 0.1.1

package/dist/pipeline/PipelineOrchestrator.js

@@ -0,0 +1,191 @@
+"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.PipelineOrchestrator = void 0;
+const fs = __importStar(require("fs/promises"));
+const types_1 = require("./types");
+const ConfigManager_1 = require("../config/ConfigManager");
+const DiffEngine_1 = require("../diff/DiffEngine");
+const TemplateParser_1 = require("../parser/TemplateParser");
+const PricingService_1 = require("../pricing/PricingService");
+const Reporter_1 = require("../reporter/Reporter");
+const SynthesisOrchestrator_1 = require("../synthesis/SynthesisOrchestrator");
+const ThresholdEnforcer_1 = require("../threshold/ThresholdEnforcer");
+class PipelineOrchestrator {
+    configManager;
+    synthesisOrchestrator;
+    thresholdEnforcer;
+    constructor() {
+        this.configManager = new ConfigManager_1.ConfigManager();
+        this.synthesisOrchestrator = new SynthesisOrchestrator_1.SynthesisOrchestrator();
+        this.thresholdEnforcer = new ThresholdEnforcer_1.ThresholdEnforcer();
+    }
+    /**
+     * Run complete pipeline analysis
+     */
+    async runPipelineAnalysis(options) {
+        try {
+            // 1. Load configuration
+            const config = await this.configManager.loadConfig(options.configPath);
+            // 2. Determine template paths
+            let baseTemplatePath;
+            let targetTemplatePath;
+            let synthesisInfo;
+            if (options.synthesize && options.cdkAppPath) {
+                // Synthesize both branches
+                const synthResult = await this.synthesizeBothBranches(options.cdkAppPath, config, options.outputPath);
+                baseTemplatePath = synthResult.baseTemplatePath;
+                targetTemplatePath = synthResult.targetTemplatePath;
+                synthesisInfo = synthResult.synthesisInfo;
+            }
+            else {
+                // Use provided template paths
+                if (!options.baseTemplate || !options.targetTemplate) {
+                    throw new types_1.PipelineError('Either provide template paths or enable synthesis with cdkAppPath', 'configuration');
+                }
+                baseTemplatePath = options.baseTemplate;
+                targetTemplatePath = options.targetTemplate;
+            }
+            // 3. Analyze costs
+            const region = options.region || config.synthesis?.context?.region || 'eu-central-1';
+            const costAnalysis = await this.analyzeCosts(baseTemplatePath, targetTemplatePath, region, config);
+            // 4. Evaluate thresholds
+            const thresholdStatus = this.thresholdEnforcer.evaluateThreshold(costAnalysis.totalDelta, costAnalysis.addedResources, costAnalysis.modifiedResources, config.thresholds, options.environment);
+            // 5. Build config summary
+            const configSummary = this.buildConfigSummary(config, options);
+            return {
+                costAnalysis,
+                thresholdStatus,
+                synthesisInfo,
+                configUsed: configSummary,
+            };
+        }
+        catch (error) {
+            if (error instanceof types_1.PipelineError) {
+                throw error;
+            }
+            throw new types_1.PipelineError(`Pipeline failed: ${error instanceof Error ? error.message : String(error)}`, 'unknown');
+        }
+    }
+    /**
+     * Synthesize both base and target branches
+     */
+    async synthesizeBothBranches(cdkAppPath, config, outputPath) {
+        // For now, just synthesize the current branch
+        // In a full implementation, this would checkout branches and synthesize each
+        const result = await this.synthesisOrchestrator.synthesize({
+            cdkAppPath,
+            outputPath: outputPath || config.synthesis?.outputPath,
+            context: config.synthesis?.context,
+            customCommand: config.synthesis?.customCommand,
+        });
+        if (!result.success) {
+            throw new types_1.PipelineError(`CDK synthesis failed: ${result.error}`, 'synthesis');
+        }
+        // For simplicity, use the first template for both base and target
+        // In production, you'd synthesize different branches
+        return {
+            baseTemplatePath: result.templatePaths[0],
+            targetTemplatePath: result.templatePaths[0],
+            synthesisInfo: {
+                baseStackCount: result.stackNames.length,
+                targetStackCount: result.stackNames.length,
+                baseSynthesisTime: result.duration,
+                targetSynthesisTime: result.duration,
+            },
+        };
+    }
+    /**
+     * Analyze costs between two templates
+     */
+    async analyzeCosts(baseTemplatePath, targetTemplatePath, region, config) {
+        const parser = new TemplateParser_1.TemplateParser();
+        const diffEngine = new DiffEngine_1.DiffEngine();
+        const pricingService = new PricingService_1.PricingService(region, config.usageAssumptions, config.exclusions?.resourceTypes, config.cache);
+        const reporter = new Reporter_1.Reporter();
+        // Read templates
+        const baseTemplateContent = await fs.readFile(baseTemplatePath, 'utf-8');
+        const targetTemplateContent = await fs.readFile(targetTemplatePath, 'utf-8');
+        // Parse templates
+        const baseTemplateObj = parser.parse(baseTemplateContent);
+        const targetTemplateObj = parser.parse(targetTemplateContent);
+        // Diff templates
+        const diff = diffEngine.diff(baseTemplateObj, targetTemplateObj);
+        // Calculate cost delta
+        const costDelta = await pricingService.getCostDelta(diff, region);
+        // Generate report
+        const summary = reporter.generateReport(costDelta, 'text');
+        return {
+            totalDelta: costDelta.totalDelta,
+            currency: costDelta.currency,
+            addedResources: costDelta.addedCosts,
+            removedResources: costDelta.removedCosts,
+            modifiedResources: costDelta.modifiedCosts,
+            summary,
+        };
+    }
+    /**
+     * Build configuration summary
+     */
+    buildConfigSummary(config, options) {
+        const summary = {
+            synthesisEnabled: !!options.synthesize,
+        };
+        if (options.configPath) {
+            summary.configPath = options.configPath;
+        }
+        if (config.thresholds) {
+            const thresholds = options.environment && config.thresholds.environments?.[options.environment]
+                ? config.thresholds.environments[options.environment]
+                : config.thresholds.default;
+            if (thresholds) {
+                summary.thresholds = {
+                    warning: thresholds.warning,
+                    error: thresholds.error,
+                    environment: options.environment,
+                };
+            }
+        }
+        if (config.usageAssumptions) {
+            summary.usageAssumptions = config.usageAssumptions;
+        }
+        if (config.exclusions?.resourceTypes) {
+            summary.excludedResourceTypes = config.exclusions.resourceTypes;
+        }
+        return summary;
+    }
+}
+exports.PipelineOrchestrator = PipelineOrchestrator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PipelineOrchestrator.js","sourceRoot":"","sources":["../../src/pipeline/PipelineOrchestrator.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs/promises';\nimport { PipelineOptions, PipelineResult, PipelineError, ConfigSummary } from './types';\nimport { ConfigManager } from '../config/ConfigManager';\nimport { DiffEngine } from '../diff/DiffEngine';\nimport { TemplateParser } from '../parser/TemplateParser';\nimport { PricingService } from '../pricing/PricingService';\nimport { Reporter } from '../reporter/Reporter';\nimport { SynthesisOrchestrator } from '../synthesis/SynthesisOrchestrator';\nimport { ThresholdEnforcer } from '../threshold/ThresholdEnforcer';\n\nexport class PipelineOrchestrator {\n  private configManager: ConfigManager;\n  private synthesisOrchestrator: SynthesisOrchestrator;\n  private thresholdEnforcer: ThresholdEnforcer;\n\n  constructor() {\n    this.configManager = new ConfigManager();\n    this.synthesisOrchestrator = new SynthesisOrchestrator();\n    this.thresholdEnforcer = new ThresholdEnforcer();\n  }\n\n  /**\n   * Run complete pipeline analysis\n   */\n  async runPipelineAnalysis(options: PipelineOptions): Promise<PipelineResult> {\n    try {\n      // 1. Load configuration\n      const config = await this.configManager.loadConfig(options.configPath);\n\n      // 2. Determine template paths\n      let baseTemplatePath: string;\n      let targetTemplatePath: string;\n      let synthesisInfo;\n\n      if (options.synthesize && options.cdkAppPath) {\n        // Synthesize both branches\n        const synthResult = await this.synthesizeBothBranches(\n          options.cdkAppPath,\n          config,\n          options.outputPath,\n        );\n        baseTemplatePath = synthResult.baseTemplatePath;\n        targetTemplatePath = synthResult.targetTemplatePath;\n        synthesisInfo = synthResult.synthesisInfo;\n      } else {\n        // Use provided template paths\n        if (!options.baseTemplate || !options.targetTemplate) {\n          throw new PipelineError(\n            'Either provide template paths or enable synthesis with cdkAppPath',\n            'configuration',\n          );\n        }\n        baseTemplatePath = options.baseTemplate;\n        targetTemplatePath = options.targetTemplate;\n      }\n\n      // 3. Analyze costs\n      const region = options.region || config.synthesis?.context?.region || 'eu-central-1';\n      const costAnalysis = await this.analyzeCosts(\n        baseTemplatePath,\n        targetTemplatePath,\n        region,\n        config,\n      );\n\n      // 4. Evaluate thresholds\n      const thresholdStatus = this.thresholdEnforcer.evaluateThreshold(\n        costAnalysis.totalDelta,\n        costAnalysis.addedResources,\n        costAnalysis.modifiedResources,\n        config.thresholds,\n        options.environment,\n      );\n\n      // 5. Build config summary\n      const configSummary = this.buildConfigSummary(config, options);\n\n      return {\n        costAnalysis,\n        thresholdStatus,\n        synthesisInfo,\n        configUsed: configSummary,\n      };\n    } catch (error) {\n      if (error instanceof PipelineError) {\n        throw error;\n      }\n      throw new PipelineError(\n        `Pipeline failed: ${error instanceof Error ? error.message : String(error)}`,\n        'unknown',\n      );\n    }\n  }\n\n  /**\n   * Synthesize both base and target branches\n   */\n  private async synthesizeBothBranches(\n    cdkAppPath: string,\n    config: any,\n    outputPath?: string,\n  ): Promise<{\n      baseTemplatePath: string;\n      targetTemplatePath: string;\n      synthesisInfo: any;\n    }> {\n    // For now, just synthesize the current branch\n    // In a full implementation, this would checkout branches and synthesize each\n    const result = await this.synthesisOrchestrator.synthesize({\n      cdkAppPath,\n      outputPath: outputPath || config.synthesis?.outputPath,\n      context: config.synthesis?.context,\n      customCommand: config.synthesis?.customCommand,\n    });\n\n    if (!result.success) {\n      throw new PipelineError(\n        `CDK synthesis failed: ${result.error}`,\n        'synthesis',\n      );\n    }\n\n    // For simplicity, use the first template for both base and target\n    // In production, you'd synthesize different branches\n    return {\n      baseTemplatePath: result.templatePaths[0],\n      targetTemplatePath: result.templatePaths[0],\n      synthesisInfo: {\n        baseStackCount: result.stackNames.length,\n        targetStackCount: result.stackNames.length,\n        baseSynthesisTime: result.duration,\n        targetSynthesisTime: result.duration,\n      },\n    };\n  }\n\n  /**\n   * Analyze costs between two templates\n   */\n  private async analyzeCosts(\n    baseTemplatePath: string,\n    targetTemplatePath: string,\n    region: string,\n    config: any,\n  ): Promise<any> {\n    const parser = new TemplateParser();\n    const diffEngine = new DiffEngine();\n    const pricingService = new PricingService(\n      region,\n      config.usageAssumptions,\n      config.exclusions?.resourceTypes,\n      config.cache,\n    );\n    const reporter = new Reporter();\n\n    // Read templates\n    const baseTemplateContent = await fs.readFile(baseTemplatePath, 'utf-8');\n    const targetTemplateContent = await fs.readFile(targetTemplatePath, 'utf-8');\n\n    // Parse templates\n    const baseTemplateObj = parser.parse(baseTemplateContent);\n    const targetTemplateObj = parser.parse(targetTemplateContent);\n\n    // Diff templates\n    const diff = diffEngine.diff(baseTemplateObj, targetTemplateObj);\n\n    // Calculate cost delta\n    const costDelta = await pricingService.getCostDelta(diff, region);\n\n    // Generate report\n    const summary = reporter.generateReport(costDelta, 'text');\n\n    return {\n      totalDelta: costDelta.totalDelta,\n      currency: costDelta.currency,\n      addedResources: costDelta.addedCosts,\n      removedResources: costDelta.removedCosts,\n      modifiedResources: costDelta.modifiedCosts,\n      summary,\n    };\n  }\n\n  /**\n   * Build configuration summary\n   */\n  private buildConfigSummary(config: any, options: PipelineOptions): ConfigSummary {\n    const summary: ConfigSummary = {\n      synthesisEnabled: !!options.synthesize,\n    };\n\n    if (options.configPath) {\n      summary.configPath = options.configPath;\n    }\n\n    if (config.thresholds) {\n      const thresholds = options.environment && config.thresholds.environments?.[options.environment]\n        ? config.thresholds.environments[options.environment]\n        : config.thresholds.default;\n\n      if (thresholds) {\n        summary.thresholds = {\n          warning: thresholds.warning,\n          error: thresholds.error,\n          environment: options.environment,\n        };\n      }\n    }\n\n    if (config.usageAssumptions) {\n      summary.usageAssumptions = config.usageAssumptions;\n    }\n\n    if (config.exclusions?.resourceTypes) {\n      summary.excludedResourceTypes = config.exclusions.resourceTypes;\n    }\n\n    return summary;\n  }\n}\n"]}

package/dist/pipeline/index.d.ts

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

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

package/dist/pipeline/types.d.ts

@@ -0,0 +1,41 @@
+import { CostAnalysisResult } from '../api/types';
+import { ThresholdEvaluation } from '../threshold/types';
+export interface PipelineOptions {
+    baseTemplate?: string;
+    targetTemplate?: string;
+    baseBranch?: string;
+    targetBranch?: string;
+    cdkAppPath?: string;
+    outputPath?: string;
+    configPath?: string;
+    region?: string;
+    synthesize?: boolean;
+    environment?: string;
+}
+export interface PipelineResult {
+    costAnalysis: CostAnalysisResult;
+    thresholdStatus: ThresholdEvaluation;
+    synthesisInfo?: SynthesisInfo;
+    configUsed: ConfigSummary;
+}
+export interface SynthesisInfo {
+    baseStackCount: number;
+    targetStackCount: number;
+    baseSynthesisTime: number;
+    targetSynthesisTime: number;
+}
+export interface ConfigSummary {
+    configPath?: string;
+    thresholds?: {
+        warning?: number;
+        error?: number;
+        environment?: string;
+    };
+    usageAssumptions?: Record<string, unknown>;
+    excludedResourceTypes?: string[];
+    synthesisEnabled: boolean;
+}
+export declare class PipelineError extends Error {
+    stage: string;
+    constructor(message: string, stage: string);
+}

package/dist/pipeline/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineError = void 0;
+class PipelineError extends Error {
+    stage;
+    constructor(message, stage) {
+        super(message);
+        this.stage = stage;
+        this.name = 'PipelineError';
+    }
+}
+exports.PipelineError = PipelineError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcGlwZWxpbmUvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBMENBLE1BQWEsYUFBYyxTQUFRLEtBQUs7SUFDRjtJQUFwQyxZQUFZLE9BQWUsRUFBUyxLQUFhO1FBQy9DLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQURtQixVQUFLLEdBQUwsS0FBSyxDQUFRO1FBRS9DLElBQUksQ0FBQyxJQUFJLEdBQUcsZUFBZSxDQUFDO0lBQzlCLENBQUM7Q0FDRjtBQUxELHNDQUtDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29zdEFuYWx5c2lzUmVzdWx0IH0gZnJvbSAnLi4vYXBpL3R5cGVzJztcbmltcG9ydCB7IFRocmVzaG9sZEV2YWx1YXRpb24gfSBmcm9tICcuLi90aHJlc2hvbGQvdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBpcGVsaW5lT3B0aW9ucyB7XG4gIGJhc2VUZW1wbGF0ZT86IHN0cmluZztcbiAgdGFyZ2V0VGVtcGxhdGU/OiBzdHJpbmc7XG4gIGJhc2VCcmFuY2g/OiBzdHJpbmc7XG4gIHRhcmdldEJyYW5jaD86IHN0cmluZztcbiAgY2RrQXBwUGF0aD86IHN0cmluZztcbiAgb3V0cHV0UGF0aD86IHN0cmluZztcbiAgY29uZmlnUGF0aD86IHN0cmluZztcbiAgcmVnaW9uPzogc3RyaW5nO1xuICBzeW50aGVzaXplPzogYm9vbGVhbjtcbiAgZW52aXJvbm1lbnQ/OiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGlwZWxpbmVSZXN1bHQge1xuICBjb3N0QW5hbHlzaXM6IENvc3RBbmFseXNpc1Jlc3VsdDtcbiAgdGhyZXNob2xkU3RhdHVzOiBUaHJlc2hvbGRFdmFsdWF0aW9uO1xuICBzeW50aGVzaXNJbmZvPzogU3ludGhlc2lzSW5mbztcbiAgY29uZmlnVXNlZDogQ29uZmlnU3VtbWFyeTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTeW50aGVzaXNJbmZvIHtcbiAgYmFzZVN0YWNrQ291bnQ6IG51bWJlcjtcbiAgdGFyZ2V0U3RhY2tDb3VudDogbnVtYmVyO1xuICBiYXNlU3ludGhlc2lzVGltZTogbnVtYmVyO1xuICB0YXJnZXRTeW50aGVzaXNUaW1lOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ29uZmlnU3VtbWFyeSB7XG4gIGNvbmZpZ1BhdGg/OiBzdHJpbmc7XG4gIHRocmVzaG9sZHM/OiB7XG4gICAgd2FybmluZz86IG51bWJlcjtcbiAgICBlcnJvcj86IG51bWJlcjtcbiAgICBlbnZpcm9ubWVudD86IHN0cmluZztcbiAgfTtcbiAgdXNhZ2VBc3N1bXB0aW9ucz86IFJlY29yZDxzdHJpbmcsIHVua25vd24+O1xuICBleGNsdWRlZFJlc291cmNlVHlwZXM/OiBzdHJpbmdbXTtcbiAgc3ludGhlc2lzRW5hYmxlZDogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGNsYXNzIFBpcGVsaW5lRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZywgcHVibGljIHN0YWdlOiBzdHJpbmcpIHtcbiAgICBzdXBlcihtZXNzYWdlKTtcbiAgICB0aGlzLm5hbWUgPSAnUGlwZWxpbmVFcnJvcic7XG4gIH1cbn1cbiJdfQ==

package/dist/pricing/CacheManager.d.ts

@@ -0,0 +1,75 @@
+import { PriceQueryParams } from './types';
+export interface CachedPriceEntry {
+    price: number;
+    timestamp: number;
+}
+export interface CacheMetadata {
+    entries: Record<string, CachedPriceEntry>;
+}
+/**
+ * Manages persistent caching of pricing data to reduce AWS API calls
+ * and improve performance across pipeline runs.
+ */
+export declare class CacheManager {
+    private cacheDir;
+    private cacheDurationMs;
+    private metadata;
+    private metadataPath;
+    /**
+     * Creates a new CacheManager instance
+     * @param cacheDir Directory to store cache files (default: .cdk-cost-analyzer-cache)
+     * @param cacheDurationHours Duration in hours before cache entries expire (default: 24)
+     */
+    constructor(cacheDir?: string, cacheDurationHours?: number);
+    /**
+     * Retrieves a cached price if it exists and is still fresh
+     * @param params Price query parameters
+     * @returns Cached price or null if not found or expired
+     */
+    getCachedPrice(params: PriceQueryParams): number | null;
+    /**
+     * Stores a price in the cache with current timestamp
+     * @param params Price query parameters
+     * @param price Price value to cache
+     */
+    setCachedPrice(params: PriceQueryParams, price: number): void;
+    /**
+     * Checks if a cached price exists and is still fresh
+     * @param params Price query parameters
+     * @returns true if fresh cache entry exists
+     */
+    hasFreshCache(params: PriceQueryParams): boolean;
+    /**
+     * Clears all cached entries
+     */
+    clearCache(): void;
+    /**
+     * Gets cache statistics
+     * @returns Object with cache statistics
+     */
+    getCacheStats(): {
+        totalEntries: number;
+        freshEntries: number;
+        staleEntries: number;
+    };
+    /**
+     * Removes stale cache entries
+     */
+    pruneStaleEntries(): void;
+    /**
+     * Generates a cache key from price query parameters
+     */
+    private getCacheKey;
+    /**
+     * Ensures the cache directory exists
+     */
+    private ensureCacheDirectory;
+    /**
+     * Loads cache metadata from disk
+     */
+    private loadMetadata;
+    /**
+     * Saves cache metadata to disk
+     */
+    private saveMetadata;
+}

package/dist/pricing/CacheManager.js

@@ -0,0 +1,195 @@
+"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.CacheManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Manages persistent caching of pricing data to reduce AWS API calls
+ * and improve performance across pipeline runs.
+ */
+class CacheManager {
+    cacheDir;
+    cacheDurationMs;
+    metadata;
+    metadataPath;
+    /**
+     * Creates a new CacheManager instance
+     * @param cacheDir Directory to store cache files (default: .cdk-cost-analyzer-cache)
+     * @param cacheDurationHours Duration in hours before cache entries expire (default: 24)
+     */
+    constructor(cacheDir = '.cdk-cost-analyzer-cache', cacheDurationHours = 24) {
+        this.cacheDir = cacheDir;
+        this.cacheDurationMs = cacheDurationHours * 60 * 60 * 1000;
+        this.metadataPath = path.join(this.cacheDir, 'metadata.json');
+        this.metadata = { entries: {} };
+        this.ensureCacheDirectory();
+        this.loadMetadata();
+    }
+    /**
+     * Retrieves a cached price if it exists and is still fresh
+     * @param params Price query parameters
+     * @returns Cached price or null if not found or expired
+     */
+    getCachedPrice(params) {
+        const cacheKey = this.getCacheKey(params);
+        const entry = this.metadata.entries[cacheKey];
+        if (!entry) {
+            return null;
+        }
+        const now = Date.now();
+        const age = now - entry.timestamp;
+        if (age > this.cacheDurationMs) {
+            // Cache entry is stale
+            delete this.metadata.entries[cacheKey];
+            this.saveMetadata();
+            return null;
+        }
+        return entry.price;
+    }
+    /**
+     * Stores a price in the cache with current timestamp
+     * @param params Price query parameters
+     * @param price Price value to cache
+     */
+    setCachedPrice(params, price) {
+        const cacheKey = this.getCacheKey(params);
+        this.metadata.entries[cacheKey] = {
+            price,
+            timestamp: Date.now(),
+        };
+        this.saveMetadata();
+    }
+    /**
+     * Checks if a cached price exists and is still fresh
+     * @param params Price query parameters
+     * @returns true if fresh cache entry exists
+     */
+    hasFreshCache(params) {
+        return this.getCachedPrice(params) !== null;
+    }
+    /**
+     * Clears all cached entries
+     */
+    clearCache() {
+        this.metadata = { entries: {} };
+        this.saveMetadata();
+    }
+    /**
+     * Gets cache statistics
+     * @returns Object with cache statistics
+     */
+    getCacheStats() {
+        const now = Date.now();
+        let freshEntries = 0;
+        let staleEntries = 0;
+        for (const entry of Object.values(this.metadata.entries)) {
+            const age = now - entry.timestamp;
+            if (age <= this.cacheDurationMs) {
+                freshEntries++;
+            }
+            else {
+                staleEntries++;
+            }
+        }
+        return {
+            totalEntries: Object.keys(this.metadata.entries).length,
+            freshEntries,
+            staleEntries,
+        };
+    }
+    /**
+     * Removes stale cache entries
+     */
+    pruneStaleEntries() {
+        const now = Date.now();
+        const freshEntries = {};
+        for (const [key, entry] of Object.entries(this.metadata.entries)) {
+            const age = now - entry.timestamp;
+            if (age <= this.cacheDurationMs) {
+                freshEntries[key] = entry;
+            }
+        }
+        this.metadata.entries = freshEntries;
+        this.saveMetadata();
+    }
+    /**
+     * Generates a cache key from price query parameters
+     */
+    getCacheKey(params) {
+        const filterStr = params.filters
+            .map((f) => `${f.field}:${f.value}`)
+            .sort()
+            .join('|');
+        return `${params.serviceCode}:${params.region}:${filterStr}`;
+    }
+    /**
+     * Ensures the cache directory exists
+     */
+    ensureCacheDirectory() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    /**
+     * Loads cache metadata from disk
+     */
+    loadMetadata() {
+        try {
+            if (fs.existsSync(this.metadataPath)) {
+                const data = fs.readFileSync(this.metadataPath, 'utf-8');
+                this.metadata = JSON.parse(data);
+            }
+        }
+        catch (error) {
+            // If metadata is corrupted, start fresh
+            this.metadata = { entries: {} };
+        }
+    }
+    /**
+     * Saves cache metadata to disk
+     */
+    saveMetadata() {
+        try {
+            fs.writeFileSync(this.metadataPath, JSON.stringify(this.metadata, null, 2), 'utf-8');
+        }
+        catch (error) {
+            // Silently fail if we can't write cache - not critical
+            console.warn(`Failed to save cache metadata: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+exports.CacheManager = CacheManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CacheManager.js","sourceRoot":"","sources":["../../src/pricing/CacheManager.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { PriceQueryParams } from './types';\n\nexport interface CachedPriceEntry {\n  price: number;\n  timestamp: number;\n}\n\nexport interface CacheMetadata {\n  entries: Record<string, CachedPriceEntry>;\n}\n\n/**\n * Manages persistent caching of pricing data to reduce AWS API calls\n * and improve performance across pipeline runs.\n */\nexport class CacheManager {\n  private cacheDir: string;\n  private cacheDurationMs: number;\n  private metadata: CacheMetadata;\n  private metadataPath: string;\n\n  /**\n   * Creates a new CacheManager instance\n   * @param cacheDir Directory to store cache files (default: .cdk-cost-analyzer-cache)\n   * @param cacheDurationHours Duration in hours before cache entries expire (default: 24)\n   */\n  constructor(\n    cacheDir: string = '.cdk-cost-analyzer-cache',\n    cacheDurationHours: number = 24,\n  ) {\n    this.cacheDir = cacheDir;\n    this.cacheDurationMs = cacheDurationHours * 60 * 60 * 1000;\n    this.metadataPath = path.join(this.cacheDir, 'metadata.json');\n    this.metadata = { entries: {} };\n    this.ensureCacheDirectory();\n    this.loadMetadata();\n  }\n\n  /**\n   * Retrieves a cached price if it exists and is still fresh\n   * @param params Price query parameters\n   * @returns Cached price or null if not found or expired\n   */\n  getCachedPrice(params: PriceQueryParams): number | null {\n    const cacheKey = this.getCacheKey(params);\n    const entry = this.metadata.entries[cacheKey];\n\n    if (!entry) {\n      return null;\n    }\n\n    const now = Date.now();\n    const age = now - entry.timestamp;\n\n    if (age > this.cacheDurationMs) {\n      // Cache entry is stale\n      delete this.metadata.entries[cacheKey];\n      this.saveMetadata();\n      return null;\n    }\n\n    return entry.price;\n  }\n\n  /**\n   * Stores a price in the cache with current timestamp\n   * @param params Price query parameters\n   * @param price Price value to cache\n   */\n  setCachedPrice(params: PriceQueryParams, price: number): void {\n    const cacheKey = this.getCacheKey(params);\n    this.metadata.entries[cacheKey] = {\n      price,\n      timestamp: Date.now(),\n    };\n    this.saveMetadata();\n  }\n\n  /**\n   * Checks if a cached price exists and is still fresh\n   * @param params Price query parameters\n   * @returns true if fresh cache entry exists\n   */\n  hasFreshCache(params: PriceQueryParams): boolean {\n    return this.getCachedPrice(params) !== null;\n  }\n\n  /**\n   * Clears all cached entries\n   */\n  clearCache(): void {\n    this.metadata = { entries: {} };\n    this.saveMetadata();\n  }\n\n  /**\n   * Gets cache statistics\n   * @returns Object with cache statistics\n   */\n  getCacheStats(): {\n    totalEntries: number;\n    freshEntries: number;\n    staleEntries: number;\n  } {\n    const now = Date.now();\n    let freshEntries = 0;\n    let staleEntries = 0;\n\n    for (const entry of Object.values(this.metadata.entries)) {\n      const age = now - entry.timestamp;\n      if (age <= this.cacheDurationMs) {\n        freshEntries++;\n      } else {\n        staleEntries++;\n      }\n    }\n\n    return {\n      totalEntries: Object.keys(this.metadata.entries).length,\n      freshEntries,\n      staleEntries,\n    };\n  }\n\n  /**\n   * Removes stale cache entries\n   */\n  pruneStaleEntries(): void {\n    const now = Date.now();\n    const freshEntries: Record<string, CachedPriceEntry> = {};\n\n    for (const [key, entry] of Object.entries(this.metadata.entries)) {\n      const age = now - entry.timestamp;\n      if (age <= this.cacheDurationMs) {\n        freshEntries[key] = entry;\n      }\n    }\n\n    this.metadata.entries = freshEntries;\n    this.saveMetadata();\n  }\n\n  /**\n   * Generates a cache key from price query parameters\n   */\n  private getCacheKey(params: PriceQueryParams): string {\n    const filterStr = params.filters\n      .map((f) => `${f.field}:${f.value}`)\n      .sort()\n      .join('|');\n    return `${params.serviceCode}:${params.region}:${filterStr}`;\n  }\n\n  /**\n   * Ensures the cache directory exists\n   */\n  private ensureCacheDirectory(): void {\n    if (!fs.existsSync(this.cacheDir)) {\n      fs.mkdirSync(this.cacheDir, { recursive: true });\n    }\n  }\n\n  /**\n   * Loads cache metadata from disk\n   */\n  private loadMetadata(): void {\n    try {\n      if (fs.existsSync(this.metadataPath)) {\n        const data = fs.readFileSync(this.metadataPath, 'utf-8');\n        this.metadata = JSON.parse(data);\n      }\n    } catch (error) {\n      // If metadata is corrupted, start fresh\n      this.metadata = { entries: {} };\n    }\n  }\n\n  /**\n   * Saves cache metadata to disk\n   */\n  private saveMetadata(): void {\n    try {\n      fs.writeFileSync(\n        this.metadataPath,\n        JSON.stringify(this.metadata, null, 2),\n        'utf-8',\n      );\n    } catch (error) {\n      // Silently fail if we can't write cache - not critical\n      console.warn(\n        `Failed to save cache metadata: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n  }\n}\n"]}

package/dist/pricing/PricingClient.d.ts

@@ -0,0 +1,17 @@
+import { PricingClient as AWSPricingClient } from '@aws-sdk/client-pricing';
+import { CacheManager } from './CacheManager';
+import { PricingClient as IPricingClient, PriceQueryParams } from './types';
+export declare class PricingClient implements IPricingClient {
+    private cache;
+    private client;
+    private cacheManager?;
+    constructor(region?: string, cacheManager?: CacheManager, awsClient?: AWSPricingClient);
+    /**
+     * Clean up resources and connections
+     */
+    destroy(): void;
+    getPrice(params: PriceQueryParams): Promise<number | null>;
+    private fetchPriceWithRetry;
+    private fetchPrice;
+    private getCacheKey;
+}