@agentic-qe/v3 3.0.0-alpha.3

package/dist/domains/test-execution/services/flaky-detector.js

@@ -0,0 +1,834 @@
+/**
+ * Agentic QE v3 - Flaky Test Detector Service
+ * Identifies and analyzes flaky tests from execution history
+ */
+import { v4 as uuidv4 } from 'uuid';
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import { ok, err } from '../../../shared/types';
+const DEFAULT_FLAKY_CONFIG = {
+    simulateForTesting: false,
+    simulatedFlakinessRate: 0.3,
+    simulatedFlakyPassRate: 0.7,
+    simulatedTestsPerFile: 2,
+    testRunner: 'npx',
+    testRunnerArgs: ['vitest', 'run', '--reporter=json'],
+    runTimeout: 60000,
+};
+// ============================================================================
+// Flaky Detector Service
+// ============================================================================
+export class FlakyDetectorService {
+    memory;
+    testHistory = new Map();
+    analysisCache = new Map();
+    config;
+    constructor(memory, config = {}) {
+        this.memory = memory;
+        this.config = { ...DEFAULT_FLAKY_CONFIG, ...config };
+    }
+    /**
+     * Detect flaky tests by running them multiple times
+     */
+    async detectFlaky(request) {
+        const startTime = Date.now();
+        try {
+            const { testFiles, runs, threshold } = request;
+            if (runs < 2) {
+                return err(new Error('Minimum 2 runs required for flaky detection'));
+            }
+            if (threshold < 0 || threshold > 1) {
+                return err(new Error('Threshold must be between 0 and 1'));
+            }
+            const flakyTests = [];
+            for (const file of testFiles) {
+                const fileResults = await this.runMultipleTimes(file, runs);
+                const flakyInFile = this.identifyFlakyTests(fileResults, threshold);
+                flakyTests.push(...flakyInFile);
+            }
+            const report = {
+                flakyTests,
+                totalRuns: runs * testFiles.length,
+                analysisTime: Date.now() - startTime,
+            };
+            // Store report for future reference
+            await this.storeReport(report);
+            return ok(report);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Analyze failure patterns for a specific test
+     */
+    async analyzePattern(testId) {
+        try {
+            // Check cache
+            const cached = this.analysisCache.get(testId);
+            if (cached) {
+                return ok(cached);
+            }
+            // Load history
+            const history = await this.getTestHistory(testId);
+            if (history.length < 5) {
+                return err(new Error('Insufficient history for pattern analysis (minimum 5 runs)'));
+            }
+            // Analyze patterns
+            const analysis = this.performPatternAnalysis(testId, history);
+            // Cache result
+            this.analysisCache.set(testId, analysis);
+            await this.memory.set(`flaky-analysis:${testId}`, analysis, {
+                namespace: 'test-execution',
+                ttl: 3600000, // 1 hour
+            });
+            return ok(analysis);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Suggest fixes for a flaky test
+     */
+    async suggestFix(testId) {
+        try {
+            const analysisResult = await this.analyzePattern(testId);
+            if (!analysisResult.success) {
+                return err(analysisResult.error);
+            }
+            const analysis = analysisResult.value;
+            const recommendations = this.generateRecommendations(analysis);
+            const suggestion = {
+                testId,
+                pattern: analysis.pattern,
+                recommendations,
+                priority: this.determinePriority(analysis),
+            };
+            return ok(suggestion);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Record a test execution for future analysis
+     */
+    async recordExecution(testId, result) {
+        // Add to in-memory history
+        const history = this.testHistory.get(testId) ?? [];
+        history.push(result);
+        // Keep only last 100 executions
+        if (history.length > 100) {
+            history.shift();
+        }
+        this.testHistory.set(testId, history);
+        // Persist to storage
+        await this.memory.set(`test-history:${testId}`, history, {
+            namespace: 'test-execution',
+            persist: true,
+        });
+        // Invalidate analysis cache
+        this.analysisCache.delete(testId);
+    }
+    /**
+     * Calculate flakiness score (0-1, where 1 is most flaky)
+     */
+    async getFlakinessScore(testId) {
+        const history = await this.getTestHistory(testId);
+        if (history.length < 2) {
+            return 0;
+        }
+        // Count state changes
+        let stateChanges = 0;
+        for (let i = 1; i < history.length; i++) {
+            if (history[i].passed !== history[i - 1].passed) {
+                stateChanges++;
+            }
+        }
+        // Calculate score based on state change frequency
+        const changeRate = stateChanges / (history.length - 1);
+        // Factor in failure rate
+        const failures = history.filter(h => !h.passed).length;
+        const failureRate = failures / history.length;
+        // Flakiness is high when there are many state changes and intermediate failure rate
+        // Pure passes (failureRate = 0) or pure failures (failureRate = 1) are not flaky
+        const flakinessFactor = Math.min(failureRate, 1 - failureRate) * 2;
+        return Math.min(1, changeRate * 0.6 + flakinessFactor * 0.4);
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    async runMultipleTimes(file, runs) {
+        // In simulation mode (for unit testing), use random behavior
+        if (this.config.simulateForTesting) {
+            return this.simulateMultipleRuns(runs);
+        }
+        // In production mode, ACTUALLY execute the test file multiple times
+        // Verify the test file exists
+        const resolvedPath = this.config.cwd
+            ? path.resolve(this.config.cwd, file)
+            : path.resolve(file);
+        if (!fs.existsSync(resolvedPath)) {
+            throw new Error(`Test file not found: ${resolvedPath}. Cannot perform flaky detection without a valid test file.`);
+        }
+        // Execute the test file N times and collect results
+        const allResults = new Map();
+        for (let runIndex = 0; runIndex < runs; runIndex++) {
+            const runResult = await this.executeTestFile(file, runIndex);
+            // Merge results from this run into allResults
+            for (const [testId, records] of runResult.entries()) {
+                const existing = allResults.get(testId) ?? [];
+                existing.push(...records);
+                allResults.set(testId, existing);
+            }
+        }
+        // If we got no results after N runs, that means the test runner failed
+        if (allResults.size === 0) {
+            throw new Error(`Test execution produced no results for ${file}. ` +
+                `Ensure the test runner (${this.config.testRunner}) is properly configured ` +
+                `and the test file contains valid tests.`);
+        }
+        // Record all executions for future reference
+        for (const [testId, records] of allResults.entries()) {
+            for (const record of records) {
+                await this.recordExecution(testId, record);
+            }
+        }
+        return allResults;
+    }
+    /**
+     * Execute a single test file and parse the results
+     */
+    async executeTestFile(file, runIndex) {
+        const results = new Map();
+        const runId = uuidv4();
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const args = [...this.config.testRunnerArgs, file];
+            const cwd = this.config.cwd ?? process.cwd();
+            const child = spawn(this.config.testRunner, args, {
+                cwd,
+                env: { ...process.env, ...this.config.env },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            // Set timeout
+            const timeout = setTimeout(() => {
+                child.kill('SIGTERM');
+                reject(new Error(`Test execution timed out after ${this.config.runTimeout}ms for ${file}`));
+            }, this.config.runTimeout);
+            child.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(new Error(`Failed to execute test runner: ${error.message}. ` +
+                    `Ensure ${this.config.testRunner} is installed and accessible.`));
+            });
+            child.on('close', (code) => {
+                clearTimeout(timeout);
+                const duration = Date.now() - startTime;
+                try {
+                    // Parse the test results from stdout
+                    const parsedResults = this.parseTestOutput(stdout, stderr, code ?? 0, file, runId, runIndex, duration);
+                    // If parsing fails but we have an exit code, create a single result for the file
+                    if (parsedResults.size === 0) {
+                        const testId = this.generateTestId(file, 'main');
+                        results.set(testId, [
+                            {
+                                runId,
+                                passed: code === 0,
+                                duration,
+                                error: code !== 0 ? stderr || `Exit code: ${code}` : undefined,
+                                timestamp: new Date(),
+                                context: {
+                                    parallelRuns: 1,
+                                    workerIndex: runIndex,
+                                },
+                            },
+                        ]);
+                    }
+                    else {
+                        for (const [testId, records] of parsedResults.entries()) {
+                            results.set(testId, records);
+                        }
+                    }
+                    resolve(results);
+                }
+                catch (parseError) {
+                    // If we can't parse output but process completed, create result from exit code
+                    const testId = this.generateTestId(file, 'main');
+                    results.set(testId, [
+                        {
+                            runId,
+                            passed: code === 0,
+                            duration,
+                            error: code !== 0
+                                ? stderr || `Exit code: ${code}, Parse error: ${parseError}`
+                                : undefined,
+                            timestamp: new Date(),
+                            context: {
+                                parallelRuns: 1,
+                                workerIndex: runIndex,
+                            },
+                        },
+                    ]);
+                    resolve(results);
+                }
+            });
+        });
+    }
+    /**
+     * Parse test runner output to extract individual test results
+     */
+    parseTestOutput(stdout, stderr, exitCode, file, runId, runIndex, totalDuration) {
+        const results = new Map();
+        // Try to parse as JSON (vitest with --reporter=json)
+        try {
+            const jsonOutput = this.extractJson(stdout);
+            if (jsonOutput) {
+                const parsed = JSON.parse(jsonOutput);
+                return this.parseVitestJson(parsed, file, runId, runIndex);
+            }
+        }
+        catch {
+            // Not valid JSON, try other formats
+        }
+        // Try to parse Jest JSON output
+        try {
+            const jsonOutput = this.extractJson(stdout);
+            if (jsonOutput) {
+                const parsed = JSON.parse(jsonOutput);
+                if (parsed.testResults) {
+                    return this.parseJestJson(parsed, file, runId, runIndex);
+                }
+            }
+        }
+        catch {
+            // Not Jest format
+        }
+        // Try to parse TAP format
+        if (stdout.includes('TAP version') || stdout.match(/^(ok|not ok)\s+\d+/m)) {
+            return this.parseTapOutput(stdout, file, runId, runIndex);
+        }
+        // Try to parse Mocha-style output
+        const mochaResults = this.parseMochaOutput(stdout, stderr, exitCode, file, runId, runIndex, totalDuration);
+        if (mochaResults.size > 0) {
+            return mochaResults;
+        }
+        // Fallback: create a single result based on exit code
+        return results;
+    }
+    /**
+     * Extract JSON from mixed output
+     */
+    extractJson(output) {
+        // Try to find JSON object or array
+        const jsonStart = output.indexOf('{');
+        const jsonArrayStart = output.indexOf('[');
+        const start = jsonStart === -1
+            ? jsonArrayStart
+            : jsonArrayStart === -1
+                ? jsonStart
+                : Math.min(jsonStart, jsonArrayStart);
+        if (start === -1)
+            return null;
+        let depth = 0;
+        let inString = false;
+        let escape = false;
+        for (let i = start; i < output.length; i++) {
+            const char = output[i];
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (char === '\\') {
+                escape = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                continue;
+            }
+            if (inString)
+                continue;
+            if (char === '{' || char === '[')
+                depth++;
+            if (char === '}' || char === ']')
+                depth--;
+            if (depth === 0) {
+                return output.substring(start, i + 1);
+            }
+        }
+        return null;
+    }
+    /**
+     * Parse Vitest JSON output
+     */
+    parseVitestJson(json, file, runId, runIndex) {
+        const results = new Map();
+        if (!json.testResults)
+            return results;
+        for (const suite of json.testResults) {
+            for (const test of suite.assertionResults || []) {
+                const testId = this.generateTestId(file, test.fullName || test.title);
+                const record = {
+                    runId,
+                    passed: test.status === 'passed',
+                    duration: test.duration || 0,
+                    error: test.status === 'failed'
+                        ? test.failureMessages?.join('\n')
+                        : undefined,
+                    timestamp: new Date(),
+                    context: {
+                        parallelRuns: 1,
+                        workerIndex: runIndex,
+                    },
+                };
+                results.set(testId, [record]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Parse Jest JSON output
+     */
+    parseJestJson(json, file, runId, runIndex) {
+        const results = new Map();
+        for (const testResult of json.testResults || []) {
+            for (const assertion of testResult.assertionResults || []) {
+                const testId = this.generateTestId(file, assertion.fullName || assertion.title);
+                const record = {
+                    runId,
+                    passed: assertion.status === 'passed',
+                    duration: assertion.duration || 0,
+                    error: assertion.status === 'failed'
+                        ? assertion.failureMessages?.join('\n')
+                        : undefined,
+                    timestamp: new Date(),
+                    context: {
+                        parallelRuns: 1,
+                        workerIndex: runIndex,
+                    },
+                };
+                results.set(testId, [record]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Parse TAP output format
+     */
+    parseTapOutput(output, file, runId, runIndex) {
+        const results = new Map();
+        const lines = output.split('\n');
+        for (const line of lines) {
+            const match = line.match(/^(ok|not ok)\s+(\d+)\s*-?\s*(.*)/);
+            if (match) {
+                const [, status, , testName] = match;
+                const testId = this.generateTestId(file, testName || `test-${match[2]}`);
+                const record = {
+                    runId,
+                    passed: status === 'ok',
+                    duration: 0,
+                    error: status !== 'ok' ? `Test failed: ${testName}` : undefined,
+                    timestamp: new Date(),
+                    context: {
+                        parallelRuns: 1,
+                        workerIndex: runIndex,
+                    },
+                };
+                results.set(testId, [record]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Parse Mocha-style console output
+     */
+    parseMochaOutput(stdout, stderr, exitCode, file, runId, runIndex, duration) {
+        const results = new Map();
+        // Look for passing/failing indicators
+        const passMatch = stdout.match(/(\d+)\s+passing/);
+        const failMatch = stdout.match(/(\d+)\s+failing/);
+        if (passMatch || failMatch) {
+            const passing = passMatch ? parseInt(passMatch[1], 10) : 0;
+            const failing = failMatch ? parseInt(failMatch[1], 10) : 0;
+            // Create aggregate results
+            for (let i = 0; i < passing; i++) {
+                const testId = this.generateTestId(file, `passing-${i + 1}`);
+                results.set(testId, [
+                    {
+                        runId,
+                        passed: true,
+                        duration: duration / (passing + failing),
+                        timestamp: new Date(),
+                        context: { parallelRuns: 1, workerIndex: runIndex },
+                    },
+                ]);
+            }
+            for (let i = 0; i < failing; i++) {
+                const testId = this.generateTestId(file, `failing-${i + 1}`);
+                results.set(testId, [
+                    {
+                        runId,
+                        passed: false,
+                        duration: duration / (passing + failing),
+                        error: stderr || 'Test failed',
+                        timestamp: new Date(),
+                        context: { parallelRuns: 1, workerIndex: runIndex },
+                    },
+                ]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Generate a deterministic test ID from file and test name
+     */
+    generateTestId(file, testName) {
+        const sanitizedFile = file.replace(/[^a-zA-Z0-9]/g, '-');
+        const sanitizedName = testName.replace(/[^a-zA-Z0-9]/g, '-');
+        return `${sanitizedFile}::${sanitizedName}`;
+    }
+    /**
+     * Get recorded execution history for tests in a file
+     */
+    async getHistoryForFile(file) {
+        const results = new Map();
+        // Check for any test IDs associated with this file in memory
+        for (const [testId, history] of this.testHistory.entries()) {
+            // Simple file association check (in real implementation, would use proper mapping)
+            if (testId.includes(file.replace(/[^a-zA-Z0-9]/g, '-'))) {
+                results.set(testId, history);
+            }
+        }
+        return results;
+    }
+    /**
+     * Simulate multiple test runs with random outcomes (for unit testing only)
+     */
+    simulateMultipleRuns(runs) {
+        const results = new Map();
+        const testCount = this.config.simulatedTestsPerFile;
+        const testIds = Array.from({ length: testCount }, () => `test-${uuidv4().slice(0, 8)}`);
+        for (const testId of testIds) {
+            const records = [];
+            // Determine if this test is flaky
+            const isFlaky = Math.random() < this.config.simulatedFlakinessRate;
+            for (let i = 0; i < runs; i++) {
+                // If flaky, randomly pass/fail; otherwise always pass
+                const passed = isFlaky
+                    ? Math.random() < this.config.simulatedFlakyPassRate
+                    : true;
+                records.push({
+                    runId: uuidv4(),
+                    passed,
+                    duration: Math.random() * 1000 + 100,
+                    error: passed ? undefined : 'Assertion failed',
+                    timestamp: new Date(),
+                    context: { parallelRuns: runs },
+                });
+            }
+            results.set(testId, records);
+        }
+        return results;
+    }
+    identifyFlakyTests(results, threshold) {
+        const flakyTests = [];
+        for (const [testId, records] of results) {
+            const failures = records.filter(r => !r.passed).length;
+            const failureRate = failures / records.length;
+            // Test is flaky if it has inconsistent results above threshold
+            if (failureRate > 0 && failureRate < 1 && failureRate >= threshold) {
+                const pattern = this.detectPattern(records);
+                flakyTests.push({
+                    testId,
+                    testName: testId,
+                    file: 'unknown',
+                    failureRate,
+                    pattern,
+                    recommendation: this.getQuickRecommendation(pattern),
+                });
+            }
+        }
+        return flakyTests;
+    }
+    detectPattern(records) {
+        // Analyze records to determine the flakiness pattern
+        // Check for timing issues
+        const failedRecords = records.filter(r => !r.passed);
+        const passedRecords = records.filter(r => r.passed);
+        if (failedRecords.length > 0 && passedRecords.length > 0) {
+            const avgFailedDuration = this.average(failedRecords.map(r => r.duration));
+            const avgPassedDuration = this.average(passedRecords.map(r => r.duration));
+            if (Math.abs(avgFailedDuration - avgPassedDuration) / avgPassedDuration > 0.5) {
+                return 'timing';
+            }
+        }
+        // Check for async issues (errors mentioning timeout, promise, async)
+        const asyncKeywords = ['timeout', 'promise', 'async', 'await', 'callback'];
+        const hasAsyncErrors = failedRecords.some(r => r.error && asyncKeywords.some(k => r.error.toLowerCase().includes(k)));
+        if (hasAsyncErrors) {
+            return 'async';
+        }
+        // Check for resource issues
+        const resourceKeywords = ['connection', 'database', 'network', 'port', 'file'];
+        const hasResourceErrors = failedRecords.some(r => r.error && resourceKeywords.some(k => r.error.toLowerCase().includes(k)));
+        if (hasResourceErrors) {
+            return 'resource';
+        }
+        // Check for ordering issues (failures correlate with preceding tests)
+        const hasOrderingPattern = failedRecords.some(r => r.context?.precedingTests && r.context.precedingTests.length > 0);
+        if (hasOrderingPattern) {
+            return 'ordering';
+        }
+        return 'unknown';
+    }
+    getQuickRecommendation(pattern) {
+        switch (pattern) {
+            case 'timing':
+                return 'Increase timeouts or use explicit waits instead of fixed delays';
+            case 'ordering':
+                return 'Ensure test isolation and independent setup/teardown';
+            case 'resource':
+                return 'Mock external dependencies or use connection pooling';
+            case 'async':
+                return 'Properly await async operations and handle promise rejections';
+            case 'unknown':
+                return 'Review test for potential race conditions or external dependencies';
+        }
+    }
+    async getTestHistory(testId) {
+        // Check in-memory first
+        const cached = this.testHistory.get(testId);
+        if (cached && cached.length > 0) {
+            return cached;
+        }
+        // Load from storage
+        const stored = await this.memory.get(`test-history:${testId}`);
+        if (stored) {
+            this.testHistory.set(testId, stored);
+            return stored;
+        }
+        return [];
+    }
+    performPatternAnalysis(testId, history) {
+        const pattern = this.detectPattern(history);
+        const factors = this.identifyFactors(history, pattern);
+        const correlations = this.calculateCorrelations(history);
+        const confidence = this.calculateConfidence(history, pattern);
+        return {
+            testId,
+            pattern,
+            confidence,
+            factors,
+            correlations,
+        };
+    }
+    identifyFactors(history, pattern) {
+        const factors = [];
+        switch (pattern) {
+            case 'timing':
+                factors.push('Variable execution duration');
+                factors.push('Possible race conditions');
+                if (this.hasDurationSpikes(history)) {
+                    factors.push('Duration spikes before failures');
+                }
+                break;
+            case 'async':
+                factors.push('Unhandled async operations');
+                factors.push('Missing await statements');
+                break;
+            case 'resource':
+                factors.push('External dependency instability');
+                factors.push('Shared resource contention');
+                break;
+            case 'ordering':
+                factors.push('Shared state between tests');
+                factors.push('Incomplete cleanup');
+                break;
+            case 'unknown':
+                factors.push('No clear pattern identified');
+                factors.push('Manual investigation recommended');
+                break;
+        }
+        return factors;
+    }
+    calculateCorrelations(history) {
+        const correlations = [];
+        // Duration correlation
+        const durationCorr = this.correlateWithFailure(history, r => r.duration);
+        if (Math.abs(durationCorr) > 0.3) {
+            correlations.push({
+                factor: 'duration',
+                correlation: durationCorr,
+                description: durationCorr > 0
+                    ? 'Failures correlate with longer duration'
+                    : 'Failures correlate with shorter duration',
+            });
+        }
+        // Time of day correlation
+        const hourCorr = this.correlateWithFailure(history, r => new Date(r.timestamp).getHours());
+        if (Math.abs(hourCorr) > 0.3) {
+            correlations.push({
+                factor: 'time_of_day',
+                correlation: hourCorr,
+                description: 'Failures correlate with specific times',
+            });
+        }
+        // Parallel execution correlation
+        const parallelCorr = this.correlateWithFailure(history, r => r.context?.parallelRuns ?? 1);
+        if (Math.abs(parallelCorr) > 0.3) {
+            correlations.push({
+                factor: 'parallelism',
+                correlation: parallelCorr,
+                description: 'Failures correlate with parallel execution',
+            });
+        }
+        return correlations;
+    }
+    correlateWithFailure(history, getValue) {
+        if (history.length < 2)
+            return 0;
+        const values = history.map(getValue);
+        const failures = history.map(r => r.passed ? 0 : 1);
+        return this.pearsonCorrelation(values, failures);
+    }
+    pearsonCorrelation(x, y) {
+        const n = x.length;
+        if (n === 0)
+            return 0;
+        const sumX = x.reduce((a, b) => a + b, 0);
+        const sumY = y.reduce((a, b) => a + b, 0);
+        const sumXY = x.reduce((a, xi, i) => a + xi * y[i], 0);
+        const sumX2 = x.reduce((a, xi) => a + xi * xi, 0);
+        const sumY2 = y.reduce((a, yi) => a + yi * yi, 0);
+        const numerator = n * sumXY - sumX * sumY;
+        const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+        return denominator === 0 ? 0 : numerator / denominator;
+    }
+    calculateConfidence(history, pattern) {
+        // Base confidence on sample size
+        const sampleConfidence = Math.min(1, history.length / 20);
+        // Pattern-specific confidence
+        let patternConfidence = 0.5;
+        if (pattern !== 'unknown') {
+            patternConfidence = 0.8;
+        }
+        // Consistency of pattern
+        const failureRate = history.filter(h => !h.passed).length / history.length;
+        const consistencyFactor = Math.min(failureRate, 1 - failureRate) * 2;
+        return sampleConfidence * 0.4 + patternConfidence * 0.4 + consistencyFactor * 0.2;
+    }
+    generateRecommendations(analysis) {
+        const recommendations = [];
+        switch (analysis.pattern) {
+            case 'timing':
+                recommendations.push({
+                    action: 'Use explicit waits',
+                    description: 'Replace fixed delays with condition-based waits',
+                    codeSnippet: `await waitFor(() => expect(element).toBeVisible());`,
+                    effort: 'low',
+                });
+                recommendations.push({
+                    action: 'Increase timeout margins',
+                    description: 'Add buffer time for slow environments',
+                    codeSnippet: `jest.setTimeout(10000);`,
+                    effort: 'low',
+                });
+                break;
+            case 'async':
+                recommendations.push({
+                    action: 'Ensure proper async handling',
+                    description: 'Await all promises and use async/await consistently',
+                    codeSnippet: `const result = await asyncOperation();\nexpect(result).toBeDefined();`,
+                    effort: 'medium',
+                });
+                recommendations.push({
+                    action: 'Add error boundaries',
+                    description: 'Catch and handle promise rejections',
+                    codeSnippet: `try {\n  await operation();\n} catch (e) {\n  console.error('Operation failed:', e);\n  throw e;\n}`,
+                    effort: 'medium',
+                });
+                break;
+            case 'resource':
+                recommendations.push({
+                    action: 'Mock external dependencies',
+                    description: 'Use mocks for external services in unit tests',
+                    codeSnippet: `jest.mock('./externalService');`,
+                    effort: 'medium',
+                });
+                recommendations.push({
+                    action: 'Implement retry logic',
+                    description: 'Add retries for transient failures',
+                    codeSnippet: `const result = await retry(() => fetchData(), { retries: 3 });`,
+                    effort: 'low',
+                });
+                break;
+            case 'ordering':
+                recommendations.push({
+                    action: 'Isolate test state',
+                    description: 'Reset shared state in beforeEach/afterEach',
+                    codeSnippet: `beforeEach(() => {\n  resetDatabase();\n  clearCache();\n});`,
+                    effort: 'medium',
+                });
+                recommendations.push({
+                    action: 'Remove inter-test dependencies',
+                    description: 'Each test should set up its own required state',
+                    effort: 'high',
+                });
+                break;
+            case 'unknown':
+                recommendations.push({
+                    action: 'Add detailed logging',
+                    description: 'Log test state at key points to identify patterns',
+                    effort: 'low',
+                });
+                recommendations.push({
+                    action: 'Run in isolation',
+                    description: 'Execute test alone to determine if it is a test interaction issue',
+                    effort: 'low',
+                });
+                break;
+        }
+        return recommendations;
+    }
+    determinePriority(analysis) {
+        if (analysis.confidence > 0.8 && analysis.pattern !== 'unknown') {
+            return 'high';
+        }
+        if (analysis.confidence > 0.5) {
+            return 'medium';
+        }
+        return 'low';
+    }
+    hasDurationSpikes(history) {
+        const durations = history.map(r => r.duration);
+        const avg = this.average(durations);
+        const stdDev = this.standardDeviation(durations);
+        return durations.some(d => d > avg + 2 * stdDev);
+    }
+    average(values) {
+        return values.length === 0 ? 0 : values.reduce((a, b) => a + b, 0) / values.length;
+    }
+    standardDeviation(values) {
+        const avg = this.average(values);
+        const squareDiffs = values.map(v => (v - avg) ** 2);
+        return Math.sqrt(this.average(squareDiffs));
+    }
+    async storeReport(report) {
+        const reportId = uuidv4();
+        await this.memory.set(`flaky-report:${reportId}`, report, {
+            namespace: 'test-execution',
+            persist: true,
+        });
+    }
+}
+//# sourceMappingURL=flaky-detector.js.map