fix: added support for multiple LLM providers

Author: github-actions

packages/cli/package.json

@@ -9,20 +9,21 @@
   "main": "./dist/index.js",
   "scripts": {
     "build": "tsc",
-
     "dev": "tsc --watch",
     "test": "vitest run"
   },
   "dependencies": {
     "@grotto/core": "workspace:*",
-    "commander": "^12.1.0",
+    "@inquirer/prompts": "8.3.2",
+    "boxen": "^7.1.1",
     "chalk": "^5.3.0",
-    "ora": "^8.0.1",
-    "conf": "^12.0.0",
     "chokidar": "^3.6.0",
-    "boxen": "^7.1.1",
-    "table": "^6.8.2",
-    "dotenv": "^16.4.5"
+    "commander": "^12.1.0",
+    "conf": "^12.0.0",
+    "dotenv": "^16.4.5",
+    "inquirer": "13.3.2",
+    "ora": "^8.0.1",
+    "table": "^6.8.2"
   },
   "devDependencies": {
     "@types/node": "^20.14.0",

packages/cli/src/commands/analyze.ts

@@ -13,7 +13,7 @@ import {
   analyzeKnowledge, 
   analyzeImpact, 
   analyzeRot, 
-  createAIClient, 
+  getAIProvider, 
   generateSummary, 
   type AnalysisResult 
 } from "@grotto/core";
@@ -82,67 +82,82 @@ export const analyzeCommand = new Command("analyze")
       const cachedResult = latestCommit ? getCachedResult(cache, repoRoot, latestCommit) : null;
 
       if (cachedResult) {
-        spinner.succeed(chalk.green(`Loaded from cache for ${latestCommit.slice(0, 7)}.`));
-        if (options.output) {
-          // Proceed to save output if requested
-          await handleReportExport(cachedResult, repoPath, repoRoot, options, spinner);
-        } else {
-          printConsoleReport(cachedResult, options.detailLevel);
+        if (!options.ai || (options.ai && cachedResult.aiSummary)) {
+          spinner.succeed(chalk.green(`Loaded from cache for ${latestCommit.slice(0, 7)}.`));
+          if (options.output) {
+            await handleReportExport(cachedResult, repoPath, repoRoot, options, spinner);
+          } else {
+            printConsoleReport(cachedResult, options.detailLevel, !!options.ai);
+          }
+          return;
         }
-        return;
+        spinner.info(chalk.blue(`Found cached analysis for ${latestCommit.slice(0, 7)}, but AI summary is missing. Generating now...`));
       }
 
-      const commits = await getCommits(git, { 
-        branch: options.branch, 
-        maxCount: parseInt(options.maxCommits, 10) 
-      });
+      const commits = cachedResult 
+        ? [] // We won't re-fetch commits if we have a cached result and just need AI
+        : await getCommits(git, { 
+            branch: options.branch, 
+            maxCount: parseInt(options.maxCommits, 10) 
+          });
 
-      if (commits.length === 0) {
+      if (!cachedResult && commits.length === 0) {
         spinner.fail(chalk.red("No commits found in the specified window/branch."));
         return;
       }
 
-      spinner.text = `Analyzing ${commits.length} commits...`;
-
-      const hotspots = analyzeHotspots(commits, options.window as any);
-      const riskScores = computeRiskScores(hotspots);
-      const churn = analyzeChurn(commits, options.window as any);
-      const contributors = analyzeContributors(commits);
-      const burnout = analyzeBurnout(commits);
-      const coupling = analyzeCoupling(commits);
-      const knowledge = analyzeKnowledge(commits);
-      const impact = analyzeImpact(commits);
-      const rot = analyzeRot(commits);
-
-      const result: AnalysisResult = {
+      const result: AnalysisResult = cachedResult || {
         meta: {
           repoPath,
           branch: options.branch,
           window: options.window,
           commitCount: commits.length,
           generatedAt: new Date(),
         },
-        hotspots,
-        riskScores,
-        churn,
-        contributors,
-        burnout,
-        coupling,
-        knowledge,
-        impact,
-        rot
+        hotspots: analyzeHotspots(commits, options.window as any),
+        riskScores: computeRiskScores(analyzeHotspots(commits, options.window as any)), // Simplified for rebuild
+        churn: analyzeChurn(commits, options.window as any),
+        contributors: analyzeContributors(commits),
+        burnout: analyzeBurnout(commits),
+        coupling: analyzeCoupling(commits),
+        knowledge: analyzeKnowledge(commits),
+        impact: analyzeImpact(commits),
+        rot: analyzeRot(commits)
       };
 
+      // Re-calculate hotspots/risk if we don't have cached result (above logic is a bit messy, let's fix)
+      if (!cachedResult) {
+        spinner.text = `Analyzing ${commits.length} commits...`;
+        const h = analyzeHotspots(commits, options.window as any);
+        result.hotspots = h;
+        result.riskScores = computeRiskScores(h);
+        result.churn = analyzeChurn(commits, options.window as any);
+        result.contributors = analyzeContributors(commits);
+        result.burnout = analyzeBurnout(commits);
+        result.coupling = analyzeCoupling(commits);
+        result.knowledge = analyzeKnowledge(commits);
+        result.impact = analyzeImpact(commits);
+        result.rot = analyzeRot(commits);
+      }
+
       if (options.ai) {
         spinner.text = "Generating AI insights...";
-        const apiKey = process.env[ENV_VARS.ANTHROPIC_API_KEY] || (config.get(CONFIG_KEYS.AI_KEY) as string);
 
+        // Resolve provider and key
+        let providerType = (config.get(CONFIG_KEYS.AI_PROVIDER) as string) || "anthropic";
+        let apiKey = process.env[ENV_VARS.ANTHROPIC_API_KEY];
+        
+        if (providerType === "openai") apiKey = process.env[ENV_VARS.OPENAI_API_KEY] || (config.get("ai.openaiKey") as string);
+        else if (providerType === "gemini") apiKey = process.env[ENV_VARS.GEMINI_API_KEY] || (config.get("ai.geminiKey") as string);
+        else apiKey = apiKey || (config.get("ai.anthropicKey") as string) || (config.get(CONFIG_KEYS.AI_KEY) as string);
+
         if (!apiKey) {
-          spinner.warn(chalk.yellow("AI summary requested but no API key found. Skipping AI layer."));
+          spinner.warn(chalk.yellow(`AI summary requested but no API key found for ${providerType}. Skipping AI layer.`));
+          spinner.info(chalk.blue(`Run 'grotto config set-ai' to configure your preferred provider.`));
         } else {
           try {
-            const aiClient = createAIClient(apiKey);
-            result.aiSummary = await generateSummary(aiClient, result);
+            const aiProvider = getAIProvider(providerType as any, apiKey);
+            result.aiSummary = await generateSummary(aiProvider, result);
           } catch (aiErr) {
             spinner.warn(chalk.yellow("AI summary failed: " + (aiErr as Error).message));
           }
@@ -160,7 +175,7 @@ export const analyzeCommand = new Command("analyze")
       if (options.output) {
         await handleReportExport(result, repoPath, repoRoot, options, spinner);
       } else {
-        printConsoleReport(result, options.detailLevel);
+        printConsoleReport(result, options.detailLevel, !!options.ai);
       }
 
     } catch (err) {

packages/cli/src/commands/config.ts

@@ -10,12 +10,36 @@ configCommand
   .command("set <key> <value>")
   .description("Set a configuration value (e.g., ai.key)")
   .action((key, value) => {
-    if (key === CONFIG_KEYS.AI_KEY) {
-      config.set(CONFIG_KEYS.AI_KEY, value);
-      console.log(chalk.green("API Key stored securely in global config."));
-    } else {
-      config.set(key, value);
-      console.log(chalk.green(`${key} set to ${value}`));
+    config.set(key, value);
+    console.log(chalk.green(`${key} set successfully.`));
+  });
+
+configCommand
+  .command("set-ai")
+  .description("Interactively configure AI provider and API key")
+  .action(async () => {
+    const { select, password } = await import("@inquirer/prompts");
+    
+    const provider = await select({
+      message: "Select an AI provider:",
+      choices: [
+        { name: "Anthropic (Claude)", value: "anthropic" },
+        { name: "OpenAI (GPT-4o)", value: "openai" },
+        { name: "Google Gemini (1.5 Pro)", value: "gemini" }
+      ]
+    });
+
+    const apiKey = await password({
+      message: `Enter your ${provider} API Key:`,
+      mask: "*"
+    });
+
+    if (apiKey) {
+      config.set("ai.provider", provider);
+      config.set(`ai.${provider}Key`, apiKey);
+      // Also set the main ai.key for backward compatibility/simplicity
+      config.set("ai.key", apiKey);
+      console.log(chalk.green(`\nAI configured successfully with ${provider}!`));
     }
   });
 
@@ -24,7 +48,7 @@ configCommand
   .description("Get a configuration value")
   .action((key) => {
     const value = config.get(key);
-    if (key === CONFIG_KEYS.AI_KEY && value) {
+    if (key.toLowerCase().includes("key") && value) {
       console.log(`${key}: ${maskKey(value as string)}`);
     } else {
       console.log(`${key}: ${value ?? "not set"}`);
@@ -35,12 +59,19 @@ configCommand
   .command("list")
   .description("List all configuration")
   .action(() => {
-    const all = config.store;
+    const all = config.store as any;
     console.log(chalk.blue.bold(`\n--- ${PROJECT_NAME} Configuration ---`));
-    for (const [key, val] of Object.entries(all || {})) {
-      if (key === "ai" && typeof val === "object" && val !== null && "key" in val) {
-        console.log(`${CONFIG_KEYS.AI_KEY}: ${maskKey((val as any).key as string)}`);
-      } else {
+    
+    if (all.ai) {
+      console.log(`${chalk.yellow("AI Provider:")} ${all.ai.provider || "not set"}`);
+      if (all.ai.anthropicKey) console.log(`${chalk.yellow("Anthropic Key:")} ${maskKey(all.ai.anthropicKey)}`);
+      if (all.ai.openaiKey) console.log(`${chalk.yellow("OpenAI Key:")} ${maskKey(all.ai.openaiKey)}`);
+      if (all.ai.geminiKey) console.log(`${chalk.yellow("Gemini Key:")} ${maskKey(all.ai.geminiKey)}`);
+    }
+
+    // List other top-level keys if any
+    for (const [key, val] of Object.entries(all)) {
+      if (key !== "ai") {
         console.log(`${key}: ${JSON.stringify(val)}`);
       }
     }

packages/cli/src/config/index.ts

@@ -5,7 +5,11 @@ const schema = {
   ai: {
     type: "object",
     properties: {
-      key: { type: "string" }
+      key: { type: "string" },
+      provider: { type: "string", enum: ["anthropic", "openai", "gemini"] },
+      anthropicKey: { type: "string" },
+      openaiKey: { type: "string" },
+      geminiKey: { type: "string" }
     }
   }
 } as const;

packages/cli/src/constants/index.ts

@@ -5,9 +5,12 @@ export const DEFAULT_WINDOW = "30d";
 export const DEFAULT_MAX_COMMITS = 500;
 
 export const CONFIG_KEYS = {
-  AI_KEY: "ai.key"
+  AI_KEY: "ai.key",
+  AI_PROVIDER: "ai.provider"
 } as const;
 
 export const ENV_VARS = {
-  ANTHROPIC_API_KEY: "ANTHROPIC_API_KEY"
+  ANTHROPIC_API_KEY: "ANTHROPIC_API_KEY",
+  OPENAI_API_KEY: "OPENAI_API_KEY",
+  GEMINI_API_KEY: "GEMINI_API_KEY"
 } as const;

packages/cli/src/formatters/console.ts

@@ -3,7 +3,7 @@ import boxen from "boxen";
 import { table, getBorderCharacters } from "table";
 import type { AnalysisResult } from "@grotto/core";
 
-export function printConsoleReport(result: AnalysisResult, detailLevel: string = "normal") {
+export function printConsoleReport(result: AnalysisResult, detailLevel: string = "normal", showAI: boolean = false) {
   try {
     const { meta, hotspots, riskScores, contributors, burnout, coupling, knowledge, impact, rot } = result;
     const isVerbose = detailLevel === "verbose";
@@ -31,23 +31,24 @@ export function printConsoleReport(result: AnalysisResult, detailLevel: string =
     );
 
     if (isSummary) {
-      printHealthIndicators(impact, rot);
+      printHealthIndicators(impact, rot, !!result.aiSummary);
       return;
     }
 
     // 2. AI Insights (Intuitive Format)
-    if (result.aiSummary) {
+    if (showAI && result.aiSummary) {
       console.log(
         boxen(
-          `${chalk.white(result.aiSummary.digest)}\n\n` +
-          `${chalk.gray.italic("Model: " + result.aiSummary.model)}`,
+          chalk.white(result.aiSummary.digest) + "\n\n" +
+          chalk.gray.italic(`Provider: ${result.aiSummary.provider} | Model: ${result.aiSummary.model}`),
           { 
             padding: 1, 
             margin: { bottom: 1 }, 
             borderStyle: "double", 
             borderColor: "magenta", 
-            title: "AI INSIGHTS", 
-            titleAlignment: "center" 
+            title: "AI ARCHITECTURAL INSIGHTS", 
+            titleAlignment: "center",
+            width: 80 // Limit width for better readability of structured text
           }
         )
       );
@@ -138,22 +139,30 @@ export function printConsoleReport(result: AnalysisResult, detailLevel: string =
     }
 
     // 7. Health Indicators & Footer Tip
-    printHealthIndicators(impact, rot);
+    printHealthIndicators(impact, rot, showAI);
   } catch (err) {
     console.error(chalk.red("\nError printing report:"), err);
   }
 }
 
-function printHealthIndicators(impact: any[], rot: any[]) {
+function printHealthIndicators(impact: any[], rot: any[], showAI: boolean) {
   const avgImpact = impact.length > 0 ? (impact.reduce((acc: number, i: any) => acc + i.blastRadius, 0) / impact.length).toFixed(2) : 0;
 
+  const footerContent = [
+    `${chalk.bold("Overall Health Indicators")}`,
+    `${chalk.gray("────────────────────────")}`,
+    `${chalk.white("Average Blast Radius:  ")} ${chalk.yellow(avgImpact + " files")}`,
+    `${chalk.white("Abandoned Files (Rot): ")} ${chalk.red(rot.length)}`
+  ];
+
+  if (!showAI) {
+    footerContent.push("");
+    footerContent.push(`${chalk.gray.italic("Tip: Run 'grotto config set-ai' to unlock AI-powered insights (use --ai flag).")}`);
+  }
+
   console.log(
     boxen(
-      `${chalk.bold("Overall Health Indicators")}\n` +
-      `${chalk.gray("────────────────────────")}\n` +
-      `${chalk.white("Average Blast Radius:  ")} ${chalk.yellow(avgImpact + " files")}\n` +
-      `${chalk.white("Abandoned Files (Rot): ")} ${chalk.red(rot.length)}\n\n` +
-      `${chalk.gray.italic("Tip: Set ANTHROPIC_API_KEY to unlock deeper AI-powered code audits.")}`,
+      footerContent.join("\n"),
       { 
         padding: 1, 
         margin: { top: 1, bottom: 1 },