qa360 1.4.5 → 2.0.1

package/dist/core/repair/utils/error-analyzer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Error Analyzer
+ *
+ * Analyzes test errors to extract patterns and classify problems.
+ */
+import type { TestError, ErrorType } from '../types.js';
+export interface ParsedError {
+    type: ErrorType;
+    message: string;
+    details: Record<string, unknown>;
+    fixable: boolean;
+}
+/**
+ * Analyze a test error message and classify it
+ */
+export declare function analyzeTestError(testFile: string, testName: string, errorMessage: string, stack?: string): TestError;
+/**
+ * Classify multiple test errors
+ */
+export declare function classifyErrors(errors: string[]): Map<ErrorType, number>;
+/**
+ * Check if error is auto-fixable
+ */
+export declare function isAutoFixable(error: TestError): boolean;
+/**
+ * Get fix suggestions for an error type
+ */
+export declare function getCommonFixes(error: TestError): string[];

package/dist/core/repair/utils/error-analyzer.js

@@ -0,0 +1,264 @@
+/**
+ * Error Analyzer
+ *
+ * Analyzes test errors to extract patterns and classify problems.
+ */
+/**
+ * Analyze a test error message and classify it
+ */
+export function analyzeTestError(testFile, testName, errorMessage, stack) {
+    const parsed = parseErrorMessage(errorMessage, stack);
+    return {
+        testFile,
+        testName,
+        line: extractErrorLine(stack),
+        type: parsed.type,
+        message: parsed.message,
+        stack,
+        context: extractContext(parsed),
+        code: extractErrorCode(parsed)
+    };
+}
+/**
+ * Parse error message to extract type and details
+ */
+function parseErrorMessage(message, stack) {
+    const lower = message.toLowerCase();
+    // AssertionError
+    if (lower.includes('expected') || lower.includes('assertion')) {
+        return {
+            type: 'assertion_error',
+            message,
+            details: {
+                expected: extractExpected(message),
+                received: extractReceived(message),
+            },
+            fixable: true
+        };
+    }
+    // TimeoutError
+    if (lower.includes('timeout') || lower.includes('timed out')) {
+        return {
+            type: 'timeout_error',
+            message,
+            details: {},
+            fixable: true
+        };
+    }
+    // ReferenceError
+    if (lower.includes('is not defined') || lower.includes('reference error')) {
+        return {
+            type: 'reference_error',
+            message,
+            details: {
+                missingVar: extractMissingVariable(message)
+            },
+            fixable: true
+        };
+    }
+    // TypeError
+    if (lower.includes('is not a') || lower.includes('is not function') || lower.includes('type error')) {
+        return {
+            type: 'type_error',
+            message,
+            details: {},
+            fixable: true
+        };
+    }
+    // Import error
+    if (lower.includes("cannot find module") || lower.includes('unexpected token')) {
+        return {
+            type: 'import_error',
+            message,
+            details: {
+                missingModule: extractMissingModule(message)
+            },
+            fixable: true
+        };
+    }
+    // Async error
+    if (lower.includes('async') || lower.includes('promise')) {
+        return {
+            type: 'async_error',
+            message,
+            details: {},
+            fixable: true
+        };
+    }
+    return {
+        type: 'unknown',
+        message,
+        details: {},
+        fixable: false
+    };
+}
+/**
+ * Extract line number from stack trace
+ */
+function extractErrorLine(stack) {
+    if (!stack)
+        return 0;
+    const lines = stack.split('\n');
+    for (const line of lines) {
+        const match = line.match(/:(\d+):(\d+)/);
+        if (match) {
+            return parseInt(match[1], 10);
+        }
+    }
+    return 0;
+}
+/**
+ * Extract expected value from error message
+ */
+function extractExpected(message) {
+    const patterns = [
+        /expected\s+["']([^"']+)["']/i,
+        /to be\s+["']?([^"')\s]+)["']?/i,
+        /expected:\s*(.+?)(?:,|but)/i
+    ];
+    for (const pattern of patterns) {
+        const match = message.match(pattern);
+        if (match)
+            return match[1].trim();
+    }
+    return '';
+}
+/**
+ * Extract received value from error message
+ */
+function extractReceived(message) {
+    const patterns = [
+        /received\s+["']([^"']+)["']/i,
+        /but got\s+["']?([^"')\s]+)["']?/i,
+        /received:\s*(.+?)(?:,|\)|$)/i
+    ];
+    for (const pattern of patterns) {
+        const match = message.match(pattern);
+        if (match)
+            return match[1].trim();
+    }
+    return '';
+}
+/**
+ * Extract missing variable from reference error
+ */
+function extractMissingVariable(message) {
+    const match = message.match(/(\w+)\s+is not defined/i);
+    if (match)
+        return match[1];
+    const refMatch = message.match(/ReferenceError:\s*(\w+)/i);
+    if (refMatch)
+        return refMatch[1];
+    return '';
+}
+/**
+ * Extract missing module from import error
+ */
+function extractMissingModule(message) {
+    const match = message.match(/Cannot find module ['"]([^'"]+)['"]/i);
+    if (match)
+        return match[1];
+    const modMatch = message.match(/Cannot find module ['"](.+)['"]/);
+    if (modMatch)
+        return modMatch[1];
+    return '';
+}
+/**
+ * Extract context from parsed error
+ */
+function extractContext(parsed) {
+    const contexts = {
+        assertion_error: 'Assertion failed - check expected vs actual values',
+        timeout_error: 'Test took too long - increase timeout or fix performance',
+        reference_error: 'Undefined variable - check imports and spelling',
+        type_error: 'Type mismatch - check data types and conversions',
+        import_error: 'Module not found - check import path and dependencies',
+        async_error: 'Async issue - check promises and async/await usage',
+        mock_error: 'Mock not configured - check test setup and mocks',
+        unknown: 'Unknown error type'
+    };
+    return contexts[parsed.type] || contexts.unknown;
+}
+/**
+ * Extract error code if present
+ */
+function extractErrorCode(parsed) {
+    return parsed.type.toUpperCase().replace(/_/g, '-');
+}
+/**
+ * Classify multiple test errors
+ */
+export function classifyErrors(errors) {
+    const counts = new Map();
+    for (const error of errors) {
+        const parsed = parseErrorMessage(error);
+        counts.set(parsed.type, (counts.get(parsed.type) || 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Check if error is auto-fixable
+ */
+export function isAutoFixable(error) {
+    // Most assertion and reference errors are auto-fixable
+    if (error.type === 'assertion_error' || error.type === 'reference_error') {
+        return true;
+    }
+    // Import errors and type errors are often fixable
+    if (error.type === 'import_error' || error.type === 'type_error') {
+        return true;
+    }
+    // Timeouts can sometimes be fixed by increasing timeout
+    if (error.type === 'timeout_error') {
+        return true;
+    }
+    return false;
+}
+/**
+ * Get fix suggestions for an error type
+ */
+export function getCommonFixes(error) {
+    const fixes = {
+        assertion_error: [
+            'Update expected value to match actual',
+            'Add/modify mock to return expected value',
+            'Fix test data setup'
+        ],
+        timeout_error: [
+            'Increase test timeout',
+            'Optimize test execution',
+            'Remove unnecessary waits'
+        ],
+        reference_error: [
+            'Import missing module/variable',
+            'Fix typo in variable name',
+            'Define missing variable'
+        ],
+        type_error: [
+            'Add type conversion',
+            'Fix data type mismatch',
+            'Check API response structure'
+        ],
+        import_error: [
+            'Install missing dependency',
+            'Fix import path',
+            'Add module to dependencies'
+        ],
+        async_error: [
+            'Add await to async calls',
+            'Return promise from async function',
+            'Fix promise chain'
+        ],
+        mock_error: [
+            'Configure mock properly',
+            'Add mock setup in test',
+            'Reset mocks between tests'
+        ],
+        unknown: [
+            'Review test code',
+            'Check test setup',
+            'Verify test environment'
+        ]
+    };
+    return fixes[error.type] || fixes.unknown;
+}

package/dist/core/retry/flakiness-integration.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Flakiness Integration for Smart Retry
+ *
+ * Integrates Smart Retry with the Flakiness Detection Engine
+ * to make intelligent retry decisions based on historical data.
+ */
+import type { FlakinessResult, TestResult as FlakinessTestResult } from '../flakiness/index.js';
+import type { RetryConfig, RetryRecommendation } from './types.js';
+/**
+ * Enhanced retry config with flakiness awareness
+ */
+export interface FlakinessAwareRetryConfig extends RetryConfig {
+    /** Use flakiness score to determine retry strategy */
+    useFlakinessScore?: boolean;
+    /** Minimum historical runs before using flakiness data */
+    minHistoricalRuns?: number;
+    /** Boost retry attempts for known flaky tests */
+    boostRetriesForFlaky?: boolean;
+    /** Reduce retries for known stable tests */
+    reduceRetriesForStable?: boolean;
+}
+/**
+ * Flakiness-aware retry engine
+ */
+export declare class FlakinessAwareRetryEngine {
+    private flakinessHistory;
+    private testHistory;
+    /**
+     * Load flakiness data
+     */
+    loadFlakinessData(results: FlakinessResult[]): void;
+    /**
+     * Add test result to history
+     */
+    addTestResult(testId: string, result: FlakinessTestResult): void;
+    /**
+     * Get retry config for a specific test based on flakiness
+     */
+    getRetryConfigForTest(testId: string, baseConfig: FlakinessAwareRetryConfig): RetryConfig;
+    /**
+     * Get comprehensive retry recommendation
+     */
+    getRetryRecommendation(testId: string): RetryRecommendation;
+    /**
+     * Check if test should be skipped (too flaky)
+     */
+    shouldSkipTest(testId: string): boolean;
+    /**
+     * Get flakiness history
+     */
+    getFlakinessHistory(): Map<string, FlakinessResult>;
+    /**
+     * Clear all history
+     */
+    clearHistory(): void;
+}
+/**
+ * Create a flakiness-aware retry engine
+ */
+export declare function createFlakinessAwareRetryEngine(): FlakinessAwareRetryEngine;

package/dist/core/retry/flakiness-integration.js

@@ -0,0 +1,228 @@
+/**
+ * Flakiness Integration for Smart Retry
+ *
+ * Integrates Smart Retry with the Flakiness Detection Engine
+ * to make intelligent retry decisions based on historical data.
+ */
+import { RetryStrategy } from './types.js';
+/**
+ * Flakiness-aware retry engine
+ */
+export class FlakinessAwareRetryEngine {
+    flakinessHistory = new Map();
+    testHistory = new Map();
+    /**
+     * Load flakiness data
+     */
+    loadFlakinessData(results) {
+        for (const result of results) {
+            this.flakinessHistory.set(result.testId, result);
+        }
+    }
+    /**
+     * Add test result to history
+     */
+    addTestResult(testId, result) {
+        if (!this.testHistory.has(testId)) {
+            this.testHistory.set(testId, []);
+        }
+        this.testHistory.get(testId).push(result);
+    }
+    /**
+     * Get retry config for a specific test based on flakiness
+     */
+    getRetryConfigForTest(testId, baseConfig) {
+        const flakiness = this.flakinessHistory.get(testId);
+        const recentResults = this.testHistory.get(testId);
+        // If no flakiness data, return base config
+        const minRuns = baseConfig.minHistoricalRuns ?? 0;
+        if (!flakiness || !recentResults || recentResults.length < minRuns) {
+            return baseConfig;
+        }
+        const config = { ...baseConfig };
+        // Adjust based on flakiness score
+        if (baseConfig.useFlakinessScore) {
+            const score = flakiness.score;
+            if (score >= 90) {
+                // Legendary/Solid - reduce retries
+                if (baseConfig.reduceRetriesForStable) {
+                    config.maxRetries = Math.max(0, baseConfig.maxRetries - 1);
+                    config.strategy = RetryStrategy.FIXED;
+                }
+            }
+            else if (score >= 75) {
+                // Good - keep base config
+                config.strategy = RetryStrategy.FIXED;
+            }
+            else if (score >= 50) {
+                // Shaky - increase retries slightly
+                if (baseConfig.boostRetriesForFlaky) {
+                    config.maxRetries = baseConfig.maxRetries + 1;
+                    config.strategy = RetryStrategy.ADAPTIVE;
+                }
+            }
+            else {
+                // Unstable - aggressive retry
+                if (baseConfig.boostRetriesForFlaky) {
+                    config.maxRetries = baseConfig.maxRetries + 2;
+                    config.strategy = RetryStrategy.INTELLIGENT;
+                }
+            }
+        }
+        // Adjust based on pattern type
+        if (flakiness.patternType) {
+            switch (flakiness.patternType) {
+                case 'timing':
+                    config.initialDelayMs = Math.max(config.initialDelayMs, 2000);
+                    config.retryOnTimeout = true;
+                    break;
+                case 'external_dependency':
+                    config.initialDelayMs = Math.max(config.initialDelayMs, 3000);
+                    config.strategy = RetryStrategy.EXPONENTIAL;
+                    break;
+                case 'race_condition':
+                    config.strategy = RetryStrategy.EXPONENTIAL;
+                    config.jitterFactor = Math.max(config.jitterFactor, 0.2);
+                    break;
+                case 'selector_issue':
+                    config.strategy = RetryStrategy.FIXED;
+                    config.maxRetries = Math.min(config.maxRetries, 3);
+                    break;
+            }
+        }
+        // Adjust based on recent streak
+        if (flakiness.currentStreak && flakiness.currentStreak > 3) {
+            if (flakiness.streakType === 'fail') {
+                // Long fail streak - boost retries
+                config.maxRetries = config.maxRetries + 1;
+            }
+            else {
+                // Long pass streak - reduce retries
+                config.maxRetries = Math.max(1, config.maxRetries - 1);
+            }
+        }
+        return config;
+    }
+    /**
+     * Get comprehensive retry recommendation
+     */
+    getRetryRecommendation(testId) {
+        const flakiness = this.flakinessHistory.get(testId);
+        const recentResults = this.testHistory.get(testId);
+        if (!flakiness || !recentResults || recentResults.length < 3) {
+            return {
+                shouldRetry: true,
+                strategy: RetryStrategy.ADAPTIVE,
+                maxRetries: 3,
+                initialDelayMs: 1000,
+                confidence: 0.5,
+                reason: 'Insufficient historical data, using default adaptive retry'
+            };
+        }
+        // Analyze recent failures
+        const recentFailures = recentResults.slice(-10).filter(r => !r.success);
+        const failureRate = recentFailures.length / Math.min(recentResults.length, 10);
+        // Build recommendation
+        let strategy;
+        let maxRetries;
+        let initialDelayMs;
+        let confidence;
+        const reasons = [];
+        // Base recommendation on flakiness score
+        if (flakiness.score >= 90) {
+            strategy = RetryStrategy.NONE;
+            maxRetries = 0;
+            initialDelayMs = 0;
+            confidence = 0.9;
+            reasons.push('Test is highly reliable');
+        }
+        else if (flakiness.score >= 75) {
+            strategy = RetryStrategy.FIXED;
+            maxRetries = 2;
+            initialDelayMs = 1000;
+            confidence = 0.75;
+            reasons.push('Test is occasionally flaky');
+        }
+        else if (flakiness.score >= 50) {
+            strategy = RetryStrategy.ADAPTIVE;
+            maxRetries = 3;
+            initialDelayMs = 1000;
+            confidence = 0.85;
+            reasons.push('Test is often flaky');
+        }
+        else {
+            strategy = RetryStrategy.INTELLIGENT;
+            maxRetries = 5;
+            initialDelayMs = 2000;
+            confidence = 0.9;
+            reasons.push('Test is very flaky, aggressive retry recommended');
+        }
+        // Adjust based on pattern
+        if (flakiness.patternType) {
+            reasons.push(`Pattern: ${flakiness.patternType}`);
+            switch (flakiness.patternType) {
+                case 'timing':
+                    initialDelayMs = Math.max(initialDelayMs, 2000);
+                    strategy = flakiness.score < 75 ? RetryStrategy.EXPONENTIAL : strategy;
+                    break;
+                case 'external_dependency':
+                    initialDelayMs = Math.max(initialDelayMs, 3000);
+                    break;
+                case 'selector_issue':
+                    strategy = RetryStrategy.FIXED;
+                    maxRetries = Math.min(maxRetries, 3);
+                    break;
+            }
+        }
+        // Adjust based on recent failure rate
+        if (failureRate > 0.5) {
+            maxRetries = Math.min(maxRetries + 1, 5);
+            reasons.push(`High recent failure rate (${Math.round(failureRate * 100)}%)`);
+        }
+        else if (failureRate < 0.1 && flakiness.score >= 75) {
+            // For highly reliable tests (score >= 90), keep maxRetries at 0
+            if (flakiness.score < 90) {
+                maxRetries = Math.max(maxRetries - 1, 1);
+            }
+            reasons.push('Low recent failure rate');
+        }
+        return {
+            shouldRetry: maxRetries > 0,
+            strategy,
+            maxRetries,
+            initialDelayMs,
+            confidence,
+            reason: reasons.join('; '),
+            pattern: flakiness.patternType
+        };
+    }
+    /**
+     * Check if test should be skipped (too flaky)
+     */
+    shouldSkipTest(testId) {
+        const flakiness = this.flakinessHistory.get(testId);
+        if (!flakiness)
+            return false;
+        // Skip if score is very low and has many runs
+        return flakiness.score < 30 && flakiness.totalRuns >= 10;
+    }
+    /**
+     * Get flakiness history
+     */
+    getFlakinessHistory() {
+        return new Map(this.flakinessHistory);
+    }
+    /**
+     * Clear all history
+     */
+    clearHistory() {
+        this.flakinessHistory.clear();
+        this.testHistory.clear();
+    }
+}
+/**
+ * Create a flakiness-aware retry engine
+ */
+export function createFlakinessAwareRetryEngine() {
+    return new FlakinessAwareRetryEngine();
+}

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

@@ -0,0 +1,14 @@
+/**
+ * QA360 Smart Retry Module (F8)
+ *
+ * Intelligent retry strategies based on flakiness scoring and pattern detection.
+ * Completes the flakiness system: Detection → Scoring → Quarantine → Smart Retry
+ *
+ * @module retry
+ */
+export { RetryStrategy, DEFAULT_RETRY_CONFIG } from './types.js';
+export type { RetryAttempt, RetryResult, RetryConfig, RetryRecommendation, RetryHistoryRecord, RetryStatistics } from './types.js';
+export { SmartRetryEngine, createSmartRetryEngine, type TestExecutor } from './retry-engine.js';
+export { FlakinessAwareRetryEngine, createFlakinessAwareRetryEngine, type FlakinessAwareRetryConfig } from './flakiness-integration.js';
+export { RetryVault } from './vault.js';
+export type { FlakinessResult, FlakinessCategory, TestResult as FlakinessTestResult } from '../flakiness/index.js';

package/dist/core/retry/index.js

@@ -0,0 +1,16 @@
+/**
+ * QA360 Smart Retry Module (F8)
+ *
+ * Intelligent retry strategies based on flakiness scoring and pattern detection.
+ * Completes the flakiness system: Detection → Scoring → Quarantine → Smart Retry
+ *
+ * @module retry
+ */
+// Types
+export { RetryStrategy, DEFAULT_RETRY_CONFIG } from './types.js';
+// Core engine
+export { SmartRetryEngine, createSmartRetryEngine } from './retry-engine.js';
+// Flakiness integration
+export { FlakinessAwareRetryEngine, createFlakinessAwareRetryEngine } from './flakiness-integration.js';
+// Vault integration
+export { RetryVault } from './vault.js';

package/dist/core/retry/retry-engine.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Smart Retry Engine
+ *
+ * Core retry logic with multiple strategies and adaptive behavior.
+ */
+import type { RetryConfig, RetryResult, RetryRecommendation } from './types.js';
+/**
+ * Test execution function type
+ */
+export type TestExecutor<T = unknown> = () => Promise<T>;
+/**
+ * Smart Retry Engine
+ */
+export declare class SmartRetryEngine {
+    private config;
+    constructor(config?: Partial<RetryConfig>);
+    /**
+     * Execute a test with retry logic
+     */
+    executeWithRetry(testId: string, executor: TestExecutor, context?: {
+        testName?: string;
+        gate?: string;
+        flakinessScore?: number;
+        patternType?: string;
+    }): Promise<RetryResult>;
+    /**
+     * Get retry recommendation based on flakiness and pattern
+     */
+    getRetryRecommendation(params: {
+        flakinessScore?: number;
+        patternType?: string;
+        errorType?: string;
+        errorCount?: number;
+        recentAttempts?: number;
+    }): RetryRecommendation;
+    /**
+     * Calculate delay before retry attempt
+     */
+    private calculateDelay;
+    /**
+     * Get effective strategy based on context
+     */
+    private getEffectiveStrategy;
+    /**
+     * Calculate intelligent delay based on common patterns
+     */
+    private getIntelligentDelay;
+    /**
+     * Apply jitter to delay to avoid thundering herd
+     */
+    private applyJitter;
+    /**
+     * Check if error type is non-retriable
+     */
+    private isNonRetriableError;
+    /**
+     * Check if error is an assertion failure
+     */
+    private isAssertionError;
+    /**
+     * Check if error is a timeout
+     */
+    private isTimeoutError;
+    /**
+     * Delay for specified milliseconds
+     */
+    private delay;
+    /**
+     * Update retry configuration
+     */
+    updateConfig(config: Partial<RetryConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): RetryConfig;
+}
+/**
+ * Create a smart retry engine
+ */
+export declare function createSmartRetryEngine(config?: Partial<RetryConfig>): SmartRetryEngine;