@jadenrazo/cloudcost-mcp 0.3.0 → 0.4.0

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">CloudCost MCP Server</h1>
 
 <p align="center">
-  Multi-cloud cost analysis for Terraform — powered by live pricing data from AWS, Azure, and GCP.
+  Multi-cloud cost analysis for Terraform. Live pricing from AWS, Azure, and GCP.
   <br />
   Built on the <a href="https://modelcontextprotocol.io">Model Context Protocol</a> for seamless AI agent integration.
 </p>
@@ -28,16 +28,20 @@
 
 ---
 
-CloudCost MCP is a [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server — a standardized way to give AI assistants like Claude access to external tools — that lets AI agents parse Terraform codebases, query real-time pricing data, and generate multi-cloud cost comparison reports. It connects directly to public pricing APIs from AWS and Azure — no API keys or cloud credentials required. GCP pricing is bundled from public catalog data.
+CloudCost MCP is a [Model Context Protocol](https://modelcontextprotocol.io) server that lets AI agents parse Terraform codebases, query real-time pricing data, and generate multi-cloud cost comparison reports. It connects directly to public pricing APIs from AWS, Azure, and GCP. No API keys or cloud credentials required.
 
 ### What it does
 
-- Parses Terraform HCL files and extracts resource inventories with variable resolution
-- Queries live on-demand pricing from AWS Bulk Pricing CSV and Azure Retail Prices REST API
-- Maps equivalent resources across AWS, Azure, and GCP (compute, database, storage, networking, Kubernetes)
-- Generates cost estimates with per-resource breakdowns (monthly and yearly)
-- Compares costs across all three providers side-by-side in markdown, JSON, or CSV
-- Provides optimization recommendations: right-sizing, reserved pricing, provider switching
+- Parses Terraform HCL files and extracts resource inventories with variable resolution, including referenced modules and OpenTofu `.tofu` files
+- Queries live on-demand pricing from AWS Bulk Pricing CSV and Azure Retail Prices REST API; GCP via live Cloud Billing Catalog API with bundled fallback
+- Maps equivalent resources across AWS, Azure, and GCP (compute, database, storage, networking, Kubernetes, container registries, secrets management, DNS)
+- Generates cost estimates with per-resource breakdowns (monthly and yearly) across multiple currencies
+- Compares costs across all three providers side-by-side in markdown, JSON, CSV, or FOCUS format
+- Provides optimization recommendations: right-sizing, reserved pricing, provider switching, spot/preemptible instances
+- Models hypothetical scenarios (instance type changes, region moves, commitment levels) without modifying Terraform files
+- Projects costs over 3, 6, 12, and 36-month horizons with reserved instance comparisons
+- Tags resources for cost attribution and groups report output by team, environment, or any custom label
+- Posts cost estimate comments to pull requests via a reusable GitHub Actions composite action
 
 ---
 
@@ -113,7 +117,7 @@ node dist/index.js
 
 ## Tools
 
-The server exposes six MCP tools. Each accepts JSON input and returns structured JSON output.
+The server exposes seven MCP tools. Each accepts JSON input and returns structured JSON output.
 
 ### `analyze_terraform`
 
@@ -134,6 +138,7 @@ Calculate costs for parsed resources on a specific provider. Returns monthly and
 | `tfvars` | `string` | No | Variable overrides |
 | `provider` | `aws \| azure \| gcp` | Yes | Target provider for pricing |
 | `region` | `string` | No | Target region (auto-mapped if omitted) |
+| `currency` | `string` | No | Output currency (default: `USD`). Supports: USD, EUR, GBP, JPY, CAD, AUD, INR, BRL |
 
 ### `compare_providers`
 
@@ -143,8 +148,9 @@ Full pipeline: parse Terraform, map resources across providers, fetch pricing, a
 |-----------|------|----------|-------------|
 | `files` | `{path, content}[]` | Yes | Terraform files |
 | `tfvars` | `string` | No | Variable overrides |
-| `format` | `markdown \| json \| csv` | No | Report format (default: `markdown`) |
+| `format` | `markdown \| json \| csv \| focus` | No | Report format (default: `markdown`) |
 | `providers` | `string[]` | No | Providers to compare (default: all three) |
+| `currency` | `string` | No | Output currency (default: `USD`). Supports: USD, EUR, GBP, JPY, CAD, AUD, INR, BRL |
 
 ### `get_equivalents`
 
@@ -178,6 +184,30 @@ Analyze Terraform resources and return optimization recommendations. Includes ri
 | `tfvars` | `string` | No | Variable overrides |
 | `providers` | `string[]` | No | Providers to evaluate (default: all three) |
 
+### `what_if`
+
+Run hypothetical pricing scenarios against existing Terraform resources. Change instance types, regions, providers, or commitment levels and see the cost delta without modifying your actual configuration.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `files` | `{path, content}[]` | Yes | Terraform files |
+| `tfvars` | `string` | No | Variable overrides |
+| `scenarios` | `object[]` | Yes | Changes to model. Each specifies a resource name and the attributes to override |
+| `providers` | `string[]` | No | Providers to evaluate (default: all three) |
+| `currency` | `string` | No | Output currency (default: `USD`) |
+
+**Example**: model the cost impact of switching compute from on-demand to spot across providers:
+
+```json
+{
+  "files": [{ "path": "main.tf", "content": "..." }],
+  "scenarios": [
+    { "resource": "aws_instance.web", "pricing_model": "spot" },
+    { "resource": "aws_instance.app", "instance_type": "m6i.2xlarge" }
+  ]
+}
+```
+
 ---
 
 ## How Pricing Works
@@ -186,30 +216,32 @@ CloudCost uses a tiered approach to get the most accurate pricing available with
 
 ### AWS
 
-1. **Live CSV streaming** (primary) — For EC2 compute pricing, the server streams the AWS Bulk Pricing CSV for the target region line-by-line. This avoids loading the full ~267 MB file into memory. All on-demand compute prices for the region are extracted in a single pass and cached in SQLite for 24 hours. Concurrent requests for the same region share a single download.
+1. **Live CSV streaming** (primary). For EC2 compute pricing, the server streams the AWS Bulk Pricing CSV for the target region line-by-line. This avoids loading the full ~267 MB file into memory. All on-demand compute prices for the region are extracted in a single pass and cached in SQLite for 24 hours. Concurrent requests for the same region share a single download.
 
-2. **Live JSON API** (secondary) — For RDS (~24 MB), S3, ELB, and VPC, the server fetches regional JSON from the [AWS Price List Bulk API](https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/index.json). These files are small enough to parse directly.
+2. **Live JSON API** (secondary). For RDS (~24 MB), S3, ELB, and VPC, the server fetches regional JSON from the [AWS Price List Bulk API](https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/index.json). These files are small enough to parse directly.
 
-3. **Fallback tables + interpolation** — If live fetching fails (network issues, timeouts), the server falls back to built-in pricing tables covering 85+ EC2 and 29 RDS instance types. A size-interpolation algorithm estimates prices for unlisted sizes within known families by following AWS's predictable doubling pattern (e.g., `large` → `xlarge` doubles the price).
+3. **Fallback tables + interpolation**. If live fetching fails (network issues, timeouts), the server falls back to built-in pricing tables covering 85+ EC2 and 29 RDS instance types. A size-interpolation algorithm estimates prices for unlisted sizes within known families by following AWS's predictable doubling pattern (e.g., `large` to `xlarge` doubles the price).
 
 ### Azure
 
-1. **Live REST API** (primary) — Queries the [Azure Retail Prices API](https://prices.azure.com/api/retail/prices) with OData filters for exact SKU matching (`armSkuName`). This is a fast, free, unauthenticated API that returns precise per-SKU pricing. Results are paginated and fully consumed.
+1. **Live REST API** (primary). Queries the [Azure Retail Prices API](https://prices.azure.com/api/retail/prices) with OData filters for exact SKU matching (`armSkuName`). Fast, free, unauthenticated. Returns precise per-SKU pricing. Results are paginated and fully consumed.
 
-2. **Fallback tables + interpolation** — If the API is unreachable, falls back to built-in tables covering 40+ VM sizes and 14 database tiers. A vCPU-proportional interpolation algorithm estimates prices for unlisted sizes.
+2. **Fallback tables + interpolation**. If the API is unreachable, falls back to built-in tables covering 40+ VM sizes and 14 database tiers. A vCPU-proportional interpolation algorithm estimates prices for unlisted sizes.
 
 ### GCP
 
-1. **Bundled pricing data** — GCP's Cloud Billing Catalog API requires an API key, so the server ships with curated pricing data in `data/gcp-pricing/`. This covers Compute Engine machine types, Cloud SQL tiers, Cloud Storage classes, and Persistent Disk types across all major regions.
+1. **Live Cloud Billing Catalog API** (primary). Queries the GCP Cloud Billing Catalog API (`cloudbilling.googleapis.com`) using unauthenticated public endpoints. Results are cached for 24 hours.
+
+2. **Bundled pricing data** (fallback). If the live API is unreachable, falls back to curated pricing data in `data/gcp-pricing/` that ships with the package. Covers Compute Engine machine types, Cloud SQL tiers, Cloud Storage classes, and Persistent Disk types across all major regions.
 
-2. **Infrastructure services** — Load balancer, Cloud NAT, and GKE pricing use fixed public rates.
+3. **Infrastructure services**. Load balancer, Cloud NAT, and GKE pricing use fixed public rates.
 
 ### Pricing Source Transparency
 
 Every price returned includes a `pricing_source` attribute indicating its origin:
-- `"live"` — fetched from a public API in real time
-- `"fallback"` — from built-in tables (approximate, but reasonable for estimates)
-- `"bundled"` — from bundled data files shipped with the package
+- `"live"`: fetched from a public API in real time
+- `"fallback"`: from built-in tables (approximate, but reasonable for estimates)
+- `"bundled"`: from bundled data files shipped with the package
 
 All pricing data is cached in a local SQLite database (`~/.cloudcost/cache.db`) with a 24-hour TTL to minimize redundant API calls.
 
@@ -288,6 +320,12 @@ All configuration is optional. The server works out of the box with sensible def
 | `CLOUDCOST_CACHE_PATH` | `~/.cloudcost/cache.db` | SQLite cache file location |
 | `CLOUDCOST_LOG_LEVEL` | `info` | Log level: `debug`, `info`, `warn`, `error` |
 | `CLOUDCOST_MONTHLY_HOURS` | `730` | Hours per month for cost calculations |
+| `CLOUDCOST_INCLUDE_DATA_TRANSFER` | `false` | Include estimated data transfer costs in reports |
+| `CLOUDCOST_PRICING_MODEL` | `on_demand` | Default pricing model: `on_demand`, `spot`, or `reserved` |
+| `CLOUDCOST_RESOLVE_MODULES` | `true` | Expand referenced Terraform modules during parsing |
+| `CLOUDCOST_BUDGET_MONTHLY` | | Monthly budget cap in USD. Triggers a warning when exceeded |
+| `CLOUDCOST_BUDGET_PER_RESOURCE` | | Per-resource monthly budget cap in USD |
+| `CLOUDCOST_BUDGET_WARN_PCT` | `80` | Percentage of budget at which a warning is surfaced (default: 80%) |
 
 ### Config File
 
@@ -351,11 +389,11 @@ Configuration priority: environment variables > config file > built-in defaults.
 
 ### Key Design Decisions
 
-- **Zero API keys** — All pricing comes from public endpoints. AWS uses the unauthenticated Bulk Pricing files. Azure uses the free Retail Prices REST API. GCP uses bundled data from public catalog information.
-- **SQLite cache** — A single `better-sqlite3` database caches all pricing lookups with configurable TTL. Shared across all tools per server lifetime.
-- **Streaming for large files** — AWS EC2 pricing data (~267 MB CSV) is streamed line-by-line rather than loaded into memory. All prices for a region are extracted in one pass and cached.
-- **Graceful degradation** — If any live pricing source is unavailable, the server falls back to built-in tables with size-interpolation. Every response includes the pricing source so the consumer knows the confidence level.
-- **ESM-only** — Requires Node 20+. All internal imports use `.js` extensions.
+- **Zero API keys.** All pricing comes from public endpoints. AWS uses the unauthenticated Bulk Pricing files. Azure uses the free Retail Prices REST API. GCP queries the Cloud Billing Catalog API with bundled fallback.
+- **SQLite cache.** A single `better-sqlite3` database caches all pricing lookups with configurable TTL. Shared across all tools per server lifetime.
+- **Streaming for large files.** AWS EC2 pricing data (~267 MB CSV) is streamed line-by-line rather than loaded into memory. Prices for a region are extracted in one pass and cached.
+- **Graceful degradation.** If any live pricing source is unavailable, the server falls back to built-in tables with size-interpolation. Every response includes the pricing source so the consumer knows the confidence level.
+- **ESM-only.** Requires Node 20+. All internal imports use `.js` extensions.
 
 ---
 
@@ -368,6 +406,9 @@ Configuration priority: environment variables > config file > built-in defaults.
 | **Storage** | `aws_ebs_volume`, `aws_s3_bucket` | `azurerm_managed_disk`, `azurerm_storage_account` | `google_compute_disk`, `google_storage_bucket` |
 | **Network** | `aws_lb`, `aws_nat_gateway` | `azurerm_lb`, `azurerm_nat_gateway` | `google_compute_forwarding_rule` |
 | **Kubernetes** | `aws_eks_cluster` | `azurerm_kubernetes_cluster` | `google_container_cluster` |
+| **Container Registries** | `aws_ecr_repository` | `azurerm_container_registry` | `google_artifact_registry_repository` |
+| **Secrets Management** | `aws_secretsmanager_secret` | `azurerm_key_vault` | `google_secret_manager_secret` |
+| **DNS** | `aws_route53_zone` | `azurerm_dns_zone` | `google_dns_managed_zone` |
 
 Instance type mapping covers 70+ AWS instance types (including Graviton/ARM families: m6g, m7g, c6g, c7g, r6g, r7g, t4g), 40+ Azure VM sizes, and 20+ GCP machine types with full bidirectional cross-provider mapping.
 
@@ -375,10 +416,8 @@ Instance type mapping covers 70+ AWS instance types (including Graviton/ARM fami
 
 ## Limitations
 
-- **Data transfer costs** are not included. Inter-region, inter-AZ, and internet egress charges are excluded from estimates.
-- **On-demand pricing only** by default. Prices reflect pay-as-you-go rates. The `optimize_cost` tool will recommend reserved instances and savings plans, but base estimates use on-demand.
-- **No Terraform module expansion**. Only direct resource blocks in the provided files are parsed. Resources defined inside referenced modules (`source = "..."`) are not resolved.
-- **GCP pricing is bundled**, not live. Prices may lag behind actual rates. AWS and Azure pricing is fetched in real time.
+- **On-demand pricing only** by default. Prices reflect pay-as-you-go rates. The `optimize_cost` tool will recommend reserved instances and savings plans, but base estimates use on-demand. Pass `pricing_model: "spot"` in `what_if` scenarios to model spot/preemptible pricing.
+- **GCP live pricing** is fetched from the Cloud Billing Catalog API with automatic fallback to bundled data when the API is unreachable. Bundled prices may lag slightly behind actual rates.
 - **First request latency**. The initial EC2 pricing lookup for a new AWS region may take 30-120 seconds as the CSV file is streamed. Subsequent lookups for the same region are instant (cached for 24 hours).
 - **Specialty instance types**. GPU instances (p4d, g5, etc.), high-memory (x2idn), and bare-metal types may fall back to interpolated pricing if not in the built-in tables and live fetch fails.
 
@@ -386,13 +425,49 @@ Instance type mapping covers 70+ AWS instance types (including Graviton/ARM fami
 
 ## Troubleshooting
 
-**$0 cost estimates** — This usually means the instance type string in your Terraform code doesn't match any known pricing data. Check that you're using a real instance type (e.g., `t3.xlarge`) rather than a variable reference that wasn't resolved. Pass your `terraform.tfvars` content via the `tfvars` parameter to resolve variables.
+**$0 cost estimates.** The instance type string in your Terraform code probably doesn't match any known pricing data. Check that you're using a real instance type (e.g., `t3.xlarge`) rather than a variable reference that wasn't resolved. Pass your `terraform.tfvars` content via the `tfvars` parameter to resolve variables.
 
-**Slow first request** — The first EC2 pricing lookup for a new region streams the full AWS pricing CSV (~267 MB). This is a one-time cost per region; all subsequent lookups hit the local SQLite cache. Set `CLOUDCOST_LOG_LEVEL=debug` to see progress.
+**Slow first request.** The first EC2 pricing lookup for a new region streams the full AWS pricing CSV (~267 MB). One-time cost per region; subsequent lookups hit the local SQLite cache. Set `CLOUDCOST_LOG_LEVEL=debug` to see progress.
 
-**Cache issues** — Delete `~/.cloudcost/cache.db` to clear all cached pricing data. The cache rebuilds automatically on the next request.
+**Cache issues.** Delete `~/.cloudcost/cache.db` to clear all cached pricing data. The cache rebuilds automatically on the next request.
+
+**Node version.** Requires Node.js 20+. Uses ESM modules, Web Streams API (`TextDecoderStream`), and `AbortSignal.timeout()`.
+
+---
+
+## GitHub Actions
+
+A reusable composite action is included at `.github/actions/cost-estimate/`. It detects changed `.tf` files, runs a cost comparison, and posts the result as a PR comment.
+
+```yaml
+# .github/workflows/cost-estimate.yml
+name: Terraform Cost Estimate
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  cost-estimate:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: ./.github/actions/cost-estimate
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          # terraform_dir: "./terraform"
+          # providers: "aws,azure,gcp"
+          # format: "markdown"
+          # currency: "USD"
+```
 
-**Node version** — The server requires Node.js 20+. It uses ESM modules, Web Streams API (`TextDecoderStream`), and `AbortSignal.timeout()`.
+The action auto-detects the directory containing changed `.tf` files and skips gracefully when no Terraform changes are present in the PR.
 
 ---
 
@@ -414,17 +489,32 @@ src/
 ├── server.ts             # MCP server setup, tool registration
 ├── config.ts             # Config loader (defaults → file → env vars)
 ├── logger.ts             # Structured logger
-├── tools/                # MCP tool handlers + Zod schemas
-├── parsers/              # HCL parsing, variable resolution
+├── currency.ts           # Multi-currency conversion and formatting
+├── tools/
+│   ├── ...               # MCP tool handlers + Zod schemas
+│   └── what-if.ts        # Hypothetical scenario modeling
+├── parsers/
+│   ├── ...               # HCL parsing, variable resolution
+│   ├── module-resolver.ts  # Terraform module expansion
+│   └── dependency-graph.ts # Resource dependency graph builder
 ├── pricing/
 │   ├── pricing-engine.ts # Router: dispatches to provider adapters
 │   ├── cache.ts          # SQLite-backed pricing cache
 │   ├── aws/              # Bulk CSV streaming + JSON + fallback
 │   ├── azure/            # Retail Prices REST API + fallback
-│   └── gcp/              # Bundled pricing data loader
-├── calculator/           # Cost calculations per resource type
+│   └── gcp/
+│       ├── bundled-loader.ts    # Static bundled pricing fallback
+│       └── cloud-billing-client.ts  # Live GCP Cloud Billing Catalog API
+├── calculator/
+│   ├── ...               # Cost calculations per resource type
+│   ├── projection.ts     # Multi-horizon cost projections
+│   ├── container-registry.ts
+│   ├── secrets.ts
+│   └── dns.ts
 ├── mapping/              # Cross-provider resource/instance mapping
-├── reporting/            # Output formatters (markdown, JSON, CSV)
+├── reporting/
+│   ├── ...               # Markdown, JSON, CSV formatters
+│   └── focus-report.ts   # FOCUS-compliant export format
 └── types/                # Shared TypeScript interfaces
 
 data/
@@ -438,4 +528,4 @@ data/
 
 ## License
 
-MIT — see [LICENSE](LICENSE) for details.
+MIT. See [LICENSE](LICENSE) for details.

package/data/resource-equivalents.json

@@ -1,17 +1,156 @@
 [
-  { "category": "compute_instance", "aws": "aws_instance", "azure": "azurerm_linux_virtual_machine", "gcp": "google_compute_instance", "notes": "General purpose VM" },
-  { "category": "compute_instance_windows", "aws": "aws_instance", "azure": "azurerm_windows_virtual_machine", "gcp": "google_compute_instance", "notes": "Windows VM" },
-  { "category": "managed_database_postgres", "aws": "aws_db_instance", "azure": "azurerm_postgresql_flexible_server", "gcp": "google_sql_database_instance", "notes": "Managed PostgreSQL" },
-  { "category": "managed_database_mysql", "aws": "aws_db_instance", "azure": "azurerm_mysql_flexible_server", "gcp": "google_sql_database_instance", "notes": "Managed MySQL" },
-  { "category": "object_storage", "aws": "aws_s3_bucket", "azure": "azurerm_storage_account", "gcp": "google_storage_bucket", "notes": "Object storage" },
-  { "category": "block_storage", "aws": "aws_ebs_volume", "azure": "azurerm_managed_disk", "gcp": "google_compute_disk", "notes": "Block storage volume" },
-  { "category": "load_balancer", "aws": "aws_lb", "azure": "azurerm_lb", "gcp": "google_compute_forwarding_rule", "notes": "Load balancer" },
-  { "category": "nat_gateway", "aws": "aws_nat_gateway", "azure": "azurerm_nat_gateway", "gcp": "google_compute_router_nat", "notes": "NAT gateway" },
-  { "category": "kubernetes_cluster", "aws": "aws_eks_cluster", "azure": "azurerm_kubernetes_cluster", "gcp": "google_container_cluster", "notes": "Managed Kubernetes" },
-  { "category": "kubernetes_node_group", "aws": "aws_eks_node_group", "azure": "azurerm_kubernetes_cluster_node_pool", "gcp": "google_container_node_pool", "notes": "Kubernetes node pool" },
-  { "category": "dns_zone", "aws": "aws_route53_zone", "azure": "azurerm_dns_zone", "gcp": "google_dns_managed_zone", "notes": "DNS hosted zone" },
-  { "category": "cdn", "aws": "aws_cloudfront_distribution", "azure": "azurerm_cdn_profile", "gcp": "google_compute_backend_bucket", "notes": "CDN distribution" },
-  { "category": "redis_cache", "aws": "aws_elasticache_cluster", "azure": "azurerm_redis_cache", "gcp": "google_redis_instance", "notes": "Managed Redis" },
-  { "category": "container_registry", "aws": "aws_ecr_repository", "azure": "azurerm_container_registry", "gcp": "google_artifact_registry_repository", "notes": "Container registry" },
-  { "category": "secrets", "aws": "aws_secretsmanager_secret", "azure": "azurerm_key_vault", "gcp": "google_secret_manager_secret", "notes": "Secrets management" }
+  {
+    "category": "compute_instance",
+    "aws": "aws_instance",
+    "azure": "azurerm_linux_virtual_machine",
+    "gcp": "google_compute_instance",
+    "notes": "General purpose VM"
+  },
+  {
+    "category": "compute_instance_windows",
+    "aws": "aws_instance",
+    "azure": "azurerm_windows_virtual_machine",
+    "gcp": "google_compute_instance",
+    "notes": "Windows VM"
+  },
+  {
+    "category": "managed_database_postgres",
+    "aws": "aws_db_instance",
+    "azure": "azurerm_postgresql_flexible_server",
+    "gcp": "google_sql_database_instance",
+    "notes": "Managed PostgreSQL"
+  },
+  {
+    "category": "managed_database_mysql",
+    "aws": "aws_db_instance",
+    "azure": "azurerm_mysql_flexible_server",
+    "gcp": "google_sql_database_instance",
+    "notes": "Managed MySQL"
+  },
+  {
+    "category": "object_storage",
+    "aws": "aws_s3_bucket",
+    "azure": "azurerm_storage_account",
+    "gcp": "google_storage_bucket",
+    "notes": "Object storage"
+  },
+  {
+    "category": "block_storage",
+    "aws": "aws_ebs_volume",
+    "azure": "azurerm_managed_disk",
+    "gcp": "google_compute_disk",
+    "notes": "Block storage volume"
+  },
+  {
+    "category": "load_balancer",
+    "aws": "aws_lb",
+    "azure": "azurerm_lb",
+    "gcp": "google_compute_forwarding_rule",
+    "notes": "Load balancer"
+  },
+  {
+    "category": "nat_gateway",
+    "aws": "aws_nat_gateway",
+    "azure": "azurerm_nat_gateway",
+    "gcp": "google_compute_router_nat",
+    "notes": "NAT gateway"
+  },
+  {
+    "category": "kubernetes_cluster",
+    "aws": "aws_eks_cluster",
+    "azure": "azurerm_kubernetes_cluster",
+    "gcp": "google_container_cluster",
+    "notes": "Managed Kubernetes"
+  },
+  {
+    "category": "kubernetes_node_group",
+    "aws": "aws_eks_node_group",
+    "azure": "azurerm_kubernetes_cluster_node_pool",
+    "gcp": "google_container_node_pool",
+    "notes": "Kubernetes node pool"
+  },
+  {
+    "category": "dns_zone",
+    "aws": "aws_route53_zone",
+    "azure": "azurerm_dns_zone",
+    "gcp": "google_dns_managed_zone",
+    "notes": "DNS hosted zone"
+  },
+  {
+    "category": "cdn",
+    "aws": "aws_cloudfront_distribution",
+    "azure": "azurerm_cdn_profile",
+    "gcp": "google_compute_backend_bucket",
+    "notes": "CDN distribution"
+  },
+  {
+    "category": "redis_cache",
+    "aws": "aws_elasticache_cluster",
+    "azure": "azurerm_redis_cache",
+    "gcp": "google_redis_instance",
+    "notes": "Managed Redis"
+  },
+  {
+    "category": "container_registry",
+    "aws": "aws_ecr_repository",
+    "azure": "azurerm_container_registry",
+    "gcp": "google_artifact_registry_repository",
+    "notes": "Container registry"
+  },
+  {
+    "category": "secrets",
+    "aws": "aws_secretsmanager_secret",
+    "azure": "azurerm_key_vault",
+    "gcp": "google_secret_manager_secret",
+    "notes": "Secrets management"
+  },
+  {
+    "category": "api_gateway",
+    "aws": "aws_api_gateway_rest_api",
+    "azure": "azurerm_api_management",
+    "gcp": "google_apigateway_api",
+    "notes": "API Gateway / Management"
+  },
+  {
+    "category": "waf",
+    "aws": "aws_wafv2_web_acl",
+    "azure": "azurerm_web_application_firewall_policy",
+    "gcp": "google_compute_security_policy",
+    "notes": "Web Application Firewall"
+  },
+  {
+    "category": "search",
+    "aws": "aws_opensearch_domain",
+    "azure": "azurerm_search_service",
+    "gcp": "google_elasticsearch_domain",
+    "notes": "Managed search / OpenSearch"
+  },
+  {
+    "category": "messaging",
+    "aws": "aws_sns_topic",
+    "azure": "azurerm_servicebus_namespace",
+    "gcp": "google_pubsub_topic",
+    "notes": "Messaging / notifications"
+  },
+  {
+    "category": "ml_inference_endpoint",
+    "aws": "aws_sagemaker_endpoint",
+    "azure": "azurerm_machine_learning_inference_cluster",
+    "gcp": "google_vertex_ai_endpoint",
+    "notes": "ML/AI inference endpoint"
+  },
+  {
+    "category": "message_broker",
+    "aws": "aws_mq_broker",
+    "azure": "azurerm_eventhub_namespace",
+    "gcp": "google_pubsub_subscription",
+    "notes": "Message broker / event streaming"
+  },
+  {
+    "category": "redis_replication_group",
+    "aws": "aws_elasticache_replication_group",
+    "azure": "azurerm_redis_cache",
+    "gcp": "google_redis_instance",
+    "notes": "Redis replication / HA cache"
+  }
 ]

package/dist/{chunk-XDBTEI42.js → chunk-TRRAOOVF.js}

@@ -43,9 +43,7 @@ var _gcpDiskPricing = null;
 var _regionPriceMultipliers = null;
 function getResourceEquivalents() {
   if (_resourceEquivalents === null) {
-    _resourceEquivalents = loadJsonFile(
-      "resource-equivalents.json"
-    );
+    _resourceEquivalents = loadJsonFile("resource-equivalents.json");
   }
   return _resourceEquivalents;
 }
@@ -69,25 +67,19 @@ function getStorageMap() {
 }
 function getAwsInstances() {
   if (_awsInstances === null) {
-    _awsInstances = loadJsonFile(
-      "instance-types/aws-instances.json"
-    );
+    _awsInstances = loadJsonFile("instance-types/aws-instances.json");
   }
   return _awsInstances;
 }
 function getAzureVmSizes() {
   if (_azureVmSizes === null) {
-    _azureVmSizes = loadJsonFile(
-      "instance-types/azure-vm-sizes.json"
-    );
+    _azureVmSizes = loadJsonFile("instance-types/azure-vm-sizes.json");
   }
   return _azureVmSizes;
 }
 function getGcpMachineTypes() {
   if (_gcpMachineTypes === null) {
-    _gcpMachineTypes = loadJsonFile(
-      "instance-types/gcp-machine-types.json"
-    );
+    _gcpMachineTypes = loadJsonFile("instance-types/gcp-machine-types.json");
   }
   return _gcpMachineTypes;
 }
@@ -125,9 +117,7 @@ function getGcpDiskPricing() {
 }
 function getRegionPriceMultipliers() {
   if (_regionPriceMultipliers === null) {
-    _regionPriceMultipliers = loadJsonFile(
-      "region-price-multipliers.json"
-    );
+    _regionPriceMultipliers = loadJsonFile("region-price-multipliers.json");
   }
   return _regionPriceMultipliers;
 }
@@ -161,4 +151,4 @@ export {
   getRegionPriceMultipliers,
   _resetLoaderCache
 };
-//# sourceMappingURL=chunk-XDBTEI42.js.map
+//# sourceMappingURL=chunk-TRRAOOVF.js.map