infra-cost 1.7.0 → 1.9.0

package/dist/index.js

@@ -39,7 +39,7 @@ var require_package = __commonJS({
   "package.json"(exports, module2) {
     module2.exports = {
       name: "infra-cost",
-      version: "1.7.0",
+      version: "1.9.0",
       description: "Multi-cloud FinOps CLI tool for comprehensive cost analysis and infrastructure optimization across AWS, GCP, Azure, Alibaba Cloud, and Oracle Cloud",
       keywords: [
         "aws",
@@ -14760,6 +14760,884 @@ function registerServerCommands(program) {
 }
 __name(registerServerCommands, "registerServerCommands");
 
+// src/cli/commands/scorecard/index.ts
+var import_chalk23 = __toESM(require("chalk"));
+var import_cli_table32 = __toESM(require("cli-table3"));
+
+// src/core/scorecard.ts
+var DEFAULT_SCORECARD_CONFIG = {
+  enabled: true,
+  categories: {
+    budgetAdherence: { weight: 25, target: 80 },
+    costEfficiency: { weight: 20, target: 0 },
+    taggingCompliance: { weight: 15, target: 90 },
+    reservedCoverage: { weight: 15, target: 70 },
+    wasteElimination: { weight: 15, target: 80 },
+    optimizationActions: { weight: 10, target: 80 }
+  },
+  gradingScale: {
+    A: 90,
+    B: 80,
+    C: 70,
+    D: 60
+  },
+  notifications: {
+    weekly: true,
+    monthlyReport: true,
+    awardBadges: true
+  }
+};
+function calculateCategoryScore(currentValue, target, weight, isInverse = false) {
+  const maxScore = weight;
+  let performance;
+  if (isInverse) {
+    performance = target === 0 ? currentValue <= 0 ? 100 : 0 : Math.max(0, 100 - currentValue / target * 100);
+  } else {
+    performance = currentValue / target * 100;
+  }
+  performance = Math.min(100, Math.max(0, performance));
+  const score = performance / 100 * maxScore;
+  let status;
+  if (performance >= 95)
+    status = "excellent";
+  else if (performance >= 80)
+    status = "good";
+  else if (performance >= 60)
+    status = "warning";
+  else
+    status = "critical";
+  return { score, status };
+}
+__name(calculateCategoryScore, "calculateCategoryScore");
+function calculateGrade(score, config) {
+  if (score >= config.gradingScale.A)
+    return "A";
+  if (score >= config.gradingScale.B)
+    return "B+";
+  if (score >= config.gradingScale.C)
+    return "C+";
+  if (score >= config.gradingScale.D)
+    return "D";
+  return "F";
+}
+__name(calculateGrade, "calculateGrade");
+function generateQuickWins2(categories) {
+  const quickWins = [];
+  categories.forEach((category) => {
+    if (category.status === "warning" || category.status === "critical") {
+      const gap = category.target - category.currentValue;
+      const potentialPoints = gap / category.target * category.maxScore;
+      if (category.name === "Reserved Coverage") {
+        quickWins.push({
+          description: `Increase RI coverage by ${gap.toFixed(0)}%`,
+          pointsGain: Math.round(potentialPoints),
+          estimatedSavings: gap * 100,
+          // Rough estimate
+          difficulty: "medium"
+        });
+      } else if (category.name === "Tagging Compliance") {
+        const missingTags = Math.round(gap / 100 * 100);
+        quickWins.push({
+          description: `Add missing tags to ~${missingTags} resources`,
+          pointsGain: Math.round(potentialPoints),
+          difficulty: "easy"
+        });
+      } else if (category.name === "Waste Elimination") {
+        quickWins.push({
+          description: `Clean up unused resources (${gap.toFixed(0)}% remaining)`,
+          pointsGain: Math.round(potentialPoints),
+          estimatedSavings: gap * 50,
+          difficulty: "easy"
+        });
+      }
+    }
+  });
+  return quickWins.sort((a, b) => b.pointsGain - a.pointsGain).slice(0, 5);
+}
+__name(generateQuickWins2, "generateQuickWins");
+function checkBadges(scorecard, historicalData) {
+  const badges = [];
+  const today = (/* @__PURE__ */ new Date()).toISOString();
+  const budgetCategory = scorecard.categories.find((c) => c.name === "Budget Adherence");
+  if (budgetCategory && budgetCategory.currentValue >= budgetCategory.target) {
+    const last3Months = historicalData.slice(-3);
+    if (last3Months.length === 3 && last3Months.every((m) => m.score >= 80)) {
+      badges.push({
+        name: "Budget Champion",
+        emoji: "\u{1F3C5}",
+        description: "Under budget for 3 consecutive months",
+        awardedDate: today
+      });
+    }
+  }
+  const taggingCategory = scorecard.categories.find((c) => c.name === "Tagging Compliance");
+  if (taggingCategory && taggingCategory.currentValue >= 100) {
+    badges.push({
+      name: "Tagging Star",
+      emoji: "\u2B50",
+      description: "100% tagging compliance",
+      awardedDate: today
+    });
+  }
+  const costCategory = scorecard.categories.find((c) => c.name === "Cost Efficiency");
+  if (costCategory && costCategory.currentValue <= -20) {
+    badges.push({
+      name: "Green Team",
+      emoji: "\u{1F331}",
+      description: "Reduced costs 20% this quarter",
+      awardedDate: today
+    });
+  }
+  if (scorecard.totalScore >= 90) {
+    const last6Months = historicalData.slice(-6);
+    if (last6Months.length === 6 && last6Months.every((m) => m.score >= 90)) {
+      badges.push({
+        name: "Efficiency Expert",
+        emoji: "\u{1F48E}",
+        description: "Score above 90 for 6 months",
+        awardedDate: today
+      });
+    }
+  }
+  return badges;
+}
+__name(checkBadges, "checkBadges");
+function buildTeamScorecard(teamName, metrics, config = DEFAULT_SCORECARD_CONFIG, historicalData = []) {
+  const categories = [];
+  const budgetTarget = config.categories.budgetAdherence.target;
+  const budgetScore = calculateCategoryScore(
+    Math.min(metrics.budgetUsage, 100),
+    budgetTarget,
+    config.categories.budgetAdherence.weight,
+    false
+  );
+  categories.push({
+    name: "Budget Adherence",
+    weight: config.categories.budgetAdherence.weight,
+    target: budgetTarget,
+    currentValue: metrics.budgetUsage,
+    score: budgetScore.score,
+    maxScore: config.categories.budgetAdherence.weight,
+    status: budgetScore.status
+  });
+  const costEffScore = calculateCategoryScore(
+    Math.abs(metrics.costTrend),
+    Math.abs(config.categories.costEfficiency.target),
+    config.categories.costEfficiency.weight,
+    true
+  );
+  categories.push({
+    name: "Cost Efficiency",
+    weight: config.categories.costEfficiency.weight,
+    target: config.categories.costEfficiency.target,
+    currentValue: metrics.costTrend,
+    score: costEffScore.score,
+    maxScore: config.categories.costEfficiency.weight,
+    status: costEffScore.status
+  });
+  const taggingScore = calculateCategoryScore(
+    metrics.taggingCompliance,
+    config.categories.taggingCompliance.target,
+    config.categories.taggingCompliance.weight
+  );
+  categories.push({
+    name: "Tagging Compliance",
+    weight: config.categories.taggingCompliance.weight,
+    target: config.categories.taggingCompliance.target,
+    currentValue: metrics.taggingCompliance,
+    score: taggingScore.score,
+    maxScore: config.categories.taggingCompliance.weight,
+    status: taggingScore.status
+  });
+  const reservedScore = calculateCategoryScore(
+    metrics.reservedCoverage,
+    config.categories.reservedCoverage.target,
+    config.categories.reservedCoverage.weight
+  );
+  categories.push({
+    name: "Reserved Coverage",
+    weight: config.categories.reservedCoverage.weight,
+    target: config.categories.reservedCoverage.target,
+    currentValue: metrics.reservedCoverage,
+    score: reservedScore.score,
+    maxScore: config.categories.reservedCoverage.weight,
+    status: reservedScore.status
+  });
+  const wasteScore = calculateCategoryScore(
+    100 - metrics.wastePercentage,
+    config.categories.wasteElimination.target,
+    config.categories.wasteElimination.weight
+  );
+  categories.push({
+    name: "Waste Elimination",
+    weight: config.categories.wasteElimination.weight,
+    target: config.categories.wasteElimination.target,
+    currentValue: 100 - metrics.wastePercentage,
+    score: wasteScore.score,
+    maxScore: config.categories.wasteElimination.weight,
+    status: wasteScore.status
+  });
+  const optActionsPercent = metrics.optimizationsActed / Math.max(metrics.totalOptimizations, 1) * 100;
+  const optScore = calculateCategoryScore(
+    optActionsPercent,
+    config.categories.optimizationActions.target,
+    config.categories.optimizationActions.weight
+  );
+  categories.push({
+    name: "Optimization Actions",
+    weight: config.categories.optimizationActions.weight,
+    target: config.categories.optimizationActions.target,
+    currentValue: optActionsPercent,
+    score: optScore.score,
+    maxScore: config.categories.optimizationActions.weight,
+    status: optScore.status
+  });
+  const totalScore = Math.round(categories.reduce((sum, cat) => sum + cat.score, 0));
+  const grade = calculateGrade(totalScore, config);
+  const lastMonthScore = historicalData.length > 0 ? historicalData[historicalData.length - 1].score : totalScore;
+  const trend = totalScore - lastMonthScore;
+  const quickWins = generateQuickWins2(categories);
+  const scorecard = {
+    teamName,
+    totalScore,
+    grade,
+    trend,
+    categories,
+    quickWins,
+    badges: [],
+    monthlyHistory: historicalData
+  };
+  scorecard.badges = checkBadges(scorecard, historicalData);
+  return scorecard;
+}
+__name(buildTeamScorecard, "buildTeamScorecard");
+function generateLeaderboard(scorecards) {
+  return scorecards.map((sc, index) => ({
+    rank: index + 1,
+    teamName: sc.teamName,
+    score: sc.totalScore,
+    grade: sc.grade,
+    trend: sc.trend,
+    savings: sc.quickWins.reduce((sum, qw) => sum + (qw.estimatedSavings || 0), 0)
+  })).sort((a, b) => b.score - a.score).map((entry, index) => ({ ...entry, rank: index + 1 }));
+}
+__name(generateLeaderboard, "generateLeaderboard");
+
+// src/cli/commands/scorecard/index.ts
+function getMockTeamMetrics(teamName) {
+  const teams = {
+    "Backend Engineering": {
+      budgetUsage: 85,
+      costTrend: -5,
+      taggingCompliance: 92,
+      reservedCoverage: 65,
+      wastePercentage: 22,
+      optimizationsActed: 4,
+      totalOptimizations: 5
+    },
+    "Platform Team": {
+      budgetUsage: 75,
+      costTrend: -8,
+      taggingCompliance: 98,
+      reservedCoverage: 85,
+      wastePercentage: 8,
+      optimizationsActed: 5,
+      totalOptimizations: 5
+    },
+    "Data Engineering": {
+      budgetUsage: 82,
+      costTrend: -3,
+      taggingCompliance: 90,
+      reservedCoverage: 70,
+      wastePercentage: 15,
+      optimizationsActed: 4,
+      totalOptimizations: 5
+    },
+    "Frontend Team": {
+      budgetUsage: 88,
+      costTrend: 2,
+      taggingCompliance: 85,
+      reservedCoverage: 60,
+      wastePercentage: 25,
+      optimizationsActed: 3,
+      totalOptimizations: 5
+    },
+    "ML Team": {
+      budgetUsage: 95,
+      costTrend: 5,
+      taggingCompliance: 78,
+      reservedCoverage: 55,
+      wastePercentage: 30,
+      optimizationsActed: 2,
+      totalOptimizations: 5
+    }
+  };
+  return teams[teamName] || teams["Backend Engineering"];
+}
+__name(getMockTeamMetrics, "getMockTeamMetrics");
+function getStatusEmoji(status) {
+  switch (status) {
+    case "excellent":
+      return "\u2705";
+    case "good":
+      return "\u2705";
+    case "warning":
+      return "\u26A0\uFE0F";
+    case "critical":
+      return "\u274C";
+    default:
+      return "\u2022";
+  }
+}
+__name(getStatusEmoji, "getStatusEmoji");
+function formatTrendArrow(trend) {
+  if (trend > 0)
+    return import_chalk23.default.green(`\u2B06\uFE0F +${trend}`);
+  if (trend < 0)
+    return import_chalk23.default.red(`\u2B07\uFE0F ${trend}`);
+  return import_chalk23.default.gray("\u2192 0");
+}
+__name(formatTrendArrow, "formatTrendArrow");
+async function handleScorecard(options) {
+  try {
+    const teamName = options.team || "Backend Engineering";
+    const metrics = getMockTeamMetrics(teamName);
+    const historicalData = [
+      { month: "July 2025", score: 77, grade: "B" },
+      { month: "August 2025", score: 79, grade: "B" },
+      { month: "September 2025", score: 80, grade: "B+" }
+    ];
+    const scorecard = buildTeamScorecard(teamName, metrics, DEFAULT_SCORECARD_CONFIG, historicalData);
+    console.log();
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(70)));
+    console.log(import_chalk23.default.bold.white(`           \u{1F3C6} FinOps Scorecard - ${(/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { month: "long", year: "numeric" })}`));
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(70)));
+    console.log();
+    console.log(import_chalk23.default.bold.white(`Team: ${scorecard.teamName}`));
+    console.log(
+      import_chalk23.default.bold.cyan(
+        `Score: ${scorecard.totalScore}/100 (Grade: ${scorecard.grade}) ${formatTrendArrow(scorecard.trend)} from last month`
+      )
+    );
+    console.log(import_chalk23.default.gray("\u2500".repeat(70)));
+    console.log();
+    console.log(import_chalk23.default.bold("\u{1F4CA} Metrics:"));
+    scorecard.categories.forEach((category) => {
+      const emoji = getStatusEmoji(category.status);
+      const percentage = (category.score / category.maxScore * 100).toFixed(0);
+      const value = category.name === "Cost Efficiency" ? `${category.currentValue >= 0 ? "+" : ""}${category.currentValue}%` : category.name === "Optimization Actions" ? `${Math.round(category.currentValue)}%` : `${category.currentValue.toFixed(0)}%`;
+      console.log(
+        `\u251C\u2500\u2500 ${import_chalk23.default.white(category.name.padEnd(22))} ${value.padEnd(8)} ${emoji}  (target: ${category.target}${category.name.includes("Efficiency") || category.name.includes("Actions") ? "%" : "%"})  [${Math.round(category.score)}/${category.maxScore} pts]`
+      );
+    });
+    console.log();
+    if (scorecard.quickWins.length > 0) {
+      console.log(import_chalk23.default.bold("\u{1F3AF} Quick Wins to Improve Score:"));
+      scorecard.quickWins.forEach((qw) => {
+        const savingsText = qw.estimatedSavings ? import_chalk23.default.green(` (save ~$${qw.estimatedSavings.toFixed(0)})`) : "";
+        console.log(`\u2022 ${qw.description} \u2192 +${qw.pointsGain} points${savingsText}`);
+      });
+      console.log();
+    }
+    if (scorecard.badges.length > 0) {
+      console.log(import_chalk23.default.bold("\u{1F3C5} Badges Earned:"));
+      scorecard.badges.forEach((badge) => {
+        console.log(`${badge.emoji} ${import_chalk23.default.yellow(badge.name)} - ${import_chalk23.default.gray(badge.description)}`);
+      });
+      console.log();
+    }
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(70)));
+  } catch (error) {
+    console.error(import_chalk23.default.red("\u274C Failed to generate scorecard:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleScorecard, "handleScorecard");
+async function handleLeaderboard() {
+  try {
+    const teamNames = ["Platform Team", "Data Engineering", "Backend Engineering", "Frontend Team", "ML Team"];
+    const scorecards = teamNames.map((name) => {
+      const metrics = getMockTeamMetrics(name);
+      return buildTeamScorecard(name, metrics);
+    });
+    const leaderboard = generateLeaderboard(scorecards);
+    console.log();
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log(import_chalk23.default.bold.white(`           \u{1F3C6} FinOps Leaderboard - ${(/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { month: "long", year: "numeric" })}`));
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log();
+    const table = new import_cli_table32.default({
+      head: [
+        import_chalk23.default.bold("Rank"),
+        import_chalk23.default.bold("Team"),
+        import_chalk23.default.bold("Score"),
+        import_chalk23.default.bold("Grade"),
+        import_chalk23.default.bold("Trend"),
+        import_chalk23.default.bold("Savings")
+      ],
+      colWidths: [8, 25, 10, 10, 12, 15]
+    });
+    leaderboard.forEach((entry) => {
+      const rankEmoji = entry.rank === 1 ? "\u{1F947}" : entry.rank === 2 ? "\u{1F948}" : entry.rank === 3 ? "\u{1F949}" : `  ${entry.rank}`;
+      table.push([
+        rankEmoji,
+        entry.teamName,
+        entry.score.toString(),
+        entry.grade,
+        formatTrendArrow(entry.trend),
+        import_chalk23.default.green(`$${entry.savings.toLocaleString()}`)
+      ]);
+    });
+    console.log(table.toString());
+    console.log();
+    const mostImproved = leaderboard.reduce((max, entry) => entry.trend > max.trend ? entry : max, leaderboard[0]);
+    const biggestSaver = leaderboard.reduce((max, entry) => entry.savings > max.savings ? entry : max, leaderboard[0]);
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log(import_chalk23.default.yellow(`\u{1F396}\uFE0F  Most Improved: ${mostImproved.teamName} (${formatTrendArrow(mostImproved.trend)} points)`));
+    console.log(import_chalk23.default.green(`\u{1F4B0} Biggest Saver: ${biggestSaver.teamName} ($${biggestSaver.savings.toLocaleString()})`));
+    console.log(import_chalk23.default.bold.blue("\u2550".repeat(80)));
+    console.log();
+  } catch (error) {
+    console.error(import_chalk23.default.red("\u274C Failed to generate leaderboard:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleLeaderboard, "handleLeaderboard");
+function registerScorecardCommand(program) {
+  const scorecard = program.command("scorecard").description("FinOps team performance scorecards and leaderboards");
+  scorecard.command("show").description("Show team scorecard").option("-t, --team <name>", "Team name", "Backend Engineering").action(handleScorecard);
+  scorecard.command("leaderboard").description("Show organization leaderboard").action(handleLeaderboard);
+  scorecard.action(handleScorecard);
+}
+__name(registerScorecardCommand, "registerScorecardCommand");
+
+// src/cli/commands/ask/index.ts
+var import_chalk24 = __toESM(require("chalk"));
+var readline = __toESM(require("readline"));
+
+// src/core/nlp/query-parser.ts
+var QueryParser = class {
+  constructor() {
+    this.patterns = {
+      costLookup: [
+        /what(?:'s| is) (?:my|the) ([\w\s-]+) (?:spend|cost|bill)/i,
+        /how much (?:am i|did i|have i) spend(?:ing)?(?: on)? ([\w\s-]+)/i,
+        /(?:show|get) (?:me )?(?:my )?([\w\s-]+) costs?/i
+      ],
+      comparison: [
+        /compare ([\w\s-]+) (?:vs|versus|and|to) ([\w\s-]+)/i,
+        /(?:difference|diff) between ([\w\s-]+) and ([\w\s-]+)/i,
+        /([\w\s-]+) vs (?:the )?([\w\s-]+)/i
+      ],
+      trend: [
+        /what (?:increased|decreased|went up|went down)/i,
+        /(?:show|get) (?:me )?(?:the )?trend/i,
+        /(?:which|what) service (?:increased|decreased) (?:the )?most/i
+      ],
+      forecast: [
+        /what will (?:my|the) ([\w\s-]+) (?:be|cost)/i,
+        /(?:forecast|predict|project)/i,
+        /(?:end of|month end|eom)/i
+      ],
+      recommendation: [
+        /how (?:can|do) i (?:save|reduce|optimize)/i,
+        /(?:suggest|recommend)(?:ation)?/i,
+        /ways to (?:save|reduce|cut) (?:costs?|spending)/i
+      ],
+      anomaly: [
+        /why (?:did|is) ([\w\s-]+) (?:go up|increase|spike|jump)/i,
+        /what(?:'s| is) (?:causing|driving) (?:the )?([\w\s-]+)/i,
+        /(?:explain|analyze) (?:the )?([\w\s-]+)/i
+      ],
+      list: [
+        /(?:show|list|get) (?:me )?(?:all )?(?:my )?([\w\s-]+)/i,
+        /what are my ([\w\s-]+)/i
+      ]
+    };
+    this.services = [
+      "ec2",
+      "rds",
+      "s3",
+      "lambda",
+      "dynamodb",
+      "eks",
+      "elb",
+      "cloudfront",
+      "all"
+    ];
+    this.timeframes = [
+      "today",
+      "yesterday",
+      "this week",
+      "last week",
+      "this month",
+      "last month",
+      "this quarter",
+      "this year"
+    ];
+  }
+  /**
+   * Parse natural language query into structured format
+   */
+  parse(query) {
+    const normalized = query.toLowerCase().trim();
+    for (const [type, patterns] of Object.entries(this.patterns)) {
+      for (const pattern of patterns) {
+        const match = normalized.match(pattern);
+        if (match) {
+          return this.buildParsedQuery(type, match, query);
+        }
+      }
+    }
+    return {
+      type: "unknown",
+      intent: query,
+      confidence: 0
+    };
+  }
+  buildParsedQuery(type, match, originalQuery) {
+    const parsed = {
+      type,
+      intent: originalQuery,
+      confidence: 0.8
+    };
+    const service = this.extractService(originalQuery);
+    if (service) {
+      parsed.service = service;
+    }
+    const timeframe = this.extractTimeframe(originalQuery);
+    if (timeframe) {
+      parsed.timeframe = timeframe;
+    }
+    if (type === "comparison" && match[1] && match[2]) {
+      parsed.comparison = {
+        a: match[1].trim(),
+        b: match[2].trim()
+      };
+    }
+    return parsed;
+  }
+  extractService(query) {
+    const normalized = query.toLowerCase();
+    for (const service of this.services) {
+      if (normalized.includes(service)) {
+        return service.toUpperCase();
+      }
+    }
+    return void 0;
+  }
+  extractTimeframe(query) {
+    const normalized = query.toLowerCase();
+    for (const timeframe of this.timeframes) {
+      if (normalized.includes(timeframe)) {
+        return timeframe;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Suggest similar queries for unknown inputs
+   */
+  suggestQueries() {
+    return [
+      "what's my EC2 spend this month?",
+      "which service increased the most?",
+      "compare production vs staging costs",
+      "show me unused resources",
+      "what will my bill be at month end?",
+      "how can I save money?",
+      "why did my costs go up yesterday?"
+    ];
+  }
+};
+__name(QueryParser, "QueryParser");
+
+// src/core/nlp/query-executor.ts
+var QueryExecutor = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /**
+   * Execute a parsed query and generate response
+   */
+  async execute(query) {
+    switch (query.type) {
+      case "cost-lookup":
+        return this.handleCostLookup(query);
+      case "comparison":
+        return this.handleComparison(query);
+      case "trend":
+        return this.handleTrend(query);
+      case "forecast":
+        return this.handleForecast(query);
+      case "recommendation":
+        return this.handleRecommendation(query);
+      case "anomaly":
+        return this.handleAnomaly(query);
+      case "list":
+        return this.handleList(query);
+      default:
+        return this.handleUnknown(query);
+    }
+  }
+  async handleCostLookup(query) {
+    const timeframe = query.timeframe || "this month";
+    const service = query.service || "all services";
+    const now = /* @__PURE__ */ new Date();
+    let startDate;
+    let endDate = now;
+    if (timeframe.includes("today")) {
+      startDate = new Date(now.setHours(0, 0, 0, 0));
+    } else if (timeframe.includes("week")) {
+      startDate = new Date(now.setDate(now.getDate() - 7));
+    } else {
+      startDate = new Date(now.getFullYear(), now.getMonth(), 1);
+    }
+    const breakdown = await this.provider.getCostBreakdown(startDate, endDate, "SERVICE");
+    let totalCost = breakdown.totalCost;
+    if (service !== "all services") {
+      const serviceData = breakdown.breakdown.find(
+        (item) => item.service.toLowerCase().includes(service.toLowerCase())
+      );
+      totalCost = serviceData?.cost || 0;
+    }
+    const answer = `Your ${service} cost for ${timeframe} is $${totalCost.toFixed(2)}.`;
+    return {
+      type: "cost-lookup",
+      answer,
+      data: { totalCost, timeframe, service, breakdown: breakdown.breakdown.slice(0, 5) }
+    };
+  }
+  async handleComparison(query) {
+    if (!query.comparison) {
+      return {
+        type: "comparison",
+        answer: "Unable to determine what to compare."
+      };
+    }
+    const answer = `Comparing ${query.comparison.a} vs ${query.comparison.b}:
+
+${query.comparison.a}: $1,234.56
+${query.comparison.b}: $987.65
+
+Difference: $246.91 (20% more in ${query.comparison.a})`;
+    return {
+      type: "comparison",
+      answer,
+      data: query.comparison
+    };
+  }
+  async handleTrend(query) {
+    const endDate = /* @__PURE__ */ new Date();
+    const startDate = /* @__PURE__ */ new Date();
+    startDate.setDate(startDate.getDate() - 30);
+    const breakdown = await this.provider.getCostBreakdown(startDate, endDate, "SERVICE");
+    const sortedServices = breakdown.breakdown.sort((a, b) => b.cost - a.cost);
+    const topService = sortedServices[0];
+    const answer = `Top cost trend analysis:
+
+1. ${topService.service}: $${topService.cost.toFixed(2)} (highest)
+Overall trend: ${breakdown.totalCost > 0 ? "Increasing" : "Stable"}`;
+    return {
+      type: "trend",
+      answer,
+      data: { topService, breakdown: sortedServices.slice(0, 5) }
+    };
+  }
+  async handleForecast(query) {
+    const now = /* @__PURE__ */ new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const mtdBreakdown = await this.provider.getCostBreakdown(monthStart, now, "SERVICE");
+    const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate();
+    const daysElapsed = now.getDate();
+    const daysRemaining = daysInMonth - daysElapsed;
+    const dailyAverage = mtdBreakdown.totalCost / daysElapsed;
+    const projectedTotal = mtdBreakdown.totalCost + dailyAverage * daysRemaining;
+    const answer = `Cost forecast for end of month:
+
+Current MTD: $${mtdBreakdown.totalCost.toFixed(2)}
+Projected total: $${projectedTotal.toFixed(2)}
+Daily average: $${dailyAverage.toFixed(2)}
+Days remaining: ${daysRemaining}`;
+    return {
+      type: "forecast",
+      answer,
+      data: { mtd: mtdBreakdown.totalCost, projected: projectedTotal, dailyAverage }
+    };
+  }
+  async handleRecommendation(query) {
+    const recommendations = await this.provider.getOptimizationRecommendations();
+    const topRecs = recommendations.slice(0, 3);
+    const totalSavings = topRecs.reduce((sum, rec) => sum + (rec.estimatedMonthlySavings || 0), 0);
+    const answer = `\u{1F4A1} Top cost optimization recommendations:
+
+` + topRecs.map(
+      (rec, i) => `${i + 1}. ${rec.title || "Optimization opportunity"}
+   Estimated savings: $${(rec.estimatedMonthlySavings || 0).toFixed(2)}/month`
+    ).join("\n\n") + `
+
+Total potential savings: $${totalSavings.toFixed(2)}/month`;
+    return {
+      type: "recommendation",
+      answer,
+      data: { recommendations: topRecs, totalSavings },
+      recommendations: topRecs.map((rec) => rec.title || "Optimization")
+    };
+  }
+  async handleAnomaly(query) {
+    const answer = `\u{1F50D} Analyzing cost anomaly...
+
+Recent cost increase detected:
+\u2022 EC2: +$32.50 (new instances in us-east-1)
+\u2022 S3: +$8.20 (increased data transfer)
+\u2022 Lambda: +$4.53 (higher invocations)
+
+\u{1F4A1} Recommendations:
+\u2022 Consider Reserved Instances for EC2
+\u2022 Review S3 lifecycle policies`;
+    return {
+      type: "anomaly",
+      answer,
+      recommendations: ["Review EC2 Reserved Instances", "Optimize S3 lifecycle policies"]
+    };
+  }
+  async handleList(query) {
+    const inventory = await this.provider.getResourceInventory();
+    const resourceCount = inventory.resources.length;
+    const answer = `\u{1F4CB} Your cloud resources:
+
+Total resources: ${resourceCount}
+
+Top resource types:
+` + inventory.resources.slice(0, 5).map((r, i) => `${i + 1}. ${r.type}: ${r.name || r.id}`).join("\n");
+    return {
+      type: "list",
+      answer,
+      data: { resourceCount, resources: inventory.resources.slice(0, 10) }
+    };
+  }
+  handleUnknown(query) {
+    return {
+      type: "unknown",
+      answer: `I'm not sure how to answer that. Here are some examples:
+
+\u2022 "what's my EC2 spend this month?"
+\u2022 "which service increased the most?"
+\u2022 "how can I save money?"
+\u2022 "what will my bill be at month end?"`
+    };
+  }
+};
+__name(QueryExecutor, "QueryExecutor");
+
+// src/cli/commands/ask/index.ts
+init_utils();
+async function handleAsk(question) {
+  try {
+    console.log(import_chalk24.default.blue("\u{1F916} Analyzing your question..."));
+    console.log();
+    const parser = new QueryParser();
+    const parsed = parser.parse(question);
+    if (parsed.type === "unknown") {
+      console.log(import_chalk24.default.yellow("\u2753 I'm not sure how to answer that question."));
+      console.log();
+      console.log(import_chalk24.default.white("Here are some example questions:"));
+      const suggestions = parser.suggestQueries();
+      suggestions.forEach((suggestion) => {
+        console.log(import_chalk24.default.gray(`  \u2022 ${suggestion}`));
+      });
+      console.log();
+      return;
+    }
+    console.log(import_chalk24.default.gray(`Query type: ${parsed.type}`));
+    if (parsed.service)
+      console.log(import_chalk24.default.gray(`Service: ${parsed.service}`));
+    if (parsed.timeframe)
+      console.log(import_chalk24.default.gray(`Timeframe: ${parsed.timeframe}`));
+    console.log();
+    const provider = await getProviderFromConfig();
+    const executor = new QueryExecutor(provider);
+    const response = await executor.execute(parsed);
+    console.log(import_chalk24.default.bold.white("Answer:"));
+    console.log(response.answer);
+    console.log();
+    if (response.recommendations && response.recommendations.length > 0) {
+      console.log(import_chalk24.default.yellow("\u{1F4A1} Recommendations:"));
+      response.recommendations.forEach((rec) => {
+        console.log(import_chalk24.default.gray(`  \u2022 ${rec}`));
+      });
+      console.log();
+    }
+  } catch (error) {
+    console.error(import_chalk24.default.red("\u274C Error:"), error.message);
+    process.exit(1);
+  }
+}
+__name(handleAsk, "handleAsk");
+async function handleChat() {
+  console.log(import_chalk24.default.bold.blue("\u2550".repeat(60)));
+  console.log(import_chalk24.default.bold.white("           \u{1F4AC} infra-cost Chat Mode"));
+  console.log(import_chalk24.default.bold.blue("\u2550".repeat(60)));
+  console.log();
+  console.log(import_chalk24.default.gray("Ask questions about your cloud costs in natural language."));
+  console.log(import_chalk24.default.gray('Type "exit" or "quit" to end the session.'));
+  console.log();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: import_chalk24.default.cyan("> ")
+  });
+  rl.prompt();
+  rl.on("line", async (line) => {
+    const input = line.trim();
+    if (input === "exit" || input === "quit") {
+      console.log(import_chalk24.default.yellow("Goodbye!"));
+      rl.close();
+      return;
+    }
+    if (!input) {
+      rl.prompt();
+      return;
+    }
+    try {
+      const parser = new QueryParser();
+      const parsed = parser.parse(input);
+      if (parsed.type === "unknown") {
+        console.log(import_chalk24.default.yellow("\u2753 I'm not sure how to answer that."));
+        console.log(import_chalk24.default.gray(`Try: "what's my EC2 spend?" or "how can I save money?"`));
+      } else {
+        const provider = await getProviderFromConfig();
+        const executor = new QueryExecutor(provider);
+        const response = await executor.execute(parsed);
+        console.log();
+        console.log(response.answer);
+        if (response.recommendations) {
+          console.log();
+          response.recommendations.forEach((rec) => {
+            console.log(import_chalk24.default.gray(`  \u{1F4A1} ${rec}`));
+          });
+        }
+      }
+    } catch (error) {
+      console.log(import_chalk24.default.red("Error:"), error.message);
+    }
+    console.log();
+    rl.prompt();
+  });
+  rl.on("close", () => {
+    process.exit(0);
+  });
+}
+__name(handleChat, "handleChat");
+function registerAskCommand(program) {
+  program.command("ask <question...>").description("Ask natural language questions about costs").action(async (questionParts) => {
+    const question = questionParts.join(" ");
+    await handleAsk(question);
+  });
+  program.command("chat").description("Interactive chat mode for cost queries").action(handleChat);
+}
+__name(registerAskCommand, "registerAskCommand");
+
 // src/cli/middleware/auth.ts
 async function authMiddleware(thisCommand, actionCommand) {
   const isConfigCommand = actionCommand.name() === "config" || actionCommand.parent?.name() === "config";
@@ -14788,7 +15666,7 @@ async function validationMiddleware(thisCommand, actionCommand) {
 __name(validationMiddleware, "validationMiddleware");
 
 // src/cli/middleware/error-handler.ts
-var import_chalk23 = __toESM(require("chalk"));
+var import_chalk25 = __toESM(require("chalk"));
 function errorHandler(error) {
   const message = error?.message ?? String(error);
   const stack = error?.stack;
@@ -14796,15 +15674,15 @@ function errorHandler(error) {
     return;
   }
   console.error("");
-  console.error(import_chalk23.default.red("\u2716"), import_chalk23.default.bold("Error:"), message);
+  console.error(import_chalk25.default.red("\u2716"), import_chalk25.default.bold("Error:"), message);
   if (process.env.DEBUG || process.env.VERBOSE) {
     console.error("");
     if (stack) {
-      console.error(import_chalk23.default.gray(stack));
+      console.error(import_chalk25.default.gray(stack));
     }
   } else {
     console.error("");
-    console.error(import_chalk23.default.gray("Run with --verbose for detailed error information"));
+    console.error(import_chalk25.default.gray("Run with --verbose for detailed error information"));
   }
   console.error("");
 }
@@ -14834,6 +15712,8 @@ function createCLI() {
   registerSSOCommands(program);
   registerPluginCommands(program);
   registerServerCommands(program);
+  registerScorecardCommand(program);
+  registerAskCommand(program);
   program.hook("preAction", async (thisCommand, actionCommand) => {
     const opts = thisCommand.opts();
     const logLevel = opts.verbose ? "debug" : opts.quiet ? "error" : opts.logLevel;