@jadenrazo/cloudcost-mcp 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,25 +1,34 @@
 #!/usr/bin/env node
 import {
+  CostEngine,
   PricingCache,
   PricingEngine,
+  SUPPORTED_CURRENCIES,
   analyzeTerraform,
   analyzeTerraformSchema,
+  bool,
   compareProviders,
   compareProvidersSchema,
+  convertBreakdownCurrency,
+  convertCurrency,
   estimateCost,
   estimateCostSchema,
   loadConfig,
   logger,
   mapInstance,
+  mapRegion,
+  num,
   optimizeCost,
   optimizeCostSchema,
+  parseTerraform,
   setLogLevel,
+  str,
   whatIf,
   whatIfSchema
-} from "./chunk-EI63JCAA.js";
+} from "./chunk-VP34WG7Z.js";
 import {
   getResourceEquivalents
-} from "./chunk-XDBTEI42.js";
+} from "./chunk-TRRAOOVF.js";
 
 // src/server.ts
 import { createRequire } from "module";
@@ -35,17 +44,13 @@ function findEquivalent(resourceType, sourceProvider, targetProvider) {
     return resourceType;
   }
   const equivalents = getResourceEquivalents();
-  const row = equivalents.find(
-    (entry) => entry[sourceProvider] === resourceType
-  );
+  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
-  );
+  const row = equivalents.find((entry) => entry[sourceProvider] === resourceType);
   if (!row) return {};
   const result = {};
   const providers = ["aws", "azure", "gcp"];
@@ -60,9 +65,7 @@ function findAllEquivalents(resourceType, sourceProvider) {
 
 // src/tools/get-equivalents.ts
 var getEquivalentsSchema = z.object({
-  resource_type: z.string().describe(
-    "Terraform resource type to look up (e.g. aws_instance, google_compute_instance)"
-  ),
+  resource_type: z.string().describe("Terraform resource type to look up (e.g. aws_instance, google_compute_instance)"),
   source_provider: z.enum(["aws", "azure", "gcp"]).describe("Cloud provider the resource type belongs to"),
   target_provider: z.enum(["aws", "azure", "gcp"]).optional().describe(
     "Specific target provider. When omitted, equivalents for all providers are returned."
@@ -76,11 +79,7 @@ async function getEquivalents(params) {
   let resourceEquivalents;
   if (params.target_provider) {
     const targetProvider = params.target_provider;
-    const equivalent = findEquivalent(
-      params.resource_type,
-      sourceProvider,
-      targetProvider
-    );
+    const equivalent = findEquivalent(params.resource_type, sourceProvider, targetProvider);
     resourceEquivalents = { [targetProvider]: equivalent };
   } else {
     resourceEquivalents = findAllEquivalents(params.resource_type, sourceProvider);
@@ -91,29 +90,38 @@ async function getEquivalents(params) {
     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
-      );
+      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
-    } : {}
+  const filteredResourceEquivalents = Object.fromEntries(
+    Object.entries(resourceEquivalents).filter(([, v]) => v !== null)
+  );
+  const result = {
+    resource_equivalents: filteredResourceEquivalents
   };
+  if (instanceEquivalents !== void 0) {
+    const filteredInstanceEquivalents = Object.fromEntries(
+      Object.entries(instanceEquivalents).filter(([, v]) => v !== null)
+    );
+    result.instance_type = params.instance_type;
+    result.instance_equivalents = filteredInstanceEquivalents;
+  }
+  return result;
 }
 
 // src/tools/get-pricing.ts
 import { z as z2 } from "zod";
 var getPricingSchema = z2.object({
   provider: z2.enum(["aws", "azure", "gcp"]).describe("Cloud provider to look up pricing for"),
-  service: z2.enum(["compute", "database", "storage", "network", "load_balancer", "nat_gateway", "kubernetes"]).describe("Service category (network defaults to nat_gateway for backward compatibility)"),
+  service: z2.enum([
+    "compute",
+    "database",
+    "storage",
+    "network",
+    "load_balancer",
+    "nat_gateway",
+    "kubernetes"
+  ]).describe("Service category (network defaults to nat_gateway for backward compatibility)"),
   resource_type: z2.string().describe(
     "Instance type, storage type, or resource identifier (e.g. t3.large, gp3, Standard_D4s_v3)"
   ),
@@ -131,20 +139,828 @@ async function getPricing(params, pricingEngine) {
     kubernetes: "kubernetes"
   };
   const service = serviceMap[params.service] ?? params.service;
-  const price = await pricingEngine.getPrice(
+  const rawPrice = await pricingEngine.getPrice(
     provider,
     service,
     params.resource_type,
     params.region
   );
+  let price = null;
+  if (rawPrice !== null) {
+    const {
+      description: _d,
+      attributes,
+      ...priceRest
+    } = rawPrice;
+    price = { ...priceRest };
+    if (attributes && Object.keys(attributes).length > 0) {
+      price.attributes = attributes;
+    }
+  }
+  return { price };
+}
+
+// src/tools/analyze-plan.ts
+import { z as z3 } from "zod";
+
+// src/parsers/terraform/plan-parser.ts
+var PROVIDER_MAP = {
+  aws: "aws",
+  azurerm: "azure",
+  google: "gcp"
+};
+function detectProviderFromName(providerName) {
+  const segments = providerName.split("/");
+  const shortName = segments[segments.length - 1];
+  return PROVIDER_MAP[shortName] ?? "aws";
+}
+var DEFAULT_REGIONS = {
+  aws: "us-east-1",
+  azure: "eastus",
+  gcp: "us-central1"
+};
+function detectRegion(attrs, provider) {
+  if (!attrs) return DEFAULT_REGIONS[provider];
+  if (provider === "aws") {
+    const az = typeof attrs["availability_zone"] === "string" ? attrs["availability_zone"] : null;
+    if (az) {
+      return az.replace(/[a-z]$/, "");
+    }
+    const region = typeof attrs["region"] === "string" ? attrs["region"] : null;
+    if (region) return region;
+  }
+  if (provider === "azure") {
+    const loc = typeof attrs["location"] === "string" ? attrs["location"] : null;
+    if (loc) return loc;
+  }
+  if (provider === "gcp") {
+    const zone = typeof attrs["zone"] === "string" ? attrs["zone"] : null;
+    if (zone) {
+      const parts = zone.split("-");
+      return parts.length > 2 ? parts.slice(0, -1).join("-") : zone;
+    }
+    const region = typeof attrs["region"] === "string" ? attrs["region"] : null;
+    if (region) return region;
+  }
+  return DEFAULT_REGIONS[provider];
+}
+var ATTRIBUTE_KEYS = [
+  "instance_type",
+  "vm_size",
+  "machine_type",
+  "engine",
+  "engine_version",
+  "storage_type",
+  "iops",
+  "throughput_mbps",
+  "multi_az",
+  "replicas",
+  "node_count",
+  "min_node_count",
+  "max_node_count",
+  "os",
+  "tier",
+  "sku"
+];
+var STORAGE_SIZE_KEYS = ["size", "storage_size_gb", "disk_size_gb", "max_size_gb"];
+function extractAttributes(attrs) {
+  const result = {};
+  for (const key of ATTRIBUTE_KEYS) {
+    if (attrs[key] !== void 0 && attrs[key] !== null) {
+      result[key] = attrs[key];
+    }
+  }
+  for (const key of STORAGE_SIZE_KEYS) {
+    const val = attrs[key];
+    if (typeof val === "number" && val > 0) {
+      result.storage_size_gb = val;
+      break;
+    }
+  }
+  return result;
+}
+function extractTags(attrs) {
+  const tags = attrs["tags"];
+  if (!tags || typeof tags !== "object" || Array.isArray(tags)) return {};
+  const result = {};
+  for (const [k, v] of Object.entries(tags)) {
+    result[k] = String(v);
+  }
+  return result;
+}
+function buildResource(rc, attrs, provider, region) {
+  return {
+    id: rc.address,
+    type: rc.type,
+    name: rc.name,
+    provider,
+    region,
+    attributes: extractAttributes(attrs),
+    tags: extractTags(attrs),
+    source_file: "plan.json"
+  };
+}
+function classifyAction(actions) {
+  if (actions.length === 2) {
+    if (actions.includes("create") && actions.includes("delete")) {
+      return "replace";
+    }
+  }
+  if (actions.length === 1) {
+    const a = actions[0];
+    if (a === "create") return "create";
+    if (a === "delete") return "delete";
+    if (a === "update") return "update";
+    if (a === "no-op") return "no-op";
+    if (a === "read") return "no-op";
+  }
+  return "no-op";
+}
+function buildInventory(resources, warnings) {
+  const byType = {};
+  for (const r of resources) {
+    byType[r.type] = (byType[r.type] ?? 0) + 1;
+  }
+  const providerCounts = {};
+  for (const r of resources) {
+    providerCounts[r.provider] = (providerCounts[r.provider] ?? 0) + 1;
+  }
+  let dominant = "aws";
+  let max = 0;
+  for (const [p, c] of Object.entries(providerCounts)) {
+    if (c > max) {
+      max = c;
+      dominant = p;
+    }
+  }
+  const dominantResource = resources.find((r) => r.provider === dominant);
+  const region = dominantResource?.region ?? DEFAULT_REGIONS[dominant];
+  return {
+    provider: dominant,
+    region,
+    resources,
+    total_count: resources.length,
+    by_type: byType,
+    parse_warnings: warnings
+  };
+}
+function parseTerraformPlan(planJson) {
+  let plan;
+  try {
+    plan = JSON.parse(planJson);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid plan JSON: ${msg}`);
+  }
+  if (!Array.isArray(plan.resource_changes)) {
+    throw new Error("Invalid plan JSON: missing or non-array resource_changes field");
+  }
+  const beforeResources = [];
+  const afterResources = [];
+  const changes = [];
+  const warnings = [];
+  const summary = {
+    creates: 0,
+    updates: 0,
+    deletes: 0,
+    no_ops: 0,
+    replaces: 0
+  };
+  for (const rc of plan.resource_changes) {
+    const provider = detectProviderFromName(rc.provider_name);
+    const action = classifyAction(rc.change.actions);
+    const region = detectRegion(rc.change.after, provider) || detectRegion(rc.change.before, provider);
+    if (rc.change.before) {
+      beforeResources.push(buildResource(rc, rc.change.before, provider, region));
+    }
+    if (rc.change.after) {
+      afterResources.push(buildResource(rc, rc.change.after, provider, region));
+    }
+    changes.push({
+      address: rc.address,
+      type: rc.type,
+      action,
+      before_attributes: rc.change.before,
+      after_attributes: rc.change.after
+    });
+    switch (action) {
+      case "create":
+        summary.creates++;
+        break;
+      case "update":
+        summary.updates++;
+        break;
+      case "delete":
+        summary.deletes++;
+        break;
+      case "replace":
+        summary.replaces++;
+        break;
+      case "no-op":
+        summary.no_ops++;
+        break;
+    }
+  }
+  logger.debug("parseTerraformPlan complete", {
+    resourceChanges: plan.resource_changes.length,
+    summary
+  });
+  return {
+    before: buildInventory(beforeResources, warnings),
+    after: buildInventory(afterResources, warnings),
+    changes,
+    summary
+  };
+}
+
+// src/tools/analyze-plan.ts
+var analyzePlanSchema = z3.object({
+  plan_json: z3.string().describe("Output of 'terraform show -json <planfile>' or 'terraform plan -json'"),
+  provider: z3.enum(["aws", "azure", "gcp"]).optional().describe("Target provider for cost estimation. If omitted, auto-detected from plan."),
+  region: z3.string().optional().describe("Target region. If omitted, detected from plan resources."),
+  currency: z3.enum(SUPPORTED_CURRENCIES).optional().default("USD").describe("Output currency")
+});
+async function analyzePlan(params, pricingEngine, config) {
+  const analysis = parseTerraformPlan(params.plan_json);
+  const targetProvider = params.provider ?? analysis.after.provider;
+  const targetRegion = params.region ?? mapRegion(analysis.after.region, analysis.after.provider, targetProvider);
+  const costEngine = new CostEngine(pricingEngine, config);
+  const [beforeBreakdown, afterBreakdown] = await Promise.all([
+    analysis.before.resources.length > 0 ? costEngine.calculateBreakdown(analysis.before.resources, targetProvider, targetRegion) : null,
+    analysis.after.resources.length > 0 ? costEngine.calculateBreakdown(analysis.after.resources, targetProvider, targetRegion) : null
+  ]);
+  const currency = params.currency ?? "USD";
+  const warnings = [
+    ...analysis.before.parse_warnings,
+    ...analysis.after.parse_warnings,
+    ...beforeBreakdown?.warnings ?? [],
+    ...afterBreakdown?.warnings ?? []
+  ];
+  const beforeCostMap = /* @__PURE__ */ new Map();
+  if (beforeBreakdown) {
+    for (const est of beforeBreakdown.by_resource) {
+      beforeCostMap.set(est.resource_id, est.monthly_cost);
+    }
+  }
+  const afterCostMap = /* @__PURE__ */ new Map();
+  if (afterBreakdown) {
+    for (const est of afterBreakdown.by_resource) {
+      afterCostMap.set(est.resource_id, est.monthly_cost);
+    }
+  }
+  const resourceDiffs = [];
+  for (const change of analysis.changes) {
+    const beforeMonthly = beforeCostMap.get(change.address) ?? 0;
+    const afterMonthly = afterCostMap.get(change.address) ?? 0;
+    const delta = afterMonthly - beforeMonthly;
+    resourceDiffs.push({
+      address: change.address,
+      resource_type: change.type,
+      action: change.action,
+      before_monthly: round2(beforeMonthly),
+      after_monthly: round2(afterMonthly),
+      delta_monthly: round2(delta),
+      currency: "USD"
+    });
+  }
+  const totalBefore = beforeBreakdown?.total_monthly ?? 0;
+  const totalAfter = afterBreakdown?.total_monthly ?? 0;
+  let result = {
+    provider: targetProvider,
+    region: targetRegion,
+    currency: "USD",
+    total_before_monthly: round2(totalBefore),
+    total_after_monthly: round2(totalAfter),
+    total_delta_monthly: round2(totalAfter - totalBefore),
+    summary: analysis.summary,
+    resource_diffs: resourceDiffs,
+    warnings: [...new Set(warnings)]
+  };
+  if (currency !== "USD") {
+    result = applyResultCurrency(result, currency);
+  }
+  logger.debug("analyzePlan complete", {
+    provider: result.provider,
+    region: result.region,
+    totalBefore: result.total_before_monthly,
+    totalAfter: result.total_after_monthly,
+    delta: result.total_delta_monthly
+  });
+  return result;
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function applyResultCurrency(result, currency) {
+  return {
+    ...result,
+    currency,
+    total_before_monthly: round2(convertCurrency(result.total_before_monthly, currency)),
+    total_after_monthly: round2(convertCurrency(result.total_after_monthly, currency)),
+    total_delta_monthly: round2(convertCurrency(result.total_delta_monthly, currency)),
+    resource_diffs: result.resource_diffs.map((d) => ({
+      ...d,
+      currency,
+      before_monthly: round2(convertCurrency(d.before_monthly, currency)),
+      after_monthly: round2(convertCurrency(d.after_monthly, currency)),
+      delta_monthly: round2(convertCurrency(d.delta_monthly, currency))
+    }))
+  };
+}
+
+// src/tools/compare-actual.ts
+import { z as z4 } from "zod";
+
+// src/parsers/terraform/state-parser.ts
+var PROVIDER_MAP2 = {
+  aws: "aws",
+  azurerm: "azure",
+  google: "gcp",
+  "google-beta": "gcp"
+};
+function detectProviderFromString(providerAddr) {
+  const match = providerAddr.match(/\/([^"/]+)"\s*\]?\s*$/);
+  if (match) {
+    return PROVIDER_MAP2[match[1]];
+  }
+  for (const [key, value] of Object.entries(PROVIDER_MAP2)) {
+    if (providerAddr.includes(`/${key}"`) || providerAddr.includes(`/${key}]`)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+var PROVIDER_DEFAULTS = {
+  aws: "us-east-1",
+  azure: "eastus",
+  gcp: "us-central1"
+};
+function detectRegion2(attrs, provider) {
+  switch (provider) {
+    case "aws": {
+      const az = str(attrs["availability_zone"]);
+      if (az) return az.replace(/[a-z]$/, "");
+      const region = str(attrs["region"]);
+      if (region) return region;
+      return PROVIDER_DEFAULTS.aws;
+    }
+    case "azure": {
+      const location = str(attrs["location"]);
+      if (location) return location;
+      return PROVIDER_DEFAULTS.azure;
+    }
+    case "gcp": {
+      const zone = str(attrs["zone"]);
+      if (zone) {
+        const parts = zone.split("-");
+        return parts.length > 2 ? parts.slice(0, -1).join("-") : zone;
+      }
+      const region = str(attrs["region"]);
+      if (region) return region;
+      return PROVIDER_DEFAULTS.gcp;
+    }
+  }
+}
+function extractAttributes2(attrs, resourceType) {
+  const result = {};
+  if (str(attrs["instance_type"])) result.instance_type = str(attrs["instance_type"]);
+  if (str(attrs["instance_class"])) result.instance_type = str(attrs["instance_class"]);
+  if (str(attrs["vm_size"])) result.vm_size = str(attrs["vm_size"]);
+  if (str(attrs["machine_type"])) result.machine_type = str(attrs["machine_type"]);
+  if (str(attrs["engine"])) result.engine = str(attrs["engine"]);
+  if (str(attrs["engine_version"])) result.engine_version = str(attrs["engine_version"]);
+  if (attrs["multi_az"] !== void 0) result.multi_az = bool(attrs["multi_az"]);
+  if (attrs["replicas"] !== void 0) result.replicas = num(attrs["replicas"]);
+  if (str(attrs["storage_type"])) result.storage_type = str(attrs["storage_type"]);
+  if (attrs["allocated_storage"] !== void 0)
+    result.storage_size_gb = num(attrs["allocated_storage"]);
+  if (attrs["size"] !== void 0 && result.storage_size_gb === void 0)
+    result.storage_size_gb = num(attrs["size"]);
+  if (attrs["iops"] !== void 0) result.iops = num(attrs["iops"]);
+  if (attrs["throughput"] !== void 0) result.throughput_mbps = num(attrs["throughput"]);
+  if (str(attrs["tier"])) result.tier = str(attrs["tier"]);
+  if (str(attrs["sku"])) result.sku = str(attrs["sku"]);
+  if (str(attrs["sku_name"])) result.sku = str(attrs["sku_name"]);
+  if (attrs["node_count"] !== void 0) result.node_count = num(attrs["node_count"]);
+  if (attrs["min_node_count"] !== void 0) result.min_node_count = num(attrs["min_node_count"]);
+  if (attrs["max_node_count"] !== void 0) result.max_node_count = num(attrs["max_node_count"]);
+  if (str(attrs["os_type"])) result.os = str(attrs["os_type"]);
+  if (resourceType === "aws_ebs_volume" || resourceType === "aws_ebs_snapshot") {
+    if (str(attrs["type"]) && !result.storage_type) result.storage_type = str(attrs["type"]);
+  }
+  if (str(attrs["load_balancer_type"]))
+    result.load_balancer_type = str(attrs["load_balancer_type"]);
+  if (attrs["internal"] !== void 0) result.internal = bool(attrs["internal"]);
+  return result;
+}
+function extractTags2(attrs) {
+  const tags = attrs["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 parseTerraformState(stateJson) {
+  const warnings = [];
+  let state;
+  try {
+    state = JSON.parse(stateJson);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.error("Failed to parse Terraform state JSON", { error: msg });
+    return {
+      provider: "aws",
+      region: PROVIDER_DEFAULTS.aws,
+      resources: [],
+      total_count: 0,
+      by_type: {},
+      parse_warnings: [`Invalid state JSON: ${msg}`]
+    };
+  }
+  if (!Array.isArray(state.resources)) {
+    return {
+      provider: "aws",
+      region: PROVIDER_DEFAULTS.aws,
+      resources: [],
+      total_count: 0,
+      by_type: {},
+      parse_warnings: warnings
+    };
+  }
+  const allResources = [];
+  for (const block of state.resources) {
+    if (block.mode !== "managed") continue;
+    const provider = detectProviderFromString(block.provider);
+    if (!provider) {
+      warnings.push(
+        `Skipping resource "${block.type}.${block.name}": unknown provider "${block.provider}"`
+      );
+      continue;
+    }
+    if (!Array.isArray(block.instances)) continue;
+    for (const instance of block.instances) {
+      const attrs = instance.attributes ?? {};
+      const region = detectRegion2(attrs, provider);
+      const tags = extractTags2(attrs);
+      const attributes = extractAttributes2(attrs, block.type);
+      let id = `${block.type}.${block.name}`;
+      if (instance.index_key !== void 0) {
+        id += typeof instance.index_key === "number" ? `[${instance.index_key}]` : `["${instance.index_key}"]`;
+      }
+      allResources.push({
+        id,
+        type: block.type,
+        name: block.name,
+        provider,
+        region,
+        attributes,
+        tags,
+        source_file: "terraform.tfstate"
+      });
+    }
+  }
+  const providerCounts = {};
+  for (const r of allResources) {
+    providerCounts[r.provider] = (providerCounts[r.provider] ?? 0) + 1;
+  }
+  let dominantProvider = "aws";
+  let maxCount = 0;
+  for (const [p, c] of Object.entries(providerCounts)) {
+    if (c > maxCount) {
+      maxCount = c;
+      dominantProvider = p;
+    }
+  }
+  const dominantRegion = allResources.find((r) => r.provider === dominantProvider)?.region ?? PROVIDER_DEFAULTS[dominantProvider];
+  const byType = {};
+  for (const r of allResources) {
+    byType[r.type] = (byType[r.type] ?? 0) + 1;
+  }
+  logger.info("Terraform state parse complete", {
+    resourceCount: allResources.length,
+    provider: dominantProvider,
+    region: dominantRegion,
+    warningCount: warnings.length
+  });
+  return {
+    provider: dominantProvider,
+    region: dominantRegion,
+    resources: allResources,
+    total_count: allResources.length,
+    by_type: byType,
+    parse_warnings: warnings
+  };
+}
+
+// src/tools/compare-actual.ts
+var compareActualSchema = z4.object({
+  state_json: z4.string().describe("Contents of terraform.tfstate file (JSON)"),
+  files: z4.array(
+    z4.object({
+      path: z4.string().describe("File path"),
+      content: z4.string().describe("File content (HCL)")
+    })
+  ).optional().describe("Optional Terraform files to compare planned costs against actual"),
+  tfvars: z4.string().optional().describe("Contents of terraform.tfvars file"),
+  provider: z4.enum(["aws", "azure", "gcp"]).optional().describe("Target cloud provider override. Defaults to auto-detecting from the state."),
+  region: z4.string().optional().describe(
+    "Target region override for pricing. Defaults to the region detected from the state."
+  ),
+  currency: z4.enum(SUPPORTED_CURRENCIES).optional().default("USD").describe("Output currency for cost estimates. Defaults to USD.")
+});
+async function compareActual(params, pricingEngine, config) {
+  const warnings = [];
+  const stateInventory = parseTerraformState(params.state_json);
+  warnings.push(...stateInventory.parse_warnings);
+  const targetProvider = params.provider ?? stateInventory.provider;
+  const targetRegion = params.region ?? stateInventory.region;
+  const costEngine = new CostEngine(pricingEngine, config);
+  const actualBreakdown = await costEngine.calculateBreakdown(
+    stateInventory.resources,
+    targetProvider,
+    targetRegion
+  );
+  warnings.push(...actualBreakdown.warnings ?? []);
+  const actualByResource = actualBreakdown.by_resource.map((r) => ({
+    resource_id: r.resource_id,
+    resource_type: r.resource_type,
+    monthly_cost: Math.round(r.monthly_cost * 100) / 100
+  }));
+  const currency = params.currency ?? "USD";
+  const result = {
+    provider: targetProvider,
+    region: targetRegion,
+    currency,
+    actual_costs: {
+      total_monthly: Math.round(actualBreakdown.total_monthly * 100) / 100,
+      total_yearly: Math.round(actualBreakdown.total_monthly * 12 * 100) / 100,
+      resource_count: stateInventory.total_count,
+      by_resource: actualByResource
+    },
+    warnings: []
+  };
+  if (params.files && params.files.length > 0) {
+    const plannedInventory = await parseTerraform(params.files, params.tfvars);
+    warnings.push(...plannedInventory.parse_warnings);
+    const plannedProvider = params.provider ?? plannedInventory.provider;
+    const plannedRegion = params.region ?? mapRegion(plannedInventory.region, plannedInventory.provider, plannedProvider);
+    const plannedBreakdown = await costEngine.calculateBreakdown(
+      plannedInventory.resources,
+      plannedProvider,
+      plannedRegion
+    );
+    warnings.push(...plannedBreakdown.warnings ?? []);
+    const plannedByResource = plannedBreakdown.by_resource.map((r) => ({
+      resource_id: r.resource_id,
+      resource_type: r.resource_type,
+      monthly_cost: Math.round(r.monthly_cost * 100) / 100
+    }));
+    result.planned_costs = {
+      total_monthly: Math.round(plannedBreakdown.total_monthly * 100) / 100,
+      total_yearly: Math.round(plannedBreakdown.total_monthly * 12 * 100) / 100,
+      resource_count: plannedInventory.total_count,
+      by_resource: plannedByResource
+    };
+    const deltaMonthly = result.actual_costs.total_monthly - result.planned_costs.total_monthly;
+    const deltaYearly = result.actual_costs.total_yearly - result.planned_costs.total_yearly;
+    const pctChange = result.planned_costs.total_monthly === 0 ? result.actual_costs.total_monthly === 0 ? 0 : 100 : Math.round(deltaMonthly / result.planned_costs.total_monthly * 1e4) / 100;
+    result.delta = {
+      monthly: Math.round(deltaMonthly * 100) / 100,
+      yearly: Math.round(deltaYearly * 100) / 100,
+      pct_change: pctChange
+    };
+  }
+  if (currency !== "USD") {
+    const actualConverted = convertBreakdownCurrency(actualBreakdown, currency);
+    result.actual_costs.total_monthly = Math.round(actualConverted.total_monthly * 100) / 100;
+    result.actual_costs.total_yearly = Math.round(actualConverted.total_monthly * 12 * 100) / 100;
+    result.actual_costs.by_resource = actualConverted.by_resource.map((r) => ({
+      resource_id: r.resource_id,
+      resource_type: r.resource_type,
+      monthly_cost: Math.round(r.monthly_cost * 100) / 100
+    }));
+    if (result.planned_costs && result.delta) {
+      const deltaMonthly = result.actual_costs.total_monthly - result.planned_costs.total_monthly;
+      result.delta.monthly = Math.round(deltaMonthly * 100) / 100;
+      result.delta.yearly = Math.round(deltaMonthly * 12 * 100) / 100;
+    }
+  }
+  result.warnings = [...new Set(warnings)];
+  return result;
+}
+
+// src/tools/price-trends.ts
+import { z as z5 } from "zod";
+var priceTrendsSchema = z5.object({
+  provider: z5.enum(["aws", "azure", "gcp"]).describe("Cloud provider"),
+  service: z5.string().describe("Service category (e.g., ec2, rds, virtual-machines)"),
+  resource_type: z5.string().describe("Resource type (e.g., t3.large, Standard_D2s_v5)"),
+  region: z5.string().describe("Cloud region"),
+  limit: z5.number().optional().default(30).describe("Max number of price points to return"),
+  since: z5.string().optional().describe("ISO date to start from (e.g., 2024-01-01)")
+});
+function priceTrends(params, cache) {
+  const { provider, service, resource_type, region, limit, since } = params;
+  const history = cache.getPriceHistory(provider, service, resource_type, region, {
+    limit,
+    since
+  });
+  const priceChange = cache.getPriceChange(provider, service, resource_type, region);
+  const currentPrice = history.length > 0 ? { price_per_unit: history[0].price_per_unit, unit: history[0].unit } : null;
   return {
     provider,
-    service: params.service,
-    resource_type: params.resource_type,
-    region: params.region,
-    price
+    service,
+    resource_type,
+    region,
+    current_price: currentPrice,
+    price_history: history,
+    price_change: priceChange,
+    data_points: history.length
+  };
+}
+
+// src/tools/detect-anomalies.ts
+import { z as z6 } from "zod";
+var detectAnomaliesSchema = z6.object({
+  files: z6.array(
+    z6.object({
+      path: z6.string().describe("File path"),
+      content: z6.string().describe("File content")
+    })
+  ),
+  tfvars: z6.string().optional().describe("Variable overrides"),
+  provider: z6.enum(["aws", "azure", "gcp"]).describe("Target cloud provider"),
+  region: z6.string().optional().describe("Target region"),
+  currency: z6.enum(SUPPORTED_CURRENCIES).optional().default("USD").describe("Output currency for cost estimates. Defaults to USD."),
+  budget_monthly: z6.number().optional().describe("Monthly budget threshold in USD"),
+  budget_per_resource: z6.number().optional().describe("Per-resource cost threshold in USD"),
+  price_change_threshold: z6.number().optional().default(10).describe("Alert on price changes exceeding this percentage")
+});
+var MIN_VCPUS_FOR_OVERSIZING = 8;
+function isOversizedInstance(instanceType) {
+  if (!instanceType) return false;
+  if (/xlarge/i.test(instanceType)) return true;
+  const azureMatch = instanceType.match(/Standard_[A-Z](\d+)s?_v\d+/i);
+  if (azureMatch) {
+    const vcpus = parseInt(azureMatch[1], 10);
+    return vcpus >= MIN_VCPUS_FOR_OVERSIZING;
+  }
+  const gcpMatch = instanceType.match(/(?:n1|n2|n2d|c2|e2)-(?:standard|highmem|highcpu)-(\d+)/);
+  if (gcpMatch) {
+    const vcpus = parseInt(gcpMatch[1], 10);
+    return vcpus >= MIN_VCPUS_FOR_OVERSIZING;
+  }
+  return false;
+}
+function serviceLabelForType(resourceType) {
+  if (resourceType.startsWith("aws_instance") || resourceType.startsWith("aws_eks_node_group"))
+    return "ec2";
+  if (resourceType.startsWith("azurerm_linux_virtual_machine") || resourceType.startsWith("azurerm_windows_virtual_machine"))
+    return "virtual-machines";
+  if (resourceType.startsWith("google_compute_instance") || resourceType.startsWith("google_container_node_pool"))
+    return "compute-engine";
+  if (resourceType.includes("db_instance") || resourceType.includes("sql_database") || resourceType.includes("postgresql") || resourceType.includes("mysql") || resourceType.includes("mssql"))
+    return "database";
+  if (resourceType.includes("s3") || resourceType.includes("storage_account") || resourceType.includes("storage_bucket"))
+    return "storage";
+  return "general";
+}
+async function detectAnomalies(params, pricingEngine, cache, 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 totalMonthly = breakdown.total_monthly;
+  const byResource = breakdown.by_resource;
+  const anomalies = [];
+  const recommendations = [];
+  if (params.budget_monthly != null && totalMonthly > params.budget_monthly) {
+    anomalies.push({
+      type: "budget_exceeded",
+      severity: "high",
+      resource: "_total",
+      resource_type: "aggregate",
+      message: `Total monthly cost $${totalMonthly.toFixed(2)} exceeds budget of $${params.budget_monthly.toFixed(2)}`,
+      details: {
+        current_cost: totalMonthly,
+        threshold: params.budget_monthly
+      }
+    });
+    recommendations.push(
+      `Total monthly cost exceeds budget by $${(totalMonthly - params.budget_monthly).toFixed(2)}. Consider right-sizing or removing unused resources.`
+    );
+  }
+  for (const est of byResource) {
+    if (params.budget_per_resource != null && est.monthly_cost > params.budget_per_resource) {
+      anomalies.push({
+        type: "budget_exceeded",
+        severity: "high",
+        resource: est.resource_id,
+        resource_type: est.resource_type,
+        message: `Resource ${est.resource_id} costs $${est.monthly_cost.toFixed(2)}/mo, exceeding per-resource budget of $${params.budget_per_resource.toFixed(2)}`,
+        details: {
+          current_cost: est.monthly_cost,
+          threshold: params.budget_per_resource
+        }
+      });
+    }
+  }
+  const priceChangeThreshold = params.price_change_threshold ?? 10;
+  for (const est of byResource) {
+    const service = serviceLabelForType(est.resource_type);
+    const instanceType = resolveInstanceType(est);
+    const resourceKey = instanceType ?? est.resource_type;
+    const priceChange = cache.getPriceChange(targetProvider, service, resourceKey, targetRegion);
+    if (priceChange && Math.abs(priceChange.change_percent) > priceChangeThreshold) {
+      const direction = priceChange.change_percent > 0 ? "increased" : "decreased";
+      anomalies.push({
+        type: "price_change",
+        severity: Math.abs(priceChange.change_percent) > 20 ? "high" : "medium",
+        resource: est.resource_id,
+        resource_type: est.resource_type,
+        message: `Pricing for ${est.resource_id} has ${direction} by ${Math.abs(priceChange.change_percent).toFixed(1)}%`,
+        details: {
+          current_cost: est.monthly_cost,
+          price_change_percent: priceChange.change_percent
+        }
+      });
+      recommendations.push(
+        `Review pricing change for ${est.resource_id} (${Math.abs(priceChange.change_percent).toFixed(1)}% ${direction}). Consider locking in reserved pricing.`
+      );
+    }
+  }
+  if (totalMonthly > 0) {
+    for (const est of byResource) {
+      const sharePercent = est.monthly_cost / totalMonthly * 100;
+      if (sharePercent > 50 && byResource.length > 1) {
+        anomalies.push({
+          type: "cost_concentration",
+          severity: "medium",
+          resource: est.resource_id,
+          resource_type: est.resource_type,
+          message: `Resource ${est.resource_id} accounts for ${sharePercent.toFixed(1)}% of total cost (concentration risk)`,
+          details: {
+            current_cost: est.monthly_cost,
+            cost_share_percent: sharePercent
+          }
+        });
+        recommendations.push(
+          `${est.resource_id} dominates total spend at ${sharePercent.toFixed(1)}%. Evaluate whether workload can be distributed or right-sized.`
+        );
+      }
+    }
+  }
+  for (const est of byResource) {
+    const instanceType = resolveInstanceType(est);
+    if (isOversizedInstance(instanceType)) {
+      anomalies.push({
+        type: "potential_oversizing",
+        severity: "low",
+        resource: est.resource_id,
+        resource_type: est.resource_type,
+        message: `Instance ${est.resource_id} uses ${instanceType} which may be over-provisioned`,
+        details: {
+          current_cost: est.monthly_cost
+        }
+      });
+      recommendations.push(
+        `Consider whether ${est.resource_id} (${instanceType}) needs all allocated resources. Smaller instance types can significantly reduce cost.`
+      );
+    }
+  }
+  const high = anomalies.filter((a) => a.severity === "high").length;
+  const medium = anomalies.filter((a) => a.severity === "medium").length;
+  const low = anomalies.filter((a) => a.severity === "low").length;
+  return {
+    total_monthly: totalMonthly,
+    anomalies,
+    summary: {
+      total_resources: byResource.length,
+      anomaly_count: anomalies.length,
+      high_severity: high,
+      medium_severity: medium,
+      low_severity: low
+    },
+    recommendations: [...new Set(recommendations)]
   };
 }
+function resolveInstanceType(est) {
+  for (const item of est.breakdown) {
+    const match = item.description.match(
+      /\b(t[23]\.\w+|m[5-7]\.\w+|c[5-7]\.\w+|r[5-7]\.\w+|Standard_\w+|n[12]d?-\w+-\d+|c2-\w+-\d+|e2-\w+-\d+)\b/i
+    );
+    if (match) return match[1];
+  }
+  return void 0;
+}
 
 // src/tools/index.ts
 function registerTools(server, config) {
@@ -157,7 +973,7 @@ function registerTools(server, config) {
     async (params) => {
       const result = await analyzeTerraform(params);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
@@ -168,7 +984,7 @@ function registerTools(server, config) {
     async (params) => {
       const result = await estimateCost(params, pricingEngine, config);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
@@ -179,7 +995,7 @@ function registerTools(server, config) {
     async (params) => {
       const result = await compareProviders(params, pricingEngine, config);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
@@ -190,7 +1006,7 @@ function registerTools(server, config) {
     async (params) => {
       const result = await getEquivalents(params);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
@@ -201,7 +1017,7 @@ function registerTools(server, config) {
     async (params) => {
       const result = await getPricing(params, pricingEngine);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
@@ -212,7 +1028,7 @@ function registerTools(server, config) {
     async (params) => {
       const result = await optimizeCost(params, pricingEngine, config);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );
@@ -223,7 +1039,51 @@ function registerTools(server, config) {
     async (params) => {
       const result = await whatIf(params, pricingEngine, config);
       return {
-        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  server.tool(
+    "analyze_plan",
+    "Parse Terraform plan JSON (from 'terraform show -json' or 'terraform plan -json') and return a cost-of-change analysis showing before/after costs and per-resource deltas.",
+    analyzePlanSchema.shape,
+    async (params) => {
+      const result = await analyzePlan(params, pricingEngine, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  server.tool(
+    "compare_actual",
+    "Parse a Terraform state file (.tfstate) and calculate actual infrastructure costs. Optionally compare against planned costs from HCL files to show drift.",
+    compareActualSchema.shape,
+    async (params) => {
+      const result = await compareActual(params, pricingEngine, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  server.tool(
+    "price_trends",
+    "Query historical pricing trends for a specific cloud resource. Returns recorded price history, the most recent price change, and summary metadata.",
+    priceTrendsSchema.shape,
+    (params) => {
+      const result = priceTrends(params, cache);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
+      };
+    }
+  );
+  server.tool(
+    "detect_anomalies",
+    "Analyze infrastructure costs and flag anomalies \u2014 resources whose estimated costs are unusual compared to historical baselines or configured thresholds.",
+    detectAnomaliesSchema.shape,
+    async (params) => {
+      const result = await detectAnomalies(params, pricingEngine, cache, config);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }]
       };
     }
   );