qa360 2.1.2 → 2.1.4

package/dist/core/repair/engine/suggestion-engine.js

@@ -1,187 +0,0 @@
-/**
- * Fix Suggestion Engine
- *
- * Generates fix suggestions using LLM.
- */
-import { createLLMProvider } from '../../ai/index.js';
-/**
- * Generate fix suggestions for test errors
- */
-export async function generateFixSuggestions(errors, testCode, sourceCode, options) {
-    const suggestions = [];
-    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, testCode, sourceCode, options) {
-    const suggestions = [];
-    // 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, testCode, sourceCode, options) {
-    const providerType = options?.llmProvider || 'ollama';
-    const prompt = buildRepairPrompt(error, testCode, sourceCode);
-    try {
-        const provider = await createLLMProvider({ preferred: providerType });
-        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, testCode, sourceCode) {
-    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, error) {
-    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) => ({
-                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) {
-    const suggestions = [];
-    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) {
-    return generateFallbackSuggestions(error);
-}

package/dist/core/repair/index.d.ts

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

package/dist/core/repair/index.js

@@ -1,13 +0,0 @@
-/**
- * Auto-Repair Module
- *
- * Automatic test failure repair using AI.
- */
-// Error Analyzer
-export { analyzeTestError, classifyErrors, isAutoFixable, getCommonFixes } from './utils/error-analyzer.js';
-// Suggestion Engine
-export { generateFixSuggestions, getQuickFixes } from './engine/suggestion-engine.js';
-// Fixer
-export { applyFixes, generateDiff, revertBackup } from './engine/fixer.js';
-// Repairer
-export { TestRepairer, analyzeTestErrors, createRepairJSONReport } from './repairer.js';

package/dist/core/repair/repairer.d.ts

@@ -1,90 +0,0 @@
-/**
- * Test Repairer
- *
- * Orchestrates the automatic test repair process.
- */
-import type { TestError, FixSuggestion, RepairAnalysis, TestRepairResult, RepairOptions } from './types.js';
-import { 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 declare class TestRepairer {
-    private options;
-    private iteration;
-    constructor(options?: RepairerOptions);
-    /**
-     * Analyze test failures and generate repair suggestions
-     */
-    analyze(testFile: string, testResults?: TestRunResult): Promise<RepairAnalysis>;
-    /**
-     * Repair tests automatically
-     */
-    repair(testFile: string, testResults: TestRunResult): Promise<RepairReport>;
-    /**
-     * Get quick fixes without LLM
-     */
-    getQuickFixes(testFile: string, error: TestError): Promise<FixSuggestion[]>;
-    /**
-     * Generate repair report
-     */
-    generateReport(report: RepairReport): string;
-    /**
-     * Read test code from file
-     */
-    private readTestCode;
-    /**
-     * Infer source file path from test file path
-     */
-    private inferSourcePath;
-    /**
-     * Extract errors from test file (basic implementation)
-     */
-    private extractErrorsFromTestFile;
-    /**
-     * Simulate test rerun (for demonstration)
-     */
-    private simulateRerun;
-    /**
-     * Calculate repair priority
-     */
-    private calculatePriority;
-    /**
-     * Emit progress callback
-     */
-    private emitProgress;
-}
-/**
- * Test run result
- */
-export interface TestRunResult {
-    passed: number;
-    failed: number;
-    errors: TestError[];
-    duration: number;
-}
-/**
- * Analyze test errors from raw output
- */
-export declare function analyzeTestErrors(testFile: string, errorOutput: string): Promise<TestError[]>;
-/**
- * Create repair report in JSON format
- */
-export declare function createRepairJSONReport(report: RepairReport): string;

package/dist/core/repair/repairer.js

@@ -1,284 +0,0 @@
-/**
- * Test Repairer
- *
- * Orchestrates the automatic test repair process.
- */
-import { readFile } from 'fs/promises';
-import { existsSync } from 'fs';
-import { analyzeTestError, isAutoFixable } from './utils/error-analyzer.js';
-import { generateFixSuggestions, getQuickFixes } from './engine/suggestion-engine.js';
-import { applyFixes } from './engine/fixer.js';
-/**
- * Main test repairer orchestrator
- */
-export class TestRepairer {
-    options;
-    iteration = 0;
-    constructor(options = {}) {
-        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, testResults) {
-        this.emitProgress('analyzing', `Analyzing test file: ${testFile}`);
-        const errors = testResults?.errors || this.extractErrorsFromTestFile(testFile);
-        const suggestions = [];
-        for (const error of errors) {
-            // Read test code
-            const testCode = await this.readTestCode(error.testFile);
-            let sourceCode;
-            // 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,
-                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, testResults) {
-        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 = [];
-        // 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, error) {
-        return getQuickFixes(error);
-    }
-    /**
-     * Generate repair report
-     */
-    generateReport(report) {
-        const lines = [];
-        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
-     */
-    async readTestCode(filePath) {
-        try {
-            return await readFile(filePath, 'utf-8');
-        }
-        catch {
-            return '';
-        }
-    }
-    /**
-     * Infer source file path from test file path
-     */
-    inferSourcePath(testPath) {
-        // 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)
-     */
-    extractErrorsFromTestFile(testFile) {
-        // In real implementation, would parse test output
-        return [];
-    }
-    /**
-     * Simulate test rerun (for demonstration)
-     */
-    simulateRerun(testFile) {
-        // In real implementation, would actually run tests
-        return [];
-    }
-    /**
-     * Calculate repair priority
-     */
-    calculatePriority(errors, autoFixable) {
-        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
-     */
-    emitProgress(stage, message) {
-        this.options.onProgress?.({
-            stage,
-            message,
-            iteration: this.iteration,
-            errorsRemaining: 0
-        });
-    }
-}
-/**
- * Analyze test errors from raw output
- */
-export async function analyzeTestErrors(testFile, errorOutput) {
-    const errors = [];
-    // 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) {
-    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);
-}

package/dist/core/repair/types.d.ts

@@ -1,91 +0,0 @@
-/**
- * Auto-Repair Module - Type Definitions
- *
- * Automatic test repair using AI.
- */
-/**
- * Test error information
- */
-export interface TestError {
-    testFile: string;
-    testName: string;
-    line: number;
-    type: ErrorType;
-    message: string;
-    stack?: string;
-    context?: string;
-    code?: string;
-}
-/**
- * Error types
- */
-export type ErrorType = 'assertion_error' | 'timeout_error' | 'reference_error' | 'type_error' | 'import_error' | 'async_error' | 'mock_error' | 'unknown';
-/**
- * Fix suggestion
- */
-export interface FixSuggestion {
-    type: FixType;
-    description: string;
-    code: string;
-    filePath: string;
-    line: number;
-    confidence: number;
-    reason: string;
-    estimatedEffort: 'low' | 'medium' | 'high';
-}
-/**
- * Fix types
- */
-export type FixType = 'add_mock' | 'add_assertion' | 'fix_import' | 'fix_async' | 'fix_timeout' | 'fix_typo' | 'update_expectation' | 'add_test' | 'refactor' | 'add_dependency' | 'manual_review';
-/**
- * Repair analysis result
- */
-export interface RepairAnalysis {
-    errors: TestError[];
-    autoFixable: number;
-    suggestions: FixSuggestion[];
-    estimatedTime: number;
-    priority: 'high' | 'medium' | 'low';
-}
-/**
- * Fix application result
- */
-export interface FixResult {
-    success: boolean;
-    suggestions: FixSuggestion[];
-    applied: number;
-    failed: number;
-    testsPassed: number;
-    testsFailed: number;
-    changes: FileChange[];
-}
-/**
- * File change
- */
-export interface FileChange {
-    path: string;
-    original: string;
-    modified: string;
-    backup: string;
-}
-/**
- * Repair options
- */
-export interface RepairOptions {
-    testPattern?: string;
-    maxIterations?: number;
-    autoApply?: boolean;
-    backup?: boolean;
-    llmProvider?: 'ollama' | 'openai' | 'anthropic' | 'mock';
-    verbose?: boolean;
-}
-/**
- * Test repair result
- */
-export interface TestRepairResult {
-    originalErrors: TestError[];
-    remainingErrors: TestError[];
-    fixes: FixSuggestion[];
-    success: boolean;
-    iterations: number;
-}

package/dist/core/repair/types.js

@@ -1,6 +0,0 @@
-/**
- * Auto-Repair Module - Type Definitions
- *
- * Automatic test repair using AI.
- */
-export {};