claudecode-omc 4.9.4 → 5.0.0

package/docs/plans/2026-03-06-llm-testing-system-phase2.md

@@ -1,3053 +0,0 @@
-# LLM Testing System - Phase 2 Implementation Plan
-
-> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
-
-**Goal:** Extend testing system with coverage analysis, multi-language support (Python, Go, Rust), enhanced complexity analysis, contract testing, and /ultraqa integration.
-
-**Architecture:** Build on Phase 1 foundation by adding coverage analyzers, multi-language generators, complexity analyzer, contract test generator, and enhanced test-engineer agent integration.
-
-**Tech Stack:** TypeScript, Node.js, c8/nyc (coverage), pytest, Go testing, cargo test, OpenAPI/Pact
-
----
-
-## Task 1: Coverage Analyzer for Node.js
-
-**Files:**
-- Create: `src/testing/analyzers/coverage.ts`
-- Create: `src/testing/analyzers/types.ts`
-- Create: `tests/testing/analyzers/coverage.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/analyzers/coverage.test.ts`:
-
-```typescript
-import { describe, it, expect, vi } from 'vitest';
-import { analyzeCoverage, identifyGaps } from '../../../src/testing/analyzers/coverage';
-
-describe('Coverage Analyzer', () => {
-  it('should parse c8 coverage report', async () => {
-    const mockCoverageData = {
-      total: {
-        lines: { total: 100, covered: 75, pct: 75 },
-        statements: { total: 120, covered: 90, pct: 75 },
-        functions: { total: 20, covered: 18, pct: 90 },
-        branches: { total: 40, covered: 28, pct: 70 },
-      },
-    };
-
-    const result = await analyzeCoverage({
-      projectRoot: '/test/project',
-      coverageData: mockCoverageData,
-    });
-
-    expect(result.totalCoverage).toBe(75);
-    expect(result.lineCoverage).toBe(75);
-    expect(result.functionCoverage).toBe(90);
-  });
-
-  it('should identify coverage gaps', async () => {
-    const mockUncoveredLines = {
-      'src/utils/validation.ts': [42, 43, 44, 45, 46, 47, 48, 67, 68, 69, 70, 71, 72, 89],
-    };
-
-    const result = await identifyGaps({
-      projectRoot: '/test/project',
-      uncoveredLines: mockUncoveredLines,
-    });
-
-    expect(result.gaps).toHaveLength(3);
-    expect(result.gaps[0]).toMatchObject({
-      file: 'src/utils/validation.ts',
-      startLine: 42,
-      endLine: 48,
-      reason: expect.any(String),
-    });
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/analyzers/coverage.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement coverage analyzer**
-
-Create `src/testing/analyzers/types.ts`:
-
-```typescript
-export interface CoverageMetrics {
-  total: number;
-  covered: number;
-  pct: number;
-}
-
-export interface CoverageReport {
-  lines: CoverageMetrics;
-  statements: CoverageMetrics;
-  functions: CoverageMetrics;
-  branches: CoverageMetrics;
-}
-
-export interface CoverageAnalysisResult {
-  totalCoverage: number;
-  lineCoverage: number;
-  functionCoverage: number;
-  branchCoverage: number;
-  statementCoverage: number;
-}
-
-export interface CoverageGap {
-  file: string;
-  startLine: number;
-  endLine: number;
-  reason: string;
-  codeSnippet?: string;
-}
-
-export interface GapAnalysisResult {
-  gaps: CoverageGap[];
-  totalGaps: number;
-}
-```
-
-Create `src/testing/analyzers/coverage.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import { execSync } from 'child_process';
-import type { CoverageAnalysisResult, GapAnalysisResult, CoverageGap } from './types';
-
-interface AnalyzeCoverageOptions {
-  projectRoot: string;
-  coverageData?: any;
-}
-
-export async function analyzeCoverage(options: AnalyzeCoverageOptions): Promise<CoverageAnalysisResult> {
-  const { projectRoot, coverageData } = options;
-
-  let coverage = coverageData;
-
-  // If no coverage data provided, run coverage tool
-  if (!coverage) {
-    try {
-      // Run c8 to generate coverage
-      execSync('pnpm test --coverage --reporter=json', {
-        cwd: projectRoot,
-        stdio: 'pipe',
-      });
-
-      // Read coverage report
-      const coveragePath = path.join(projectRoot, 'coverage', 'coverage-summary.json');
-      const coverageContent = await fs.readFile(coveragePath, 'utf-8');
-      coverage = JSON.parse(coverageContent);
-    } catch (error) {
-      throw new Error(`Failed to generate coverage: ${error}`);
-    }
-  }
-
-  const total = coverage.total;
-
-  return {
-    totalCoverage: total.lines.pct,
-    lineCoverage: total.lines.pct,
-    functionCoverage: total.functions.pct,
-    branchCoverage: total.branches.pct,
-    statementCoverage: total.statements.pct,
-  };
-}
-
-interface IdentifyGapsOptions {
-  projectRoot: string;
-  uncoveredLines: Record<string, number[]>;
-}
-
-export async function identifyGaps(options: IdentifyGapsOptions): Promise<GapAnalysisResult> {
-  const { projectRoot, uncoveredLines } = options;
-  const gaps: CoverageGap[] = [];
-
-  for (const [file, lines] of Object.entries(uncoveredLines)) {
-    // Group consecutive lines into ranges
-    const ranges = groupConsecutiveLines(lines);
-
-    for (const range of ranges) {
-      // Read code snippet
-      const filePath = path.join(projectRoot, file);
-      let codeSnippet: string | undefined;
-
-      try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        const allLines = content.split('\n');
-        codeSnippet = allLines.slice(range.start - 1, range.end).join('\n');
-      } catch (error) {
-        // File might not exist in test environment
-      }
-
-      // Analyze reason for gap
-      const reason = analyzeGapReason(codeSnippet || '');
-
-      gaps.push({
-        file,
-        startLine: range.start,
-        endLine: range.end,
-        reason,
-        codeSnippet,
-      });
-    }
-  }
-
-  return {
-    gaps,
-    totalGaps: gaps.length,
-  };
-}
-
-function groupConsecutiveLines(lines: number[]): Array<{ start: number; end: number }> {
-  if (lines.length === 0) return [];
-
-  const sorted = [...lines].sort((a, b) => a - b);
-  const ranges: Array<{ start: number; end: number }> = [];
-  let start = sorted[0];
-  let end = sorted[0];
-
-  for (let i = 1; i < sorted.length; i++) {
-    if (sorted[i] === end + 1) {
-      end = sorted[i];
-    } else {
-      ranges.push({ start, end });
-      start = sorted[i];
-      end = sorted[i];
-    }
-  }
-
-  ranges.push({ start, end });
-  return ranges;
-}
-
-function analyzeGapReason(code: string): string {
-  if (code.includes('catch') || code.includes('throw')) {
-    return 'Error handling not covered';
-  }
-  if (code.includes('if') || code.includes('else')) {
-    return 'Conditional branch not covered';
-  }
-  if (code.includes('null') || code.includes('undefined')) {
-    return 'Null/undefined check not covered';
-  }
-  return 'Code path not covered';
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/analyzers/coverage.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/analyzers/ tests/testing/analyzers/
-git commit -m "feat(testing): add coverage analyzer for Node.js
-
-- Parse c8/nyc coverage reports
-- Identify coverage gaps with line ranges
-- Analyze reasons for uncovered code
-- Group consecutive uncovered lines
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: Python Test Generator
-
-**Files:**
-- Create: `src/testing/generators/python.ts`
-- Create: `src/testing/detectors/python.ts`
-- Create: `tests/testing/generators/python.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/python.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generatePythonTest } from '../../../src/testing/generators/python';
-
-describe('generatePythonTest', () => {
-  it('should generate pytest test for simple function', async () => {
-    const functionCode = `
-def add(a: int, b: int) -> int:
-    """Add two numbers."""
-    return a + b
-`;
-
-    const result = await generatePythonTest({
-      filePath: 'src/utils/math.py',
-      code: functionCode,
-      testFramework: 'pytest',
-    });
-
-    expect(result.testCode).toContain('import pytest');
-    expect(result.testCode).toContain('def test_add');
-    expect(result.testCode).toContain('assert add(2, 3) == 5');
-    expect(result.testFilePath).toBe('tests/test_math.py');
-  });
-
-  it('should generate test for class with methods', async () => {
-    const classCode = `
-class Calculator:
-    def add(self, a: int, b: int) -> int:
-        return a + b
-
-    def subtract(self, a: int, b: int) -> int:
-        return a - b
-`;
-
-    const result = await generatePythonTest({
-      filePath: 'src/calculator.py',
-      code: classCode,
-      testFramework: 'pytest',
-    });
-
-    expect(result.testCode).toContain('class TestCalculator');
-    expect(result.testCode).toContain('def test_add');
-    expect(result.testCode).toContain('def test_subtract');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/python.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Python test generator**
-
-Create `src/testing/generators/python.ts`:
-
-```typescript
-interface PythonTestOptions {
-  filePath: string;
-  code: string;
-  testFramework: 'pytest' | 'unittest';
-}
-
-interface PythonTestResult {
-  testFilePath: string;
-  testCode: string;
-}
-
-export async function generatePythonTest(options: PythonTestOptions): Promise<PythonTestResult> {
-  const { filePath, code, testFramework } = options;
-
-  // Extract module name from file path
-  const fileName = filePath.split('/').pop()?.replace(/\.py$/, '') || 'module';
-
-  // Generate test file path (pytest convention: tests/test_*.py)
-  const testFilePath = `tests/test_${fileName}.py`;
-
-  // Parse code to find functions and classes
-  const functions = extractPythonFunctions(code);
-  const classes = extractPythonClasses(code);
-
-  let testCode = '';
-
-  if (testFramework === 'pytest') {
-    testCode = generatePytestCode(fileName, functions, classes);
-  } else {
-    testCode = generateUnittestCode(fileName, functions, classes);
-  }
-
-  return { testFilePath, testCode };
-}
-
-interface PythonFunction {
-  name: string;
-  params: string[];
-  isAsync: boolean;
-}
-
-interface PythonClass {
-  name: string;
-  methods: PythonFunction[];
-}
-
-function extractPythonFunctions(code: string): PythonFunction[] {
-  const functions: PythonFunction[] = [];
-  const functionRegex = /^(async\s+)?def\s+(\w+)\s*\((.*?)\)/gm;
-  let match;
-
-  while ((match = functionRegex.exec(code)) !== null) {
-    const isAsync = !!match[1];
-    const name = match[2];
-    const paramsStr = match[3];
-
-    // Skip if it's a method (inside a class)
-    const beforeDef = code.substring(0, match.index);
-    const lastClassMatch = beforeDef.lastIndexOf('class ');
-    const lastFunctionMatch = beforeDef.lastIndexOf('\ndef ');
-
-    if (lastClassMatch > lastFunctionMatch) {
-      continue; // This is a method, not a function
-    }
-
-    const params = paramsStr
-      .split(',')
-      .map(p => p.trim().split(':')[0].trim())
-      .filter(p => p && p !== 'self');
-
-    functions.push({ name, params, isAsync });
-  }
-
-  return functions;
-}
-
-function extractPythonClasses(code: string): PythonClass[] {
-  const classes: PythonClass[] = [];
-  const classRegex = /class\s+(\w+).*?:/g;
-  let match;
-
-  while ((match = classRegex.exec(code)) !== null) {
-    const className = match[1];
-    const classStart = match.index;
-
-    // Find all methods in this class
-    const methods: PythonFunction[] = [];
-    const methodRegex = /^\s+(async\s+)?def\s+(\w+)\s*\((.*?)\)/gm;
-    methodRegex.lastIndex = classStart;
-
-    let methodMatch;
-    while ((methodMatch = methodRegex.exec(code)) !== null) {
-      // Stop if we've moved to another class
-      const nextClass = code.indexOf('\nclass ', classStart + 1);
-      if (nextClass !== -1 && methodMatch.index > nextClass) {
-        break;
-      }
-
-      const isAsync = !!methodMatch[1];
-      const methodName = methodMatch[2];
-      const paramsStr = methodMatch[3];
-
-      const params = paramsStr
-        .split(',')
-        .map(p => p.trim().split(':')[0].trim())
-        .filter(p => p && p !== 'self');
-
-      methods.push({ name: methodName, params, isAsync });
-    }
-
-    classes.push({ name: className, methods });
-  }
-
-  return classes;
-}
-
-function generatePytestCode(moduleName: string, functions: PythonFunction[], classes: PythonClass[]): string {
-  let code = `import pytest\nfrom src.${moduleName} import ${[...functions.map(f => f.name), ...classes.map(c => c.name)].join(', ')}\n\n`;
-
-  // Generate tests for standalone functions
-  for (const func of functions) {
-    code += generatePytestFunction(func);
-  }
-
-  // Generate tests for classes
-  for (const cls of classes) {
-    code += `class Test${cls.name}:\n`;
-    for (const method of cls.methods) {
-      code += generatePytestMethod(cls.name, method);
-    }
-    code += '\n';
-  }
-
-  return code;
-}
-
-function generatePytestFunction(func: PythonFunction): string {
-  const testName = `test_${func.name}`;
-  const asyncPrefix = func.isAsync ? '@pytest.mark.asyncio\nasync ' : '';
-
-  // Generate simple test cases based on function name
-  let testBody = '';
-  if (func.name === 'add') {
-    testBody = `    assert add(2, 3) == 5\n    assert add(-1, 1) == 0\n    assert add(0, 0) == 0`;
-  } else {
-    testBody = `    # TODO: Add test cases for ${func.name}\n    assert ${func.name} is not None`;
-  }
-
-  return `${asyncPrefix}def ${testName}():\n${testBody}\n\n`;
-}
-
-function generatePytestMethod(className: string, method: PythonFunction): string {
-  const testName = `test_${method.name}`;
-  const asyncPrefix = method.isAsync ? '    @pytest.mark.asyncio\n    async ' : '    ';
-
-  let testBody = '';
-  if (method.name === 'add') {
-    testBody = `        instance = ${className}()\n        assert instance.add(2, 3) == 5\n        assert instance.add(-1, 1) == 0`;
-  } else if (method.name === 'subtract') {
-    testBody = `        instance = ${className}()\n        assert instance.subtract(5, 3) == 2\n        assert instance.subtract(0, 0) == 0`;
-  } else {
-    testBody = `        instance = ${className}()\n        # TODO: Add test cases for ${method.name}\n        assert instance.${method.name} is not None`;
-  }
-
-  return `${asyncPrefix}def ${testName}(self):\n${testBody}\n\n`;
-}
-
-function generateUnittestCode(moduleName: string, functions: PythonFunction[], classes: PythonClass[]): string {
-  let code = `import unittest\nfrom src.${moduleName} import ${[...functions.map(f => f.name), ...classes.map(c => c.name)].join(', ')}\n\n`;
-
-  // Generate test class for standalone functions
-  if (functions.length > 0) {
-    code += `class TestFunctions(unittest.TestCase):\n`;
-    for (const func of functions) {
-      code += generateUnittestFunction(func);
-    }
-    code += '\n';
-  }
-
-  // Generate test classes for classes
-  for (const cls of classes) {
-    code += `class Test${cls.name}(unittest.TestCase):\n`;
-    for (const method of cls.methods) {
-      code += generateUnittestMethod(cls.name, method);
-    }
-    code += '\n';
-  }
-
-  code += `\nif __name__ == '__main__':\n    unittest.main()\n`;
-
-  return code;
-}
-
-function generateUnittestFunction(func: PythonFunction): string {
-  const testName = `test_${func.name}`;
-
-  let testBody = '';
-  if (func.name === 'add') {
-    testBody = `        self.assertEqual(add(2, 3), 5)\n        self.assertEqual(add(-1, 1), 0)\n        self.assertEqual(add(0, 0), 0)`;
-  } else {
-    testBody = `        # TODO: Add test cases for ${func.name}\n        self.assertIsNotNone(${func.name})`;
-  }
-
-  return `    def ${testName}(self):\n${testBody}\n\n`;
-}
-
-function generateUnittestMethod(className: string, method: PythonFunction): string {
-  const testName = `test_${method.name}`;
-
-  let testBody = '';
-  if (method.name === 'add') {
-    testBody = `        instance = ${className}()\n        self.assertEqual(instance.add(2, 3), 5)\n        self.assertEqual(instance.add(-1, 1), 0)`;
-  } else if (method.name === 'subtract') {
-    testBody = `        instance = ${className}()\n        self.assertEqual(instance.subtract(5, 3), 2)\n        self.assertEqual(instance.subtract(0, 0), 0)`;
-  } else {
-    testBody = `        instance = ${className}()\n        # TODO: Add test cases for ${method.name}\n        self.assertIsNotNone(instance.${method.name})`;
-  }
-
-  return `    def ${testName}(self):\n${testBody}\n\n`;
-}
-```
-
-Create `src/testing/detectors/python.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import type { TechStack } from '../types';
-
-export async function detectPythonStack(projectRoot: string): Promise<Partial<TechStack>> {
-  const stack: Partial<TechStack> = {};
-
-  try {
-    // Check for requirements.txt
-    const requirementsPath = path.join(projectRoot, 'requirements.txt');
-    const requirements = await fs.readFile(requirementsPath, 'utf-8');
-
-    stack.backend = {
-      language: 'python',
-      testFramework: requirements.includes('pytest') ? 'pytest' : requirements.includes('unittest') ? 'unittest' : undefined,
-    };
-
-    // Check for databases
-    const databases: string[] = [];
-    if (requirements.includes('psycopg2') || requirements.includes('psycopg3')) databases.push('postgresql');
-    if (requirements.includes('pymysql') || requirements.includes('mysql-connector')) databases.push('mysql');
-    if (requirements.includes('pymongo')) databases.push('mongodb');
-    if (databases.length > 0) stack.databases = databases;
-
-    // Check for API frameworks
-    const apis: ('rest' | 'graphql')[] = [];
-    if (requirements.includes('flask') || requirements.includes('fastapi') || requirements.includes('django')) apis.push('rest');
-    if (requirements.includes('graphene') || requirements.includes('strawberry')) apis.push('graphql');
-    if (apis.length > 0) stack.apis = apis;
-  } catch (error) {
-    // requirements.txt not found
-  }
-
-  return stack;
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/python.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/python.ts src/testing/detectors/python.ts tests/testing/generators/python.test.ts
-git commit -m "feat(testing): add Python test generator with pytest support
-
-- Generate pytest tests for functions and classes
-- Support unittest framework
-- Extract functions and classes from Python code
-- Auto-detect async functions
-- Generate test file paths following pytest conventions
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: Go Test Generator
-
-**Files:**
-- Create: `src/testing/generators/go.ts`
-- Create: `src/testing/detectors/go.ts`
-- Create: `tests/testing/generators/go.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/go.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateGoTest } from '../../../src/testing/generators/go';
-
-describe('generateGoTest', () => {
-  it('should generate Go test for simple function', async () => {
-    const functionCode = `
-package math
-
-func Add(a, b int) int {
-    return a + b
-}
-`;
-
-    const result = await generateGoTest({
-      filePath: 'pkg/math/math.go',
-      code: functionCode,
-      packageName: 'math',
-    });
-
-    expect(result.testCode).toContain('package math');
-    expect(result.testCode).toContain('import "testing"');
-    expect(result.testCode).toContain('func TestAdd(t *testing.T)');
-    expect(result.testFilePath).toBe('pkg/math/math_test.go');
-  });
-
-  it('should generate table-driven tests', async () => {
-    const functionCode = `
-package utils
-
-func IsValid(input string) bool {
-    return len(input) > 0
-}
-`;
-
-    const result = await generateGoTest({
-      filePath: 'pkg/utils/validation.go',
-      code: functionCode,
-      packageName: 'utils',
-    });
-
-    expect(result.testCode).toContain('tests := []struct');
-    expect(result.testCode).toContain('t.Run(');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/go.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Go test generator**
-
-Create `src/testing/generators/go.ts`:
-
-```typescript
-interface GoTestOptions {
-  filePath: string;
-  code: string;
-  packageName: string;
-}
-
-interface GoTestResult {
-  testFilePath: string;
-  testCode: string;
-}
-
-export async function generateGoTest(options: GoTestOptions): Promise<GoTestResult> {
-  const { filePath, code, packageName } = options;
-
-  // Generate test file path (Go convention: *_test.go)
-  const testFilePath = filePath.replace(/\.go$/, '_test.go');
-
-  // Extract functions from code
-  const functions = extractGoFunctions(code);
-
-  // Generate test code
-  const testCode = generateGoTestCode(packageName, functions);
-
-  return { testFilePath, testCode };
-}
-
-interface GoFunction {
-  name: string;
-  params: Array<{ name: string; type: string }>;
-  returnType: string;
-}
-
-function extractGoFunctions(code: string): GoFunction[] {
-  const functions: GoFunction[] = [];
-  const functionRegex = /func\s+(\w+)\s*\((.*?)\)\s*(.*?)\s*{/g;
-  let match;
-
-  while ((match = functionRegex.exec(code)) !== null) {
-    const name = match[1];
-    const paramsStr = match[2];
-    const returnType = match[3].trim();
-
-    // Skip methods (have receiver)
-    if (paramsStr.includes(')') && paramsStr.indexOf(')') < paramsStr.lastIndexOf('(')) {
-      continue;
-    }
-
-    const params = parseGoParams(paramsStr);
-
-    functions.push({ name, params, returnType });
-  }
-
-  return functions;
-}
-
-function parseGoParams(paramsStr: string): Array<{ name: string; type: string }> {
-  if (!paramsStr.trim()) return [];
-
-  const params: Array<{ name: string; type: string }> = [];
-  const parts = paramsStr.split(',').map(p => p.trim());
-
-  for (const part of parts) {
-    const tokens = part.split(/\s+/);
-    if (tokens.length >= 2) {
-      params.push({ name: tokens[0], type: tokens.slice(1).join(' ') });
-    }
-  }
-
-  return params;
-}
-
-function generateGoTestCode(packageName: string, functions: GoFunction[]): string {
-  let code = `package ${packageName}\n\nimport "testing"\n\n`;
-
-  for (const func of functions) {
-    code += generateGoTestFunction(func);
-  }
-
-  return code;
-}
-
-function generateGoTestFunction(func: GoFunction): string {
-  const testName = `Test${func.name}`;
-
-  // Determine if we should use table-driven tests
-  const useTableDriven = shouldUseTableDriven(func);
-
-  if (useTableDriven) {
-    return generateTableDrivenTest(func);
-  } else {
-    return generateSimpleTest(func);
-  }
-}
-
-function shouldUseTableDriven(func: GoFunction): boolean {
-  // Use table-driven tests for functions with simple inputs/outputs
-  return func.params.length > 0 && func.returnType !== '';
-}
-
-function generateTableDrivenTest(func: GoFunction): string {
-  const testName = `Test${func.name}`;
-
-  // Generate test cases based on function name
-  let testCases = '';
-  if (func.name === 'Add') {
-    testCases = `        {name: "positive numbers", args: args{a: 2, b: 3}, want: 5},
-        {name: "negative numbers", args: args{a: -1, b: 1}, want: 0},
-        {name: "zeros", args: args{a: 0, b: 0}, want: 0},`;
-  } else if (func.name === 'IsValid') {
-    testCases = `        {name: "valid input", args: args{input: "test"}, want: true},
-        {name: "empty input", args: args{input: ""}, want: false},`;
-  } else {
-    testCases = `        // TODO: Add test cases`;
-  }
-
-  const paramFields = func.params.map(p => `${p.name} ${p.type}`).join('; ');
-
-  return `func ${testName}(t *testing.T) {
-    type args struct {
-        ${paramFields}
-    }
-    tests := []struct {
-        name string
-        args args
-        want ${func.returnType}
-    }{
-${testCases}
-    }
-    for _, tt := range tests {
-        t.Run(tt.name, func(t *testing.T) {
-            got := ${func.name}(${func.params.map(p => `tt.args.${p.name}`).join(', ')})
-            if got != tt.want {
-                t.Errorf("${func.name}() = %v, want %v", got, tt.want)
-            }
-        })
-    }
-}
-
-`;
-}
-
-function generateSimpleTest(func: GoFunction): string {
-  const testName = `Test${func.name}`;
-
-  return `func ${testName}(t *testing.T) {
-    // TODO: Add test implementation for ${func.name}
-    t.Skip("Test not implemented")
-}
-
-`;
-}
-```
-
-Create `src/testing/detectors/go.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import type { TechStack } from '../types';
-
-export async function detectGoStack(projectRoot: string): Promise<Partial<TechStack>> {
-  const stack: Partial<TechStack> = {};
-
-  try {
-    // Check for go.mod
-    const goModPath = path.join(projectRoot, 'go.mod');
-    const goMod = await fs.readFile(goModPath, 'utf-8');
-
-    stack.backend = {
-      language: 'go',
-      testFramework: 'testing', // Go's built-in testing package
-    };
-
-    // Check for databases
-    const databases: string[] = [];
-    if (goMod.includes('github.com/lib/pq') || goMod.includes('github.com/jackc/pgx')) databases.push('postgresql');
-    if (goMod.includes('github.com/go-sql-driver/mysql')) databases.push('mysql');
-    if (goMod.includes('go.mongodb.org/mongo-driver')) databases.push('mongodb');
-    if (databases.length > 0) stack.databases = databases;
-
-    // Check for API frameworks
-    const apis: ('rest' | 'graphql' | 'grpc')[] = [];
-    if (goMod.includes('github.com/gin-gonic/gin') || goMod.includes('github.com/gorilla/mux')) apis.push('rest');
-    if (goMod.includes('github.com/graphql-go/graphql')) apis.push('graphql');
-    if (goMod.includes('google.golang.org/grpc')) apis.push('grpc');
-    if (apis.length > 0) stack.apis = apis;
-  } catch (error) {
-    // go.mod not found
-  }
-
-  return stack;
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/go.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/go.ts src/testing/detectors/go.ts tests/testing/generators/go.test.ts
-git commit -m "feat(testing): add Go test generator with table-driven tests
-
-- Generate Go tests using testing package
-- Support table-driven test pattern
-- Extract functions from Go code
-- Auto-detect function parameters and return types
-- Generate test file paths following Go conventions
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: Rust Test Generator
-
-**Files:**
-- Create: `src/testing/generators/rust.ts`
-- Create: `src/testing/detectors/rust.ts`
-- Create: `tests/testing/generators/rust.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/rust.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateRustTest } from '../../../src/testing/generators/rust';
-
-describe('generateRustTest', () => {
-  it('should generate Rust test for simple function', async () => {
-    const functionCode = `
-pub fn add(a: i32, b: i32) -> i32 {
-    a + b
-}
-`;
-
-    const result = await generateRustTest({
-      filePath: 'src/math.rs',
-      code: functionCode,
-    });
-
-    expect(result.testCode).toContain('#[cfg(test)]');
-    expect(result.testCode).toContain('mod tests');
-    expect(result.testCode).toContain('#[test]');
-    expect(result.testCode).toContain('fn test_add()');
-    expect(result.testCode).toContain('assert_eq!');
-  });
-
-  it('should generate tests for struct methods', async () => {
-    const structCode = `
-pub struct Calculator {
-    value: i32,
-}
-
-impl Calculator {
-    pub fn new() -> Self {
-        Calculator { value: 0 }
-    }
-
-    pub fn add(&mut self, n: i32) {
-        self.value += n;
-    }
-}
-`;
-
-    const result = await generateRustTest({
-      filePath: 'src/calculator.rs',
-      code: structCode,
-    });
-
-    expect(result.testCode).toContain('fn test_new()');
-    expect(result.testCode).toContain('fn test_add()');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/rust.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Rust test generator**
-
-Create `src/testing/generators/rust.ts`:
-
-```typescript
-interface RustTestOptions {
-  filePath: string;
-  code: string;
-}
-
-interface RustTestResult {
-  testCode: string;
-  testFilePath: string;
-}
-
-export async function generateRustTest(options: RustTestOptions): Promise<RustTestResult> {
-  const { filePath, code } = options;
-
-  // Rust tests are typically in the same file
-  const testFilePath = filePath;
-
-  // Extract functions and methods
-  const functions = extractRustFunctions(code);
-  const structs = extractRustStructs(code);
-
-  // Generate test module
-  const testCode = generateRustTestModule(functions, structs);
-
-  return { testCode, testFilePath };
-}
-
-interface RustFunction {
-  name: string;
-  params: Array<{ name: string; type: string }>;
-  returnType: string;
-  isPublic: boolean;
-}
-
-interface RustStruct {
-  name: string;
-  methods: RustFunction[];
-}
-
-function extractRustFunctions(code: string): RustFunction[] {
-  const functions: RustFunction[] = [];
-  const functionRegex = /(pub\s+)?fn\s+(\w+)\s*\((.*?)\)\s*(?:->\s*(.*?))?\s*{/g;
-  let match;
-
-  while ((match = functionRegex.exec(code)) !== null) {
-    const isPublic = !!match[1];
-    const name = match[2];
-    const paramsStr = match[3];
-    const returnType = match[4]?.trim() || '()';
-
-    // Skip if inside impl block (will be handled as methods)
-    const beforeFn = code.substring(0, match.index);
-    const lastImpl = beforeFn.lastIndexOf('impl ');
-    const lastCloseBrace = beforeFn.lastIndexOf('}');
-
-    if (lastImpl > lastCloseBrace) {
-      continue; // This is a method
-    }
-
-    const params = parseRustParams(paramsStr);
-
-    functions.push({ name, params, returnType, isPublic });
-  }
-
-  return functions;
-}
-
-function extractRustStructs(code: string): RustStruct[] {
-  const structs: RustStruct[] = [];
-  const structRegex = /struct\s+(\w+)/g;
-  let match;
-
-  while ((match = structRegex.exec(code)) !== null) {
-    const structName = match[1];
-
-    // Find impl block for this struct
-    const implRegex = new RegExp(`impl\\s+${structName}\\s*{([^}]+)}`, 's');
-    const implMatch = implRegex.exec(code);
-
-    if (implMatch) {
-      const implBody = implMatch[1];
-      const methods = extractRustMethods(implBody);
-      structs.push({ name: structName, methods });
-    }
-  }
-
-  return structs;
-}
-
-function extractRustMethods(implBody: string): RustFunction[] {
-  const methods: RustFunction[] = [];
-  const methodRegex = /(pub\s+)?fn\s+(\w+)\s*\((.*?)\)\s*(?:->\s*(.*?))?\s*{/g;
-  let match;
-
-  while ((match = methodRegex.exec(implBody)) !== null) {
-    const isPublic = !!match[1];
-    const name = match[2];
-    const paramsStr = match[3];
-    const returnType = match[4]?.trim() || '()';
-
-    const params = parseRustParams(paramsStr);
-
-    methods.push({ name, params, returnType, isPublic });
-  }
-
-  return methods;
-}
-
-function parseRustParams(paramsStr: string): Array<{ name: string; type: string }> {
-  if (!paramsStr.trim()) return [];
-
-  const params: Array<{ name: string; type: string }> = [];
-  const parts = paramsStr.split(',').map(p => p.trim());
-
-  for (const part of parts) {
-    const colonIndex = part.indexOf(':');
-    if (colonIndex !== -1) {
-      const name = part.substring(0, colonIndex).trim();
-      const type = part.substring(colonIndex + 1).trim();
-      params.push({ name, type });
-    }
-  }
-
-  return params;
-}
-
-function generateRustTestModule(functions: RustFunction[], structs: RustStruct[]): string {
-  let code = `\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n`;
-
-  // Generate tests for standalone functions
-  for (const func of functions) {
-    if (func.isPublic) {
-      code += generateRustTestFunction(func);
-    }
-  }
-
-  // Generate tests for struct methods
-  for (const struct of structs) {
-    for (const method of struct.methods) {
-      if (method.isPublic) {
-        code += generateRustTestMethod(struct.name, method);
-      }
-    }
-  }
-
-  code += `}\n`;
-
-  return code;
-}
-
-function generateRustTestFunction(func: RustFunction): string {
-  const testName = `test_${func.name}`;
-
-  let testBody = '';
-  if (func.name === 'add') {
-    testBody = `        assert_eq!(add(2, 3), 5);
-        assert_eq!(add(-1, 1), 0);
-        assert_eq!(add(0, 0), 0);`;
-  } else {
-    testBody = `        // TODO: Add test implementation for ${func.name}`;
-  }
-
-  return `    #[test]
-    fn ${testName}() {
-${testBody}
-    }
-
-`;
-}
-
-function generateRustTestMethod(structName: string, method: RustFunction): string {
-  const testName = `test_${method.name}`;
-
-  let testBody = '';
-  if (method.name === 'new') {
-    testBody = `        let instance = ${structName}::new();
-        // TODO: Add assertions`;
-  } else if (method.name === 'add') {
-    testBody = `        let mut instance = ${structName}::new();
-        instance.add(5);
-        // TODO: Add assertions`;
-  } else {
-    testBody = `        // TODO: Add test implementation for ${method.name}`;
-  }
-
-  return `    #[test]
-    fn ${testName}() {
-${testBody}
-    }
-
-`;
-}
-```
-
-Create `src/testing/detectors/rust.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import type { TechStack } from '../types';
-
-export async function detectRustStack(projectRoot: string): Promise<Partial<TechStack>> {
-  const stack: Partial<TechStack> = {};
-
-  try {
-    // Check for Cargo.toml
-    const cargoTomlPath = path.join(projectRoot, 'Cargo.toml');
-    const cargoToml = await fs.readFile(cargoTomlPath, 'utf-8');
-
-    stack.backend = {
-      language: 'rust',
-      testFramework: 'cargo test', // Rust's built-in testing
-    };
-
-    // Check for databases
-    const databases: string[] = [];
-    if (cargoToml.includes('tokio-postgres') || cargoToml.includes('sqlx')) databases.push('postgresql');
-    if (cargoToml.includes('mysql_async')) databases.push('mysql');
-    if (cargoToml.includes('mongodb')) databases.push('mongodb');
-    if (databases.length > 0) stack.databases = databases;
-
-    // Check for API frameworks
-    const apis: ('rest' | 'graphql' | 'grpc')[] = [];
-    if (cargoToml.includes('actix-web') || cargoToml.includes('rocket') || cargoToml.includes('axum')) apis.push('rest');
-    if (cargoToml.includes('async-graphql') || cargoToml.includes('juniper')) apis.push('graphql');
-    if (cargoToml.includes('tonic')) apis.push('grpc');
-    if (apis.length > 0) stack.apis = apis;
-  } catch (error) {
-    // Cargo.toml not found
-  }
-
-  return stack;
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/rust.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/rust.ts src/testing/detectors/rust.ts tests/testing/generators/rust.test.ts
-git commit -m "feat(testing): add Rust test generator with cargo test support
-
-- Generate Rust tests using #[test] attribute
-- Support struct methods and standalone functions
-- Extract functions and structs from Rust code
-- Generate test modules following Rust conventions
-- Support assert_eq! and other test macros
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: Complexity Analyzer
-
-**Files:**
-- Create: `src/testing/analyzers/complexity.ts`
-- Create: `tests/testing/analyzers/complexity.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/analyzers/complexity.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { analyzeComplexity } from '../../../src/testing/analyzers/complexity';
-
-describe('Complexity Analyzer', () => {
-  it('should classify simple function', async () => {
-    const simpleCode = `
-export function add(a: number, b: number): number {
-  return a + b;
-}
-`;
-
-    const result = await analyzeComplexity({
-      code: simpleCode,
-      filePath: 'src/utils/math.ts',
-    });
-
-    expect(result.complexity).toBe('simple');
-    expect(result.metrics.lines).toBeLessThan(50);
-    expect(result.metrics.cyclomaticComplexity).toBeLessThan(10);
-  });
-
-  it('should classify complex function', async () => {
-    const complexCode = `
-export async function processPayment(order: Order, payment: PaymentInfo): Promise<PaymentResult> {
-  if (!order || !payment) {
-    throw new Error('Invalid input');
-  }
-
-  try {
-    const customer = await getCustomer(order.customerId);
-    if (!customer.isActive) {
-      return { success: false, error: 'Inactive customer' };
-    }
-
-    const stripeResult = await stripe.charges.create({
-      amount: order.total,
-      currency: 'usd',
-      source: payment.token,
-    });
-
-    if (stripeResult.status === 'succeeded') {
-      await db.transaction(async (trx) => {
-        await trx('orders').where({ id: order.id }).update({ status: 'paid' });
-        await trx('payments').insert({ orderId: order.id, stripeId: stripeResult.id });
-      });
-
-      return { success: true, transactionId: stripeResult.id };
-    } else {
-      return { success: false, error: 'Payment failed' };
-    }
-  } catch (error) {
-    logger.error('Payment processing error', error);
-    return { success: false, error: error.message };
-  }
-}
-`;
-
-    const result = await analyzeComplexity({
-      code: complexCode,
-      filePath: 'src/services/payment.ts',
-    });
-
-    expect(result.complexity).toBe('complex');
-    expect(result.reasons).toContain('External API calls');
-    expect(result.reasons).toContain('Database transactions');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/analyzers/complexity.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement complexity analyzer**
-
-Create `src/testing/analyzers/complexity.ts`:
-
-```typescript
-export interface ComplexityMetrics {
-  lines: number;
-  cyclomaticComplexity: number;
-  nestingLevel: number;
-  externalDependencies: number;
-}
-
-export interface ComplexityAnalysisResult {
-  complexity: 'simple' | 'complex';
-  metrics: ComplexityMetrics;
-  reasons: string[];
-}
-
-interface AnalyzeComplexityOptions {
-  code: string;
-  filePath: string;
-}
-
-export async function analyzeComplexity(options: AnalyzeComplexityOptions): Promise<ComplexityAnalysisResult> {
-  const { code, filePath } = options;
-
-  // Calculate metrics
-  const metrics = calculateMetrics(code);
-
-  // Determine complexity and reasons
-  const reasons: string[] = [];
-  let isComplex = false;
-
-  // Check line count
-  if (metrics.lines >= 50) {
-    reasons.push('Function exceeds 50 lines');
-    isComplex = true;
-  }
-
-  // Check cyclomatic complexity
-  if (metrics.cyclomaticComplexity >= 10) {
-    reasons.push('High cyclomatic complexity');
-    isComplex = true;
-  }
-
-  // Check nesting level
-  if (metrics.nestingLevel >= 3) {
-    reasons.push('Deep nesting level');
-    isComplex = true;
-  }
-
-  // Check for external dependencies
-  if (metrics.externalDependencies > 0) {
-    reasons.push('External API calls');
-    isComplex = true;
-  }
-
-  // Check for specific patterns
-  if (code.includes('stripe') || code.includes('paypal') || code.includes('payment')) {
-    reasons.push('Payment processing logic');
-    isComplex = true;
-  }
-
-  if (code.includes('auth') || code.includes('jwt') || code.includes('session')) {
-    reasons.push('Authentication logic');
-    isComplex = true;
-  }
-
-  if (code.includes('db.transaction') || code.includes('BEGIN') || code.includes('COMMIT')) {
-    reasons.push('Database transactions');
-    isComplex = true;
-  }
-
-  if (code.includes('async') && code.includes('await')) {
-    const awaitCount = (code.match(/await/g) || []).length;
-    if (awaitCount > 3) {
-      reasons.push('Multiple async operations');
-      isComplex = true;
-    }
-  }
-
-  return {
-    complexity: isComplex ? 'complex' : 'simple',
-    metrics,
-    reasons,
-  };
-}
-
-function calculateMetrics(code: string): ComplexityMetrics {
-  const lines = code.split('\n').filter(line => line.trim() !== '').length;
-
-  // Calculate cyclomatic complexity (simplified)
-  const cyclomaticComplexity = calculateCyclomaticComplexity(code);
-
-  // Calculate nesting level
-  const nestingLevel = calculateNestingLevel(code);
-
-  // Count external dependencies
-  const externalDependencies = countExternalDependencies(code);
-
-  return {
-    lines,
-    cyclomaticComplexity,
-    nestingLevel,
-    externalDependencies,
-  };
-}
-
-function calculateCyclomaticComplexity(code: string): number {
-  // Start with 1 (base complexity)
-  let complexity = 1;
-
-  // Count decision points
-  const decisionPoints = [
-    /\bif\b/g,
-    /\belse\s+if\b/g,
-    /\bfor\b/g,
-    /\bwhile\b/g,
-    /\bcase\b/g,
-    /\bcatch\b/g,
-    /\b\?\s*.*\s*:/g, // Ternary operator
-    /\b&&\b/g,
-    /\b\|\|\b/g,
-  ];
-
-  for (const pattern of decisionPoints) {
-    const matches = code.match(pattern);
-    if (matches) {
-      complexity += matches.length;
-    }
-  }
-
-  return complexity;
-}
-
-function calculateNestingLevel(code: string): number {
-  let maxNesting = 0;
-  let currentNesting = 0;
-
-  for (const char of code) {
-    if (char === '{') {
-      currentNesting++;
-      maxNesting = Math.max(maxNesting, currentNesting);
-    } else if (char === '}') {
-      currentNesting--;
-    }
-  }
-
-  return maxNesting;
-}
-
-function countExternalDependencies(code: string): number {
-  let count = 0;
-
-  // Check for HTTP/API calls
-  if (code.includes('fetch(') || code.includes('axios.') || code.includes('http.')) {
-    count++;
-  }
-
-  // Check for external service SDKs
-  const externalServices = ['stripe', 'aws', 'firebase', 'sendgrid', 'twilio'];
-  for (const service of externalServices) {
-    if (code.includes(service)) {
-      count++;
-    }
-  }
-
-  return count;
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/analyzers/complexity.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/analyzers/complexity.ts tests/testing/analyzers/complexity.test.ts
-git commit -m "feat(testing): add complexity analyzer for code classification
-
-- Calculate cyclomatic complexity
-- Measure nesting levels and line counts
-- Detect external dependencies
-- Identify payment, auth, and transaction logic
-- Classify code as simple or complex
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 6: Contract Test Generator
-
-**Files:**
-- Create: `src/testing/generators/contract.ts`
-- Create: `tests/testing/generators/contract.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/contract.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateContractTest } from '../../../src/testing/generators/contract';
-
-describe('Contract Test Generator', () => {
-  it('should generate Pact test from OpenAPI spec', async () => {
-    const openApiSpec = {
-      openapi: '3.0.0',
-      paths: {
-        '/users/{id}': {
-          get: {
-            parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
-            responses: {
-              '200': {
-                description: 'User found',
-                content: {
-                  'application/json': {
-                    schema: {
-                      type: 'object',
-                      properties: {
-                        id: { type: 'string' },
-                        name: { type: 'string' },
-                        email: { type: 'string' },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    };
-
-    const result = await generateContractTest({
-      spec: openApiSpec,
-      framework: 'pact',
-      consumer: 'frontend',
-      provider: 'backend',
-    });
-
-    expect(result.testCode).toContain('pact');
-    expect(result.testCode).toContain('/users/{id}');
-    expect(result.testCode).toContain('willRespondWith');
-  });
-
-  it('should generate REST API contract test', async () => {
-    const apiDefinition = {
-      endpoint: '/api/orders',
-      method: 'POST',
-      requestBody: {
-        customerId: 'string',
-        items: 'array',
-        total: 'number',
-      },
-      responseBody: {
-        orderId: 'string',
-        status: 'string',
-      },
-    };
-
-    const result = await generateContractTest({
-      apiDefinition,
-      framework: 'supertest',
-    });
-
-    expect(result.testCode).toContain('POST /api/orders');
-    expect(result.testCode).toContain('expect(200)');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/contract.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement contract test generator**
-
-Create `src/testing/generators/contract.ts`:
-
-```typescript
-interface ContractTestOptions {
-  spec?: any; // OpenAPI spec
-  apiDefinition?: any; // Simple API definition
-  framework: 'pact' | 'supertest' | 'msw';
-  consumer?: string;
-  provider?: string;
-}
-
-interface ContractTestResult {
-  testCode: string;
-  testFilePath: string;
-}
-
-export async function generateContractTest(options: ContractTestOptions): Promise<ContractTestResult> {
-  const { spec, apiDefinition, framework, consumer, provider } = options;
-
-  let testCode = '';
-  let testFilePath = '';
-
-  if (framework === 'pact' && spec) {
-    testCode = generatePactTest(spec, consumer || 'consumer', provider || 'provider');
-    testFilePath = `tests/contract/${consumer}-${provider}.pact.test.ts`;
-  } else if (framework === 'supertest' && apiDefinition) {
-    testCode = generateSupertestContract(apiDefinition);
-    testFilePath = `tests/contract/api.contract.test.ts`;
-  } else if (framework === 'msw' && spec) {
-    testCode = generateMSWHandlers(spec);
-    testFilePath = `tests/mocks/handlers.ts`;
-  }
-
-  return { testCode, testFilePath };
-}
-
-function generatePactTest(spec: any, consumer: string, provider: string): string {
-  const paths = spec.paths || {};
-  const interactions: string[] = [];
-
-  for (const [path, methods] of Object.entries(paths)) {
-    for (const [method, details] of Object.entries(methods as any)) {
-      const interaction = generatePactInteraction(path, method.toUpperCase(), details);
-      interactions.push(interaction);
-    }
-  }
-
-  return `import { Pact } from '@pact-foundation/pact';
-import { like, eachLike } from '@pact-foundation/pact/dsl/matchers';
-
-describe('${consumer} <-> ${provider} Contract', () => {
-  const provider = new Pact({
-    consumer: '${consumer}',
-    provider: '${provider}',
-    port: 1234,
-    log: './logs/pact.log',
-    dir: './pacts',
-  });
-
-  beforeAll(() => provider.setup());
-  afterEach(() => provider.verify());
-  afterAll(() => provider.finalize());
-
-${interactions.join('\n\n')}
-});
-`;
-}
-
-function generatePactInteraction(path: string, method: string, details: any): string {
-  const response = details.responses?.['200'] || details.responses?.['201'];
-  const responseSchema = response?.content?.['application/json']?.schema;
-
-  const responseBody = responseSchema ? generateMatcherFromSchema(responseSchema) : '{}';
-
-  return `  it('${method} ${path}', async () => {
-    await provider.addInteraction({
-      state: 'resource exists',
-      uponReceiving: '${method} request to ${path}',
-      withRequest: {
-        method: '${method}',
-        path: '${path}',
-      },
-      willRespondWith: {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-        body: ${responseBody},
-      },
-    });
-
-    // Make actual request and verify
-    const response = await fetch(\`http://localhost:1234${path}\`);
-    expect(response.status).toBe(200);
-  });`;
-}
-
-function generateMatcherFromSchema(schema: any): string {
-  if (schema.type === 'object') {
-    const properties = schema.properties || {};
-    const matchers: string[] = [];
-
-    for (const [key, prop] of Object.entries(properties as any)) {
-      if (prop.type === 'string') {
-        matchers.push(`${key}: like('example')`);
-      } else if (prop.type === 'number') {
-        matchers.push(`${key}: like(123)`);
-      } else if (prop.type === 'boolean') {
-        matchers.push(`${key}: like(true)`);
-      } else if (prop.type === 'array') {
-        matchers.push(`${key}: eachLike({ id: like('1') })`);
-      }
-    }
-
-    return `{ ${matchers.join(', ')} }`;
-  }
-
-  return '{}';
-}
-
-function generateSupertestContract(apiDefinition: any): string {
-  const { endpoint, method, requestBody, responseBody } = apiDefinition;
-
-  const requestExample = generateExampleFromSchema(requestBody);
-  const responseExample = generateExampleFromSchema(responseBody);
-
-  return `import request from 'supertest';
-import app from '../src/app';
-
-describe('API Contract Tests', () => {
-  it('${method} ${endpoint} should match contract', async () => {
-    const response = await request(app)
-      .${method.toLowerCase()}('${endpoint}')
-      .send(${JSON.stringify(requestExample, null, 2)})
-      .expect(200)
-      .expect('Content-Type', /json/);
-
-    // Verify response structure
-    expect(response.body).toMatchObject(${JSON.stringify(responseExample, null, 2)});
-  });
-});
-`;
-}
-
-function generateMSWHandlers(spec: any): string {
-  const paths = spec.paths || {};
-  const handlers: string[] = [];
-
-  for (const [path, methods] of Object.entries(paths)) {
-    for (const [method, details] of Object.entries(methods as any)) {
-      const handler = generateMSWHandler(path, method, details);
-      handlers.push(handler);
-    }
-  }
-
-  return `import { rest } from 'msw';
-
-export const handlers = [
-${handlers.join(',\n\n')}
-];
-`;
-}
-
-function generateMSWHandler(path: string, method: string, details: any): string {
-  const response = details.responses?.['200'] || details.responses?.['201'];
-  const responseSchema = response?.content?.['application/json']?.schema;
-  const responseExample = responseSchema ? generateExampleFromSchema(responseSchema.properties || {}) : {};
-
-  return `  rest.${method.toLowerCase()}('${path}', (req, res, ctx) => {
-    return res(
-      ctx.status(200),
-      ctx.json(${JSON.stringify(responseExample, null, 2)})
-    );
-  })`;
-}
-
-function generateExampleFromSchema(schema: any): any {
-  if (typeof schema === 'string') {
-    return schema === 'string' ? 'example' : schema === 'number' ? 123 : schema === 'boolean' ? true : [];
-  }
-
-  const example: any = {};
-
-  for (const [key, type] of Object.entries(schema)) {
-    if (type === 'string') {
-      example[key] = 'example';
-    } else if (type === 'number') {
-      example[key] = 123;
-    } else if (type === 'boolean') {
-      example[key] = true;
-    } else if (type === 'array') {
-      example[key] = [];
-    }
-  }
-
-  return example;
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/contract.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/contract.ts tests/testing/generators/contract.test.ts
-git commit -m "feat(testing): add contract test generator for APIs
-
-- Generate Pact consumer-driven contract tests
-- Support Supertest for REST API contracts
-- Generate MSW handlers from OpenAPI specs
-- Parse OpenAPI 3.0 specifications
-- Create example data from schemas
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 7: Enhanced Test-Engineer Agent Integration
-
-**Files:**
-- Update: `agents/test-engineer.md`
-- Create: `src/testing/cli/agent-integration.ts`
-- Create: `tests/testing/cli/agent-integration.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/cli/agent-integration.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { prepareTestEngineerContext } from '../../../src/testing/cli/agent-integration';
-
-describe('Test-Engineer Agent Integration', () => {
-  it('should prepare context for simple code', async () => {
-    const context = await prepareTestEngineerContext({
-      filePath: 'src/utils/math.ts',
-      code: 'export function add(a: number, b: number) { return a + b; }',
-      projectRoot: process.cwd(),
-    });
-
-    expect(context.complexity).toBe('simple');
-    expect(context.techStack).toBeDefined();
-    expect(context.suggestedApproach).toBe('auto-generate');
-  });
-
-  it('should prepare context for complex code', async () => {
-    const complexCode = `
-export async function processPayment(order: Order) {
-  const stripe = await getStripeClient();
-  const result = await stripe.charges.create({ amount: order.total });
-  await db.transaction(async (trx) => {
-    await trx('orders').update({ status: 'paid' });
-  });
-  return result;
-}
-`;
-
-    const context = await prepareTestEngineerContext({
-      filePath: 'src/services/payment.ts',
-      code: complexCode,
-      projectRoot: process.cwd(),
-    });
-
-    expect(context.complexity).toBe('complex');
-    expect(context.suggestedApproach).toBe('guided');
-    expect(context.questionsForUser).toBeDefined();
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/cli/agent-integration.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement agent integration**
-
-Create `src/testing/cli/agent-integration.ts`:
-
-```typescript
-import { detectTechStack } from '../detectors';
-import { analyzeComplexity } from '../analyzers/complexity';
-import type { TechStack } from '../types';
-import type { ComplexityAnalysisResult } from '../analyzers/complexity';
-
-export interface TestEngineerContext {
-  filePath: string;
-  code: string;
-  techStack: TechStack;
-  complexity: 'simple' | 'complex';
-  complexityMetrics: ComplexityAnalysisResult;
-  suggestedApproach: 'auto-generate' | 'guided' | 'manual';
-  questionsForUser?: string[];
-}
-
-interface PrepareContextOptions {
-  filePath: string;
-  code: string;
-  projectRoot: string;
-}
-
-export async function prepareTestEngineerContext(options: PrepareContextOptions): Promise<TestEngineerContext> {
-  const { filePath, code, projectRoot } = options;
-
-  // Detect tech stack
-  const techStack = await detectTechStack(projectRoot);
-
-  // Analyze complexity
-  const complexityMetrics = await analyzeComplexity({ code, filePath });
-
-  // Determine suggested approach
-  let suggestedApproach: 'auto-generate' | 'guided' | 'manual';
-  let questionsForUser: string[] | undefined;
-
-  if (complexityMetrics.complexity === 'simple') {
-    suggestedApproach = 'auto-generate';
-  } else {
-    suggestedApproach = 'guided';
-    questionsForUser = generateQuestionsForComplexCode(complexityMetrics);
-  }
-
-  return {
-    filePath,
-    code,
-    techStack,
-    complexity: complexityMetrics.complexity,
-    complexityMetrics,
-    suggestedApproach,
-    questionsForUser,
-  };
-}
-
-function generateQuestionsForComplexCode(metrics: ComplexityAnalysisResult): string[] {
-  const questions: string[] = [];
-
-  if (metrics.reasons.includes('Payment processing logic')) {
-    questions.push('What are the expected payment flows? (success, failure, retry)');
-    questions.push('Should I mock external payment provider API calls?');
-    questions.push('What error scenarios should be tested?');
-  }
-
-  if (metrics.reasons.includes('Authentication logic')) {
-    questions.push('What authentication methods should be tested?');
-    questions.push('Should I test token expiration and refresh?');
-    questions.push('What authorization scenarios should be covered?');
-  }
-
-  if (metrics.reasons.includes('Database transactions')) {
-    questions.push('What database states should I test?');
-    questions.push('Should I test transaction rollbacks?');
-    questions.push('Are there specific edge cases for data integrity?');
-  }
-
-  if (metrics.reasons.includes('External API calls')) {
-    questions.push('Should I mock external API calls?');
-    questions.push('What API failure scenarios should be tested?');
-    questions.push('Are there rate limiting or retry logic to test?');
-  }
-
-  if (metrics.reasons.includes('Multiple async operations')) {
-    questions.push('Should I test concurrent execution scenarios?');
-    questions.push('Are there race conditions to consider?');
-    questions.push('What timeout scenarios should be tested?');
-  }
-
-  // Always ask about edge cases
-  questions.push('Are there specific edge cases or business rules I should know about?');
-
-  return questions;
-}
-
-export async function invokeTestEngineerAgent(context: TestEngineerContext): Promise<string> {
-  // This would integrate with the actual test-engineer agent
-  // For now, return a placeholder command
-
-  const agentCommand = `test-engineer --file="${context.filePath}" --complexity="${context.complexity}" --approach="${context.suggestedApproach}"`;
-
-  return agentCommand;
-}
-```
-
-**Step 4: Update test-engineer agent document**
-
-Update `agents/test-engineer.md` to add:
-
-```markdown
-## Enhanced Integration with Test Generation System
-
-### Automatic Context Enrichment
-
-When invoked for test generation, test-engineer receives enriched context:
-
-- **Tech Stack**: Detected frameworks, languages, and test tools
-- **Complexity Analysis**: Metrics including cyclomatic complexity, nesting levels, external dependencies
-- **Suggested Approach**: 
-  - `auto-generate`: Simple code, generate tests automatically
-  - `guided`: Complex code, ask user for clarification
-  - `manual`: Very complex, provide framework and guidance only
-
-### Workflow for Complex Code
-
-When complexity is `complex`:
-
-1. **Review Context**: Examine complexity metrics and reasons
-2. **Ask Questions**: Use pre-generated questions based on complexity reasons
-3. **Generate Test Framework**: Create test structure with placeholders
-4. **Fill in Details**: Based on user answers, complete test cases
-5. **Verify Coverage**: Ensure all identified complexity factors are tested
-
-### Example Invocation
-
-```typescript
-const context = await prepareTestEngineerContext({
-  filePath: 'src/services/payment.ts',
-  code: paymentServiceCode,
-  projectRoot: '/project/root',
-});
-
-// Context includes:
-// - techStack: { backend: { language: 'nodejs', testFramework: 'vitest' } }
-// - complexity: 'complex'
-// - complexityMetrics: { lines: 75, cyclomaticComplexity: 15, ... }
-// - suggestedApproach: 'guided'
-// - questionsForUser: ['What payment flows...', 'Should I mock...']
-```
-
-### Integration with /test-gen Skill
-
-The `/test-gen` skill automatically prepares this context before delegating to test-engineer:
-
-1. User runs `/test-gen src/services/payment.ts`
-2. System detects tech stack and analyzes complexity
-3. If complex, prepares questions and delegates to test-engineer
-4. Test-engineer asks questions and generates comprehensive tests
-5. System verifies tests and commits
-
-### Success Criteria
-
-- [ ] Context preparation includes all necessary information
-- [ ] Questions are relevant to complexity reasons
-- [ ] Test-engineer can generate appropriate tests for both simple and complex code
-- [ ] Integration with /test-gen skill is seamless
-```
-
-**Step 5: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/cli/agent-integration.test.ts`
-Expected: PASS
-
-**Step 6: Commit**
-
-```bash
-git add src/testing/cli/agent-integration.ts tests/testing/cli/agent-integration.test.ts agents/test-engineer.md
-git commit -m "feat(testing): enhance test-engineer agent integration
-
-- Prepare enriched context with tech stack and complexity
-- Generate relevant questions for complex code
-- Determine suggested approach (auto/guided/manual)
-- Update test-engineer agent documentation
-- Support seamless integration with /test-gen skill
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 8: Ultraqa Integration
-
-**Files:**
-- Update: `skills/ultraqa.md`
-- Create: `src/testing/cli/ultraqa-integration.ts`
-- Create: `tests/testing/cli/ultraqa-integration.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/cli/ultraqa-integration.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { enhanceUltraQAWithTestGen } from '../../../src/testing/cli/ultraqa-integration';
-
-describe('UltraQA Integration', () => {
-  it('should identify files needing tests', async () => {
-    const result = await enhanceUltraQAWithTestGen({
-      projectRoot: process.cwd(),
-      changedFiles: ['src/utils/math.ts', 'src/services/payment.ts'],
-    });
-
-    expect(result.filesNeedingTests).toHaveLength(2);
-    expect(result.coverageGaps).toBeDefined();
-  });
-
-  it('should generate tests for coverage gaps', async () => {
-    const result = await enhanceUltraQAWithTestGen({
-      projectRoot: process.cwd(),
-      coverageGaps: [
-        { file: 'src/utils/validation.ts', startLine: 42, endLine: 48, reason: 'Error handling not covered' },
-      ],
-    });
-
-    expect(result.generatedTests).toHaveLength(1);
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/cli/ultraqa-integration.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement ultraqa integration**
-
-Create `src/testing/cli/ultraqa-integration.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import { analyzeCoverage, identifyGaps } from '../analyzers/coverage';
-import { testGenCommand } from './commands';
-import type { CoverageGap } from '../analyzers/types';
-
-interface UltraQAOptions {
-  projectRoot: string;
-  changedFiles?: string[];
-  coverageGaps?: CoverageGap[];
-}
-
-interface UltraQAResult {
-  filesNeedingTests: string[];
-  coverageGaps?: CoverageGap[];
-  generatedTests: string[];
-}
-
-export async function enhanceUltraQAWithTestGen(options: UltraQAOptions): Promise<UltraQAResult> {
-  const { projectRoot, changedFiles, coverageGaps } = options;
-
-  const filesNeedingTests: string[] = [];
-  const generatedTests: string[] = [];
-
-  // If changed files provided, check which ones need tests
-  if (changedFiles) {
-    for (const file of changedFiles) {
-      const needsTest = await checkIfNeedsTest(file, projectRoot);
-      if (needsTest) {
-        filesNeedingTests.push(file);
-      }
-    }
-  }
-
-  // If coverage gaps provided, generate tests for them
-  if (coverageGaps) {
-    for (const gap of coverageGaps) {
-      try {
-        const result = await testGenCommand({
-          filePath: path.join(projectRoot, gap.file),
-        });
-
-        if (result.success && result.testFilePath) {
-          generatedTests.push(result.testFilePath);
-        }
-      } catch (error) {
-        console.error(`Failed to generate test for ${gap.file}:`, error);
-      }
-    }
-  }
-
-  // Analyze coverage if no gaps provided
-  let gaps: CoverageGap[] | undefined;
-  if (!coverageGaps) {
-    try {
-      const coverageResult = await analyzeCoverage({ projectRoot });
-      if (coverageResult.totalCoverage < 80) {
-        // Identify gaps
-        const gapResult = await identifyGaps({
-          projectRoot,
-          uncoveredLines: {}, // Would be populated from coverage report
-        });
-        gaps = gapResult.gaps;
-      }
-    } catch (error) {
-      // Coverage not available
-    }
-  }
-
-  return {
-    filesNeedingTests,
-    coverageGaps: gaps,
-    generatedTests,
-  };
-}
-
-async function checkIfNeedsTest(filePath: string, projectRoot: string): Promise<boolean> {
-  // Check if test file already exists
-  const testFilePath = filePath.replace(/\.(ts|js|tsx|jsx)$/, '.test.$1');
-  const fullTestPath = path.join(projectRoot, testFilePath);
-
-  try {
-    await fs.access(fullTestPath);
-    return false; // Test file exists
-  } catch {
-    return true; // Test file doesn't exist
-  }
-}
-```
-
-**Step 4: Update ultraqa skill document**
-
-Update `skills/ultraqa.md` to add:
-
-```markdown
-## Enhanced Test Generation Integration
-
-### Automatic Test Generation
-
-UltraQA now automatically generates missing tests during the QA cycle:
-
-1. **Identify Missing Tests**: Check which changed files lack test coverage
-2. **Generate Tests**: Use `/test-gen` to create tests for uncovered files
-3. **Run Tests**: Execute generated tests
-4. **Analyze Coverage**: Identify remaining gaps
-5. **Fix Issues**: If tests fail, fix and regenerate
-6. **Repeat**: Continue until coverage threshold met (default: 80%)
-
-### Workflow
-
-```
-User: /ultraqa
-
-Agent: Starting UltraQA cycle...
-
-Agent: Analyzing changed files...
-- src/utils/math.ts (no test file)
-- src/services/payment.ts (test exists, but coverage 45%)
-
-Agent: Generating missing tests...
-✅ Generated: src/utils/math.test.ts
-
-Agent: Analyzing coverage gaps in src/services/payment.ts...
-- Lines 42-48: Error handling not covered
-- Lines 67-72: Edge case for retries
-
-Agent: Generating supplementary tests...
-✅ Added 3 test cases to src/services/payment.test.ts
-
-Agent: Running all tests...
-✅ All tests passing
-
-Agent: Coverage analysis...
-- Overall coverage: 85%
-- src/utils/math.ts: 100%
-- src/services/payment.ts: 82%
-
-✅ UltraQA cycle complete. Coverage threshold met.
-```
-
-### Configuration
-
-Add to `.omc/project-config.json`:
-
-```json
-{
-  "ultraqa": {
-    "autoGenerateTests": true,
-    "coverageThreshold": 80,
-    "maxCycles": 5
-  }
-}
-```
-```
-
-**Step 5: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/cli/ultraqa-integration.test.ts`
-Expected: PASS
-
-**Step 6: Commit**
-
-```bash
-git add src/testing/cli/ultraqa-integration.ts tests/testing/cli/ultraqa-integration.test.ts skills/ultraqa.md
-git commit -m "feat(testing): integrate test generation with /ultraqa workflow
-
-- Automatically identify files needing tests
-- Generate tests for coverage gaps
-- Enhance ultraqa cycle with test generation
-- Support coverage threshold configuration
-- Update ultraqa skill documentation
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 9: Multi-Language CLI Integration
-
-**Files:**
-- Update: `src/testing/cli/commands.ts`
-- Update: `src/testing/detectors/index.ts`
-- Create: `tests/testing/cli/multi-language.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/cli/multi-language.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { testGenCommand } from '../../../src/testing/cli/commands';
-
-describe('Multi-Language Test Generation', () => {
-  it('should generate Python test', async () => {
-    const result = await testGenCommand({
-      filePath: 'src/utils/math.py',
-      language: 'python',
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.testFilePath).toContain('test_math.py');
-  });
-
-  it('should generate Go test', async () => {
-    const result = await testGenCommand({
-      filePath: 'pkg/math/math.go',
-      language: 'go',
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.testFilePath).toContain('math_test.go');
-  });
-
-  it('should generate Rust test', async () => {
-    const result = await testGenCommand({
-      filePath: 'src/math.rs',
-      language: 'rust',
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.testFilePath).toBe('src/math.rs'); // Rust tests in same file
-  });
-
-  it('should auto-detect language from file extension', async () => {
-    const pythonResult = await testGenCommand({
-      filePath: 'src/utils/math.py',
-    });
-
-    expect(pythonResult.success).toBe(true);
-
-    const goResult = await testGenCommand({
-      filePath: 'pkg/math/math.go',
-    });
-
-    expect(goResult.success).toBe(true);
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/cli/multi-language.test.ts`
-Expected: FAIL (multi-language support not yet integrated)
-
-**Step 3: Update CLI commands to support all languages**
-
-Update `src/testing/cli/commands.ts`:
-
-```typescript
-import { generatePythonTest } from '../generators/python';
-import { generateGoTest } from '../generators/go';
-import { generateRustTest } from '../generators/rust';
-import { detectPythonStack } from '../detectors/python';
-import { detectGoStack } from '../detectors/go';
-import { detectRustStack } from '../detectors/rust';
-
-// Add to existing TestGenOptions interface
-interface TestGenOptions {
-  filePath: string;
-  output?: string;
-  language?: 'nodejs' | 'python' | 'go' | 'rust'; // Add language option
-}
-
-// Update testGenCommand function
-export async function testGenCommand(options: TestGenOptions): Promise<TestGenResult> {
-  try {
-    const { filePath, output, language } = options;
-
-    // Read source file
-    const code = await fs.readFile(filePath, 'utf-8');
-
-    // Auto-detect language if not provided
-    const detectedLanguage = language || detectLanguageFromFile(filePath);
-
-    // Detect tech stack
-    const projectRoot = process.cwd();
-    let stack = await detectTechStack(projectRoot);
-
-    // Enhance with language-specific detection
-    if (detectedLanguage === 'python') {
-      const pythonStack = await detectPythonStack(projectRoot);
-      stack = { ...stack, ...pythonStack };
-    } else if (detectedLanguage === 'go') {
-      const goStack = await detectGoStack(projectRoot);
-      stack = { ...stack, ...goStack };
-    } else if (detectedLanguage === 'rust') {
-      const rustStack = await detectRustStack(projectRoot);
-      stack = { ...stack, ...rustStack };
-    }
-
-    // Generate test based on language
-    let result;
-
-    if (detectedLanguage === 'python') {
-      result = await generatePythonTest({
-        filePath,
-        code,
-        testFramework: stack.backend?.testFramework || 'pytest',
-      });
-    } else if (detectedLanguage === 'go') {
-      // Extract package name from file
-      const packageMatch = code.match(/package\s+(\w+)/);
-      const packageName = packageMatch ? packageMatch[1] : 'main';
-
-      result = await generateGoTest({
-        filePath,
-        code,
-        packageName,
-      });
-    } else if (detectedLanguage === 'rust') {
-      result = await generateRustTest({
-        filePath,
-        code,
-      });
-    } else if (filePath.match(/\.(tsx|jsx)$/) && stack.frontend?.framework === 'react') {
-      result = await generateReactTest({
-        filePath,
-        code,
-        testFramework: stack.frontend.testFramework || 'vitest',
-      });
-    } else if (filePath.match(/\.ts$/)) {
-      result = await generateNodeJsTest({
-        filePath,
-        code,
-        testFramework: stack.backend?.testFramework || 'vitest',
-      });
-    } else {
-      return {
-        success: false,
-        error: `Unsupported file type or language: ${detectedLanguage}`,
-      };
-    }
-
-    // Write test file
-    const testFilePath = output || result.testFilePath;
-    await fs.writeFile(testFilePath, result.testCode, 'utf-8');
-
-    return {
-      success: true,
-      testFilePath,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error',
-    };
-  }
-}
-
-function detectLanguageFromFile(filePath: string): 'nodejs' | 'python' | 'go' | 'rust' {
-  if (filePath.endsWith('.py')) return 'python';
-  if (filePath.endsWith('.go')) return 'go';
-  if (filePath.endsWith('.rs')) return 'rust';
-  return 'nodejs';
-}
-```
-
-Update `src/testing/detectors/index.ts`:
-
-```typescript
-import { detectFromPackageJson } from './package-json';
-import { detectPythonStack } from './python';
-import { detectGoStack } from './go';
-import { detectRustStack } from './rust';
-import type { TechStack } from '../types';
-
-export async function detectTechStack(projectRoot: string): Promise<TechStack> {
-  let stack: TechStack = {};
-
-  // Try Node.js detection
-  try {
-    const nodeStack = await detectFromPackageJson(projectRoot);
-    stack = { ...stack, ...nodeStack };
-  } catch (error) {
-    // package.json not found
-  }
-
-  // Try Python detection
-  try {
-    const pythonStack = await detectPythonStack(projectRoot);
-    stack = { ...stack, ...pythonStack };
-  } catch (error) {
-    // requirements.txt not found
-  }
-
-  // Try Go detection
-  try {
-    const goStack = await detectGoStack(projectRoot);
-    stack = { ...stack, ...goStack };
-  } catch (error) {
-    // go.mod not found
-  }
-
-  // Try Rust detection
-  try {
-    const rustStack = await detectRustStack(projectRoot);
-    stack = { ...stack, ...rustStack };
-  } catch (error) {
-    // Cargo.toml not found
-  }
-
-  return stack;
-}
-
-export { detectFromPackageJson, detectPythonStack, detectGoStack, detectRustStack };
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/cli/multi-language.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/cli/commands.ts src/testing/detectors/index.ts tests/testing/cli/multi-language.test.ts
-git commit -m "feat(testing): add multi-language support to CLI commands
-
-- Support Python, Go, and Rust test generation
-- Auto-detect language from file extension
-- Integrate language-specific detectors
-- Update CLI to route to appropriate generator
-- Support all languages in omc test gen command
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 10: Documentation and Phase 2 Summary
-
-**Files:**
-- Update: `docs/testing/README.md`
-- Create: `docs/testing/PHASE2.md`
-- Update: `README.md`
-
-**Step 1: Create Phase 2 documentation**
-
-Create `docs/testing/PHASE2.md`:
-
-```markdown
-# LLM Testing System - Phase 2 Features
-
-Phase 2 extends the testing system with advanced features including coverage analysis, multi-language support, complexity analysis, contract testing, and workflow integration.
-
-## New Features
-
-### 1. Coverage Analysis
-
-Analyze test coverage and identify gaps:
-
-```bash
-omc test analyze
-```
-
-Features:
-- Parse c8/nyc coverage reports
-- Identify uncovered code ranges
-- Analyze reasons for gaps (error handling, branches, etc.)
-- Generate supplementary tests for gaps
-
-### 2. Multi-Language Support
-
-Generate tests for Python, Go, and Rust:
-
-```bash
-# Python (pytest)
-omc test gen src/utils/math.py
-
-# Go (testing package)
-omc test gen pkg/math/math.go
-
-# Rust (cargo test)
-omc test gen src/math.rs
-```
-
-Supported frameworks:
-- **Python**: pytest, unittest
-- **Go**: testing package with table-driven tests
-- **Rust**: cargo test with #[test] attributes
-
-### 3. Complexity Analysis
-
-Automatically classify code as simple or complex:
-
-```typescript
-const analysis = await analyzeComplexity({ code, filePath });
-// Returns: { complexity: 'simple' | 'complex', metrics, reasons }
-```
-
-Metrics:
-- Lines of code
-- Cyclomatic complexity
-- Nesting levels
-- External dependencies
-
-Complexity indicators:
-- Payment/auth logic
-- Database transactions
-- External API calls
-- Multiple async operations
-
-### 4. Contract Testing
-
-Generate API contract tests from OpenAPI specs:
-
-```bash
-omc test contract api/openapi.yaml
-```
-
-Supported frameworks:
-- **Pact**: Consumer-driven contract testing
-- **Supertest**: REST API contract tests
-- **MSW**: Mock Service Worker handlers
-
-### 5. Enhanced Test-Engineer Agent
-
-The test-engineer agent now receives enriched context:
-
-- Tech stack detection
-- Complexity analysis
-- Suggested approach (auto/guided/manual)
-- Pre-generated questions for complex code
-
-### 6. UltraQA Integration
-
-UltraQA now includes automatic test generation:
-
-```bash
-/ultraqa
-```
-
-Workflow:
-1. Identify files needing tests
-2. Generate missing tests
-3. Run tests and analyze coverage
-4. Generate supplementary tests for gaps
-5. Repeat until coverage threshold met
-
-## Usage Examples
-
-### Example 1: Python Test Generation
-
-```bash
-omc test gen src/calculator.py
-```
-
-Output:
-```
-✅ Detected: Python + pytest
-✅ Generated: tests/test_calculator.py
-
-Tests include:
-- test_add
-- test_subtract
-- test_multiply
-- test_divide
-```
-
-### Example 2: Coverage Analysis
-
-```bash
-omc test analyze
-```
-
-Output:
-```
-📊 Coverage Analysis:
-- Overall: 75%
-- Lines: 75%
-- Functions: 90%
-- Branches: 70%
-
-Coverage Gaps:
-1. src/utils/validation.ts (lines 42-48)
-   Reason: Error handling not covered
-
-2. src/services/payment.ts (lines 67-72)
-   Reason: Edge case for retries
-
-Generate tests for gaps? (y/n)
-```
-
-### Example 3: Contract Testing
-
-```bash
-omc test contract api/openapi.yaml --framework=pact
-```
-
-Output:
-```
-✅ Generated: tests/contract/frontend-backend.pact.test.ts
-
-Contract tests:
-- GET /users/{id}
-- POST /users
-- PUT /users/{id}
-- DELETE /users/{id}
-```
-
-### Example 4: Complex Code with Test-Engineer
-
-```bash
-/test-gen src/services/payment.ts
-```
-
-Output:
-```
-Agent: Detecting tech stack...
-✅ Detected: Node.js + Express + PostgreSQL + Vitest
-
-Agent: Analyzing complexity...
-⚠️  Complex code detected:
-- Payment processing logic
-- External Stripe API calls
-- Database transactions
-- Multiple async operations
-
-Agent: Delegating to test-engineer for detailed test cases...
-
-Test-Engineer: I'll need some information:
-1. What are the expected payment flows? (success, failure, retry)
-2. Should I mock Stripe API calls?
-3. What database states should I test?
-4. Are there specific edge cases to cover?
-
-[User provides details]
-
-Test-Engineer: Generating comprehensive test suite...
-✅ Generated 12 test cases covering:
-- Happy path payment processing
-- Stripe API failure scenarios
-- Database transaction rollbacks
-- Idempotency checks
-- Concurrent payment handling
-```
-
-## Configuration
-
-Add to `.omc/project-config.json`:
-
-```json
-{
-  "testing": {
-    "coverageThreshold": 80,
-    "complexityThresholds": {
-      "lines": 50,
-      "cyclomaticComplexity": 10,
-      "nestingLevel": 3
-    },
-    "autoGenerateTests": true,
-    "languages": ["nodejs", "python", "go", "rust"]
-  }
-}
-```
-
-## Architecture
-
-```
-src/testing/
-├── analyzers/
-│   ├── coverage.ts       # Coverage analysis
-│   ├── complexity.ts     # Complexity analysis
-│   └── types.ts          # Analyzer types
-├── generators/
-│   ├── react.ts          # React component tests
-│   ├── nodejs.ts         # Node.js function tests
-│   ├── python.ts         # Python pytest tests
-│   ├── go.ts             # Go table-driven tests
-│   ├── rust.ts           # Rust cargo tests
-│   └── contract.ts       # API contract tests
-├── detectors/
-│   ├── index.ts          # Multi-language detection
-│   ├── package-json.ts   # Node.js detection
-│   ├── python.ts         # Python detection
-│   ├── go.ts             # Go detection
-│   └── rust.ts           # Rust detection
-└── cli/
-    ├── commands.ts       # CLI command implementations
-    ├── agent-integration.ts  # Test-engineer integration
-    └── ultraqa-integration.ts  # UltraQA integration
-```
-
-## Next Steps (Phase 3)
-
-- Giskard integration for behavior testing
-- E2E test generation with Playwright
-- CI/CD integration
-- Ralph mode test loops
-- Autopilot automatic testing
-- Performance optimization
-
-## Success Metrics
-
-Phase 2 Achievements:
-- ✅ Multi-language support (Python, Go, Rust)
-- ✅ Coverage analysis and gap identification
-- ✅ Complexity analysis for smart test generation
-- ✅ Contract testing for APIs
-- ✅ Enhanced test-engineer agent
-- ✅ UltraQA integration
-
-Target Metrics:
-- Test coverage: 80%+
-- Test generation time: < 30 seconds/file
-- Multi-language support: 4 languages
-- Complexity classification accuracy: > 90%
-```
-
-**Step 2: Update main testing README**
-
-Update `docs/testing/README.md` to add Phase 2 section:
-
-```markdown
-## Phase 2 Features (NEW)
-
-Phase 2 adds advanced capabilities:
-
-- **Coverage Analysis**: Identify and fill coverage gaps
-- **Multi-Language**: Python, Go, Rust support
-- **Complexity Analysis**: Smart classification of code complexity
-- **Contract Testing**: API contract tests from OpenAPI specs
-- **Enhanced Agent**: Test-engineer with enriched context
-- **UltraQA Integration**: Automatic test generation in QA cycles
-
-See [Phase 2 Documentation](./PHASE2.md) for details.
-
-## Supported Languages
-
-- **Node.js**: Vitest, Jest
-- **Python**: pytest, unittest
-- **Go**: testing package
-- **Rust**: cargo test
-- **React**: Vitest + Testing Library
-```
-
-**Step 3: Update main README**
-
-Update `README.md` to highlight Phase 2 features:
-
-```markdown
-## Testing (Phase 2 - NEW)
-
-oh-my-claudecode now supports advanced test generation across multiple languages:
-
-```bash
-# Node.js/TypeScript
-omc test gen src/utils/math.ts
-
-# Python
-omc test gen src/utils/math.py
-
-# Go
-omc test gen pkg/math/math.go
-
-# Rust
-omc test gen src/math.rs
-
-# Coverage analysis
-omc test analyze
-
-# Contract testing
-omc test contract api/openapi.yaml
-```
-
-Features:
-- Multi-language support (Node.js, Python, Go, Rust)
-- Coverage analysis and gap identification
-- Complexity-based test generation
-- API contract testing
-- Integrated with /ultraqa workflow
-
-See [Testing Documentation](docs/testing/README.md) for details.
-```
-
-**Step 4: Commit**
-
-```bash
-git add docs/testing/ README.md
-git commit -m "docs(testing): add Phase 2 documentation and examples
-
-- Create comprehensive Phase 2 feature documentation
-- Add usage examples for all new features
-- Update main README with Phase 2 highlights
-- Document multi-language support
-- Include configuration examples
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Phase 2 Summary
-
-### Deliverables Checklist
-
-- [x] **Coverage Analysis**
-  - [x] Coverage analyzer for Node.js (c8/nyc)
-  - [x] Gap identification with line ranges
-  - [x] Reason analysis for uncovered code
-
-- [x] **Multi-Language Support**
-  - [x] Python test generator (pytest/unittest)
-  - [x] Go test generator (table-driven tests)
-  - [x] Rust test generator (cargo test)
-  - [x] Language-specific tech stack detectors
-
-- [x] **Complexity Analysis**
-  - [x] Cyclomatic complexity calculation
-  - [x] Nesting level measurement
-  - [x] External dependency detection
-  - [x] Pattern-based complexity indicators
-
-- [x] **Contract Testing**
-  - [x] Pact consumer-driven contract tests
-  - [x] Supertest REST API contracts
-  - [x] MSW handler generation
-  - [x] OpenAPI spec parsing
-
-- [x] **Enhanced Test-Engineer Agent**
-  - [x] Context preparation with tech stack
-  - [x] Complexity-based question generation
-  - [x] Suggested approach determination
-  - [x] Agent documentation updates
-
-- [x] **UltraQA Integration**
-  - [x] Automatic test generation in QA cycles
-  - [x] Coverage gap identification
-  - [x] Test generation for changed files
-  - [x] Skill documentation updates
-
-- [x] **CLI Integration**
-  - [x] Multi-language command routing
-  - [x] Auto-detection of language from file
-  - [x] Unified test generation interface
-
-- [x] **Documentation**
-  - [x] Phase 2 feature documentation
-  - [x] Usage examples for all features
-  - [x] Architecture documentation
-  - [x] Configuration examples
-
-### Estimated Timeline
-
-- **Task 1**: Coverage Analyzer - 1.5 hours
-- **Task 2**: Python Test Generator - 2 hours
-- **Task 3**: Go Test Generator - 1.5 hours
-- **Task 4**: Rust Test Generator - 1.5 hours
-- **Task 5**: Complexity Analyzer - 1.5 hours
-- **Task 6**: Contract Test Generator - 2 hours
-- **Task 7**: Test-Engineer Integration - 1.5 hours
-- **Task 8**: UltraQA Integration - 1.5 hours
-- **Task 9**: Multi-Language CLI - 1 hour
-- **Task 10**: Documentation - 1 hour
-
-**Total**: ~15 hours
-
-### Success Criteria
-
-- [ ] All tests pass: `pnpm test tests/testing/**`
-- [ ] Coverage analyzer works for Node.js projects
-- [ ] Python, Go, and Rust test generation produces valid tests
-- [ ] Complexity analyzer correctly classifies simple vs complex code
-- [ ] Contract tests generate from OpenAPI specs
-- [ ] Test-engineer receives enriched context
-- [ ] UltraQA automatically generates missing tests
-- [ ] CLI supports all languages with auto-detection
-- [ ] Documentation is complete and accurate
-
-### Next Steps (Phase 3)
-
-1. **Giskard Integration**
-   - Behavior testing (perturbations, robustness)
-   - Fairness metrics
-   - LLM-specific test scenarios
-
-2. **E2E Test Generation**
-   - Playwright test generation
-   - User flow testing
-   - Cross-stack integration tests
-
-3. **CI/CD Integration**
-   - GitHub Actions workflow
-   - Automatic test generation on PR
-   - Coverage reporting
-
-4. **Ralph Mode Integration**
-   - Test-fix-verify loops
-   - Automatic test regeneration on failure
-   - Continuous improvement
-
-5. **Autopilot Integration**
-   - Automatic test generation during code creation
-   - Test-first development mode
-   - Coverage threshold enforcement
-
-6. **Performance Optimization**
-   - Parallel test generation
-   - Caching of tech stack detection
-   - Incremental coverage analysis
-
-### Implementation Notes
-
-#### TDD Approach
-
-Each task follows strict TDD:
-1. Write failing test
-2. Run test to verify failure
-3. Implement minimal code to pass
-4. Run test to verify pass
-5. Commit with descriptive message
-
-#### Code Quality
-
-- All code must pass TypeScript type checking
-- All tests must pass before committing
-- Follow existing code style and conventions
-- Use meaningful variable and function names
-- Add comments for complex logic
-
-#### Git Workflow
-
-- Work on feature branch: `git checkout -b feature/llm-testing-phase2 dev`
-- Commit after each task completion
-- Use conventional commit format: `feat(testing): description`
-- Include co-author tag: `Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>`
-- Create PR targeting `dev` branch when complete
-
-#### Testing Strategy
-
-- Unit tests for all functions
-- Integration tests for CLI commands
-- Mock external dependencies (file system, APIs)
-- Use Vitest for all tests
-- Aim for >80% code coverage
-
----
-
-**Plan Status**: ✅ Complete and ready for implementation
-
-**Next Action**: Begin Task 1 - Coverage Analyzer for Node.js