@jadenrazo/cloudcost-mcp 0.2.0 → 0.3.0

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

@@ -40,6 +40,7 @@ var _gcpComputePricing = null;
 var _gcpSqlPricing = null;
 var _gcpStoragePricing = null;
 var _gcpDiskPricing = null;
+var _regionPriceMultipliers = null;
 function getResourceEquivalents() {
   if (_resourceEquivalents === null) {
     _resourceEquivalents = loadJsonFile(
@@ -122,6 +123,14 @@ function getGcpDiskPricing() {
   }
   return _gcpDiskPricing;
 }
+function getRegionPriceMultipliers() {
+  if (_regionPriceMultipliers === null) {
+    _regionPriceMultipliers = loadJsonFile(
+      "region-price-multipliers.json"
+    );
+  }
+  return _regionPriceMultipliers;
+}
 function _resetLoaderCache() {
   _resourceEquivalents = null;
   _instanceMap = null;
@@ -134,6 +143,7 @@ function _resetLoaderCache() {
   _gcpSqlPricing = null;
   _gcpStoragePricing = null;
   _gcpDiskPricing = null;
+  _regionPriceMultipliers = null;
 }
 
 export {
@@ -148,6 +158,7 @@ export {
   getGcpSqlPricing,
   getGcpStoragePricing,
   getGcpDiskPricing,
+  getRegionPriceMultipliers,
   _resetLoaderCache
 };
-//# sourceMappingURL=chunk-KZJSZMWM.js.map
+//# sourceMappingURL=chunk-XDBTEI42.js.map

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,345 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+import {
+  PricingCache,
+  PricingEngine,
+  analyzeTerraform,
+  compareProviders,
+  estimateCost,
+  loadConfig,
+  optimizeCost,
+  whatIf
+} from "./chunk-EI63JCAA.js";
+import "./chunk-XDBTEI42.js";
+
+// src/cli.ts
+import { readFileSync, existsSync, statSync } from "fs";
+import { resolve, extname, join } from "path";
+import { readdirSync } from "fs";
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const parsed = {
+    command: void 0,
+    path: void 0,
+    provider: "aws",
+    region: void 0,
+    format: "markdown",
+    providers: ["aws", "azure", "gcp"],
+    changes: void 0,
+    json: false,
+    help: false
+  };
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+    } else if (arg === "--json") {
+      parsed.json = true;
+    } else if (arg === "--provider" && args[i + 1]) {
+      parsed.provider = args[++i];
+    } else if (arg === "--region" && args[i + 1]) {
+      parsed.region = args[++i];
+    } else if (arg === "--format" && args[i + 1]) {
+      parsed.format = args[++i];
+    } else if (arg === "--providers" && args[i + 1]) {
+      parsed.providers = args[++i].split(",").map((p) => p.trim());
+    } else if (arg === "--changes" && args[i + 1]) {
+      parsed.changes = args[++i];
+    } else if (!arg.startsWith("--")) {
+      if (!parsed.command) {
+        parsed.command = arg;
+      } else if (!parsed.path) {
+        parsed.path = arg;
+      }
+    }
+    i++;
+  }
+  return parsed;
+}
+function loadTerraformFiles(inputPath) {
+  const resolved = resolve(inputPath);
+  if (!existsSync(resolved)) {
+    throw new Error(`Path not found: ${resolved}`);
+  }
+  const stat = statSync(resolved);
+  if (stat.isFile()) {
+    return [
+      {
+        path: resolved,
+        content: readFileSync(resolved, "utf-8")
+      }
+    ];
+  }
+  if (stat.isDirectory()) {
+    const entries = readdirSync(resolved);
+    const tfFiles = entries.filter((e) => extname(e) === ".tf" || extname(e) === ".tofu").map((e) => join(resolved, e));
+    if (tfFiles.length === 0) {
+      throw new Error(`No .tf or .tofu files found in directory: ${resolved}`);
+    }
+    return tfFiles.map((f) => ({
+      path: f,
+      content: readFileSync(f, "utf-8")
+    }));
+  }
+  throw new Error(`Path is neither a file nor directory: ${resolved}`);
+}
+function loadTfvars(inputPath) {
+  const dir = statSync(resolve(inputPath)).isDirectory() ? resolve(inputPath) : resolve(inputPath, "..");
+  const tfvarsPath = join(dir, "terraform.tfvars");
+  if (existsSync(tfvarsPath)) {
+    return readFileSync(tfvarsPath, "utf-8");
+  }
+  return void 0;
+}
+function printJson(data) {
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printText(data) {
+  if (typeof data === "string") {
+    process.stdout.write(data + "\n");
+    return;
+  }
+  process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+}
+function printUsage() {
+  process.stdout.write(`
+CloudCost \u2014 multi-cloud Terraform cost estimator
+
+Usage:
+  cloudcost analyze <path>                       Parse Terraform and show resource inventory
+  cloudcost estimate <path> [options]            Estimate costs on a specific provider
+  cloudcost compare <path> [options]             Compare costs across all providers
+  cloudcost optimize <path> [options]            Show cost optimization recommendations
+  cloudcost what-if <path> --changes <file>      Simulate attribute changes and show cost impact
+
+Options:
+  --provider <aws|azure|gcp>                     Target provider (default: aws)
+  --region <region>                              Target region (default: auto-detect)
+  --format <markdown|json|csv>                   Report format for compare (default: markdown)
+  --providers <aws,azure,gcp>                    Comma-separated providers for compare/optimize
+  --changes <path>                               JSON file with changes array for what-if
+  --json                                         Output raw JSON
+  --help, -h                                     Show this help
+
+Examples:
+  cloudcost analyze ./terraform
+  cloudcost estimate ./terraform --provider aws --region us-east-1
+  cloudcost compare ./terraform --format markdown
+  cloudcost optimize ./terraform --providers aws,gcp
+  cloudcost estimate main.tf --provider gcp --json
+  cloudcost what-if ./terraform --changes changes.json --provider aws
+`.trimStart());
+}
+async function runAnalyze(args, files, tfvars) {
+  const result = await analyzeTerraform({ files, tfvars, include_dependencies: false });
+  if (args.json) {
+    printJson(result);
+  } else {
+    printText(result);
+  }
+}
+async function runEstimate(args, files, tfvars, pricingEngine, config) {
+  const validProviders = ["aws", "azure", "gcp"];
+  if (!validProviders.includes(args.provider)) {
+    throw new Error(`Invalid provider "${args.provider}". Must be one of: aws, azure, gcp`);
+  }
+  const result = await estimateCost(
+    {
+      files,
+      tfvars,
+      provider: args.provider,
+      region: args.region,
+      currency: "USD"
+    },
+    pricingEngine,
+    config
+  );
+  if (args.json) {
+    printJson(result);
+  } else {
+    printText(result);
+  }
+}
+async function runCompare(args, files, tfvars, pricingEngine, config) {
+  const validFormats = ["markdown", "json", "csv"];
+  if (!validFormats.includes(args.format)) {
+    throw new Error(`Invalid format "${args.format}". Must be one of: markdown, json, csv`);
+  }
+  const validatedProviders = args.providers.filter(
+    (p) => p === "aws" || p === "azure" || p === "gcp"
+  );
+  const result = await compareProviders(
+    {
+      files,
+      tfvars,
+      format: args.format,
+      currency: "USD",
+      providers: validatedProviders.length > 0 ? validatedProviders : ["aws", "azure", "gcp"]
+    },
+    pricingEngine,
+    config
+  );
+  if (args.json) {
+    printJson(result);
+  } else {
+    const obj = result;
+    if (typeof obj["report"] === "string") {
+      printText(obj["report"]);
+    } else {
+      printText(result);
+    }
+  }
+}
+async function runOptimize(args, files, tfvars, pricingEngine, config) {
+  const validatedProviders = args.providers.filter(
+    (p) => p === "aws" || p === "azure" || p === "gcp"
+  );
+  const result = await optimizeCost(
+    {
+      files,
+      tfvars,
+      providers: validatedProviders.length > 0 ? validatedProviders : ["aws", "azure", "gcp"]
+    },
+    pricingEngine,
+    config
+  );
+  if (args.json) {
+    printJson(result);
+  } else {
+    printText(result);
+  }
+}
+async function runWhatIf(args, files, tfvars, pricingEngine, config) {
+  if (!args.changes) {
+    throw new Error(
+      'The what-if command requires --changes <path> pointing to a JSON file with a "changes" array'
+    );
+  }
+  const changesPath = resolve(args.changes);
+  if (!existsSync(changesPath)) {
+    throw new Error(`Changes file not found: ${changesPath}`);
+  }
+  let parsedChanges;
+  try {
+    parsedChanges = JSON.parse(readFileSync(changesPath, "utf-8"));
+  } catch (err) {
+    throw new Error(
+      `Failed to parse changes file "${changesPath}": ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let changesArray;
+  if (Array.isArray(parsedChanges)) {
+    changesArray = parsedChanges;
+  } else if (parsedChanges !== null && typeof parsedChanges === "object" && "changes" in parsedChanges && Array.isArray(parsedChanges["changes"])) {
+    changesArray = parsedChanges["changes"];
+  } else {
+    throw new Error(
+      `Changes file must contain a JSON array or an object with a "changes" array`
+    );
+  }
+  const changes = changesArray.map((item, index) => {
+    if (item === null || typeof item !== "object") {
+      throw new Error(`Change at index ${index} must be an object`);
+    }
+    const c = item;
+    if (typeof c["resource_id"] !== "string" || !c["resource_id"]) {
+      throw new Error(`Change at index ${index} is missing a valid "resource_id"`);
+    }
+    if (typeof c["attribute"] !== "string" || !c["attribute"]) {
+      throw new Error(`Change at index ${index} is missing a valid "attribute"`);
+    }
+    if (typeof c["new_value"] !== "string" && typeof c["new_value"] !== "number") {
+      throw new Error(
+        `Change at index ${index} "new_value" must be a string or number`
+      );
+    }
+    return {
+      resource_id: c["resource_id"],
+      attribute: c["attribute"],
+      new_value: c["new_value"]
+    };
+  });
+  const validProviders = ["aws", "azure", "gcp"];
+  const provider = validProviders.includes(args.provider) ? args.provider : void 0;
+  const result = await whatIf(
+    {
+      files,
+      tfvars,
+      changes,
+      provider,
+      region: args.region
+    },
+    pricingEngine,
+    config
+  );
+  if (args.json) {
+    printJson(result);
+  } else {
+    printText(result);
+  }
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help || !args.command) {
+    printUsage();
+    process.exit(args.help ? 0 : 1);
+  }
+  const validCommands = ["analyze", "estimate", "compare", "optimize", "what-if"];
+  if (!validCommands.includes(args.command)) {
+    process.stderr.write(`Unknown command: ${args.command}
+`);
+    printUsage();
+    process.exit(1);
+  }
+  if (!args.path) {
+    process.stderr.write(`Error: path argument is required
+`);
+    printUsage();
+    process.exit(1);
+  }
+  let files;
+  let tfvars;
+  try {
+    files = loadTerraformFiles(args.path);
+    tfvars = loadTfvars(args.path);
+  } catch (err) {
+    process.stderr.write(`Error loading Terraform files: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const cache = new PricingCache(config.cache.db_path);
+  const pricingEngine = new PricingEngine(cache, config);
+  try {
+    switch (args.command) {
+      case "analyze":
+        await runAnalyze(args, files, tfvars);
+        break;
+      case "estimate":
+        await runEstimate(args, files, tfvars, pricingEngine, config);
+        break;
+      case "compare":
+        await runCompare(args, files, tfvars, pricingEngine, config);
+        break;
+      case "optimize":
+        await runOptimize(args, files, tfvars, pricingEngine, config);
+        break;
+      case "what-if":
+        await runWhatIf(args, files, tfvars, pricingEngine, config);
+        break;
+    }
+  } catch (err) {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  } finally {
+    cache.close();
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map