@delegance/claude-autopilot 1.4.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@delegance/claude-autopilot",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "type": "module",
   "description": "Claude Code automation pipeline: spec → plan → implement → validate → PR",
   "keywords": [
@@ -46,6 +46,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.90.0",
+    "@google/generative-ai": "^0.24.1",
     "ajv": "^8",
     "dotenv": ">=16",
     "js-yaml": "^4",

package/src/adapters/loader.ts

@@ -16,6 +16,8 @@ const BUILTIN_PATHS: Record<IntegrationPoint, Record<string, string>> = {
   'review-engine': {
     codex: './review-engine/codex.ts',
     claude: './review-engine/claude.ts',
+    gemini: './review-engine/gemini.ts',
+    'openai-compatible': './review-engine/openai-compatible.ts',
     auto: './review-engine/auto.ts',
   },
   'vcs-host': { github: './vcs-host/github.ts' },

package/src/adapters/review-engine/auto.ts

@@ -2,19 +2,42 @@ import type { Capabilities } from '../base.ts';
 import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
 import { AutopilotError } from '../../core/errors.ts';
 
-// Priority order: ANTHROPIC_API_KEY → claude, OPENAI_API_KEY → codex
+// Priority order for key detection
 async function resolveAdapter(): Promise<ReviewEngine> {
   if (process.env.ANTHROPIC_API_KEY) {
     const { claudeAdapter } = await import('./claude.ts');
     return claudeAdapter;
   }
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) {
+    const { geminiAdapter } = await import('./gemini.ts');
+    return geminiAdapter;
+  }
   if (process.env.OPENAI_API_KEY) {
     const { codexAdapter } = await import('./codex.ts');
     return codexAdapter;
   }
+  if (process.env.GROQ_API_KEY) {
+    const { openaiCompatibleAdapter } = await import('./openai-compatible.ts');
+    // Wrap with Groq config injected into review() context
+    return {
+      ...openaiCompatibleAdapter,
+      name: 'auto',
+      review(input: ReviewInput) {
+        return openaiCompatibleAdapter.review({
+          ...input,
+          context: {
+            ...input.context,
+            model: 'llama-3.3-70b-versatile',
+            baseUrl: 'https://api.groq.com/openai/v1',
+            apiKeyEnv: 'GROQ_API_KEY',
+          } as typeof input.context,
+        });
+      },
+    };
+  }
   throw new AutopilotError(
-    'No LLM API key found — set ANTHROPIC_API_KEY (recommended) or OPENAI_API_KEY to enable review',
-    { code: 'auth', provider: 'auto' }
+    'No LLM API key found. Set one of: ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, GROQ_API_KEY',
+    { code: 'auth', provider: 'auto' },
   );
 }
 

package/src/adapters/review-engine/gemini.ts

@@ -0,0 +1,131 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import type { Finding } from '../../core/findings/types.ts';
+import { AutopilotError } from '../../core/errors.ts';
+import type { Capabilities } from '../base.ts';
+import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
+
+const DEFAULT_MODEL = 'gemini-2.5-pro-preview-05-06';
+const MAX_OUTPUT_TOKENS = 4096;
+
+// Cost per million tokens (USD) — gemini-2.5-pro pricing (<200k context)
+const COST_PER_M_INPUT = 1.25;
+const COST_PER_M_OUTPUT = 10.0;
+
+const PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
+
+The codebase context:
+{STACK}
+
+Please review the following:
+
+---
+
+{CONTENT}
+
+---
+
+Provide structured feedback in exactly this format:
+
+## Review Summary
+One paragraph overall assessment.
+
+## Findings
+
+For each finding, use this format:
+### [CRITICAL|WARNING|NOTE] <short title>
+<explanation>
+**Suggestion:** <actionable fix>
+
+Rules:
+- CRITICAL: Blocks merge (security issues, data loss risks, broken contracts)
+- WARNING: Should address before merging (logic errors, missing error handling, test gaps)
+- NOTE: Improvement suggestion (style, performance, clarity)
+- Maximum 10 findings, ranked by severity
+- Be specific and constructive
+- Reference the file and line when possible`;
+
+export const geminiAdapter: ReviewEngine = {
+  name: 'gemini',
+  apiVersion: '1.0.0',
+
+  getCapabilities(): Capabilities {
+    return { structuredOutput: false, streaming: false, maxContextTokens: 1000000, inlineComments: false };
+  },
+
+  estimateTokens(content: string): number {
+    return Math.ceil(content.length / 4);
+  },
+
+  async review(input: ReviewInput): Promise<ReviewOutput> {
+    const apiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
+    if (!apiKey) {
+      throw new AutopilotError('GEMINI_API_KEY (or GOOGLE_API_KEY) not set', { code: 'auth', provider: 'gemini' });
+    }
+
+    const model = (input.context as Record<string, unknown> | undefined)?.['model'] as string | undefined ?? DEFAULT_MODEL;
+    const stack = input.context?.stack ?? 'A web application — stack details unspecified.';
+    const prompt = PROMPT_TEMPLATE.replace('{STACK}', stack).replace('{CONTENT}', input.content);
+
+    const genAI = new GoogleGenerativeAI(apiKey);
+    const genModel = genAI.getGenerativeModel({
+      model,
+      generationConfig: { maxOutputTokens: MAX_OUTPUT_TOKENS },
+    });
+
+    let result: Awaited<ReturnType<typeof genModel.generateContent>>;
+    try {
+      result = await genModel.generateContent(prompt);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isRateLimit = /rate.limit|429|quota/i.test(message);
+      const isAuth = /api.key|unauthorized|403/i.test(message);
+      throw new AutopilotError(`Gemini review call failed: ${message}`, {
+        code: isAuth ? 'auth' : isRateLimit ? 'rate_limit' : 'transient_network',
+        provider: 'gemini',
+        retryable: isRateLimit,
+      });
+    }
+
+    const rawOutput = result.response.text();
+    const usage = result.response.usageMetadata;
+    const costUSD = usage
+      ? (usage.promptTokenCount / 1_000_000) * COST_PER_M_INPUT +
+        (usage.candidatesTokenCount / 1_000_000) * COST_PER_M_OUTPUT
+      : undefined;
+
+    return {
+      findings: parseGeminiOutput(rawOutput),
+      rawOutput,
+      usage: usage
+        ? { input: usage.promptTokenCount, output: usage.candidatesTokenCount, costUSD }
+        : undefined,
+    };
+  },
+};
+
+export default geminiAdapter;
+
+function parseGeminiOutput(output: string): Finding[] {
+  const findings: Finding[] = [];
+  const regex = /### \[(CRITICAL|WARNING|NOTE)\]\s*(.+?)(?=\n### \[|## Review Summary|$)/gs;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(output)) !== null) {
+    const severity = match[1]!.toLowerCase() as Finding['severity'];
+    const body = match[2]!.trim();
+    const titleEnd = body.indexOf('\n');
+    const title = (titleEnd > 0 ? body.slice(0, titleEnd) : body).trim();
+    const suggestion = body.match(/\*\*Suggestion:\*\*\s*(.+)/s)?.[1]?.trim();
+    findings.push({
+      id: `gemini-${findings.length}`,
+      source: 'review-engine',
+      severity,
+      category: 'gemini-review',
+      file: '<unspecified>',
+      message: title,
+      suggestion,
+      protectedPath: false,
+      createdAt: new Date().toISOString(),
+    });
+  }
+  return findings;
+}

package/src/adapters/review-engine/openai-compatible.ts

@@ -0,0 +1,126 @@
+import OpenAI from 'openai';
+import type { Finding } from '../../core/findings/types.ts';
+import { AutopilotError } from '../../core/errors.ts';
+import type { Capabilities } from '../base.ts';
+import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
+
+const MAX_OUTPUT_TOKENS = 4096;
+
+const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
+
+The codebase context:
+{STACK}
+
+Provide structured feedback in exactly this format:
+
+## Review Summary
+One paragraph overall assessment.
+
+## Findings
+
+For each finding, use this format:
+### [CRITICAL|WARNING|NOTE] <short title>
+<explanation>
+**Suggestion:** <actionable fix>
+
+Rules:
+- CRITICAL: Blocks merge (security issues, data loss risks, broken contracts)
+- WARNING: Should address before merging (logic errors, missing error handling, test gaps)
+- NOTE: Improvement suggestion (style, performance, clarity)
+- Maximum 10 findings, ranked by severity
+- Be specific and constructive
+- Reference the file and line when possible`;
+
+export const openaiCompatibleAdapter: ReviewEngine = {
+  name: 'openai-compatible',
+  apiVersion: '1.0.0',
+
+  getCapabilities(): Capabilities {
+    return { structuredOutput: false, streaming: false, maxContextTokens: 128000, inlineComments: false };
+  },
+
+  estimateTokens(content: string): number {
+    return Math.ceil(content.length / 4);
+  },
+
+  async review(input: ReviewInput): Promise<ReviewOutput> {
+    const opts = (input.context as Record<string, unknown> | undefined) ?? {};
+
+    // API key: options.apiKey → named env var → OPENAI_API_KEY
+    const apiKeyEnv = (opts['apiKeyEnv'] as string | undefined) ?? 'OPENAI_API_KEY';
+    const apiKey = (opts['apiKey'] as string | undefined) ?? process.env[apiKeyEnv] ?? 'ollama';
+
+    const baseURL = (opts['baseUrl'] as string | undefined) ??
+      process.env.OPENAI_BASE_URL ??
+      undefined;
+
+    const model = opts['model'] as string | undefined;
+    if (!model) {
+      throw new AutopilotError(
+        'openai-compatible adapter requires options.model to be set in autopilot.config.yaml',
+        { code: 'invalid_config', provider: 'openai-compatible' },
+      );
+    }
+
+    const stack = input.context?.stack ?? 'A web application — stack details unspecified.';
+    const systemPrompt = SYSTEM_PROMPT_TEMPLATE.replace('{STACK}', stack);
+    const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
+
+    let response: OpenAI.Chat.ChatCompletion;
+    try {
+      response = await client.chat.completions.create({
+        model,
+        max_tokens: MAX_OUTPUT_TOKENS,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: `Please review the following:\n\n---\n\n${input.content}` },
+        ],
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const isRateLimit = /rate.limit|429/i.test(message);
+      const isAuth = /unauthorized|401|invalid.api.key/i.test(message);
+      throw new AutopilotError(`openai-compatible review call failed: ${message}`, {
+        code: isAuth ? 'auth' : isRateLimit ? 'rate_limit' : 'transient_network',
+        provider: 'openai-compatible',
+        retryable: isRateLimit,
+      });
+    }
+
+    const rawOutput = response.choices[0]?.message.content ?? '';
+    return {
+      findings: parseOutput(rawOutput),
+      rawOutput,
+      usage: response.usage
+        ? { input: response.usage.prompt_tokens, output: response.usage.completion_tokens }
+        : undefined,
+    };
+  },
+};
+
+export default openaiCompatibleAdapter;
+
+function parseOutput(output: string): Finding[] {
+  const findings: Finding[] = [];
+  const regex = /### \[(CRITICAL|WARNING|NOTE)\]\s*(.+?)(?=\n### \[|## Review Summary|$)/gs;
+  let match: RegExpExecArray | null;
+  while ((match = regex.exec(output)) !== null) {
+    const severity = match[1]!.toLowerCase() as Finding['severity'];
+    const body = match[2]!.trim();
+    const titleEnd = body.indexOf('\n');
+    const title = (titleEnd > 0 ? body.slice(0, titleEnd) : body).trim();
+    const suggestion = body.match(/\*\*Suggestion:\*\*\s*(.+)/s)?.[1]?.trim();
+    findings.push({
+      id: `openai-compatible-${findings.length}`,
+      source: 'review-engine',
+      severity,
+      category: 'openai-compatible-review',
+      file: '<unspecified>',
+      message: title,
+      suggestion,
+      protectedPath: false,
+      createdAt: new Date().toISOString(),
+    });
+  }
+  return findings;
+}

package/src/cli/run.ts

@@ -112,9 +112,10 @@ export async function runCommand(options: RunCommandOptions = {}): Promise<numbe
   let reviewEngine: ReviewEngine | undefined;
   if (config.reviewEngine) {
     const ref = typeof config.reviewEngine === 'string' ? config.reviewEngine : config.reviewEngine.adapter;
-    const hasAnyKey = !!(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY);
-    if (!hasAnyKey && (ref === 'auto' || ref === 'claude' || ref === 'codex')) {
-      console.log(fmt('yellow', '\n  [run] No LLM API key found — set ANTHROPIC_API_KEY or OPENAI_API_KEY to enable review'));
+    const hasAnyKey = !!(process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY ||
+      process.env.GOOGLE_API_KEY || process.env.OPENAI_API_KEY || process.env.GROQ_API_KEY);
+    if (!hasAnyKey && ['auto', 'claude', 'gemini', 'codex', 'openai-compatible'].includes(ref)) {
+      console.log(fmt('yellow', '\n  [run] No LLM API key found — set ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENAI_API_KEY, or GROQ_API_KEY to enable review'));
     } else {
       try {
         reviewEngine = await loadAdapter<ReviewEngine>({