qa360 2.1.2 → 2.1.4

package/core/src/repair/engine/suggestion-engine.ts

@@ -0,0 +1,234 @@
+/**
+ * Fix Suggestion Engine
+ *
+ * Generates fix suggestions using LLM.
+ */
+
+import type { FixSuggestion, TestError, RepairOptions } from '../types.js';
+import { createLLMProvider, type LLMProvider } from '../../ai/index.js';
+
+export interface SuggestionOptions extends RepairOptions {
+  maxSuggestions?: number;
+  includeCode?: boolean;
+}
+
+/**
+ * Generate fix suggestions for test errors
+ */
+export async function generateFixSuggestions(
+  errors: TestError[],
+  testCode: string,
+  sourceCode?: string,
+  options?: SuggestionOptions
+): Promise<FixSuggestion[]> {
+  const suggestions: FixSuggestion[] = [];
+
+  for (const error of errors) {
+    const errorSuggestions = await generateSuggestionsForError(
+      error,
+      testCode,
+      sourceCode,
+      options
+    );
+    suggestions.push(...errorSuggestions);
+  }
+
+  // Sort by confidence and limit
+  const max = options?.maxSuggestions ?? 10;
+  suggestions.sort((a, b) => b.confidence - a.confidence);
+  return suggestions.slice(0, max);
+}
+
+/**
+ * Generate suggestions for a single error
+ */
+async function generateSuggestionsForError(
+  error: TestError,
+  testCode: string,
+  sourceCode: string | undefined,
+  options?: SuggestionOptions
+): Promise<FixSuggestion[]> {
+  const suggestions: FixSuggestion[] = [];
+
+  // Use LLM to generate suggestions
+  const llmResponse = await callLLMForFix(error, testCode, sourceCode, options);
+
+  // Parse LLM response into suggestions
+  const parsed = parseLLMResponse(llmResponse, error);
+
+  return parsed.length > 0 ? parsed : generateFallbackSuggestions(error);
+}
+
+/**
+ * Call LLM to generate fix
+ */
+async function callLLMForFix(
+  error: TestError,
+  testCode: string,
+  sourceCode: string | undefined,
+  options?: SuggestionOptions
+): Promise<string> {
+  const providerType = options?.llmProvider || 'ollama';
+
+  const prompt = buildRepairPrompt(error, testCode, sourceCode);
+
+  try {
+    const provider = await createLLMProvider({ preferred: providerType as any });
+    const result = await provider.generate({
+      prompt,
+      maxTokens: 500,
+      temperature: 0.3
+    });
+    return result.content || '';
+  } catch {
+    // Fallback to empty response
+    return '';
+  }
+}
+
+/**
+ * Build prompt for repair
+ */
+function buildRepairPrompt(error: TestError, testCode: string, sourceCode?: string): string {
+  return `You are a test repair expert. Analyze this test error and suggest fixes.
+
+Test file: ${error.testFile}
+Test: ${error.testName}
+Error type: ${error.type}
+Error message: ${error.message}
+
+Test code:
+\`\`\`typescript
+${testCode}
+\`\`\`
+
+${sourceCode ? `Source code:\n\`\`\`typescript\n${sourceCode}\n\`\`\`\n` : ''}
+
+Provide a JSON response with this format:
+{
+  "fixes": [
+    {
+      "type": "fix_type",
+      "description": "Brief description",
+      "code": "code to apply",
+      "line": ${error.line},
+      "confidence": 0.8,
+      "reason": "Why this fix works"
+    }
+  ]
+}
+
+Only respond with valid JSON, no explanations.`;
+}
+
+/**
+ * Parse LLM response into suggestions
+ */
+function parseLLMResponse(response: string, error: TestError): FixSuggestion[] {
+  try {
+    // Try to extract JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) return [];
+
+    const parsed = JSON.parse(jsonMatch[0]);
+
+    if (Array.isArray(parsed.fixes)) {
+      return parsed.fixes.map((fix: any) => ({
+        type: fix.type || 'update_expectation',
+        description: fix.description || 'Fix test',
+        code: fix.code || '',
+        filePath: error.testFile,
+        line: fix.line || error.line,
+        confidence: fix.confidence || 0.5,
+        reason: fix.reason || 'Generated fix',
+        estimatedEffort: fix.estimatedEffort || 'medium'
+      }));
+    }
+  } catch {
+    // Failed to parse, return empty
+  }
+
+  return [];
+}
+
+/**
+ * Generate fallback suggestions when LLM fails
+ */
+function generateFallbackSuggestions(error: TestError): FixSuggestion[] {
+  const suggestions: FixSuggestion[] = [];
+
+  switch (error.type) {
+    case 'assertion_error':
+      suggestions.push({
+        type: 'update_expectation',
+        description: 'Update expected value to match actual',
+        code: `// Update expectation based on error: ${error.message}`,
+        filePath: error.testFile,
+        line: error.line,
+        confidence: 0.6,
+        reason: 'Assertion failed - check expected vs actual',
+        estimatedEffort: 'low'
+      });
+      break;
+
+    case 'reference_error':
+      suggestions.push({
+        type: 'fix_import',
+        description: 'Import missing variable or module',
+        code: `// Import missing: ${error.message.match(/(\w+) is not defined/)?.[1] || 'unknown'}`,
+        filePath: error.testFile,
+        line: 1,
+        confidence: 0.7,
+        reason: 'Reference error - missing import or definition',
+        estimatedEffort: 'low'
+      });
+      break;
+
+    case 'timeout_error':
+      suggestions.push({
+        type: 'fix_timeout',
+        description: 'Increase test timeout',
+        code: `test.setTimeout(10000); // Increase timeout`,
+        filePath: error.testFile,
+        line: error.line,
+        confidence: 0.8,
+        reason: 'Test timed out - increase timeout or optimize',
+        estimatedEffort: 'low'
+      });
+      break;
+
+    case 'import_error':
+      suggestions.push({
+        type: 'add_dependency',
+        description: 'Install missing dependency',
+        code: `// Run: npm install ${error.message.match(/Cannot find module ['"]([^'"]+)['"]/)?.[1] || 'missing-package'}`,
+        filePath: error.testFile,
+        line: 1,
+        confidence: 0.7,
+        reason: 'Module not found - install or fix import path',
+        estimatedEffort: 'low'
+      });
+      break;
+
+    default:
+      suggestions.push({
+        type: 'manual_review',
+        description: 'Manual review required',
+        code: `// Review error: ${error.message}`,
+        filePath: error.testFile,
+        line: error.line,
+        confidence: 0.3,
+        reason: 'Unknown error type - manual intervention needed',
+        estimatedEffort: 'high'
+      });
+  }
+
+  return suggestions;
+}
+
+/**
+ * Get quick fix suggestions without LLM
+ */
+export function getQuickFixes(error: TestError): FixSuggestion[] {
+  return generateFallbackSuggestions(error);
+}

package/core/src/repair/index.ts

@@ -0,0 +1,53 @@
+/**
+ * Auto-Repair Module
+ *
+ * Automatic test failure repair using AI.
+ */
+
+// Types
+export type {
+  TestError,
+  ErrorType,
+  FixSuggestion,
+  FixType,
+  RepairAnalysis,
+  FixResult,
+  FileChange,
+  RepairOptions,
+  TestRepairResult
+} from './types.js';
+
+// Error Analyzer
+export {
+  analyzeTestError,
+  classifyErrors,
+  isAutoFixable,
+  getCommonFixes,
+  type ParsedError
+} from './utils/error-analyzer.js';
+
+// Suggestion Engine
+export {
+  generateFixSuggestions,
+  getQuickFixes,
+  type SuggestionOptions
+} from './engine/suggestion-engine.js';
+
+// Fixer
+export {
+  applyFixes,
+  generateDiff,
+  revertBackup,
+  type FixerOptions
+} from './engine/fixer.js';
+
+// Repairer
+export {
+  TestRepairer,
+  analyzeTestErrors,
+  createRepairJSONReport,
+  type RepairerOptions,
+  type RepairProgress,
+  type RepairReport,
+  type TestRunResult
+} from './repairer.js';

package/core/src/repair/repairer.ts

@@ -0,0 +1,376 @@
+/**
+ * Test Repairer
+ *
+ * Orchestrates the automatic test repair process.
+ */
+
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import type { TestError, FixSuggestion, RepairAnalysis, TestRepairResult, RepairOptions } from './types.js';
+import { analyzeTestError, isAutoFixable } from './utils/error-analyzer.js';
+import { generateFixSuggestions, getQuickFixes } from './engine/suggestion-engine.js';
+import { applyFixes, type FixerOptions } from './engine/fixer.js';
+
+export interface RepairerOptions extends RepairOptions {
+  fixer?: FixerOptions;
+  maxIterations?: number;
+  onProgress?: (progress: RepairProgress) => void;
+}
+
+export interface RepairProgress {
+  stage: 'analyzing' | 'suggesting' | 'applying' | 'verifying' | 'complete';
+  message: string;
+  iteration?: number;
+  fixesApplied?: number;
+  errorsRemaining?: number;
+}
+
+export interface RepairReport {
+  analysis: RepairAnalysis;
+  result: TestRepairResult;
+  duration: number;
+  success: boolean;
+}
+
+/**
+ * Main test repairer orchestrator
+ */
+export class TestRepairer {
+  private options: RepairerOptions;
+  private iteration = 0;
+
+  constructor(options: RepairerOptions = {}) {
+    this.options = {
+      maxIterations: options.maxIterations ?? 3,
+      backup: options.backup ?? true,
+      autoApply: options.autoApply ?? false,
+      llmProvider: options.llmProvider ?? 'ollama',
+      verbose: options.verbose ?? false,
+      ...options
+    };
+  }
+
+  /**
+   * Analyze test failures and generate repair suggestions
+   */
+  async analyze(
+    testFile: string,
+    testResults?: TestRunResult
+  ): Promise<RepairAnalysis> {
+    this.emitProgress('analyzing', `Analyzing test file: ${testFile}`);
+
+    const errors = testResults?.errors || this.extractErrorsFromTestFile(testFile);
+    const suggestions: FixSuggestion[] = [];
+
+    for (const error of errors) {
+      // Read test code
+      const testCode = await this.readTestCode(error.testFile);
+      let sourceCode: string | undefined;
+
+      // Try to find and read source file
+      const sourcePath = this.inferSourcePath(error.testFile);
+      if (sourcePath && existsSync(sourcePath)) {
+        sourceCode = await readFile(sourcePath, 'utf-8');
+      }
+
+      // Generate suggestions
+      const errorSuggestions = await generateFixSuggestions(
+        [error],
+        testCode,
+        sourceCode,
+        {
+          llmProvider: this.options.llmProvider as any,
+          maxSuggestions: 3,
+          includeCode: true
+        }
+      );
+
+      suggestions.push(...errorSuggestions);
+    }
+
+    const autoFixable = errors.filter(isAutoFixable).length;
+    const estimatedTime = suggestions.length * 5; // 5 seconds per suggestion
+
+    const priority = this.calculatePriority(errors, autoFixable);
+
+    return {
+      errors,
+      autoFixable,
+      suggestions: suggestions.slice(0, 10),
+      estimatedTime,
+      priority
+    };
+  }
+
+  /**
+   * Repair tests automatically
+   */
+  async repair(
+    testFile: string,
+    testResults: TestRunResult
+  ): Promise<RepairReport> {
+    const startTime = Date.now();
+
+    // Analyze failures
+    const analysis = await this.analyze(testFile, testResults);
+
+    this.emitProgress('suggesting', `Generated ${analysis.suggestions.length} fix suggestions`);
+
+    if (analysis.suggestions.length === 0) {
+      return {
+        analysis,
+        result: {
+          originalErrors: analysis.errors,
+          remainingErrors: analysis.errors,
+          fixes: [],
+          success: false,
+          iterations: 0
+        },
+        duration: Date.now() - startTime,
+        success: false
+      };
+    }
+
+    let currentErrors = [...analysis.errors];
+    const appliedFixes: FixSuggestion[] = [];
+
+    // Iterative repair cycle
+    for (this.iteration = 0; this.iteration < this.options.maxIterations!; this.iteration++) {
+      this.emitProgress('applying', `Iteration ${this.iteration + 1}/${this.options.maxIterations}`);
+
+      // Apply fixes
+      if (this.options.autoApply) {
+        const fixResult = await applyFixes(analysis.suggestions, {
+          backup: this.options.backup,
+          dryRun: false
+        });
+
+        appliedFixes.push(...analysis.suggestions.slice(0, fixResult.applied));
+
+        this.emitProgress('applying', `Applied ${fixResult.applied} fixes`);
+
+        // Re-run tests (simulated here - in real scenario would run actual tests)
+        const newErrors = this.simulateRerun(testFile);
+
+        if (newErrors.length === 0) {
+          this.emitProgress('complete', 'All tests passing!');
+
+          return {
+            analysis,
+            result: {
+              originalErrors: currentErrors,
+              remainingErrors: [],
+              fixes: appliedFixes,
+              success: true,
+              iterations: this.iteration + 1
+            },
+            duration: Date.now() - startTime,
+            success: true
+          };
+        }
+
+        currentErrors = newErrors;
+      } else {
+        // Dry run - just report what would be done
+        break;
+      }
+    }
+
+    const success = currentErrors.length < analysis.errors.length;
+
+    return {
+      analysis,
+      result: {
+        originalErrors: analysis.errors,
+        remainingErrors: currentErrors,
+        fixes: appliedFixes,
+        success,
+        iterations: this.iteration
+      },
+      duration: Date.now() - startTime,
+      success
+    };
+  }
+
+  /**
+   * Get quick fixes without LLM
+   */
+  async getQuickFixes(testFile: string, error: TestError): Promise<FixSuggestion[]> {
+    return getQuickFixes(error);
+  }
+
+  /**
+   * Generate repair report
+   */
+  generateReport(report: RepairReport): string {
+    const lines: string[] = [];
+
+    lines.push('=== Test Repair Report ===');
+    lines.push(`Duration: ${report.duration}ms`);
+    lines.push(`Iterations: ${report.result.iterations}`);
+    lines.push(`Original Errors: ${report.result.originalErrors.length}`);
+    lines.push(`Remaining Errors: ${report.result.remainingErrors.length}`);
+    lines.push(`Fixes Applied: ${report.result.fixes.length}`);
+    lines.push(`Success: ${report.success ? 'Yes' : 'No'}`);
+    lines.push('');
+
+    if (report.analysis.suggestions.length > 0) {
+      lines.push('Suggestions:');
+      for (const suggestion of report.analysis.suggestions) {
+        lines.push(`  - ${suggestion.description}`);
+        lines.push(`    Type: ${suggestion.type}`);
+        lines.push(`    Confidence: ${(suggestion.confidence * 100).toFixed(0)}%`);
+        lines.push(`    Effort: ${suggestion.estimatedEffort}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Read test code from file
+   */
+  private async readTestCode(filePath: string): Promise<string> {
+    try {
+      return await readFile(filePath, 'utf-8');
+    } catch {
+      return '';
+    }
+  }
+
+  /**
+   * Infer source file path from test file path
+   */
+  private inferSourcePath(testPath: string): string | undefined {
+    // Common patterns: src.test.ts -> src.ts, __tests__/foo.test.ts -> foo.ts
+    const replacements = [
+      { from: '.test.ts', to: '.ts' },
+      { from: '.spec.ts', to: '.ts' },
+      { from: '.test.js', to: '.js' },
+      { from: '.spec.js', to: '.js' },
+      { from: '__tests__/', to: '../src/' },
+      { from: '/test/', to: '/src/' }
+    ];
+
+    for (const { from, to } of replacements) {
+      if (testPath.includes(from)) {
+        return testPath.replace(from, to);
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Extract errors from test file (basic implementation)
+   */
+  private extractErrorsFromTestFile(testFile: string): TestError[] {
+    // In real implementation, would parse test output
+    return [];
+  }
+
+  /**
+   * Simulate test rerun (for demonstration)
+   */
+  private simulateRerun(testFile: string): TestError[] {
+    // In real implementation, would actually run tests
+    return [];
+  }
+
+  /**
+   * Calculate repair priority
+   */
+  private calculatePriority(errors: TestError[], autoFixable: number): 'high' | 'medium' | 'low' {
+    const fixableRatio = errors.length > 0 ? autoFixable / errors.length : 0;
+
+    if (fixableRatio >= 0.7 && errors.length > 0) {
+      return 'high';
+    } else if (fixableRatio >= 0.4) {
+      return 'medium';
+    }
+    return 'low';
+  }
+
+  /**
+   * Emit progress callback
+   */
+  private emitProgress(stage: RepairProgress['stage'], message: string): void {
+    this.options.onProgress?.({
+      stage,
+      message,
+      iteration: this.iteration,
+      errorsRemaining: 0
+    });
+  }
+}
+
+/**
+ * Test run result
+ */
+export interface TestRunResult {
+  passed: number;
+  failed: number;
+  errors: TestError[];
+  duration: number;
+}
+
+/**
+ * Analyze test errors from raw output
+ */
+export async function analyzeTestErrors(
+  testFile: string,
+  errorOutput: string
+): Promise<TestError[]> {
+  const errors: TestError[] = [];
+
+  // Parse error output (basic implementation)
+  const errorBlocks = errorOutput.split(/\n\s*●/g).filter(Boolean);
+
+  for (const block of errorBlocks) {
+    const lines = block.split('\n');
+    const firstLine = lines[0] || '';
+
+    // Extract test name
+    const testNameMatch = firstLine.match(/^(.+?)\s*$/);
+    const testName = testNameMatch?.[1] || 'unknown';
+
+    // Extract error message
+    const errorMessage = lines.slice(1).join('\n').trim();
+
+    if (errorMessage) {
+      errors.push(analyzeTestError(testFile, testName, errorMessage));
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * Create repair report in JSON format
+ */
+export function createRepairJSONReport(report: RepairReport): string {
+  return JSON.stringify({
+    duration: report.duration,
+    success: report.success,
+    result: {
+      originalErrors: report.result.originalErrors.length,
+      remainingErrors: report.result.remainingErrors.length,
+      fixesApplied: report.result.fixes.length,
+      iterations: report.result.iterations,
+      success: report.result.success
+    },
+    analysis: {
+      totalErrors: report.analysis.errors.length,
+      autoFixable: report.analysis.autoFixable,
+      suggestions: report.analysis.suggestions.length,
+      priority: report.analysis.priority,
+      estimatedTime: report.analysis.estimatedTime
+    },
+    suggestions: report.analysis.suggestions.map(s => ({
+      type: s.type,
+      description: s.description,
+      confidence: s.confidence,
+      estimatedEffort: s.estimatedEffort
+    }))
+  }, null, 2);
+}