@jadenrazo/cloudcost-mcp 1.0.0 → 1.2.0

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

@@ -121,6 +121,34 @@ function getRegionPriceMultipliers() {
   }
   return _regionPriceMultipliers;
 }
+var _fallbackMeta = {};
+function getFallbackMetadata(provider) {
+  if (_fallbackMeta[provider] !== void 0) return _fallbackMeta[provider];
+  const relPath = `${provider}-pricing/metadata.json`;
+  try {
+    _fallbackMeta[provider] = loadJsonFile(relPath);
+  } catch {
+    _fallbackMeta[provider] = null;
+  }
+  return _fallbackMeta[provider];
+}
+var FRESH_MAX_AGE_DAYS = 14;
+var AGING_MAX_AGE_DAYS = 45;
+var MS_PER_DAY = 864e5;
+function getPricingMetadata(provider, now = /* @__PURE__ */ new Date()) {
+  const meta = getFallbackMetadata(provider);
+  const source = meta?.source ?? "unknown";
+  if (!meta?.last_updated) {
+    return { source, as_of: null, age_days: null, staleness: "stale" };
+  }
+  const asOf = new Date(meta.last_updated);
+  if (Number.isNaN(asOf.getTime())) {
+    return { source, as_of: meta.last_updated, age_days: null, staleness: "stale" };
+  }
+  const ageDays = Math.max(0, Math.floor((now.getTime() - asOf.getTime()) / MS_PER_DAY));
+  const staleness = ageDays < FRESH_MAX_AGE_DAYS ? "fresh" : ageDays < AGING_MAX_AGE_DAYS ? "aging" : "stale";
+  return { source, as_of: meta.last_updated, age_days: ageDays, staleness };
+}
 function _resetLoaderCache() {
   _resourceEquivalents = null;
   _instanceMap = null;
@@ -149,6 +177,8 @@ export {
   getGcpStoragePricing,
   getGcpDiskPricing,
   getRegionPriceMultipliers,
+  getFallbackMetadata,
+  getPricingMetadata,
   _resetLoaderCache
 };
-//# sourceMappingURL=chunk-TRRAOOVF.js.map
+//# sourceMappingURL=chunk-LWTVE7UY.js.map

package/dist/cli.d.ts

@@ -1 +1,42 @@
 #!/usr/bin/env node
+/**
+ * CloudCost MCP CLI
+ *
+ * Standalone command-line interface for the CloudCost MCP server tools.
+ *
+ * Usage:
+ *   cloudcost analyze <path>
+ *   cloudcost estimate <path> [--provider aws|azure|gcp] [--region <region>] [--currency <code>]
+ *   cloudcost compare <path> [--format markdown|json|csv|focus] [--currency <code>]
+ *   cloudcost optimize <path> [--providers aws,azure,gcp]
+ *   cloudcost what-if <path> --changes <changes.json> [--provider aws|azure|gcp] [--region <region>]
+ *
+ * Flags:
+ *   --json        Output raw JSON instead of formatted text
+ *   --help, -h    Show usage
+ */
+interface ParsedArgs {
+    command: string | undefined;
+    path: string | undefined;
+    provider: string;
+    region: string | undefined;
+    format: string;
+    providers: string[];
+    currency: string;
+    changes: string | undefined;
+    json: boolean;
+    help: boolean;
+}
+declare const VALID_PROVIDERS: readonly ["aws", "azure", "gcp"];
+type ValidProvider = (typeof VALID_PROVIDERS)[number];
+declare const VALID_FORMATS: readonly ["markdown", "json", "csv", "focus"];
+type ValidFormat = (typeof VALID_FORMATS)[number];
+declare function parseArgs(argv: string[]): ParsedArgs;
+/**
+ * Validate option values after parsing. Returns a human-readable usage error
+ * for the first invalid value, or null when everything is valid. Kept
+ * separate from parseArgs so both are unit-testable without process.exit.
+ */
+declare function validateArgs(args: ParsedArgs): string | null;
+
+export { type ParsedArgs, VALID_FORMATS, VALID_PROVIDERS, type ValidFormat, type ValidProvider, parseArgs, validateArgs };

package/dist/cli.js

@@ -3,19 +3,23 @@
 import {
   PricingCache,
   PricingEngine,
+  SUPPORTED_CURRENCIES,
   analyzeTerraform,
   compareProviders,
   estimateCost,
   loadConfig,
   optimizeCost,
   whatIf
-} from "./chunk-E7KOWAMW.js";
-import "./chunk-TRRAOOVF.js";
+} from "./chunk-CGMU4ETN.js";
+import "./chunk-LWTVE7UY.js";
 
 // src/cli.ts
-import { readFileSync, existsSync, statSync } from "fs";
+import { readFileSync, existsSync, statSync, realpathSync } from "fs";
 import { resolve, extname, join } from "path";
 import { readdirSync } from "fs";
+import { pathToFileURL } from "url";
+var VALID_PROVIDERS = ["aws", "azure", "gcp"];
+var VALID_FORMATS = ["markdown", "json", "csv", "focus"];
 function parseArgs(argv) {
   const args = argv.slice(2);
   const parsed = {
@@ -25,6 +29,7 @@ function parseArgs(argv) {
     region: void 0,
     format: "markdown",
     providers: ["aws", "azure", "gcp"],
+    currency: "USD",
     changes: void 0,
     json: false,
     help: false
@@ -44,6 +49,8 @@ function parseArgs(argv) {
       parsed.format = args[++i];
     } else if (arg === "--providers" && args[i + 1]) {
       parsed.providers = args[++i].split(",").map((p) => p.trim());
+    } else if (arg === "--currency" && args[i + 1]) {
+      parsed.currency = args[++i].toUpperCase();
     } else if (arg === "--changes" && args[i + 1]) {
       parsed.changes = args[++i];
     } else if (!arg.startsWith("--")) {
@@ -57,6 +64,23 @@ function parseArgs(argv) {
   }
   return parsed;
 }
+function validateArgs(args) {
+  if (!VALID_PROVIDERS.includes(args.provider)) {
+    return `Invalid --provider "${args.provider}". Must be one of: ${VALID_PROVIDERS.join(", ")}`;
+  }
+  if (!VALID_FORMATS.includes(args.format)) {
+    return `Invalid --format "${args.format}". Must be one of: ${VALID_FORMATS.join(", ")}`;
+  }
+  if (!SUPPORTED_CURRENCIES.includes(args.currency)) {
+    return `Invalid --currency "${args.currency}". Must be one of: ${SUPPORTED_CURRENCIES.join(", ")}`;
+  }
+  for (const p of args.providers) {
+    if (!VALID_PROVIDERS.includes(p)) {
+      return `Invalid provider "${p}" in --providers. Must be a comma-separated list of: ${VALID_PROVIDERS.join(", ")}`;
+    }
+  }
+  return null;
+}
 function loadTerraformFiles(inputPath) {
   const resolved = resolve(inputPath);
   if (!existsSync(resolved)) {
@@ -117,8 +141,9 @@ Usage:
 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)
+  --format <markdown|json|csv|focus>             Report format for compare (default: markdown)
   --providers <aws,azure,gcp>                    Comma-separated providers for compare/optimize
+  --currency <USD|EUR|GBP|JPY|CAD|AUD|INR|BRL>   Output currency for estimate/compare (default: USD)
   --changes <path>                               JSON file with changes array for what-if
   --json                                         Output raw JSON
   --help, -h                                     Show this help
@@ -142,17 +167,13 @@ async function runAnalyze(args, files, tfvars) {
   }
 }
 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"
+      currency: args.currency
     },
     pricingEngine,
     config
@@ -164,19 +185,15 @@ async function runEstimate(args, files, tfvars, pricingEngine, config) {
   }
 }
 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"
+    (p) => VALID_PROVIDERS.includes(p)
   );
   const result = await compareProviders(
     {
       files,
       tfvars,
       format: args.format,
-      currency: "USD",
+      currency: args.currency,
       providers: validatedProviders.length > 0 ? validatedProviders : ["aws", "azure", "gcp"]
     },
     pricingEngine,
@@ -195,7 +212,7 @@ async function runCompare(args, files, tfvars, pricingEngine, config) {
 }
 async function runOptimize(args, files, tfvars, pricingEngine, config) {
   const validatedProviders = args.providers.filter(
-    (p) => p === "aws" || p === "azure" || p === "gcp"
+    (p) => VALID_PROVIDERS.includes(p)
   );
   const result = await optimizeCost(
     {
@@ -258,8 +275,7 @@ async function runWhatIf(args, files, tfvars, pricingEngine, config) {
       new_value: c["new_value"]
     };
   });
-  const validProviders = ["aws", "azure", "gcp"];
-  const provider = validProviders.includes(args.provider) ? args.provider : void 0;
+  const provider = VALID_PROVIDERS.includes(args.provider) ? args.provider : void 0;
   const result = await whatIf(
     {
       files,
@@ -292,6 +308,14 @@ async function main() {
   }
   if (!args.path) {
     process.stderr.write(`Error: path argument is required
+`);
+    printUsage();
+    process.exit(1);
+  }
+  const argError = validateArgs(args);
+  if (argError) {
+    process.stderr.write(`Error: ${argError}
+
 `);
     printUsage();
     process.exit(1);
@@ -337,9 +361,26 @@ async function main() {
     cache.close();
   }
 }
-main().catch((err) => {
-  process.stderr.write(`Fatal error: ${err instanceof Error ? err.message : String(err)}
+function isMainModule() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(entry)).href;
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  main().catch((err) => {
+    process.stderr.write(`Fatal error: ${err instanceof Error ? err.message : String(err)}
 `);
-  process.exit(1);
-});
+    process.exit(1);
+  });
+}
+export {
+  VALID_FORMATS,
+  VALID_PROVIDERS,
+  parseArgs,
+  validateArgs
+};
 //# sourceMappingURL=cli.js.map