feat: Enhance AI Code Agent with multi-provider support

htilly · htilly · commit 6268fb44833c · 2025-12-14T01:05:32.000+01:00
- Updated the AI Code Agent to support multiple AI providers: Claude, OpenAI, and Google Gemini.
- Modified README.md to include setup instructions for new AI providers and their respective API keys.
- Improved error handling and Slack notification for agent failures.
- Added a new package.json for agent dependencies and updated GitHub Actions workflow to install these dependencies.
- Enhanced documentation for AI provider configuration and quick setup instructions.
diff --git a/.github/agent/agent.js b/.github/agent/agent.js
@@ -1,15 +1,140 @@
 import { execSync } from "child_process";
-import OpenAI from "openai";
 import fs from "fs";
 
-const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+// Support multiple AI providers
+const provider = process.env.AI_PROVIDER || "claude"; // claude, openai, or gemini
 const task = process.env.TASK || "Improve code quality";
 const requester = process.env.REQUESTER || "unknown";
+const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+const runId = process.env.GITHUB_RUN_ID;
+
+// Initialize AI client based on provider
+let aiClient = null;
+let aiModel = null;
+
+if (provider === "claude") {
+  // Claude (Anthropic) - FREE tier available!
+  const { Anthropic } = await import("@anthropic-ai/sdk");
+  const apiKey = process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY;
+  if (!apiKey) {
+    console.error("[AGENT] ANTHROPIC_API_KEY or CLAUDE_API_KEY not set");
+    process.exit(1);
+  }
+  aiClient = new Anthropic({ apiKey });
+  aiModel = process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022";
+  console.log(`[AGENT] Using Claude (Anthropic) with model: ${aiModel}`);
+} else if (provider === "openai") {
+  // OpenAI (original)
+  const { default: OpenAI } = await import("openai");
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    console.error("[AGENT] OPENAI_API_KEY not set");
+    process.exit(1);
+  }
+  aiClient = new OpenAI({ apiKey });
+  aiModel = process.env.OPENAI_MODEL || "gpt-4o";
+  console.log(`[AGENT] Using OpenAI with model: ${aiModel}`);
+  } else if (provider === "gemini") {
+    // Google Gemini - FREE tier available!
+    const { GoogleGenerativeAI } = await import("@google/generative-ai");
+    const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+      console.error("[AGENT] GEMINI_API_KEY or GOOGLE_API_KEY not set");
+      process.exit(1);
+    }
+    const genAI = new GoogleGenerativeAI(apiKey);
+    aiModel = process.env.GEMINI_MODEL || "gemini-1.5-pro";
+    aiClient = genAI.getGenerativeModel({ model: aiModel });
+    console.log(`[AGENT] Using Google Gemini with model: ${aiModel}`);
+} else {
+  console.error(`[AGENT] Unknown provider: ${provider}. Use: claude, openai, or gemini`);
+  process.exit(1);
+}
 
 function sh(cmd) {
   return execSync(cmd, { encoding: "utf8", stdio: "pipe" });
 }
 
+// Send error notification to Slack
+async function notifySlackError(errorMessage, errorType = "Unknown error") {
+  if (!webhookUrl) {
+    console.log("[AGENT] No SLACK_WEBHOOK_URL configured, skipping notification");
+    return;
+  }
+
+  const errorEmoji = errorType.includes("quota") ? "💳" : "❌";
+  const message = {
+    text: `${errorEmoji} AICODE Agent Failed`,
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `${errorEmoji} *AICODE Agent Failed*\n\n*Task:* ${task}\n*Requested by:* ${requester}\n*Error:* ${errorType}\n\n${errorMessage}`
+        }
+      },
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `<https://github.com/htilly/SlackONOS/actions/runs/${runId}|View GitHub Actions logs>`
+        }
+      }
+    ]
+  };
+
+  try {
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    if (!response.ok) {
+      console.error(`[AGENT] Failed to send Slack notification: ${response.status}`);
+    } else {
+      console.log("[AGENT] Error notification sent to Slack");
+    }
+  } catch (err) {
+    console.error(`[AGENT] Error sending Slack notification: ${err.message}`);
+  }
+}
+
+// Handle errors and exit gracefully
+async function handleError(error, errorType = "Unknown error") {
+  let errorMessage = error.message || String(error);
+  
+  // Format quota errors more clearly
+  if (error.code === "insufficient_quota" || error.type === "insufficient_quota") {
+    errorType = `${provider.toUpperCase()} API Quota Exceeded`;
+    if (provider === "claude") {
+      errorMessage = "You exceeded your Anthropic API quota. Check billing at https://console.anthropic.com/";
+    } else if (provider === "openai") {
+      errorMessage = "You exceeded your OpenAI API quota. Check billing at https://platform.openai.com/account/billing";
+    } else {
+      errorMessage = "You exceeded your API quota. Please check your plan and billing details.";
+    }
+  } else if (error.status === 429 || error.statusCode === 429) {
+    errorType = `${provider.toUpperCase()} API Rate Limit`;
+    errorMessage = "API rate limit exceeded. Please try again later.";
+  } else if (error.status === 401 || error.statusCode === 401) {
+    errorType = `${provider.toUpperCase()} API Authentication Failed`;
+    if (provider === "claude") {
+      errorMessage = "Invalid Anthropic API key. Please check your GitHub secrets (ANTHROPIC_API_KEY or CLAUDE_API_KEY).";
+    } else if (provider === "openai") {
+      errorMessage = "Invalid OpenAI API key. Please check your GitHub secrets (OPENAI_API_KEY).";
+    } else {
+      errorMessage = "Invalid API key. Please check your GitHub secrets.";
+    }
+  }
+
+  console.error(`[AGENT] ${errorType}: ${errorMessage}`);
+  
+  // Send notification to Slack
+  await notifySlackError(errorMessage, errorType);
+  
+  process.exit(1);
+}
+
 console.log(`[AGENT] Starting AI code agent for task: ${task}`);
 console.log(`[AGENT] Requested by: ${requester}`);
 
@@ -56,14 +181,40 @@ Generate a safe, focused code change as a unified git diff. The diff will be app
 
 Remember: Output ONLY the git diff, no explanations, no markdown code blocks, just the raw diff.`;
 
-console.log("[AGENT] Calling OpenAI API...");
-const res = await client.chat.completions.create({
-  model: "gpt-4o",
-  temperature: 0.2,
-  messages: [{ role: "user", content: prompt }],
-});
+// Call AI provider with unified interface
+async function callAI(promptText) {
+  if (provider === "claude") {
+    const response = await aiClient.messages.create({
+      model: aiModel,
+      max_tokens: 4096,
+      temperature: 0.2,
+      messages: [{ role: "user", content: promptText }],
+    });
+    return response.content[0].text;
+  } else if (provider === "openai") {
+    const response = await aiClient.chat.completions.create({
+      model: aiModel,
+      temperature: 0.2,
+      messages: [{ role: "user", content: promptText }],
+    });
+    return response.choices[0].message.content;
+  } else if (provider === "gemini") {
+    const result = await aiClient.generateContent({
+      contents: [{ role: "user", parts: [{ text: promptText }] }],
+      generationConfig: { temperature: 0.2 },
+    });
+    return result.response.text();
+  }
+}
 
-const output = res.choices[0].message.content;
+console.log(`[AGENT] Calling ${provider.toUpperCase()} API...`);
+let output;
+try {
+  output = await callAI(prompt);
+} catch (error) {
+  await handleError(error, `${provider.toUpperCase()} API Error`);
+  return; // Exit already handled
+}
 
 // Extract diff from potential markdown code blocks
 let diff = output;
@@ -77,10 +228,9 @@ if (output.includes("```")) {
 
 // Validate diff format
 if (!diff.includes("diff --git")) {
-  console.error("[AGENT] Model did not return a valid diff");
-  console.error("[AGENT] Output was:");
-  console.error(output);
-  process.exit(1);
+  const errorMsg = `Model did not return a valid diff. Output was:\n\`\`\`\n${output.substring(0, 500)}\n\`\`\``;
+  await handleError(new Error(errorMsg), "Invalid Diff Format");
+  return;
 }
 
 // Safety check: Ensure we're not touching forbidden files
@@ -94,16 +244,22 @@ const forbiddenPatterns = [
 
 for (const pattern of forbiddenPatterns) {
   if (pattern.test(diff)) {
-    console.error(`[AGENT] SAFETY VIOLATION: Attempted to modify forbidden file matching ${pattern}`);
-    process.exit(1);
+    await handleError(
+      new Error(`Attempted to modify forbidden file matching ${pattern}`),
+      "Safety Violation"
+    );
+    return;
   }
 }
 
 // Count lines changed
 const linesChanged = (diff.match(/^[+-][^+-]/gm) || []).length;
 if (linesChanged > 300) {
-  console.error(`[AGENT] SAFETY VIOLATION: Too many lines changed (${linesChanged} > 300)`);
-  process.exit(1);
+  await handleError(
+    new Error(`Too many lines changed (${linesChanged} > 300). Maximum allowed is 300 lines.`),
+    "Safety Violation"
+  );
+  return;
 }
 
 console.log(`[AGENT] Generated diff with ${linesChanged} lines changed`);
@@ -115,10 +271,9 @@ try {
   sh("git apply /tmp/aicode.patch");
   console.log("[AGENT] Patch applied successfully");
 } catch (err) {
-  console.error("[AGENT] Failed to apply patch:", err.message);
-  console.error("[AGENT] Diff was:");
-  console.error(diff);
-  process.exit(1);
+  const errorMsg = `Failed to apply patch: ${err.message}\n\nDiff preview:\n\`\`\`\n${diff.substring(0, 500)}\n\`\`\``;
+  await handleError(new Error(errorMsg), "Patch Application Failed");
+  return;
 }
 
 // Show diff for logs
diff --git a/.github/agent/package.json b/.github/agent/package.json
@@ -0,0 +1,9 @@
+{
+  "type": "module",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.27.0",
+    "@google/generative-ai": "^0.21.0",
+    "openai": "^4.70.0"
+  }
+}
+
diff --git a/.github/workflows/aicode-agent.yml b/.github/workflows/aicode-agent.yml
@@ -27,21 +27,50 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
+      - name: Install agent dependencies
+        working-directory: .github/agent
+        run: npm install
+
       - name: Run AI Agent
+        id: agent
         env:
+          # AI Provider selection (claude, openai, or gemini)
+          AI_PROVIDER: ${{ secrets.AI_PROVIDER || 'claude' }}
+          # Claude/Anthropic (default, FREE tier available)
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          CLAUDE_API_KEY: ${{ secrets.CLAUDE_API_KEY }}
+          CLAUDE_MODEL: ${{ secrets.CLAUDE_MODEL || 'claude-3-5-sonnet-20241022' }}
+          # OpenAI (fallback)
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          OPENAI_MODEL: ${{ secrets.OPENAI_MODEL || 'gpt-4o' }}
+          # Google Gemini (alternative, FREE tier available)
+          GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
+          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
+          GEMINI_MODEL: ${{ secrets.GEMINI_MODEL || 'gemini-1.5-pro' }}
+          # Other
+          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+          GITHUB_RUN_ID: ${{ github.run_id }}
           TASK: ${{ github.event.client_payload.task }}
           REQUESTER: ${{ github.event.client_payload.requester }}
-        run: node .github/agent/agent.js
+        run: node --input-type=module .github/agent/agent.js
+        continue-on-error: true
+
+      - name: Notify Slack on agent failure
+        if: steps.agent.outcome != 'success'
+        run: |
+          curl -X POST "${{ secrets.SLACK_WEBHOOK_URL }}" \
+            -H "Content-Type: application/json" \
+            -d "{\"text\":\"❌ AICODE Agent failed before tests. <https://github.com/htilly/SlackONOS/actions/runs/${{ github.run_id }}|View logs>\"}"
 
       - name: Run tests
         id: tests
+        if: steps.agent.outcome == 'success'
         run: npm test
         continue-on-error: true
 
       - name: Create PR if tests pass
         id: cpr
-        if: steps.tests.outcome == 'success'
+        if: steps.agent.outcome == 'success' && steps.tests.outcome == 'success'
         uses: peter-evans/create-pull-request@v6
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
@@ -59,14 +88,14 @@ jobs:
             Review the changes carefully before merging.
 
       - name: Notify Slack on success
-        if: steps.tests.outcome == 'success'
+        if: steps.agent.outcome == 'success' && steps.tests.outcome == 'success'
         run: |
           curl -X POST "${{ secrets.SLACK_WEBHOOK_URL }}" \
             -H "Content-Type: application/json" \
             -d "{\"text\":\"✅ AICODE PR created: <https://github.com/htilly/SlackONOS/pull/${{ steps.cpr.outputs.pull-request-number }}|#${{ steps.cpr.outputs.pull-request-number }}>\"}"
 
-      - name: Notify Slack on failure
-        if: steps.tests.outcome != 'success'
+      - name: Notify Slack on test failure
+        if: steps.agent.outcome == 'success' && steps.tests.outcome != 'success'
         run: |
           curl -X POST "${{ secrets.SLACK_WEBHOOK_URL }}" \
             -H "Content-Type: application/json" \
diff --git a/README.md b/README.md
@@ -605,16 +605,31 @@ aicode <task description>
    ```
 
 **GitHub Secrets (Repository Settings):**
-1. `OPENAI_API_KEY` - OpenAI API key for GPT-4 (for code generation)
-2. `SLACK_WEBHOOK_URL` - Incoming webhook URL for Slack notifications
+
+**AI Provider (choose one):**
+- **Claude (Recommended - FREE tier!):** `ANTHROPIC_API_KEY` or `CLAUDE_API_KEY`
+  - Get key: https://console.anthropic.com/ ($5 free credit!)
+  - Set `AI_PROVIDER=claude` (optional, default)
+- **Google Gemini (FREE tier!):** `GEMINI_API_KEY` or `GOOGLE_API_KEY`
+  - Get key: https://aistudio.google.com/app/apikey
+  - Set `AI_PROVIDER=gemini`
+- **OpenAI (paid):** `OPENAI_API_KEY`
+  - Get key: https://platform.openai.com/api-keys
+  - Set `AI_PROVIDER=openai`
+
+**Required:**
+- `SLACK_WEBHOOK_URL` - Incoming webhook URL for Slack notifications
 
 **Setup Steps:**
 1. Go to GitHub Settings → Developer Settings → Personal Access Tokens
 2. Generate new token (classic) with `repo` scope
 3. Add token to your `config/config.json` as `githubToken`
 4. Create a Slack incoming webhook: https://api.slack.com/messaging/webhooks
 5. Add webhook URL to GitHub repository secrets as `SLACK_WEBHOOK_URL`
-6. Add OpenAI API key to GitHub repository secrets as `OPENAI_API_KEY`
+6. **Choose AI Provider:**
+   - **Claude (Recommended):** Get key from https://console.anthropic.com/ → Add as `ANTHROPIC_API_KEY` → (Optional) Set `AI_PROVIDER=claude`
+   - **Gemini:** Get key from https://aistudio.google.com/app/apikey → Add as `GEMINI_API_KEY` → Set `AI_PROVIDER=gemini`
+   - **OpenAI:** Get key from https://platform.openai.com/api-keys → Add as `OPENAI_API_KEY` → Set `AI_PROVIDER=openai`
 
 ### Safety Features
 
diff --git a/docs/AI_CODE_AGENT.md b/docs/AI_CODE_AGENT.md
