Gemma 4 × Antigravity で作るコーディングエージェントシステム — コードレビュー・テスト生成・リファクタリング支援を一括処理する実装ガイド

# Antigravity ターミナルで実行
npm create agentkit@latest my-coding-agent
cd my-coding-agent
npm install
 
# Gemma 4 API（Google AI Studio）の設定
# .env.local に以下を追加
# GEMMA_API_KEY=YOUR_GEMMA_API_KEY
# GEMMA_MODEL=gemma-4-27b-it

// src/lib/gemma-client.ts
import { GoogleGenerativeAI } from "@google/generative-ai";
 
const genAI = new GoogleGenerativeAI(process.env.GEMMA_API_KEY\!);
 
export interface GemmaCallOptions {
  model?: string;
  maxOutputTokens?: number;
  temperature?: number;
  retries?: number;
}
 
export async function callGemma(
  systemPrompt: string,
  userMessage: string,
  options: GemmaCallOptions = {}
): Promise<string> {
  const {
    model = "gemma-4-27b-it",
    maxOutputTokens = 2048,
    temperature = 0.2, // コーディングタスクは低めが安定する
    retries = 3,
  } = options;
 
  const gemmaModel = genAI.getGenerativeModel({
    model,
    generationConfig: { maxOutputTokens, temperature },
    systemInstruction: systemPrompt,
  });
 
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const result = await gemmaModel.generateContent(userMessage);
      const text = result.response.text();
 
      if (\!text || text.trim().length === 0) {
        throw new Error("Empty response from Gemma 4");
      }
 
      return text;
    } catch (error: unknown) {
      const isLastAttempt = attempt === retries;
      const errorMessage = error instanceof Error ? error.message : String(error);
 
      if (isLastAttempt) {
        throw new Error(
          `Gemma 4 call failed after ${retries} attempts: ${errorMessage}`
        );
      }
 
      // 429 (rate limit) の場合は指数バックオフで待機
      if (
        errorMessage.includes("429") ||
        errorMessage.includes("rate limit")
      ) {
        await new Promise((resolve) =>
          setTimeout(resolve, 2 ** attempt * 1000)
        );
      }
    }
  }
 
  throw new Error("Unreachable");
}

// src/agents/code-review.ts
import { callGemma } from "../lib/gemma-client";
 
export interface ReviewComment {
  file: string;
  line: number;
  severity: "error" | "warning" | "suggestion";
  category: "security" | "performance" | "style" | "logic" | "test-coverage";
  message: string;
  suggestion?: string; // 修正案（省略可能）
}
 
export interface ReviewResult {
  comments: ReviewComment[];
  summary: string;
  approvalStatus: "approved" | "changes-requested" | "comment";
}
 
const CODE_REVIEW_SYSTEM_PROMPT = `You are an expert code reviewer. Analyze the provided git diff and return feedback as valid JSON only.
 
Rules:
- Focus only on the changed lines in the diff
- Do NOT comment on unchanged code
- Return JSON matching the ReviewResult type exactly
- If no issues found, return empty comments array with "approved" status
- severity "error" = blocks merge, "warning" = should fix, "suggestion" = optional improvement
- Be specific: include the actual problematic code snippet in the message
- Return ONLY valid JSON. Do NOT wrap in markdown code fences.`;
 
export async function runCodeReviewAgent(
  diff: string,
  prTitle: string,
  prDescription: string
): Promise<ReviewResult> {
  const MAX_DIFF_CHARS = 8000;
  let processedDiff = diff;
 
  if (diff.length > MAX_DIFF_CHARS) {
    // 変更行のみに絞り込む（+/-行以外は省略してコンテキスト節約）
    processedDiff = diff
      .split("\n")
      .filter(
        (line) =>
          line.startsWith("+") ||
          line.startsWith("-") ||
          line.startsWith("@@") ||
          line.startsWith("diff")
      )
      .join("\n")
      .slice(0, MAX_DIFF_CHARS);
 
    processedDiff += "\n[... diff truncated for context limit ...]";
  }
 
  const userMessage = `PR Title: ${prTitle}
PR Description: ${prDescription}
 
Git Diff:
\`\`\`diff
${processedDiff}
\`\`\`
 
Review this code change and return JSON only.`;
 
  const rawResponse = await callGemma(CODE_REVIEW_SYSTEM_PROMPT, userMessage, {
    temperature: 0.1,
    maxOutputTokens: 1024,
  });
 
  try {
    // Gemma 4がコードブロックで包む場合があるので除去
    const cleaned = rawResponse
      .replace(/^```json\n?/, "")
      .replace(/\n?```$/, "")
      .trim();
 
    return JSON.parse(cleaned) as ReviewResult;
  } catch {
    // パース失敗時はフォールバック応答を返す（全体を止めない）
    console.error(
      "Failed to parse code review response:",
      rawResponse.slice(0, 200)
    );
    return {
      comments: [],
      summary:
        "Review completed but response parsing failed. Manual review recommended.",
      approvalStatus: "comment",
    };
  }
}

// src/agents/test-gen.ts
import { callGemma } from "../lib/gemma-client";
 
export interface TestGenerationResult {
  testCode: string;
  testFilePath: string;
  testFramework: "vitest" | "jest" | "unknown";
  coveredScenarios: string[];
  missingScenarios: string[]; // Gemma 4が「本来テストすべきだが今回省いた」と判断したもの
}
 
const TEST_GEN_SYSTEM_PROMPT = `You are an expert test engineer specializing in TypeScript/JavaScript testing.
 
Your task: Generate test code for the provided source file, following the EXACT style of the existing tests.
 
Rules:
- Match the existing test structure precisely (same describe/it patterns, same assertion style)
- Use the same mocking approach as existing tests
- Generate tests for: happy path, edge cases, error cases
- Return ONLY valid JSON. Do NOT wrap in markdown code fences.
- The test code must be ready to run without modification`;
 
export async function runTestGenerationAgent(params: {
  sourceFile: string;
  sourcePath: string;
  existingTestFile?: string;
  existingTestPath?: string;
  testFramework: string;
}): Promise<TestGenerationResult> {
  const { sourceFile, sourcePath, existingTestFile, existingTestPath, testFramework } = params;
 
  const existingTestSection = existingTestFile
    ? `## Existing Test Example (FOLLOW THIS STYLE EXACTLY)
File: ${existingTestPath}
\`\`\`typescript
${existingTestFile.slice(0, 3000)}${existingTestFile.length > 3000 ? "\n// ... (truncated)" : ""}
\`\`\``
    : `## No existing tests found. Use ${testFramework} best practices.`;
 
  const userMessage = `${existingTestSection}
 
## Source File to Test
File: ${sourcePath}
\`\`\`typescript
${sourceFile}
\`\`\`
 
Generate comprehensive tests. Return JSON only:
{"testCode":"...","testFilePath":"...","testFramework":"vitest|jest|unknown","coveredScenarios":["..."],"missingScenarios":["..."]}`;
 
  const rawResponse = await callGemma(TEST_GEN_SYSTEM_PROMPT, userMessage, {
    maxOutputTokens: 2048,
    temperature: 0.1,
  });
 
  try {
    const cleaned = rawResponse
      .replace(/^```json\n?/, "")
      .replace(/\n?```$/, "")
      .trim();
 
    const result = JSON.parse(cleaned) as TestGenerationResult;
 
    if (\!result.testCode || result.testCode.trim().length < 50) {
      throw new Error("Generated test code is too short or empty");
    }
 
    return result;
  } catch (error) {
    const errorMessage = error instanceof Error ? error.message : String(error);
    throw new Error(`Test generation failed: ${errorMessage}`);
  }
}

// src/agents/refactor.ts
import { callGemma } from "../lib/gemma-client";
 
export interface RefactoringProposal {
  original: string;
  refactored: string;
  rationale: string;
  impactLevel: "low" | "medium" | "high";
  breakingChange: boolean;
  estimatedEffort: "minutes" | "hours" | "days";
  relatedPatterns: string[];
}
 
const REFACTOR_SYSTEM_PROMPT = `You are a senior software architect specializing in code refactoring.
 
Analyze the provided code and return a single, highest-priority refactoring proposal as JSON.
 
Focus on one of these, in priority order:
1. Security vulnerabilities
2. Performance bottlenecks (N+1, unnecessary loops, memory leaks)
3. Readability and maintainability
4. Design pattern improvements
 
Return ONLY valid JSON. Do NOT include markdown code fences in the JSON string values.`;
 
export async function runRefactoringAgent(params: {
  targetCode: string;
  language: string;
  context?: string;
}): Promise<RefactoringProposal | null> {
  const { targetCode, language, context } = params;
 
  // コードが短すぎる場合はスキップ
  if (targetCode.trim().split("\n").length < 5) {
    return null;
  }
 
  const userMessage = `Language: ${language}
${context ? `Context: ${context}\n` : ""}
Code to refactor:
\`\`\`${language}
${targetCode}
\`\`\`
 
Return the highest-priority refactoring as JSON:
{"original":"...","refactored":"...","rationale":"...","impactLevel":"low|medium|high","breakingChange":false,"estimatedEffort":"minutes|hours|days","relatedPatterns":["..."]}`;
 
  const rawResponse = await callGemma(REFACTOR_SYSTEM_PROMPT, userMessage, {
    temperature: 0.15,
    maxOutputTokens: 1500,
  });
 
  try {
    const cleaned = rawResponse
      .replace(/^```json\n?/, "")
      .replace(/\n?```$/, "")
      .trim();
 
    return JSON.parse(cleaned) as RefactoringProposal;
  } catch {
    // リファクタリング提案の失敗は非致命的 — nullを返してManager Agentに判断させる
    return null;
  }
}

// src/agents/manager.ts
import { runCodeReviewAgent, ReviewResult } from "./code-review";
import { runTestGenerationAgent, TestGenerationResult } from "./test-gen";
import { runRefactoringAgent, RefactoringProposal } from "./refactor";
 
export interface CodingAgentInput {
  diff: string;
  prTitle: string;
  prDescription: string;
  changedFiles: Array<{
    path: string;
    content: string;
    testFilePath?: string;
    testFileContent?: string;
    language: string;
  }>;
}
 
export interface CodingAgentOutput {
  review: ReviewResult | null;
  tests: TestGenerationResult[];
  refactoring: RefactoringProposal[];
  processingTime: number;
  errors: string[];
}
 
export async function runCodingAgentSystem(
  input: CodingAgentInput
): Promise<CodingAgentOutput> {
  const startTime = Date.now();
  const errors: string[] = [];
  const tests: TestGenerationResult[] = [];
  const refactoring: RefactoringProposal[] = [];
 
  // コードレビューを並列で開始（diffはファイルに依存しないため先行実行可能）
  const reviewPromise = runCodeReviewAgent(
    input.diff,
    input.prTitle,
    input.prDescription
  ).catch((err: Error) => {
    errors.push(`Code review failed: ${err.message}`);
    return null;
  });
 
  // テスト生成とリファクタリングを並列で実行
  const fileProcessingPromises = input.changedFiles.map(async (file) => {
    // TypeScript/JavaScriptファイルのみテスト生成対象
    if (["ts", "tsx", "js", "jsx"].some((ext) => file.path.endsWith(`.${ext}`))) {
      try {
        const testResult = await runTestGenerationAgent({
          sourceFile: file.content,
          sourcePath: file.path,
          existingTestFile: file.testFileContent,
          existingTestPath: file.testFilePath,
          testFramework: detectTestFramework(file.testFileContent),
        });
        tests.push(testResult);
      } catch (err: unknown) {
        const errorMessage = err instanceof Error ? err.message : String(err);
        errors.push(`Test generation failed for ${file.path}: ${errorMessage}`);
      }
    }
 
    // 全ファイルでリファクタリング提案を取得
    try {
      const refactorResult = await runRefactoringAgent({
        targetCode: file.content,
        language: file.language,
      });
      if (refactorResult) {
        refactoring.push(refactorResult);
      }
    } catch (err: unknown) {
      const errorMessage = err instanceof Error ? err.message : String(err);
      errors.push(
        `Refactoring analysis failed for ${file.path}: ${errorMessage}`
      );
    }
  });
 
  const [review] = await Promise.all([
    reviewPromise,
    Promise.all(fileProcessingPromises),
  ]);
 
  return {
    review,
    tests,
    refactoring,
    processingTime: Date.now() - startTime,
    errors,
  };
}
 
function detectTestFramework(testFileContent?: string): string {
  if (\!testFileContent) return "vitest";
  if (
    testFileContent.includes("from 'vitest'") ||
    testFileContent.includes('from "vitest"')
  ) {
    return "vitest";
  }
  if (
    testFileContent.includes("from 'jest'") ||
    testFileContent.includes("@jest/globals")
  ) {
    return "jest";
  }
  return "vitest";
}

// src/index.ts (Cloudflare Workers エントリポイント)
import { runCodingAgentSystem, CodingAgentInput } from "./agents/manager";
 
interface Env {
  WEBHOOK_TOKEN: string;
  GEMMA_API_KEY: string;
}
 
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method \!== "POST") {
      return new Response("Method not allowed", { status: 405 });
    }
 
    const authHeader = request.headers.get("Authorization");
    if (authHeader \!== `Bearer ${env.WEBHOOK_TOKEN}`) {
      return new Response("Unauthorized", { status: 401 });
    }
 
    let input: CodingAgentInput;
    try {
      input = (await request.json()) as CodingAgentInput;
    } catch {
      return new Response("Invalid JSON body", { status: 400 });
    }
 
    // Cloudflare Workers の30秒タイムアウト対策
    const timeoutMs = 25000;
    const agentPromise = runCodingAgentSystem(input);
    const timeoutPromise = new Promise<never>((_, reject) =>
      setTimeout(() => reject(new Error("Processing timeout")), timeoutMs)
    );
 
    try {
      const result = await Promise.race([agentPromise, timeoutPromise]);
      return new Response(JSON.stringify(result), {
        headers: { "Content-Type": "application/json" },
      });
    } catch (error: unknown) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      return new Response(JSON.stringify({ error: errorMessage }), {
        status: 500,
        headers: { "Content-Type": "application/json" },
      });
    }
  },
};

// 不要なAPI呼び出しを事前にスキップ
function shouldSkipReview(diff: string): boolean {
  const nonCodeExtensions = [".md", ".txt", ".json", ".yml", ".yaml", ".toml"];
  const changedFiles = diff
    .split("\n")
    .filter((line) => line.startsWith("diff --git"))
    .map((line) => line.split(" b/")[1]);
 
  return changedFiles.every((file) =>
    nonCodeExtensions.some((ext) => file?.endsWith(ext))
  );
}
 
function shouldSkipTestGeneration(filePath: string): boolean {
  return (
    filePath.includes(".test.") ||
    filePath.includes(".spec.") ||
    filePath.endsWith(".d.ts") ||
    filePath.includes("config.") ||
    filePath.includes("/constants/")
  );
}

import pLimit from "p-limit";
const limit = pLimit(3); // 同時3リクエストまで
 
const fileProcessingPromises = input.changedFiles.map((file) =>
  limit(async () => {
    // ファイル処理のコード
  })
);