qa360 2.2.1 → 2.2.7

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

@@ -1,234 +0,0 @@
-/**
- * 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

@@ -1,53 +0,0 @@
-/**
- * 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

@@ -1,376 +0,0 @@
-/**
- * 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);
-}