cbrowser 6.1.0 → 6.3.0

package/dist/browser.js

@@ -21,6 +21,12 @@ exports.parseNLTestSuite = parseNLTestSuite;
 exports.runNLTestSuite = runNLTestSuite;
 exports.formatNLTestReport = formatNLTestReport;
 exports.runNLTestFile = runNLTestFile;
+exports.repairTest = repairTest;
+exports.repairTestSuite = repairTestSuite;
+exports.formatRepairReport = formatRepairReport;
+exports.exportRepairedTest = exportRepairedTest;
+exports.detectFlakyTests = detectFlakyTests;
+exports.formatFlakyTestReport = formatFlakyTestReport;
 const playwright_1 = require("playwright");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -3297,4 +3303,842 @@ async function runNLTestFile(filepath, options = {}) {
     const suite = parseNLTestSuite(content, suiteName);
     return runNLTestSuite(suite, options);
 }
+// =========================================================================
+// AI Test Repair (v6.2.0)
+// =========================================================================
+/**
+ * Classify the type of failure from an error message.
+ */
+function classifyFailure(error, step) {
+    const lowerError = error.toLowerCase();
+    if (lowerError.includes("not found") || lowerError.includes("no element") || lowerError.includes("failed to click")) {
+        return "selector_not_found";
+    }
+    if (lowerError.includes("assertion") || lowerError.includes("verify") || lowerError.includes("expected")) {
+        return "assertion_failed";
+    }
+    if (lowerError.includes("timeout") || lowerError.includes("timed out")) {
+        return "timeout";
+    }
+    if (lowerError.includes("navigation") || lowerError.includes("navigate") || lowerError.includes("url")) {
+        return "navigation_failed";
+    }
+    if (lowerError.includes("not interactable") || lowerError.includes("disabled") || lowerError.includes("hidden")) {
+        return "element_not_interactable";
+    }
+    return "unknown";
+}
+/**
+ * Find alternative selectors for a target on the current page.
+ */
+async function findAlternatives(browser, originalTarget) {
+    const page = browser.page;
+    if (!page)
+        return [];
+    try {
+        const alternatives = await page.evaluate((target) => {
+            const results = [];
+            const lowerTarget = target.toLowerCase();
+            // Find buttons with similar text
+            document.querySelectorAll("button, [role='button'], input[type='submit'], input[type='button']").forEach((el) => {
+                const text = el.textContent?.trim() || el.value || "";
+                if (text && (text.toLowerCase().includes(lowerTarget) || lowerTarget.includes(text.toLowerCase()))) {
+                    results.push(`button: "${text}"`);
+                }
+            });
+            // Find links with similar text
+            document.querySelectorAll("a").forEach((el) => {
+                const text = el.textContent?.trim() || "";
+                if (text && (text.toLowerCase().includes(lowerTarget) || lowerTarget.includes(text.toLowerCase()))) {
+                    results.push(`link: "${text}"`);
+                }
+            });
+            // Find inputs with similar labels/placeholders
+            document.querySelectorAll("input, textarea, select").forEach((el) => {
+                const input = el;
+                const placeholder = input.placeholder || "";
+                const label = document.querySelector(`label[for="${input.id}"]`)?.textContent?.trim() || "";
+                const name = input.name || "";
+                if (placeholder.toLowerCase().includes(lowerTarget) || lowerTarget.includes(placeholder.toLowerCase())) {
+                    results.push(`input with placeholder "${placeholder}"`);
+                }
+                if (label.toLowerCase().includes(lowerTarget) || lowerTarget.includes(label.toLowerCase())) {
+                    results.push(`input labeled "${label}"`);
+                }
+                if (name.toLowerCase().includes(lowerTarget)) {
+                    results.push(`input named "${name}"`);
+                }
+            });
+            // Find elements by aria-label
+            document.querySelectorAll("[aria-label]").forEach((el) => {
+                const label = el.getAttribute("aria-label") || "";
+                if (label.toLowerCase().includes(lowerTarget) || lowerTarget.includes(label.toLowerCase())) {
+                    results.push(`aria:${el.tagName.toLowerCase()}/"${label}"`);
+                }
+            });
+            return [...new Set(results)].slice(0, 10);
+        }, originalTarget);
+        return alternatives;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get page context for failure analysis.
+ */
+async function getPageContext(browser) {
+    const page = browser.page;
+    if (!page)
+        return { url: "", title: "", visibleText: [] };
+    try {
+        const context = await page.evaluate(() => {
+            const visibleText = [];
+            // Get visible button/link text
+            document.querySelectorAll("button, a, [role='button']").forEach((el) => {
+                const text = el.textContent?.trim();
+                if (text && text.length < 50) {
+                    visibleText.push(text);
+                }
+            });
+            return {
+                url: window.location.href,
+                title: document.title,
+                visibleText: [...new Set(visibleText)].slice(0, 20),
+            };
+        });
+        return context;
+    }
+    catch {
+        return { url: "", title: "", visibleText: [] };
+    }
+}
+/**
+ * Generate repair suggestions for a failed step.
+ */
+async function generateRepairSuggestions(browser, step, error, failureType, alternatives, pageContext) {
+    const suggestions = [];
+    switch (failureType) {
+        case "selector_not_found": {
+            // Suggest alternative selectors
+            for (const alt of alternatives.slice(0, 3)) {
+                const newInstruction = step.instruction.replace(step.target || "", alt.replace(/^(button|link|input|aria):\s*/, "").replace(/"/g, "'"));
+                suggestions.push({
+                    type: "selector_update",
+                    confidence: 0.7,
+                    description: `Update selector to "${alt}"`,
+                    originalInstruction: step.instruction,
+                    suggestedInstruction: `click ${alt.replace(/^(button|link|input|aria):\s*/, "")}`,
+                    reasoning: `Found similar element on page: ${alt}`,
+                });
+            }
+            // Suggest adding a wait
+            if (suggestions.length === 0) {
+                suggestions.push({
+                    type: "add_wait",
+                    confidence: 0.5,
+                    description: "Add wait before this step",
+                    originalInstruction: step.instruction,
+                    suggestedInstruction: `wait 2 seconds\n${step.instruction}`,
+                    reasoning: "Element might not be loaded yet - adding wait may help",
+                });
+            }
+            break;
+        }
+        case "assertion_failed": {
+            // Suggest updating the assertion based on page content
+            if (step.action === "assert" && pageContext.visibleText.length > 0) {
+                const possibleText = pageContext.visibleText.find((t) => t.length > 3 && t.length < 30);
+                if (possibleText) {
+                    suggestions.push({
+                        type: "assertion_update",
+                        confidence: 0.6,
+                        description: `Update assertion to check for visible text`,
+                        originalInstruction: step.instruction,
+                        suggestedInstruction: `verify page contains "${possibleText}"`,
+                        reasoning: `Page contains "${possibleText}" which might be the intended check`,
+                    });
+                }
+            }
+            // Suggest checking URL instead
+            if (pageContext.url) {
+                const urlPath = new URL(pageContext.url).pathname;
+                suggestions.push({
+                    type: "assertion_update",
+                    confidence: 0.5,
+                    description: "Assert URL instead of content",
+                    originalInstruction: step.instruction,
+                    suggestedInstruction: `verify url contains "${urlPath}"`,
+                    reasoning: `Current URL is ${pageContext.url}`,
+                });
+            }
+            break;
+        }
+        case "timeout": {
+            suggestions.push({
+                type: "add_wait",
+                confidence: 0.7,
+                description: "Increase wait time",
+                originalInstruction: step.instruction,
+                suggestedInstruction: `wait 5 seconds\n${step.instruction}`,
+                reasoning: "Operation timed out - page may need more time to load",
+            });
+            break;
+        }
+        case "element_not_interactable": {
+            suggestions.push({
+                type: "add_wait",
+                confidence: 0.6,
+                description: "Wait for element to become interactive",
+                originalInstruction: step.instruction,
+                suggestedInstruction: `wait 2 seconds\n${step.instruction}`,
+                reasoning: "Element exists but is not interactable - may need to wait",
+            });
+            // Suggest scrolling
+            suggestions.push({
+                type: "change_action",
+                confidence: 0.5,
+                description: "Scroll element into view first",
+                originalInstruction: step.instruction,
+                suggestedInstruction: `scroll down\n${step.instruction}`,
+                reasoning: "Element might be outside viewport",
+            });
+            break;
+        }
+        default: {
+            // Generic suggestion to skip
+            suggestions.push({
+                type: "skip_step",
+                confidence: 0.3,
+                description: "Skip this step",
+                originalInstruction: step.instruction,
+                suggestedInstruction: `// SKIPPED: ${step.instruction}`,
+                reasoning: "Unable to determine a fix - consider removing this step",
+            });
+        }
+    }
+    // Sort by confidence
+    return suggestions.sort((a, b) => b.confidence - a.confidence);
+}
+/**
+ * Analyze a failed test step and suggest repairs.
+ */
+async function analyzeFailure(browser, step, error) {
+    const failureType = classifyFailure(error, step);
+    const alternatives = step.target ? await findAlternatives(browser, step.target) : [];
+    const pageContext = await getPageContext(browser);
+    const suggestions = await generateRepairSuggestions(browser, step, error, failureType, alternatives, pageContext);
+    return {
+        step,
+        error,
+        failureType,
+        targetSelector: step.target,
+        alternativeSelectors: alternatives,
+        pageContext,
+        suggestions,
+    };
+}
+/**
+ * Run a test, analyze failures, and suggest/apply repairs.
+ */
+async function repairTest(test, options = {}) {
+    const { headless = true, autoApply = false, verifyRepairs = true, maxRetries = 3, } = options;
+    const browser = new CBrowser({ headless });
+    const failureAnalyses = [];
+    const repairedSteps = [];
+    let failedSteps = 0;
+    console.log(`\n🔧 Analyzing test: ${test.name}`);
+    console.log(`   Steps: ${test.steps.length}`);
+    console.log(`   Auto-apply: ${autoApply}`);
+    console.log("");
+    try {
+        await browser.launch();
+        for (const step of test.steps) {
+            console.log(`   → ${step.instruction}`);
+            let stepPassed = false;
+            let lastError = "";
+            let attempts = 0;
+            while (!stepPassed && attempts < maxRetries) {
+                attempts++;
+                try {
+                    // Execute the step
+                    switch (step.action) {
+                        case "navigate":
+                            await browser.navigate(step.target || "");
+                            stepPassed = true;
+                            break;
+                        case "click":
+                            const clickResult = await browser.smartClick(step.target || "");
+                            stepPassed = clickResult.success;
+                            if (!stepPassed)
+                                lastError = `Failed to click: ${step.target}`;
+                            break;
+                        case "fill":
+                            await browser.fill(step.target || "", step.value || "");
+                            stepPassed = true;
+                            break;
+                        case "assert":
+                            const assertResult = await browser.assert(step.instruction);
+                            stepPassed = assertResult.passed;
+                            if (!stepPassed)
+                                lastError = assertResult.message;
+                            break;
+                        case "wait":
+                            if (step.target) {
+                                const page = browser.page;
+                                if (page) {
+                                    await page.waitForSelector(`text=${step.target}`, { timeout: 10000 });
+                                }
+                            }
+                            else {
+                                const ms = parseFloat(step.value || "1") * 1000;
+                                await new Promise((r) => setTimeout(r, ms));
+                            }
+                            stepPassed = true;
+                            break;
+                        case "scroll":
+                            const direction = step.target?.toLowerCase() === "up" ? -500 : 500;
+                            const page = browser.page;
+                            if (page) {
+                                await page.evaluate((d) => window.scrollBy(0, d), direction);
+                            }
+                            stepPassed = true;
+                            break;
+                        case "screenshot":
+                            await browser.screenshot();
+                            stepPassed = true;
+                            break;
+                        default:
+                            // Try as click
+                            const unknownResult = await browser.smartClick(step.target || step.instruction);
+                            stepPassed = unknownResult.success;
+                            if (!stepPassed)
+                                lastError = `Could not interpret: ${step.instruction}`;
+                    }
+                }
+                catch (e) {
+                    lastError = e.message;
+                    stepPassed = false;
+                }
+                if (!stepPassed && attempts < maxRetries) {
+                    console.log(`     ⚠️ Attempt ${attempts} failed, retrying...`);
+                    await new Promise((r) => setTimeout(r, 500));
+                }
+            }
+            if (stepPassed) {
+                console.log(`     ✓ Passed`);
+                repairedSteps.push(step);
+            }
+            else {
+                console.log(`     ✗ Failed: ${lastError}`);
+                failedSteps++;
+                // Analyze the failure
+                const analysis = await analyzeFailure(browser, step, lastError);
+                failureAnalyses.push(analysis);
+                if (autoApply && analysis.suggestions.length > 0) {
+                    const bestSuggestion = analysis.suggestions[0];
+                    console.log(`     🔧 Auto-applying: ${bestSuggestion.description}`);
+                    // Parse the suggested instruction into a step
+                    const repairedStep = parseNLInstruction(bestSuggestion.suggestedInstruction.split("\n").pop() || "");
+                    repairedSteps.push(repairedStep);
+                }
+                else {
+                    // Keep original step
+                    repairedSteps.push(step);
+                    if (analysis.suggestions.length > 0) {
+                        console.log(`     💡 Suggestions:`);
+                        for (const suggestion of analysis.suggestions.slice(0, 2)) {
+                            console.log(`        - ${suggestion.description} (${Math.round(suggestion.confidence * 100)}%)`);
+                            console.log(`          → ${suggestion.suggestedInstruction}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Create repaired test
+        const repairedTest = {
+            name: test.name,
+            description: test.description,
+            steps: repairedSteps,
+        };
+        // Optionally verify the repaired test
+        let repairedTestPasses;
+        if (verifyRepairs && autoApply && failedSteps > 0) {
+            console.log(`\n   🔄 Verifying repaired test...`);
+            await browser.close();
+            const verifyBrowser = new CBrowser({ headless });
+            try {
+                await verifyBrowser.launch();
+                let allPassed = true;
+                for (const step of repairedSteps) {
+                    try {
+                        switch (step.action) {
+                            case "navigate":
+                                await verifyBrowser.navigate(step.target || "");
+                                break;
+                            case "click":
+                                const result = await verifyBrowser.smartClick(step.target || "");
+                                if (!result.success)
+                                    allPassed = false;
+                                break;
+                            case "fill":
+                                await verifyBrowser.fill(step.target || "", step.value || "");
+                                break;
+                            case "assert":
+                                const assertResult = await verifyBrowser.assert(step.instruction);
+                                if (!assertResult.passed)
+                                    allPassed = false;
+                                break;
+                            case "wait":
+                                if (!step.target) {
+                                    const ms = parseFloat(step.value || "1") * 1000;
+                                    await new Promise((r) => setTimeout(r, ms));
+                                }
+                                break;
+                        }
+                    }
+                    catch {
+                        allPassed = false;
+                    }
+                }
+                repairedTestPasses = allPassed;
+                console.log(`   ${allPassed ? "✅" : "❌"} Repaired test ${allPassed ? "PASSES" : "still FAILS"}`);
+            }
+            finally {
+                await verifyBrowser.close();
+            }
+        }
+        return {
+            originalTest: test,
+            repairedTest: failedSteps > 0 ? repairedTest : undefined,
+            failedSteps,
+            repairedSteps: autoApply ? failedSteps : 0,
+            failureAnalyses,
+            repairedTestPasses,
+        };
+    }
+    finally {
+        await browser.close();
+    }
+}
+/**
+ * Run test repair on a full suite.
+ */
+async function repairTestSuite(suite, options = {}) {
+    const startTime = Date.now();
+    const testResults = [];
+    console.log(`\n🔧 Repairing Test Suite: ${suite.name}`);
+    console.log(`   Tests: ${suite.tests.length}`);
+    console.log("");
+    for (const test of suite.tests) {
+        const result = await repairTest(test, options);
+        testResults.push(result);
+    }
+    const testsWithFailures = testResults.filter((r) => r.failedSteps > 0).length;
+    const testsRepaired = testResults.filter((r) => r.repairedSteps > 0).length;
+    const totalFailedSteps = testResults.reduce((sum, r) => sum + r.failedSteps, 0);
+    const totalRepairedSteps = testResults.reduce((sum, r) => sum + r.repairedSteps, 0);
+    return {
+        suiteName: suite.name,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime,
+        testResults,
+        summary: {
+            totalTests: suite.tests.length,
+            testsWithFailures,
+            testsRepaired,
+            totalFailedSteps,
+            totalRepairedSteps,
+            repairSuccessRate: totalFailedSteps > 0 ? (totalRepairedSteps / totalFailedSteps) * 100 : 100,
+        },
+    };
+}
+/**
+ * Format a repair result as a report.
+ */
+function formatRepairReport(result) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
+    lines.push("║                       AI TEST REPAIR REPORT                                  ║");
+    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    lines.push(`📋 Suite: ${result.suiteName}`);
+    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
+    lines.push(`📅 Timestamp: ${result.timestamp}`);
+    lines.push("");
+    // Summary
+    lines.push("📊 SUMMARY");
+    lines.push("─".repeat(60));
+    lines.push(`  Total Tests: ${result.summary.totalTests}`);
+    lines.push(`  Tests with Failures: ${result.summary.testsWithFailures}`);
+    lines.push(`  Tests Repaired: ${result.summary.testsRepaired}`);
+    lines.push(`  Total Failed Steps: ${result.summary.totalFailedSteps}`);
+    lines.push(`  Total Repaired Steps: ${result.summary.totalRepairedSteps}`);
+    lines.push(`  Repair Success Rate: ${result.summary.repairSuccessRate.toFixed(0)}%`);
+    lines.push("");
+    // Per-test details
+    for (const testResult of result.testResults) {
+        if (testResult.failedSteps === 0)
+            continue;
+        lines.push(`\n🔧 ${testResult.originalTest.name}`);
+        lines.push(`   Failed Steps: ${testResult.failedSteps}`);
+        lines.push(`   Repaired: ${testResult.repairedSteps}`);
+        for (const analysis of testResult.failureAnalyses) {
+            lines.push(`\n   ❌ ${analysis.step.instruction}`);
+            lines.push(`      Error: ${analysis.error}`);
+            lines.push(`      Type: ${analysis.failureType}`);
+            if (analysis.suggestions.length > 0) {
+                lines.push(`      💡 Suggestions:`);
+                for (const s of analysis.suggestions.slice(0, 2)) {
+                    lines.push(`         - ${s.description} (${Math.round(s.confidence * 100)}%)`);
+                    lines.push(`           → ${s.suggestedInstruction}`);
+                }
+            }
+        }
+        if (testResult.repairedTestPasses !== undefined) {
+            lines.push(`\n   ${testResult.repairedTestPasses ? "✅" : "❌"} Repaired test ${testResult.repairedTestPasses ? "PASSES" : "still FAILS"}`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Export repaired test to file.
+ */
+function exportRepairedTest(result) {
+    if (!result.repairedTest) {
+        return `# Test: ${result.originalTest.name}\n# No repairs needed\n${result.originalTest.steps.map((s) => s.instruction).join("\n")}`;
+    }
+    const lines = [];
+    lines.push(`# Test: ${result.repairedTest.name} (Repaired)`);
+    lines.push(`# Original failures: ${result.failedSteps}`);
+    lines.push(`# Repairs applied: ${result.repairedSteps}`);
+    lines.push("");
+    for (const step of result.repairedTest.steps) {
+        lines.push(step.instruction);
+    }
+    return lines.join("\n");
+}
+/**
+ * Calculate flakiness score.
+ * 0 = completely stable (all same result)
+ * 100 = maximally flaky (50% pass, 50% fail)
+ */
+function calculateFlakinessScore(passCount, failCount) {
+    const total = passCount + failCount;
+    if (total === 0)
+        return 0;
+    const passRate = passCount / total;
+    // Flakiness is maximized at 50% pass rate
+    // Score = 1 - |passRate - 0.5| * 2, scaled to 0-100
+    const flakiness = (1 - Math.abs(passRate - 0.5) * 2) * 100;
+    return Math.round(flakiness);
+}
+/**
+ * Classify a test based on its results.
+ */
+function classifyTest(passCount, failCount) {
+    const total = passCount + failCount;
+    if (total === 0)
+        return "stable_pass";
+    const passRate = passCount / total;
+    if (passRate === 1)
+        return "stable_pass";
+    if (passRate === 0)
+        return "stable_fail";
+    if (passRate >= 0.8)
+        return "mostly_pass";
+    if (passRate <= 0.2)
+        return "mostly_fail";
+    return "flaky";
+}
+/**
+ * Run a single test once and return the result.
+ */
+async function runTestOnce(test, runNumber, headless) {
+    const browser = new CBrowser({ headless });
+    const stepResults = [];
+    let testPassed = true;
+    let testError;
+    const startTime = Date.now();
+    try {
+        await browser.launch();
+        for (const step of test.steps) {
+            let stepPassed = true;
+            let stepError;
+            try {
+                switch (step.action) {
+                    case "navigate":
+                        await browser.navigate(step.target || "");
+                        break;
+                    case "click":
+                        const clickResult = await browser.smartClick(step.target || "");
+                        if (!clickResult.success) {
+                            stepPassed = false;
+                            stepError = `Failed to click: ${step.target}`;
+                        }
+                        break;
+                    case "fill":
+                        await browser.fill(step.target || "", step.value || "");
+                        break;
+                    case "assert":
+                        const assertResult = await browser.assert(step.instruction);
+                        stepPassed = assertResult.passed;
+                        if (!assertResult.passed) {
+                            stepError = assertResult.message;
+                        }
+                        break;
+                    case "wait":
+                        if (!step.target) {
+                            const ms = parseFloat(step.value || "1") * 1000;
+                            await new Promise((r) => setTimeout(r, ms));
+                        }
+                        else {
+                            const page = browser.page;
+                            if (page) {
+                                await page.waitForSelector(`text=${step.target}`, { timeout: 10000 });
+                            }
+                        }
+                        break;
+                    case "scroll":
+                        const direction = step.target?.toLowerCase() === "up" ? -500 : 500;
+                        const page = browser.page;
+                        if (page) {
+                            await page.evaluate((d) => window.scrollBy(0, d), direction);
+                        }
+                        break;
+                    case "screenshot":
+                        await browser.screenshot();
+                        break;
+                    default:
+                        const unknownResult = await browser.smartClick(step.target || step.instruction);
+                        if (!unknownResult.success) {
+                            stepPassed = false;
+                            stepError = `Could not interpret: ${step.instruction}`;
+                        }
+                }
+            }
+            catch (e) {
+                stepPassed = false;
+                stepError = e.message;
+            }
+            stepResults.push({
+                instruction: step.instruction,
+                passed: stepPassed,
+                error: stepError,
+            });
+            if (!stepPassed) {
+                testPassed = false;
+                testError = testError || stepError;
+            }
+        }
+    }
+    catch (e) {
+        testPassed = false;
+        testError = e.message;
+    }
+    finally {
+        await browser.close();
+    }
+    return {
+        runNumber,
+        passed: testPassed,
+        duration: Date.now() - startTime,
+        error: testError,
+        stepResults,
+    };
+}
+/**
+ * Analyze a test for flakiness by running it multiple times.
+ */
+async function analyzeTestFlakiness(test, options) {
+    const { runs = 5, headless = true, flakinessThreshold = 20, delayBetweenRuns = 500, } = options;
+    const testRuns = [];
+    console.log(`\n   🔄 Running ${runs} times...`);
+    for (let i = 1; i <= runs; i++) {
+        const result = await runTestOnce(test, i, headless);
+        testRuns.push(result);
+        const icon = result.passed ? "✓" : "✗";
+        console.log(`      Run ${i}: ${icon} (${result.duration}ms)`);
+        if (i < runs && delayBetweenRuns > 0) {
+            await new Promise((r) => setTimeout(r, delayBetweenRuns));
+        }
+    }
+    // Calculate overall stats
+    const passCount = testRuns.filter((r) => r.passed).length;
+    const failCount = testRuns.filter((r) => !r.passed).length;
+    const flakinessScore = calculateFlakinessScore(passCount, failCount);
+    const classification = classifyTest(passCount, failCount);
+    const isFlaky = flakinessScore >= flakinessThreshold;
+    // Calculate duration stats
+    const durations = testRuns.map((r) => r.duration);
+    const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;
+    const variance = Math.sqrt(durations.reduce((sum, d) => sum + Math.pow(d - avgDuration, 2), 0) / durations.length);
+    // Analyze per-step flakiness
+    const stepAnalysis = [];
+    for (let stepIdx = 0; stepIdx < test.steps.length; stepIdx++) {
+        const step = test.steps[stepIdx];
+        const stepResults = testRuns.map((r) => r.stepResults[stepIdx]).filter(Boolean);
+        const stepPassCount = stepResults.filter((s) => s?.passed).length;
+        const stepFailCount = stepResults.filter((s) => !s?.passed).length;
+        const stepFlakinessScore = calculateFlakinessScore(stepPassCount, stepFailCount);
+        const stepErrors = [...new Set(stepResults.filter((s) => s?.error).map((s) => s.error))];
+        stepAnalysis.push({
+            instruction: step.instruction,
+            passCount: stepPassCount,
+            failCount: stepFailCount,
+            flakinessScore: stepFlakinessScore,
+            isFlaky: stepFlakinessScore >= flakinessThreshold,
+            errors: stepErrors,
+        });
+    }
+    return {
+        testName: test.name,
+        totalRuns: runs,
+        passCount,
+        failCount,
+        flakinessScore,
+        isFlaky,
+        classification,
+        runs: testRuns,
+        stepAnalysis,
+        avgDuration: Math.round(avgDuration),
+        durationVariance: Math.round(variance),
+    };
+}
+/**
+ * Run flaky test detection on a test suite.
+ */
+async function detectFlakyTests(suite, options = {}) {
+    const { runs = 5, flakinessThreshold = 20 } = options;
+    const startTime = Date.now();
+    const testAnalyses = [];
+    console.log(`\n🔍 Flaky Test Detection: ${suite.name}`);
+    console.log(`   Tests: ${suite.tests.length}`);
+    console.log(`   Runs per test: ${runs}`);
+    console.log(`   Flakiness threshold: ${flakinessThreshold}%`);
+    for (const test of suite.tests) {
+        console.log(`\n📋 Test: ${test.name}`);
+        const analysis = await analyzeTestFlakiness(test, options);
+        testAnalyses.push(analysis);
+        const statusIcon = analysis.classification === "stable_pass" ? "✅" :
+            analysis.classification === "stable_fail" ? "❌" :
+                analysis.classification === "flaky" ? "⚠️" :
+                    analysis.classification === "mostly_pass" ? "🟡" : "🟠";
+        console.log(`   ${statusIcon} ${analysis.classification.toUpperCase()} (${analysis.passCount}/${analysis.totalRuns} passed, flakiness: ${analysis.flakinessScore}%)`);
+    }
+    // Calculate summary
+    const stablePassTests = testAnalyses.filter((t) => t.classification === "stable_pass").length;
+    const stableFailTests = testAnalyses.filter((t) => t.classification === "stable_fail").length;
+    const flakyTests = testAnalyses.filter((t) => t.isFlaky).length;
+    const mostFlakyTest = testAnalyses.reduce((max, t) => t.flakinessScore > (max?.flakinessScore || 0) ? t : max, testAnalyses[0])?.testName;
+    const allSteps = testAnalyses.flatMap((t) => t.stepAnalysis);
+    const mostFlakyStep = allSteps.reduce((max, s) => s.flakinessScore > (max?.flakinessScore || 0) ? s : max, allSteps[0])?.instruction;
+    const overallFlakinessScore = testAnalyses.length > 0
+        ? Math.round(testAnalyses.reduce((sum, t) => sum + t.flakinessScore, 0) / testAnalyses.length)
+        : 0;
+    return {
+        suiteName: suite.name,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime,
+        runsPerTest: runs,
+        testAnalyses,
+        summary: {
+            totalTests: suite.tests.length,
+            stablePassTests,
+            stableFailTests,
+            flakyTests,
+            mostFlakyTest: flakyTests > 0 ? mostFlakyTest : undefined,
+            mostFlakyStep: allSteps.some((s) => s.isFlaky) ? mostFlakyStep : undefined,
+            overallFlakinessScore,
+        },
+    };
+}
+/**
+ * Format a flaky test report.
+ */
+function formatFlakyTestReport(result) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
+    lines.push("║                      FLAKY TEST DETECTION REPORT                             ║");
+    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    lines.push(`📋 Suite: ${result.suiteName}`);
+    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
+    lines.push(`🔄 Runs per test: ${result.runsPerTest}`);
+    lines.push(`📅 Timestamp: ${result.timestamp}`);
+    lines.push("");
+    // Summary
+    const flakyEmoji = result.summary.flakyTests === 0 ? "✅" : "⚠️";
+    lines.push(`${flakyEmoji} Overall Flakiness: ${result.summary.overallFlakinessScore}%`);
+    lines.push("");
+    lines.push("📊 SUMMARY");
+    lines.push("─".repeat(60));
+    lines.push(`  Total Tests: ${result.summary.totalTests}`);
+    lines.push(`  Stable (Pass): ${result.summary.stablePassTests}`);
+    lines.push(`  Stable (Fail): ${result.summary.stableFailTests}`);
+    lines.push(`  Flaky: ${result.summary.flakyTests}`);
+    if (result.summary.mostFlakyTest) {
+        lines.push(`  Most Flaky Test: ${result.summary.mostFlakyTest}`);
+    }
+    if (result.summary.mostFlakyStep) {
+        lines.push(`  Most Flaky Step: ${result.summary.mostFlakyStep.slice(0, 50)}...`);
+    }
+    lines.push("");
+    // Results table
+    lines.push("┌────────────────────────────────┬────────────┬──────────┬───────────┬────────────┐");
+    lines.push("│ Test                           │ Status     │ Pass/Fail│ Flakiness │ Avg Time   │");
+    lines.push("├────────────────────────────────┼────────────┼──────────┼───────────┼────────────┤");
+    for (const test of result.testAnalyses) {
+        const name = test.testName.padEnd(30).slice(0, 30);
+        const status = test.classification.replace("_", " ").toUpperCase().padEnd(10).slice(0, 10);
+        const passFailStr = `${test.passCount}/${test.totalRuns}`.padEnd(8);
+        const flakiness = `${test.flakinessScore}%`.padEnd(9);
+        const avgTime = `${(test.avgDuration / 1000).toFixed(1)}s`.padEnd(10);
+        lines.push(`│ ${name} │ ${status} │ ${passFailStr} │ ${flakiness} │ ${avgTime} │`);
+    }
+    lines.push("└────────────────────────────────┴────────────┴──────────┴───────────┴────────────┘");
+    lines.push("");
+    // Flaky tests details
+    const flakyTests = result.testAnalyses.filter((t) => t.isFlaky);
+    if (flakyTests.length > 0) {
+        lines.push("⚠️  FLAKY TESTS DETAILS");
+        lines.push("─".repeat(60));
+        for (const test of flakyTests) {
+            lines.push(`\n  📋 ${test.testName}`);
+            lines.push(`     Flakiness: ${test.flakinessScore}%`);
+            lines.push(`     Pass Rate: ${test.passCount}/${test.totalRuns} (${Math.round((test.passCount / test.totalRuns) * 100)}%)`);
+            lines.push(`     Duration: ${test.avgDuration}ms ± ${test.durationVariance}ms`);
+            const flakySteps = test.stepAnalysis.filter((s) => s.isFlaky);
+            if (flakySteps.length > 0) {
+                lines.push(`     Flaky Steps:`);
+                for (const step of flakySteps) {
+                    lines.push(`       - "${step.instruction.slice(0, 40)}..." (${step.flakinessScore}% flaky)`);
+                    if (step.errors.length > 0) {
+                        lines.push(`         Errors: ${step.errors[0].slice(0, 50)}`);
+                    }
+                }
+            }
+        }
+        lines.push("");
+    }
+    // Recommendations
+    lines.push("💡 RECOMMENDATIONS");
+    lines.push("─".repeat(60));
+    if (result.summary.flakyTests === 0) {
+        lines.push("  ✅ All tests are stable - no action needed");
+    }
+    else {
+        lines.push(`  ⚠️ ${result.summary.flakyTests} flaky test(s) detected`);
+        lines.push("  Consider:");
+        lines.push("    - Adding explicit waits for timing-sensitive operations");
+        lines.push("    - Using more specific selectors");
+        lines.push("    - Checking for race conditions in the application");
+        lines.push("    - Isolating tests to avoid shared state issues");
+    }
+    lines.push("");
+    return lines.join("\n");
+}
 //# sourceMappingURL=browser.js.map