Building a Coding Agent System with Gemma 4 × Antigravity — A Complete Implementation Guide for Code Review, Test Generation, and Refactoring

npm create agentkit@latest my-coding-agent
cd my-coding-agent
npm install
 
# Add to .env.local:
# GEMMA_API_KEY=YOUR_GEMMA_API_KEY
# GEMMA_MODEL=gemma-4-26b-a4b-it

// src/lib/gemma-client.ts
import { GoogleGenAI } from "@google/genai";
 
const ai = new GoogleGenAI({ apiKey: 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-26b-a4b-it",
    maxOutputTokens = 2048,
    temperature = 0.2, // Low temperature for reproducible coding tasks
    retries = 3,
  } = options;
 
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const response = await ai.models.generateContent({
        model,
        contents: userMessage,
        config: {
          systemInstruction: systemPrompt,
          maxOutputTokens,
          temperature,
        },
      });
 
      const text = 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}`
        );
      }
 
      // Always wait, not just on 429. Retrying instantly just burns
      // all three attempts on the same failure.
      const isRateLimited =
        errorMessage.includes("429") || errorMessage.includes("rate limit");
      const waitMs = isRateLimited ? 2 ** attempt * 1000 : 500;
      await new Promise((resolve) => setTimeout(resolve, waitMs));
    }
  }
 
  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
- 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) {
    // Strip unchanged context lines — they don't improve Gemma 4's accuracy
    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 sometimes wraps JSON in code fences despite instructions
    const cleaned = rawResponse
      .replace(/^```json\n?/, "")
      .replace(/\n?```$/, "")
      .trim();
 
    return JSON.parse(cleaned) as ReviewResult;
  } catch {
    // Return a graceful fallback rather than crashing the whole pipeline
    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[]; // Scenarios Gemma 4 identified but chose not to generate
}
 
const TEST_GEN_SYSTEM_PROMPT = `You are an expert test engineer specializing in TypeScript/JavaScript testing.
 
Your task: Generate test code following the EXACT style of the existing tests.
 
Rules:
- Match the existing test structure precisely
- Use the same mocking approach as existing tests
- Cover: 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 code and return a single, highest-priority refactoring proposal as JSON.
 
Priority order:
1. Security vulnerabilities
2. Performance bottlenecks (N+1, memory leaks, unnecessary loops)
3. Readability and maintainability
4. Design pattern improvements
 
Return ONLY valid JSON. Do NOT include markdown code fences in JSON 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; // Not worth refactoring
  }
 
  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 {
    return null; // Non-fatal — let Manager Agent handle the absence
  }
}

// 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[] = [];
 
  // Fire code review immediately — it only needs the diff, not individual files
  const reviewPromise = runCodeReviewAgent(
    input.diff,
    input.prTitle,
    input.prDescription
  ).catch((err: Error) => {
    errors.push(`Code review failed: ${err.message}`);
    return null;
  });
 
  // Process each file in parallel
  const fileProcessingPromises = input.changedFiles.map(async (file) => {
    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
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 });
    }
 
    // Race against Cloudflare's 30-second timeout
    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" },
      });
    }
  },
};

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))
  );
}

import pLimit from "p-limit";
const limit = pLimit(3); // Max 3 concurrent requests
 
const fileProcessingPromises = input.changedFiles.map((file) =>
  limit(async () => {
    // file processing
  })
);