infra-cost 0.1.0 → 0.2.0

package/dist/demo/test-multi-cloud-dashboard.js

@@ -0,0 +1,3370 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/visualization/multi-cloud-dashboard.ts
+import chalk4 from "chalk";
+
+// src/types/providers.ts
+var CloudProviderAdapter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  calculateServiceTotals(rawCostData) {
+    return this.processRawCostData(rawCostData);
+  }
+  processRawCostData(rawCostData) {
+    const totals = {
+      lastMonth: 0,
+      thisMonth: 0,
+      last7Days: 0,
+      yesterday: 0
+    };
+    const totalsByService = {
+      lastMonth: {},
+      thisMonth: {},
+      last7Days: {},
+      yesterday: {}
+    };
+    const now = /* @__PURE__ */ new Date();
+    const startOfThisMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+    const startOfLastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    const endOfLastMonth = new Date(now.getFullYear(), now.getMonth(), 0);
+    const yesterday = new Date(now);
+    yesterday.setDate(yesterday.getDate() - 1);
+    const last7DaysStart = new Date(now);
+    last7DaysStart.setDate(last7DaysStart.getDate() - 7);
+    for (const [serviceName, serviceCosts] of Object.entries(rawCostData)) {
+      let lastMonthServiceTotal = 0;
+      let thisMonthServiceTotal = 0;
+      let last7DaysServiceTotal = 0;
+      let yesterdayServiceTotal = 0;
+      for (const [dateStr, cost] of Object.entries(serviceCosts)) {
+        const date = new Date(dateStr);
+        if (date >= startOfLastMonth && date <= endOfLastMonth) {
+          lastMonthServiceTotal += cost;
+        }
+        if (date >= startOfThisMonth) {
+          thisMonthServiceTotal += cost;
+        }
+        if (date >= last7DaysStart && date < yesterday) {
+          last7DaysServiceTotal += cost;
+        }
+        if (date.toDateString() === yesterday.toDateString()) {
+          yesterdayServiceTotal += cost;
+        }
+      }
+      totalsByService.lastMonth[serviceName] = lastMonthServiceTotal;
+      totalsByService.thisMonth[serviceName] = thisMonthServiceTotal;
+      totalsByService.last7Days[serviceName] = last7DaysServiceTotal;
+      totalsByService.yesterday[serviceName] = yesterdayServiceTotal;
+      totals.lastMonth += lastMonthServiceTotal;
+      totals.thisMonth += thisMonthServiceTotal;
+      totals.last7Days += last7DaysServiceTotal;
+      totals.yesterday += yesterdayServiceTotal;
+    }
+    return {
+      totals,
+      totalsByService
+    };
+  }
+};
+var ResourceType = /* @__PURE__ */ ((ResourceType2) => {
+  ResourceType2["COMPUTE"] = "compute";
+  ResourceType2["STORAGE"] = "storage";
+  ResourceType2["DATABASE"] = "database";
+  ResourceType2["NETWORK"] = "network";
+  ResourceType2["SECURITY"] = "security";
+  ResourceType2["SERVERLESS"] = "serverless";
+  ResourceType2["CONTAINER"] = "container";
+  ResourceType2["ANALYTICS"] = "analytics";
+  return ResourceType2;
+})(ResourceType || {});
+
+// src/providers/aws.ts
+import { CostExplorerClient, GetCostAndUsageCommand } from "@aws-sdk/client-cost-explorer";
+import { IAMClient, ListAccountAliasesCommand } from "@aws-sdk/client-iam";
+import { STSClient, GetCallerIdentityCommand } from "@aws-sdk/client-sts";
+import { EC2Client, DescribeInstancesCommand, DescribeVolumesCommand, DescribeVpcsCommand, DescribeSubnetsCommand } from "@aws-sdk/client-ec2";
+import { S3Client, ListBucketsCommand } from "@aws-sdk/client-s3";
+import { RDSClient, DescribeDBInstancesCommand } from "@aws-sdk/client-rds";
+import { LambdaClient, ListFunctionsCommand } from "@aws-sdk/client-lambda";
+import { BudgetsClient, DescribeBudgetsCommand } from "@aws-sdk/client-budgets";
+import dayjs from "dayjs";
+
+// src/logger.ts
+import chalk from "chalk";
+import ora from "ora";
+var spinner;
+function showSpinner(text) {
+  if (!spinner) {
+    spinner = ora({ text: "" }).start();
+  }
+  spinner.text = text;
+}
+
+// src/analytics/anomaly-detector.ts
+var AnomalyDetector = class {
+  constructor(config = { sensitivity: "MEDIUM", lookbackPeriods: 14 }) {
+    this.config = config;
+  }
+  /**
+   * Detects anomalies using multiple statistical methods
+   */
+  detectAnomalies(dataPoints) {
+    if (dataPoints.length < this.config.lookbackPeriods) {
+      return [];
+    }
+    const anomalies = [];
+    anomalies.push(...this.detectStatisticalAnomalies(dataPoints));
+    anomalies.push(...this.detectTrendAnomalies(dataPoints));
+    anomalies.push(...this.detectSeasonalAnomalies(dataPoints));
+    return this.consolidateAnomalies(anomalies);
+  }
+  /**
+   * Statistical anomaly detection using modified Z-score
+   */
+  detectStatisticalAnomalies(dataPoints) {
+    const anomalies = [];
+    const values = dataPoints.map((dp) => dp.value);
+    for (let i = this.config.lookbackPeriods; i < dataPoints.length; i++) {
+      const currentValue = values[i];
+      const historicalValues = values.slice(i - this.config.lookbackPeriods, i);
+      const median = this.calculateMedian(historicalValues);
+      const mad = this.calculateMAD(historicalValues, median);
+      const modifiedZScore = mad === 0 ? 0 : 0.6745 * (currentValue - median) / mad;
+      const threshold = this.getSensitivityThreshold();
+      if (Math.abs(modifiedZScore) > threshold) {
+        const deviation = currentValue - median;
+        const deviationPercentage = median === 0 ? 0 : Math.abs(deviation / median) * 100;
+        anomalies.push({
+          timestamp: dataPoints[i].timestamp,
+          actualValue: currentValue,
+          expectedValue: median,
+          deviation: Math.abs(deviation),
+          deviationPercentage,
+          severity: this.calculateSeverity(Math.abs(modifiedZScore), threshold),
+          confidence: Math.min(95, Math.abs(modifiedZScore) / threshold * 100),
+          type: deviation > 0 ? "SPIKE" : "DROP",
+          description: this.generateAnomalyDescription("STATISTICAL", deviation, deviationPercentage),
+          potentialCauses: this.generatePotentialCauses(deviation > 0 ? "SPIKE" : "DROP", deviationPercentage)
+        });
+      }
+    }
+    return anomalies;
+  }
+  /**
+   * Trend-based anomaly detection
+   */
+  detectTrendAnomalies(dataPoints) {
+    const anomalies = [];
+    const values = dataPoints.map((dp) => dp.value);
+    const trendWindow = Math.min(7, Math.floor(this.config.lookbackPeriods / 2));
+    for (let i = trendWindow * 2; i < dataPoints.length; i++) {
+      const recentTrend = this.calculateLinearTrend(values.slice(i - trendWindow, i));
+      const historicalTrend = this.calculateLinearTrend(values.slice(i - trendWindow * 2, i - trendWindow));
+      const trendChange = Math.abs(recentTrend - historicalTrend);
+      const trendChangeThreshold = this.config.sensitivity === "HIGH" ? 0.1 : this.config.sensitivity === "MEDIUM" ? 0.2 : 0.3;
+      if (trendChange > trendChangeThreshold) {
+        const currentValue = values[i];
+        const expectedValue = values[i - 1] + historicalTrend;
+        const deviation = Math.abs(currentValue - expectedValue);
+        const deviationPercentage = expectedValue === 0 ? 0 : deviation / expectedValue * 100;
+        anomalies.push({
+          timestamp: dataPoints[i].timestamp,
+          actualValue: currentValue,
+          expectedValue,
+          deviation,
+          deviationPercentage,
+          severity: this.calculateSeverity(trendChange, trendChangeThreshold),
+          confidence: Math.min(90, trendChange / trendChangeThreshold * 100),
+          type: "TREND_CHANGE",
+          description: `Significant trend change detected: ${recentTrend > historicalTrend ? "acceleration" : "deceleration"} in cost growth`,
+          potentialCauses: this.generatePotentialCauses("TREND_CHANGE", deviationPercentage)
+        });
+      }
+    }
+    return anomalies;
+  }
+  /**
+   * Seasonal anomaly detection
+   */
+  detectSeasonalAnomalies(dataPoints) {
+    if (!this.config.seasonalityPeriods || dataPoints.length < this.config.seasonalityPeriods * 2) {
+      return [];
+    }
+    const anomalies = [];
+    const values = dataPoints.map((dp) => dp.value);
+    const seasonalPeriod = this.config.seasonalityPeriods;
+    for (let i = seasonalPeriod; i < dataPoints.length; i++) {
+      const currentValue = values[i];
+      const seasonalBaseline = values[i - seasonalPeriod];
+      const seasonalDeviation = Math.abs(currentValue - seasonalBaseline);
+      const seasonalDeviationPercentage = seasonalBaseline === 0 ? 0 : seasonalDeviation / seasonalBaseline * 100;
+      const threshold = seasonalBaseline * 0.3;
+      if (seasonalDeviation > threshold && seasonalDeviationPercentage > 25) {
+        anomalies.push({
+          timestamp: dataPoints[i].timestamp,
+          actualValue: currentValue,
+          expectedValue: seasonalBaseline,
+          deviation: seasonalDeviation,
+          deviationPercentage: seasonalDeviationPercentage,
+          severity: this.calculateSeverity(seasonalDeviationPercentage, 25),
+          confidence: 80,
+          type: "SEASONAL_ANOMALY",
+          description: `Unusual seasonal pattern: ${seasonalDeviationPercentage.toFixed(1)}% deviation from same period last cycle`,
+          potentialCauses: this.generatePotentialCauses("SEASONAL_ANOMALY", seasonalDeviationPercentage)
+        });
+      }
+    }
+    return anomalies;
+  }
+  calculateMedian(values) {
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+  }
+  calculateMAD(values, median) {
+    const deviations = values.map((v) => Math.abs(v - median));
+    return this.calculateMedian(deviations);
+  }
+  calculateLinearTrend(values) {
+    const n = values.length;
+    const x = Array.from({ length: n }, (_, i) => i);
+    const sumX = x.reduce((a, b) => a + b, 0);
+    const sumY = values.reduce((a, b) => a + b, 0);
+    const sumXY = x.reduce((sum, xi, i) => sum + xi * values[i], 0);
+    const sumXX = x.reduce((sum, xi) => sum + xi * xi, 0);
+    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+    return slope;
+  }
+  getSensitivityThreshold() {
+    switch (this.config.sensitivity) {
+      case "HIGH":
+        return 2.5;
+      case "MEDIUM":
+        return 3.5;
+      case "LOW":
+        return 4.5;
+      default:
+        return 3.5;
+    }
+  }
+  calculateSeverity(score, threshold) {
+    const ratio = score / threshold;
+    if (ratio > 3)
+      return "CRITICAL";
+    if (ratio > 2)
+      return "HIGH";
+    if (ratio > 1.5)
+      return "MEDIUM";
+    return "LOW";
+  }
+  generateAnomalyDescription(type, deviation, deviationPercentage) {
+    const direction = deviation > 0 ? "increase" : "decrease";
+    const magnitude = deviationPercentage > 100 ? "massive" : deviationPercentage > 50 ? "significant" : deviationPercentage > 25 ? "notable" : "minor";
+    return `${type.toLowerCase()} anomaly detected: ${magnitude} ${direction} of ${deviationPercentage.toFixed(1)}%`;
+  }
+  generatePotentialCauses(type, deviationPercentage) {
+    const causes = [];
+    switch (type) {
+      case "SPIKE":
+        causes.push("Increased resource usage or traffic");
+        causes.push("New service deployments or scaling events");
+        causes.push("Data transfer spikes or storage usage increases");
+        if (deviationPercentage > 50) {
+          causes.push("Potential security incident or DDoS attack");
+          causes.push("Misconfigured auto-scaling rules");
+        }
+        break;
+      case "DROP":
+        causes.push("Reduced usage or traffic patterns");
+        causes.push("Service shutdowns or downscaling");
+        causes.push("Resource optimization implementations");
+        if (deviationPercentage > 50) {
+          causes.push("Service outages or failures");
+          causes.push("Billing or account issues");
+        }
+        break;
+      case "TREND_CHANGE":
+        causes.push("Business growth or contraction");
+        causes.push("Architectural changes or migrations");
+        causes.push("New feature rollouts or service changes");
+        causes.push("Seasonal business pattern shifts");
+        break;
+      case "SEASONAL_ANOMALY":
+        causes.push("Unusual business events or promotions");
+        causes.push("Holiday pattern deviations");
+        causes.push("Market or economic factors");
+        causes.push("Competitor actions or market changes");
+        break;
+    }
+    return causes;
+  }
+  consolidateAnomalies(anomalies) {
+    const groupedAnomalies = /* @__PURE__ */ new Map();
+    anomalies.forEach((anomaly) => {
+      const key = anomaly.timestamp;
+      if (!groupedAnomalies.has(key)) {
+        groupedAnomalies.set(key, []);
+      }
+      groupedAnomalies.get(key).push(anomaly);
+    });
+    const consolidated = [];
+    groupedAnomalies.forEach((group) => {
+      const sorted = group.sort((a, b) => {
+        const severityOrder = { "CRITICAL": 4, "HIGH": 3, "MEDIUM": 2, "LOW": 1 };
+        if (severityOrder[a.severity] !== severityOrder[b.severity]) {
+          return severityOrder[b.severity] - severityOrder[a.severity];
+        }
+        return b.confidence - a.confidence;
+      });
+      consolidated.push(sorted[0]);
+    });
+    return consolidated.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  }
+};
+var CostAnalyticsEngine = class {
+  constructor(config) {
+    this.anomalyDetector = new AnomalyDetector(config);
+  }
+  analyzeProvider(provider, costData, serviceData) {
+    const analytics = {
+      provider,
+      analysisDate: (/* @__PURE__ */ new Date()).toISOString(),
+      overallAnomalies: this.anomalyDetector.detectAnomalies(costData),
+      serviceAnomalies: {},
+      insights: this.generateInsights(costData),
+      recommendations: this.generateRecommendations(costData)
+    };
+    if (serviceData) {
+      Object.entries(serviceData).forEach(([service, data]) => {
+        analytics.serviceAnomalies[service] = this.anomalyDetector.detectAnomalies(data);
+      });
+    }
+    return analytics;
+  }
+  generateInsights(costData) {
+    const insights = [];
+    const values = costData.map((dp) => dp.value);
+    if (values.length < 7)
+      return insights;
+    const latest = values[values.length - 1];
+    const weekAgo = values[values.length - 7];
+    const monthAgo = values.length > 30 ? values[values.length - 30] : values[0];
+    const weekGrowth = weekAgo > 0 ? (latest - weekAgo) / weekAgo * 100 : 0;
+    const monthGrowth = monthAgo > 0 ? (latest - monthAgo) / monthAgo * 100 : 0;
+    if (Math.abs(weekGrowth) > 15) {
+      insights.push(`Significant week-over-week cost ${weekGrowth > 0 ? "increase" : "decrease"} of ${Math.abs(weekGrowth).toFixed(1)}%`);
+    }
+    if (Math.abs(monthGrowth) > 25) {
+      insights.push(`Notable month-over-month cost ${monthGrowth > 0 ? "growth" : "reduction"} of ${Math.abs(monthGrowth).toFixed(1)}%`);
+    }
+    const volatility = this.calculateVolatility(values);
+    if (volatility > 0.3) {
+      insights.push(`High cost volatility detected (${(volatility * 100).toFixed(1)}%) - consider investigating irregular spending patterns`);
+    }
+    return insights;
+  }
+  generateRecommendations(costData) {
+    const recommendations = [];
+    const values = costData.map((dp) => dp.value);
+    const volatility = this.calculateVolatility(values);
+    const trend = this.anomalyDetector["calculateLinearTrend"](values.slice(-14));
+    if (volatility > 0.2) {
+      recommendations.push("Implement cost budgets and alerts to better track spending variations");
+      recommendations.push("Consider using reserved instances or savings plans for more predictable costs");
+    }
+    if (trend > 0.1) {
+      recommendations.push("Cost trend is increasing - review recent resource additions and scaling policies");
+      recommendations.push("Consider implementing automated cost optimization tools");
+    }
+    return recommendations;
+  }
+  calculateVolatility(values) {
+    if (values.length < 2)
+      return 0;
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
+    const stdDev = Math.sqrt(variance);
+    return mean > 0 ? stdDev / mean : 0;
+  }
+};
+
+// src/providers/aws.ts
+var AWSProvider = class extends CloudProviderAdapter {
+  constructor(config) {
+    super(config);
+  }
+  getCredentials() {
+    return this.config.credentials;
+  }
+  getRegion() {
+    return this.config.region || "us-east-1";
+  }
+  async validateCredentials() {
+    try {
+      const sts = new STSClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      await sts.send(new GetCallerIdentityCommand({}));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getAccountInfo() {
+    var _a;
+    showSpinner("Getting AWS account information");
+    try {
+      const iam = new IAMClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      const accountAliases = await iam.send(new ListAccountAliasesCommand({}));
+      const foundAlias = (_a = accountAliases == null ? void 0 : accountAliases.AccountAliases) == null ? void 0 : _a[0];
+      if (foundAlias) {
+        return {
+          id: foundAlias,
+          name: foundAlias,
+          provider: "aws" /* AWS */
+        };
+      }
+      const sts = new STSClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      const accountInfo = await sts.send(new GetCallerIdentityCommand({}));
+      return {
+        id: accountInfo.Account || "unknown",
+        name: accountInfo.Account || "unknown",
+        provider: "aws" /* AWS */
+      };
+    } catch (error) {
+      throw new Error(`Failed to get AWS account information: ${error.message}`);
+    }
+  }
+  async getRawCostData() {
+    var _a, _b, _c, _d;
+    showSpinner("Getting AWS pricing data");
+    try {
+      const costExplorer = new CostExplorerClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      const endDate = dayjs().subtract(1, "day");
+      const startDate = endDate.subtract(65, "day");
+      const pricingData = await costExplorer.send(new GetCostAndUsageCommand({
+        TimePeriod: {
+          Start: startDate.format("YYYY-MM-DD"),
+          End: endDate.format("YYYY-MM-DD")
+        },
+        Granularity: "DAILY",
+        Filter: {
+          Not: {
+            Dimensions: {
+              Key: "RECORD_TYPE",
+              Values: ["Credit", "Refund", "Upfront", "Support"]
+            }
+          }
+        },
+        Metrics: ["UnblendedCost"],
+        GroupBy: [
+          {
+            Type: "DIMENSION",
+            Key: "SERVICE"
+          }
+        ]
+      }));
+      const costByService = {};
+      for (const day of pricingData.ResultsByTime || []) {
+        for (const group of day.Groups || []) {
+          const serviceName = (_a = group.Keys) == null ? void 0 : _a[0];
+          const cost = (_c = (_b = group.Metrics) == null ? void 0 : _b.UnblendedCost) == null ? void 0 : _c.Amount;
+          const costDate = (_d = day.TimePeriod) == null ? void 0 : _d.End;
+          if (serviceName && cost && costDate) {
+            costByService[serviceName] = costByService[serviceName] || {};
+            costByService[serviceName][costDate] = parseFloat(cost);
+          }
+        }
+      }
+      return costByService;
+    } catch (error) {
+      throw new Error(`Failed to get AWS cost data: ${error.message}`);
+    }
+  }
+  async getCostBreakdown() {
+    const rawCostData = await this.getRawCostData();
+    return this.calculateServiceTotals(rawCostData);
+  }
+  async getResourceInventory(filters) {
+    showSpinner("Discovering AWS resources");
+    const regions = (filters == null ? void 0 : filters.regions) || [this.config.region || "us-east-1"];
+    const resourceTypes = (filters == null ? void 0 : filters.resourceTypes) || Object.values(ResourceType);
+    const includeCosts = (filters == null ? void 0 : filters.includeCosts) || false;
+    const inventory = {
+      provider: "aws" /* AWS */,
+      region: regions.join(", "),
+      totalResources: 0,
+      resourcesByType: {
+        ["compute" /* COMPUTE */]: 0,
+        ["storage" /* STORAGE */]: 0,
+        ["database" /* DATABASE */]: 0,
+        ["network" /* NETWORK */]: 0,
+        ["security" /* SECURITY */]: 0,
+        ["serverless" /* SERVERLESS */]: 0,
+        ["container" /* CONTAINER */]: 0,
+        ["analytics" /* ANALYTICS */]: 0
+      },
+      totalCost: 0,
+      resources: {
+        compute: [],
+        storage: [],
+        database: [],
+        network: [],
+        security: [],
+        serverless: [],
+        container: [],
+        analytics: []
+      },
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    for (const region of regions) {
+      try {
+        if (resourceTypes.includes("compute" /* COMPUTE */)) {
+          const ec2Resources = await this.discoverEC2Instances(region, includeCosts);
+          inventory.resources.compute.push(...ec2Resources);
+          inventory.resourcesByType["compute" /* COMPUTE */] += ec2Resources.length;
+        }
+        if (resourceTypes.includes("storage" /* STORAGE */)) {
+          const s3Resources = await this.discoverS3Buckets(region, includeCosts);
+          const ebsResources = await this.discoverEBSVolumes(region, includeCosts);
+          inventory.resources.storage.push(...s3Resources, ...ebsResources);
+          inventory.resourcesByType["storage" /* STORAGE */] += s3Resources.length + ebsResources.length;
+        }
+        if (resourceTypes.includes("database" /* DATABASE */)) {
+          const rdsResources = await this.discoverRDSInstances(region, includeCosts);
+          inventory.resources.database.push(...rdsResources);
+          inventory.resourcesByType["database" /* DATABASE */] += rdsResources.length;
+        }
+        if (resourceTypes.includes("serverless" /* SERVERLESS */)) {
+          const lambdaResources = await this.discoverLambdaFunctions(region, includeCosts);
+          inventory.resources.serverless.push(...lambdaResources);
+          inventory.resourcesByType["serverless" /* SERVERLESS */] += lambdaResources.length;
+        }
+        if (resourceTypes.includes("network" /* NETWORK */)) {
+          const vpcResources = await this.discoverVPCs(region, includeCosts);
+          const subnetResources = await this.discoverSubnets(region, includeCosts);
+          inventory.resources.network.push(...vpcResources, ...subnetResources);
+          inventory.resourcesByType["network" /* NETWORK */] += vpcResources.length + subnetResources.length;
+        }
+      } catch (error) {
+        console.warn(`Failed to discover resources in region ${region}: ${error.message}`);
+      }
+    }
+    inventory.totalResources = Object.values(inventory.resourcesByType).reduce((sum, count) => sum + count, 0);
+    if (includeCosts) {
+      inventory.totalCost = Object.values(inventory.resources).flat().reduce((sum, resource) => sum + (resource.costToDate || 0), 0);
+    }
+    return inventory;
+  }
+  async discoverEC2Instances(region, includeCosts) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    try {
+      const ec2Client = new EC2Client({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new DescribeInstancesCommand({});
+      const result = await ec2Client.send(command);
+      const instances = [];
+      for (const reservation of result.Reservations || []) {
+        for (const instance of reservation.Instances || []) {
+          const ec2Instance = {
+            id: instance.InstanceId || "",
+            name: ((_b = (_a = instance.Tags) == null ? void 0 : _a.find((tag) => tag.Key === "Name")) == null ? void 0 : _b.Value) || instance.InstanceId || "",
+            state: ((_c = instance.State) == null ? void 0 : _c.Name) || "unknown",
+            region,
+            tags: (_d = instance.Tags) == null ? void 0 : _d.reduce((acc, tag) => {
+              if (tag.Key && tag.Value)
+                acc[tag.Key] = tag.Value;
+              return acc;
+            }, {}),
+            createdAt: instance.LaunchTime || /* @__PURE__ */ new Date(),
+            provider: "aws" /* AWS */,
+            instanceType: instance.InstanceType,
+            cpu: this.getCpuCountForInstanceType(instance.InstanceType),
+            memory: this.getMemoryForInstanceType(instance.InstanceType),
+            platform: instance.Platform || "linux",
+            instanceId: instance.InstanceId || "",
+            imageId: instance.ImageId || "",
+            keyName: instance.KeyName,
+            securityGroups: ((_e = instance.SecurityGroups) == null ? void 0 : _e.map((sg) => sg.GroupId || "")) || [],
+            subnetId: instance.SubnetId || "",
+            vpcId: instance.VpcId || "",
+            publicDnsName: instance.PublicDnsName,
+            privateDnsName: instance.PrivateDnsName,
+            monitoring: ((_f = instance.Monitoring) == null ? void 0 : _f.State) === "enabled",
+            placement: {
+              availabilityZone: ((_g = instance.Placement) == null ? void 0 : _g.AvailabilityZone) || "",
+              groupName: (_h = instance.Placement) == null ? void 0 : _h.GroupName
+            },
+            publicIp: instance.PublicIpAddress,
+            privateIp: instance.PrivateIpAddress
+          };
+          if (includeCosts) {
+            ec2Instance.costToDate = await this.getResourceCosts(instance.InstanceId || "");
+          }
+          instances.push(ec2Instance);
+        }
+      }
+      return instances;
+    } catch (error) {
+      console.warn(`Failed to discover EC2 instances in ${region}: ${error.message}`);
+      return [];
+    }
+  }
+  async discoverS3Buckets(region, includeCosts) {
+    try {
+      const s3Client = new S3Client({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new ListBucketsCommand({});
+      const result = await s3Client.send(command);
+      const buckets = [];
+      for (const bucket of result.Buckets || []) {
+        if (!bucket.Name)
+          continue;
+        const s3Bucket = {
+          id: bucket.Name,
+          name: bucket.Name,
+          state: "active",
+          region,
+          createdAt: bucket.CreationDate || /* @__PURE__ */ new Date(),
+          provider: "aws" /* AWS */,
+          sizeGB: 0,
+          // Would need additional API calls to get actual size
+          storageType: "S3",
+          bucketName: bucket.Name
+        };
+        if (includeCosts) {
+          s3Bucket.costToDate = await this.getResourceCosts(bucket.Name);
+        }
+        buckets.push(s3Bucket);
+      }
+      return buckets;
+    } catch (error) {
+      console.warn(`Failed to discover S3 buckets: ${error.message}`);
+      return [];
+    }
+  }
+  async discoverEBSVolumes(region, includeCosts) {
+    var _a, _b, _c, _d;
+    try {
+      const ec2Client = new EC2Client({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new DescribeVolumesCommand({});
+      const result = await ec2Client.send(command);
+      const volumes = [];
+      for (const volume of result.Volumes || []) {
+        if (!volume.VolumeId)
+          continue;
+        const ebsVolume = {
+          id: volume.VolumeId,
+          name: ((_b = (_a = volume.Tags) == null ? void 0 : _a.find((tag) => tag.Key === "Name")) == null ? void 0 : _b.Value) || volume.VolumeId,
+          state: volume.State || "unknown",
+          region,
+          tags: (_c = volume.Tags) == null ? void 0 : _c.reduce((acc, tag) => {
+            if (tag.Key && tag.Value)
+              acc[tag.Key] = tag.Value;
+            return acc;
+          }, {}),
+          createdAt: volume.CreateTime || /* @__PURE__ */ new Date(),
+          provider: "aws" /* AWS */,
+          sizeGB: volume.Size || 0,
+          storageType: volume.VolumeType || "gp2",
+          encrypted: volume.Encrypted,
+          volumeId: volume.VolumeId,
+          volumeType: volume.VolumeType || "gp2",
+          iops: volume.Iops,
+          throughput: volume.Throughput,
+          attachments: (_d = volume.Attachments) == null ? void 0 : _d.map((attachment) => ({
+            instanceId: attachment.InstanceId || "",
+            device: attachment.Device || ""
+          })),
+          snapshotId: volume.SnapshotId
+        };
+        if (includeCosts) {
+          ebsVolume.costToDate = await this.getResourceCosts(volume.VolumeId);
+        }
+        volumes.push(ebsVolume);
+      }
+      return volumes;
+    } catch (error) {
+      console.warn(`Failed to discover EBS volumes in ${region}: ${error.message}`);
+      return [];
+    }
+  }
+  async discoverRDSInstances(region, includeCosts) {
+    var _a, _b;
+    try {
+      const rdsClient = new RDSClient({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new DescribeDBInstancesCommand({});
+      const result = await rdsClient.send(command);
+      const instances = [];
+      for (const dbInstance of result.DBInstances || []) {
+        if (!dbInstance.DBInstanceIdentifier)
+          continue;
+        const rdsInstance = {
+          id: dbInstance.DBInstanceIdentifier,
+          name: dbInstance.DBName || dbInstance.DBInstanceIdentifier,
+          state: dbInstance.DBInstanceStatus || "unknown",
+          region,
+          createdAt: dbInstance.InstanceCreateTime || /* @__PURE__ */ new Date(),
+          provider: "aws" /* AWS */,
+          engine: dbInstance.Engine || "",
+          version: dbInstance.EngineVersion || "",
+          instanceClass: dbInstance.DBInstanceClass,
+          storageGB: dbInstance.AllocatedStorage,
+          multiAZ: dbInstance.MultiAZ,
+          dbInstanceIdentifier: dbInstance.DBInstanceIdentifier,
+          dbName: dbInstance.DBName,
+          masterUsername: dbInstance.MasterUsername || "",
+          endpoint: (_a = dbInstance.Endpoint) == null ? void 0 : _a.Address,
+          port: (_b = dbInstance.Endpoint) == null ? void 0 : _b.Port,
+          availabilityZone: dbInstance.AvailabilityZone,
+          backupRetentionPeriod: dbInstance.BackupRetentionPeriod,
+          storageEncrypted: dbInstance.StorageEncrypted
+        };
+        if (includeCosts) {
+          rdsInstance.costToDate = await this.getResourceCosts(dbInstance.DBInstanceIdentifier);
+        }
+        instances.push(rdsInstance);
+      }
+      return instances;
+    } catch (error) {
+      console.warn(`Failed to discover RDS instances in ${region}: ${error.message}`);
+      return [];
+    }
+  }
+  async discoverLambdaFunctions(region, includeCosts) {
+    try {
+      const lambdaClient = new LambdaClient({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new ListFunctionsCommand({});
+      const result = await lambdaClient.send(command);
+      const functions = [];
+      for (const func of result.Functions || []) {
+        if (!func.FunctionName)
+          continue;
+        const lambdaFunction = {
+          id: func.FunctionArn || func.FunctionName,
+          name: func.FunctionName,
+          state: func.State || "unknown",
+          region,
+          createdAt: /* @__PURE__ */ new Date(),
+          // Lambda doesn't provide creation time in list
+          provider: "aws" /* AWS */,
+          functionName: func.FunctionName,
+          runtime: func.Runtime || "",
+          handler: func.Handler || "",
+          codeSize: func.CodeSize || 0,
+          timeout: func.Timeout || 0,
+          memorySize: func.MemorySize || 0,
+          lastModified: new Date(func.LastModified || ""),
+          version: func.Version || ""
+        };
+        if (includeCosts) {
+          lambdaFunction.costToDate = await this.getResourceCosts(func.FunctionName);
+        }
+        functions.push(lambdaFunction);
+      }
+      return functions;
+    } catch (error) {
+      console.warn(`Failed to discover Lambda functions in ${region}: ${error.message}`);
+      return [];
+    }
+  }
+  async discoverVPCs(region, includeCosts) {
+    var _a, _b, _c;
+    try {
+      const ec2Client = new EC2Client({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new DescribeVpcsCommand({});
+      const result = await ec2Client.send(command);
+      const vpcs = [];
+      for (const vpc of result.Vpcs || []) {
+        if (!vpc.VpcId)
+          continue;
+        const awsVpc = {
+          id: vpc.VpcId,
+          name: ((_b = (_a = vpc.Tags) == null ? void 0 : _a.find((tag) => tag.Key === "Name")) == null ? void 0 : _b.Value) || vpc.VpcId,
+          state: vpc.State || "unknown",
+          region,
+          tags: (_c = vpc.Tags) == null ? void 0 : _c.reduce((acc, tag) => {
+            if (tag.Key && tag.Value)
+              acc[tag.Key] = tag.Value;
+            return acc;
+          }, {}),
+          createdAt: /* @__PURE__ */ new Date(),
+          // VPC doesn't provide creation time
+          provider: "aws" /* AWS */,
+          vpcId: vpc.VpcId,
+          cidrBlock: vpc.CidrBlock || "",
+          dhcpOptionsId: vpc.DhcpOptionsId || "",
+          isDefault: vpc.IsDefault || false
+        };
+        if (includeCosts) {
+          awsVpc.costToDate = await this.getResourceCosts(vpc.VpcId);
+        }
+        vpcs.push(awsVpc);
+      }
+      return vpcs;
+    } catch (error) {
+      console.warn(`Failed to discover VPCs in ${region}: ${error.message}`);
+      return [];
+    }
+  }
+  async discoverSubnets(region, includeCosts) {
+    var _a, _b, _c;
+    try {
+      const ec2Client = new EC2Client({
+        credentials: this.getCredentials(),
+        region
+      });
+      const command = new DescribeSubnetsCommand({});
+      const result = await ec2Client.send(command);
+      const subnets = [];
+      for (const subnet of result.Subnets || []) {
+        if (!subnet.SubnetId)
+          continue;
+        const awsSubnet = {
+          id: subnet.SubnetId,
+          name: ((_b = (_a = subnet.Tags) == null ? void 0 : _a.find((tag) => tag.Key === "Name")) == null ? void 0 : _b.Value) || subnet.SubnetId,
+          state: subnet.State || "unknown",
+          region,
+          tags: (_c = subnet.Tags) == null ? void 0 : _c.reduce((acc, tag) => {
+            if (tag.Key && tag.Value)
+              acc[tag.Key] = tag.Value;
+            return acc;
+          }, {}),
+          createdAt: /* @__PURE__ */ new Date(),
+          // Subnet doesn't provide creation time
+          provider: "aws" /* AWS */,
+          subnetId: subnet.SubnetId,
+          vpcId: subnet.VpcId || "",
+          cidrBlock: subnet.CidrBlock || "",
+          availableIpAddressCount: subnet.AvailableIpAddressCount || 0,
+          availabilityZone: subnet.AvailabilityZone || "",
+          mapPublicIpOnLaunch: subnet.MapPublicIpOnLaunch || false
+        };
+        if (includeCosts) {
+          awsSubnet.costToDate = await this.getResourceCosts(subnet.SubnetId);
+        }
+        subnets.push(awsSubnet);
+      }
+      return subnets;
+    } catch (error) {
+      console.warn(`Failed to discover Subnets in ${region}: ${error.message}`);
+      return [];
+    }
+  }
+  async getResourceCosts(resourceId) {
+    return 0;
+  }
+  async getOptimizationRecommendations() {
+    const recommendations = [];
+    try {
+      recommendations.push(
+        "Consider using Reserved Instances for long-running EC2 instances to save up to 72%",
+        "Enable S3 Intelligent Tiering for automatic cost optimization",
+        "Review underutilized RDS instances and consider right-sizing",
+        "Implement lifecycle policies for EBS snapshots older than 30 days",
+        "Consider using Spot Instances for fault-tolerant workloads"
+      );
+    } catch (error) {
+      console.warn(`Failed to generate optimization recommendations: ${error.message}`);
+    }
+    return recommendations;
+  }
+  async getBudgets() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    showSpinner("Getting AWS budgets");
+    try {
+      const budgetsClient = new BudgetsClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      const sts = new STSClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      const accountInfo = await sts.send(new GetCallerIdentityCommand({}));
+      const accountId = accountInfo.Account;
+      if (!accountId) {
+        throw new Error("Unable to determine AWS account ID");
+      }
+      const budgetsResponse = await budgetsClient.send(new DescribeBudgetsCommand({
+        AccountId: accountId
+      }));
+      const budgets = [];
+      for (const budget of budgetsResponse.Budgets || []) {
+        if (!budget.BudgetName || !budget.BudgetLimit)
+          continue;
+        const budgetInfo = {
+          budgetName: budget.BudgetName,
+          budgetLimit: parseFloat(budget.BudgetLimit.Amount || "0"),
+          actualSpend: parseFloat(((_b = (_a = budget.CalculatedSpend) == null ? void 0 : _a.ActualSpend) == null ? void 0 : _b.Amount) || "0"),
+          forecastedSpend: parseFloat(((_d = (_c = budget.CalculatedSpend) == null ? void 0 : _c.ForecastedSpend) == null ? void 0 : _d.Amount) || "0"),
+          timeUnit: budget.TimeUnit || "MONTHLY",
+          timePeriod: {
+            start: typeof ((_e = budget.TimePeriod) == null ? void 0 : _e.Start) === "string" ? (_f = budget.TimePeriod) == null ? void 0 : _f.Start : ((_g = budget.TimePeriod) == null ? void 0 : _g.Start) instanceof Date ? (_h = budget.TimePeriod) == null ? void 0 : _h.Start.toISOString() : "",
+            end: typeof ((_i = budget.TimePeriod) == null ? void 0 : _i.End) === "string" ? (_j = budget.TimePeriod) == null ? void 0 : _j.End : ((_k = budget.TimePeriod) == null ? void 0 : _k.End) instanceof Date ? (_l = budget.TimePeriod) == null ? void 0 : _l.End.toISOString() : ""
+          },
+          budgetType: budget.BudgetType || "COST",
+          status: this.determineBudgetStatus(budget),
+          thresholds: this.parseBudgetThresholds(budget),
+          costFilters: this.parseCostFilters(budget)
+        };
+        budgets.push(budgetInfo);
+      }
+      return budgets;
+    } catch (error) {
+      console.warn(`Failed to get AWS budgets: ${error.message}`);
+      return [];
+    }
+  }
+  async getBudgetAlerts() {
+    const budgets = await this.getBudgets();
+    const alerts = [];
+    for (const budget of budgets) {
+      const percentageUsed = budget.actualSpend / budget.budgetLimit * 100;
+      for (const threshold of budget.thresholds) {
+        let isExceeded = false;
+        let currentValue = 0;
+        if (threshold.thresholdType === "PERCENTAGE") {
+          currentValue = percentageUsed;
+          if (threshold.notificationType === "ACTUAL") {
+            isExceeded = percentageUsed >= threshold.threshold;
+          } else if (threshold.notificationType === "FORECASTED" && budget.forecastedSpend) {
+            const forecastedPercentage = budget.forecastedSpend / budget.budgetLimit * 100;
+            isExceeded = forecastedPercentage >= threshold.threshold;
+            currentValue = forecastedPercentage;
+          }
+        } else {
+          currentValue = budget.actualSpend;
+          if (threshold.notificationType === "ACTUAL") {
+            isExceeded = budget.actualSpend >= threshold.threshold;
+          } else if (threshold.notificationType === "FORECASTED" && budget.forecastedSpend) {
+            isExceeded = budget.forecastedSpend >= threshold.threshold;
+            currentValue = budget.forecastedSpend;
+          }
+        }
+        if (isExceeded) {
+          const alert = {
+            budgetName: budget.budgetName,
+            alertType: threshold.notificationType === "FORECASTED" ? "FORECAST_EXCEEDED" : "THRESHOLD_EXCEEDED",
+            currentSpend: budget.actualSpend,
+            budgetLimit: budget.budgetLimit,
+            threshold: threshold.threshold,
+            percentageUsed,
+            timeRemaining: this.calculateTimeRemaining(budget.timePeriod),
+            severity: this.determineSeverity(percentageUsed),
+            message: this.generateAlertMessage(budget, threshold, percentageUsed)
+          };
+          alerts.push(alert);
+        }
+      }
+    }
+    return alerts;
+  }
+  async getCostTrendAnalysis(months = 6) {
+    var _a, _b, _c, _d, _e;
+    showSpinner("Analyzing cost trends");
+    try {
+      const costExplorer = new CostExplorerClient({
+        credentials: this.getCredentials(),
+        region: this.getRegion()
+      });
+      const endDate = dayjs();
+      const startDate = endDate.subtract(months, "month");
+      const monthlyData = await costExplorer.send(new GetCostAndUsageCommand({
+        TimePeriod: {
+          Start: startDate.format("YYYY-MM-DD"),
+          End: endDate.format("YYYY-MM-DD")
+        },
+        Granularity: "MONTHLY",
+        Metrics: ["UnblendedCost"],
+        GroupBy: [
+          {
+            Type: "DIMENSION",
+            Key: "SERVICE"
+          }
+        ]
+      }));
+      const monthlyCosts = [];
+      const monthlyBreakdown = [];
+      const serviceTrends = {};
+      let totalCost = 0;
+      for (const result of monthlyData.ResultsByTime || []) {
+        const period = ((_a = result.TimePeriod) == null ? void 0 : _a.Start) || "";
+        const monthCost = ((_c = (_b = result.Total) == null ? void 0 : _b.UnblendedCost) == null ? void 0 : _c.Amount) ? parseFloat(result.Total.UnblendedCost.Amount) : 0;
+        monthlyCosts.push(monthCost);
+        totalCost += monthCost;
+        const services = {};
+        (_d = result.Groups) == null ? void 0 : _d.forEach((group) => {
+          var _a2, _b2, _c2;
+          const serviceName = ((_a2 = group.Keys) == null ? void 0 : _a2[0]) || "Unknown";
+          const cost = parseFloat(((_c2 = (_b2 = group.Metrics) == null ? void 0 : _b2.UnblendedCost) == null ? void 0 : _c2.Amount) || "0");
+          services[serviceName] = cost;
+          if (!serviceTrends[serviceName]) {
+            serviceTrends[serviceName] = [];
+          }
+          serviceTrends[serviceName].push(cost);
+        });
+        monthlyBreakdown.push({
+          month: period,
+          cost: monthCost,
+          services
+        });
+      }
+      const averageDailyCost = totalCost / (months * 30);
+      const projectedMonthlyCost = monthlyCosts.length > 0 ? monthlyCosts[monthlyCosts.length - 1] : averageDailyCost * 30;
+      let avgMonthOverMonthGrowth = 0;
+      if (monthlyCosts.length > 1) {
+        const growthRates = [];
+        for (let i = 1; i < monthlyCosts.length; i++) {
+          const growth = (monthlyCosts[i] - monthlyCosts[i - 1]) / monthlyCosts[i - 1] * 100;
+          growthRates.push(growth);
+        }
+        avgMonthOverMonthGrowth = growthRates.reduce((a, b) => a + b, 0) / growthRates.length;
+      }
+      const costAnomalies = [];
+      for (let i = 0; i < monthlyCosts.length; i++) {
+        const monthCost = monthlyCosts[i];
+        const period = ((_e = monthlyBreakdown[i]) == null ? void 0 : _e.month) || "";
+        if (i > 0) {
+          const prevMonthCost = monthlyCosts[i - 1];
+          const monthOverMonthChange = (monthCost - prevMonthCost) / prevMonthCost * 100;
+          if (Math.abs(monthOverMonthChange) > 25) {
+            costAnomalies.push({
+              date: period,
+              deviation: Math.abs(monthOverMonthChange),
+              severity: Math.abs(monthOverMonthChange) > 50 ? "CRITICAL" : "HIGH",
+              description: `${monthOverMonthChange > 0 ? "Spike" : "Drop"} in monthly costs: ${monthOverMonthChange.toFixed(1)}% MoM change`
+            });
+          }
+        }
+        if (i > 2) {
+          const avgOfPrevious = monthlyCosts.slice(0, i).reduce((a, b) => a + b, 0) / i;
+          const deviation = (monthCost - avgOfPrevious) / avgOfPrevious * 100;
+          if (Math.abs(deviation) > 30) {
+            costAnomalies.push({
+              date: period,
+              deviation: Math.abs(deviation),
+              severity: Math.abs(deviation) > 60 ? "CRITICAL" : "MEDIUM",
+              description: `Cost ${deviation > 0 ? "above" : "below"} ${months}-month average by ${Math.abs(deviation).toFixed(1)}%`
+            });
+          }
+        }
+      }
+      const serviceAnalysis = {};
+      Object.entries(serviceTrends).forEach(([service, costs]) => {
+        if (costs.length > 1) {
+          const currentCost = costs[costs.length - 1];
+          const previousCost = costs[costs.length - 2];
+          const growthRate = (currentCost - previousCost) / previousCost * 100;
+          const trend = Math.abs(growthRate) < 5 ? "stable" : growthRate > 0 ? "increasing" : "decreasing";
+          serviceAnalysis[service] = {
+            currentCost,
+            growthRate,
+            trend
+          };
+        }
+      });
+      const analyticsEngine = new CostAnalyticsEngine({
+        sensitivity: "MEDIUM",
+        lookbackPeriods: Math.min(14, monthlyBreakdown.length),
+        seasonalityPeriods: 12
+        // Monthly seasonality
+      });
+      const dataPoints = monthlyBreakdown.map((mb) => ({
+        timestamp: mb.month,
+        value: mb.cost
+      }));
+      const analytics = analyticsEngine.analyzeProvider("aws" /* AWS */, dataPoints);
+      const enhancedAnomalies = [...costAnomalies];
+      analytics.overallAnomalies.forEach((anomaly) => {
+        enhancedAnomalies.push({
+          date: anomaly.timestamp,
+          deviation: anomaly.deviationPercentage,
+          severity: anomaly.severity,
+          description: `${anomaly.description} (${anomaly.confidence.toFixed(0)}% confidence)`
+        });
+      });
+      return {
+        totalCost,
+        averageDailyCost,
+        projectedMonthlyCost,
+        avgMonthOverMonthGrowth,
+        costAnomalies: enhancedAnomalies,
+        monthlyBreakdown,
+        serviceTrends: serviceAnalysis,
+        forecastAccuracy: monthlyCosts.length > 3 ? this.calculateForecastAccuracy(monthlyCosts) : 0,
+        analytics: {
+          insights: analytics.insights,
+          recommendations: analytics.recommendations,
+          volatilityScore: this.calculateVolatility(monthlyCosts),
+          trendStrength: this.calculateTrendStrength(monthlyCosts)
+        }
+      };
+    } catch (error) {
+      console.error("Failed to get AWS cost trend analysis:", error);
+      return this.getMockTrendAnalysis(months);
+    }
+  }
+  calculateForecastAccuracy(monthlyCosts) {
+    if (monthlyCosts.length < 4)
+      return 0;
+    const n = monthlyCosts.length;
+    const lastThreeActual = monthlyCosts.slice(-3);
+    const trainData = monthlyCosts.slice(0, -3);
+    const prediction = trainData.reduce((a, b) => a + b, 0) / trainData.length;
+    const actualAvg = lastThreeActual.reduce((a, b) => a + b, 0) / lastThreeActual.length;
+    const accuracy = Math.max(0, 100 - Math.abs(prediction - actualAvg) / actualAvg * 100);
+    return Math.round(accuracy);
+  }
+  getMockTrendAnalysis(months) {
+    const monthlyCosts = Array.from({ length: months }, (_, i) => {
+      const baseCost = 1500 + Math.random() * 500;
+      const trend = 1 + i * 0.02;
+      const volatility = 0.8 + Math.random() * 0.4;
+      return baseCost * trend * volatility;
+    });
+    const totalCost = monthlyCosts.reduce((sum, cost) => sum + cost, 0);
+    const averageDailyCost = totalCost / (months * 30);
+    const projectedMonthlyCost = monthlyCosts[monthlyCosts.length - 1];
+    let avgMonthOverMonthGrowth = 0;
+    if (monthlyCosts.length > 1) {
+      const growthRates = [];
+      for (let i = 1; i < monthlyCosts.length; i++) {
+        const growth = (monthlyCosts[i] - monthlyCosts[i - 1]) / monthlyCosts[i - 1] * 100;
+        growthRates.push(growth);
+      }
+      avgMonthOverMonthGrowth = growthRates.reduce((a, b) => a + b, 0) / growthRates.length;
+    }
+    const costAnomalies = [];
+    if (months >= 3) {
+      costAnomalies.push({
+        date: new Date(Date.now() - 60 * 24 * 60 * 60 * 1e3).toISOString().split("T")[0],
+        deviation: 35.2,
+        severity: "MEDIUM",
+        description: "Cost spike due to increased EC2 usage during Black Friday traffic"
+      });
+      costAnomalies.push({
+        date: new Date(Date.now() - 90 * 24 * 60 * 60 * 1e3).toISOString().split("T")[0],
+        deviation: 28.7,
+        severity: "HIGH",
+        description: "Month-over-month increase of 28.7% in data transfer costs"
+      });
+    }
+    const mockServices = ["EC2-Instance", "S3", "RDS", "Lambda", "CloudFront"];
+    const monthlyBreakdown = monthlyCosts.map((cost, i) => {
+      const date = /* @__PURE__ */ new Date();
+      date.setMonth(date.getMonth() - (months - i - 1));
+      const services = {};
+      mockServices.forEach((service) => {
+        services[service] = cost * (0.1 + Math.random() * 0.3);
+      });
+      return {
+        month: date.toISOString().split("T")[0],
+        cost,
+        services
+      };
+    });
+    const serviceTrends = {
+      "EC2-Instance": { currentCost: 850, growthRate: 12.3, trend: "increasing" },
+      "S3": { currentCost: 125, growthRate: -5.2, trend: "decreasing" },
+      "RDS": { currentCost: 420, growthRate: 2.1, trend: "stable" },
+      "Lambda": { currentCost: 45, growthRate: 25.6, trend: "increasing" },
+      "CloudFront": { currentCost: 78, growthRate: -1.8, trend: "stable" }
+    };
+    return {
+      totalCost,
+      averageDailyCost,
+      projectedMonthlyCost,
+      avgMonthOverMonthGrowth,
+      costAnomalies,
+      monthlyBreakdown,
+      serviceTrends,
+      forecastAccuracy: 87
+    };
+  }
+  async getFinOpsRecommendations() {
+    const recommendations = [
+      {
+        id: "aws-ri-ec2",
+        type: "RESERVED_CAPACITY",
+        title: "Purchase EC2 Reserved Instances",
+        description: "Long-running EC2 instances can benefit from Reserved Instance pricing",
+        potentialSavings: {
+          amount: 500,
+          percentage: 72,
+          timeframe: "MONTHLY"
+        },
+        effort: "LOW",
+        priority: "HIGH",
+        implementationSteps: [
+          "Analyze EC2 usage patterns over the past 30 days",
+          "Identify instances running >75% of the time",
+          "Purchase 1-year or 3-year Reserved Instances",
+          "Monitor utilization and adjust as needed"
+        ],
+        tags: ["ec2", "reserved-instances", "cost-optimization"]
+      },
+      {
+        id: "aws-s3-lifecycle",
+        type: "COST_OPTIMIZATION",
+        title: "Implement S3 Lifecycle Policies",
+        description: "Automatically transition old S3 data to cheaper storage classes",
+        potentialSavings: {
+          amount: 150,
+          percentage: 40,
+          timeframe: "MONTHLY"
+        },
+        effort: "MEDIUM",
+        priority: "MEDIUM",
+        implementationSteps: [
+          "Analyze S3 access patterns",
+          "Create lifecycle policies for infrequently accessed data",
+          "Transition to IA after 30 days, Glacier after 90 days",
+          "Enable Intelligent Tiering for dynamic workloads"
+        ],
+        tags: ["s3", "lifecycle", "storage-optimization"]
+      },
+      {
+        id: "aws-rightsizing",
+        type: "RESOURCE_RIGHTSIZING",
+        title: "Right-size Underutilized Resources",
+        description: "Reduce costs by downsizing underutilized EC2 and RDS instances",
+        potentialSavings: {
+          amount: 300,
+          percentage: 25,
+          timeframe: "MONTHLY"
+        },
+        effort: "HIGH",
+        priority: "HIGH",
+        implementationSteps: [
+          "Enable CloudWatch detailed monitoring",
+          "Analyze CPU, memory, and network utilization",
+          "Identify instances with <40% average utilization",
+          "Plan maintenance windows for resizing",
+          "Test application performance after changes"
+        ],
+        tags: ["rightsizing", "ec2", "rds", "performance-optimization"]
+      }
+    ];
+    return recommendations;
+  }
+  // Helper methods for instance types (simplified mapping)
+  getCpuCountForInstanceType(instanceType) {
+    if (!instanceType)
+      return 0;
+    const cpuMap = {
+      "t2.nano": 1,
+      "t2.micro": 1,
+      "t2.small": 1,
+      "t2.medium": 2,
+      "t2.large": 2,
+      "m5.large": 2,
+      "m5.xlarge": 4,
+      "m5.2xlarge": 8,
+      "m5.4xlarge": 16,
+      "c5.large": 2,
+      "c5.xlarge": 4,
+      "c5.2xlarge": 8,
+      "c5.4xlarge": 16
+    };
+    return cpuMap[instanceType] || 1;
+  }
+  getMemoryForInstanceType(instanceType) {
+    if (!instanceType)
+      return 0;
+    const memoryMap = {
+      "t2.nano": 0.5,
+      "t2.micro": 1,
+      "t2.small": 2,
+      "t2.medium": 4,
+      "t2.large": 8,
+      "m5.large": 8,
+      "m5.xlarge": 16,
+      "m5.2xlarge": 32,
+      "m5.4xlarge": 64,
+      "c5.large": 4,
+      "c5.xlarge": 8,
+      "c5.2xlarge": 16,
+      "c5.4xlarge": 32
+    };
+    return memoryMap[instanceType] || 1;
+  }
+  // Helper methods for budget functionality
+  determineBudgetStatus(budget) {
+    var _a, _b, _c;
+    if (!budget.CalculatedSpend)
+      return "OK";
+    const actual = parseFloat(((_a = budget.CalculatedSpend.ActualSpend) == null ? void 0 : _a.Amount) || "0");
+    const limit = parseFloat(((_b = budget.BudgetLimit) == null ? void 0 : _b.Amount) || "0");
+    const forecasted = parseFloat(((_c = budget.CalculatedSpend.ForecastedSpend) == null ? void 0 : _c.Amount) || "0");
+    if (actual >= limit)
+      return "ALARM";
+    if (forecasted >= limit)
+      return "FORECASTED_ALARM";
+    return "OK";
+  }
+  parseBudgetThresholds(budget) {
+    return [
+      {
+        threshold: 80,
+        thresholdType: "PERCENTAGE",
+        comparisonOperator: "GREATER_THAN",
+        notificationType: "ACTUAL"
+      },
+      {
+        threshold: 100,
+        thresholdType: "PERCENTAGE",
+        comparisonOperator: "GREATER_THAN",
+        notificationType: "FORECASTED"
+      }
+    ];
+  }
+  parseCostFilters(budget) {
+    return budget.CostFilters || {};
+  }
+  calculateTimeRemaining(timePeriod) {
+    if (!timePeriod.end)
+      return "Unknown";
+    const endDate = dayjs(timePeriod.end);
+    const now = dayjs();
+    const daysRemaining = endDate.diff(now, "day");
+    if (daysRemaining <= 0)
+      return "Period ended";
+    if (daysRemaining === 1)
+      return "1 day";
+    return `${daysRemaining} days`;
+  }
+  determineSeverity(percentageUsed) {
+    if (percentageUsed >= 100)
+      return "CRITICAL";
+    if (percentageUsed >= 90)
+      return "HIGH";
+    if (percentageUsed >= 75)
+      return "MEDIUM";
+    return "LOW";
+  }
+  generateAlertMessage(budget, threshold, percentageUsed) {
+    const thresholdType = threshold.thresholdType === "PERCENTAGE" ? "%" : "$";
+    return `Budget "${budget.budgetName}" has ${threshold.notificationType.toLowerCase()} ${threshold.threshold}${thresholdType} threshold (currently at ${percentageUsed.toFixed(1)}%)`;
+  }
+  async getTopServices(startDate, endDate) {
+    return [
+      {
+        serviceName: "Amazon Elastic Compute Cloud - Compute",
+        cost: 1250.45,
+        percentage: 45.2,
+        trend: "INCREASING"
+      },
+      {
+        serviceName: "Amazon Simple Storage Service",
+        cost: 680.23,
+        percentage: 24.6,
+        trend: "STABLE"
+      },
+      {
+        serviceName: "Amazon Relational Database Service",
+        cost: 445.67,
+        percentage: 16.1,
+        trend: "DECREASING"
+      }
+    ];
+  }
+  detectCostAnomalies(trendData) {
+    const anomalies = [];
+    for (let i = 1; i < trendData.length; i++) {
+      const current = trendData[i];
+      const changePercentage = Math.abs(current.changeFromPrevious.percentage);
+      if (changePercentage > 50) {
+        anomalies.push({
+          date: current.period,
+          actualCost: current.actualCost,
+          expectedCost: current.actualCost - current.changeFromPrevious.amount,
+          deviation: changePercentage,
+          severity: changePercentage > 100 ? "HIGH" : "MEDIUM",
+          possibleCause: changePercentage > 0 ? "Unexpected cost increase" : "Significant cost reduction"
+        });
+      }
+    }
+    return anomalies;
+  }
+  static createFromLegacyConfig(legacyConfig) {
+    const config = {
+      provider: "aws" /* AWS */,
+      credentials: {
+        accessKeyId: legacyConfig.credentials.accessKeyId,
+        secretAccessKey: legacyConfig.credentials.secretAccessKey,
+        sessionToken: legacyConfig.credentials.sessionToken
+      },
+      region: legacyConfig.region
+    };
+    return new AWSProvider(config);
+  }
+  calculateVolatility(values) {
+    if (values.length < 2)
+      return 0;
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
+    const stdDev = Math.sqrt(variance);
+    return mean > 0 ? stdDev / mean : 0;
+  }
+  calculateTrendStrength(values) {
+    if (values.length < 3)
+      return 0;
+    const n = values.length;
+    const x = Array.from({ length: n }, (_, i) => i);
+    const meanX = x.reduce((a, b) => a + b, 0) / n;
+    const meanY = values.reduce((a, b) => a + b, 0) / n;
+    const ssXY = x.reduce((sum, xi, i) => sum + (xi - meanX) * (values[i] - meanY), 0);
+    const ssXX = x.reduce((sum, xi) => sum + Math.pow(xi - meanX, 2), 0);
+    const ssYY = values.reduce((sum, yi) => sum + Math.pow(yi - meanY, 2), 0);
+    const correlation = ssXX === 0 || ssYY === 0 ? 0 : ssXY / Math.sqrt(ssXX * ssYY);
+    return Math.abs(correlation);
+  }
+};
+
+// src/providers/gcp.ts
+var GCPProvider = class extends CloudProviderAdapter {
+  constructor(config) {
+    super(config);
+  }
+  async validateCredentials() {
+    console.warn("GCP credential validation not yet implemented");
+    return false;
+  }
+  async getAccountInfo() {
+    showSpinner("Getting GCP project information");
+    try {
+      throw new Error("GCP integration not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get GCP project information: ${error.message}`);
+    }
+  }
+  async getRawCostData() {
+    showSpinner("Getting GCP billing data");
+    try {
+      throw new Error("GCP cost analysis not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get GCP cost data: ${error.message}`);
+    }
+  }
+  async getCostBreakdown() {
+    const rawCostData = await this.getRawCostData();
+    return this.calculateServiceTotals(rawCostData);
+  }
+  async getResourceInventory(filters) {
+    showSpinner("Discovering GCP resources");
+    const regions = (filters == null ? void 0 : filters.regions) || [this.config.region || "us-central1"];
+    const resourceTypes = (filters == null ? void 0 : filters.resourceTypes) || Object.values(ResourceType);
+    const includeCosts = (filters == null ? void 0 : filters.includeCosts) || false;
+    const inventory = {
+      provider: "gcp" /* GOOGLE_CLOUD */,
+      region: regions.join(", "),
+      totalResources: 0,
+      resourcesByType: {
+        ["compute" /* COMPUTE */]: 0,
+        ["storage" /* STORAGE */]: 0,
+        ["database" /* DATABASE */]: 0,
+        ["network" /* NETWORK */]: 0,
+        ["security" /* SECURITY */]: 0,
+        ["serverless" /* SERVERLESS */]: 0,
+        ["container" /* CONTAINER */]: 0,
+        ["analytics" /* ANALYTICS */]: 0
+      },
+      totalCost: 0,
+      resources: {
+        compute: [],
+        storage: [],
+        database: [],
+        network: [],
+        security: [],
+        serverless: [],
+        container: [],
+        analytics: []
+      },
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    const projectId = this.config.credentials.projectId;
+    if (!projectId) {
+      throw new Error("GCP Project ID is required for resource discovery");
+    }
+    try {
+      if (resourceTypes.includes("compute" /* COMPUTE */)) {
+        const computeResources = await this.discoverComputeInstances(projectId, regions, includeCosts);
+        inventory.resources.compute.push(...computeResources);
+        inventory.resourcesByType["compute" /* COMPUTE */] += computeResources.length;
+      }
+      if (resourceTypes.includes("storage" /* STORAGE */)) {
+        const storageResources = await this.discoverStorageBuckets(projectId, includeCosts);
+        inventory.resources.storage.push(...storageResources);
+        inventory.resourcesByType["storage" /* STORAGE */] += storageResources.length;
+      }
+      if (resourceTypes.includes("database" /* DATABASE */)) {
+        const databaseResources = await this.discoverCloudSQLInstances(projectId, regions, includeCosts);
+        inventory.resources.database.push(...databaseResources);
+        inventory.resourcesByType["database" /* DATABASE */] += databaseResources.length;
+      }
+      if (resourceTypes.includes("serverless" /* SERVERLESS */)) {
+        const serverlessResources = await this.discoverCloudFunctions(projectId, regions, includeCosts);
+        inventory.resources.serverless.push(...serverlessResources);
+        inventory.resourcesByType["serverless" /* SERVERLESS */] += serverlessResources.length;
+      }
+      if (resourceTypes.includes("container" /* CONTAINER */)) {
+        const containerResources = await this.discoverGKEClusters(projectId, regions, includeCosts);
+        inventory.resources.container.push(...containerResources);
+        inventory.resourcesByType["container" /* CONTAINER */] += containerResources.length;
+      }
+    } catch (error) {
+      console.warn(`Failed to discover GCP resources: ${error.message}`);
+    }
+    inventory.totalResources = Object.values(inventory.resourcesByType).reduce((sum, count) => sum + count, 0);
+    if (includeCosts) {
+      inventory.totalCost = Object.values(inventory.resources).flat().reduce((sum, resource) => sum + (resource.costToDate || 0), 0);
+    }
+    return inventory;
+  }
+  async discoverComputeInstances(projectId, regions, includeCosts) {
+    console.warn("GCP Compute Engine discovery is simulated - integrate with @google-cloud/compute for production use");
+    const instances = [];
+    if (process.env.GCP_MOCK_DATA === "true") {
+      instances.push({
+        id: "instance-1",
+        name: "web-server-1",
+        state: "RUNNING",
+        region: regions[0],
+        provider: "gcp" /* GOOGLE_CLOUD */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-15"),
+        instanceType: "e2-medium",
+        cpu: 1,
+        memory: 4,
+        instanceName: "web-server-1",
+        machineType: "e2-medium",
+        zone: `${regions[0]}-a`,
+        image: "projects/ubuntu-os-cloud/global/images/ubuntu-2004-focal-v20240110",
+        disks: [{
+          type: "pd-standard",
+          sizeGb: 20,
+          boot: true
+        }],
+        networkInterfaces: [{
+          network: "projects/my-project/global/networks/default"
+        }],
+        tags: {
+          "Environment": "production",
+          "Team": "web"
+        },
+        costToDate: includeCosts ? 45.67 : 0
+      });
+    }
+    return instances;
+  }
+  async discoverStorageBuckets(projectId, includeCosts) {
+    console.warn("GCP Cloud Storage discovery is simulated - integrate with @google-cloud/storage for production use");
+    const buckets = [];
+    if (process.env.GCP_MOCK_DATA === "true") {
+      buckets.push({
+        id: "my-app-storage-bucket",
+        name: "my-app-storage-bucket",
+        state: "active",
+        region: "us-central1",
+        provider: "gcp" /* GOOGLE_CLOUD */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-10"),
+        sizeGB: 150,
+        storageType: "STANDARD",
+        bucketName: "my-app-storage-bucket",
+        location: "US-CENTRAL1",
+        storageClass: "STANDARD",
+        tags: {
+          "Project": "web-app",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 3.45 : 0
+      });
+    }
+    return buckets;
+  }
+  async discoverCloudSQLInstances(projectId, regions, includeCosts) {
+    console.warn("GCP Cloud SQL discovery is simulated - integrate with Google Cloud SQL Admin API for production use");
+    const instances = [];
+    if (process.env.GCP_MOCK_DATA === "true") {
+      instances.push({
+        id: "production-db-1",
+        name: "production-db-1",
+        state: "RUNNABLE",
+        region: regions[0],
+        provider: "gcp" /* GOOGLE_CLOUD */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-12"),
+        engine: "POSTGRES_14",
+        version: "14.9",
+        instanceClass: "db-custom-2-8192",
+        storageGB: 100,
+        instanceId: "production-db-1",
+        databaseVersion: "POSTGRES_14",
+        tier: "db-custom-2-8192",
+        diskSizeGb: 100,
+        diskType: "PD_SSD",
+        ipAddresses: [{
+          type: "PRIMARY",
+          ipAddress: "10.1.2.3"
+        }],
+        tags: {
+          "Database": "primary",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 89.23 : 0
+      });
+    }
+    return instances;
+  }
+  async discoverCloudFunctions(projectId, regions, includeCosts) {
+    console.warn("GCP Cloud Functions discovery is simulated - integrate with @google-cloud/functions for production use");
+    const functions = [];
+    if (process.env.GCP_MOCK_DATA === "true") {
+      functions.push({
+        id: "projects/my-project/locations/us-central1/functions/api-handler",
+        name: "api-handler",
+        state: "ACTIVE",
+        region: regions[0],
+        provider: "gcp" /* GOOGLE_CLOUD */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-20"),
+        functionName: "api-handler",
+        runtime: "nodejs20",
+        entryPoint: "handleRequest",
+        availableMemoryMb: 256,
+        timeout: "60s",
+        tags: {
+          "Function": "api",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 12.45 : 0
+      });
+    }
+    return functions;
+  }
+  async discoverGKEClusters(projectId, regions, includeCosts) {
+    console.warn("GCP GKE discovery is simulated - integrate with @google-cloud/container for production use");
+    const clusters = [];
+    if (process.env.GCP_MOCK_DATA === "true") {
+      clusters.push({
+        id: "production-cluster",
+        name: "production-cluster",
+        state: "RUNNING",
+        region: regions[0],
+        provider: "gcp" /* GOOGLE_CLOUD */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-18"),
+        clusterName: "production-cluster",
+        location: `${regions[0]}-a`,
+        nodeCount: 3,
+        currentMasterVersion: "1.28.3-gke.1203001",
+        currentNodeVersion: "1.28.3-gke.1203001",
+        network: "projects/my-project/global/networks/default",
+        nodePools: [{
+          name: "default-pool",
+          nodeCount: 3,
+          config: {
+            machineType: "e2-medium",
+            diskSizeGb: 100
+          }
+        }],
+        tags: {
+          "Cluster": "production",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 234.56 : 0
+      });
+    }
+    return clusters;
+  }
+  async getResourceCosts(resourceId) {
+    console.warn("GCP resource costing is not yet implemented - integrate with Google Cloud Billing API");
+    return 0;
+  }
+  async getOptimizationRecommendations() {
+    return [
+      "Consider using Sustained Use Discounts for long-running Compute Engine instances",
+      "Enable Cloud Storage lifecycle policies to automatically transition old data to cheaper storage classes",
+      "Use Committed Use Discounts for predictable Compute Engine workloads to save up to 57%",
+      "Consider using Preemptible VMs for fault-tolerant workloads to save up to 80%",
+      "Review Cloud SQL instances and consider right-sizing based on actual usage",
+      "Use Cloud Functions for event-driven workloads instead of always-on Compute Engine instances",
+      "Implement Cloud Storage Nearline or Coldline for infrequently accessed data",
+      "Consider using Google Kubernetes Engine Autopilot for optimized node management"
+    ];
+  }
+  async getBudgets() {
+    throw new Error("GCP budget tracking not yet implemented. Please use AWS for now.");
+  }
+  async getBudgetAlerts() {
+    throw new Error("GCP budget alerts not yet implemented. Please use AWS for now.");
+  }
+  async getCostTrendAnalysis(months) {
+    throw new Error("GCP cost trend analysis not yet implemented. Please use AWS for now.");
+  }
+  async getFinOpsRecommendations() {
+    throw new Error("GCP FinOps recommendations not yet implemented. Please use AWS for now.");
+  }
+  // Helper method to validate GCP-specific configuration
+  static validateGCPConfig(config) {
+    const requiredFields = ["projectId"];
+    for (const field of requiredFields) {
+      if (!config.credentials[field]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Helper method to get required credential fields for GCP
+  static getRequiredCredentials() {
+    return [
+      "projectId",
+      "keyFilePath"
+      // Path to service account JSON file
+      // Alternative: 'serviceAccountKey' for JSON content
+    ];
+  }
+};
+
+// src/providers/azure.ts
+var AzureProvider = class extends CloudProviderAdapter {
+  constructor(config) {
+    super(config);
+  }
+  async validateCredentials() {
+    console.warn("Azure credential validation not yet implemented");
+    return false;
+  }
+  async getAccountInfo() {
+    showSpinner("Getting Azure subscription information");
+    try {
+      throw new Error("Azure integration not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get Azure subscription information: ${error.message}`);
+    }
+  }
+  async getRawCostData() {
+    showSpinner("Getting Azure cost data");
+    try {
+      throw new Error("Azure cost analysis not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get Azure cost data: ${error.message}`);
+    }
+  }
+  async getCostBreakdown() {
+    const rawCostData = await this.getRawCostData();
+    return this.calculateServiceTotals(rawCostData);
+  }
+  async getResourceInventory(filters) {
+    showSpinner("Discovering Azure resources");
+    const regions = (filters == null ? void 0 : filters.regions) || [this.config.region || "eastus"];
+    const resourceTypes = (filters == null ? void 0 : filters.resourceTypes) || Object.values(ResourceType);
+    const includeCosts = (filters == null ? void 0 : filters.includeCosts) || false;
+    const inventory = {
+      provider: "azure" /* AZURE */,
+      region: regions.join(", "),
+      totalResources: 0,
+      resourcesByType: {
+        ["compute" /* COMPUTE */]: 0,
+        ["storage" /* STORAGE */]: 0,
+        ["database" /* DATABASE */]: 0,
+        ["network" /* NETWORK */]: 0,
+        ["security" /* SECURITY */]: 0,
+        ["serverless" /* SERVERLESS */]: 0,
+        ["container" /* CONTAINER */]: 0,
+        ["analytics" /* ANALYTICS */]: 0
+      },
+      totalCost: 0,
+      resources: {
+        compute: [],
+        storage: [],
+        database: [],
+        network: [],
+        security: [],
+        serverless: [],
+        container: [],
+        analytics: []
+      },
+      lastUpdated: /* @__PURE__ */ new Date()
+    };
+    const subscriptionId = this.config.credentials.subscriptionId;
+    if (!subscriptionId) {
+      throw new Error("Azure Subscription ID is required for resource discovery");
+    }
+    try {
+      if (resourceTypes.includes("compute" /* COMPUTE */)) {
+        const computeResources = await this.discoverVirtualMachines(subscriptionId, regions, includeCosts);
+        inventory.resources.compute.push(...computeResources);
+        inventory.resourcesByType["compute" /* COMPUTE */] += computeResources.length;
+      }
+      if (resourceTypes.includes("storage" /* STORAGE */)) {
+        const storageResources = await this.discoverStorageAccounts(subscriptionId, includeCosts);
+        inventory.resources.storage.push(...storageResources);
+        inventory.resourcesByType["storage" /* STORAGE */] += storageResources.length;
+      }
+      if (resourceTypes.includes("database" /* DATABASE */)) {
+        const databaseResources = await this.discoverSQLDatabases(subscriptionId, regions, includeCosts);
+        inventory.resources.database.push(...databaseResources);
+        inventory.resourcesByType["database" /* DATABASE */] += databaseResources.length;
+      }
+      if (resourceTypes.includes("serverless" /* SERVERLESS */)) {
+        const serverlessResources = await this.discoverFunctionApps(subscriptionId, regions, includeCosts);
+        inventory.resources.serverless.push(...serverlessResources);
+        inventory.resourcesByType["serverless" /* SERVERLESS */] += serverlessResources.length;
+      }
+      if (resourceTypes.includes("container" /* CONTAINER */)) {
+        const containerResources = await this.discoverAKSClusters(subscriptionId, regions, includeCosts);
+        inventory.resources.container.push(...containerResources);
+        inventory.resourcesByType["container" /* CONTAINER */] += containerResources.length;
+      }
+      if (resourceTypes.includes("network" /* NETWORK */)) {
+        const networkResources = await this.discoverVirtualNetworks(subscriptionId, regions, includeCosts);
+        inventory.resources.network.push(...networkResources);
+        inventory.resourcesByType["network" /* NETWORK */] += networkResources.length;
+      }
+    } catch (error) {
+      console.warn(`Failed to discover Azure resources: ${error.message}`);
+    }
+    inventory.totalResources = Object.values(inventory.resourcesByType).reduce((sum, count) => sum + count, 0);
+    if (includeCosts) {
+      inventory.totalCost = Object.values(inventory.resources).flat().reduce((sum, resource) => sum + (resource.costToDate || 0), 0);
+    }
+    return inventory;
+  }
+  async discoverVirtualMachines(subscriptionId, regions, includeCosts) {
+    console.warn("Azure Virtual Machines discovery is simulated - integrate with Azure SDK for production use");
+    const vms = [];
+    if (process.env.AZURE_MOCK_DATA === "true") {
+      vms.push({
+        id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Compute/virtualMachines/web-vm-01",
+        name: "web-vm-01",
+        state: "PowerState/running",
+        region: regions[0],
+        provider: "azure" /* AZURE */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-15"),
+        instanceType: "Standard_D2s_v3",
+        cpu: 2,
+        memory: 8,
+        resourceId: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Compute/virtualMachines/web-vm-01",
+        vmSize: "Standard_D2s_v3",
+        osType: "Linux",
+        imageReference: {
+          publisher: "Canonical",
+          offer: "UbuntuServer",
+          sku: "20.04-LTS",
+          version: "latest"
+        },
+        osDisk: {
+          osType: "Linux",
+          diskSizeGB: 30,
+          managedDisk: {
+            storageAccountType: "Premium_LRS"
+          }
+        },
+        networkProfile: {
+          networkInterfaces: [{
+            id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Network/networkInterfaces/web-vm-01-nic"
+          }]
+        },
+        tags: {
+          "Environment": "production",
+          "Team": "web",
+          "CostCenter": "engineering"
+        },
+        costToDate: includeCosts ? 89.45 : 0
+      });
+    }
+    return vms;
+  }
+  async discoverStorageAccounts(subscriptionId, includeCosts) {
+    console.warn("Azure Storage Accounts discovery is simulated - integrate with Azure SDK for production use");
+    const storageAccounts = [];
+    if (process.env.AZURE_MOCK_DATA === "true") {
+      storageAccounts.push({
+        id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Storage/storageAccounts/prodstorageacct",
+        name: "prodstorageacct",
+        state: "active",
+        region: "eastus",
+        provider: "azure" /* AZURE */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-10"),
+        sizeGB: 500,
+        storageType: "Standard_LRS",
+        accountName: "prodstorageacct",
+        kind: "StorageV2",
+        tier: "Standard",
+        replicationType: "LRS",
+        accessTier: "Hot",
+        encryption: {
+          services: {
+            blob: { enabled: true },
+            file: { enabled: true }
+          }
+        },
+        tags: {
+          "Environment": "production",
+          "Application": "web-app"
+        },
+        costToDate: includeCosts ? 25.67 : 0
+      });
+    }
+    return storageAccounts;
+  }
+  async discoverSQLDatabases(subscriptionId, regions, includeCosts) {
+    console.warn("Azure SQL Database discovery is simulated - integrate with Azure SQL Management API for production use");
+    const databases = [];
+    if (process.env.AZURE_MOCK_DATA === "true") {
+      databases.push({
+        id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Sql/servers/prod-sql-server/databases/webapp-db",
+        name: "webapp-db",
+        state: "Online",
+        region: regions[0],
+        provider: "azure" /* AZURE */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-12"),
+        engine: "Microsoft SQL Server",
+        version: "12.0",
+        instanceClass: "S2",
+        storageGB: 250,
+        databaseId: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Sql/servers/prod-sql-server/databases/webapp-db",
+        serverName: "prod-sql-server",
+        edition: "Standard",
+        serviceObjective: "S2",
+        collation: "SQL_Latin1_General_CP1_CI_AS",
+        maxSizeBytes: 268435456e3,
+        status: "Online",
+        elasticPoolName: void 0,
+        tags: {
+          "Database": "primary",
+          "Environment": "production",
+          "Application": "webapp"
+        },
+        costToDate: includeCosts ? 156.78 : 0
+      });
+    }
+    return databases;
+  }
+  async discoverFunctionApps(subscriptionId, regions, includeCosts) {
+    console.warn("Azure Function Apps discovery is simulated - integrate with Azure App Service API for production use");
+    const functionApps = [];
+    if (process.env.AZURE_MOCK_DATA === "true") {
+      functionApps.push({
+        id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Web/sites/api-functions",
+        name: "api-functions",
+        state: "Running",
+        region: regions[0],
+        provider: "azure" /* AZURE */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-20"),
+        functionAppName: "api-functions",
+        kind: "functionapp",
+        runtime: "dotnet",
+        runtimeVersion: "6",
+        hostingPlan: {
+          name: "consumption-plan",
+          tier: "Dynamic"
+        },
+        tags: {
+          "Function": "api",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 23.45 : 0
+      });
+    }
+    return functionApps;
+  }
+  async discoverAKSClusters(subscriptionId, regions, includeCosts) {
+    console.warn("Azure AKS discovery is simulated - integrate with Azure Kubernetes Service API for production use");
+    const clusters = [];
+    if (process.env.AZURE_MOCK_DATA === "true") {
+      clusters.push({
+        id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.ContainerService/managedClusters/prod-aks",
+        name: "prod-aks",
+        state: "Succeeded",
+        region: regions[0],
+        provider: "azure" /* AZURE */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-18"),
+        clusterName: "prod-aks",
+        kubernetesVersion: "1.28.3",
+        nodeCount: 3,
+        dnsPrefix: "prod-aks-dns",
+        agentPoolProfiles: [{
+          name: "agentpool",
+          count: 3,
+          vmSize: "Standard_D2s_v3",
+          osType: "Linux",
+          osDiskSizeGB: 128
+        }],
+        networkProfile: {
+          networkPlugin: "azure",
+          serviceCidr: "10.0.0.0/16",
+          dnsServiceIP: "10.0.0.10"
+        },
+        tags: {
+          "Cluster": "production",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 345.67 : 0
+      });
+    }
+    return clusters;
+  }
+  async discoverVirtualNetworks(subscriptionId, regions, includeCosts) {
+    console.warn("Azure Virtual Networks discovery is simulated - integrate with Azure Network API for production use");
+    const vnets = [];
+    if (process.env.AZURE_MOCK_DATA === "true") {
+      vnets.push({
+        id: "/subscriptions/sub123/resourceGroups/rg-prod/providers/Microsoft.Network/virtualNetworks/prod-vnet",
+        name: "prod-vnet",
+        state: "active",
+        region: regions[0],
+        provider: "azure" /* AZURE */,
+        createdAt: /* @__PURE__ */ new Date("2024-01-05"),
+        vnetName: "prod-vnet",
+        addressSpace: {
+          addressPrefixes: ["10.1.0.0/16"]
+        },
+        subnets: [{
+          name: "default",
+          addressPrefix: "10.1.0.0/24"
+        }, {
+          name: "aks-subnet",
+          addressPrefix: "10.1.1.0/24"
+        }],
+        tags: {
+          "Network": "production",
+          "Environment": "production"
+        },
+        costToDate: includeCosts ? 0 : 0
+        // VNets typically don't have direct costs
+      });
+    }
+    return vnets;
+  }
+  async getResourceCosts(resourceId) {
+    console.warn("Azure resource costing is not yet implemented - integrate with Azure Cost Management API");
+    return 0;
+  }
+  async getOptimizationRecommendations() {
+    return [
+      "Use Azure Reserved Virtual Machine Instances for consistent workloads to save up to 72%",
+      "Consider Azure Spot Virtual Machines for fault-tolerant workloads to save up to 90%",
+      "Implement Azure Storage lifecycle management to automatically tier data to cooler storage",
+      "Use Azure SQL Database elastic pools for multiple databases with varying usage patterns",
+      "Consider Azure Container Instances for short-lived containerized workloads instead of AKS",
+      "Implement auto-scaling for Virtual Machine Scale Sets to optimize compute costs",
+      "Use Azure Functions consumption plan for event-driven workloads with variable traffic",
+      "Consider Azure Storage Archive tier for long-term retention of infrequently accessed data",
+      "Use Azure Hybrid Benefit to save on Windows Server and SQL Server licensing costs",
+      "Implement Azure Cost Management budgets and alerts to monitor spending"
+    ];
+  }
+  async getBudgets() {
+    throw new Error("Azure budget tracking not yet implemented. Please use AWS for now.");
+  }
+  async getBudgetAlerts() {
+    throw new Error("Azure budget alerts not yet implemented. Please use AWS for now.");
+  }
+  async getCostTrendAnalysis(months) {
+    throw new Error("Azure cost trend analysis not yet implemented. Please use AWS for now.");
+  }
+  async getFinOpsRecommendations() {
+    throw new Error("Azure FinOps recommendations not yet implemented. Please use AWS for now.");
+  }
+  // Helper method to validate Azure-specific configuration
+  static validateAzureConfig(config) {
+    const requiredFields = ["subscriptionId", "tenantId", "clientId", "clientSecret"];
+    for (const field of requiredFields) {
+      if (!config.credentials[field]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Helper method to get required credential fields for Azure
+  static getRequiredCredentials() {
+    return [
+      "subscriptionId",
+      "tenantId",
+      "clientId",
+      "clientSecret"
+    ];
+  }
+};
+
+// src/providers/alicloud.ts
+var AlibabaCloudProvider = class extends CloudProviderAdapter {
+  constructor(config) {
+    super(config);
+  }
+  async validateCredentials() {
+    console.warn("Alibaba Cloud credential validation not yet implemented");
+    return false;
+  }
+  async getAccountInfo() {
+    showSpinner("Getting Alibaba Cloud account information");
+    try {
+      throw new Error("Alibaba Cloud integration not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get Alibaba Cloud account information: ${error.message}`);
+    }
+  }
+  async getRawCostData() {
+    showSpinner("Getting Alibaba Cloud billing data");
+    try {
+      throw new Error("Alibaba Cloud cost analysis not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get Alibaba Cloud cost data: ${error.message}`);
+    }
+  }
+  async getCostBreakdown() {
+    const rawCostData = await this.getRawCostData();
+    return this.calculateServiceTotals(rawCostData);
+  }
+  async getResourceInventory(filters) {
+    throw new Error("Alibaba Cloud resource inventory not yet implemented. Please use AWS for now.");
+  }
+  async getResourceCosts(resourceId) {
+    throw new Error("Alibaba Cloud resource costing not yet implemented. Please use AWS for now.");
+  }
+  async getOptimizationRecommendations() {
+    throw new Error("Alibaba Cloud optimization recommendations not yet implemented. Please use AWS for now.");
+  }
+  async getBudgets() {
+    throw new Error("Alibaba Cloud budget tracking not yet implemented. Please use AWS for now.");
+  }
+  async getBudgetAlerts() {
+    throw new Error("Alibaba Cloud budget alerts not yet implemented. Please use AWS for now.");
+  }
+  async getCostTrendAnalysis(months) {
+    throw new Error("Alibaba Cloud cost trend analysis not yet implemented. Please use AWS for now.");
+  }
+  async getFinOpsRecommendations() {
+    throw new Error("Alibaba Cloud FinOps recommendations not yet implemented. Please use AWS for now.");
+  }
+  // Helper method to validate Alibaba Cloud-specific configuration
+  static validateAlibabaCloudConfig(config) {
+    const requiredFields = ["accessKeyId", "accessKeySecret"];
+    for (const field of requiredFields) {
+      if (!config.credentials[field]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Helper method to get required credential fields for Alibaba Cloud
+  static getRequiredCredentials() {
+    return [
+      "accessKeyId",
+      "accessKeySecret"
+      // Optional: 'securityToken', 'regionId'
+    ];
+  }
+};
+
+// src/providers/oracle.ts
+var OracleCloudProvider = class extends CloudProviderAdapter {
+  constructor(config) {
+    super(config);
+  }
+  async validateCredentials() {
+    console.warn("Oracle Cloud credential validation not yet implemented");
+    return false;
+  }
+  async getAccountInfo() {
+    showSpinner("Getting Oracle Cloud tenancy information");
+    try {
+      throw new Error("Oracle Cloud integration not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get Oracle Cloud tenancy information: ${error.message}`);
+    }
+  }
+  async getRawCostData() {
+    showSpinner("Getting Oracle Cloud usage data");
+    try {
+      throw new Error("Oracle Cloud cost analysis not yet implemented. Please use AWS for now.");
+    } catch (error) {
+      throw new Error(`Failed to get Oracle Cloud cost data: ${error.message}`);
+    }
+  }
+  async getCostBreakdown() {
+    const rawCostData = await this.getRawCostData();
+    return this.calculateServiceTotals(rawCostData);
+  }
+  async getResourceInventory(filters) {
+    throw new Error("Oracle Cloud resource inventory not yet implemented. Please use AWS for now.");
+  }
+  async getResourceCosts(resourceId) {
+    throw new Error("Oracle Cloud resource costing not yet implemented. Please use AWS for now.");
+  }
+  async getOptimizationRecommendations() {
+    throw new Error("Oracle Cloud optimization recommendations not yet implemented. Please use AWS for now.");
+  }
+  async getBudgets() {
+    throw new Error("Oracle Cloud budget tracking not yet implemented. Please use AWS for now.");
+  }
+  async getBudgetAlerts() {
+    throw new Error("Oracle Cloud budget alerts not yet implemented. Please use AWS for now.");
+  }
+  async getCostTrendAnalysis(months) {
+    throw new Error("Oracle Cloud cost trend analysis not yet implemented. Please use AWS for now.");
+  }
+  async getFinOpsRecommendations() {
+    throw new Error("Oracle Cloud FinOps recommendations not yet implemented. Please use AWS for now.");
+  }
+  // Helper method to validate Oracle Cloud-specific configuration
+  static validateOracleCloudConfig(config) {
+    const requiredFields = ["userId", "tenancyId", "fingerprint", "privateKeyPath"];
+    for (const field of requiredFields) {
+      if (!config.credentials[field]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // Helper method to get required credential fields for Oracle Cloud
+  static getRequiredCredentials() {
+    return [
+      "userId",
+      // User OCID
+      "tenancyId",
+      // Tenancy OCID
+      "fingerprint",
+      // Public key fingerprint
+      "privateKeyPath"
+      // Path to private key file
+      // Optional: 'region', 'passphrase'
+    ];
+  }
+};
+
+// src/providers/factory.ts
+var CloudProviderFactory = class {
+  createProvider(config) {
+    if (!this.validateProviderConfig(config)) {
+      throw new Error(`Invalid configuration for provider: ${config.provider}`);
+    }
+    switch (config.provider) {
+      case "aws" /* AWS */:
+        return new AWSProvider(config);
+      case "gcp" /* GOOGLE_CLOUD */:
+        return new GCPProvider(config);
+      case "azure" /* AZURE */:
+        return new AzureProvider(config);
+      case "alicloud" /* ALIBABA_CLOUD */:
+        return new AlibabaCloudProvider(config);
+      case "oracle" /* ORACLE_CLOUD */:
+        return new OracleCloudProvider(config);
+      default:
+        throw new Error(`Unsupported cloud provider: ${config.provider}`);
+    }
+  }
+  getSupportedProviders() {
+    return [
+      "aws" /* AWS */,
+      "gcp" /* GOOGLE_CLOUD */,
+      "azure" /* AZURE */,
+      "alicloud" /* ALIBABA_CLOUD */,
+      "oracle" /* ORACLE_CLOUD */
+    ];
+  }
+  validateProviderConfig(config) {
+    if (!config.provider) {
+      return false;
+    }
+    const supportedProviders = this.getSupportedProviders();
+    if (!supportedProviders.includes(config.provider)) {
+      return false;
+    }
+    return config.credentials !== null && config.credentials !== void 0;
+  }
+  static getProviderDisplayNames() {
+    return {
+      ["aws" /* AWS */]: "Amazon Web Services (AWS)",
+      ["gcp" /* GOOGLE_CLOUD */]: "Google Cloud Platform (GCP)",
+      ["azure" /* AZURE */]: "Microsoft Azure",
+      ["alicloud" /* ALIBABA_CLOUD */]: "Alibaba Cloud",
+      ["oracle" /* ORACLE_CLOUD */]: "Oracle Cloud Infrastructure (OCI)"
+    };
+  }
+  static getProviderFromString(provider) {
+    const normalizedProvider = provider.toLowerCase().trim();
+    const providerMap = {
+      "aws": "aws" /* AWS */,
+      "amazon": "aws" /* AWS */,
+      "amazonwebservices": "aws" /* AWS */,
+      "gcp": "gcp" /* GOOGLE_CLOUD */,
+      "google": "gcp" /* GOOGLE_CLOUD */,
+      "googlecloud": "gcp" /* GOOGLE_CLOUD */,
+      "azure": "azure" /* AZURE */,
+      "microsoft": "azure" /* AZURE */,
+      "microsoftazure": "azure" /* AZURE */,
+      "alicloud": "alicloud" /* ALIBABA_CLOUD */,
+      "alibaba": "alicloud" /* ALIBABA_CLOUD */,
+      "alibabacloud": "alicloud" /* ALIBABA_CLOUD */,
+      "oracle": "oracle" /* ORACLE_CLOUD */,
+      "oci": "oracle" /* ORACLE_CLOUD */,
+      "oraclecloud": "oracle" /* ORACLE_CLOUD */
+    };
+    return providerMap[normalizedProvider.replace(/[-_\s]/g, "")] || null;
+  }
+};
+
+// src/discovery/profile-discovery.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import chalk2 from "chalk";
+var CloudProfileDiscovery = class {
+  constructor() {
+    this.warnings = [];
+    this.homeDirectory = homedir();
+  }
+  /**
+   * Discover all available cloud provider profiles
+   */
+  async discoverAllProfiles() {
+    console.log(chalk2.yellow("\u{1F50D} Discovering cloud provider profiles..."));
+    const results = {
+      totalFound: 0,
+      byProvider: {
+        ["aws" /* AWS */]: [],
+        ["gcp" /* GOOGLE_CLOUD */]: [],
+        ["azure" /* AZURE */]: [],
+        ["alicloud" /* ALIBABA_CLOUD */]: [],
+        ["oracle" /* ORACLE_CLOUD */]: []
+      },
+      recommended: null,
+      warnings: []
+    };
+    const awsProfiles = await this.discoverAWSProfiles();
+    const gcpProfiles = await this.discoverGCPProfiles();
+    const azureProfiles = await this.discoverAzureProfiles();
+    const alicloudProfiles = await this.discoverAlibabaCloudProfiles();
+    const oracleProfiles = await this.discoverOracleCloudProfiles();
+    results.byProvider["aws" /* AWS */] = awsProfiles;
+    results.byProvider["gcp" /* GOOGLE_CLOUD */] = gcpProfiles;
+    results.byProvider["azure" /* AZURE */] = azureProfiles;
+    results.byProvider["alicloud" /* ALIBABA_CLOUD */] = alicloudProfiles;
+    results.byProvider["oracle" /* ORACLE_CLOUD */] = oracleProfiles;
+    results.totalFound = Object.values(results.byProvider).reduce((total, profiles) => total + profiles.length, 0);
+    results.recommended = this.determineRecommendedProfile(results.byProvider);
+    results.warnings = this.warnings;
+    return results;
+  }
+  /**
+   * Discover AWS profiles from ~/.aws/credentials and ~/.aws/config
+   */
+  async discoverAWSProfiles() {
+    const profiles = [];
+    const credentialsPath = join(this.homeDirectory, ".aws", "credentials");
+    const configPath = join(this.homeDirectory, ".aws", "config");
+    if (!existsSync(credentialsPath) && !existsSync(configPath)) {
+      return profiles;
+    }
+    try {
+      const credentialsProfiles = existsSync(credentialsPath) ? this.parseIniFile(credentialsPath) : {};
+      const configProfiles = existsSync(configPath) ? this.parseAWSConfigFile(configPath) : {};
+      const allProfileNames = /* @__PURE__ */ new Set([
+        ...Object.keys(credentialsProfiles),
+        ...Object.keys(configProfiles)
+      ]);
+      for (const profileName of allProfileNames) {
+        const credConfig = credentialsProfiles[profileName] || {};
+        const fileConfig = configProfiles[profileName] || {};
+        if (!credConfig.aws_access_key_id && !fileConfig.role_arn && !fileConfig.sso_start_url) {
+          continue;
+        }
+        profiles.push({
+          name: profileName,
+          provider: "aws" /* AWS */,
+          region: fileConfig.region || credConfig.region || "us-east-1",
+          isDefault: profileName === "default",
+          credentialsPath: existsSync(credentialsPath) ? credentialsPath : void 0,
+          configPath: existsSync(configPath) ? configPath : void 0,
+          status: this.validateAWSProfile(credConfig, fileConfig),
+          lastUsed: this.getLastUsedDate(credentialsPath)
+        });
+      }
+    } catch (error) {
+      this.warnings.push(`Failed to parse AWS profiles: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return profiles;
+  }
+  /**
+   * Discover Google Cloud profiles from gcloud CLI
+   */
+  async discoverGCPProfiles() {
+    const profiles = [];
+    const gcpConfigDir = join(this.homeDirectory, ".config", "gcloud");
+    if (!existsSync(gcpConfigDir)) {
+      return profiles;
+    }
+    try {
+      const configurationsPath = join(gcpConfigDir, "configurations");
+      if (existsSync(configurationsPath)) {
+        const configFiles = __require("fs").readdirSync(configurationsPath);
+        for (const configFile of configFiles) {
+          if (configFile.startsWith("config_")) {
+            const profileName = configFile.replace("config_", "");
+            const configPath = join(configurationsPath, configFile);
+            profiles.push({
+              name: profileName,
+              provider: "gcp" /* GOOGLE_CLOUD */,
+              isDefault: profileName === "default",
+              configPath,
+              status: "available",
+              lastUsed: this.getLastUsedDate(configPath)
+            });
+          }
+        }
+      }
+      const adcPath = join(gcpConfigDir, "application_default_credentials.json");
+      if (existsSync(adcPath)) {
+        profiles.push({
+          name: "application-default",
+          provider: "gcp" /* GOOGLE_CLOUD */,
+          isDefault: true,
+          credentialsPath: adcPath,
+          status: "available"
+        });
+      }
+    } catch (error) {
+      this.warnings.push(`Failed to discover GCP profiles: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return profiles;
+  }
+  /**
+   * Discover Azure profiles from Azure CLI
+   */
+  async discoverAzureProfiles() {
+    const profiles = [];
+    const azureConfigDir = join(this.homeDirectory, ".azure");
+    if (!existsSync(azureConfigDir)) {
+      return profiles;
+    }
+    try {
+      const profilesFile = join(azureConfigDir, "azureProfile.json");
+      if (existsSync(profilesFile)) {
+        const profilesData = JSON.parse(readFileSync(profilesFile, "utf8"));
+        if (profilesData.subscriptions && Array.isArray(profilesData.subscriptions)) {
+          profilesData.subscriptions.forEach((sub, index) => {
+            profiles.push({
+              name: sub.name || `subscription-${index + 1}`,
+              provider: "azure" /* AZURE */,
+              isDefault: sub.isDefault === true,
+              status: sub.state === "Enabled" ? "available" : "invalid",
+              configPath: profilesFile
+            });
+          });
+        }
+      }
+    } catch (error) {
+      this.warnings.push(`Failed to discover Azure profiles: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return profiles;
+  }
+  /**
+   * Discover Alibaba Cloud profiles
+   */
+  async discoverAlibabaCloudProfiles() {
+    const profiles = [];
+    const alicloudConfigPath = join(this.homeDirectory, ".aliyun", "config.json");
+    if (!existsSync(alicloudConfigPath)) {
+      return profiles;
+    }
+    try {
+      const configData = JSON.parse(readFileSync(alicloudConfigPath, "utf8"));
+      if (configData.profiles && Array.isArray(configData.profiles)) {
+        configData.profiles.forEach((profile) => {
+          profiles.push({
+            name: profile.name || "default",
+            provider: "alicloud" /* ALIBABA_CLOUD */,
+            region: profile.region_id || "cn-hangzhou",
+            isDefault: profile.name === "default",
+            configPath: alicloudConfigPath,
+            status: profile.access_key_id ? "available" : "invalid"
+          });
+        });
+      }
+    } catch (error) {
+      this.warnings.push(`Failed to discover Alibaba Cloud profiles: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return profiles;
+  }
+  /**
+   * Discover Oracle Cloud profiles
+   */
+  async discoverOracleCloudProfiles() {
+    const profiles = [];
+    const ociConfigPath = join(this.homeDirectory, ".oci", "config");
+    if (!existsSync(ociConfigPath)) {
+      return profiles;
+    }
+    try {
+      const configProfiles = this.parseIniFile(ociConfigPath);
+      for (const [profileName, config] of Object.entries(configProfiles)) {
+        profiles.push({
+          name: profileName,
+          provider: "oracle" /* ORACLE_CLOUD */,
+          region: config.region || "us-phoenix-1",
+          isDefault: profileName === "DEFAULT",
+          configPath: ociConfigPath,
+          status: config.user && config.key_file ? "available" : "invalid"
+        });
+      }
+    } catch (error) {
+      this.warnings.push(`Failed to discover Oracle Cloud profiles: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return profiles;
+  }
+  /**
+   * Display discovered profiles in a formatted table
+   */
+  displayDiscoveryResults(results) {
+    console.log("\n" + chalk2.bold.cyan("\u{1F3AF} Profile Discovery Results"));
+    console.log("\u2550".repeat(60));
+    if (results.totalFound === 0) {
+      console.log(chalk2.yellow("\u26A0\uFE0F  No cloud provider profiles found"));
+      console.log(chalk2.gray("   Make sure you have configured at least one cloud provider CLI"));
+      return;
+    }
+    console.log(chalk2.green(`\u2705 Found ${results.totalFound} profiles across ${Object.keys(results.byProvider).length} providers`));
+    for (const [provider, profiles] of Object.entries(results.byProvider)) {
+      if (profiles.length > 0) {
+        console.log(`
+${this.getProviderIcon(provider)} ${chalk2.bold(provider.toUpperCase())}: ${profiles.length} profiles`);
+        profiles.forEach((profile, index) => {
+          const statusIcon = profile.status === "available" ? "\u2705" : profile.status === "invalid" ? "\u274C" : "\u26A0\uFE0F";
+          const defaultBadge = profile.isDefault ? chalk2.green(" (default)") : "";
+          console.log(`   ${index + 1}. ${profile.name}${defaultBadge} ${statusIcon}`);
+          if (profile.region) {
+            console.log(`      Region: ${chalk2.gray(profile.region)}`);
+          }
+        });
+      }
+    }
+    if (results.recommended) {
+      console.log("\n" + chalk2.bold.green("\u{1F31F} Recommended Profile:"));
+      console.log(`   ${results.recommended.provider.toUpperCase()}: ${results.recommended.name}`);
+      console.log(chalk2.gray(`   Use: --provider ${results.recommended.provider} --profile ${results.recommended.name}`));
+    }
+    if (results.warnings.length > 0) {
+      console.log("\n" + chalk2.bold.yellow("\u26A0\uFE0F  Warnings:"));
+      results.warnings.forEach((warning) => {
+        console.log(chalk2.yellow(`   \u2022 ${warning}`));
+      });
+    }
+    console.log("\n" + chalk2.bold.cyan("\u{1F4A1} Usage Examples:"));
+    console.log(chalk2.gray("   infra-cost --provider aws --profile production"));
+    console.log(chalk2.gray("   infra-cost --provider gcp --profile my-project"));
+    console.log(chalk2.gray("   infra-cost --all-profiles  # Use all available profiles"));
+  }
+  /**
+   * Auto-select best profile based on discovery results
+   */
+  autoSelectProfile(results) {
+    if (results.recommended && results.recommended.status === "available") {
+      return results.recommended;
+    }
+    for (const profiles of Object.values(results.byProvider)) {
+      const defaultProfile = profiles.find((p) => p.isDefault && p.status === "available");
+      if (defaultProfile)
+        return defaultProfile;
+    }
+    for (const profiles of Object.values(results.byProvider)) {
+      const availableProfile = profiles.find((p) => p.status === "available");
+      if (availableProfile)
+        return availableProfile;
+    }
+    return null;
+  }
+  // Helper methods
+  parseIniFile(filePath) {
+    const content = readFileSync(filePath, "utf8");
+    const profiles = {};
+    let currentProfile = "";
+    content.split("\n").forEach((line) => {
+      line = line.trim();
+      if (line.startsWith("[") && line.endsWith("]")) {
+        currentProfile = line.slice(1, -1);
+        profiles[currentProfile] = {};
+      } else if (currentProfile && line.includes("=")) {
+        const [key, ...valueParts] = line.split("=");
+        profiles[currentProfile][key.trim()] = valueParts.join("=").trim();
+      }
+    });
+    return profiles;
+  }
+  parseAWSConfigFile(filePath) {
+    const content = readFileSync(filePath, "utf8");
+    const profiles = {};
+    let currentProfile = "";
+    content.split("\n").forEach((line) => {
+      line = line.trim();
+      if (line.startsWith("[") && line.endsWith("]")) {
+        const profileMatch = line.match(/\[(?:profile\s+)?(.+)\]/);
+        currentProfile = profileMatch ? profileMatch[1] : "";
+        if (currentProfile) {
+          profiles[currentProfile] = {};
+        }
+      } else if (currentProfile && line.includes("=")) {
+        const [key, ...valueParts] = line.split("=");
+        profiles[currentProfile][key.trim()] = valueParts.join("=").trim();
+      }
+    });
+    return profiles;
+  }
+  validateAWSProfile(credConfig, fileConfig) {
+    if (credConfig.aws_access_key_id && credConfig.aws_secret_access_key) {
+      return "available";
+    }
+    if (fileConfig.role_arn || fileConfig.sso_start_url) {
+      return "available";
+    }
+    return "invalid";
+  }
+  getLastUsedDate(filePath) {
+    try {
+      const stats = __require("fs").statSync(filePath);
+      return stats.mtime;
+    } catch {
+      return void 0;
+    }
+  }
+  determineRecommendedProfile(byProvider) {
+    const priority = [
+      "aws" /* AWS */,
+      "gcp" /* GOOGLE_CLOUD */,
+      "azure" /* AZURE */,
+      "alicloud" /* ALIBABA_CLOUD */,
+      "oracle" /* ORACLE_CLOUD */
+    ];
+    for (const provider of priority) {
+      const profiles = byProvider[provider];
+      const defaultProfile = profiles.find((p) => p.isDefault && p.status === "available");
+      if (defaultProfile)
+        return defaultProfile;
+      const availableProfile = profiles.find((p) => p.status === "available");
+      if (availableProfile)
+        return availableProfile;
+    }
+    return null;
+  }
+  getProviderIcon(provider) {
+    const icons = {
+      ["aws" /* AWS */]: "\u2601\uFE0F",
+      ["gcp" /* GOOGLE_CLOUD */]: "\u{1F310}",
+      ["azure" /* AZURE */]: "\u{1F537}",
+      ["alicloud" /* ALIBABA_CLOUD */]: "\u{1F7E0}",
+      ["oracle" /* ORACLE_CLOUD */]: "\u{1F534}"
+    };
+    return icons[provider] || "\u2601\uFE0F";
+  }
+};
+
+// src/visualization/terminal-ui.ts
+import Table from "cli-table3";
+import chalk3 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) => chalk3.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 chalk3[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" + chalk3.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 += chalk3.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 += chalk3.gray(`Showing top ${maxDisplay} of ${allServiceEntries.length} services `) + chalk3.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 chalk3.red("No trend data available");
+    }
+    let output = "\n" + chalk3.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: `${chalk3.cyan(label)} ${chalk3.cyan("[")}${chalk3.yellow("{bar}")}${chalk3.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 chalk3.green("\u2705 No cost anomalies detected");
+    }
+    let output = "\n" + chalk3.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 += chalk3[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 += `   ${chalk3.gray(anomaly.description)}
+`;
+      }
+      output += "\n";
+    });
+    return output;
+  }
+  /**
+   * Creates a fancy header with branding
+   */
+  createHeader(title, subtitle) {
+    const width = 60;
+    let output = "\n";
+    output += chalk3.cyan("\u250C" + "\u2500".repeat(width - 2) + "\u2510") + "\n";
+    const titlePadding = Math.floor((width - title.length - 4) / 2);
+    output += chalk3.cyan("\u2502") + " ".repeat(titlePadding) + chalk3.bold.white(title) + " ".repeat(width - title.length - titlePadding - 2) + chalk3.cyan("\u2502") + "\n";
+    if (subtitle) {
+      const subtitlePadding = Math.floor((width - subtitle.length - 4) / 2);
+      output += chalk3.cyan("\u2502") + " ".repeat(subtitlePadding) + chalk3.gray(subtitle) + " ".repeat(width - subtitle.length - subtitlePadding - 2) + chalk3.cyan("\u2502") + "\n";
+    }
+    output += chalk3.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 chalk3.red(`\u2197 ${changeStr}`);
+    } else if (change < 0) {
+      return chalk3.green(`\u2198 ${changeStr}`);
+    } else {
+      return chalk3.gray("\u2192 0.0%");
+    }
+  }
+  getTrendIndicator(current, previous) {
+    if (previous === 0)
+      return chalk3.gray("\u2500");
+    const change = (current - previous) / previous * 100;
+    if (change > 10)
+      return chalk3.red("\u2197\u2197");
+    if (change > 0)
+      return chalk3.yellow("\u2197");
+    if (change < -10)
+      return chalk3.green("\u2198\u2198");
+    if (change < 0)
+      return chalk3.green("\u2198");
+    return chalk3.gray("\u2192");
+  }
+  colorizeBar(bar, normalizedValue, threshold) {
+    const thresholdValue = threshold || 0.7;
+    if (normalizedValue > thresholdValue) {
+      return chalk3.red(bar);
+    } else if (normalizedValue > 0.4) {
+      return chalk3.yellow(bar);
+    } else {
+      return chalk3.green(bar);
+    }
+  }
+  formatChangeIndicator(percentage) {
+    const indicator = percentage >= 0 ? "\u2197" : "\u2198";
+    const color = percentage >= 0 ? "red" : "green";
+    const sign = percentage >= 0 ? "+" : "";
+    return chalk3[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/visualization/multi-cloud-dashboard.ts
+var MultiCloudDashboard = class {
+  constructor() {
+    this.ui = new TerminalUIEngine();
+    this.factory = new CloudProviderFactory();
+    this.discovery = new CloudProfileDiscovery();
+  }
+  /**
+   * Create comprehensive multi-cloud inventory dashboard
+   */
+  async generateMultiCloudInventoryDashboard(providers) {
+    console.log(chalk4.yellow("\u{1F310} Gathering multi-cloud inventory..."));
+    const summary = await this.collectMultiCloudInventory(providers);
+    return this.renderMultiCloudDashboard(summary);
+  }
+  /**
+   * Collect inventory from all available cloud providers
+   */
+  async collectMultiCloudInventory(providers) {
+    const summary = {
+      totalProviders: 0,
+      totalResources: 0,
+      totalCost: 0,
+      providerBreakdown: {},
+      consolidatedResourcesByType: {
+        ["compute" /* COMPUTE */]: 0,
+        ["storage" /* STORAGE */]: 0,
+        ["database" /* DATABASE */]: 0,
+        ["network" /* NETWORK */]: 0,
+        ["security" /* SECURITY */]: 0,
+        ["serverless" /* SERVERLESS */]: 0,
+        ["container" /* CONTAINER */]: 0,
+        ["analytics" /* ANALYTICS */]: 0
+      },
+      topResourcesByProvider: []
+    };
+    const discoveryResults = await this.discovery.discoverAllProfiles();
+    const targetProviders = providers || this.factory.getSupportedProviders();
+    for (const provider of targetProviders) {
+      const profiles = discoveryResults.byProvider[provider];
+      summary.providerBreakdown[provider] = {
+        inventory: null,
+        status: "unavailable",
+        resourceCount: 0,
+        cost: 0
+      };
+      if (profiles.length === 0) {
+        continue;
+      }
+      try {
+        const profile = profiles.find((p) => p.status === "available");
+        if (!profile) {
+          summary.providerBreakdown[provider].status = "unavailable";
+          continue;
+        }
+        console.log(chalk4.gray(`  Scanning ${provider.toUpperCase()} resources...`));
+        const providerAdapter = this.createProviderAdapter(provider, profile);
+        if (!providerAdapter) {
+          summary.providerBreakdown[provider].status = "error";
+          summary.providerBreakdown[provider].errorMessage = "Failed to initialize provider";
+          continue;
+        }
+        const inventory = await providerAdapter.getResourceInventory({
+          includeCosts: true,
+          resourceTypes: Object.values(ResourceType)
+        });
+        summary.providerBreakdown[provider] = {
+          inventory,
+          status: "active",
+          resourceCount: inventory.totalResources,
+          cost: inventory.totalCost
+        };
+        summary.totalProviders++;
+        summary.totalResources += inventory.totalResources;
+        summary.totalCost += inventory.totalCost;
+        Object.entries(inventory.resourcesByType).forEach(([type, count]) => {
+          summary.consolidatedResourcesByType[type] += count;
+        });
+      } catch (error) {
+        console.warn(chalk4.yellow(`\u26A0\uFE0F  Failed to scan ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`));
+        summary.providerBreakdown[provider].status = "error";
+        summary.providerBreakdown[provider].errorMessage = error instanceof Error ? error.message : "Unknown error";
+      }
+    }
+    summary.topResourcesByProvider = this.calculateTopResourcesByProvider(summary);
+    return summary;
+  }
+  /**
+   * Render the multi-cloud dashboard
+   */
+  renderMultiCloudDashboard(summary) {
+    let output = "";
+    output += this.ui.createHeader(
+      "\u{1F310} Multi-Cloud Infrastructure Dashboard",
+      `Comprehensive view across ${summary.totalProviders} cloud providers`
+    );
+    output += chalk4.bold.cyan("\u{1F4CA} Executive Summary") + "\n";
+    output += "\u2550".repeat(60) + "\n\n";
+    const summaryTable = this.ui.createTable([
+      { header: "Metric", width: 25, align: "left", color: "cyan" },
+      { header: "Value", width: 20, align: "right", color: "yellow" },
+      { header: "Details", width: 30, align: "left" }
+    ], [
+      {
+        metric: "Active Providers",
+        value: summary.totalProviders.toString(),
+        details: this.getActiveProvidersList(summary)
+      },
+      {
+        metric: "Total Resources",
+        value: summary.totalResources.toLocaleString(),
+        details: this.getResourceTypeBreakdown(summary)
+      },
+      {
+        metric: "Total Monthly Cost",
+        value: `$${summary.totalCost.toFixed(2)}`,
+        details: this.getCostBreakdownByProvider(summary)
+      }
+    ]);
+    output += summaryTable + "\n\n";
+    output += chalk4.bold.cyan("\u2601\uFE0F Provider Breakdown") + "\n";
+    output += "\u2550".repeat(60) + "\n\n";
+    for (const [provider, data] of Object.entries(summary.providerBreakdown)) {
+      const providerName = this.getProviderDisplayName(provider);
+      const statusIcon = this.getStatusIcon(data.status);
+      const statusColor = this.getStatusColor(data.status);
+      output += `${statusIcon} ${chalk4.bold[statusColor](providerName)}
+`;
+      if (data.status === "active" && data.inventory) {
+        output += `   Resources: ${chalk4.yellow(data.resourceCount.toLocaleString())}
+`;
+        output += `   Cost: ${chalk4.green(`$${data.cost.toFixed(2)}`)}
+`;
+        output += `   Regions: ${chalk4.blue(data.inventory.region)}
+`;
+        output += `   Last Updated: ${chalk4.gray(data.inventory.lastUpdated.toLocaleString())}
+`;
+        const topTypes = Object.entries(data.inventory.resourcesByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a).slice(0, 3).map(([type, count]) => `${count} ${type}`).join(", ");
+        if (topTypes) {
+          output += `   Top Types: ${chalk4.gray(topTypes)}
+`;
+        }
+      } else if (data.status === "error") {
+        output += `   ${chalk4.red("Error: " + (data.errorMessage || "Unknown error"))}
+`;
+      } else if (data.status === "unavailable") {
+        output += `   ${chalk4.gray("No credentials or profiles configured")}
+`;
+      }
+      output += "\n";
+    }
+    output += chalk4.bold.cyan("\u{1F4C8} Consolidated Resource Analysis") + "\n";
+    output += "\u2550".repeat(60) + "\n\n";
+    const resourceTypeTable = this.ui.createTable([
+      { header: "Resource Type", width: 20, align: "left", color: "blue" },
+      { header: "Total Count", width: 15, align: "right", color: "yellow" },
+      { header: "Percentage", width: 12, align: "right" },
+      { header: "Top Provider", width: 20, align: "left" }
+    ], this.createResourceTypeRows(summary));
+    output += resourceTypeTable + "\n\n";
+    output += this.generateMultiCloudInsights(summary);
+    output += chalk4.bold.cyan("\u{1F4A1} Multi-Cloud Recommendations") + "\n";
+    output += "\u2550".repeat(60) + "\n";
+    output += this.generateMultiCloudRecommendations(summary);
+    return output;
+  }
+  /**
+   * Generate actionable multi-cloud insights
+   */
+  generateMultiCloudInsights(summary) {
+    let output = chalk4.bold.cyan("\u{1F9E0} Multi-Cloud Insights") + "\n";
+    output += "\u2550".repeat(60) + "\n\n";
+    const insights = [];
+    const activeProviders = Object.values(summary.providerBreakdown).filter((p) => p.status === "active").length;
+    if (activeProviders === 1) {
+      insights.push("\u{1F4CD} Single-cloud deployment detected - consider multi-cloud strategy for resilience");
+    } else if (activeProviders > 3) {
+      insights.push("\u{1F30D} Excellent cloud diversity - you have strong vendor independence");
+    }
+    const providerCosts = Object.entries(summary.providerBreakdown).filter(([, data]) => data.status === "active").map(([provider, data]) => ({ provider, cost: data.cost })).sort((a, b) => b.cost - a.cost);
+    if (providerCosts.length > 1) {
+      const topProvider = providerCosts[0];
+      const costPercentage = topProvider.cost / summary.totalCost * 100;
+      if (costPercentage > 70) {
+        insights.push(`\u{1F4B0} ${topProvider.provider.toUpperCase()} dominates ${costPercentage.toFixed(1)}% of costs - consider rebalancing`);
+      }
+    }
+    const topResourceType = Object.entries(summary.consolidatedResourcesByType).sort(([, a], [, b]) => b - a)[0];
+    if (topResourceType && topResourceType[1] > 0) {
+      const percentage = topResourceType[1] / summary.totalResources * 100;
+      insights.push(`\u{1F527} ${topResourceType[0]} resources account for ${percentage.toFixed(1)}% of total infrastructure`);
+    }
+    insights.forEach((insight, index) => {
+      output += `${index + 1}. ${insight}
+`;
+    });
+    return output + "\n";
+  }
+  /**
+   * Generate multi-cloud optimization recommendations
+   */
+  generateMultiCloudRecommendations(summary) {
+    let output = "";
+    const recommendations = [];
+    const activeProviders = Object.entries(summary.providerBreakdown).filter(([, data]) => data.status === "active");
+    if (activeProviders.length > 1) {
+      recommendations.push("\u{1F504} Use --compare-clouds to identify cost arbitrage opportunities");
+      recommendations.push("\u{1F4CA} Run --optimization-report for cross-cloud resource rightsizing");
+    }
+    const unavailableProviders = Object.entries(summary.providerBreakdown).filter(([, data]) => data.status === "unavailable");
+    if (unavailableProviders.length > 0) {
+      recommendations.push("\u{1F527} Configure credentials for unavailable providers to get complete visibility");
+      recommendations.push("\u{1F50D} Use --discover-profiles to check for existing but unconfigured profiles");
+    }
+    if (summary.totalCost > 1e3) {
+      recommendations.push("\u{1F4C8} Set up --monitor for real-time cost tracking across all providers");
+      recommendations.push("\u{1F6A8} Configure --alert-threshold for multi-cloud budget management");
+    }
+    recommendations.push("\u{1F3F7}\uFE0F Implement consistent tagging strategy across all cloud providers");
+    recommendations.push("\u{1F512} Use --dependency-mapping to understand cross-cloud resource relationships");
+    recommendations.forEach((rec, index) => {
+      output += chalk4.gray(`${index + 1}. ${rec}
+`);
+    });
+    output += "\n" + chalk4.bold.yellow("\u26A1 Quick Actions:") + "\n";
+    output += chalk4.gray("\u2022 infra-cost --all-profiles --combine-profiles  # Aggregate view\n");
+    output += chalk4.gray("\u2022 infra-cost --compare-clouds aws,gcp,azure     # Cost comparison\n");
+    output += chalk4.gray("\u2022 infra-cost --inventory --group-by provider    # Detailed inventory\n");
+    return output;
+  }
+  // Helper methods
+  createProviderAdapter(provider, profile) {
+    try {
+      const config = {
+        provider,
+        credentials: profile.credentials || {},
+        region: profile.region,
+        profile: profile.name
+      };
+      return this.factory.createProvider(config);
+    } catch (error) {
+      console.warn(`Failed to create provider adapter for ${provider}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+  getProviderDisplayName(provider) {
+    const names = CloudProviderFactory.getProviderDisplayNames();
+    return names[provider] || provider.toUpperCase();
+  }
+  getStatusIcon(status) {
+    switch (status) {
+      case "active":
+        return "\u2705";
+      case "unavailable":
+        return "\u26AA";
+      case "error":
+        return "\u274C";
+      default:
+        return "\u26AA";
+    }
+  }
+  getStatusColor(status) {
+    switch (status) {
+      case "active":
+        return "green";
+      case "unavailable":
+        return "gray";
+      case "error":
+        return "red";
+      default:
+        return "gray";
+    }
+  }
+  getActiveProvidersList(summary) {
+    const active = Object.entries(summary.providerBreakdown).filter(([, data]) => data.status === "active").map(([provider]) => provider.toUpperCase());
+    return active.join(", ") || "None";
+  }
+  getResourceTypeBreakdown(summary) {
+    const top3 = Object.entries(summary.consolidatedResourcesByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a).slice(0, 3).map(([type, count]) => `${count} ${type}`);
+    return top3.join(", ") || "None";
+  }
+  getCostBreakdownByProvider(summary) {
+    const costs = Object.entries(summary.providerBreakdown).filter(([, data]) => data.status === "active" && data.cost > 0).map(([provider, data]) => `${provider}: $${data.cost.toFixed(0)}`);
+    return costs.join(", ") || "None";
+  }
+  createResourceTypeRows(summary) {
+    return Object.entries(summary.consolidatedResourcesByType).filter(([, count]) => count > 0).sort(([, a], [, b]) => b - a).map(([type, count]) => {
+      const percentage = (count / summary.totalResources * 100).toFixed(1) + "%";
+      const topProvider = this.getTopProviderForResourceType(summary, type);
+      return {
+        resourceType: type.charAt(0).toUpperCase() + type.slice(1),
+        totalCount: count.toLocaleString(),
+        percentage,
+        topProvider: topProvider ? topProvider.toUpperCase() : "N/A"
+      };
+    });
+  }
+  getTopProviderForResourceType(summary, resourceType) {
+    let maxCount = 0;
+    let topProvider = null;
+    Object.entries(summary.providerBreakdown).forEach(([provider, data]) => {
+      if (data.inventory && data.inventory.resourcesByType[resourceType] > maxCount) {
+        maxCount = data.inventory.resourcesByType[resourceType];
+        topProvider = provider;
+      }
+    });
+    return topProvider;
+  }
+  calculateTopResourcesByProvider(summary) {
+    const results = [];
+    Object.entries(summary.providerBreakdown).forEach(([provider, data]) => {
+      if (data.inventory && data.resourceCount > 0) {
+        Object.entries(data.inventory.resourcesByType).forEach(([type, count]) => {
+          if (count > 0) {
+            results.push({
+              provider,
+              resourceType: type,
+              count,
+              percentage: count / summary.totalResources * 100
+            });
+          }
+        });
+      }
+    });
+    return results.sort((a, b) => b.count - a.count).slice(0, 10);
+  }
+};
+
+// src/demo/test-multi-cloud-dashboard.ts
+async function testMultiCloudDashboard() {
+  console.log("\u{1F680} Testing Multi-Cloud Dashboard...\n");
+  try {
+    const dashboard = new MultiCloudDashboard();
+    console.log("\u{1F4CA} Test 1: Full Multi-Cloud Dashboard");
+    console.log("\u2500".repeat(50));
+    const fullDashboard = await dashboard.generateMultiCloudInventoryDashboard();
+    console.log(fullDashboard);
+    console.log("\n\u{1F4CA} Test 2: Specific Providers Dashboard (AWS + GCP)");
+    console.log("\u2500".repeat(50));
+    const specificProviders = await dashboard.generateMultiCloudInventoryDashboard([
+      "aws" /* AWS */,
+      "gcp" /* GOOGLE_CLOUD */
+    ]);
+    console.log(specificProviders);
+    console.log("\n\u2705 Multi-Cloud Dashboard tests completed!");
+    console.log("\n\u{1F4A1} Usage Examples:");
+    console.log("   infra-cost --multi-cloud-dashboard");
+    console.log("   infra-cost --all-clouds-inventory");
+    console.log("   infra-cost --multi-cloud-dashboard --compare-clouds aws,gcp,azure");
+    console.log("   infra-cost --inventory --all-profiles");
+  } catch (error) {
+    console.error("\u274C Error testing multi-cloud dashboard:", error instanceof Error ? error.message : error);
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  testMultiCloudDashboard();
+}
+//# sourceMappingURL=test-multi-cloud-dashboard.js.map