infra-cost 0.1.0 → 0.2.0

package/dist/demo/test-enhanced-ui.js

@@ -0,0 +1,1662 @@
+#!/usr/bin/env node
+
+// src/demo/test-enhanced-ui.ts
+import chalk2 from "chalk";
+
+// src/visualization/terminal-ui.ts
+import Table from "cli-table3";
+import chalk from "chalk";
+import cliProgress from "cli-progress";
+import moment from "moment";
+var TerminalUIEngine = class {
+  constructor() {
+    this.progressBar = null;
+  }
+  /**
+   * Creates a formatted table with enhanced styling
+   */
+  createTable(columns, rows) {
+    const table = new Table({
+      head: columns.map((col) => chalk.bold(col.header)),
+      colWidths: columns.map((col) => col.width || 20),
+      colAligns: columns.map((col) => col.align || "left"),
+      style: {
+        head: [],
+        border: [],
+        compact: false
+      },
+      chars: {
+        "top": "\u2500",
+        "top-mid": "\u252C",
+        "top-left": "\u250C",
+        "top-right": "\u2510",
+        "bottom": "\u2500",
+        "bottom-mid": "\u2534",
+        "bottom-left": "\u2514",
+        "bottom-right": "\u2518",
+        "left": "\u2502",
+        "left-mid": "\u251C",
+        "mid": "\u2500",
+        "mid-mid": "\u253C",
+        "right": "\u2502",
+        "right-mid": "\u2524",
+        "middle": "\u2502"
+      }
+    });
+    rows.forEach((row) => {
+      const formattedRow = columns.map((col, index) => {
+        const value = Object.values(row)[index];
+        const colorKey = col.color;
+        if (colorKey && typeof value === "string") {
+          return chalk[colorKey](value);
+        }
+        return String(value);
+      });
+      table.push(formattedRow);
+    });
+    return table.toString();
+  }
+  /**
+   * Creates a cost breakdown table with rich formatting
+   * Optimized for large datasets with pagination and filtering
+   */
+  createCostTable(costBreakdown, options = {
+    showPercentages: true,
+    highlightTop: 5,
+    currency: "USD",
+    compact: false
+  }) {
+    const { totals, totalsByService } = costBreakdown;
+    let output = "\n" + chalk.bold.cyan("\u{1F4B0} Cost Analysis Summary") + "\n";
+    output += "\u2550".repeat(50) + "\n\n";
+    const summaryColumns = [
+      { header: "Period", width: 15, align: "left", color: "cyan" },
+      { header: "Cost", width: 15, align: "right", color: "yellow" },
+      { header: "Change", width: 20, align: "right" }
+    ];
+    const summaryRows = [
+      {
+        period: "Yesterday",
+        cost: this.formatCurrency(totals.yesterday, options.currency),
+        change: ""
+      },
+      {
+        period: "Last 7 Days",
+        cost: this.formatCurrency(totals.last7Days, options.currency),
+        change: this.calculateChange(totals.last7Days, totals.yesterday * 7)
+      },
+      {
+        period: "This Month",
+        cost: this.formatCurrency(totals.thisMonth, options.currency),
+        change: this.calculateChange(totals.thisMonth, totals.lastMonth)
+      },
+      {
+        period: "Last Month",
+        cost: this.formatCurrency(totals.lastMonth, options.currency),
+        change: ""
+      }
+    ];
+    output += this.createTable(summaryColumns, summaryRows) + "\n\n";
+    output += chalk.bold.cyan("\u{1F4CA} Service Breakdown (This Month)") + "\n";
+    output += "\u2550".repeat(50) + "\n\n";
+    const allServiceEntries = Object.entries(totalsByService.thisMonth);
+    const significantServices = allServiceEntries.filter(([_, cost]) => cost > 0.01).sort(([, a], [, b]) => b - a);
+    const maxDisplay = options.highlightTop || 15;
+    const serviceEntries = significantServices.slice(0, maxDisplay);
+    if (allServiceEntries.length > maxDisplay) {
+      const hiddenServices = allServiceEntries.length - maxDisplay;
+      const hiddenCost = significantServices.slice(maxDisplay).reduce((sum, [_, cost]) => sum + cost, 0);
+      if (hiddenCost > 0) {
+        output += chalk.gray(`Showing top ${maxDisplay} of ${allServiceEntries.length} services `) + chalk.gray(`(${hiddenServices} services with $${hiddenCost.toFixed(2)} hidden)
+
+`);
+      }
+    }
+    const serviceColumns = [
+      { header: "Service", width: 25, align: "left", color: "blue" },
+      { header: "Cost", width: 15, align: "right", color: "yellow" },
+      { header: "Share", width: 10, align: "right" },
+      { header: "Trend", width: 15, align: "center" }
+    ];
+    const serviceRows = serviceEntries.map(([service, cost]) => {
+      const share = (cost / totals.thisMonth * 100).toFixed(1);
+      const lastMonthCost = totalsByService.lastMonth[service] || 0;
+      const trend = this.getTrendIndicator(cost, lastMonthCost);
+      return {
+        service,
+        cost: this.formatCurrency(cost, options.currency),
+        share: `${share}%`,
+        trend
+      };
+    });
+    output += this.createTable(serviceColumns, serviceRows);
+    return output;
+  }
+  /**
+   * Creates ASCII trend chart for cost visualization
+   */
+  createTrendChart(trendData, options = {
+    width: 60,
+    showLabels: true,
+    currency: "USD"
+  }) {
+    if (!trendData || trendData.length === 0) {
+      return chalk.red("No trend data available");
+    }
+    let output = "\n" + chalk.bold.cyan("\u{1F4C8} Cost Trend Analysis") + "\n";
+    output += "\u2550".repeat(50) + "\n\n";
+    const maxCost = Math.max(...trendData.map((d) => d.actualCost));
+    const minCost = Math.min(...trendData.map((d) => d.actualCost));
+    const range = maxCost - minCost;
+    trendData.forEach((data, index) => {
+      const normalizedValue = range > 0 ? (data.actualCost - minCost) / range : 0.5;
+      const barLength = Math.round(normalizedValue * options.width);
+      const bar = "\u2588".repeat(barLength) + "\u2591".repeat(options.width - barLength);
+      const coloredBar = this.colorizeBar(bar, normalizedValue, options.colorThreshold);
+      const period = moment(data.period).format("MMM YYYY");
+      const cost = this.formatCurrency(data.actualCost, options.currency);
+      const change = data.changeFromPrevious ? this.formatChangeIndicator(data.changeFromPrevious.percentage) : "";
+      output += `${period.padEnd(10)} ${coloredBar} ${cost.padStart(10)} ${change}
+`;
+    });
+    output += "\n" + "\u2500".repeat(options.width + 25) + "\n";
+    output += `Range: ${this.formatCurrency(minCost, options.currency)} - ${this.formatCurrency(maxCost, options.currency)}
+`;
+    return output;
+  }
+  /**
+   * Creates a progress bar for long-running operations
+   */
+  startProgress(label, total = 100) {
+    if (this.progressBar) {
+      this.progressBar.stop();
+    }
+    this.progressBar = new cliProgress.SingleBar({
+      format: `${chalk.cyan(label)} ${chalk.cyan("[")}${chalk.yellow("{bar}")}${chalk.cyan("]")} {percentage}% | ETA: {eta}s | {value}/{total}`,
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      hideCursor: true
+    });
+    this.progressBar.start(total, 0);
+  }
+  /**
+   * Updates progress bar
+   */
+  updateProgress(value, payload) {
+    if (this.progressBar) {
+      this.progressBar.update(value, payload);
+    }
+  }
+  /**
+   * Stops and clears progress bar
+   */
+  stopProgress() {
+    if (this.progressBar) {
+      this.progressBar.stop();
+      this.progressBar = null;
+    }
+  }
+  /**
+   * Creates a cost anomaly alert box
+   */
+  createAnomalyAlert(anomalies) {
+    if (anomalies.length === 0) {
+      return chalk.green("\u2705 No cost anomalies detected");
+    }
+    let output = "\n" + chalk.bold.red("\u{1F6A8} Cost Anomalies Detected") + "\n";
+    output += "\u2550".repeat(50) + "\n\n";
+    anomalies.forEach((anomaly) => {
+      const severityColor = this.getSeverityColor(anomaly.severity);
+      const icon = this.getSeverityIcon(anomaly.severity);
+      output += chalk[severityColor](`${icon} ${anomaly.date}
+`);
+      output += `   Expected: ${this.formatCurrency(anomaly.expectedCost, "USD")}
+`;
+      output += `   Actual:   ${this.formatCurrency(anomaly.actualCost, "USD")}
+`;
+      output += `   Deviation: ${anomaly.deviation > 0 ? "+" : ""}${anomaly.deviation.toFixed(1)}%
+`;
+      if (anomaly.description) {
+        output += `   ${chalk.gray(anomaly.description)}
+`;
+      }
+      output += "\n";
+    });
+    return output;
+  }
+  /**
+   * Creates a fancy header with branding
+   */
+  createHeader(title, subtitle) {
+    const width = 60;
+    let output = "\n";
+    output += chalk.cyan("\u250C" + "\u2500".repeat(width - 2) + "\u2510") + "\n";
+    const titlePadding = Math.floor((width - title.length - 4) / 2);
+    output += chalk.cyan("\u2502") + " ".repeat(titlePadding) + chalk.bold.white(title) + " ".repeat(width - title.length - titlePadding - 2) + chalk.cyan("\u2502") + "\n";
+    if (subtitle) {
+      const subtitlePadding = Math.floor((width - subtitle.length - 4) / 2);
+      output += chalk.cyan("\u2502") + " ".repeat(subtitlePadding) + chalk.gray(subtitle) + " ".repeat(width - subtitle.length - subtitlePadding - 2) + chalk.cyan("\u2502") + "\n";
+    }
+    output += chalk.cyan("\u2514" + "\u2500".repeat(width - 2) + "\u2518") + "\n\n";
+    return output;
+  }
+  // Helper methods
+  formatCurrency(amount, currency) {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency,
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    }).format(amount);
+  }
+  calculateChange(current, previous) {
+    if (previous === 0)
+      return "";
+    const change = (current - previous) / previous * 100;
+    const changeStr = `${change >= 0 ? "+" : ""}${change.toFixed(1)}%`;
+    if (change > 0) {
+      return chalk.red(`\u2197 ${changeStr}`);
+    } else if (change < 0) {
+      return chalk.green(`\u2198 ${changeStr}`);
+    } else {
+      return chalk.gray("\u2192 0.0%");
+    }
+  }
+  getTrendIndicator(current, previous) {
+    if (previous === 0)
+      return chalk.gray("\u2500");
+    const change = (current - previous) / previous * 100;
+    if (change > 10)
+      return chalk.red("\u2197\u2197");
+    if (change > 0)
+      return chalk.yellow("\u2197");
+    if (change < -10)
+      return chalk.green("\u2198\u2198");
+    if (change < 0)
+      return chalk.green("\u2198");
+    return chalk.gray("\u2192");
+  }
+  colorizeBar(bar, normalizedValue, threshold) {
+    const thresholdValue = threshold || 0.7;
+    if (normalizedValue > thresholdValue) {
+      return chalk.red(bar);
+    } else if (normalizedValue > 0.4) {
+      return chalk.yellow(bar);
+    } else {
+      return chalk.green(bar);
+    }
+  }
+  formatChangeIndicator(percentage) {
+    const indicator = percentage >= 0 ? "\u2197" : "\u2198";
+    const color = percentage >= 0 ? "red" : "green";
+    const sign = percentage >= 0 ? "+" : "";
+    return chalk[color](`${indicator} ${sign}${percentage.toFixed(1)}%`);
+  }
+  getSeverityColor(severity) {
+    switch (severity.toLowerCase()) {
+      case "critical":
+        return "red";
+      case "high":
+        return "red";
+      case "medium":
+        return "yellow";
+      case "low":
+        return "cyan";
+      default:
+        return "gray";
+    }
+  }
+  getSeverityIcon(severity) {
+    switch (severity.toLowerCase()) {
+      case "critical":
+        return "\u{1F534}";
+      case "high":
+        return "\u{1F7E0}";
+      case "medium":
+        return "\u{1F7E1}";
+      case "low":
+        return "\u{1F535}";
+      default:
+        return "\u26AA";
+    }
+  }
+};
+
+// src/demo/demo-data-generator.ts
+var DemoDataGenerator = class {
+  /**
+   * Generate sample account information
+   */
+  static generateAccountInfo() {
+    return {
+      id: "123456789012",
+      name: "Demo Production Account",
+      provider: "aws" /* AWS */
+    };
+  }
+  /**
+   * Generate realistic cost breakdown data
+   */
+  static generateCostBreakdown() {
+    const services = [
+      "Amazon EC2-Instance",
+      "Amazon S3",
+      "Amazon RDS",
+      "AWS Lambda",
+      "Amazon CloudFront",
+      "Amazon EBS",
+      "Amazon VPC",
+      "Amazon Route 53",
+      "AWS Application Load Balancer",
+      "Amazon ElastiCache",
+      "Amazon SES",
+      "Amazon CloudWatch",
+      "AWS Data Transfer",
+      "Amazon DynamoDB"
+    ];
+    const generateServiceCosts = (baseMultiplier) => {
+      const costs = {};
+      services.forEach((service) => {
+        const baseCost = Math.random() * 1e3 * baseMultiplier;
+        const serviceMultiplier = this.getServiceMultiplier(service);
+        costs[service] = Math.round(baseCost * serviceMultiplier * 100) / 100;
+      });
+      return costs;
+    };
+    const lastMonth = generateServiceCosts(1);
+    const thisMonth = generateServiceCosts(0.85);
+    const last7Days = generateServiceCosts(0.2);
+    const yesterday = generateServiceCosts(0.03);
+    return {
+      totals: {
+        lastMonth: Object.values(lastMonth).reduce((sum, cost) => sum + cost, 0),
+        thisMonth: Object.values(thisMonth).reduce((sum, cost) => sum + cost, 0),
+        last7Days: Object.values(last7Days).reduce((sum, cost) => sum + cost, 0),
+        yesterday: Object.values(yesterday).reduce((sum, cost) => sum + cost, 0)
+      },
+      totalsByService: {
+        lastMonth,
+        thisMonth,
+        last7Days,
+        yesterday
+      }
+    };
+  }
+  /**
+   * Generate trend analysis data for the last 6 months
+   */
+  static generateTrendAnalysis() {
+    var _a;
+    const months = 6;
+    const trendData = [];
+    for (let i = months - 1; i >= 0; i--) {
+      const date = /* @__PURE__ */ new Date();
+      date.setMonth(date.getMonth() - i);
+      const baselineCost = 3500;
+      const seasonalFactor = 1 + 0.2 * Math.sin(date.getMonth() / 12 * 2 * Math.PI);
+      const trendFactor = 1 + (months - i - 1) * 0.05;
+      const randomVariation = 0.9 + Math.random() * 0.2;
+      const actualCost = baselineCost * seasonalFactor * trendFactor * randomVariation;
+      const previousCost = i === months - 1 ? actualCost * 0.95 : ((_a = trendData[i - 1]) == null ? void 0 : _a.actualCost) || actualCost;
+      trendData.push({
+        period: date.toISOString().substring(0, 7),
+        // YYYY-MM format
+        actualCost: Math.round(actualCost * 100) / 100,
+        forecastedCost: actualCost * (0.95 + Math.random() * 0.1),
+        budgetLimit: 4e3,
+        previousPeriodCost: previousCost,
+        changeFromPrevious: {
+          amount: actualCost - previousCost,
+          percentage: (actualCost - previousCost) / previousCost * 100
+        }
+      });
+    }
+    const topServices = [
+      { serviceName: "Amazon EC2-Instance", cost: 1250.8, percentage: 32.1, trend: "INCREASING" },
+      { serviceName: "Amazon RDS", cost: 890.45, percentage: 22.9, trend: "STABLE" },
+      { serviceName: "Amazon S3", cost: 420.3, percentage: 10.8, trend: "DECREASING" },
+      { serviceName: "AWS Lambda", cost: 380.7, percentage: 9.8, trend: "INCREASING" },
+      { serviceName: "Amazon CloudFront", cost: 220.15, percentage: 5.7, trend: "STABLE" }
+    ];
+    const costAnomalies = [
+      {
+        date: new Date(Date.now() - 5 * 24 * 60 * 60 * 1e3).toISOString().substring(0, 10),
+        actualCost: 4850.3,
+        expectedCost: 3200.5,
+        deviation: 51.6,
+        severity: "HIGH",
+        possibleCause: "EC2 instance scale-out event",
+        description: "Unusual spike in EC2 costs detected during weekend scaling event"
+      },
+      {
+        date: new Date(Date.now() - 12 * 24 * 60 * 60 * 1e3).toISOString().substring(0, 10),
+        actualCost: 2100.8,
+        expectedCost: 3100.2,
+        deviation: -32.2,
+        severity: "MEDIUM",
+        possibleCause: "Scheduled maintenance window",
+        description: "Lower than expected costs during planned maintenance"
+      }
+    ];
+    return {
+      provider: "aws" /* AWS */,
+      timeRange: {
+        start: trendData[0].period + "-01",
+        end: trendData[trendData.length - 1].period + "-28"
+      },
+      granularity: "MONTHLY",
+      trendData,
+      totalCost: trendData.reduce((sum, data) => sum + data.actualCost, 0),
+      averageDailyCost: trendData[trendData.length - 1].actualCost / 30,
+      projectedMonthlyCost: trendData[trendData.length - 1].actualCost * 1.05,
+      avgMonthOverMonthGrowth: 5.2,
+      topServices,
+      costAnomalies,
+      analytics: {
+        insights: [
+          "EC2 costs have increased by 15% over the last 3 months due to increased workload",
+          "S3 storage costs decreased by 8% after implementing lifecycle policies",
+          "Lambda usage shows steady growth pattern aligned with application scaling",
+          "RDS costs remain stable with good resource utilization",
+          "CloudFront costs show seasonal variation with higher usage in Q4"
+        ],
+        recommendations: [
+          "Consider Reserved Instances for EC2 to reduce costs by up to 30%",
+          "Implement automated S3 lifecycle management for additional savings",
+          "Review Lambda memory allocation for cost optimization",
+          "Consider RDS instance rightsizing based on utilization metrics"
+        ],
+        volatilityScore: 0.15,
+        trendStrength: 0.72
+      }
+    };
+  }
+  /**
+   * Generate realistic FinOps recommendations
+   */
+  static generateRecommendations() {
+    return [
+      {
+        id: "rec-001",
+        type: "COST_OPTIMIZATION",
+        title: "Purchase EC2 Reserved Instances",
+        description: "Based on your consistent EC2 usage patterns, purchasing Reserved Instances could save up to 30% on compute costs.",
+        potentialSavings: {
+          amount: 450.3,
+          percentage: 30,
+          timeframe: "MONTHLY"
+        },
+        effort: "LOW",
+        priority: "HIGH",
+        resources: ["i-1234567890abcdef0", "i-0987654321fedcba0"],
+        implementationSteps: [
+          "Analyze current EC2 usage patterns over the last 12 months",
+          "Purchase 1-year Reserved Instances for consistent workloads",
+          "Set up automated monitoring for RI utilization",
+          "Review and optimize instance sizing before purchasing RIs"
+        ],
+        tags: ["ec2", "reserved-instances", "cost-optimization"]
+      },
+      {
+        id: "rec-002",
+        type: "RESOURCE_RIGHTSIZING",
+        title: "Rightsize RDS Instances",
+        description: "Several RDS instances show low CPU utilization. Downsizing these instances could reduce costs without impacting performance.",
+        potentialSavings: {
+          amount: 280.75,
+          percentage: 25,
+          timeframe: "MONTHLY"
+        },
+        effort: "MEDIUM",
+        priority: "MEDIUM",
+        resources: ["mydb-instance-1", "mydb-instance-2"],
+        implementationSteps: [
+          "Review RDS CloudWatch metrics for CPU, memory, and I/O utilization",
+          "Create RDS snapshots before making changes",
+          "Modify instance class during maintenance window",
+          "Monitor performance after changes for 1 week"
+        ],
+        tags: ["rds", "rightsizing", "database-optimization"]
+      },
+      {
+        id: "rec-003",
+        type: "ARCHITECTURE",
+        title: "Implement S3 Intelligent Tiering",
+        description: "Enable S3 Intelligent Tiering to automatically optimize storage costs based on access patterns.",
+        potentialSavings: {
+          amount: 125.5,
+          percentage: 15,
+          timeframe: "MONTHLY"
+        },
+        effort: "LOW",
+        priority: "MEDIUM",
+        resources: ["s3-bucket-logs", "s3-bucket-backups"],
+        implementationSteps: [
+          "Enable S3 Intelligent Tiering on identified buckets",
+          "Set up lifecycle policies for automatic transitions",
+          "Monitor cost impact over 3 months",
+          "Review and adjust policies based on access patterns"
+        ],
+        tags: ["s3", "storage-optimization", "intelligent-tiering"]
+      },
+      {
+        id: "rec-004",
+        type: "COST_OPTIMIZATION",
+        title: "Optimize Lambda Memory Allocation",
+        description: "Lambda functions are over-provisioned with memory. Optimizing memory allocation can reduce costs significantly.",
+        potentialSavings: {
+          amount: 95.8,
+          percentage: 20,
+          timeframe: "MONTHLY"
+        },
+        effort: "HIGH",
+        priority: "LOW",
+        resources: ["process-images-lambda", "data-processor-lambda"],
+        implementationSteps: [
+          "Use AWS Lambda Power Tuning tool to find optimal memory settings",
+          "Test performance with different memory allocations",
+          "Update Lambda configurations incrementally",
+          "Set up monitoring for execution duration and cost metrics"
+        ],
+        tags: ["lambda", "serverless-optimization", "memory-tuning"]
+      }
+    ];
+  }
+  /**
+   * Generate sample resource inventory
+   */
+  static generateResourceInventory() {
+    return {
+      provider: "aws" /* AWS */,
+      region: "us-east-1",
+      totalResources: 145,
+      resourcesByType: {
+        ["compute" /* COMPUTE */]: 35,
+        ["storage" /* STORAGE */]: 28,
+        ["database" /* DATABASE */]: 12,
+        ["network" /* NETWORK */]: 25,
+        ["security" /* SECURITY */]: 18,
+        ["serverless" /* SERVERLESS */]: 15,
+        ["container" /* CONTAINER */]: 8,
+        ["analytics" /* ANALYTICS */]: 4
+      },
+      totalCost: 3890.5,
+      resources: {
+        compute: [],
+        storage: [],
+        database: [],
+        network: []
+      },
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Generate cost anomalies for testing
+   */
+  static generateCostAnomalies() {
+    return [
+      {
+        date: new Date(Date.now() - 2 * 24 * 60 * 60 * 1e3).toISOString().substring(0, 10),
+        actualCost: 5200.8,
+        expectedCost: 3500.2,
+        deviation: 48.6,
+        severity: "CRITICAL",
+        description: "Significant cost spike detected in EC2 Auto Scaling group due to unexpected traffic surge"
+      },
+      {
+        date: new Date(Date.now() - 7 * 24 * 60 * 60 * 1e3).toISOString().substring(0, 10),
+        actualCost: 2800.3,
+        expectedCost: 3200.5,
+        deviation: -12.5,
+        severity: "LOW",
+        description: "Lower than expected S3 costs due to successful data archiving policies"
+      }
+    ];
+  }
+  /**
+   * Helper method to generate realistic service cost multipliers
+   */
+  static getServiceMultiplier(serviceName) {
+    const multipliers = {
+      "Amazon EC2-Instance": 2.5,
+      "Amazon RDS": 1.8,
+      "Amazon S3": 1,
+      "AWS Lambda": 0.8,
+      "Amazon CloudFront": 0.6,
+      "Amazon EBS": 0.9,
+      "Amazon VPC": 0.3,
+      "Amazon Route 53": 0.2,
+      "AWS Application Load Balancer": 0.4,
+      "Amazon ElastiCache": 0.7,
+      "Amazon SES": 0.1,
+      "Amazon CloudWatch": 0.3,
+      "AWS Data Transfer": 0.5,
+      "Amazon DynamoDB": 0.6
+    };
+    return multipliers[serviceName] || 0.5;
+  }
+};
+
+// src/exporters/pdf-exporter.ts
+import puppeteer from "puppeteer";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import moment2 from "moment";
+var PDFExporter = class {
+  constructor(options = {}) {
+    this.browser = null;
+    this.options = {
+      outputPath: "./reports",
+      includeCharts: true,
+      includeSummary: true,
+      includeDetails: true,
+      includeRecommendations: true,
+      format: "A4",
+      orientation: "portrait",
+      theme: "light",
+      ...options
+    };
+  }
+  /**
+   * Generate comprehensive audit report PDF
+   */
+  async generateAuditReport(data) {
+    try {
+      await this.initializeBrowser();
+      const html = this.generateAuditHTML(data);
+      const filename = this.options.filename || `infra-cost-audit-${moment2(data.generatedAt).format("YYYY-MM-DD-HHmm")}.pdf`;
+      const outputPath = this.ensureOutputDirectory();
+      const fullPath = join(outputPath, filename);
+      const page = await this.browser.newPage();
+      await page.setContent(html, { waitUntil: "networkidle0" });
+      await page.pdf({
+        path: fullPath,
+        format: this.options.format,
+        orientation: this.options.orientation,
+        printBackground: true,
+        margin: {
+          top: "1in",
+          bottom: "1in",
+          left: "0.8in",
+          right: "0.8in"
+        },
+        displayHeaderFooter: true,
+        headerTemplate: this.generateHeaderTemplate(data.accountInfo),
+        footerTemplate: this.generateFooterTemplate()
+      });
+      await page.close();
+      await this.closeBrowser();
+      return fullPath;
+    } catch (error) {
+      await this.closeBrowser();
+      throw new Error(`PDF generation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Generate cost trend report PDF
+   */
+  async generateTrendReport(accountInfo, trendAnalysis) {
+    var _a, _b;
+    const data = {
+      accountInfo,
+      costBreakdown: {
+        totals: {
+          lastMonth: 0,
+          thisMonth: 0,
+          last7Days: 0,
+          yesterday: 0
+        },
+        totalsByService: {
+          lastMonth: {},
+          thisMonth: {},
+          last7Days: {},
+          yesterday: {}
+        }
+      },
+      trendAnalysis,
+      generatedAt: /* @__PURE__ */ new Date(),
+      reportPeriod: {
+        start: new Date(((_a = trendAnalysis.timeRange) == null ? void 0 : _a.start) || Date.now() - 6 * 30 * 24 * 60 * 60 * 1e3),
+        end: new Date(((_b = trendAnalysis.timeRange) == null ? void 0 : _b.end) || Date.now())
+      }
+    };
+    return this.generateAuditReport(data);
+  }
+  /**
+   * Generate executive summary PDF
+   */
+  async generateExecutiveSummary(data) {
+    this.options.includeDetails = false;
+    this.options.includeCharts = true;
+    this.options.includeSummary = true;
+    this.options.includeRecommendations = true;
+    const filename = `infra-cost-executive-summary-${moment2(data.generatedAt).format("YYYY-MM-DD")}.pdf`;
+    this.options.filename = filename;
+    return this.generateAuditReport(data);
+  }
+  generateAuditHTML(data) {
+    const theme = this.getThemeStyles();
+    return `
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="UTF-8">
+      <title>Infrastructure Cost Audit Report</title>
+      <style>
+        ${theme}
+        ${this.getBaseStyles()}
+      </style>
+    </head>
+    <body>
+      <div class="report-container">
+        ${this.generateCoverPage(data)}
+        ${this.options.includeSummary ? this.generateExecutiveSummary(data) : ""}
+        ${this.generateCostBreakdownSection(data.costBreakdown)}
+        ${data.trendAnalysis && this.options.includeCharts ? this.generateTrendAnalysisSection(data.trendAnalysis) : ""}
+        ${data.resourceInventory && this.options.includeDetails ? this.generateResourceInventorySection(data.resourceInventory) : ""}
+        ${data.anomalies && data.anomalies.length > 0 ? this.generateAnomaliesSection(data.anomalies) : ""}
+        ${data.recommendations && this.options.includeRecommendations ? this.generateRecommendationsSection(data.recommendations) : ""}
+        ${this.generateAppendixSection(data)}
+      </div>
+    </body>
+    </html>`;
+  }
+  generateCoverPage(data) {
+    return `
+    <div class="cover-page">
+      <div class="header">
+        <h1>Infrastructure Cost Analysis Report</h1>
+        <div class="subtitle">Comprehensive Cloud Cost Audit & Optimization</div>
+      </div>
+
+      <div class="account-info">
+        <h2>Account Information</h2>
+        <div class="info-grid">
+          <div class="info-item">
+            <strong>Account ID:</strong> ${data.accountInfo.id}
+          </div>
+          <div class="info-item">
+            <strong>Account Name:</strong> ${data.accountInfo.name || "N/A"}
+          </div>
+          <div class="info-item">
+            <strong>Cloud Provider:</strong> ${this.getProviderDisplayName(data.accountInfo.provider)}
+          </div>
+          <div class="info-item">
+            <strong>Report Generated:</strong> ${moment2(data.generatedAt).format("MMMM Do YYYY, h:mm:ss a")}
+          </div>
+          <div class="info-item">
+            <strong>Report Period:</strong>
+            ${moment2(data.reportPeriod.start).format("MMM DD, YYYY")} -
+            ${moment2(data.reportPeriod.end).format("MMM DD, YYYY")}
+          </div>
+        </div>
+      </div>
+
+      <div class="cost-summary-card">
+        <h2>Cost Summary</h2>
+        <div class="summary-grid">
+          <div class="summary-item">
+            <div class="amount">${this.formatCurrency(data.costBreakdown.totals.thisMonth)}</div>
+            <div class="label">This Month</div>
+          </div>
+          <div class="summary-item">
+            <div class="amount">${this.formatCurrency(data.costBreakdown.totals.lastMonth)}</div>
+            <div class="label">Last Month</div>
+          </div>
+          <div class="summary-item">
+            <div class="amount">${this.formatCurrency(data.costBreakdown.totals.last7Days)}</div>
+            <div class="label">Last 7 Days</div>
+          </div>
+          <div class="summary-item">
+            <div class="amount">${this.formatCurrency(data.costBreakdown.totals.yesterday)}</div>
+            <div class="label">Yesterday</div>
+          </div>
+        </div>
+      </div>
+
+      <div class="report-scope">
+        <h2>Report Scope</h2>
+        <ul>
+          ${this.options.includeSummary ? "<li>Executive Summary</li>" : ""}
+          <li>Cost Breakdown Analysis</li>
+          ${this.options.includeCharts ? "<li>Trend Analysis & Visualizations</li>" : ""}
+          ${this.options.includeDetails ? "<li>Resource Inventory</li>" : ""}
+          ${this.options.includeRecommendations ? "<li>Cost Optimization Recommendations</li>" : ""}
+        </ul>
+      </div>
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateExecutiveSummary(data) {
+    var _a;
+    const monthlyChange = this.calculatePercentageChange(
+      data.costBreakdown.totals.thisMonth,
+      data.costBreakdown.totals.lastMonth
+    );
+    const topServices = Object.entries(data.costBreakdown.totalsByService.thisMonth).sort(([, a], [, b]) => b - a).slice(0, 5);
+    return `
+    <div class="section">
+      <h1>Executive Summary</h1>
+
+      <div class="executive-insights">
+        <div class="insight-card ${monthlyChange >= 0 ? "warning" : "success"}">
+          <h3>Monthly Cost Trend</h3>
+          <p>Your cloud spending has ${monthlyChange >= 0 ? "increased" : "decreased"} by
+          <strong>${Math.abs(monthlyChange).toFixed(1)}%</strong> compared to last month.</p>
+        </div>
+
+        <div class="insight-card info">
+          <h3>Top Cost Drivers</h3>
+          <ul>
+            ${topServices.map(([service, cost]) => `
+              <li>${service}: ${this.formatCurrency(cost)}
+                  (${(cost / data.costBreakdown.totals.thisMonth * 100).toFixed(1)}% of total)
+              </li>
+            `).join("")}
+          </ul>
+        </div>
+
+        ${data.anomalies && data.anomalies.length > 0 ? `
+          <div class="insight-card warning">
+            <h3>Cost Anomalies</h3>
+            <p><strong>${data.anomalies.length}</strong> cost anomalies detected requiring attention.</p>
+          </div>
+        ` : ""}
+      </div>
+
+      <div class="key-metrics">
+        <h3>Key Performance Indicators</h3>
+        <div class="metrics-grid">
+          <div class="metric">
+            <div class="metric-value">${this.formatCurrency(data.costBreakdown.totals.thisMonth / moment2().date())}</div>
+            <div class="metric-label">Avg Daily Spend</div>
+          </div>
+          <div class="metric">
+            <div class="metric-value">${topServices.length}</div>
+            <div class="metric-label">Active Services</div>
+          </div>
+          <div class="metric">
+            <div class="metric-value">${((_a = data.trendAnalysis) == null ? void 0 : _a.projectedMonthlyCost) ? this.formatCurrency(data.trendAnalysis.projectedMonthlyCost) : "N/A"}</div>
+            <div class="metric-label">Projected Monthly</div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateCostBreakdownSection(costBreakdown) {
+    const serviceEntries = Object.entries(costBreakdown.totalsByService.thisMonth).filter(([, cost]) => cost > 0).sort(([, a], [, b]) => b - a);
+    return `
+    <div class="section">
+      <h1>Cost Breakdown Analysis</h1>
+
+      <div class="cost-comparison">
+        <h3>Period Comparison</h3>
+        <table class="data-table">
+          <thead>
+            <tr>
+              <th>Period</th>
+              <th>Total Cost</th>
+              <th>Change</th>
+              <th>Trend</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr>
+              <td>This Month</td>
+              <td>${this.formatCurrency(costBreakdown.totals.thisMonth)}</td>
+              <td>${this.formatChangePercentage(costBreakdown.totals.thisMonth, costBreakdown.totals.lastMonth)}</td>
+              <td>${this.getTrendIcon(costBreakdown.totals.thisMonth, costBreakdown.totals.lastMonth)}</td>
+            </tr>
+            <tr>
+              <td>Last Month</td>
+              <td>${this.formatCurrency(costBreakdown.totals.lastMonth)}</td>
+              <td>-</td>
+              <td>-</td>
+            </tr>
+            <tr>
+              <td>Last 7 Days</td>
+              <td>${this.formatCurrency(costBreakdown.totals.last7Days)}</td>
+              <td>${this.formatChangePercentage(costBreakdown.totals.last7Days, costBreakdown.totals.yesterday * 7)}</td>
+              <td>${this.getTrendIcon(costBreakdown.totals.last7Days, costBreakdown.totals.yesterday * 7)}</td>
+            </tr>
+            <tr>
+              <td>Yesterday</td>
+              <td>${this.formatCurrency(costBreakdown.totals.yesterday)}</td>
+              <td>-</td>
+              <td>-</td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      <div class="service-breakdown">
+        <h3>Service-Level Breakdown (This Month)</h3>
+        <table class="data-table">
+          <thead>
+            <tr>
+              <th>Service</th>
+              <th>Cost</th>
+              <th>Share</th>
+              <th>vs Last Month</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${serviceEntries.map(([service, cost]) => {
+      const share = (cost / costBreakdown.totals.thisMonth * 100).toFixed(1);
+      const lastMonthCost = costBreakdown.totalsByService.lastMonth[service] || 0;
+      const change = this.formatChangePercentage(cost, lastMonthCost);
+      return `
+                <tr>
+                  <td>${service}</td>
+                  <td>${this.formatCurrency(cost)}</td>
+                  <td>${share}%</td>
+                  <td>${change}</td>
+                </tr>
+              `;
+    }).join("")}
+          </tbody>
+        </table>
+      </div>
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateTrendAnalysisSection(trendAnalysis) {
+    var _a;
+    return `
+    <div class="section">
+      <h1>Trend Analysis</h1>
+
+      <div class="trend-insights">
+        <div class="insight-grid">
+          <div class="insight-item">
+            <div class="insight-value">${this.formatCurrency(trendAnalysis.totalCost)}</div>
+            <div class="insight-label">Total Period Cost</div>
+          </div>
+          <div class="insight-item">
+            <div class="insight-value">${this.formatCurrency(trendAnalysis.averageDailyCost)}</div>
+            <div class="insight-label">Average Daily Cost</div>
+          </div>
+          <div class="insight-item">
+            <div class="insight-value">${this.formatCurrency(trendAnalysis.projectedMonthlyCost)}</div>
+            <div class="insight-label">Projected Monthly</div>
+          </div>
+          <div class="insight-item">
+            <div class="insight-value">${((_a = trendAnalysis.avgMonthOverMonthGrowth) == null ? void 0 : _a.toFixed(1)) || "N/A"}%</div>
+            <div class="insight-label">Avg MoM Growth</div>
+          </div>
+        </div>
+      </div>
+
+      ${trendAnalysis.topServices ? `
+        <div class="top-services">
+          <h3>Top Services by Cost</h3>
+          <table class="data-table">
+            <thead>
+              <tr>
+                <th>Service</th>
+                <th>Cost</th>
+                <th>Share</th>
+                <th>Trend</th>
+              </tr>
+            </thead>
+            <tbody>
+              ${trendAnalysis.topServices.map((service) => `
+                <tr>
+                  <td>${service.serviceName}</td>
+                  <td>${this.formatCurrency(service.cost)}</td>
+                  <td>${service.percentage.toFixed(1)}%</td>
+                  <td>${service.trend}</td>
+                </tr>
+              `).join("")}
+            </tbody>
+          </table>
+        </div>
+      ` : ""}
+
+      ${trendAnalysis.analytics ? `
+        <div class="analytics-insights">
+          <h3>Analytics Insights</h3>
+          <ul>
+            ${trendAnalysis.analytics.insights.map((insight) => `<li>${insight}</li>`).join("")}
+          </ul>
+
+          <div class="analytics-metrics">
+            <div class="metric-row">
+              <span>Volatility Score:</span>
+              <span class="metric-value">${trendAnalysis.analytics.volatilityScore.toFixed(2)}</span>
+            </div>
+            <div class="metric-row">
+              <span>Trend Strength:</span>
+              <span class="metric-value">${trendAnalysis.analytics.trendStrength.toFixed(2)}</span>
+            </div>
+          </div>
+        </div>
+      ` : ""}
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateResourceInventorySection(inventory) {
+    return `
+    <div class="section">
+      <h1>Resource Inventory</h1>
+
+      <div class="inventory-summary">
+        <div class="summary-stats">
+          <div class="stat">
+            <div class="stat-value">${inventory.totalResources}</div>
+            <div class="stat-label">Total Resources</div>
+          </div>
+          <div class="stat">
+            <div class="stat-value">${this.formatCurrency(inventory.totalCost)}</div>
+            <div class="stat-label">Total Cost</div>
+          </div>
+          <div class="stat">
+            <div class="stat-value">${inventory.region}</div>
+            <div class="stat-label">Primary Region</div>
+          </div>
+        </div>
+      </div>
+
+      <div class="resource-breakdown">
+        <h3>Resources by Type</h3>
+        <table class="data-table">
+          <thead>
+            <tr>
+              <th>Resource Type</th>
+              <th>Count</th>
+              <th>Percentage</th>
+            </tr>
+          </thead>
+          <tbody>
+            ${Object.entries(inventory.resourcesByType).map(([type, count]) => `
+              <tr>
+                <td>${type.charAt(0).toUpperCase() + type.slice(1)}</td>
+                <td>${count}</td>
+                <td>${(count / inventory.totalResources * 100).toFixed(1)}%</td>
+              </tr>
+            `).join("")}
+          </tbody>
+        </table>
+      </div>
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateAnomaliesSection(anomalies) {
+    return `
+    <div class="section">
+      <h1>Cost Anomalies</h1>
+
+      <div class="anomalies-overview">
+        <p class="overview-text">
+          <strong>${anomalies.length}</strong> cost anomalies have been detected during the report period.
+          These represent significant deviations from expected spending patterns and require investigation.
+        </p>
+      </div>
+
+      <div class="anomalies-list">
+        ${anomalies.map((anomaly) => `
+          <div class="anomaly-card severity-${anomaly.severity.toLowerCase()}">
+            <div class="anomaly-header">
+              <h4>${moment2(anomaly.date).format("MMMM DD, YYYY")}</h4>
+              <span class="severity-badge ${anomaly.severity.toLowerCase()}">${anomaly.severity}</span>
+            </div>
+            <div class="anomaly-details">
+              <div class="detail-row">
+                <span>Expected Cost:</span>
+                <span>${this.formatCurrency(anomaly.expectedCost)}</span>
+              </div>
+              <div class="detail-row">
+                <span>Actual Cost:</span>
+                <span>${this.formatCurrency(anomaly.actualCost)}</span>
+              </div>
+              <div class="detail-row">
+                <span>Deviation:</span>
+                <span class="${anomaly.deviation > 0 ? "increase" : "decrease"}">
+                  ${anomaly.deviation > 0 ? "+" : ""}${anomaly.deviation.toFixed(1)}%
+                </span>
+              </div>
+              ${anomaly.description ? `
+                <div class="anomaly-description">
+                  <p>${anomaly.description}</p>
+                </div>
+              ` : ""}
+            </div>
+          </div>
+        `).join("")}
+      </div>
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateRecommendationsSection(recommendations) {
+    const totalPotentialSavings = recommendations.reduce((sum, rec) => sum + rec.potentialSavings.amount, 0);
+    return `
+    <div class="section">
+      <h1>Cost Optimization Recommendations</h1>
+
+      <div class="recommendations-overview">
+        <div class="savings-potential">
+          <h3>Potential Savings: ${this.formatCurrency(totalPotentialSavings)}</h3>
+          <p>${recommendations.length} optimization opportunities identified</p>
+        </div>
+      </div>
+
+      <div class="recommendations-list">
+        ${recommendations.map((rec) => `
+          <div class="recommendation-card priority-${rec.priority.toLowerCase()}">
+            <div class="recommendation-header">
+              <h4>${rec.title}</h4>
+              <div class="recommendation-meta">
+                <span class="priority-badge ${rec.priority.toLowerCase()}">${rec.priority}</span>
+                <span class="effort-badge effort-${rec.effort.toLowerCase()}">${rec.effort} Effort</span>
+              </div>
+            </div>
+
+            <div class="recommendation-body">
+              <p>${rec.description}</p>
+
+              <div class="savings-info">
+                <div class="savings-amount">
+                  Potential Savings: <strong>${this.formatCurrency(rec.potentialSavings.amount)}</strong>
+                  <span class="timeframe">(${rec.potentialSavings.timeframe.toLowerCase()})</span>
+                </div>
+                <div class="savings-percentage">
+                  ${rec.potentialSavings.percentage.toFixed(1)}% reduction
+                </div>
+              </div>
+
+              ${rec.implementationSteps.length > 0 ? `
+                <div class="implementation-steps">
+                  <h5>Implementation Steps:</h5>
+                  <ol>
+                    ${rec.implementationSteps.map((step) => `<li>${step}</li>`).join("")}
+                  </ol>
+                </div>
+              ` : ""}
+
+              ${rec.resources && rec.resources.length > 0 ? `
+                <div class="affected-resources">
+                  <h5>Affected Resources:</h5>
+                  <ul>
+                    ${rec.resources.map((resource) => `<li>${resource}</li>`).join("")}
+                  </ul>
+                </div>
+              ` : ""}
+
+              ${rec.tags.length > 0 ? `
+                <div class="recommendation-tags">
+                  ${rec.tags.map((tag) => `<span class="tag">${tag}</span>`).join("")}
+                </div>
+              ` : ""}
+            </div>
+          </div>
+        `).join("")}
+      </div>
+    </div>
+    <div class="page-break"></div>`;
+  }
+  generateAppendixSection(data) {
+    return `
+    <div class="section">
+      <h1>Appendix</h1>
+
+      <div class="report-metadata">
+        <h3>Report Generation Details</h3>
+        <table class="metadata-table">
+          <tr>
+            <td>Report Generated:</td>
+            <td>${moment2(data.generatedAt).format("MMMM Do YYYY, h:mm:ss a")}</td>
+          </tr>
+          <tr>
+            <td>Tool Version:</td>
+            <td>infra-cost v0.1.0</td>
+          </tr>
+          <tr>
+            <td>Report Type:</td>
+            <td>Comprehensive Audit Report</td>
+          </tr>
+          <tr>
+            <td>Data Source:</td>
+            <td>${this.getProviderDisplayName(data.accountInfo.provider)} Cost Explorer API</td>
+          </tr>
+          <tr>
+            <td>Analysis Period:</td>
+            <td>${moment2(data.reportPeriod.start).format("MMM DD, YYYY")} - ${moment2(data.reportPeriod.end).format("MMM DD, YYYY")}</td>
+          </tr>
+        </table>
+      </div>
+
+      <div class="methodology">
+        <h3>Methodology</h3>
+        <ul>
+          <li>Cost data retrieved from cloud provider's native billing APIs</li>
+          <li>Trend analysis based on historical spending patterns</li>
+          <li>Anomaly detection using statistical analysis and machine learning algorithms</li>
+          <li>Recommendations generated based on FinOps best practices and usage patterns</li>
+          <li>All costs displayed in USD unless otherwise specified</li>
+        </ul>
+      </div>
+
+      <div class="disclaimers">
+        <h3>Important Notes</h3>
+        <ul>
+          <li>Cost data is subject to cloud provider billing cycles and may include estimates</li>
+          <li>Savings projections are estimates based on current usage patterns</li>
+          <li>Implementation of recommendations should be carefully planned and tested</li>
+          <li>This report is generated automatically and should be reviewed by qualified personnel</li>
+        </ul>
+      </div>
+    </div>`;
+  }
+  // Helper methods and styles...
+  getThemeStyles() {
+    if (this.options.theme === "dark") {
+      return `
+        :root {
+          --primary-color: #2563eb;
+          --secondary-color: #64748b;
+          --background-color: #1e293b;
+          --text-color: #f8fafc;
+          --border-color: #374151;
+          --success-color: #10b981;
+          --warning-color: #f59e0b;
+          --danger-color: #ef4444;
+          --card-background: #334155;
+        }
+      `;
+    }
+    return `
+      :root {
+        --primary-color: #2563eb;
+        --secondary-color: #64748b;
+        --background-color: #ffffff;
+        --text-color: #1f2937;
+        --border-color: #e5e7eb;
+        --success-color: #10b981;
+        --warning-color: #f59e0b;
+        --danger-color: #ef4444;
+        --card-background: #f9fafb;
+      }
+    `;
+  }
+  getBaseStyles() {
+    return `
+      body {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        line-height: 1.6;
+        color: var(--text-color);
+        background-color: var(--background-color);
+        margin: 0;
+        padding: 0;
+      }
+
+      .report-container {
+        max-width: 100%;
+        margin: 0 auto;
+      }
+
+      .page-break {
+        page-break-before: always;
+      }
+
+      .cover-page {
+        text-align: center;
+        padding: 2rem;
+        min-height: 80vh;
+        display: flex;
+        flex-direction: column;
+        justify-content: center;
+      }
+
+      .header h1 {
+        font-size: 2.5rem;
+        color: var(--primary-color);
+        margin-bottom: 0.5rem;
+      }
+
+      .subtitle {
+        font-size: 1.2rem;
+        color: var(--secondary-color);
+        margin-bottom: 3rem;
+      }
+
+      .section {
+        padding: 2rem;
+        margin-bottom: 2rem;
+      }
+
+      .section h1 {
+        color: var(--primary-color);
+        border-bottom: 2px solid var(--primary-color);
+        padding-bottom: 0.5rem;
+        margin-bottom: 2rem;
+      }
+
+      .data-table {
+        width: 100%;
+        border-collapse: collapse;
+        margin: 1rem 0;
+      }
+
+      .data-table th,
+      .data-table td {
+        padding: 0.75rem;
+        text-align: left;
+        border-bottom: 1px solid var(--border-color);
+      }
+
+      .data-table th {
+        background-color: var(--card-background);
+        font-weight: 600;
+      }
+
+      .cost-summary-card {
+        background: var(--card-background);
+        border-radius: 8px;
+        padding: 2rem;
+        margin: 2rem 0;
+        border: 1px solid var(--border-color);
+      }
+
+      .summary-grid {
+        display: grid;
+        grid-template-columns: repeat(4, 1fr);
+        gap: 1rem;
+        text-align: center;
+      }
+
+      .summary-item .amount {
+        font-size: 1.5rem;
+        font-weight: bold;
+        color: var(--primary-color);
+      }
+
+      .summary-item .label {
+        color: var(--secondary-color);
+        font-size: 0.9rem;
+      }
+
+      .anomaly-card {
+        border-left: 4px solid;
+        padding: 1rem;
+        margin: 1rem 0;
+        background: var(--card-background);
+        border-radius: 0 8px 8px 0;
+      }
+
+      .anomaly-card.severity-critical {
+        border-left-color: var(--danger-color);
+      }
+
+      .anomaly-card.severity-high {
+        border-left-color: #ff6b35;
+      }
+
+      .anomaly-card.severity-medium {
+        border-left-color: var(--warning-color);
+      }
+
+      .anomaly-card.severity-low {
+        border-left-color: #3b82f6;
+      }
+
+      .recommendation-card {
+        border: 1px solid var(--border-color);
+        border-radius: 8px;
+        padding: 1.5rem;
+        margin: 1rem 0;
+        background: var(--card-background);
+      }
+
+      .priority-badge {
+        padding: 0.25rem 0.5rem;
+        border-radius: 4px;
+        font-size: 0.75rem;
+        font-weight: 600;
+        text-transform: uppercase;
+      }
+
+      .priority-badge.critical {
+        background-color: var(--danger-color);
+        color: white;
+      }
+
+      .priority-badge.high {
+        background-color: #ff6b35;
+        color: white;
+      }
+
+      .priority-badge.medium {
+        background-color: var(--warning-color);
+        color: white;
+      }
+
+      .priority-badge.low {
+        background-color: #3b82f6;
+        color: white;
+      }
+
+      .trend-chart {
+        font-family: monospace;
+        background: var(--card-background);
+        padding: 1rem;
+        border-radius: 4px;
+        margin: 1rem 0;
+      }
+
+      @media print {
+        body { print-color-adjust: exact; }
+        .page-break { page-break-before: always; }
+      }
+    `;
+  }
+  generateHeaderTemplate(accountInfo) {
+    return `
+    <div style="font-size: 10px; color: #666; width: 100%; text-align: center; margin-top: 10px;">
+      Infrastructure Cost Report - ${accountInfo.name || accountInfo.id} - ${this.getProviderDisplayName(accountInfo.provider)}
+    </div>`;
+  }
+  generateFooterTemplate() {
+    return `
+    <div style="font-size: 10px; color: #666; width: 100%; text-align: center; margin-bottom: 10px;">
+      <div style="display: flex; justify-content: space-between; width: 100%; align-items: center;">
+        <span>Generated by infra-cost v0.1.0</span>
+        <span>Page <span class="pageNumber"></span> of <span class="totalPages"></span></span>
+        <span>${moment2().format("YYYY-MM-DD HH:mm")}</span>
+      </div>
+    </div>`;
+  }
+  async initializeBrowser() {
+    if (!this.browser) {
+      this.browser = await puppeteer.launch({
+        headless: true,
+        args: ["--no-sandbox", "--disable-setuid-sandbox"]
+      });
+    }
+  }
+  async closeBrowser() {
+    if (this.browser) {
+      await this.browser.close();
+      this.browser = null;
+    }
+  }
+  ensureOutputDirectory() {
+    const outputPath = this.options.outputPath;
+    if (!existsSync(outputPath)) {
+      mkdirSync(outputPath, { recursive: true });
+    }
+    return outputPath;
+  }
+  formatCurrency(amount) {
+    return new Intl.NumberFormat("en-US", {
+      style: "currency",
+      currency: "USD",
+      minimumFractionDigits: 2,
+      maximumFractionDigits: 2
+    }).format(amount);
+  }
+  calculatePercentageChange(current, previous) {
+    if (previous === 0)
+      return 0;
+    return (current - previous) / previous * 100;
+  }
+  formatChangePercentage(current, previous) {
+    const change = this.calculatePercentageChange(current, previous);
+    const sign = change >= 0 ? "+" : "";
+    return `${sign}${change.toFixed(1)}%`;
+  }
+  getTrendIcon(current, previous) {
+    const change = this.calculatePercentageChange(current, previous);
+    if (change > 5)
+      return "\u2197\uFE0F";
+    if (change < -5)
+      return "\u2198\uFE0F";
+    return "\u27A1\uFE0F";
+  }
+  getProviderDisplayName(provider) {
+    const displayNames = {
+      ["aws" /* AWS */]: "Amazon Web Services",
+      ["gcp" /* GOOGLE_CLOUD */]: "Google Cloud Platform",
+      ["azure" /* AZURE */]: "Microsoft Azure",
+      ["alicloud" /* ALIBABA_CLOUD */]: "Alibaba Cloud",
+      ["oracle" /* ORACLE_CLOUD */]: "Oracle Cloud Infrastructure"
+    };
+    return displayNames[provider] || provider;
+  }
+};
+
+// src/demo/test-enhanced-ui.ts
+async function testEnhancedUI() {
+  console.log(chalk2.bold.cyan("\u{1F9EA} Testing Enhanced Terminal UI Features\n"));
+  const ui = new TerminalUIEngine();
+  console.log(chalk2.bold.yellow("Test 1: Enhanced Header"));
+  console.log("\u2500".repeat(50));
+  const header = ui.createHeader("\u{1F680} Infrastructure Cost Analysis", "Demo Production Account");
+  console.log(header);
+  console.log(chalk2.bold.yellow("Test 2: Rich Cost Breakdown Table"));
+  console.log("\u2500".repeat(50));
+  const costBreakdown = DemoDataGenerator.generateCostBreakdown();
+  const costTable = ui.createCostTable(costBreakdown, {
+    showPercentages: true,
+    highlightTop: 8,
+    currency: "USD",
+    compact: false
+  });
+  console.log(costTable);
+  console.log(chalk2.bold.yellow("Test 3: ASCII Trend Chart"));
+  console.log("\u2500".repeat(50));
+  const trendAnalysis = DemoDataGenerator.generateTrendAnalysis();
+  if (trendAnalysis.trendData) {
+    const trendChart = ui.createTrendChart(trendAnalysis.trendData, {
+      width: 50,
+      showLabels: true,
+      currency: "USD",
+      colorThreshold: 0.7
+    });
+    console.log(trendChart);
+  }
+  console.log(chalk2.bold.yellow("Test 4: Cost Anomaly Alerts"));
+  console.log("\u2500".repeat(50));
+  const anomalies = DemoDataGenerator.generateCostAnomalies();
+  const anomalyAlert = ui.createAnomalyAlert(anomalies);
+  console.log(anomalyAlert);
+  console.log(chalk2.bold.yellow("Test 5: Progress Indicators"));
+  console.log("\u2500".repeat(50));
+  ui.startProgress("Processing cost analysis", 100);
+  for (let i = 0; i <= 100; i += 20) {
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    ui.updateProgress(i, { step: `Processing step ${i / 20 + 1}/6` });
+  }
+  ui.stopProgress();
+  console.log(chalk2.green("\u2705 Processing completed!\n"));
+  console.log(chalk2.bold.yellow("Test 6: Executive Summary Format"));
+  console.log("\u2500".repeat(50));
+  const recommendations = DemoDataGenerator.generateRecommendations();
+  const totalSavings = recommendations.reduce((sum, rec) => sum + rec.potentialSavings.amount, 0);
+  console.log("\n" + chalk2.bold.cyan("\u{1F3AF} Key Performance Indicators"));
+  console.log("\u2550".repeat(50));
+  console.log(`Monthly Spend: ${chalk2.yellow("$" + costBreakdown.totals.thisMonth.toFixed(2))}`);
+  console.log(`Cost Change: ${costBreakdown.totals.thisMonth > costBreakdown.totals.lastMonth ? chalk2.red("\u2197 +" + ((costBreakdown.totals.thisMonth - costBreakdown.totals.lastMonth) / costBreakdown.totals.lastMonth * 100).toFixed(1) + "%") : chalk2.green("\u2198 " + ((costBreakdown.totals.thisMonth - costBreakdown.totals.lastMonth) / costBreakdown.totals.lastMonth * 100).toFixed(1) + "%")}`);
+  console.log(`Optimization Potential: ${chalk2.green("$" + totalSavings.toFixed(2))}`);
+  console.log(`Active Recommendations: ${chalk2.cyan(recommendations.length.toString())}`);
+  console.log("\n" + chalk2.bold.cyan("\u{1F4A1} Top Cost Optimization Recommendations"));
+  console.log("\u2550".repeat(60));
+  recommendations.slice(0, 3).forEach((rec, index) => {
+    console.log(`
+${index + 1}. ${chalk2.bold(rec.title)}`);
+    console.log(`   ${rec.description}`);
+    console.log(`   \u{1F4B0} Potential savings: ${chalk2.green("$" + rec.potentialSavings.amount.toFixed(2))} ${rec.potentialSavings.timeframe.toLowerCase()}`);
+    console.log(`   \u{1F3AF} Priority: ${chalk2[rec.priority === "HIGH" ? "red" : rec.priority === "MEDIUM" ? "yellow" : "cyan"](rec.priority)}`);
+    console.log(`   \u{1F527} Effort: ${chalk2.gray(rec.effort)}`);
+  });
+  console.log("\n" + chalk2.gray("\u2501".repeat(70)));
+  console.log(chalk2.gray("\u{1F4A1} Demo completed successfully! All enhanced UI features are working."));
+  console.log(chalk2.gray("\u{1F4CA} Use --trend, --audit, or --executive-summary with real data"));
+  return true;
+}
+async function testPDFGeneration() {
+  console.log("\n" + chalk2.bold.cyan("\u{1F4C4} Testing PDF Generation"));
+  console.log("\u2500".repeat(50));
+  try {
+    const pdfExporter = new PDFExporter({
+      outputPath: "./demo-reports",
+      includeCharts: true,
+      includeSummary: true,
+      includeDetails: true,
+      includeRecommendations: true
+    });
+    const accountInfo = DemoDataGenerator.generateAccountInfo();
+    const costBreakdown = DemoDataGenerator.generateCostBreakdown();
+    const recommendations = DemoDataGenerator.generateRecommendations();
+    const anomalies = DemoDataGenerator.generateCostAnomalies();
+    const inventory = DemoDataGenerator.generateResourceInventory();
+    console.log("\u{1F504} Generating comprehensive demo audit report...");
+    const auditData = {
+      accountInfo,
+      costBreakdown,
+      resourceInventory: inventory,
+      recommendations,
+      anomalies,
+      generatedAt: /* @__PURE__ */ new Date(),
+      reportPeriod: {
+        start: new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3),
+        end: /* @__PURE__ */ new Date()
+      }
+    };
+    const pdfPath = await pdfExporter.generateAuditReport(auditData);
+    console.log(chalk2.green(`\u2705 Demo PDF report generated: ${pdfPath}`));
+    return true;
+  } catch (error) {
+    console.log(chalk2.yellow(`\u26A0\uFE0F  PDF generation test skipped: ${error instanceof Error ? error.message : "Unknown error"}`));
+    console.log(chalk2.gray("   (This is expected in environments without browser support)"));
+    return false;
+  }
+}
+async function main() {
+  try {
+    console.log(chalk2.bold.blue("\u{1F680} Enhanced infra-cost UI Testing Suite"));
+    console.log(chalk2.gray("Testing all new features with realistic demo data\n"));
+    const uiTestResult = await testEnhancedUI();
+    const pdfTestResult = await testPDFGeneration();
+    console.log("\n" + chalk2.bold.green("\u{1F389} Testing Complete!"));
+    console.log(`Terminal UI Features: ${uiTestResult ? chalk2.green("\u2705 PASS") : chalk2.red("\u274C FAIL")}`);
+    console.log(`PDF Generation: ${pdfTestResult ? chalk2.green("\u2705 PASS") : chalk2.yellow("\u26A0\uFE0F  SKIP")}`);
+    if (uiTestResult) {
+      console.log("\n" + chalk2.bold.cyan("Next Steps:"));
+      console.log("\u2022 Run with real AWS credentials: infra-cost --trend");
+      console.log("\u2022 Generate audit reports: infra-cost --audit --pdf-report");
+      console.log("\u2022 Create executive summaries: infra-cost --executive-summary");
+    }
+  } catch (error) {
+    console.error(chalk2.red("\u274C Test failed:"), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+export {
+  testEnhancedUI,
+  testPDFGeneration
+};
+//# sourceMappingURL=test-enhanced-ui.js.map