npm - infra-cost - Versions diffs - 0.3.2 → 1.2.0 - Mend

infra-cost 0.3.2 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/README.md +663 -105
package/dist/cli/index.js +10888 -0
package/dist/index.js +10072 -35530
package/package.json +45 -28
package/dist/demo/test-enhanced-ui.js +0 -1693
package/dist/demo/test-multi-cloud-dashboard.js +0 -3375

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

@@ -1,3375 +0,0 @@
-#!/usr/bin/env node
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-// src/visualization/multi-cloud-dashboard.ts
-var import_chalk4 = __toESM(require("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
-var import_client_cost_explorer = require("@aws-sdk/client-cost-explorer");
-var import_client_iam = require("@aws-sdk/client-iam");
-var import_client_sts = require("@aws-sdk/client-sts");
-var import_client_ec2 = require("@aws-sdk/client-ec2");
-var import_client_s3 = require("@aws-sdk/client-s3");
-var import_client_rds = require("@aws-sdk/client-rds");
-var import_client_lambda = require("@aws-sdk/client-lambda");
-var import_client_budgets = require("@aws-sdk/client-budgets");
-var import_dayjs = __toESM(require("dayjs"));
-// src/logger.ts
-var import_chalk = __toESM(require("chalk"));
-var import_ora = __toESM(require("ora"));
-var spinner;
-function showSpinner(text) {
-  if (!spinner) {
-    spinner = (0, import_ora.default)({ 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 import_client_sts.STSClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      await sts.send(new import_client_sts.GetCallerIdentityCommand({}));
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async getAccountInfo() {
-    showSpinner("Getting AWS account information");
-    try {
-      const iam = new import_client_iam.IAMClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      const accountAliases = await iam.send(new import_client_iam.ListAccountAliasesCommand({}));
-      const foundAlias = accountAliases?.AccountAliases?.[0];
-      if (foundAlias) {
-        return {
-          id: foundAlias,
-          name: foundAlias,
-          provider: "aws" /* AWS */
-        };
-      }
-      const sts = new import_client_sts.STSClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      const accountInfo = await sts.send(new import_client_sts.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() {
-    showSpinner("Getting AWS pricing data");
-    try {
-      const costExplorer = new import_client_cost_explorer.CostExplorerClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      const endDate = (0, import_dayjs.default)().subtract(1, "day");
-      const startDate = endDate.subtract(65, "day");
-      const pricingData = await costExplorer.send(new import_client_cost_explorer.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 = group.Keys?.[0];
-          const cost = group.Metrics?.UnblendedCost?.Amount;
-          const costDate = day.TimePeriod?.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?.regions || [this.config.region || "us-east-1"];
-    const resourceTypes = filters?.resourceTypes || Object.values(ResourceType);
-    const includeCosts = 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) {
-    try {
-      const ec2Client = new import_client_ec2.EC2Client({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_ec2.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: instance.Tags?.find((tag) => tag.Key === "Name")?.Value || instance.InstanceId || "",
-            state: instance.State?.Name || "unknown",
-            region,
-            tags: instance.Tags?.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: instance.SecurityGroups?.map((sg) => sg.GroupId || "") || [],
-            subnetId: instance.SubnetId || "",
-            vpcId: instance.VpcId || "",
-            publicDnsName: instance.PublicDnsName,
-            privateDnsName: instance.PrivateDnsName,
-            monitoring: instance.Monitoring?.State === "enabled",
-            placement: {
-              availabilityZone: instance.Placement?.AvailabilityZone || "",
-              groupName: instance.Placement?.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 import_client_s3.S3Client({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_s3.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) {
-    try {
-      const ec2Client = new import_client_ec2.EC2Client({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_ec2.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: volume.Tags?.find((tag) => tag.Key === "Name")?.Value || volume.VolumeId,
-          state: volume.State || "unknown",
-          region,
-          tags: volume.Tags?.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: volume.Attachments?.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) {
-    try {
-      const rdsClient = new import_client_rds.RDSClient({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_rds.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: dbInstance.Endpoint?.Address,
-          port: dbInstance.Endpoint?.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 import_client_lambda.LambdaClient({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_lambda.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) {
-    try {
-      const ec2Client = new import_client_ec2.EC2Client({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_ec2.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: vpc.Tags?.find((tag) => tag.Key === "Name")?.Value || vpc.VpcId,
-          state: vpc.State || "unknown",
-          region,
-          tags: vpc.Tags?.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) {
-    try {
-      const ec2Client = new import_client_ec2.EC2Client({
-        credentials: this.getCredentials(),
-        region
-      });
-      const command = new import_client_ec2.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: subnet.Tags?.find((tag) => tag.Key === "Name")?.Value || subnet.SubnetId,
-          state: subnet.State || "unknown",
-          region,
-          tags: subnet.Tags?.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() {
-    showSpinner("Getting AWS budgets");
-    try {
-      const budgetsClient = new import_client_budgets.BudgetsClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      const sts = new import_client_sts.STSClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      const accountInfo = await sts.send(new import_client_sts.GetCallerIdentityCommand({}));
-      const accountId = accountInfo.Account;
-      if (!accountId) {
-        throw new Error("Unable to determine AWS account ID");
-      }
-      const budgetsResponse = await budgetsClient.send(new import_client_budgets.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(budget.CalculatedSpend?.ActualSpend?.Amount || "0"),
-          forecastedSpend: parseFloat(budget.CalculatedSpend?.ForecastedSpend?.Amount || "0"),
-          timeUnit: budget.TimeUnit || "MONTHLY",
-          timePeriod: {
-            start: typeof budget.TimePeriod?.Start === "string" ? budget.TimePeriod?.Start : budget.TimePeriod?.Start instanceof Date ? budget.TimePeriod?.Start.toISOString() : "",
-            end: typeof budget.TimePeriod?.End === "string" ? budget.TimePeriod?.End : budget.TimePeriod?.End instanceof Date ? budget.TimePeriod?.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) {
-    showSpinner("Analyzing cost trends");
-    try {
-      const costExplorer = new import_client_cost_explorer.CostExplorerClient({
-        credentials: this.getCredentials(),
-        region: this.getRegion()
-      });
-      const endDate = (0, import_dayjs.default)();
-      const startDate = endDate.subtract(months, "month");
-      const monthlyData = await costExplorer.send(new import_client_cost_explorer.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 = result.TimePeriod?.Start || "";
-        const monthCost = result.Total?.UnblendedCost?.Amount ? parseFloat(result.Total.UnblendedCost.Amount) : 0;
-        monthlyCosts.push(monthCost);
-        totalCost += monthCost;
-        const services = {};
-        result.Groups?.forEach((group) => {
-          const serviceName = group.Keys?.[0] || "Unknown";
-          const cost = parseFloat(group.Metrics?.UnblendedCost?.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 = monthlyBreakdown[i]?.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) {
-    if (!budget.CalculatedSpend)
-      return "OK";
-    const actual = parseFloat(budget.CalculatedSpend.ActualSpend?.Amount || "0");
-    const limit = parseFloat(budget.BudgetLimit?.Amount || "0");
-    const forecasted = parseFloat(budget.CalculatedSpend.ForecastedSpend?.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 = (0, import_dayjs.default)(timePeriod.end);
-    const now = (0, import_dayjs.default)();
-    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?.regions || [this.config.region || "us-central1"];
-    const resourceTypes = filters?.resourceTypes || Object.values(ResourceType);
-    const includeCosts = 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?.regions || [this.config.region || "eastus"];
-    const resourceTypes = filters?.resourceTypes || Object.values(ResourceType);
-    const includeCosts = 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
-var import_fs = require("fs");
-var import_path = require("path");
-var import_os = require("os");
-var import_chalk2 = __toESM(require("chalk"));
-var CloudProfileDiscovery = class {
-  constructor() {
-    this.warnings = [];
-    this.homeDirectory = (0, import_os.homedir)();
-  }
-  /**
-   * Discover all available cloud provider profiles
-   */
-  async discoverAllProfiles() {
-    console.log(import_chalk2.default.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 = (0, import_path.join)(this.homeDirectory, ".aws", "credentials");
-    const configPath = (0, import_path.join)(this.homeDirectory, ".aws", "config");
-    if (!(0, import_fs.existsSync)(credentialsPath) && !(0, import_fs.existsSync)(configPath)) {
-      return profiles;
-    }
-    try {
-      const credentialsProfiles = (0, import_fs.existsSync)(credentialsPath) ? this.parseIniFile(credentialsPath) : {};
-      const configProfiles = (0, import_fs.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: (0, import_fs.existsSync)(credentialsPath) ? credentialsPath : void 0,
-          configPath: (0, import_fs.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 = (0, import_path.join)(this.homeDirectory, ".config", "gcloud");
-    if (!(0, import_fs.existsSync)(gcpConfigDir)) {
-      return profiles;
-    }
-    try {
-      const configurationsPath = (0, import_path.join)(gcpConfigDir, "configurations");
-      if ((0, import_fs.existsSync)(configurationsPath)) {
-        const configFiles = require("fs").readdirSync(configurationsPath);
-        for (const configFile of configFiles) {
-          if (configFile.startsWith("config_")) {
-            const profileName = configFile.replace("config_", "");
-            const configPath = (0, import_path.join)(configurationsPath, configFile);
-            profiles.push({
-              name: profileName,
-              provider: "gcp" /* GOOGLE_CLOUD */,
-              isDefault: profileName === "default",
-              configPath,
-              status: "available",
-              lastUsed: this.getLastUsedDate(configPath)
-            });
-          }
-        }
-      }
-      const adcPath = (0, import_path.join)(gcpConfigDir, "application_default_credentials.json");
-      if ((0, import_fs.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 = (0, import_path.join)(this.homeDirectory, ".azure");
-    if (!(0, import_fs.existsSync)(azureConfigDir)) {
-      return profiles;
-    }
-    try {
-      const profilesFile = (0, import_path.join)(azureConfigDir, "azureProfile.json");
-      if ((0, import_fs.existsSync)(profilesFile)) {
-        const profilesData = JSON.parse((0, import_fs.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 = (0, import_path.join)(this.homeDirectory, ".aliyun", "config.json");
-    if (!(0, import_fs.existsSync)(alicloudConfigPath)) {
-      return profiles;
-    }
-    try {
-      const configData = JSON.parse((0, import_fs.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 = (0, import_path.join)(this.homeDirectory, ".oci", "config");
-    if (!(0, import_fs.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" + import_chalk2.default.bold.cyan("\u{1F3AF} Profile Discovery Results"));
-    console.log("\u2550".repeat(60));
-    if (results.totalFound === 0) {
-      console.log(import_chalk2.default.yellow("\u26A0\uFE0F  No cloud provider profiles found"));
-      console.log(import_chalk2.default.gray("   Make sure you have configured at least one cloud provider CLI"));
-      return;
-    }
-    console.log(import_chalk2.default.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)} ${import_chalk2.default.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 ? import_chalk2.default.green(" (default)") : "";
-          console.log(`   ${index + 1}. ${profile.name}${defaultBadge} ${statusIcon}`);
-          if (profile.region) {
-            console.log(`      Region: ${import_chalk2.default.gray(profile.region)}`);
-          }
-        });
-      }
-    }
-    if (results.recommended) {
-      console.log("\n" + import_chalk2.default.bold.green("\u{1F31F} Recommended Profile:"));
-      console.log(`   ${results.recommended.provider.toUpperCase()}: ${results.recommended.name}`);
-      console.log(import_chalk2.default.gray(`   Use: --provider ${results.recommended.provider} --profile ${results.recommended.name}`));
-    }
-    if (results.warnings.length > 0) {
-      console.log("\n" + import_chalk2.default.bold.yellow("\u26A0\uFE0F  Warnings:"));
-      results.warnings.forEach((warning) => {
-        console.log(import_chalk2.default.yellow(`   \u2022 ${warning}`));
-      });
-    }
-    console.log("\n" + import_chalk2.default.bold.cyan("\u{1F4A1} Usage Examples:"));
-    console.log(import_chalk2.default.gray("   infra-cost --provider aws --profile production"));
-    console.log(import_chalk2.default.gray("   infra-cost --provider gcp --profile my-project"));
-    console.log(import_chalk2.default.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 = (0, import_fs.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 = (0, import_fs.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
-var import_cli_table3 = __toESM(require("cli-table3"));
-var import_chalk3 = __toESM(require("chalk"));
-var import_cli_progress = __toESM(require("cli-progress"));
-var import_moment = __toESM(require("moment"));
-var TerminalUIEngine = class {
-  constructor() {
-    this.progressBar = null;
-  }
-  /**
-   * Creates a formatted table with enhanced styling
-   */
-  createTable(columns, rows) {
-    const table = new import_cli_table3.default({
-      head: columns.map((col) => import_chalk3.default.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 import_chalk3.default[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" + import_chalk3.default.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 += import_chalk3.default.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 += import_chalk3.default.gray(`Showing top ${maxDisplay} of ${allServiceEntries.length} services `) + import_chalk3.default.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 import_chalk3.default.red("No trend data available");
-    }
-    let output = "\n" + import_chalk3.default.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 = (0, import_moment.default)(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 import_cli_progress.default.SingleBar({
-      format: `${import_chalk3.default.cyan(label)} ${import_chalk3.default.cyan("[")}${import_chalk3.default.yellow("{bar}")}${import_chalk3.default.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 import_chalk3.default.green("\u2705 No cost anomalies detected");
-    }
-    let output = "\n" + import_chalk3.default.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 += import_chalk3.default[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 += `   ${import_chalk3.default.gray(anomaly.description)}
-`;
-      }
-      output += "\n";
-    });
-    return output;
-  }
-  /**
-   * Creates a fancy header with branding
-   */
-  createHeader(title, subtitle) {
-    const width = 60;
-    let output = "\n";
-    output += import_chalk3.default.cyan("\u250C" + "\u2500".repeat(width - 2) + "\u2510") + "\n";
-    const titlePadding = Math.floor((width - title.length - 4) / 2);
-    output += import_chalk3.default.cyan("\u2502") + " ".repeat(titlePadding) + import_chalk3.default.bold.white(title) + " ".repeat(width - title.length - titlePadding - 2) + import_chalk3.default.cyan("\u2502") + "\n";
-    if (subtitle) {
-      const subtitlePadding = Math.floor((width - subtitle.length - 4) / 2);
-      output += import_chalk3.default.cyan("\u2502") + " ".repeat(subtitlePadding) + import_chalk3.default.gray(subtitle) + " ".repeat(width - subtitle.length - subtitlePadding - 2) + import_chalk3.default.cyan("\u2502") + "\n";
-    }
-    output += import_chalk3.default.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 import_chalk3.default.red(`\u2197 ${changeStr}`);
-    } else if (change < 0) {
-      return import_chalk3.default.green(`\u2198 ${changeStr}`);
-    } else {
-      return import_chalk3.default.gray("\u2192 0.0%");
-    }
-  }
-  getTrendIndicator(current, previous) {
-    if (previous === 0)
-      return import_chalk3.default.gray("\u2500");
-    const change = (current - previous) / previous * 100;
-    if (change > 10)
-      return import_chalk3.default.red("\u2197\u2197");
-    if (change > 0)
-      return import_chalk3.default.yellow("\u2197");
-    if (change < -10)
-      return import_chalk3.default.green("\u2198\u2198");
-    if (change < 0)
-      return import_chalk3.default.green("\u2198");
-    return import_chalk3.default.gray("\u2192");
-  }
-  colorizeBar(bar, normalizedValue, threshold) {
-    const thresholdValue = threshold || 0.7;
-    if (normalizedValue > thresholdValue) {
-      return import_chalk3.default.red(bar);
-    } else if (normalizedValue > 0.4) {
-      return import_chalk3.default.yellow(bar);
-    } else {
-      return import_chalk3.default.green(bar);
-    }
-  }
-  formatChangeIndicator(percentage) {
-    const indicator = percentage >= 0 ? "\u2197" : "\u2198";
-    const color = percentage >= 0 ? "red" : "green";
-    const sign = percentage >= 0 ? "+" : "";
-    return import_chalk3.default[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(import_chalk4.default.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(import_chalk4.default.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(import_chalk4.default.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 += import_chalk4.default.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 += import_chalk4.default.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} ${import_chalk4.default.bold[statusColor](providerName)}
-`;
-      if (data.status === "active" && data.inventory) {
-        output += `   Resources: ${import_chalk4.default.yellow(data.resourceCount.toLocaleString())}
-`;
-        output += `   Cost: ${import_chalk4.default.green(`$${data.cost.toFixed(2)}`)}
-`;
-        output += `   Regions: ${import_chalk4.default.blue(data.inventory.region)}
-`;
-        output += `   Last Updated: ${import_chalk4.default.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: ${import_chalk4.default.gray(topTypes)}
-`;
-        }
-      } else if (data.status === "error") {
-        output += `   ${import_chalk4.default.red("Error: " + (data.errorMessage || "Unknown error"))}
-`;
-      } else if (data.status === "unavailable") {
-        output += `   ${import_chalk4.default.gray("No credentials or profiles configured")}
-`;
-      }
-      output += "\n";
-    }
-    output += import_chalk4.default.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 += import_chalk4.default.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 = import_chalk4.default.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 += import_chalk4.default.gray(`${index + 1}. ${rec}
-`);
-    });
-    output += "\n" + import_chalk4.default.bold.yellow("\u26A1 Quick Actions:") + "\n";
-    output += import_chalk4.default.gray("\u2022 infra-cost --all-profiles --combine-profiles  # Aggregate view\n");
-    output += import_chalk4.default.gray("\u2022 infra-cost --compare-clouds aws,gcp,azure     # Cost comparison\n");
-    output += import_chalk4.default.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
-var import_meta = {};
-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