cbrowser 6.0.0 → 6.2.0

package/dist/browser.js

@@ -16,6 +16,15 @@ exports.applyChaos = applyChaos;
 exports.runChaosTest = runChaosTest;
 exports.comparePersonas = comparePersonas;
 exports.formatComparisonReport = formatComparisonReport;
+exports.parseNLInstruction = parseNLInstruction;
+exports.parseNLTestSuite = parseNLTestSuite;
+exports.runNLTestSuite = runNLTestSuite;
+exports.formatNLTestReport = formatNLTestReport;
+exports.runNLTestFile = runNLTestFile;
+exports.repairTest = repairTest;
+exports.repairTestSuite = repairTestSuite;
+exports.formatRepairReport = formatRepairReport;
+exports.exportRepairedTest = exportRepairedTest;
 const playwright_1 = require("playwright");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -2877,4 +2886,936 @@ function formatComparisonReport(comparison) {
     lines.push("");
     return lines.join("\n");
 }
+// =========================================================================
+// Natural Language Test Suites
+// =========================================================================
+/**
+ * Parse a single natural language instruction into an NLTestStep.
+ *
+ * Supported patterns:
+ * - "go to https://..." / "navigate to https://..." / "open https://..."
+ * - "click [the] <target>" / "press <target>"
+ * - "type '<value>' in[to] <target>" / "fill <target> with '<value>'"
+ * - "select '<option>' from <dropdown>"
+ * - "scroll down/up"
+ * - "wait [for] <seconds> seconds"
+ * - "verify <assertion>" / "assert <assertion>" / "check <assertion>"
+ * - "take screenshot"
+ */
+function parseNLInstruction(instruction) {
+    const lower = instruction.toLowerCase().trim();
+    // Navigate patterns
+    const navigateMatch = lower.match(/^(?:go to|navigate to|open|visit)\s+(.+)$/i);
+    if (navigateMatch) {
+        return {
+            instruction,
+            action: "navigate",
+            target: navigateMatch[1].trim(),
+        };
+    }
+    // Click patterns
+    const clickMatch = lower.match(/^(?:click|tap|press)\s+(?:on\s+)?(?:the\s+)?(.+)$/i);
+    if (clickMatch) {
+        return {
+            instruction,
+            action: "click",
+            target: clickMatch[1].trim(),
+        };
+    }
+    // Fill patterns: "type 'value' in target" or "fill target with 'value'"
+    const typeMatch = lower.match(/^(?:type|enter)\s+['"](.+?)['"]\s+(?:in|into)\s+(?:the\s+)?(.+)$/i);
+    if (typeMatch) {
+        return {
+            instruction,
+            action: "fill",
+            value: typeMatch[1],
+            target: typeMatch[2].trim(),
+        };
+    }
+    const fillMatch = lower.match(/^fill\s+(?:the\s+)?(.+?)\s+with\s+['"](.+?)['"]$/i);
+    if (fillMatch) {
+        return {
+            instruction,
+            action: "fill",
+            target: fillMatch[1].trim(),
+            value: fillMatch[2],
+        };
+    }
+    // Select patterns
+    const selectMatch = lower.match(/^select\s+['"](.+?)['"]\s+(?:from|in)\s+(?:the\s+)?(.+)$/i);
+    if (selectMatch) {
+        return {
+            instruction,
+            action: "select",
+            value: selectMatch[1],
+            target: selectMatch[2].trim(),
+        };
+    }
+    // Scroll patterns
+    const scrollMatch = lower.match(/^scroll\s+(up|down|left|right)(?:\s+(\d+)\s+(?:times|pixels))?$/i);
+    if (scrollMatch) {
+        return {
+            instruction,
+            action: "scroll",
+            target: scrollMatch[1],
+            value: scrollMatch[2] || "3",
+        };
+    }
+    // Wait patterns
+    const waitMatch = lower.match(/^wait\s+(?:for\s+)?(\d+(?:\.\d+)?)\s*(?:seconds?|s)$/i);
+    if (waitMatch) {
+        return {
+            instruction,
+            action: "wait",
+            value: waitMatch[1],
+        };
+    }
+    // Wait for text pattern
+    const waitForMatch = lower.match(/^wait\s+(?:for|until)\s+['"](.+?)['"]\s+(?:appears?|is visible|shows?)$/i);
+    if (waitForMatch) {
+        return {
+            instruction,
+            action: "wait",
+            target: waitForMatch[1],
+        };
+    }
+    // Assert/verify patterns
+    const assertPatterns = [
+        // Title assertions
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:page\s+)?title\s+(?:contains?|has)\s+['"](.+?)['"]$/i, type: "title", assertType: "contains" },
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:page\s+)?title\s+(?:is|equals?)\s+['"](.+?)['"]$/i, type: "title", assertType: "equals" },
+        // URL assertions
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?url\s+(?:contains?|has)\s+['"](.+?)['"]$/i, type: "url", assertType: "contains" },
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?url\s+(?:is|equals?)\s+['"](.+?)['"]$/i, type: "url", assertType: "equals" },
+        // Content assertions
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:page\s+)?(?:contains?|has|shows?)\s+['"](.+?)['"]$/i, type: "content", assertType: "contains" },
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?['"](.+?)['"]\s+(?:is\s+)?(?:visible|displayed|shown)$/i, type: "content", assertType: "contains" },
+        // Element exists
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?['"](.+?)['"]\s+exists?$/i, type: "element", assertType: "exists" },
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:there\s+is\s+)?(?:a|an)\s+['"](.+?)['"]$/i, type: "element", assertType: "exists" },
+        // Count assertions
+        { pattern: /^(?:verify|assert|check)\s+(?:that\s+)?(?:there\s+are\s+)?(\d+)\s+(.+?)$/i, type: "count", assertType: "count" },
+    ];
+    for (const { pattern, type, assertType } of assertPatterns) {
+        const match = lower.match(pattern);
+        if (match) {
+            return {
+                instruction,
+                action: "assert",
+                target: type === "count" ? match[2] : match[1],
+                value: type === "count" ? match[1] : undefined,
+                assertionType: assertType,
+            };
+        }
+    }
+    // Screenshot pattern
+    if (/^(?:take\s+(?:a\s+)?screenshot|screenshot|capture\s+(?:the\s+)?(?:page|screen))$/i.test(lower)) {
+        return {
+            instruction,
+            action: "screenshot",
+        };
+    }
+    // Unknown - return as-is for AI-powered interpretation later
+    return {
+        instruction,
+        action: "unknown",
+        target: instruction,
+    };
+}
+/**
+ * Parse a natural language test suite from text.
+ *
+ * Format:
+ * ```
+ * # Test: Login Flow
+ * go to https://example.com
+ * click the login button
+ * type "user@example.com" in email field
+ * type "password123" in password field
+ * click submit
+ * verify url contains "/dashboard"
+ *
+ * # Test: Search Functionality
+ * go to https://example.com
+ * type "test query" in search box
+ * click search button
+ * verify page contains "results"
+ * ```
+ */
+function parseNLTestSuite(text, suiteName = "Unnamed Suite") {
+    const lines = text.split("\n").map(l => l.trim()).filter(l => l && !l.startsWith("//"));
+    const tests = [];
+    let currentTest = null;
+    for (const line of lines) {
+        // Check for test header: "# Test: Name" or "## Name" or "Test: Name"
+        const testHeaderMatch = line.match(/^(?:#\s*)?(?:test:\s*)?(.+)$/i);
+        if (line.startsWith("#") || line.toLowerCase().startsWith("test:")) {
+            // Save previous test if exists
+            if (currentTest && currentTest.steps.length > 0) {
+                tests.push(currentTest);
+            }
+            const name = testHeaderMatch?.[1]?.replace(/^#+\s*/, "").replace(/^test:\s*/i, "").trim() || "Unnamed Test";
+            currentTest = {
+                name,
+                steps: [],
+            };
+        }
+        else if (line.length > 0) {
+            // Parse as instruction
+            if (!currentTest) {
+                // Create default test if no header found
+                currentTest = {
+                    name: "Default Test",
+                    steps: [],
+                };
+            }
+            const step = parseNLInstruction(line);
+            currentTest.steps.push(step);
+        }
+    }
+    // Save final test
+    if (currentTest && currentTest.steps.length > 0) {
+        tests.push(currentTest);
+    }
+    return { name: suiteName, tests };
+}
+/**
+ * Run a natural language test suite.
+ */
+async function runNLTestSuite(suite, options = {}) {
+    const { stepTimeout = 30000, continueOnFailure = true, screenshotOnFailure = true, headless = true, } = options;
+    const startTime = Date.now();
+    const testResults = [];
+    console.log(`\n🧪 Running Test Suite: ${suite.name}`);
+    console.log(`   Tests: ${suite.tests.length}`);
+    console.log(`   Continue on failure: ${continueOnFailure}`);
+    console.log("");
+    const browser = new CBrowser({
+        headless,
+    });
+    try {
+        await browser.launch();
+        for (const test of suite.tests) {
+            console.log(`\n📋 Test: ${test.name}`);
+            const testStartTime = Date.now();
+            const stepResults = [];
+            let testPassed = true;
+            let testError;
+            for (const step of test.steps) {
+                console.log(`   → ${step.instruction}`);
+                const stepStartTime = Date.now();
+                let stepPassed = true;
+                let stepError;
+                let screenshot;
+                let actualValue;
+                try {
+                    // Execute the step based on action type
+                    switch (step.action) {
+                        case "navigate": {
+                            await browser.navigate(step.target || "");
+                            break;
+                        }
+                        case "click": {
+                            const result = await browser.smartClick(step.target || "");
+                            if (!result.success) {
+                                throw new Error(`Failed to click: ${step.target}`);
+                            }
+                            break;
+                        }
+                        case "fill": {
+                            await browser.fill(step.target || "", step.value || "");
+                            break;
+                        }
+                        case "select": {
+                            await browser.fill(step.target || "", step.value || "");
+                            break;
+                        }
+                        case "scroll": {
+                            const direction = step.target?.toLowerCase() === "up" ? -500 : 500;
+                            // Use private page access through cast
+                            const page = browser.page;
+                            if (page) {
+                                await page.evaluate((d) => window.scrollBy(0, d), direction);
+                            }
+                            break;
+                        }
+                        case "wait": {
+                            if (step.target) {
+                                // Wait for text to appear - use private page access
+                                const page = browser.page;
+                                if (page) {
+                                    await page.waitForSelector(`text=${step.target}`, { timeout: stepTimeout });
+                                }
+                            }
+                            else {
+                                // Wait for duration
+                                const ms = parseFloat(step.value || "1") * 1000;
+                                await new Promise(r => setTimeout(r, ms));
+                            }
+                            break;
+                        }
+                        case "assert": {
+                            const assertResult = await browser.assert(step.instruction);
+                            stepPassed = assertResult.passed;
+                            actualValue = String(assertResult.actual);
+                            if (!assertResult.passed) {
+                                stepError = assertResult.message;
+                            }
+                            break;
+                        }
+                        case "screenshot": {
+                            screenshot = await browser.screenshot();
+                            break;
+                        }
+                        case "unknown": {
+                            // Try to interpret as a click or fill
+                            console.log(`   ⚠️ Unknown instruction, attempting smart interpretation...`);
+                            const result = await browser.smartClick(step.target || step.instruction);
+                            if (!result.success) {
+                                throw new Error(`Could not interpret: ${step.instruction}`);
+                            }
+                            break;
+                        }
+                    }
+                    console.log(`     ✓ Passed (${Date.now() - stepStartTime}ms)`);
+                }
+                catch (e) {
+                    stepPassed = false;
+                    stepError = e.message;
+                    testPassed = false;
+                    testError = testError || e.message;
+                    console.log(`     ✗ Failed: ${e.message}`);
+                    if (screenshotOnFailure) {
+                        try {
+                            screenshot = await browser.screenshot();
+                        }
+                        catch { }
+                    }
+                }
+                stepResults.push({
+                    instruction: step.instruction,
+                    action: step.action,
+                    passed: stepPassed,
+                    duration: Date.now() - stepStartTime,
+                    error: stepError,
+                    screenshot,
+                    actualValue,
+                });
+                // Stop test if step failed and not continuing on failure
+                if (!stepPassed && !continueOnFailure) {
+                    break;
+                }
+            }
+            testResults.push({
+                name: test.name,
+                passed: testPassed,
+                duration: Date.now() - testStartTime,
+                stepResults,
+                error: testError,
+            });
+            console.log(`   ${testPassed ? "✅" : "❌"} ${test.name}: ${testPassed ? "PASSED" : "FAILED"}`);
+        }
+    }
+    finally {
+        await browser.close();
+    }
+    const passed = testResults.filter(t => t.passed).length;
+    const failed = testResults.filter(t => !t.passed).length;
+    const result = {
+        name: suite.name,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime,
+        testResults,
+        summary: {
+            total: suite.tests.length,
+            passed,
+            failed,
+            skipped: 0,
+            passRate: suite.tests.length > 0 ? (passed / suite.tests.length) * 100 : 0,
+        },
+    };
+    return result;
+}
+/**
+ * Format a test suite result as a report.
+ */
+function formatNLTestReport(result) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
+    lines.push("║                    NATURAL LANGUAGE TEST REPORT                              ║");
+    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    lines.push(`📋 Suite: ${result.name}`);
+    lines.push(`⏱️  Duration: ${(result.duration / 1000).toFixed(1)}s`);
+    lines.push(`📅 Timestamp: ${result.timestamp}`);
+    lines.push("");
+    // Summary stats
+    const passEmoji = result.summary.passRate === 100 ? "🎉" : result.summary.passRate >= 80 ? "✅" : "⚠️";
+    lines.push(`${passEmoji} Pass Rate: ${result.summary.passed}/${result.summary.total} (${result.summary.passRate.toFixed(0)}%)`);
+    lines.push("");
+    // Results table
+    lines.push("┌───────────────────────────────────────┬──────────┬──────────┬────────────────────┐");
+    lines.push("│ Test                                  │ Status   │ Duration │ Error              │");
+    lines.push("├───────────────────────────────────────┼──────────┼──────────┼────────────────────┤");
+    for (const test of result.testResults) {
+        const name = test.name.padEnd(37).slice(0, 37);
+        const status = test.passed ? "✓ PASS".padEnd(8) : "✗ FAIL".padEnd(8);
+        const duration = `${(test.duration / 1000).toFixed(1)}s`.padEnd(8);
+        const error = (test.error || "-").slice(0, 18).padEnd(18);
+        lines.push(`│ ${name} │ ${status} │ ${duration} │ ${error} │`);
+    }
+    lines.push("└───────────────────────────────────────┴──────────┴──────────┴────────────────────┘");
+    lines.push("");
+    // Failed test details
+    const failedTests = result.testResults.filter(t => !t.passed);
+    if (failedTests.length > 0) {
+        lines.push("❌ FAILED TESTS");
+        lines.push("─".repeat(60));
+        for (const test of failedTests) {
+            lines.push(`\n  📋 ${test.name}`);
+            const failedSteps = test.stepResults.filter(s => !s.passed);
+            for (const step of failedSteps) {
+                lines.push(`     ✗ ${step.instruction}`);
+                if (step.error) {
+                    lines.push(`       Error: ${step.error}`);
+                }
+                if (step.screenshot) {
+                    lines.push(`       Screenshot: ${step.screenshot}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Run a natural language test suite from a file.
+ */
+async function runNLTestFile(filepath, options = {}) {
+    if (!(0, fs_1.existsSync)(filepath)) {
+        throw new Error(`Test file not found: ${filepath}`);
+    }
+    const content = (0, fs_1.readFileSync)(filepath, "utf-8");
+    const suiteName = filepath.split("/").pop()?.replace(/\.[^.]+$/, "") || "Test Suite";
+    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");
+}
 //# sourceMappingURL=browser.js.map