@jadenrazo/cloudcost-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,4488 @@
+#!/usr/bin/env node
+import {
+  getAwsInstances,
+  getAzureVmSizes,
+  getGcpComputePricing,
+  getGcpDiskPricing,
+  getGcpMachineTypes,
+  getGcpSqlPricing,
+  getGcpStoragePricing,
+  getInstanceMap,
+  getRegionMappings,
+  getResourceEquivalents,
+  getStorageMap
+} from "./chunk-KZJSZMWM.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  cache: {
+    ttl_seconds: 86400,
+    db_path: ""
+  },
+  pricing: {
+    monthly_hours: 730,
+    default_currency: "USD",
+    aws_pricing_region: "us-east-1"
+  },
+  logging: {
+    level: "info"
+  }
+};
+
+// src/config.ts
+function getConfigDir() {
+  return join(homedir(), ".cloudcost");
+}
+function loadFileConfig() {
+  const configPath = join(getConfigDir(), "config.json");
+  if (!existsSync(configPath)) return {};
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function loadEnvConfig() {
+  const config = {};
+  const env = process.env;
+  if (env.CLOUDCOST_CACHE_TTL || env.CLOUDCOST_CACHE_PATH) {
+    config.cache = {
+      ttl_seconds: env.CLOUDCOST_CACHE_TTL ? parseInt(env.CLOUDCOST_CACHE_TTL, 10) : DEFAULT_CONFIG.cache.ttl_seconds,
+      db_path: env.CLOUDCOST_CACHE_PATH ?? ""
+    };
+  }
+  if (env.CLOUDCOST_LOG_LEVEL) {
+    config.logging = {
+      level: env.CLOUDCOST_LOG_LEVEL
+    };
+  }
+  if (env.CLOUDCOST_MONTHLY_HOURS) {
+    config.pricing = {
+      ...DEFAULT_CONFIG.pricing,
+      monthly_hours: parseInt(env.CLOUDCOST_MONTHLY_HOURS, 10)
+    };
+  }
+  return config;
+}
+function loadConfig() {
+  const fileConfig = loadFileConfig();
+  const envConfig = loadEnvConfig();
+  const defaultDbPath = join(getConfigDir(), "cache.db");
+  return {
+    cache: {
+      ...DEFAULT_CONFIG.cache,
+      db_path: defaultDbPath,
+      ...fileConfig.cache,
+      ...envConfig.cache
+    },
+    pricing: {
+      ...DEFAULT_CONFIG.pricing,
+      ...fileConfig.pricing,
+      ...envConfig.pricing
+    },
+    logging: {
+      ...DEFAULT_CONFIG.logging,
+      ...fileConfig.logging,
+      ...envConfig.logging
+    }
+  };
+}
+
+// src/logger.ts
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = "info";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  return LEVEL_ORDER[level] >= LEVEL_ORDER[currentLevel];
+}
+function log(level, message, data) {
+  if (!shouldLog(level)) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = data ? `[${timestamp}] ${level.toUpperCase()}: ${message} ${JSON.stringify(data)}` : `[${timestamp}] ${level.toUpperCase()}: ${message}`;
+  process.stderr.write(entry + "\n");
+}
+var logger = {
+  debug: (msg, data) => log("debug", msg, data),
+  info: (msg, data) => log("info", msg, data),
+  warn: (msg, data) => log("warn", msg, data),
+  error: (msg, data) => log("error", msg, data)
+};
+
+// src/pricing/cache.ts
+import Database from "better-sqlite3";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+var SCHEMA = `
+  CREATE TABLE IF NOT EXISTS pricing_cache (
+    key        TEXT PRIMARY KEY,
+    data       TEXT NOT NULL,
+    provider   TEXT NOT NULL,
+    service    TEXT NOT NULL,
+    region     TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_pricing_cache_provider   ON pricing_cache (provider);
+  CREATE INDEX IF NOT EXISTS idx_pricing_cache_expires_at ON pricing_cache (expires_at);
+`;
+var PricingCache = class {
+  db;
+  constructor(dbPath) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.db.exec(SCHEMA);
+    logger.debug("PricingCache initialised", { dbPath });
+  }
+  /**
+   * Retrieve a cached value by key. Returns null when the entry does not exist
+   * or has already expired; expired rows are deleted as a side-effect so the
+   * table self-trims on read.
+   */
+  get(key) {
+    const row = this.db.prepare(
+      "SELECT * FROM pricing_cache WHERE key = ?"
+    ).get(key);
+    if (!row) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (row.expires_at <= now) {
+      this.db.prepare("DELETE FROM pricing_cache WHERE key = ?").run(key);
+      logger.debug("Cache miss (expired)", { key });
+      return null;
+    }
+    logger.debug("Cache hit", { key });
+    return JSON.parse(row.data);
+  }
+  /**
+   * Store a value in the cache.
+   *
+   * The composite key convention for pricing lookups is:
+   *   `{provider}/{service}/{region}/{resource_type}`
+   *
+   * Callers are responsible for constructing the key before calling this
+   * method; the method itself treats the key as an opaque string so it can
+   * be reused for other cache domains in the future.
+   */
+  set(key, data, provider, service, region, ttlSeconds) {
+    const now = /* @__PURE__ */ new Date();
+    const expiresAt = new Date(now.getTime() + ttlSeconds * 1e3);
+    this.db.prepare(
+      `INSERT INTO pricing_cache (key, data, provider, service, region, created_at, expires_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT (key) DO UPDATE SET
+           data       = excluded.data,
+           provider   = excluded.provider,
+           service    = excluded.service,
+           region     = excluded.region,
+           created_at = excluded.created_at,
+           expires_at = excluded.expires_at`
+    ).run(
+      key,
+      JSON.stringify(data),
+      provider,
+      service,
+      region,
+      now.toISOString(),
+      expiresAt.toISOString()
+    );
+    logger.debug("Cache set", { key, ttlSeconds });
+  }
+  /** Remove a single cache entry. */
+  invalidate(key) {
+    const result = this.db.prepare("DELETE FROM pricing_cache WHERE key = ?").run(key);
+    logger.debug("Cache invalidated", { key, removed: result.changes });
+  }
+  /** Remove every cache entry belonging to a provider. */
+  invalidateByProvider(provider) {
+    const result = this.db.prepare("DELETE FROM pricing_cache WHERE provider = ?").run(provider);
+    logger.debug("Cache invalidated by provider", {
+      provider,
+      removed: result.changes
+    });
+  }
+  /**
+   * Delete all entries whose expiry timestamp is in the past.
+   * Returns the number of rows removed.
+   */
+  cleanup() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const result = this.db.prepare("DELETE FROM pricing_cache WHERE expires_at <= ?").run(now);
+    const removed = result.changes;
+    logger.debug("Cache cleanup complete", { removed });
+    return removed;
+  }
+  /** Return aggregate statistics about the current cache state. */
+  getStats() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const totals = this.db.prepare(
+      `SELECT
+           COUNT(*)                        AS total_entries,
+           COALESCE(SUM(LENGTH(data)), 0)  AS size_bytes
+         FROM pricing_cache`
+    ).get();
+    const expired = this.db.prepare(
+      "SELECT COUNT(*) AS expired_entries FROM pricing_cache WHERE expires_at <= ?"
+    ).get(now);
+    return {
+      total_entries: totals.total_entries,
+      expired_entries: expired.expired_entries,
+      size_bytes: totals.size_bytes
+    };
+  }
+  /** Close the underlying database connection. */
+  close() {
+    this.db.close();
+    logger.debug("PricingCache closed");
+  }
+};
+
+// src/pricing/aws/aws-normalizer.ts
+function extractUsdPrice(priceDimensions) {
+  for (const dim of Object.values(priceDimensions)) {
+    const usd = dim?.pricePerUnit?.USD;
+    if (usd !== void 0) {
+      const val = parseFloat(usd);
+      if (!isNaN(val)) return val;
+    }
+  }
+  return 0;
+}
+function extractUnit(priceDimensions) {
+  for (const dim of Object.values(priceDimensions)) {
+    if (dim?.unit) return String(dim.unit);
+  }
+  return "Hrs";
+}
+function normalizeAwsCompute(rawProduct, rawPrice, region) {
+  const attrs = rawProduct?.attributes ?? {};
+  const terms = rawPrice?.terms?.OnDemand ?? {};
+  let price = 0;
+  let unit = "Hrs";
+  for (const term of Object.values(terms)) {
+    const dims = term?.priceDimensions ?? {};
+    price = extractUsdPrice(dims);
+    unit = extractUnit(dims);
+    break;
+  }
+  return {
+    provider: "aws",
+    service: "ec2",
+    resource_type: attrs.instanceType ?? "unknown",
+    region,
+    unit,
+    price_per_unit: price,
+    currency: "USD",
+    description: attrs.instanceType ? `AWS EC2 ${attrs.instanceType} (${attrs.operatingSystem ?? "Linux"})` : void 0,
+    attributes: {
+      instance_type: attrs.instanceType ?? "",
+      vcpu: attrs.vcpu ?? "",
+      memory: attrs.memory ?? "",
+      operating_system: attrs.operatingSystem ?? "Linux",
+      tenancy: attrs.tenancy ?? "Shared"
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeAwsDatabase(rawProduct, rawPrice, region) {
+  const attrs = rawProduct?.attributes ?? {};
+  const terms = rawPrice?.terms?.OnDemand ?? {};
+  let price = 0;
+  let unit = "Hrs";
+  for (const term of Object.values(terms)) {
+    const dims = term?.priceDimensions ?? {};
+    price = extractUsdPrice(dims);
+    unit = extractUnit(dims);
+    break;
+  }
+  return {
+    provider: "aws",
+    service: "rds",
+    resource_type: attrs.instanceType ?? "unknown",
+    region,
+    unit,
+    price_per_unit: price,
+    currency: "USD",
+    description: attrs.instanceType ? `AWS RDS ${attrs.instanceType} (${attrs.databaseEngine ?? "MySQL"})` : void 0,
+    attributes: {
+      instance_type: attrs.instanceType ?? "",
+      database_engine: attrs.databaseEngine ?? "",
+      deployment_option: attrs.deploymentOption ?? "Single-AZ",
+      vcpu: attrs.vcpu ?? "",
+      memory: attrs.memory ?? ""
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeAwsStorage(rawProduct, rawPrice, region) {
+  const attrs = rawProduct?.attributes ?? {};
+  const terms = rawPrice?.terms?.OnDemand ?? {};
+  let price = 0;
+  let unit = "GB-Mo";
+  for (const term of Object.values(terms)) {
+    const dims = term?.priceDimensions ?? {};
+    price = extractUsdPrice(dims);
+    unit = extractUnit(dims);
+    break;
+  }
+  const volumeType = attrs.volumeApiName ?? attrs.volumeType ?? "gp3";
+  return {
+    provider: "aws",
+    service: "ebs",
+    resource_type: volumeType,
+    region,
+    unit,
+    price_per_unit: price,
+    currency: "USD",
+    description: `AWS EBS ${volumeType} volume`,
+    attributes: {
+      volume_type: volumeType,
+      max_iops: attrs.maxIopsvolume ?? "",
+      max_throughput: attrs.maxThroughputvolume ?? ""
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/pricing/aws/bulk-loader.ts
+function parseCsvLine(line) {
+  const fields = [];
+  let i = 0;
+  const len = line.length;
+  while (i <= len) {
+    if (i === len) {
+      if (fields.length > 0 && line[len - 1] === ",") {
+        fields.push("");
+      }
+      break;
+    }
+    if (line[i] === '"') {
+      i++;
+      let field = "";
+      while (i < len) {
+        if (line[i] === '"') {
+          if (i + 1 < len && line[i + 1] === '"') {
+            field += '"';
+            i += 2;
+          } else {
+            i++;
+            break;
+          }
+        } else {
+          field += line[i];
+          i++;
+        }
+      }
+      fields.push(field);
+      if (i < len && line[i] === ",") i++;
+    } else {
+      const start = i;
+      while (i < len && line[i] !== ",") i++;
+      fields.push(line.slice(start, i));
+      if (i < len) i++;
+    }
+  }
+  return fields;
+}
+var EC2_BASE_PRICES = {
+  "t2.micro": 0.0116,
+  "t2.small": 0.023,
+  "t2.medium": 0.0464,
+  "t2.large": 0.0928,
+  "t3.micro": 0.0104,
+  "t3.small": 0.0208,
+  "t3.medium": 0.0416,
+  "t3.large": 0.0832,
+  "t3.xlarge": 0.1664,
+  "t3.2xlarge": 0.3328,
+  "t3a.micro": 94e-4,
+  "t3a.small": 0.0188,
+  "t3a.medium": 0.0376,
+  "t3a.large": 0.0752,
+  "t3a.xlarge": 0.1504,
+  "t4g.micro": 84e-4,
+  "t4g.small": 0.0168,
+  "t4g.medium": 0.0336,
+  "t4g.large": 0.0672,
+  "t4g.xlarge": 0.1344,
+  "m5.large": 0.096,
+  "m5.xlarge": 0.192,
+  "m5.2xlarge": 0.384,
+  "m5.4xlarge": 0.768,
+  "m5a.large": 0.086,
+  "m5a.xlarge": 0.172,
+  "m5a.2xlarge": 0.344,
+  "m5a.4xlarge": 0.688,
+  "m6i.large": 0.096,
+  "m6i.xlarge": 0.192,
+  "m6i.2xlarge": 0.384,
+  "m6i.4xlarge": 0.768,
+  "m6i.8xlarge": 1.536,
+  "m6g.large": 0.077,
+  "m6g.xlarge": 0.154,
+  "m6g.2xlarge": 0.308,
+  "m6g.4xlarge": 0.616,
+  "m7i.large": 0.1008,
+  "m7i.xlarge": 0.2016,
+  "m7i.2xlarge": 0.4032,
+  "m7g.large": 0.0816,
+  "m7g.xlarge": 0.1632,
+  "m7g.2xlarge": 0.3264,
+  "m7g.4xlarge": 0.6528,
+  "c5.large": 0.085,
+  "c5.xlarge": 0.17,
+  "c5.2xlarge": 0.34,
+  "c5a.large": 0.077,
+  "c5a.xlarge": 0.154,
+  "c5a.2xlarge": 0.308,
+  "c6i.large": 0.085,
+  "c6i.xlarge": 0.17,
+  "c6i.2xlarge": 0.34,
+  "c6g.large": 0.068,
+  "c6g.xlarge": 0.136,
+  "c6g.2xlarge": 0.272,
+  "c6g.4xlarge": 0.544,
+  "c7i.large": 0.089,
+  "c7i.xlarge": 0.178,
+  "c7i.2xlarge": 0.357,
+  "c7g.large": 0.072,
+  "c7g.xlarge": 0.145,
+  "c7g.2xlarge": 0.29,
+  "c7g.4xlarge": 0.58,
+  "r5.large": 0.126,
+  "r5.xlarge": 0.252,
+  "r5.2xlarge": 0.504,
+  "r5a.large": 0.113,
+  "r5a.xlarge": 0.226,
+  "r5a.2xlarge": 0.452,
+  "r6i.large": 0.126,
+  "r6i.xlarge": 0.252,
+  "r6i.2xlarge": 0.504,
+  "r6g.large": 0.101,
+  "r6g.xlarge": 0.202,
+  "r6g.2xlarge": 0.403,
+  "r6g.4xlarge": 0.806,
+  "r7i.large": 0.133,
+  "r7i.xlarge": 0.266,
+  "r7i.2xlarge": 0.532,
+  "r7g.large": 0.107,
+  "r7g.xlarge": 0.214,
+  "r7g.2xlarge": 0.428,
+  "r7g.4xlarge": 0.856
+};
+var RDS_BASE_PRICES = {
+  "db.t3.micro": 0.017,
+  "db.t3.small": 0.034,
+  "db.t3.medium": 0.068,
+  "db.t3.large": 0.136,
+  "db.t4g.micro": 0.016,
+  "db.t4g.small": 0.032,
+  "db.t4g.medium": 0.065,
+  "db.t4g.large": 0.129,
+  "db.t4g.xlarge": 0.258,
+  "db.m5.large": 0.171,
+  "db.m5.xlarge": 0.342,
+  "db.m6g.large": 0.154,
+  "db.m6g.xlarge": 0.308,
+  "db.m6g.2xlarge": 0.616,
+  "db.m6i.large": 0.171,
+  "db.m6i.xlarge": 0.342,
+  "db.m6i.2xlarge": 0.684,
+  "db.m7g.large": 0.168,
+  "db.m7g.xlarge": 0.336,
+  "db.m7g.2xlarge": 0.672,
+  "db.r5.large": 0.25,
+  "db.r5.xlarge": 0.5,
+  "db.r5.2xlarge": 1,
+  "db.r6g.large": 0.218,
+  "db.r6g.xlarge": 0.437,
+  "db.r6g.2xlarge": 0.874,
+  "db.r6i.large": 0.25,
+  "db.r6i.xlarge": 0.5,
+  "db.r6i.2xlarge": 1
+};
+var EBS_BASE_PRICES = {
+  "gp3": 0.08,
+  "gp2": 0.1,
+  "io2": 0.125,
+  "io1": 0.125,
+  "st1": 0.045,
+  "sc1": 0.015
+};
+var ALB_HOURLY = 0.0225;
+var ALB_LCU_HOURLY = 8e-3;
+var NAT_HOURLY = 0.045;
+var NAT_PER_GB = 0.045;
+var EKS_HOURLY = 0.1;
+var REGION_MULTIPLIERS = {
+  "us-east-1": 1,
+  "us-east-2": 1,
+  "us-west-1": 1.08,
+  "us-west-2": 1,
+  "eu-west-1": 1.1,
+  "eu-west-2": 1.12,
+  "eu-central-1": 1.12,
+  "ap-southeast-1": 1.15,
+  "ap-southeast-2": 1.15,
+  "ap-northeast-1": 1.12,
+  "ap-northeast-2": 1.1,
+  "ap-south-1": 1.08,
+  "sa-east-1": 1.2,
+  "ca-central-1": 1.08,
+  "eu-north-1": 1.1,
+  "eu-south-1": 1.12,
+  "me-south-1": 1.15,
+  "af-south-1": 1.22
+};
+function regionMultiplier(region) {
+  return REGION_MULTIPLIERS[region.toLowerCase()] ?? 1;
+}
+var CACHE_TTL = 86400;
+var BULK_PRICING_BASE = "https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws";
+var AwsBulkLoader = class _AwsBulkLoader {
+  cache;
+  /**
+   * Deduplicates concurrent streaming CSV fetches for the same region.
+   * Keyed by region; value is the in-flight Promise<boolean>.
+   */
+  ec2CsvFetchInProgress = /* @__PURE__ */ new Map();
+  constructor(cache) {
+    this.cache = cache;
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  async getComputePrice(instanceType, region, os = "Linux") {
+    const cacheKey = this.buildCacheKey("ec2", region, instanceType, os);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      const csvOk = await this.fetchAndCacheEc2CsvPrices(region);
+      if (csvOk) {
+        const afterCsv = this.cache.get(cacheKey);
+        if (afterCsv) return afterCsv;
+      }
+    } catch (err) {
+      logger.debug("AWS EC2 CSV streaming failed", {
+        region,
+        instanceType,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    try {
+      const bulk = await this.fetchBulkPricing("AmazonEC2", region);
+      if (bulk) {
+        const result = this.extractEc2Price(bulk, instanceType, region, os);
+        if (result) {
+          this.cache.set(cacheKey, result, "aws", "ec2", region, CACHE_TTL);
+          return result;
+        }
+      }
+    } catch (err) {
+      logger.debug("AWS bulk EC2 JSON fetch failed, using fallback", {
+        region,
+        instanceType,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return this.fallbackComputePrice(instanceType, region, os, cacheKey);
+  }
+  async getDatabasePrice(instanceClass, region, engine = "MySQL") {
+    const cacheKey = this.buildCacheKey("rds", region, instanceClass, engine);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      const bulk = await this.fetchBulkPricing("AmazonRDS", region);
+      if (bulk) {
+        const result = this.extractRdsPrice(bulk, instanceClass, region, engine);
+        if (result) {
+          this.cache.set(cacheKey, result, "aws", "rds", region, CACHE_TTL);
+          return result;
+        }
+      }
+    } catch (err) {
+      logger.debug("AWS bulk RDS fetch failed, using fallback", {
+        region,
+        instanceClass,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return this.fallbackDatabasePrice(instanceClass, region, engine, cacheKey);
+  }
+  async getStoragePrice(volumeType, region) {
+    const cacheKey = this.buildCacheKey("ebs", region, volumeType);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      const bulk = await this.fetchBulkPricing("AmazonEC2", region);
+      if (bulk) {
+        const result = this.extractEbsPrice(bulk, volumeType, region);
+        if (result) {
+          this.cache.set(cacheKey, result, "aws", "ebs", region, CACHE_TTL);
+          return result;
+        }
+      }
+    } catch (err) {
+      logger.debug("AWS bulk EBS fetch failed, using fallback", {
+        region,
+        volumeType,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return this.fallbackStoragePrice(volumeType, region, cacheKey);
+  }
+  async getLoadBalancerPrice(region) {
+    const multiplier = regionMultiplier(region);
+    return {
+      provider: "aws",
+      service: "elb",
+      resource_type: "alb",
+      region,
+      unit: "Hrs",
+      price_per_unit: ALB_HOURLY * multiplier,
+      currency: "USD",
+      description: "AWS Application Load Balancer (hourly fixed charge)",
+      attributes: {
+        lcu_hourly_price: String(ALB_LCU_HOURLY * multiplier),
+        pricing_model: "fixed_plus_lcu"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getNatGatewayPrice(region) {
+    const multiplier = regionMultiplier(region);
+    return {
+      provider: "aws",
+      service: "vpc",
+      resource_type: "nat-gateway",
+      region,
+      unit: "Hrs",
+      price_per_unit: NAT_HOURLY * multiplier,
+      currency: "USD",
+      description: "AWS NAT Gateway (hourly charge + data processing)",
+      attributes: {
+        per_gb_price: String(NAT_PER_GB * multiplier)
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getKubernetesPrice(region) {
+    const multiplier = regionMultiplier(region);
+    return {
+      provider: "aws",
+      service: "eks",
+      resource_type: "cluster",
+      region,
+      unit: "Hrs",
+      price_per_unit: EKS_HOURLY * multiplier,
+      currency: "USD",
+      description: "AWS EKS control plane (per cluster/hour)",
+      attributes: {},
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – EC2 CSV streaming
+  // -------------------------------------------------------------------------
+  /**
+   * Fetch the per-region EC2 pricing CSV from the AWS Bulk Pricing endpoint,
+   * stream it line-by-line, parse every "Compute Instance / OnDemand / Shared"
+   * row for ALL operating systems, and write each extracted price into the
+   * SQLite cache.
+   *
+   * The CSV URL pattern is:
+   *   https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonEC2/current/{region}/index.csv
+   *
+   * The first ~5 rows of the file are metadata (FormatVersion, Disclaimer,
+   * Publication Date, etc.).  The actual header row is the first row whose
+   * first field is "SKU".
+   *
+   * Returns true when at least one price was extracted and cached.
+   */
+  fetchAndCacheEc2CsvPrices(region) {
+    const inflight = this.ec2CsvFetchInProgress.get(region);
+    if (inflight) return inflight;
+    const promise = this._doFetchAndCacheEc2CsvPrices(region).finally(() => {
+      this.ec2CsvFetchInProgress.delete(region);
+    });
+    this.ec2CsvFetchInProgress.set(region, promise);
+    return promise;
+  }
+  async _doFetchAndCacheEc2CsvPrices(region) {
+    const url = `${BULK_PRICING_BASE}/AmazonEC2/current/${region}/index.csv`;
+    logger.debug("Streaming AWS EC2 CSV pricing", { url, region });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 12e4);
+    try {
+      const res = await fetch(url, { signal: controller.signal });
+      if (!res.ok) {
+        logger.debug("AWS EC2 CSV fetch returned non-OK status", {
+          region,
+          status: res.status
+        });
+        return false;
+      }
+      if (!res.body) {
+        logger.debug("AWS EC2 CSV response has no body", { region });
+        return false;
+      }
+      const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
+      let colInstanceType = -1;
+      let colOS = -1;
+      let colTenancy = -1;
+      let colTermType = -1;
+      let colCapacityStatus = -1;
+      let colProductFamily = -1;
+      let colPrice = -1;
+      let colUnit = -1;
+      let headerFound = false;
+      let leftover = "";
+      let cachedCount = 0;
+      const effectiveDate = (/* @__PURE__ */ new Date()).toISOString();
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        const chunk = leftover + value;
+        const lines = chunk.split("\n");
+        leftover = lines.pop() ?? "";
+        for (const rawLine of lines) {
+          const line = rawLine.trimEnd();
+          if (!line) continue;
+          if (!headerFound) {
+            if (line.startsWith('"SKU"') || line.startsWith("SKU")) {
+              const headers = parseCsvLine(line);
+              for (let h = 0; h < headers.length; h++) {
+                const name = headers[h].trim();
+                if (name === "Instance Type") colInstanceType = h;
+                else if (name === "Operating System") colOS = h;
+                else if (name === "Tenancy") colTenancy = h;
+                else if (name === "TermType") colTermType = h;
+                else if (name === "Capacity Status") colCapacityStatus = h;
+                else if (name === "Product Family") colProductFamily = h;
+                else if (name === "PricePerUnit" || name === "Price Per Unit") colPrice = h;
+                else if (name === "Unit") colUnit = h;
+              }
+              if (colInstanceType === -1 || colOS === -1 || colPrice === -1) {
+                logger.debug("AWS EC2 CSV header missing required columns", {
+                  region,
+                  colInstanceType,
+                  colOS,
+                  colPrice
+                });
+                return false;
+              }
+              headerFound = true;
+            }
+            continue;
+          }
+          if (!line.includes("OnDemand") || !line.includes("Compute Instance")) {
+            continue;
+          }
+          const fields = parseCsvLine(line);
+          if (colProductFamily !== -1) {
+            const pf = fields[colProductFamily] ?? "";
+            if (pf !== "Compute Instance") continue;
+          }
+          if (colTenancy !== -1) {
+            const tenancy = fields[colTenancy] ?? "";
+            if (tenancy !== "Shared") continue;
+          }
+          if (colTermType !== -1) {
+            const termType = fields[colTermType] ?? "";
+            if (termType !== "OnDemand") continue;
+          }
+          if (colCapacityStatus !== -1) {
+            const cap = fields[colCapacityStatus] ?? "";
+            if (cap !== "Used") continue;
+          }
+          const instanceType = fields[colInstanceType] ?? "";
+          const os = fields[colOS] ?? "";
+          const rawPrice = fields[colPrice] ?? "";
+          const unit = colUnit !== -1 ? fields[colUnit] ?? "Hrs" : "Hrs";
+          if (!instanceType || !os || !rawPrice) continue;
+          const priceValue = parseFloat(rawPrice);
+          if (!isFinite(priceValue) || priceValue <= 0) continue;
+          const csvCacheKey = `aws/ec2/${region}/${instanceType.toLowerCase()}/${os.toLowerCase()}`;
+          const normalized = {
+            provider: "aws",
+            service: "ec2",
+            resource_type: instanceType,
+            region,
+            unit,
+            price_per_unit: priceValue,
+            currency: "USD",
+            description: `AWS EC2 ${instanceType} (${os}) on-demand`,
+            attributes: {
+              instance_type: instanceType,
+              operating_system: os,
+              tenancy: "Shared",
+              pricing_source: "live"
+            },
+            effective_date: effectiveDate
+          };
+          this.cache.set(csvCacheKey, normalized, "aws", "ec2", region, CACHE_TTL);
+          cachedCount++;
+        }
+      }
+      if (leftover.trim() && headerFound) {
+        const line = leftover.trimEnd();
+        if (line.includes("OnDemand") && line.includes("Compute Instance")) {
+          const fields = parseCsvLine(line);
+          const instanceType = fields[colInstanceType] ?? "";
+          const os = fields[colOS] ?? "";
+          const rawPrice = fields[colPrice] ?? "";
+          const unit = colUnit !== -1 ? fields[colUnit] ?? "Hrs" : "Hrs";
+          const priceValue = parseFloat(rawPrice);
+          if (instanceType && os && isFinite(priceValue) && priceValue > 0) {
+            const csvCacheKey = `aws/ec2/${region}/${instanceType.toLowerCase()}/${os.toLowerCase()}`;
+            this.cache.set(
+              csvCacheKey,
+              {
+                provider: "aws",
+                service: "ec2",
+                resource_type: instanceType,
+                region,
+                unit,
+                price_per_unit: priceValue,
+                currency: "USD",
+                description: `AWS EC2 ${instanceType} (${os}) on-demand`,
+                attributes: {
+                  instance_type: instanceType,
+                  operating_system: os,
+                  tenancy: "Shared",
+                  pricing_source: "live"
+                },
+                effective_date: (/* @__PURE__ */ new Date()).toISOString()
+              },
+              "aws",
+              "ec2",
+              region,
+              CACHE_TTL
+            );
+            cachedCount++;
+          }
+        }
+      }
+      logger.debug("AWS EC2 CSV streaming complete", { region, cachedCount });
+      return cachedCount > 0;
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        logger.debug("AWS EC2 CSV streaming timed out", { region });
+      } else {
+        logger.debug("AWS EC2 CSV streaming error", {
+          region,
+          err: err instanceof Error ? err.message : String(err)
+        });
+      }
+      return false;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – live API fetch
+  // -------------------------------------------------------------------------
+  async fetchBulkPricing(service, region) {
+    const url = `${BULK_PRICING_BASE}/${service}/current/${region}/index.json`;
+    logger.debug("Fetching AWS bulk pricing", { url });
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} from ${url}`);
+    }
+    return res.json();
+  }
+  buildCacheKey(service, region, ...parts) {
+    return ["aws", service, region, ...parts].map((p) => p.toLowerCase()).join("/");
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – extract prices from bulk JSON
+  // -------------------------------------------------------------------------
+  extractEc2Price(bulk, instanceType, region, os) {
+    const products = bulk?.products ?? {};
+    const onDemand = bulk?.terms?.OnDemand ?? {};
+    for (const [sku, product] of Object.entries(products)) {
+      const attrs = product?.attributes ?? {};
+      if (attrs.instanceType === instanceType && (attrs.operatingSystem ?? "").toLowerCase() === os.toLowerCase() && attrs.tenancy === "Shared" && attrs.capacitystatus === "Used") {
+        const priceTerms = onDemand[sku];
+        if (priceTerms) {
+          return normalizeAwsCompute(product, { terms: { OnDemand: { [sku]: priceTerms } } }, region);
+        }
+      }
+    }
+    return null;
+  }
+  extractRdsPrice(bulk, instanceClass, region, engine) {
+    const products = bulk?.products ?? {};
+    const onDemand = bulk?.terms?.OnDemand ?? {};
+    for (const [sku, product] of Object.entries(products)) {
+      const attrs = product?.attributes ?? {};
+      if (attrs.instanceType === instanceClass && (attrs.databaseEngine ?? "").toLowerCase().includes(engine.toLowerCase()) && attrs.deploymentOption === "Single-AZ") {
+        const priceTerms = onDemand[sku];
+        if (priceTerms) {
+          return normalizeAwsDatabase(product, { terms: { OnDemand: { [sku]: priceTerms } } }, region);
+        }
+      }
+    }
+    return null;
+  }
+  extractEbsPrice(bulk, volumeType, region) {
+    const products = bulk?.products ?? {};
+    const onDemand = bulk?.terms?.OnDemand ?? {};
+    for (const [sku, product] of Object.entries(products)) {
+      const attrs = product?.attributes ?? {};
+      const apiName = (attrs.volumeApiName ?? "").toLowerCase();
+      if (product?.productFamily === "Storage" && (apiName === volumeType.toLowerCase() || (attrs.volumeType ?? "").toLowerCase() === volumeType.toLowerCase())) {
+        const priceTerms = onDemand[sku];
+        if (priceTerms) {
+          return normalizeAwsStorage(product, { terms: { OnDemand: { [sku]: priceTerms } } }, region);
+        }
+      }
+    }
+    return null;
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – size interpolation
+  // -------------------------------------------------------------------------
+  /**
+   * AWS instance sizes follow a predictable doubling pattern:
+   * nano → micro → small → medium → large → xlarge → 2xlarge → 4xlarge → 8xlarge → ...
+   * Each step roughly doubles the price. Given a known price at one size,
+   * we can estimate the price for a missing size in the same family.
+   */
+  static SIZE_ORDER = [
+    "nano",
+    "micro",
+    "small",
+    "medium",
+    "large",
+    "xlarge",
+    "2xlarge",
+    "4xlarge",
+    "8xlarge",
+    "12xlarge",
+    "16xlarge",
+    "24xlarge",
+    "32xlarge",
+    "48xlarge"
+  ];
+  interpolatePrice(requestedType, table) {
+    const lower = requestedType.toLowerCase();
+    const lastDot = lower.lastIndexOf(".");
+    if (lastDot === -1) return void 0;
+    const family = lower.slice(0, lastDot);
+    const targetSize = lower.slice(lastDot + 1);
+    const targetIdx = _AwsBulkLoader.SIZE_ORDER.indexOf(targetSize);
+    if (targetIdx === -1) return void 0;
+    let bestKey;
+    let bestIdx = -1;
+    let bestDistance = Infinity;
+    for (const key of Object.keys(table)) {
+      const keyLastDot = key.lastIndexOf(".");
+      if (keyLastDot === -1) continue;
+      const keyFamily = key.slice(0, keyLastDot);
+      const keySize = key.slice(keyLastDot + 1);
+      if (keyFamily !== family) continue;
+      const keyIdx = _AwsBulkLoader.SIZE_ORDER.indexOf(keySize);
+      if (keyIdx === -1) continue;
+      const distance = Math.abs(keyIdx - targetIdx);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestIdx = keyIdx;
+        bestKey = key;
+      }
+    }
+    if (bestKey === void 0 || bestIdx === -1) return void 0;
+    const knownPrice = table[bestKey];
+    const steps = targetIdx - bestIdx;
+    return knownPrice * Math.pow(2, steps);
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – fallback hardcoded prices
+  // -------------------------------------------------------------------------
+  fallbackComputePrice(instanceType, region, os, cacheKey) {
+    let basePrice = EC2_BASE_PRICES[instanceType.toLowerCase()];
+    if (basePrice === void 0) {
+      basePrice = this.interpolatePrice(instanceType, EC2_BASE_PRICES) ?? void 0;
+    }
+    if (basePrice === void 0) {
+      logger.warn("No fallback price found for EC2 instance type", { instanceType });
+      return null;
+    }
+    const multiplier = regionMultiplier(region);
+    const result = {
+      provider: "aws",
+      service: "ec2",
+      resource_type: instanceType,
+      region,
+      unit: "Hrs",
+      price_per_unit: basePrice * multiplier,
+      currency: "USD",
+      description: `AWS EC2 ${instanceType} (${os}) \u2013 fallback pricing`,
+      attributes: {
+        instance_type: instanceType,
+        operating_system: os,
+        tenancy: "Shared",
+        pricing_source: "fallback"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(cacheKey, result, "aws", "ec2", region, CACHE_TTL);
+    return result;
+  }
+  fallbackDatabasePrice(instanceClass, region, engine, cacheKey) {
+    let basePrice = RDS_BASE_PRICES[instanceClass.toLowerCase()];
+    if (basePrice === void 0) {
+      basePrice = this.interpolatePrice(instanceClass, RDS_BASE_PRICES) ?? void 0;
+    }
+    if (basePrice === void 0) {
+      logger.warn("No fallback price found for RDS instance class", { instanceClass });
+      return null;
+    }
+    const multiplier = regionMultiplier(region);
+    const result = {
+      provider: "aws",
+      service: "rds",
+      resource_type: instanceClass,
+      region,
+      unit: "Hrs",
+      price_per_unit: basePrice * multiplier,
+      currency: "USD",
+      description: `AWS RDS ${instanceClass} (${engine}) \u2013 fallback pricing`,
+      attributes: {
+        instance_type: instanceClass,
+        database_engine: engine,
+        deployment_option: "Single-AZ",
+        pricing_source: "fallback"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(cacheKey, result, "aws", "rds", region, CACHE_TTL);
+    return result;
+  }
+  fallbackStoragePrice(volumeType, region, cacheKey) {
+    const basePrice = EBS_BASE_PRICES[volumeType.toLowerCase()];
+    if (basePrice === void 0) {
+      logger.warn("No fallback price found for EBS volume type", { volumeType });
+      return null;
+    }
+    const multiplier = regionMultiplier(region);
+    const result = {
+      provider: "aws",
+      service: "ebs",
+      resource_type: volumeType,
+      region,
+      unit: "GB-Mo",
+      price_per_unit: basePrice * multiplier,
+      currency: "USD",
+      description: `AWS EBS ${volumeType} volume \u2013 fallback pricing`,
+      attributes: {
+        volume_type: volumeType,
+        pricing_source: "fallback"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(cacheKey, result, "aws", "ebs", region, CACHE_TTL);
+    return result;
+  }
+};
+
+// src/pricing/azure/azure-normalizer.ts
+function normalizeAzureCompute(item) {
+  return {
+    provider: "azure",
+    service: "virtual-machines",
+    resource_type: item.skuName ?? item.armSkuName ?? "unknown",
+    region: item.armRegionName ?? item.location ?? "",
+    unit: item.unitOfMeasure ?? "1 Hour",
+    price_per_unit: item.retailPrice ?? item.unitPrice ?? 0,
+    currency: item.currencyCode ?? "USD",
+    tier: item.tierMinimumUnits !== void 0 ? String(item.tierMinimumUnits) : void 0,
+    description: item.productName ?? void 0,
+    attributes: {
+      sku_name: item.skuName ?? "",
+      arm_sku_name: item.armSkuName ?? "",
+      service_name: item.serviceName ?? "Virtual Machines",
+      product_name: item.productName ?? "",
+      meter_name: item.meterName ?? "",
+      pricing_source: "azure-retail-api"
+    },
+    effective_date: item.effectiveStartDate ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeAzureDatabase(item) {
+  return {
+    provider: "azure",
+    service: "azure-database",
+    resource_type: item.skuName ?? item.armSkuName ?? "unknown",
+    region: item.armRegionName ?? item.location ?? "",
+    unit: item.unitOfMeasure ?? "1 Hour",
+    price_per_unit: item.retailPrice ?? item.unitPrice ?? 0,
+    currency: item.currencyCode ?? "USD",
+    description: item.productName ?? void 0,
+    attributes: {
+      sku_name: item.skuName ?? "",
+      service_name: item.serviceName ?? "",
+      product_name: item.productName ?? "",
+      meter_name: item.meterName ?? "",
+      pricing_source: "azure-retail-api"
+    },
+    effective_date: item.effectiveStartDate ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeAzureStorage(item) {
+  return {
+    provider: "azure",
+    service: "managed-disks",
+    resource_type: item.skuName ?? item.armSkuName ?? "unknown",
+    region: item.armRegionName ?? item.location ?? "",
+    unit: item.unitOfMeasure ?? "1 GiB/Month",
+    price_per_unit: item.retailPrice ?? item.unitPrice ?? 0,
+    currency: item.currencyCode ?? "USD",
+    description: item.productName ?? void 0,
+    attributes: {
+      sku_name: item.skuName ?? "",
+      service_name: item.serviceName ?? "",
+      product_name: item.productName ?? "",
+      meter_name: item.meterName ?? "",
+      pricing_source: "azure-retail-api"
+    },
+    effective_date: item.effectiveStartDate ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/pricing/azure/retail-client.ts
+var VM_BASE_PRICES = {
+  "standard_b1s": 0.0104,
+  "standard_b1ms": 0.0207,
+  "standard_b2s": 0.0416,
+  "standard_b2ms": 0.0832,
+  "standard_b4ms": 0.166,
+  "standard_b8ms": 0.333,
+  "standard_b12ms": 0.499,
+  "standard_b16ms": 0.666,
+  "standard_d2s_v4": 0.096,
+  "standard_d4s_v4": 0.192,
+  "standard_d8s_v4": 0.384,
+  "standard_d2s_v5": 0.096,
+  "standard_d4s_v5": 0.192,
+  "standard_d8s_v5": 0.384,
+  "standard_d16s_v5": 0.768,
+  "standard_d32s_v5": 1.536,
+  "standard_d2ds_v5": 0.113,
+  "standard_d4ds_v5": 0.226,
+  "standard_d8ds_v5": 0.452,
+  "standard_d2ps_v5": 0.077,
+  "standard_d4ps_v5": 0.154,
+  "standard_e2s_v5": 0.126,
+  "standard_e4s_v5": 0.252,
+  "standard_e8s_v5": 0.504,
+  "standard_e16s_v5": 1.008,
+  "standard_e32s_v5": 2.016,
+  "standard_e2ds_v5": 0.144,
+  "standard_e4ds_v5": 0.288,
+  "standard_f2s_v2": 0.085,
+  "standard_f4s_v2": 0.17,
+  "standard_f8s_v2": 0.34,
+  "standard_f16s_v2": 0.68,
+  "standard_f32s_v2": 1.36,
+  "standard_l8s_v3": 0.624,
+  "standard_l16s_v3": 1.248,
+  "standard_nc4as_t4_v3": 0.526,
+  "standard_nc8as_t4_v3": 0.752,
+  "standard_e2ps_v5": 0.101,
+  "standard_e4ps_v5": 0.202,
+  "standard_e8ps_v5": 0.403
+};
+var DISK_BASE_PRICES = {
+  "premium_lrs": 0.132,
+  "standard_lrs": 0.04,
+  "standardssd_lrs": 0.075,
+  "ultrassd_lrs": 0.12,
+  "premium_lrs_p10": 52e-4,
+  "premium_lrs_p20": 0.01,
+  "premium_lrs_p30": 0.0192,
+  "premium_lrs_p40": 0.0373
+};
+var DB_BASE_PRICES = {
+  "burstable_standard_b1ms": 0.044,
+  "burstable_standard_b2s": 0.088,
+  "burstable_standard_b4ms": 0.176,
+  "gp_standard_d2s_v3": 0.124,
+  "gp_standard_d4s_v3": 0.248,
+  "gp_standard_d8s_v3": 0.496,
+  "gp_standard_d16s_v3": 0.992,
+  "gp_standard_d2ds_v4": 0.124,
+  "gp_standard_d4ds_v4": 0.248,
+  "gp_standard_d8ds_v4": 0.496,
+  "gp_standard_d16ds_v4": 0.992,
+  "mo_standard_e2ds_v4": 0.17,
+  "mo_standard_e4ds_v4": 0.341,
+  "mo_standard_e8ds_v4": 0.682
+};
+var ALB_HOURLY2 = 0.025;
+var ALB_RULE_HOURLY = 5e-3;
+var NAT_HOURLY2 = 0.045;
+var NAT_PER_GB2 = 0.045;
+var AKS_HOURLY = 0.1;
+var REGION_MULTIPLIERS2 = {
+  eastus: 1,
+  eastus2: 1,
+  westus: 1.05,
+  westus2: 1,
+  westus3: 1.02,
+  centralus: 1,
+  northeurope: 1.08,
+  westeurope: 1.08,
+  uksouth: 1.08,
+  ukwest: 1.12,
+  southeastasia: 1.12,
+  eastasia: 1.12,
+  japaneast: 1.1,
+  japanwest: 1.12,
+  australiaeast: 1.15,
+  brazilsouth: 1.25,
+  canadacentral: 1.05,
+  southafricanorth: 1.15,
+  germanywestcentral: 1.1,
+  centralindia: 1.08,
+  koreacentral: 1.1,
+  swedencentral: 1.08,
+  italynorth: 1.1,
+  uaenorth: 1.12
+};
+function regionMultiplier2(region) {
+  return REGION_MULTIPLIERS2[region.toLowerCase()] ?? 1;
+}
+var CACHE_TTL2 = 86400;
+var RETAIL_API_BASE = "https://prices.azure.com/api/retail/prices";
+var AzureRetailClient = class {
+  cache;
+  constructor(cache) {
+    this.cache = cache;
+  }
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  async getComputePrice(vmSize, region, os = "linux") {
+    const cacheKey = this.buildCacheKey("vm", region, vmSize, os);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      const armRegion = region.toLowerCase().replace(/\s+/g, "");
+      const filter = this.buildODataFilter("Virtual Machines", armRegion, vmSize, true);
+      const items = await this.queryPricing(filter);
+      const match = this.pickVmItem(items, vmSize, os);
+      if (match) {
+        const result = normalizeAzureCompute(match);
+        this.cache.set(cacheKey, result, "azure", "vm", region, CACHE_TTL2);
+        return result;
+      }
+    } catch (err) {
+      logger.debug("Azure Retail API VM fetch failed, using fallback", {
+        region,
+        vmSize,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return this.fallbackComputePrice(vmSize, region, os, cacheKey);
+  }
+  async getDatabasePrice(tier, region, engine = "PostgreSQL") {
+    const cacheKey = this.buildCacheKey("db", region, tier, engine);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      const armRegion = region.toLowerCase().replace(/\s+/g, "");
+      const serviceName = `Azure Database for ${engine}`;
+      const filter = this.buildODataFilter(serviceName, armRegion, tier);
+      const items = await this.queryPricing(filter);
+      if (items.length > 0) {
+        const result = normalizeAzureDatabase(items[0]);
+        this.cache.set(cacheKey, result, "azure", "db", region, CACHE_TTL2);
+        return result;
+      }
+    } catch (err) {
+      logger.debug("Azure Retail API DB fetch failed, using fallback", {
+        region,
+        tier,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return this.fallbackDatabasePrice(tier, region, engine, cacheKey);
+  }
+  async getStoragePrice(diskType, region) {
+    const cacheKey = this.buildCacheKey("disk", region, diskType);
+    const cached = this.cache.get(cacheKey);
+    if (cached) return cached;
+    try {
+      const armRegion = region.toLowerCase().replace(/\s+/g, "");
+      const filter = this.buildODataFilter("Storage", armRegion, diskType);
+      const items = await this.queryPricing(filter);
+      if (items.length > 0) {
+        const result = normalizeAzureStorage(items[0]);
+        this.cache.set(cacheKey, result, "azure", "storage", region, CACHE_TTL2);
+        return result;
+      }
+    } catch (err) {
+      logger.debug("Azure Retail API storage fetch failed, using fallback", {
+        region,
+        diskType,
+        err: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return this.fallbackStoragePrice(diskType, region, cacheKey);
+  }
+  async getLoadBalancerPrice(region) {
+    const multiplier = regionMultiplier2(region);
+    return {
+      provider: "azure",
+      service: "load-balancer",
+      resource_type: "standard",
+      region,
+      unit: "1 Hour",
+      price_per_unit: ALB_HOURLY2 * multiplier,
+      currency: "USD",
+      description: "Azure Load Balancer Standard (hourly + per rule)",
+      attributes: {
+        rule_hourly_price: String(ALB_RULE_HOURLY * multiplier),
+        pricing_model: "fixed_plus_rules"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getNatGatewayPrice(region) {
+    const multiplier = regionMultiplier2(region);
+    return {
+      provider: "azure",
+      service: "nat-gateway",
+      resource_type: "nat-gateway",
+      region,
+      unit: "1 Hour",
+      price_per_unit: NAT_HOURLY2 * multiplier,
+      currency: "USD",
+      description: "Azure NAT Gateway (hourly + data processed)",
+      attributes: {
+        per_gb_price: String(NAT_PER_GB2 * multiplier)
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getKubernetesPrice(region) {
+    const multiplier = regionMultiplier2(region);
+    return {
+      provider: "azure",
+      service: "aks",
+      resource_type: "cluster",
+      region,
+      unit: "1 Hour",
+      price_per_unit: AKS_HOURLY * multiplier,
+      currency: "USD",
+      description: "Azure Kubernetes Service (uptime SLA tier, per cluster/hour)",
+      attributes: {},
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – live API
+  // -------------------------------------------------------------------------
+  async queryPricing(filter) {
+    const allItems = [];
+    let url = `${RETAIL_API_BASE}?api-version=2023-01-01-preview&$filter=${encodeURIComponent(filter)}`;
+    logger.debug("Querying Azure Retail Prices API", { filter });
+    let pages = 0;
+    while (url && pages < 10) {
+      const res = await fetch(url, {
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!res.ok) {
+        throw new Error(`HTTP ${res.status} from Azure Retail API`);
+      }
+      const json = await res.json();
+      allItems.push(...json?.Items ?? []);
+      url = json?.NextPageLink ?? null;
+      pages++;
+    }
+    return allItems;
+  }
+  buildODataFilter(service, armRegion, skuName, exactArmSku) {
+    let filter = `serviceName eq '${service}' and armRegionName eq '${armRegion}' and priceType eq 'Consumption'`;
+    if (skuName) {
+      if (exactArmSku) {
+        filter += ` and armSkuName eq '${skuName}'`;
+      } else {
+        filter += ` and contains(skuName, '${skuName}')`;
+      }
+    }
+    return filter;
+  }
+  buildCacheKey(service, region, ...parts) {
+    return ["azure", service, region, ...parts].map((p) => p.toLowerCase()).join("/");
+  }
+  /**
+   * From the API response items, pick the item that best matches the desired
+   * VM size and OS.  Prefers exact skuName matches and the correct OS suffix
+   * ("Windows" vs everything else being Linux).
+   */
+  pickVmItem(items, vmSize, os) {
+    if (items.length === 0) return null;
+    const vmLower = vmSize.toLowerCase();
+    const isWindows = os.toLowerCase().includes("windows");
+    for (const item of items) {
+      const skuLower = (item.skuName ?? "").toLowerCase();
+      const hasWindows = skuLower.includes("windows");
+      if (skuLower.includes(vmLower) && (isWindows && hasWindows || !isWindows && !hasWindows)) {
+        return item;
+      }
+    }
+    return items[0];
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – size interpolation
+  // -------------------------------------------------------------------------
+  /**
+   * Azure VM sizes embed vCPU count as a number: Standard_D2s_v5 → 2 vCPUs.
+   * Doubling the number roughly doubles the price. Find the nearest known
+   * size in the same family/suffix and scale proportionally.
+   */
+  interpolateVmPrice(vmSize, table) {
+    const key = vmSize.toLowerCase().replace(/\s+/g, "_");
+    const match = key.match(/^(.+?)(\d+)(.*?)$/);
+    if (!match) return void 0;
+    const [, prefix, numStr, suffix] = match;
+    const targetNum = parseInt(numStr, 10);
+    if (isNaN(targetNum) || targetNum === 0) return void 0;
+    let bestKey;
+    let bestNum = 0;
+    let bestDistance = Infinity;
+    for (const candidate of Object.keys(table)) {
+      const candMatch = candidate.match(/^(.+?)(\d+)(.*?)$/);
+      if (!candMatch) continue;
+      const [, cPrefix, cNumStr, cSuffix] = candMatch;
+      if (cPrefix !== prefix || cSuffix !== suffix) continue;
+      const cNum = parseInt(cNumStr, 10);
+      if (isNaN(cNum) || cNum === 0) continue;
+      const distance = Math.abs(cNum - targetNum);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestNum = cNum;
+        bestKey = candidate;
+      }
+    }
+    if (bestKey === void 0 || bestNum === 0) return void 0;
+    return table[bestKey] * (targetNum / bestNum);
+  }
+  /**
+   * Azure DB tier names embed a vCPU number similarly to VM sizes.
+   * e.g. "gp_standard_d2s_v3" → "gp_standard_d4s_v3" doubles.
+   */
+  interpolateDbPrice(tier, table) {
+    const key = tier.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
+    const match = key.match(/^(.+?)(\d+)(.*?)$/);
+    if (!match) return void 0;
+    const [, prefix, numStr, suffix] = match;
+    const targetNum = parseInt(numStr, 10);
+    if (isNaN(targetNum) || targetNum === 0) return void 0;
+    let bestKey;
+    let bestNum = 0;
+    let bestDistance = Infinity;
+    for (const candidate of Object.keys(table)) {
+      const candMatch = candidate.match(/^(.+?)(\d+)(.*?)$/);
+      if (!candMatch) continue;
+      const [, cPrefix, cNumStr, cSuffix] = candMatch;
+      if (cPrefix !== prefix || cSuffix !== suffix) continue;
+      const cNum = parseInt(cNumStr, 10);
+      if (isNaN(cNum) || cNum === 0) continue;
+      const distance = Math.abs(cNum - targetNum);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        bestNum = cNum;
+        bestKey = candidate;
+      }
+    }
+    if (bestKey === void 0 || bestNum === 0) return void 0;
+    return table[bestKey] * (targetNum / bestNum);
+  }
+  // -------------------------------------------------------------------------
+  // Internal helpers – fallback hardcoded prices
+  // -------------------------------------------------------------------------
+  fallbackComputePrice(vmSize, region, os, cacheKey) {
+    const key = vmSize.toLowerCase().replace(/\s+/g, "_");
+    let basePrice = VM_BASE_PRICES[key];
+    if (basePrice === void 0) {
+      basePrice = this.interpolateVmPrice(vmSize, VM_BASE_PRICES) ?? void 0;
+    }
+    if (basePrice === void 0) {
+      logger.warn("No fallback price found for Azure VM size", { vmSize });
+      return null;
+    }
+    const multiplier = regionMultiplier2(region);
+    const result = {
+      provider: "azure",
+      service: "virtual-machines",
+      resource_type: vmSize,
+      region,
+      unit: "1 Hour",
+      price_per_unit: basePrice * multiplier,
+      currency: "USD",
+      description: `Azure VM ${vmSize} (${os}) \u2013 fallback pricing`,
+      attributes: {
+        sku_name: vmSize,
+        operating_system: os,
+        pricing_source: "fallback"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(cacheKey, result, "azure", "vm", region, CACHE_TTL2);
+    return result;
+  }
+  fallbackDatabasePrice(tier, region, engine, cacheKey) {
+    const key = tier.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
+    let basePrice = DB_BASE_PRICES[key];
+    if (basePrice === void 0) {
+      basePrice = this.interpolateDbPrice(tier, DB_BASE_PRICES) ?? void 0;
+    }
+    if (basePrice === void 0) {
+      logger.warn("No fallback price found for Azure DB tier", { tier });
+      return null;
+    }
+    const multiplier = regionMultiplier2(region);
+    const result = {
+      provider: "azure",
+      service: "azure-database",
+      resource_type: tier,
+      region,
+      unit: "1 Hour",
+      price_per_unit: basePrice * multiplier,
+      currency: "USD",
+      description: `Azure Database for ${engine} ${tier} \u2013 fallback pricing`,
+      attributes: {
+        tier,
+        engine,
+        pricing_source: "fallback"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(cacheKey, result, "azure", "db", region, CACHE_TTL2);
+    return result;
+  }
+  fallbackStoragePrice(diskType, region, cacheKey) {
+    const key = diskType.toLowerCase().replace(/\s+/g, "_").replace(/-/g, "_");
+    const basePrice = DISK_BASE_PRICES[key];
+    if (basePrice === void 0) {
+      logger.warn("No fallback price found for Azure disk type", { diskType });
+      return null;
+    }
+    const multiplier = regionMultiplier2(region);
+    const result = {
+      provider: "azure",
+      service: "managed-disks",
+      resource_type: diskType,
+      region,
+      unit: "1 GiB/Month",
+      price_per_unit: basePrice * multiplier,
+      currency: "USD",
+      description: `Azure Managed Disk ${diskType} \u2013 fallback pricing`,
+      attributes: {
+        disk_type: diskType,
+        pricing_source: "fallback"
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.cache.set(cacheKey, result, "azure", "storage", region, CACHE_TTL2);
+    return result;
+  }
+};
+
+// src/pricing/gcp/gcp-normalizer.ts
+function normalizeGcpCompute(machineType, hourlyPrice, region) {
+  return {
+    provider: "gcp",
+    service: "compute-engine",
+    resource_type: machineType,
+    region,
+    unit: "h",
+    price_per_unit: hourlyPrice,
+    currency: "USD",
+    description: `GCP Compute Engine ${machineType}`,
+    attributes: {
+      machine_type: machineType,
+      pricing_source: "bundled"
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeGcpDatabase(tier, hourlyPrice, region) {
+  return {
+    provider: "gcp",
+    service: "cloud-sql",
+    resource_type: tier,
+    region,
+    unit: "h",
+    price_per_unit: hourlyPrice,
+    currency: "USD",
+    description: `GCP Cloud SQL ${tier}`,
+    attributes: {
+      tier,
+      pricing_source: "bundled"
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeGcpStorage(storageClass, pricePerGb, region) {
+  return {
+    provider: "gcp",
+    service: "cloud-storage",
+    resource_type: storageClass,
+    region,
+    unit: "GiBy.mo",
+    price_per_unit: pricePerGb,
+    currency: "USD",
+    description: `GCP Cloud Storage ${storageClass}`,
+    attributes: {
+      storage_class: storageClass,
+      pricing_source: "bundled"
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeGcpDisk(diskType, pricePerGb, region) {
+  return {
+    provider: "gcp",
+    service: "persistent-disk",
+    resource_type: diskType,
+    region,
+    unit: "GiBy.mo",
+    price_per_unit: pricePerGb,
+    currency: "USD",
+    description: `GCP Persistent Disk ${diskType}`,
+    attributes: {
+      disk_type: diskType,
+      pricing_source: "bundled"
+    },
+    effective_date: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/pricing/gcp/bundled-loader.ts
+var LB_FORWARDING_RULE_HOURLY = 0.025;
+var LB_PER_GB = 8e-3;
+var NAT_HOURLY3 = 0.044;
+var NAT_PER_GB3 = 0.045;
+var GKE_STANDARD_HOURLY = 0.1;
+var GKE_AUTOPILOT_VCPU_HOURLY = 0.0445;
+var GcpBundledLoader = class {
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+  async getComputePrice(machineType, region) {
+    try {
+      const pricing = getGcpComputePricing();
+      const regionPrices = pricing[region];
+      if (!regionPrices) {
+        logger.debug("GCP compute: region not found in bundled data", {
+          region,
+          machineType
+        });
+        return null;
+      }
+      const price = regionPrices[machineType];
+      if (price === void 0) {
+        logger.debug("GCP compute: machine type not found in bundled data", {
+          region,
+          machineType
+        });
+        return null;
+      }
+      return normalizeGcpCompute(machineType, price, region);
+    } catch (err) {
+      logger.error("GCP compute pricing load error", {
+        machineType,
+        region,
+        err: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async getDatabasePrice(tier, region) {
+    try {
+      const pricing = getGcpSqlPricing();
+      const regionPrices = pricing[region];
+      if (!regionPrices) {
+        logger.debug("GCP SQL: region not found in bundled data", {
+          region,
+          tier
+        });
+        return null;
+      }
+      const price = regionPrices[tier];
+      if (price === void 0 || tier === "storage_per_gb" || tier === "ha_multiplier") {
+        logger.debug("GCP SQL: tier not found in bundled data", {
+          region,
+          tier
+        });
+        return null;
+      }
+      return normalizeGcpDatabase(tier, price, region);
+    } catch (err) {
+      logger.error("GCP SQL pricing load error", {
+        tier,
+        region,
+        err: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async getStoragePrice(storageClass, region) {
+    try {
+      const pricing = getGcpStoragePricing();
+      const regionPrices = pricing[region];
+      if (!regionPrices) {
+        logger.debug("GCP Storage: region not found in bundled data", {
+          region,
+          storageClass
+        });
+        return null;
+      }
+      const classKey = storageClass.toUpperCase();
+      const price = regionPrices[classKey];
+      if (price === void 0) {
+        logger.debug("GCP Storage: storage class not found in bundled data", {
+          region,
+          storageClass
+        });
+        return null;
+      }
+      return normalizeGcpStorage(storageClass.toUpperCase(), price, region);
+    } catch (err) {
+      logger.error("GCP Storage pricing load error", {
+        storageClass,
+        region,
+        err: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async getDiskPrice(diskType, region) {
+    try {
+      const pricing = getGcpDiskPricing();
+      const regionPrices = pricing[region];
+      if (!regionPrices) {
+        logger.debug("GCP Disk: region not found in bundled data", {
+          region,
+          diskType
+        });
+        return null;
+      }
+      const diskKey = diskType;
+      const price = regionPrices[diskKey];
+      if (price === void 0) {
+        logger.debug("GCP Disk: disk type not found in bundled data", {
+          region,
+          diskType
+        });
+        return null;
+      }
+      return normalizeGcpDisk(diskType, price, region);
+    } catch (err) {
+      logger.error("GCP Disk pricing load error", {
+        diskType,
+        region,
+        err: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  }
+  async getLoadBalancerPrice(region) {
+    return {
+      provider: "gcp",
+      service: "cloud-load-balancing",
+      resource_type: "forwarding-rule",
+      region,
+      unit: "h",
+      price_per_unit: LB_FORWARDING_RULE_HOURLY,
+      currency: "USD",
+      description: "GCP Cloud Load Balancing forwarding rule (per hour + data processed)",
+      attributes: {
+        per_gb_price: String(LB_PER_GB)
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getNatGatewayPrice(region) {
+    return {
+      provider: "gcp",
+      service: "cloud-nat",
+      resource_type: "nat-gateway",
+      region,
+      unit: "h",
+      price_per_unit: NAT_HOURLY3,
+      currency: "USD",
+      description: "GCP Cloud NAT (per gateway/hour + data processed)",
+      attributes: {
+        per_gb_price: String(NAT_PER_GB3)
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  async getKubernetesPrice(region, mode = "standard") {
+    const hourlyPrice = mode === "autopilot" ? GKE_AUTOPILOT_VCPU_HOURLY : GKE_STANDARD_HOURLY;
+    return {
+      provider: "gcp",
+      service: "gke",
+      resource_type: "cluster",
+      region,
+      unit: "h",
+      price_per_unit: hourlyPrice,
+      currency: "USD",
+      description: mode === "autopilot" ? "GCP GKE Autopilot cluster (estimated per-vCPU/hr; actual billing is per-pod resources)" : "GCP GKE Standard cluster (per cluster/hour)",
+      attributes: {
+        mode,
+        ...mode === "autopilot" && {
+          pricing_model: "per_vcpu_hour",
+          pricing_note: "Autopilot charges per pod vCPU and memory. This price is a per-vCPU/hr approximation for cluster-level cost estimation."
+        }
+      },
+      effective_date: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/pricing/pricing-engine.ts
+var AwsProvider = class {
+  loader;
+  constructor(cache) {
+    this.loader = new AwsBulkLoader(cache);
+  }
+  getComputePrice(instanceType, region, os) {
+    return this.loader.getComputePrice(instanceType, region, os);
+  }
+  getDatabasePrice(instanceType, region, engine) {
+    return this.loader.getDatabasePrice(instanceType, region, engine);
+  }
+  getStoragePrice(storageType, region, _sizeGb) {
+    return this.loader.getStoragePrice(storageType, region);
+  }
+  getLoadBalancerPrice(_type, region) {
+    return this.loader.getLoadBalancerPrice(region);
+  }
+  getNatGatewayPrice(region) {
+    return this.loader.getNatGatewayPrice(region);
+  }
+  getKubernetesPrice(region) {
+    return this.loader.getKubernetesPrice(region);
+  }
+};
+var AzureProvider = class {
+  client;
+  constructor(cache) {
+    this.client = new AzureRetailClient(cache);
+  }
+  getComputePrice(instanceType, region, os) {
+    return this.client.getComputePrice(instanceType, region, os);
+  }
+  getDatabasePrice(instanceType, region, engine) {
+    return this.client.getDatabasePrice(instanceType, region, engine);
+  }
+  getStoragePrice(storageType, region, _sizeGb) {
+    return this.client.getStoragePrice(storageType, region);
+  }
+  getLoadBalancerPrice(_type, region) {
+    return this.client.getLoadBalancerPrice(region);
+  }
+  getNatGatewayPrice(region) {
+    return this.client.getNatGatewayPrice(region);
+  }
+  getKubernetesPrice(region) {
+    return this.client.getKubernetesPrice(region);
+  }
+};
+var GcpProvider = class {
+  loader;
+  constructor() {
+    this.loader = new GcpBundledLoader();
+  }
+  getComputePrice(instanceType, region, _os) {
+    return this.loader.getComputePrice(instanceType, region);
+  }
+  getDatabasePrice(instanceType, region, _engine) {
+    return this.loader.getDatabasePrice(instanceType, region);
+  }
+  getStoragePrice(storageType, region, _sizeGb) {
+    if (storageType.startsWith("pd-")) {
+      return this.loader.getDiskPrice(storageType, region);
+    }
+    return this.loader.getStoragePrice(storageType, region);
+  }
+  getLoadBalancerPrice(_type, region) {
+    return this.loader.getLoadBalancerPrice(region);
+  }
+  getNatGatewayPrice(region) {
+    return this.loader.getNatGatewayPrice(region);
+  }
+  getKubernetesPrice(region) {
+    return this.loader.getKubernetesPrice(region);
+  }
+};
+var PricingEngine = class {
+  providers = /* @__PURE__ */ new Map();
+  constructor(cache, _config) {
+    this.providers.set("aws", new AwsProvider(cache));
+    this.providers.set("azure", new AzureProvider(cache));
+    this.providers.set("gcp", new GcpProvider());
+  }
+  /**
+   * Return the PricingProvider for a specific cloud provider.
+   * Throws if the provider is not registered (should never happen for the
+   * three known providers).
+   */
+  getProvider(provider) {
+    const p = this.providers.get(provider);
+    if (!p) {
+      throw new Error(`Unknown cloud provider: ${provider}`);
+    }
+    return p;
+  }
+  /**
+   * Generic price lookup that maps service/resourceType strings to the
+   * appropriate method on the underlying PricingProvider.
+   *
+   * Supported service values (case-insensitive):
+   *   compute, ec2, vm, instance        → getComputePrice
+   *   database, rds, sql, db            → getDatabasePrice
+   *   storage, ebs, disk, gcs           → getStoragePrice
+   *   lb, load-balancer, alb, nlb       → getLoadBalancerPrice
+   *   nat, nat-gateway                  → getNatGatewayPrice
+   *   k8s, kubernetes, eks, aks, gke    → getKubernetesPrice
+   */
+  async getPrice(provider, service, resourceType, region, attributes = {}) {
+    const p = this.getProvider(provider);
+    const svc = service.toLowerCase();
+    logger.debug("PricingEngine.getPrice", {
+      provider,
+      service,
+      resourceType,
+      region
+    });
+    if (svc === "compute" || svc === "ec2" || svc === "vm" || svc === "instance" || svc === "virtual-machines") {
+      return p.getComputePrice(resourceType, region, attributes.os);
+    }
+    if (svc === "database" || svc === "rds" || svc === "sql" || svc === "db" || svc === "cloud-sql" || svc === "azure-database") {
+      return p.getDatabasePrice(resourceType, region, attributes.engine);
+    }
+    if (svc === "storage" || svc === "ebs" || svc === "disk" || svc === "gcs" || svc === "managed-disks" || svc === "persistent-disk" || svc === "cloud-storage") {
+      const sizeGb = attributes.size_gb ? parseFloat(attributes.size_gb) : void 0;
+      return p.getStoragePrice(resourceType, region, sizeGb);
+    }
+    if (svc === "lb" || svc === "load-balancer" || svc === "alb" || svc === "nlb" || svc === "elb" || svc === "cloud-load-balancing") {
+      return p.getLoadBalancerPrice(resourceType, region);
+    }
+    if (svc === "nat" || svc === "nat-gateway" || svc === "cloud-nat") {
+      return p.getNatGatewayPrice(region);
+    }
+    if (svc === "k8s" || svc === "kubernetes" || svc === "eks" || svc === "aks" || svc === "gke") {
+      return p.getKubernetesPrice(region);
+    }
+    logger.warn("PricingEngine: unrecognised service", { service, provider });
+    return null;
+  }
+};
+
+// src/tools/analyze-terraform.ts
+import { z } from "zod";
+
+// src/parsers/hcl-parser.ts
+import { parse } from "@cdktf/hcl2json";
+async function parseHclToJson(hclContent, filename = "main.tf") {
+  if (!hclContent.trim()) {
+    logger.debug("Received empty HCL content, returning empty object", {
+      filename
+    });
+    return {};
+  }
+  try {
+    const result = await parse(filename, hclContent);
+    logger.debug("Parsed HCL successfully", { filename });
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.error("Failed to parse HCL", { filename, error: message });
+    throw new Error(
+      `HCL parse error in "${filename}": ${message}`
+    );
+  }
+}
+
+// src/parsers/variable-resolver.ts
+function resolveVariables(hclJson, tfvarsContent) {
+  const defaults = extractVariableDefaults(hclJson);
+  const overrides = tfvarsContent ? parseTfvars(tfvarsContent) : {};
+  const resolved = { ...defaults, ...overrides };
+  logger.debug("Resolved variables", {
+    defaultCount: Object.keys(defaults).length,
+    overrideCount: Object.keys(overrides).length
+  });
+  return resolved;
+}
+function extractVariableDefaults(hclJson) {
+  const defaults = {};
+  const variableBlock = hclJson["variable"];
+  if (!variableBlock || typeof variableBlock !== "object") {
+    return defaults;
+  }
+  for (const [varName, declarations] of Object.entries(
+    variableBlock
+  )) {
+    if (!Array.isArray(declarations) || declarations.length === 0) continue;
+    const declaration = declarations[0];
+    if ("default" in declaration) {
+      defaults[varName] = declaration["default"];
+    }
+  }
+  return defaults;
+}
+function parseTfvars(content) {
+  const result = {};
+  for (const rawLine of content.split("\n")) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eqIndex = line.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = line.slice(0, eqIndex).trim();
+    const rawValue = line.slice(eqIndex + 1).trim();
+    if (!key) continue;
+    result[key] = parseTfvarsValue(rawValue);
+  }
+  return result;
+}
+function parseTfvarsValue(raw) {
+  if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'")) {
+    return raw.slice(1, -1);
+  }
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  if (/^-?\d+$/.test(raw)) return parseInt(raw, 10);
+  if (/^-?\d+\.\d+$/.test(raw)) return parseFloat(raw);
+  return raw;
+}
+function substituteVariables(value, variables) {
+  if (typeof value === "string") {
+    return substituteInString(value, variables);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => substituteVariables(item, variables));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = substituteVariables(v, variables);
+    }
+    return result;
+  }
+  return value;
+}
+var VAR_ONLY_RE = /^\$\{var\.([^}]+)\}$/;
+var VAR_INLINE_RE = /\$\{var\.([^}]+)\}/g;
+function substituteInString(str2, variables) {
+  const wholeMatch = VAR_ONLY_RE.exec(str2);
+  if (wholeMatch) {
+    const varName = wholeMatch[1];
+    return varName in variables ? variables[varName] : str2;
+  }
+  return str2.replace(VAR_INLINE_RE, (_match, varName) => {
+    if (varName in variables) {
+      const v = variables[varName];
+      return v === null ? "" : String(v);
+    }
+    return _match;
+  });
+}
+
+// src/parsers/provider-detector.ts
+var PROVIDER_PREFIXES = [
+  ["aws_", "aws"],
+  ["azurerm_", "azure"],
+  ["google_", "gcp"]
+];
+function detectProvider(resourceType) {
+  for (const [prefix, provider] of PROVIDER_PREFIXES) {
+    if (resourceType.startsWith(prefix)) {
+      return provider;
+    }
+  }
+  throw new Error(
+    `Cannot determine cloud provider for resource type "${resourceType}". Supported prefixes: aws_, azurerm_, google_`
+  );
+}
+
+// src/parsers/resource-extractor.ts
+function detectRegionFromProviders(hclJson, provider, variables) {
+  const defaults = {
+    aws: "us-east-1",
+    azure: "eastus",
+    gcp: "us-central1"
+  };
+  const providerBlock = hclJson["provider"];
+  if (!providerBlock || typeof providerBlock !== "object") {
+    return defaults[provider];
+  }
+  const providerKeyMap = {
+    aws: "aws",
+    azure: "azurerm",
+    gcp: "google"
+  };
+  const key = providerKeyMap[provider];
+  const declarations = providerBlock[key];
+  if (!Array.isArray(declarations) || declarations.length === 0) {
+    return defaults[provider];
+  }
+  const declaration = declarations[0];
+  const regionAttr = provider === "azure" ? "location" : "region";
+  const rawRegion = declaration[regionAttr];
+  if (!rawRegion) return defaults[provider];
+  const resolved = substituteVariables(rawRegion, variables);
+  if (typeof resolved === "string" && resolved && !resolved.startsWith("${")) {
+    return resolved;
+  }
+  return defaults[provider];
+}
+function firstBlock(block, key) {
+  const nested = block[key];
+  if (Array.isArray(nested) && nested.length > 0) {
+    return nested[0];
+  }
+  return {};
+}
+function str(v) {
+  return typeof v === "string" && v ? v : void 0;
+}
+function num(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    return isNaN(n) ? void 0 : n;
+  }
+  return void 0;
+}
+function bool(v) {
+  if (typeof v === "boolean") return v;
+  if (v === "true") return true;
+  if (v === "false") return false;
+  return void 0;
+}
+var extractors = {
+  aws_instance(block) {
+    const root = firstBlock(block, "root_block_device");
+    const attrs = {};
+    if (str(block["instance_type"])) attrs.instance_type = str(block["instance_type"]);
+    if (str(block["ami"])) attrs.ami = str(block["ami"]);
+    if (str(block["availability_zone"])) attrs.availability_zone = str(block["availability_zone"]);
+    if (root["volume_type"]) attrs.storage_type = str(root["volume_type"]);
+    if (root["volume_size"] !== void 0) attrs.storage_size_gb = num(root["volume_size"]);
+    if (root["iops"] !== void 0) attrs.iops = num(root["iops"]);
+    if (root["throughput"] !== void 0) attrs.throughput_mbps = num(root["throughput"]);
+    return attrs;
+  },
+  aws_db_instance(block) {
+    const attrs = {};
+    if (str(block["instance_class"])) attrs.instance_type = str(block["instance_class"]);
+    if (str(block["engine"])) attrs.engine = str(block["engine"]);
+    if (str(block["engine_version"])) attrs.engine_version = str(block["engine_version"]);
+    if (str(block["storage_type"])) attrs.storage_type = str(block["storage_type"]);
+    if (block["allocated_storage"] !== void 0) attrs.storage_size_gb = num(block["allocated_storage"]);
+    if (block["iops"] !== void 0) attrs.iops = num(block["iops"]);
+    if (block["multi_az"] !== void 0) attrs.multi_az = bool(block["multi_az"]);
+    if (block["replicas"] !== void 0) attrs.replicas = num(block["replicas"]);
+    return attrs;
+  },
+  aws_rds_cluster(block) {
+    const attrs = {};
+    if (str(block["engine"])) attrs.engine = str(block["engine"]);
+    if (str(block["engine_version"])) attrs.engine_version = str(block["engine_version"]);
+    if (str(block["db_cluster_instance_class"])) attrs.instance_type = str(block["db_cluster_instance_class"]);
+    if (block["master_username"]) attrs.master_username = str(block["master_username"]);
+    return attrs;
+  },
+  aws_s3_bucket(block) {
+    const attrs = {};
+    const lifecycle = firstBlock(block, "lifecycle_rule");
+    const transition = firstBlock(lifecycle, "transition");
+    if (str(transition["storage_class"])) attrs.storage_type = str(transition["storage_class"]);
+    if (str(block["bucket"])) attrs.bucket = str(block["bucket"]);
+    return attrs;
+  },
+  aws_lb(block) {
+    const attrs = {};
+    if (str(block["load_balancer_type"])) attrs.load_balancer_type = str(block["load_balancer_type"]);
+    if (block["internal"] !== void 0) attrs.internal = bool(block["internal"]);
+    return attrs;
+  },
+  aws_alb(block) {
+    return extractors["aws_lb"](block);
+  },
+  aws_nat_gateway(block) {
+    const attrs = {};
+    if (str(block["allocation_id"])) attrs.allocation_id = str(block["allocation_id"]);
+    return attrs;
+  },
+  aws_eks_cluster(block) {
+    const attrs = {};
+    if (str(block["name"])) attrs.cluster_name = str(block["name"]);
+    return attrs;
+  },
+  aws_eks_node_group(block) {
+    const scaling = firstBlock(block, "scaling_config");
+    const attrs = {};
+    const instanceTypes = block["instance_types"];
+    if (Array.isArray(instanceTypes) && instanceTypes.length > 0) {
+      attrs.instance_type = str(instanceTypes[0]);
+    }
+    if (scaling["desired_size"] !== void 0) attrs.node_count = num(scaling["desired_size"]);
+    if (scaling["min_size"] !== void 0) attrs.min_node_count = num(scaling["min_size"]);
+    if (scaling["max_size"] !== void 0) attrs.max_node_count = num(scaling["max_size"]);
+    return attrs;
+  },
+  aws_elasticache_cluster(block) {
+    const attrs = {};
+    if (str(block["node_type"])) attrs.instance_type = str(block["node_type"]);
+    if (str(block["engine"])) attrs.engine = str(block["engine"]);
+    if (block["num_cache_nodes"] !== void 0) attrs.node_count = num(block["num_cache_nodes"]);
+    return attrs;
+  },
+  aws_elasticache_replication_group(block) {
+    const attrs = {};
+    if (str(block["node_type"])) attrs.instance_type = str(block["node_type"]);
+    if (block["num_cache_clusters"] !== void 0) attrs.node_count = num(block["num_cache_clusters"]);
+    return attrs;
+  },
+  aws_ebs_volume(block) {
+    const attrs = {};
+    if (str(block["type"])) attrs.storage_type = str(block["type"]);
+    if (block["size"] !== void 0) attrs.storage_size_gb = num(block["size"]);
+    if (block["iops"] !== void 0) attrs.iops = num(block["iops"]);
+    if (block["throughput"] !== void 0) attrs.throughput_mbps = num(block["throughput"]);
+    return attrs;
+  },
+  aws_lambda_function(block) {
+    const attrs = {};
+    if (block["memory_size"] !== void 0) attrs.memory_size = num(block["memory_size"]);
+    if (block["timeout"] !== void 0) attrs.timeout = num(block["timeout"]);
+    if (str(block["architecture"])) {
+      attrs.architecture = str(block["architecture"]);
+    } else {
+      const arch = block["architectures"];
+      if (Array.isArray(arch) && arch.length > 0) {
+        attrs.architecture = str(arch[0]);
+      }
+    }
+    if (str(block["runtime"])) attrs.runtime = str(block["runtime"]);
+    return attrs;
+  },
+  aws_dynamodb_table(block) {
+    const attrs = {};
+    if (str(block["billing_mode"])) attrs.billing_mode = str(block["billing_mode"]);
+    if (block["read_capacity"] !== void 0) attrs.read_capacity = num(block["read_capacity"]);
+    if (block["write_capacity"] !== void 0) attrs.write_capacity = num(block["write_capacity"]);
+    return attrs;
+  },
+  aws_efs_file_system(block) {
+    const attrs = {};
+    if (str(block["performance_mode"])) attrs.performance_mode = str(block["performance_mode"]);
+    if (str(block["throughput_mode"])) attrs.throughput_mode = str(block["throughput_mode"]);
+    return attrs;
+  },
+  aws_cloudfront_distribution(block) {
+    const attrs = {};
+    if (str(block["price_class"])) attrs.price_class = str(block["price_class"]);
+    return attrs;
+  },
+  aws_sqs_queue(block) {
+    const attrs = {};
+    if (block["fifo_queue"] !== void 0) attrs.fifo_queue = bool(block["fifo_queue"]);
+    return attrs;
+  },
+  // ---------------------------------------------------------------------------
+  // Azure
+  // ---------------------------------------------------------------------------
+  azurerm_virtual_machine(block) {
+    const attrs = {};
+    if (str(block["vm_size"])) attrs.vm_size = str(block["vm_size"]);
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    return attrs;
+  },
+  azurerm_linux_virtual_machine(block) {
+    const attrs = {};
+    if (str(block["size"])) attrs.vm_size = str(block["size"]);
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    return attrs;
+  },
+  azurerm_windows_virtual_machine(block) {
+    const attrs = {};
+    if (str(block["size"])) attrs.vm_size = str(block["size"]);
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    attrs.os = "Windows";
+    return attrs;
+  },
+  azurerm_managed_disk(block) {
+    const attrs = {};
+    if (str(block["storage_account_type"])) attrs.storage_type = str(block["storage_account_type"]);
+    if (block["disk_size_gb"] !== void 0) attrs.storage_size_gb = num(block["disk_size_gb"]);
+    if (block["disk_iops_read_write"] !== void 0) attrs.iops = num(block["disk_iops_read_write"]);
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    return attrs;
+  },
+  azurerm_sql_server(block) {
+    const attrs = {};
+    if (str(block["version"])) attrs.engine_version = str(block["version"]);
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    return attrs;
+  },
+  azurerm_mssql_database(block) {
+    const attrs = {};
+    if (str(block["sku_name"])) attrs.sku = str(block["sku_name"]);
+    if (block["max_size_gb"] !== void 0) attrs.storage_size_gb = num(block["max_size_gb"]);
+    return attrs;
+  },
+  azurerm_kubernetes_cluster(block) {
+    const defaultPool = firstBlock(block, "default_node_pool");
+    const attrs = {};
+    if (str(defaultPool["vm_size"])) attrs.vm_size = str(defaultPool["vm_size"]);
+    if (defaultPool["node_count"] !== void 0) attrs.node_count = num(defaultPool["node_count"]);
+    if (defaultPool["min_count"] !== void 0) attrs.min_node_count = num(defaultPool["min_count"]);
+    if (defaultPool["max_count"] !== void 0) attrs.max_node_count = num(defaultPool["max_count"]);
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    return attrs;
+  },
+  azurerm_cosmosdb_account(block) {
+    const attrs = {};
+    if (str(block["offer_type"])) attrs.offer_type = str(block["offer_type"]);
+    if (str(block["kind"])) attrs.kind = str(block["kind"]);
+    const capabilities = block["capabilities"];
+    if (Array.isArray(capabilities)) {
+      const capNames = capabilities.map((c) => typeof c === "object" && c !== null ? str(c["name"]) : void 0).filter((n) => n !== void 0);
+      if (capNames.length > 0) attrs.capabilities = capNames;
+    }
+    return attrs;
+  },
+  azurerm_app_service_plan(block) {
+    const attrs = {};
+    const skuBlock = firstBlock(block, "sku");
+    if (str(skuBlock["tier"])) attrs.sku_tier = str(skuBlock["tier"]);
+    if (str(skuBlock["size"])) attrs.sku_size = str(skuBlock["size"]);
+    if (str(block["sku_name"])) attrs.sku = str(block["sku_name"]);
+    return attrs;
+  },
+  azurerm_function_app(block) {
+    const attrs = {};
+    if (str(block["app_service_plan_id"])) attrs.app_service_plan_id = str(block["app_service_plan_id"]);
+    return attrs;
+  },
+  azurerm_redis_cache(block) {
+    const attrs = {};
+    if (block["capacity"] !== void 0) attrs.capacity = num(block["capacity"]);
+    if (str(block["family"])) attrs.family = str(block["family"]);
+    if (str(block["sku_name"])) attrs.sku = str(block["sku_name"]);
+    return attrs;
+  },
+  azurerm_cosmosdb_sql_database(block) {
+    const attrs = {};
+    if (block["throughput"] !== void 0) attrs.throughput = num(block["throughput"]);
+    return attrs;
+  },
+  azurerm_storage_account(block) {
+    const attrs = {};
+    if (str(block["account_tier"])) attrs.account_tier = str(block["account_tier"]);
+    if (str(block["account_replication_type"])) attrs.account_replication_type = str(block["account_replication_type"]);
+    return attrs;
+  },
+  // ---------------------------------------------------------------------------
+  // GCP
+  // ---------------------------------------------------------------------------
+  google_compute_instance(block) {
+    const attrs = {};
+    if (str(block["machine_type"])) attrs.machine_type = str(block["machine_type"]);
+    if (str(block["zone"])) attrs.zone = str(block["zone"]);
+    const boot = firstBlock(block, "boot_disk");
+    const initParams = firstBlock(boot, "initialize_params");
+    if (str(initParams["type"])) attrs.storage_type = str(initParams["type"]);
+    if (initParams["size"] !== void 0) attrs.storage_size_gb = num(initParams["size"]);
+    return attrs;
+  },
+  google_compute_disk(block) {
+    const attrs = {};
+    if (str(block["type"])) attrs.storage_type = str(block["type"]);
+    if (block["size"] !== void 0) attrs.storage_size_gb = num(block["size"]);
+    if (str(block["zone"])) attrs.zone = str(block["zone"]);
+    return attrs;
+  },
+  google_sql_database_instance(block) {
+    const settings = firstBlock(block, "settings");
+    const attrs = {};
+    if (str(settings["tier"])) attrs.tier = str(settings["tier"]);
+    if (str(block["database_version"])) attrs.engine = str(block["database_version"]);
+    if (str(block["region"])) attrs.region_attr = str(block["region"]);
+    const dataCacheConfig = firstBlock(settings, "data_cache_config");
+    if (dataCacheConfig["data_cache_enabled"] !== void 0) {
+      attrs.data_cache_enabled = bool(dataCacheConfig["data_cache_enabled"]);
+    }
+    return attrs;
+  },
+  google_container_cluster(block) {
+    const nodeConfig = firstBlock(block, "node_config");
+    const attrs = {};
+    if (str(nodeConfig["machine_type"])) attrs.machine_type = str(nodeConfig["machine_type"]);
+    if (block["initial_node_count"] !== void 0) attrs.node_count = num(block["initial_node_count"]);
+    if (str(block["location"])) attrs.zone = str(block["location"]);
+    return attrs;
+  },
+  google_container_node_pool(block) {
+    const nodeConfig = firstBlock(block, "node_config");
+    const autoscaling = firstBlock(block, "autoscaling");
+    const attrs = {};
+    if (str(nodeConfig["machine_type"])) attrs.machine_type = str(nodeConfig["machine_type"]);
+    if (block["node_count"] !== void 0) attrs.node_count = num(block["node_count"]);
+    if (autoscaling["min_node_count"] !== void 0) attrs.min_node_count = num(autoscaling["min_node_count"]);
+    if (autoscaling["max_node_count"] !== void 0) attrs.max_node_count = num(autoscaling["max_node_count"]);
+    return attrs;
+  },
+  google_cloud_run_service(block) {
+    const attrs = {};
+    const template = firstBlock(block, "template");
+    const spec = firstBlock(template, "spec");
+    const container = firstBlock(spec, "containers");
+    const resources = firstBlock(container, "resources");
+    const limits = firstBlock(resources, "limits");
+    if (str(limits["cpu"])) attrs.cpu = str(limits["cpu"]);
+    if (str(limits["memory"])) attrs.memory = str(limits["memory"]);
+    return attrs;
+  },
+  google_cloudfunctions_function(block) {
+    const attrs = {};
+    if (str(block["runtime"])) attrs.runtime = str(block["runtime"]);
+    if (block["available_memory_mb"] !== void 0) attrs.memory_size = num(block["available_memory_mb"]);
+    return attrs;
+  },
+  google_bigquery_dataset(block) {
+    const attrs = {};
+    if (str(block["location"])) attrs.location = str(block["location"]);
+    return attrs;
+  },
+  google_redis_instance(block) {
+    const attrs = {};
+    if (str(block["tier"])) attrs.tier = str(block["tier"]);
+    if (block["memory_size_gb"] !== void 0) attrs.memory_size = num(block["memory_size_gb"]);
+    return attrs;
+  },
+  google_artifact_registry_repository(block) {
+    const attrs = {};
+    if (str(block["format"])) attrs.format = str(block["format"]);
+    return attrs;
+  }
+};
+function regionFromResourceBlock(resourceType, block, provider) {
+  switch (provider) {
+    case "azure": {
+      const loc = str(block["location"]);
+      return loc && !loc.startsWith("${") ? loc : void 0;
+    }
+    case "gcp": {
+      const zone = str(block["zone"]);
+      if (zone && !zone.startsWith("${")) {
+        const parts = zone.split("-");
+        return parts.length > 2 ? parts.slice(0, -1).join("-") : zone;
+      }
+      return str(block["region"]);
+    }
+    case "aws": {
+      const az = str(block["availability_zone"]);
+      if (az && !az.startsWith("${")) {
+        const parts = az.split("-");
+        return parts.length > 2 ? parts.slice(0, -1).join("-") : az;
+      }
+      return void 0;
+    }
+  }
+}
+function extractTags(block) {
+  const tags = block["tags"];
+  if (!tags || typeof tags !== "object" || Array.isArray(tags)) return {};
+  const result = {};
+  for (const [k, v] of Object.entries(tags)) {
+    if (typeof v === "string") result[k] = v;
+    else if (v !== null && v !== void 0) result[k] = String(v);
+  }
+  return result;
+}
+function resolveCount(rawCount, resourceId, warnings) {
+  const n = num(rawCount);
+  if (n !== void 0 && Number.isInteger(n) && n >= 0) return n;
+  warnings.push(
+    `Resource "${resourceId}" has a count that could not be resolved to a number. Defaulting to 1.`
+  );
+  return 1;
+}
+function resolveForEachKeys(rawForEach, resourceId, warnings) {
+  if (rawForEach && typeof rawForEach === "object" && !Array.isArray(rawForEach)) {
+    const keys = Object.keys(rawForEach);
+    if (keys.length > 0) return keys;
+  }
+  if (Array.isArray(rawForEach) && rawForEach.length > 0) {
+    return rawForEach.map(
+      (v, i) => typeof v === "string" ? v : typeof v === "number" ? String(v) : String(i)
+    );
+  }
+  warnings.push(
+    `Resource "${resourceId}" has a for_each that could not be resolved. Defaulting to 1 instance.`
+  );
+  return ["0"];
+}
+function extractResources(hclJson, variables, sourceFile, defaultRegions = {}, warnings = []) {
+  const resources = [];
+  const moduleBlock = hclJson["module"];
+  if (moduleBlock && typeof moduleBlock === "object" && !Array.isArray(moduleBlock)) {
+    for (const moduleName of Object.keys(moduleBlock)) {
+      warnings.push(
+        `Module "${moduleName}" detected but not expanded. Resources inside modules are not included in the estimate.`
+      );
+      logger.debug("Module detected, skipping expansion", { moduleName });
+    }
+  }
+  const resourceBlock = hclJson["resource"];
+  if (!resourceBlock || typeof resourceBlock !== "object") {
+    return resources;
+  }
+  for (const [resourceType, instances] of Object.entries(
+    resourceBlock
+  )) {
+    let provider;
+    try {
+      provider = detectProvider(resourceType);
+    } catch {
+      logger.warn("Skipping resource with unknown provider prefix", {
+        resourceType
+      });
+      continue;
+    }
+    if (!instances || typeof instances !== "object" || Array.isArray(instances)) {
+      continue;
+    }
+    for (const [resourceName, blockList] of Object.entries(
+      instances
+    )) {
+      if (!Array.isArray(blockList) || blockList.length === 0) continue;
+      const rawBlock = blockList[0];
+      const block = substituteVariables(rawBlock, variables);
+      const resourceRegion = regionFromResourceBlock(resourceType, block, provider);
+      const region = resourceRegion ?? defaultRegions[provider] ?? (provider === "aws" ? "us-east-1" : provider === "azure" ? "eastus" : "us-central1");
+      const extractor = extractors[resourceType];
+      const attributes = extractor ? extractor(block) : {};
+      const tags = extractTags(block);
+      const baseId = `${resourceType}.${resourceName}`;
+      const rawCount = block["count"];
+      const rawForEach = block["for_each"];
+      if (rawCount !== void 0) {
+        const count = resolveCount(rawCount, baseId, warnings);
+        for (let i = 0; i < count; i++) {
+          resources.push({
+            id: `${baseId}[${i}]`,
+            type: resourceType,
+            name: resourceName,
+            provider,
+            region,
+            attributes,
+            tags,
+            source_file: sourceFile
+          });
+        }
+      } else if (rawForEach !== void 0) {
+        const keys = resolveForEachKeys(rawForEach, baseId, warnings);
+        for (const key of keys) {
+          resources.push({
+            id: `${baseId}["${key}"]`,
+            type: resourceType,
+            name: resourceName,
+            provider,
+            region,
+            attributes,
+            tags,
+            source_file: sourceFile
+          });
+        }
+      } else {
+        resources.push({
+          id: baseId,
+          type: resourceType,
+          name: resourceName,
+          provider,
+          region,
+          attributes,
+          tags,
+          source_file: sourceFile
+        });
+      }
+      logger.debug("Extracted resource", {
+        id: baseId,
+        region,
+        provider
+      });
+    }
+  }
+  return resources;
+}
+
+// src/parsers/index.ts
+var PROVIDER_DEFAULTS = {
+  aws: "us-east-1",
+  azure: "eastus",
+  gcp: "us-central1"
+};
+function inferDominantProvider(resources) {
+  if (resources.length === 0) return "aws";
+  const counts = {};
+  for (const r of resources) {
+    counts[r.provider] = (counts[r.provider] ?? 0) + 1;
+  }
+  let dominant = "aws";
+  let max = 0;
+  for (const [p, c] of Object.entries(counts)) {
+    if (c > max) {
+      max = c;
+      dominant = p;
+    }
+  }
+  return dominant;
+}
+async function parseTerraform(files, tfvarsContent) {
+  const warnings = [];
+  const parsedJsons = [];
+  for (const file of files) {
+    try {
+      const json = await parseHclToJson(file.content, file.path);
+      parsedJsons.push({ path: file.path, json });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`Parse error in ${file.path}: ${msg}`);
+      logger.warn("Skipping file due to parse error", {
+        path: file.path,
+        error: msg
+      });
+    }
+  }
+  if (parsedJsons.length === 0) {
+    logger.warn("No files were successfully parsed");
+    return {
+      provider: "aws",
+      region: PROVIDER_DEFAULTS["aws"],
+      resources: [],
+      total_count: 0,
+      by_type: {},
+      parse_warnings: warnings
+    };
+  }
+  const combined = mergeHclJsons(parsedJsons.map((p) => p.json));
+  const variables = resolveVariables(combined, tfvarsContent);
+  const providers = ["aws", "azure", "gcp"];
+  const defaultRegions = {};
+  for (const p of providers) {
+    defaultRegions[p] = detectRegionFromProviders(combined, p, variables);
+  }
+  const allResources = [];
+  for (const { path, json } of parsedJsons) {
+    try {
+      const resources = extractResources(json, variables, path, defaultRegions, warnings);
+      allResources.push(...resources);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push(`Extraction error in ${path}: ${msg}`);
+      logger.warn("Resource extraction failed", { path, error: msg });
+    }
+  }
+  const dominantProvider = inferDominantProvider(allResources);
+  const dominantRegion = defaultRegions[dominantProvider] ?? PROVIDER_DEFAULTS[dominantProvider];
+  const byType = {};
+  for (const r of allResources) {
+    byType[r.type] = (byType[r.type] ?? 0) + 1;
+  }
+  const inventory = {
+    provider: dominantProvider,
+    region: dominantRegion,
+    resources: allResources,
+    total_count: allResources.length,
+    by_type: byType,
+    parse_warnings: warnings
+  };
+  logger.info("Terraform parse complete", {
+    fileCount: files.length,
+    resourceCount: allResources.length,
+    provider: dominantProvider,
+    region: dominantRegion,
+    warningCount: warnings.length
+  });
+  return inventory;
+}
+function mergeHclJsons(jsons) {
+  const merged = {};
+  for (const json of jsons) {
+    for (const [key, value] of Object.entries(json)) {
+      if (!(key in merged)) {
+        merged[key] = deepClone(value);
+        continue;
+      }
+      const existing = merged[key];
+      if (value !== null && typeof value === "object" && !Array.isArray(value) && existing !== null && typeof existing === "object" && !Array.isArray(existing)) {
+        merged[key] = mergeObjects(
+          existing,
+          value
+        );
+      } else if (Array.isArray(existing) && Array.isArray(value)) {
+        merged[key] = [...existing, ...value];
+      } else {
+        merged[key] = deepClone(value);
+      }
+    }
+  }
+  return merged;
+}
+function mergeObjects(a, b) {
+  const result = { ...a };
+  for (const [key, bVal] of Object.entries(b)) {
+    const aVal = result[key];
+    if (aVal !== null && typeof aVal === "object" && !Array.isArray(aVal) && bVal !== null && typeof bVal === "object" && !Array.isArray(bVal)) {
+      result[key] = mergeObjects(
+        aVal,
+        bVal
+      );
+    } else if (Array.isArray(aVal) && Array.isArray(bVal)) {
+      result[key] = [...aVal, ...bVal];
+    } else {
+      result[key] = deepClone(bVal);
+    }
+  }
+  return result;
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  return JSON.parse(JSON.stringify(value));
+}
+
+// src/tools/analyze-terraform.ts
+var analyzeTerraformSchema = z.object({
+  files: z.array(
+    z.object({
+      path: z.string().describe("File path"),
+      content: z.string().describe("File content (HCL)")
+    })
+  ).describe("Terraform files to analyze"),
+  tfvars: z.string().optional().describe("Contents of terraform.tfvars file")
+});
+async function analyzeTerraform(params) {
+  const inventory = await parseTerraform(params.files, params.tfvars);
+  const { parse_warnings, ...rest } = inventory;
+  return {
+    parse_warnings,
+    has_warnings: parse_warnings.length > 0,
+    ...rest
+  };
+}
+
+// src/tools/estimate-cost.ts
+import { z as z2 } from "zod";
+
+// src/mapping/region-mapper.ts
+var DEFAULT_REGIONS = {
+  aws: "us-east-1",
+  azure: "eastus",
+  gcp: "us-central1"
+};
+function mapRegion(region, sourceProvider, targetProvider) {
+  if (sourceProvider === targetProvider) return region;
+  const mappings = getRegionMappings();
+  const row = mappings.find(
+    (entry) => entry[sourceProvider] === region
+  );
+  if (!row) {
+    const fallback = DEFAULT_REGIONS[targetProvider];
+    logger.debug("region-mapper: no mapping found, using default", {
+      region,
+      sourceProvider,
+      targetProvider,
+      fallback
+    });
+    return fallback;
+  }
+  const mapped = row[targetProvider];
+  if (!mapped) {
+    return DEFAULT_REGIONS[targetProvider];
+  }
+  return mapped;
+}
+
+// src/mapping/instance-mapper.ts
+function directionKey(source, target) {
+  if (source === target) return null;
+  return `${source}_to_${target}`;
+}
+function getSpecsForProvider(provider) {
+  switch (provider) {
+    case "aws":
+      return getAwsInstances();
+    case "azure":
+      return getAzureVmSizes();
+    case "gcp":
+      return getGcpMachineTypes();
+  }
+}
+var SCORE_EXACT_VCPU = 40;
+var SCORE_APPROX_VCPU = 20;
+var SCORE_EXACT_MEMORY = 40;
+var SCORE_APPROX_MEMORY = 20;
+var SCORE_CATEGORY = 20;
+function mapInstance(instanceType, sourceProvider, targetProvider) {
+  if (sourceProvider === targetProvider) return instanceType;
+  const key = directionKey(sourceProvider, targetProvider);
+  if (!key) return instanceType;
+  const instanceMap = getInstanceMap();
+  const directionalMap = instanceMap[key];
+  if (directionalMap) {
+    const exact = directionalMap[instanceType];
+    if (exact) {
+      logger.debug("instance-mapper: exact match", {
+        instanceType,
+        sourceProvider,
+        targetProvider,
+        result: exact
+      });
+      return exact;
+    }
+  }
+  const sourceSpecs = getSpecsForProvider(sourceProvider);
+  const sourceSpec = sourceSpecs.find(
+    (s) => s.instance_type === instanceType
+  );
+  if (!sourceSpec) {
+    logger.debug("instance-mapper: source spec not found, cannot map", {
+      instanceType,
+      sourceProvider
+    });
+    return null;
+  }
+  return findNearestInstance(
+    {
+      vcpus: sourceSpec.vcpus,
+      memory_gb: sourceSpec.memory_gb,
+      category: sourceSpec.category
+    },
+    targetProvider
+  );
+}
+function findNearestInstance(spec, targetProvider) {
+  const candidates = getSpecsForProvider(targetProvider);
+  if (candidates.length === 0) return null;
+  let bestScore = -1;
+  let bestType = null;
+  for (const candidate of candidates) {
+    let score = 0;
+    if (candidate.vcpus === spec.vcpus) {
+      score += SCORE_EXACT_VCPU;
+    } else {
+      const larger = Math.max(candidate.vcpus, spec.vcpus);
+      const smaller = Math.min(candidate.vcpus, spec.vcpus);
+      if (smaller > 0) {
+        score += SCORE_APPROX_VCPU * (smaller / larger);
+      }
+    }
+    if (candidate.memory_gb === spec.memory_gb) {
+      score += SCORE_EXACT_MEMORY;
+    } else {
+      const larger = Math.max(candidate.memory_gb, spec.memory_gb);
+      const smaller = Math.min(candidate.memory_gb, spec.memory_gb);
+      if (smaller > 0) {
+        score += SCORE_APPROX_MEMORY * (smaller / larger);
+      }
+    }
+    if (candidate.category === spec.category) {
+      score += SCORE_CATEGORY;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestType = candidate.instance_type;
+    }
+  }
+  if (bestType) {
+    logger.debug("instance-mapper: nearest match found", {
+      spec,
+      targetProvider,
+      result: bestType,
+      score: bestScore
+    });
+  }
+  return bestType;
+}
+
+// src/mapping/storage-mapper.ts
+function mapStorageType(storageType, sourceProvider, targetProvider) {
+  if (sourceProvider === targetProvider) return storageType;
+  const { block_storage, object_storage } = getStorageMap();
+  const allEntries = [...block_storage, ...object_storage];
+  const row = allEntries.find(
+    (entry) => entry[sourceProvider] === storageType
+  );
+  if (!row) {
+    logger.debug("storage-mapper: no mapping found", {
+      storageType,
+      sourceProvider,
+      targetProvider
+    });
+    return null;
+  }
+  const mapped = row[targetProvider];
+  if (!mapped) {
+    logger.debug("storage-mapper: target column missing in row", {
+      storageType,
+      sourceProvider,
+      targetProvider
+    });
+    return null;
+  }
+  return mapped;
+}
+
+// src/calculator/compute.ts
+async function calculateComputeCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
+  const notes = [];
+  const breakdown = [];
+  const sourceInstanceType = resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.machine_type ?? "";
+  const mappedInstance = sourceInstanceType ? mapInstance(sourceInstanceType, resource.provider, targetProvider) : null;
+  let confidence = "low";
+  let specBasedMapping = false;
+  if (!mappedInstance) {
+    notes.push(
+      `No instance mapping found for ${sourceInstanceType} (${resource.provider} -> ${targetProvider})`
+    );
+  } else {
+    const { getInstanceMap: getInstanceMap2 } = await import("./loader-WIX54B7L.js");
+    const im = getInstanceMap2();
+    const dirKey = `${resource.provider}_to_${targetProvider}`;
+    const directMap = im[dirKey];
+    const isExact = directMap?.[sourceInstanceType] === mappedInstance;
+    confidence = isExact ? "high" : "medium";
+    if (!isExact) {
+      specBasedMapping = true;
+      notes.push(
+        `Instance mapping for ${sourceInstanceType} -> ${mappedInstance} is an approximate spec-based match`
+      );
+    }
+  }
+  const effectiveInstance = mappedInstance ?? sourceInstanceType;
+  const computePrice = effectiveInstance ? await pricingEngine.getProvider(targetProvider).getComputePrice(effectiveInstance, targetRegion, resource.attributes.os) : null;
+  let computeMonthlyCost = 0;
+  let pricingSource = "fallback";
+  if (computePrice) {
+    const rawSource = computePrice.attributes?.pricing_source;
+    if (rawSource === "bundled") {
+      pricingSource = "bundled";
+    } else if (rawSource === "fallback") {
+      pricingSource = "fallback";
+      notes.push(`Pricing for ${effectiveInstance} uses bundled fallback data (live API unavailable)`);
+    } else {
+      pricingSource = "live";
+    }
+    if (specBasedMapping) {
+      notes.push(`Spec-based instance mapping used: ${sourceInstanceType} -> ${mappedInstance}`);
+    }
+    const hourlyPrice = computePrice.price_per_unit;
+    computeMonthlyCost = hourlyPrice * monthlyHours;
+    breakdown.push({
+      description: `${effectiveInstance} compute (${monthlyHours}h/month)`,
+      unit: "Hrs",
+      quantity: monthlyHours,
+      unit_price: hourlyPrice,
+      monthly_cost: computeMonthlyCost
+    });
+  } else {
+    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
+    confidence = "low";
+    pricingSource = "fallback";
+  }
+  let storageMonthlyCost = 0;
+  const rootDisk = resource.attributes.root_block_device;
+  const storageType = rootDisk?.volume_type ?? resource.attributes.storage_type;
+  const storageSizeGb = rootDisk?.volume_size ?? resource.attributes.storage_size_gb;
+  if (storageType && storageSizeGb && storageSizeGb > 0) {
+    const mappedStorageType = mapStorageType(
+      storageType,
+      resource.provider,
+      targetProvider
+    ) ?? storageType;
+    const storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(mappedStorageType, targetRegion, storageSizeGb);
+    if (storagePrice) {
+      storageMonthlyCost = storagePrice.price_per_unit * storageSizeGb;
+      breakdown.push({
+        description: `Root disk ${mappedStorageType} (${storageSizeGb} GB)`,
+        unit: "GB-Mo",
+        quantity: storageSizeGb,
+        unit_price: storagePrice.price_per_unit,
+        monthly_cost: storageMonthlyCost
+      });
+    } else {
+      logger.debug("calculateComputeCost: no storage price found", {
+        mappedStorageType,
+        targetRegion
+      });
+    }
+  }
+  const totalMonthly = computeMonthlyCost + storageMonthlyCost;
+  return {
+    resource_id: resource.id,
+    resource_type: resource.type,
+    resource_name: resource.name,
+    provider: targetProvider,
+    region: targetRegion,
+    monthly_cost: totalMonthly,
+    yearly_cost: totalMonthly * 12,
+    currency: "USD",
+    breakdown,
+    confidence,
+    notes,
+    pricing_source: pricingSource
+  };
+}
+
+// src/calculator/database.ts
+function normalizeDbInstanceClass(instanceClass) {
+  return instanceClass.startsWith("db.") ? instanceClass.slice(3) : instanceClass;
+}
+async function calculateDatabaseCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
+  const notes = [];
+  const breakdown = [];
+  const sourceInstanceClass = resource.attributes.instance_class ?? resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.tier ?? "";
+  const isMultiAz = Boolean(resource.attributes.multi_az);
+  const allocatedStorageGb = resource.attributes.allocated_storage ?? resource.attributes.storage_size_gb ?? 0;
+  const engine = resource.attributes.engine ?? "MySQL";
+  const normalised = normalizeDbInstanceClass(sourceInstanceClass);
+  let mappedInstance = null;
+  if (targetProvider === "gcp") {
+    mappedInstance = mapInstance(sourceInstanceClass, resource.provider, "gcp");
+    if (!mappedInstance) {
+      mappedInstance = mapInstance(normalised, resource.provider, "gcp");
+    }
+    if (mappedInstance && !mappedInstance.startsWith("db-")) {
+      const dbMapped = mapInstance(sourceInstanceClass, resource.provider, "gcp");
+      if (dbMapped) mappedInstance = dbMapped;
+    }
+  } else if (targetProvider === "aws") {
+    mappedInstance = mapInstance(sourceInstanceClass, resource.provider, "aws");
+    if (!mappedInstance && normalised !== sourceInstanceClass) {
+      mappedInstance = mapInstance(normalised, resource.provider, "aws");
+    }
+    if (mappedInstance && !mappedInstance.startsWith("db.")) {
+      mappedInstance = `db.${mappedInstance}`;
+    }
+  } else {
+    mappedInstance = mapInstance(sourceInstanceClass, resource.provider, targetProvider);
+    if (!mappedInstance) {
+      mappedInstance = mapInstance(normalised, resource.provider, targetProvider);
+    }
+  }
+  const effectiveInstance = mappedInstance ?? sourceInstanceClass;
+  if (!mappedInstance) {
+    notes.push(
+      `No DB instance mapping found for ${sourceInstanceClass} (${resource.provider} -> ${targetProvider}); using source class`
+    );
+  }
+  const dbPrice = await pricingEngine.getProvider(targetProvider).getDatabasePrice(effectiveInstance, targetRegion, engine);
+  let instanceMonthlyCost = 0;
+  let pricingSource = "fallback";
+  if (dbPrice) {
+    const rawSource = dbPrice.attributes?.pricing_source;
+    if (rawSource === "bundled") {
+      pricingSource = "bundled";
+    } else if (rawSource === "fallback") {
+      pricingSource = "fallback";
+      notes.push(`Pricing for ${effectiveInstance} uses bundled fallback data (live API unavailable)`);
+    } else {
+      pricingSource = "live";
+    }
+    instanceMonthlyCost = dbPrice.price_per_unit * monthlyHours;
+    let haMultiplier = 1;
+    if (isMultiAz) {
+      if (targetProvider === "gcp") {
+        const gcpMult = parseFloat(
+          dbPrice.attributes?.ha_multiplier ?? "2"
+        );
+        haMultiplier = isNaN(gcpMult) ? 2 : gcpMult;
+      } else {
+        haMultiplier = 2;
+      }
+      notes.push(`Multi-AZ enabled: instance cost multiplied by ${haMultiplier}`);
+    }
+    const adjustedCost = instanceMonthlyCost * haMultiplier;
+    breakdown.push({
+      description: `${effectiveInstance} DB instance (${monthlyHours}h/month)${isMultiAz ? " x" + haMultiplier + " (Multi-AZ)" : ""}`,
+      unit: "Hrs",
+      quantity: monthlyHours * haMultiplier,
+      unit_price: dbPrice.price_per_unit,
+      monthly_cost: adjustedCost
+    });
+    instanceMonthlyCost = adjustedCost;
+  } else {
+    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
+    logger.debug("calculateDatabaseCost: no price", {
+      effectiveInstance,
+      targetRegion
+    });
+  }
+  let storageMonthlyCost = 0;
+  if (allocatedStorageGb > 0) {
+    const storageType = resource.attributes.storage_type ?? "gp3";
+    const storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(storageType, targetRegion, allocatedStorageGb);
+    if (storagePrice) {
+      storageMonthlyCost = storagePrice.price_per_unit * allocatedStorageGb;
+      breakdown.push({
+        description: `DB storage ${storageType} (${allocatedStorageGb} GB)`,
+        unit: "GB-Mo",
+        quantity: allocatedStorageGb,
+        unit_price: storagePrice.price_per_unit,
+        monthly_cost: storageMonthlyCost
+      });
+    }
+  }
+  const totalMonthly = instanceMonthlyCost + storageMonthlyCost;
+  return {
+    resource_id: resource.id,
+    resource_type: resource.type,
+    resource_name: resource.name,
+    provider: targetProvider,
+    region: targetRegion,
+    monthly_cost: totalMonthly,
+    yearly_cost: totalMonthly * 12,
+    currency: "USD",
+    breakdown,
+    confidence: mappedInstance ? "high" : "low",
+    notes,
+    pricing_source: pricingSource
+  };
+}
+
+// src/calculator/storage.ts
+var DEFAULT_OBJECT_STORAGE_GB = 100;
+var BLOCK_STORAGE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "aws_ebs_volume",
+  "azurerm_managed_disk",
+  "google_compute_disk"
+]);
+var BLOCK_STORAGE_FALLBACK = {
+  aws: "gp3",
+  azure: "Premium_LRS",
+  gcp: "pd-ssd"
+};
+function isBlockStorage(resource) {
+  return BLOCK_STORAGE_RESOURCE_TYPES.has(resource.type);
+}
+async function calculateStorageCost(resource, targetProvider, targetRegion, pricingEngine) {
+  const notes = [];
+  const breakdown = [];
+  const block = isBlockStorage(resource);
+  const sourceStorageType = resource.attributes.storage_type ?? resource.attributes.type ?? resource.attributes.storage_class ?? (block ? "gp3" : "STANDARD");
+  const mappedStorageType = mapStorageType(sourceStorageType, resource.provider, targetProvider) ?? sourceStorageType;
+  let sizeGb = resource.attributes.storage_size_gb ?? resource.attributes.disk_size_gb ?? resource.attributes.size;
+  if (!sizeGb || sizeGb <= 0) {
+    if (block) {
+      sizeGb = 8;
+      notes.push("No storage size specified; defaulting to 8 GB for block volume");
+    } else {
+      sizeGb = DEFAULT_OBJECT_STORAGE_GB;
+      notes.push(
+        `No storage size specified; assuming ${DEFAULT_OBJECT_STORAGE_GB} GB for object storage cost estimate`
+      );
+    }
+  }
+  let resolvedStorageType = mappedStorageType;
+  let storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(resolvedStorageType, targetRegion, sizeGb);
+  if (!storagePrice && !block) {
+    const fallbackType = BLOCK_STORAGE_FALLBACK[targetProvider];
+    if (fallbackType) {
+      storagePrice = await pricingEngine.getProvider(targetProvider).getStoragePrice(fallbackType, targetRegion, sizeGb);
+      if (storagePrice) {
+        resolvedStorageType = fallbackType;
+        notes.push(
+          `Object storage class "${mappedStorageType}" not directly priced; using ${fallbackType} rate as an approximation`
+        );
+      }
+    }
+  }
+  let totalMonthly = 0;
+  let pricingSource = "fallback";
+  if (storagePrice) {
+    const rawSource = storagePrice.attributes?.pricing_source;
+    if (rawSource === "bundled") {
+      pricingSource = "bundled";
+    } else if (rawSource === "fallback") {
+      pricingSource = "fallback";
+      notes.push(`Pricing for ${resolvedStorageType} uses bundled fallback data (live API unavailable)`);
+    } else {
+      pricingSource = "live";
+    }
+    totalMonthly = storagePrice.price_per_unit * sizeGb;
+    breakdown.push({
+      description: `${block ? "Block" : "Object"} storage ${resolvedStorageType} (${sizeGb} GB)`,
+      unit: "GB-Mo",
+      quantity: sizeGb,
+      unit_price: storagePrice.price_per_unit,
+      monthly_cost: totalMonthly
+    });
+  } else {
+    notes.push(
+      `No pricing data found for ${resource.type} in ${targetRegion}`
+    );
+    logger.debug("calculateStorageCost: no price", {
+      mappedStorageType,
+      targetRegion
+    });
+  }
+  return {
+    resource_id: resource.id,
+    resource_type: resource.type,
+    resource_name: resource.name,
+    provider: targetProvider,
+    region: targetRegion,
+    monthly_cost: totalMonthly,
+    yearly_cost: totalMonthly * 12,
+    currency: "USD",
+    breakdown,
+    confidence: storagePrice ? "high" : "low",
+    notes,
+    pricing_source: pricingSource
+  };
+}
+
+// src/calculator/network.ts
+var DEFAULT_NAT_DATA_GB = 100;
+async function calculateNatGatewayCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
+  const notes = [];
+  const breakdown = [];
+  const natPrice = await pricingEngine.getProvider(targetProvider).getNatGatewayPrice(targetRegion);
+  let totalMonthly = 0;
+  let natPricingSource = "fallback";
+  if (natPrice) {
+    const rawSource = natPrice.attributes?.pricing_source;
+    if (rawSource === "bundled") {
+      natPricingSource = "bundled";
+    } else if (rawSource === "fallback") {
+      natPricingSource = "fallback";
+    } else {
+      natPricingSource = "live";
+    }
+    const hourlyCharge = natPrice.price_per_unit * monthlyHours;
+    breakdown.push({
+      description: `NAT Gateway hourly charge (${monthlyHours}h/month)`,
+      unit: "Hrs",
+      quantity: monthlyHours,
+      unit_price: natPrice.price_per_unit,
+      monthly_cost: hourlyCharge
+    });
+    totalMonthly += hourlyCharge;
+    const perGbPrice = parseFloat(
+      natPrice.attributes?.per_gb_price ?? "0"
+    );
+    if (perGbPrice > 0) {
+      const dataGb = resource.attributes.data_processed_gb ?? DEFAULT_NAT_DATA_GB;
+      if (!resource.attributes.data_processed_gb || resource.attributes.data_processed_gb <= 0) {
+        notes.push(
+          `Data processing cost estimated at ${dataGb} GB/month; provide data_processed_gb attribute for accuracy`
+        );
+      }
+      const dataCharge = perGbPrice * dataGb;
+      breakdown.push({
+        description: `NAT Gateway data processing (${dataGb} GB/month)`,
+        unit: "GB",
+        quantity: dataGb,
+        unit_price: perGbPrice,
+        monthly_cost: dataCharge
+      });
+      totalMonthly += dataCharge;
+    }
+  } else {
+    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
+  }
+  return {
+    resource_id: resource.id,
+    resource_type: resource.type,
+    resource_name: resource.name,
+    provider: targetProvider,
+    region: targetRegion,
+    monthly_cost: totalMonthly,
+    yearly_cost: totalMonthly * 12,
+    currency: "USD",
+    breakdown,
+    confidence: natPrice ? "medium" : "low",
+    notes,
+    pricing_source: natPricingSource
+  };
+}
+async function calculateLoadBalancerCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
+  const notes = [];
+  const breakdown = [];
+  const lbType = resource.attributes.load_balancer_type ?? "application";
+  const lbPrice = await pricingEngine.getProvider(targetProvider).getLoadBalancerPrice(lbType, targetRegion);
+  let totalMonthly = 0;
+  let lbPricingSource = "fallback";
+  if (lbPrice) {
+    const rawSource = lbPrice.attributes?.pricing_source;
+    if (rawSource === "bundled") {
+      lbPricingSource = "bundled";
+    } else if (rawSource === "fallback") {
+      lbPricingSource = "fallback";
+    } else {
+      lbPricingSource = "live";
+    }
+    totalMonthly = lbPrice.price_per_unit * monthlyHours;
+    breakdown.push({
+      description: `Load Balancer hourly charge (${monthlyHours}h/month)`,
+      unit: "Hrs",
+      quantity: monthlyHours,
+      unit_price: lbPrice.price_per_unit,
+      monthly_cost: totalMonthly
+    });
+    notes.push(
+      "Traffic-based charges (LCU/data processing) are excluded; this is the fixed hourly component only"
+    );
+  } else {
+    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
+  }
+  return {
+    resource_id: resource.id,
+    resource_type: resource.type,
+    resource_name: resource.name,
+    provider: targetProvider,
+    region: targetRegion,
+    monthly_cost: totalMonthly,
+    yearly_cost: totalMonthly * 12,
+    currency: "USD",
+    breakdown,
+    confidence: lbPrice ? "medium" : "low",
+    notes,
+    pricing_source: lbPricingSource
+  };
+}
+
+// src/calculator/kubernetes.ts
+async function calculateKubernetesCost(resource, targetProvider, targetRegion, pricingEngine, monthlyHours = 730) {
+  const notes = [];
+  const breakdown = [];
+  const k8sPrice = await pricingEngine.getProvider(targetProvider).getKubernetesPrice(targetRegion);
+  let totalMonthly = 0;
+  let pricingSource = "fallback";
+  if (k8sPrice) {
+    const rawSource = k8sPrice.attributes?.pricing_source;
+    if (rawSource === "bundled") {
+      pricingSource = "bundled";
+    } else if (rawSource === "fallback") {
+      pricingSource = "fallback";
+    } else {
+      pricingSource = "live";
+    }
+    const controlPlaneCost = k8sPrice.price_per_unit * monthlyHours;
+    breakdown.push({
+      description: `Kubernetes control plane (${monthlyHours}h/month)`,
+      unit: "Hrs",
+      quantity: monthlyHours,
+      unit_price: k8sPrice.price_per_unit,
+      monthly_cost: controlPlaneCost
+    });
+    totalMonthly += controlPlaneCost;
+  } else {
+    notes.push(`No pricing data found for ${resource.type} in ${targetRegion}`);
+  }
+  const nodeCount = resource.attributes.node_count ?? resource.attributes.min_node_count;
+  if (nodeCount && nodeCount > 0) {
+    const nodeInstanceType = resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.machine_type;
+    if (nodeInstanceType) {
+      const nodeResource = {
+        ...resource,
+        id: `${resource.id}/node`,
+        type: "compute_node",
+        name: `${resource.name}-node`,
+        attributes: {
+          instance_type: nodeInstanceType,
+          vm_size: nodeInstanceType,
+          machine_type: nodeInstanceType
+        }
+      };
+      const nodeCostEstimate = await calculateComputeCost(
+        nodeResource,
+        targetProvider,
+        targetRegion,
+        pricingEngine,
+        monthlyHours
+      );
+      if (nodeCostEstimate.monthly_cost > 0) {
+        const nodeGroupCost = nodeCostEstimate.monthly_cost * nodeCount;
+        breakdown.push({
+          description: `${nodeCount}x node (${nodeInstanceType}) compute`,
+          unit: "nodes",
+          quantity: nodeCount,
+          unit_price: nodeCostEstimate.monthly_cost,
+          monthly_cost: nodeGroupCost
+        });
+        totalMonthly += nodeGroupCost;
+        notes.push(
+          `Node cost estimated for ${nodeCount} nodes of type ${nodeInstanceType}`
+        );
+      }
+    } else {
+      notes.push(
+        `node_count=${nodeCount} specified but no instance_type found; node compute cost excluded`
+      );
+    }
+  }
+  return {
+    resource_id: resource.id,
+    resource_type: resource.type,
+    resource_name: resource.name,
+    provider: targetProvider,
+    region: targetRegion,
+    monthly_cost: totalMonthly,
+    yearly_cost: totalMonthly * 12,
+    currency: "USD",
+    breakdown,
+    confidence: k8sPrice ? "medium" : "low",
+    notes,
+    pricing_source: pricingSource
+  };
+}
+
+// src/calculator/cost-engine.ts
+var COMPUTE_TYPES = /* @__PURE__ */ new Set([
+  "aws_instance",
+  "azurerm_linux_virtual_machine",
+  "azurerm_windows_virtual_machine",
+  "google_compute_instance",
+  // Node groups – cost their compute like VMs.
+  "aws_eks_node_group",
+  "azurerm_kubernetes_cluster_node_pool",
+  "google_container_node_pool",
+  "compute_node"
+]);
+var DATABASE_TYPES = /* @__PURE__ */ new Set([
+  "aws_db_instance",
+  "azurerm_postgresql_flexible_server",
+  "azurerm_mysql_flexible_server",
+  "azurerm_mssql_server",
+  "google_sql_database_instance"
+]);
+var BLOCK_STORAGE_TYPES = /* @__PURE__ */ new Set([
+  "aws_ebs_volume",
+  "azurerm_managed_disk",
+  "google_compute_disk"
+]);
+var OBJECT_STORAGE_TYPES = /* @__PURE__ */ new Set([
+  "aws_s3_bucket",
+  "azurerm_storage_account",
+  "google_storage_bucket"
+]);
+var NAT_GATEWAY_TYPES = /* @__PURE__ */ new Set([
+  "aws_nat_gateway",
+  "azurerm_nat_gateway",
+  "google_compute_router_nat"
+]);
+var LOAD_BALANCER_TYPES = /* @__PURE__ */ new Set([
+  "aws_lb",
+  "aws_alb",
+  "azurerm_lb",
+  "azurerm_application_gateway",
+  "google_compute_forwarding_rule"
+]);
+var KUBERNETES_TYPES = /* @__PURE__ */ new Set([
+  "aws_eks_cluster",
+  "azurerm_kubernetes_cluster",
+  "google_container_cluster"
+]);
+function serviceLabel(resourceType) {
+  if (COMPUTE_TYPES.has(resourceType)) return "compute";
+  if (DATABASE_TYPES.has(resourceType)) return "database";
+  if (BLOCK_STORAGE_TYPES.has(resourceType)) return "block_storage";
+  if (OBJECT_STORAGE_TYPES.has(resourceType)) return "object_storage";
+  if (NAT_GATEWAY_TYPES.has(resourceType)) return "network";
+  if (LOAD_BALANCER_TYPES.has(resourceType)) return "network";
+  if (KUBERNETES_TYPES.has(resourceType)) return "kubernetes";
+  return "other";
+}
+var CostEngine = class {
+  pricingEngine;
+  monthlyHours;
+  constructor(pricingEngine, config) {
+    this.pricingEngine = pricingEngine;
+    this.monthlyHours = config.pricing.monthly_hours;
+  }
+  /**
+   * Calculates the cost of a single resource on a target provider.
+   */
+  async calculateCost(resource, targetProvider, targetRegion) {
+    const type = resource.type;
+    logger.debug("CostEngine.calculateCost", {
+      resourceId: resource.id,
+      type,
+      targetProvider,
+      targetRegion
+    });
+    if (COMPUTE_TYPES.has(type)) {
+      return calculateComputeCost(
+        resource,
+        targetProvider,
+        targetRegion,
+        this.pricingEngine,
+        this.monthlyHours
+      );
+    }
+    if (DATABASE_TYPES.has(type)) {
+      return calculateDatabaseCost(
+        resource,
+        targetProvider,
+        targetRegion,
+        this.pricingEngine,
+        this.monthlyHours
+      );
+    }
+    if (BLOCK_STORAGE_TYPES.has(type) || OBJECT_STORAGE_TYPES.has(type)) {
+      return calculateStorageCost(
+        resource,
+        targetProvider,
+        targetRegion,
+        this.pricingEngine
+      );
+    }
+    if (NAT_GATEWAY_TYPES.has(type)) {
+      return calculateNatGatewayCost(
+        resource,
+        targetProvider,
+        targetRegion,
+        this.pricingEngine,
+        this.monthlyHours
+      );
+    }
+    if (LOAD_BALANCER_TYPES.has(type)) {
+      return calculateLoadBalancerCost(
+        resource,
+        targetProvider,
+        targetRegion,
+        this.pricingEngine,
+        this.monthlyHours
+      );
+    }
+    if (KUBERNETES_TYPES.has(type)) {
+      return calculateKubernetesCost(
+        resource,
+        targetProvider,
+        targetRegion,
+        this.pricingEngine,
+        this.monthlyHours
+      );
+    }
+    logger.warn("CostEngine: unsupported resource type", { type, targetProvider });
+    return {
+      resource_id: resource.id,
+      resource_type: type,
+      resource_name: resource.name,
+      provider: targetProvider,
+      region: targetRegion,
+      monthly_cost: 0,
+      yearly_cost: 0,
+      currency: "USD",
+      breakdown: [],
+      confidence: "low",
+      notes: [`Resource type "${type}" is not yet supported by the cost engine`],
+      pricing_source: "fallback"
+    };
+  }
+  /**
+   * Calculates costs for all resources and aggregates them into a CostBreakdown.
+   *
+   * Resources that fail to produce a cost estimate are logged and skipped rather
+   * than letting a single failure abort the entire calculation.
+   */
+  async calculateBreakdown(resources, targetProvider, targetRegion) {
+    const estimates = [];
+    const byService = {};
+    const warnings = [];
+    for (const resource of resources) {
+      try {
+        const estimate = await this.calculateCost(
+          resource,
+          targetProvider,
+          targetRegion
+        );
+        estimates.push(estimate);
+        const svc = serviceLabel(resource.type);
+        byService[svc] = (byService[svc] ?? 0) + estimate.monthly_cost;
+        if (estimate.pricing_source === "fallback") {
+          warnings.push(
+            `${estimate.resource_name} (${estimate.resource_type}): using fallback/bundled pricing data`
+          );
+        }
+        if (estimate.monthly_cost === 0 && estimate.confidence === "low") {
+          warnings.push(
+            `No pricing data found for ${estimate.resource_type} in ${targetRegion} \u2014 cost reported as $0`
+          );
+        }
+      } catch (err) {
+        logger.error("CostEngine: failed to calculate cost for resource", {
+          resourceId: resource.id,
+          type: resource.type,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const totalMonthly = estimates.reduce((sum, e) => sum + e.monthly_cost, 0);
+    return {
+      provider: targetProvider,
+      region: targetRegion,
+      total_monthly: Math.round(totalMonthly * 100) / 100,
+      total_yearly: Math.round(totalMonthly * 12 * 100) / 100,
+      currency: "USD",
+      by_service: byService,
+      by_resource: estimates,
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      warnings
+    };
+  }
+};
+
+// src/tools/estimate-cost.ts
+var estimateCostSchema = z2.object({
+  files: z2.array(
+    z2.object({
+      path: z2.string().describe("File path"),
+      content: z2.string().describe("File content (HCL)")
+    })
+  ),
+  tfvars: z2.string().optional().describe("Contents of terraform.tfvars file"),
+  provider: z2.enum(["aws", "azure", "gcp"]).describe("Target cloud provider to estimate costs for"),
+  region: z2.string().optional().describe(
+    "Target region for pricing lookup. Defaults to the source region mapped to the target provider."
+  )
+});
+async function estimateCost(params, pricingEngine, config) {
+  const inventory = await parseTerraform(params.files, params.tfvars);
+  const targetProvider = params.provider;
+  const targetRegion = params.region ?? mapRegion(inventory.region, inventory.provider, targetProvider);
+  const costEngine = new CostEngine(pricingEngine, config);
+  const breakdown = await costEngine.calculateBreakdown(
+    inventory.resources,
+    targetProvider,
+    targetRegion
+  );
+  const parseWarnings = inventory.parse_warnings ?? [];
+  const allWarnings = [.../* @__PURE__ */ new Set([...parseWarnings, ...breakdown.warnings ?? []])];
+  return {
+    ...breakdown,
+    parse_warnings: parseWarnings,
+    warnings: allWarnings
+  };
+}
+
+// src/tools/compare-providers.ts
+import { z as z3 } from "zod";
+
+// src/calculator/reserved.ts
+var DISCOUNT_RATES = {
+  aws: [
+    { term: "1yr", payment: "no_upfront", rate: 0.36 },
+    { term: "1yr", payment: "partial_upfront", rate: 0.4 },
+    { term: "1yr", payment: "all_upfront", rate: 0.42 },
+    { term: "3yr", payment: "no_upfront", rate: 0.52 },
+    { term: "3yr", payment: "partial_upfront", rate: 0.57 },
+    { term: "3yr", payment: "all_upfront", rate: 0.6 }
+  ],
+  azure: [
+    { term: "1yr", payment: "all_upfront", rate: 0.35 },
+    { term: "3yr", payment: "all_upfront", rate: 0.55 },
+    // Azure does not offer no-upfront RI in the same way; partial_upfront maps
+    // to hybrid benefit combined, approximated here.
+    { term: "1yr", payment: "partial_upfront", rate: 0.3 },
+    { term: "3yr", payment: "partial_upfront", rate: 0.5 }
+  ],
+  gcp: [
+    // GCP Committed Use Discounts (CUDs) – resource-based.
+    { term: "1yr", payment: "all_upfront", rate: 0.28 },
+    { term: "3yr", payment: "all_upfront", rate: 0.55 },
+    { term: "1yr", payment: "partial_upfront", rate: 0.2 },
+    { term: "3yr", payment: "partial_upfront", rate: 0.45 }
+  ]
+};
+function calculateReservedPricing(onDemandMonthly, provider) {
+  const rates = DISCOUNT_RATES[provider];
+  const options = rates.map(({ term, payment, rate }) => {
+    const monthly_cost = onDemandMonthly * (1 - rate);
+    const monthly_savings = onDemandMonthly - monthly_cost;
+    return {
+      term,
+      payment,
+      monthly_cost: Math.round(monthly_cost * 100) / 100,
+      monthly_savings: Math.round(monthly_savings * 100) / 100,
+      percentage_savings: Math.round(rate * 1e3) / 10
+      // e.g. 36.0
+    };
+  });
+  const best_option = options.reduce(
+    (best, opt) => opt.monthly_savings > best.monthly_savings ? opt : best,
+    options[0]
+  );
+  return {
+    on_demand_monthly: Math.round(onDemandMonthly * 100) / 100,
+    options,
+    best_option
+  };
+}
+
+// src/calculator/optimizer.ts
+var LARGE_INSTANCE_SUFFIXES = [
+  ".xlarge",
+  ".2xlarge",
+  ".4xlarge",
+  ".8xlarge",
+  ".16xlarge",
+  "Standard_B4ms",
+  "Standard_B8ms",
+  "Standard_D4",
+  "Standard_D8",
+  "Standard_D16",
+  "Standard_E4",
+  "Standard_E8",
+  "n2-standard-4",
+  "n2-standard-8",
+  "n2-standard-16",
+  "e2-standard-4",
+  "e2-standard-8"
+];
+var HIGH_UTILISATION_INDICATORS = [
+  "high-cpu",
+  "high-memory",
+  "production",
+  "prod",
+  "perf",
+  "performance"
+];
+function isLikelyOversized(resource) {
+  const instanceType = resource.attributes.instance_type ?? resource.attributes.vm_size ?? resource.attributes.machine_type ?? "";
+  const isLarge = LARGE_INSTANCE_SUFFIXES.some(
+    (suffix) => instanceType.toLowerCase().includes(suffix.toLowerCase())
+  );
+  if (!isLarge) return false;
+  const tagValues = Object.values(resource.tags).map((v) => v.toLowerCase());
+  const tagKeys = Object.keys(resource.tags).map((k) => k.toLowerCase());
+  const allTagText = [...tagKeys, ...tagValues].join(" ");
+  const hasHighUtilisationSignal = HIGH_UTILISATION_INDICATORS.some(
+    (signal) => allTagText.includes(signal)
+  );
+  return !hasHighUtilisationSignal;
+}
+var COMPUTE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "aws_instance",
+  "azurerm_linux_virtual_machine",
+  "azurerm_windows_virtual_machine",
+  "google_compute_instance",
+  "aws_eks_cluster",
+  "aws_eks_node_group",
+  "azurerm_kubernetes_cluster",
+  "google_container_cluster",
+  "google_container_node_pool"
+]);
+var DATABASE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "aws_db_instance",
+  "azurerm_postgresql_flexible_server",
+  "azurerm_mysql_flexible_server",
+  "google_sql_database_instance"
+]);
+var OBJECT_STORAGE_RESOURCE_TYPES = /* @__PURE__ */ new Set([
+  "aws_s3_bucket",
+  "azurerm_storage_account",
+  "google_storage_bucket"
+]);
+function generateOptimizations(estimates, resources) {
+  const recommendations = [];
+  const resourceById = new Map(
+    resources.map((r) => [r.id, r])
+  );
+  const estimatesByResourceId = /* @__PURE__ */ new Map();
+  for (const estimate of estimates) {
+    const existing = estimatesByResourceId.get(estimate.resource_id) ?? [];
+    existing.push(estimate);
+    estimatesByResourceId.set(estimate.resource_id, existing);
+  }
+  for (const [resourceId, resourceEstimates] of estimatesByResourceId) {
+    const resource = resourceById.get(resourceId);
+    if (!resourceEstimates.length) continue;
+    const current = resourceEstimates[0];
+    if (resource && COMPUTE_RESOURCE_TYPES.has(resource.type)) {
+      if (isLikelyOversized(resource) && current.monthly_cost > 0) {
+        const estimatedSavings = current.monthly_cost * 0.3;
+        recommendations.push({
+          resource_id: resourceId,
+          resource_name: current.resource_name,
+          type: "right_size",
+          description: `${resource.attributes.instance_type ?? resource.attributes.vm_size ?? "Instance"} appears over-provisioned. Consider downsizing to the next smaller instance type.`,
+          current_monthly_cost: current.monthly_cost,
+          estimated_monthly_cost: current.monthly_cost - estimatedSavings,
+          monthly_savings: estimatedSavings,
+          percentage_savings: 30,
+          confidence: "medium",
+          provider: current.provider
+        });
+      }
+    }
+    if (resource && (COMPUTE_RESOURCE_TYPES.has(resource.type) || DATABASE_RESOURCE_TYPES.has(resource.type)) && current.monthly_cost > 0) {
+      const reserved = calculateReservedPricing(
+        current.monthly_cost,
+        current.provider
+      );
+      const best = reserved.best_option;
+      if (best.percentage_savings >= 20) {
+        recommendations.push({
+          resource_id: resourceId,
+          resource_name: current.resource_name,
+          type: "reserved",
+          description: `Switching to a ${best.term} ${best.payment.replace(/_/g, " ")} commitment could save approximately ${best.percentage_savings}% per month.`,
+          current_monthly_cost: current.monthly_cost,
+          estimated_monthly_cost: best.monthly_cost,
+          monthly_savings: best.monthly_savings,
+          percentage_savings: best.percentage_savings,
+          confidence: "high",
+          provider: current.provider
+        });
+      }
+    }
+    if (resourceEstimates.length > 1 && current.monthly_cost > 0) {
+      const cheapest = resourceEstimates.reduce(
+        (min, e) => e.monthly_cost < min.monthly_cost ? e : min,
+        current
+      );
+      if (cheapest.provider !== current.provider) {
+        const savings = current.monthly_cost - cheapest.monthly_cost;
+        const pct = savings / current.monthly_cost * 100;
+        if (pct >= 20) {
+          recommendations.push({
+            resource_id: resourceId,
+            resource_name: current.resource_name,
+            type: "switch_provider",
+            description: `${cheapest.provider.toUpperCase()} offers this resource at $${cheapest.monthly_cost.toFixed(2)}/month vs $${current.monthly_cost.toFixed(2)}/month on ${current.provider.toUpperCase()}, saving approximately ${pct.toFixed(0)}%.`,
+            current_monthly_cost: current.monthly_cost,
+            estimated_monthly_cost: cheapest.monthly_cost,
+            monthly_savings: savings,
+            percentage_savings: Math.round(pct * 10) / 10,
+            confidence: "medium",
+            provider: cheapest.provider
+          });
+        }
+      }
+    }
+    if (resource && OBJECT_STORAGE_RESOURCE_TYPES.has(resource.type)) {
+      const storageClass = resource.attributes.storage_class ?? "";
+      const isHotTier = storageClass === "" || storageClass.toLowerCase() === "standard" || storageClass.toLowerCase() === "hot";
+      if (isHotTier && current.monthly_cost > 0) {
+        const estimatedSavings = current.monthly_cost * 0.4;
+        recommendations.push({
+          resource_id: resourceId,
+          resource_name: current.resource_name,
+          type: "storage_tier",
+          description: "Consider using an infrequent-access or cool storage tier if data is not accessed daily. This can reduce storage costs by ~40\u201360%.",
+          current_monthly_cost: current.monthly_cost,
+          estimated_monthly_cost: current.monthly_cost - estimatedSavings,
+          monthly_savings: estimatedSavings,
+          percentage_savings: 40,
+          confidence: "low",
+          provider: current.provider
+        });
+      }
+    }
+  }
+  return recommendations;
+}
+
+// src/reporting/markdown-report.ts
+function formatUsd(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function providerLabel(provider) {
+  switch (provider) {
+    case "aws":
+      return "AWS";
+    case "azure":
+      return "Azure";
+    case "gcp":
+      return "GCP";
+  }
+}
+function generateMarkdownReport(comparison, resources, options = {}, parseWarnings = []) {
+  const includeBreakdown = options.include_breakdown !== false;
+  const includeRecommendations = options.include_recommendations !== false;
+  const monthlyHours = options.monthly_hours ?? 730;
+  const lines = [];
+  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  lines.push(
+    `# Cloud Cost Comparison Report`,
+    ``,
+    `**Generated:** ${now}  `,
+    `**Source provider:** ${providerLabel(comparison.source_provider)}  `,
+    `**Resources analysed:** ${resources.length}`,
+    ``
+  );
+  lines.push(`## Summary`, ``);
+  const sourceBreakdown = comparison.comparisons.find(
+    (b) => b.provider === comparison.source_provider
+  );
+  const sourceMonthly = sourceBreakdown?.total_monthly ?? 0;
+  lines.push(
+    `| Provider | Monthly Cost | Yearly Cost | vs Source |`,
+    `|----------|-------------|------------|-----------|`
+  );
+  for (const breakdown of comparison.comparisons) {
+    const diff = breakdown.total_monthly - sourceMonthly;
+    const diffLabel = breakdown.provider === comparison.source_provider ? "\u2014" : diff < 0 ? `${formatUsd(Math.abs(diff))} cheaper` : diff > 0 ? `${formatUsd(diff)} more expensive` : "same cost";
+    lines.push(
+      `| ${providerLabel(breakdown.provider)} | ${formatUsd(breakdown.total_monthly)} | ${formatUsd(breakdown.total_yearly)} | ${diffLabel} |`
+    );
+  }
+  lines.push(``);
+  if (comparison.savings_summary.length > 0) {
+    lines.push(`## Savings Potential`, ``);
+    lines.push(
+      `| Provider | Monthly Cost | Savings from Source | Savings % |`,
+      `|----------|-------------|--------------------|-----------| `
+    );
+    for (const s of comparison.savings_summary) {
+      const savings = s.difference_from_source;
+      const savingsLabel = savings < 0 ? formatUsd(Math.abs(savings)) : `-${formatUsd(savings)}`;
+      const pct = s.percentage_difference < 0 ? `${Math.abs(s.percentage_difference).toFixed(1)}% cheaper` : `${s.percentage_difference.toFixed(1)}% more`;
+      lines.push(
+        `| ${providerLabel(s.provider)} | ${formatUsd(s.total_monthly)} | ${savingsLabel} | ${pct} |`
+      );
+    }
+    lines.push(``);
+  }
+  if (includeBreakdown && resources.length > 0) {
+    lines.push(`## Resource Breakdown`, ``);
+    const costMatrix = /* @__PURE__ */ new Map();
+    for (const breakdown of comparison.comparisons) {
+      for (const estimate of breakdown.by_resource) {
+        const row = costMatrix.get(estimate.resource_id) ?? {};
+        row[breakdown.provider] = estimate.monthly_cost;
+        costMatrix.set(estimate.resource_id, row);
+      }
+    }
+    const presentProviders = comparison.comparisons.map((b) => b.provider);
+    const headerCols = presentProviders.map((p) => providerLabel(p)).join(" | ");
+    lines.push(
+      `| Resource | Type | ${headerCols} |`,
+      `|----------|------|${presentProviders.map(() => "------").join("|")}|`
+    );
+    for (const resource of resources) {
+      const costs = costMatrix.get(resource.id) ?? {};
+      const costCols = presentProviders.map((p) => formatUsd(costs[p] ?? 0)).join(" | ");
+      lines.push(
+        `| ${resource.name} | ${resource.type} | ${costCols} |`
+      );
+    }
+    lines.push(``);
+  }
+  if (includeRecommendations) {
+    const allEstimates = comparison.comparisons.flatMap((b) => b.by_resource);
+    const recommendations = generateOptimizations(allEstimates, resources);
+    if (recommendations.length > 0) {
+      lines.push(`## Savings Recommendations`, ``);
+      for (const rec of recommendations) {
+        const savingsLabel = `${formatUsd(rec.monthly_savings)}/month (${rec.percentage_savings}%)`;
+        lines.push(
+          `### ${rec.resource_name} \u2013 ${rec.type.replace(/_/g, " ")}`,
+          ``,
+          `${rec.description}`,
+          ``,
+          `- **Current cost:** ${formatUsd(rec.current_monthly_cost)}/month`,
+          `- **Estimated after:** ${formatUsd(rec.estimated_monthly_cost)}/month`,
+          `- **Potential savings:** ${savingsLabel}`,
+          `- **Confidence:** ${rec.confidence}`,
+          ``
+        );
+      }
+    } else {
+      lines.push(`## Savings Recommendations`, ``, `No recommendations at this time.`, ``);
+    }
+  }
+  lines.push(`## Assumptions`, ``);
+  lines.push(
+    `| Parameter | Value |`,
+    `|-----------|-------|`,
+    `| Pricing model | On-demand (no reserved or spot instances) |`,
+    `| Operating system | Linux (unless specified in resource attributes) |`,
+    `| Monthly hours | ${monthlyHours} |`,
+    `| Currency | USD |`,
+    `| Pricing source | Mix of live API and fallback/bundled data |`,
+    `| Data transfer costs | Not included |`,
+    `| Tax | Not included |`,
+    ``
+  );
+  const allDataWarnings = comparison.comparisons.flatMap((b) => b.warnings ?? []);
+  const allWarnings = [.../* @__PURE__ */ new Set([...parseWarnings, ...allDataWarnings])];
+  if (allWarnings.length > 0) {
+    lines.push(`## Limitations`, ``);
+    lines.push(
+      `> The following issues were detected during analysis that may affect estimate accuracy:`,
+      ``
+    );
+    for (const w of allWarnings) {
+      lines.push(`- ${w}`);
+    }
+    lines.push(``);
+  }
+  return lines.join("\n");
+}
+
+// src/reporting/json-report.ts
+function generateJsonReport(comparison, resources, monthlyHours = 730, parseWarnings = []) {
+  const sourcesSet = /* @__PURE__ */ new Set();
+  for (const breakdown of comparison.comparisons) {
+    for (const estimate of breakdown.by_resource) {
+      const src = estimate.pricing_source;
+      if (src) {
+        sourcesSet.add(`${breakdown.provider}_${src}`);
+      }
+    }
+  }
+  const allDataWarnings = comparison.comparisons.flatMap((b) => b.warnings ?? []);
+  const allWarnings = [.../* @__PURE__ */ new Set([...parseWarnings, ...allDataWarnings])];
+  const output = {
+    metadata: {
+      generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      pricing_sources_used: Array.from(sourcesSet).sort(),
+      assumptions: {
+        pricing_model: "on-demand",
+        operating_system: "Linux (unless specified)",
+        monthly_hours: monthlyHours,
+        currency: "USD",
+        data_transfer_costs: "not included",
+        tax: "not included"
+      },
+      warnings: allWarnings
+    },
+    ...comparison,
+    resource_summary: {
+      total: resources.length,
+      by_type: resources.reduce((acc, r) => {
+        acc[r.type] = (acc[r.type] ?? 0) + 1;
+        return acc;
+      }, {})
+    }
+  };
+  return JSON.stringify(output, null, 2);
+}
+
+// src/reporting/csv-report.ts
+var PROVIDERS = ["aws", "azure", "gcp"];
+function csvEscape(value) {
+  const str2 = String(value);
+  if (str2.includes(",") || str2.includes("\n") || str2.includes('"')) {
+    return `"${str2.replace(/"/g, '""')}"`;
+  }
+  return str2;
+}
+function generateCsvReport(comparison, resources) {
+  const lines = [];
+  lines.push("# Prices are estimates based on on-demand pricing. See assumptions in JSON/Markdown reports.");
+  lines.push("Resource,Type,AWS Monthly,Azure Monthly,GCP Monthly,Cheapest");
+  const costByProviderAndResource = /* @__PURE__ */ new Map();
+  for (const breakdown of comparison.comparisons) {
+    const byResource = /* @__PURE__ */ new Map();
+    for (const estimate of breakdown.by_resource) {
+      byResource.set(estimate.resource_id, estimate.monthly_cost);
+    }
+    costByProviderAndResource.set(breakdown.provider, byResource);
+  }
+  for (const resource of resources) {
+    const costs = {};
+    for (const provider of PROVIDERS) {
+      const providerMap = costByProviderAndResource.get(provider);
+      if (providerMap) {
+        costs[provider] = providerMap.get(resource.id) ?? 0;
+      }
+    }
+    let cheapest = "N/A";
+    let lowestCost = Infinity;
+    for (const provider of PROVIDERS) {
+      const cost = costs[provider] ?? 0;
+      if (cost > 0 && cost < lowestCost) {
+        lowestCost = cost;
+        cheapest = provider.toUpperCase();
+      }
+    }
+    const row = [
+      csvEscape(resource.name),
+      csvEscape(resource.type),
+      csvEscape((costs.aws ?? 0).toFixed(2)),
+      csvEscape((costs.azure ?? 0).toFixed(2)),
+      csvEscape((costs.gcp ?? 0).toFixed(2)),
+      csvEscape(cheapest)
+    ];
+    lines.push(row.join(","));
+  }
+  return lines.join("\n");
+}
+
+// src/tools/compare-providers.ts
+var compareProvidersSchema = z3.object({
+  files: z3.array(
+    z3.object({
+      path: z3.string().describe("File path"),
+      content: z3.string().describe("File content (HCL)")
+    })
+  ),
+  tfvars: z3.string().optional().describe("Contents of terraform.tfvars file"),
+  format: z3.enum(["markdown", "json", "csv"]).default("markdown").describe("Output report format"),
+  providers: z3.array(z3.enum(["aws", "azure", "gcp"])).default(["aws", "azure", "gcp"]).describe("Cloud providers to include in the comparison")
+});
+async function compareProviders(params, pricingEngine, config) {
+  const inventory = await parseTerraform(params.files, params.tfvars);
+  const sourceProvider = inventory.provider;
+  const costEngine = new CostEngine(pricingEngine, config);
+  const comparisons = [];
+  for (const provider of params.providers) {
+    const targetRegion = mapRegion(inventory.region, sourceProvider, provider);
+    const breakdown = await costEngine.calculateBreakdown(
+      inventory.resources,
+      provider,
+      targetRegion
+    );
+    comparisons.push(breakdown);
+  }
+  const sourceBreakdown = comparisons.find((b) => b.provider === sourceProvider) ?? comparisons[0];
+  const sourceMonthly = sourceBreakdown?.total_monthly ?? 0;
+  const savingsSummary = comparisons.map((b) => {
+    const diff = b.total_monthly - sourceMonthly;
+    const pct = sourceMonthly !== 0 ? diff / sourceMonthly * 100 : 0;
+    return {
+      provider: b.provider,
+      total_monthly: b.total_monthly,
+      difference_from_source: Math.round(diff * 100) / 100,
+      percentage_difference: Math.round(pct * 10) / 10
+    };
+  });
+  const comparison = {
+    source_provider: sourceProvider,
+    comparisons,
+    savings_summary: savingsSummary,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const allWarnings = comparisons.flatMap((b) => b.warnings ?? []);
+  const parseWarnings = inventory.parse_warnings ?? [];
+  const monthlyHours = config.pricing.monthly_hours;
+  let report;
+  switch (params.format) {
+    case "json":
+      report = generateJsonReport(comparison, inventory.resources, monthlyHours, parseWarnings);
+      break;
+    case "csv":
+      report = generateCsvReport(comparison, inventory.resources);
+      break;
+    case "markdown":
+    default:
+      report = generateMarkdownReport(
+        comparison,
+        inventory.resources,
+        {},
+        parseWarnings
+      );
+      break;
+  }
+  return {
+    report,
+    format: params.format,
+    comparison,
+    warnings: [.../* @__PURE__ */ new Set([...parseWarnings, ...allWarnings])]
+  };
+}
+
+// src/tools/get-equivalents.ts
+import { z as z4 } from "zod";
+
+// src/mapping/resource-mapper.ts
+function findEquivalent(resourceType, sourceProvider, targetProvider) {
+  if (sourceProvider === targetProvider) {
+    return resourceType;
+  }
+  const equivalents = getResourceEquivalents();
+  const row = equivalents.find(
+    (entry) => entry[sourceProvider] === resourceType
+  );
+  if (!row) return null;
+  return row[targetProvider] ?? null;
+}
+function findAllEquivalents(resourceType, sourceProvider) {
+  const equivalents = getResourceEquivalents();
+  const row = equivalents.find(
+    (entry) => entry[sourceProvider] === resourceType
+  );
+  if (!row) return {};
+  const result = {};
+  const providers = ["aws", "azure", "gcp"];
+  for (const provider of providers) {
+    const value = row[provider];
+    if (value) {
+      result[provider] = value;
+    }
+  }
+  return result;
+}
+
+// src/tools/get-equivalents.ts
+var getEquivalentsSchema = z4.object({
+  resource_type: z4.string().describe(
+    "Terraform resource type to look up (e.g. aws_instance, google_compute_instance)"
+  ),
+  source_provider: z4.enum(["aws", "azure", "gcp"]).describe("Cloud provider the resource type belongs to"),
+  target_provider: z4.enum(["aws", "azure", "gcp"]).optional().describe(
+    "Specific target provider. When omitted, equivalents for all providers are returned."
+  ),
+  instance_type: z4.string().optional().describe(
+    "Instance type / VM size to also map across providers (e.g. t3.large, Standard_D4s_v3)"
+  )
+});
+async function getEquivalents(params) {
+  const sourceProvider = params.source_provider;
+  let resourceEquivalents;
+  if (params.target_provider) {
+    const targetProvider = params.target_provider;
+    const equivalent = findEquivalent(
+      params.resource_type,
+      sourceProvider,
+      targetProvider
+    );
+    resourceEquivalents = { [targetProvider]: equivalent };
+  } else {
+    resourceEquivalents = findAllEquivalents(params.resource_type, sourceProvider);
+  }
+  let instanceEquivalents;
+  if (params.instance_type) {
+    const providers = ["aws", "azure", "gcp"];
+    const targets = params.target_provider ? [params.target_provider] : providers.filter((p) => p !== sourceProvider);
+    instanceEquivalents = {};
+    for (const target of targets) {
+      instanceEquivalents[target] = mapInstance(
+        params.instance_type,
+        sourceProvider,
+        target
+      );
+    }
+  }
+  return {
+    resource_type: params.resource_type,
+    source_provider: sourceProvider,
+    resource_equivalents: resourceEquivalents,
+    ...instanceEquivalents !== void 0 ? {
+      instance_type: params.instance_type,
+      instance_equivalents: instanceEquivalents
+    } : {}
+  };
+}
+
+// src/tools/get-pricing.ts
+import { z as z5 } from "zod";
+var getPricingSchema = z5.object({
+  provider: z5.enum(["aws", "azure", "gcp"]).describe("Cloud provider to look up pricing for"),
+  service: z5.enum(["compute", "database", "storage", "network", "kubernetes"]).describe("Service category"),
+  resource_type: z5.string().describe(
+    "Instance type, storage type, or resource identifier (e.g. t3.large, gp3, Standard_D4s_v3)"
+  ),
+  region: z5.string().describe("Cloud region (e.g. us-east-1, eastus, us-central1)")
+});
+async function getPricing(params, pricingEngine) {
+  const provider = params.provider;
+  const serviceMap = {
+    compute: "compute",
+    database: "database",
+    storage: "storage",
+    network: "nat-gateway",
+    kubernetes: "kubernetes"
+  };
+  const service = serviceMap[params.service] ?? params.service;
+  const price = await pricingEngine.getPrice(
+    provider,
+    service,
+    params.resource_type,
+    params.region
+  );
+  return {
+    provider,
+    service: params.service,
+    resource_type: params.resource_type,
+    region: params.region,
+    price
+  };
+}
+
+// src/tools/optimize-cost.ts
+import { z as z6 } from "zod";
+var optimizeCostSchema = z6.object({
+  files: z6.array(
+    z6.object({
+      path: z6.string().describe("File path"),
+      content: z6.string().describe("File content (HCL)")
+    })
+  ),
+  tfvars: z6.string().optional().describe("Contents of terraform.tfvars file"),
+  providers: z6.array(z6.enum(["aws", "azure", "gcp"])).default(["aws", "azure", "gcp"]).describe("Providers to calculate costs against for cross-provider recommendations")
+});
+async function optimizeCost(params, pricingEngine, config) {
+  const inventory = await parseTerraform(params.files, params.tfvars);
+  const sourceProvider = inventory.provider;
+  const costEngine = new CostEngine(pricingEngine, config);
+  const allEstimates = [];
+  for (const provider of params.providers) {
+    const targetRegion = mapRegion(inventory.region, sourceProvider, provider);
+    const breakdown = await costEngine.calculateBreakdown(
+      inventory.resources,
+      provider,
+      targetRegion
+    );
+    allEstimates.push(...breakdown.by_resource);
+  }
+  const recommendations = generateOptimizations(allEstimates, inventory.resources);
+  const sourceEstimates = allEstimates.filter(
+    (e) => e.provider === sourceProvider && e.monthly_cost > 0
+  );
+  const reservedPricing = sourceEstimates.map((estimate) => ({
+    resource_id: estimate.resource_id,
+    resource_name: estimate.resource_name,
+    resource_type: estimate.resource_type,
+    provider: estimate.provider,
+    ...calculateReservedPricing(estimate.monthly_cost, estimate.provider)
+  }));
+  const totalPotentialSavings = recommendations.reduce((sum, r) => sum + r.monthly_savings, 0);
+  return {
+    recommendations,
+    reserved_pricing: reservedPricing,
+    total_potential_savings: Math.round(totalPotentialSavings * 100) / 100,
+    recommendation_count: recommendations.length,
+    resource_count: inventory.resources.length
+  };
+}
+
+// src/tools/index.ts
+function registerTools(server, config) {
+  const cache = new PricingCache(config.cache.db_path);
+  const pricingEngine = new PricingEngine(cache, config);
+  server.tool(
+    "analyze_terraform",
+    "Parse Terraform HCL files and extract a resource inventory with provider detection, variable resolution, and cost-relevant attribute extraction",
+    analyzeTerraformSchema.shape,
+    async (params) => {
+      const result = await analyzeTerraform(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "estimate_cost",
+    "Estimate monthly and yearly cloud costs for Terraform resources on a specific provider. Returns a full cost breakdown by resource and service category.",
+    estimateCostSchema.shape,
+    async (params) => {
+      const result = await estimateCost(params, pricingEngine, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "compare_providers",
+    "Run a full cost comparison across AWS, Azure, and GCP for a set of Terraform resources. Returns a formatted report and raw comparison data including savings potential.",
+    compareProvidersSchema.shape,
+    async (params) => {
+      const result = await compareProviders(params, pricingEngine, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_equivalents",
+    "Look up the equivalent Terraform resource types across cloud providers. Optionally also maps an instance type / VM size to the nearest equivalent on target providers.",
+    getEquivalentsSchema.shape,
+    async (params) => {
+      const result = await getEquivalents(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "get_pricing",
+    "Direct pricing lookup for a specific cloud provider, service, resource type, and region. Returns the normalised unit price with metadata.",
+    getPricingSchema.shape,
+    async (params) => {
+      const result = await getPricing(params, pricingEngine);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.tool(
+    "optimize_cost",
+    "Analyse Terraform resources and return cost optimisation recommendations including right-sizing suggestions, reserved pricing comparisons, and cross-provider savings opportunities.",
+    optimizeCostSchema.shape,
+    async (params) => {
+      const result = await optimizeCost(params, pricingEngine, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/server.ts
+async function startServer() {
+  const config = loadConfig();
+  setLogLevel(config.logging.level);
+  const server = new McpServer({
+    name: "cloudcost-mcp",
+    version: "0.1.0"
+  });
+  registerTools(server, config);
+  const transport = new StdioServerTransport();
+  logger.info("Starting CloudCost MCP server");
+  await server.connect(transport);
+}
+
+// src/index.ts
+process.on("uncaughtException", (err) => {
+  process.stderr.write(`Uncaught exception: ${err.stack ?? err.message}
+`);
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  const msg = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+  process.stderr.write(`Unhandled rejection: ${msg}
+`);
+  process.exit(1);
+});
+startServer().catch((err) => {
+  process.stderr.write(`Failed to start server: ${err.stack ?? err.message}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map