Automating Bug Resolution: How LLMs Slash Debugging Time and Development Costs

┌────────────────────────────────────────────────────────────────────────┐
│               Production Crash or Failing CI Test Run                  │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │ Stack Trace & Error Message
                                    ▼
┌────────────────────────────────────────────────────────────────────────┐
│                   Context Gathering Engine (AST Slicer)                │
│    Extracts offending source files, local functions, and git history   │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │ Structured Prompt
                                    ▼
┌────────────────────────────────────────────────────────────────────────┐
│                LLM Debugger Agent (Claude 3.5 / GPT-4o)                │
│                                                                        │
│   • Diagnoses root cause                                               │
│   • Generates unified diff patch                                       │
│   • Writes regression reproduction unit test                           │
└───────────────────────────────────┬────────────────────────────────────┘
                                    │ Candidate Patch
                                    ▼
┌────────────────────────────────────────────────────────────────────────┐
│                     Sandboxed Test Verification                        │
│             Applies git patch & executes 'npm test' in Docker          │
└──────────────────┬──────────────────────────────────┬──────────────────┘
                   │                                  │
                   │ Tests Pass                       │ Tests Fail
                   ▼                                  ▼
┌──────────────────────────────────────┐ ┌───────────────────────────────┐
│ Automated Pull Request Opened        │ │ Reflection Feedback Loop      │
│ Includes RCA summary & test proof    │ │ Feeds test error back to LLM  │
└──────────────────────────────────────┘ └───────────────────────────────┘

// src/agent/contextExtractor.ts
import fs from "fs";
import path from "path";

export interface BugContext {
  filePath: string;
  lineNumber: number;
  errorMessage: string;
  codeSnippet: string;
}

export function extractBugContext(stackTrace: string, repoRoot: string): BugContext | null {
  // Regex matching typical Node/TypeScript stack trace line: at Object.<anonymous> (/app/src/utils.ts:42:15)
  const match = stackTrace.match(/(?:ats+.*?()?([/\].*?.(?:ts|js|tsx|jsx)):(d+):(d+))?/);
  if (!match) return null;

  const [, rawPath, lineStr] = match;
  const targetPath = path.isAbsolute(rawPath) ? rawPath : path.join(repoRoot, rawPath);
  const lineNumber = parseInt(lineStr, 10);

  if (!fs.existsSync(targetPath)) return null;

  const fileLines = fs.readFileSync(targetPath, "utf8").split("
");
  const start = Math.max(0, lineNumber - 15);
  const end = Math.min(fileLines.length, lineNumber + 15);

  const snippet = fileLines
    .slice(start, end)
    .map((line, idx) => `${start + idx + 1}: ${line}`)
    .join("
");

  return {
    filePath: targetPath,
    lineNumber,
    errorMessage: stackTrace.split("
")[0],
    codeSnippet: snippet,
  };
}

// src/agent/BugFixAgent.ts
import { OpenAI } from "openai";
import { z } from "zod";
import { BugContext } from "./contextExtractor";

const openai = new OpenAI();

// Structured Output Schema
const BugFixSchema = z.object({
  rootCauseAnalysis: z.string().describe("Concise explanation of the underlying software defect"),
  suggestedPatch: z.string().describe("The exact code replacement or unified diff"),
  fixedCodeContent: z.string().describe("The complete fixed file content ready to write to disk"),
  regressionTestCode: z.string().describe("A runnable Vitest/Jest unit test that reproduces and verifies the fix"),
});

export class BugFixAgent {
  public async analyzeAndRepair(context: BugContext): Promise<z.infer<typeof BugFixSchema>> {
    const prompt = `
You are an expert Principal Software Engineer. A production crash occurred with the following diagnostic details:

Error: ${context.errorMessage}
File: ${context.filePath} (Crash line: ${context.lineNumber})

Source Code Snippet around crash site:
```typescript
${context.codeSnippet}

---

### 3. Verification & Automated Pull Request Pipeline

```typescript
// src/agent/runRepairPipeline.ts
import { execSync } from "child_process";
import fs from "fs";
import { extractBugContext } from "./contextExtractor";
import { BugFixAgent } from "./BugFixAgent";

export async function runAutomatedRepair(rawCrashLog: string) {
  console.log("🔍 Analyzing incoming crash report...");
  const context = extractBugContext(rawCrashLog, process.cwd());

  if (!context) {
    console.error("Could not correlate crash log to physical source file.");
    return;
  }

  const agent = new BugFixAgent();
  const solution = await agent.analyzeAndRepair(context);

  console.log("
--- Root Cause Analysis ---");
  console.log(solution.rootCauseAnalysis);

  // 1. Create a dedicated git branch
  const branchName = `ai-fix/crash-${Date.now()}`;
  execSync(`git checkout -b ${branchName}`);

  // 2. Apply the fix to disk
  fs.writeFileSync(context.filePath, solution.fixedCodeContent, "utf8");

  // 3. Write generated regression test
  const testPath = context.filePath.replace(/.ts$/, ".spec.ts");
  fs.writeFileSync(testPath, solution.regressionTestCode, "utf8");

  // 4. Run verification tests
  try {
    console.log("🧪 Executing test suite against patched codebase...");
    execSync("npm test", { stdio: "inherit" });
    console.log("✅ Verification successful! Tests pass cleanly.");

    // 5. Commit and stage PR
    execSync("git add .");
    execSync(`git commit -m "fix: auto-remediation for ${context.errorMessage.slice(0, 50)}"`);
    console.log(`🚀 Ready to open Pull Request from branch ${branchName}`);
  } catch (testError) {
    console.error("❌ Generated patch failed test verification. Reverting git state.");
    execSync("git reset --hard HEAD");
  }
}