cbrowser 5.3.0 → 6.1.0

package/dist/browser.js

@@ -14,6 +14,13 @@ exports.huntBugs = huntBugs;
 exports.crossBrowserDiff = crossBrowserDiff;
 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;
 const playwright_1 = require("playwright");
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -2671,4 +2678,623 @@ async function runChaosTest(browser, url, chaos, actions = []) {
         };
     }
 }
+/**
+ * Run the same journey with multiple personas and compare results.
+ * This runs personas in parallel (up to maxConcurrency) for efficiency.
+ */
+async function comparePersonas(options) {
+    const { startUrl, goal, personas, maxSteps = 20, maxConcurrency = 3, headless = true, } = options;
+    const startTime = Date.now();
+    const results = [];
+    console.log(`\n🔄 Comparing ${personas.length} personas...`);
+    console.log(`   URL: ${startUrl}`);
+    console.log(`   Goal: ${goal}`);
+    console.log(`   Concurrency: ${maxConcurrency}\n`);
+    // Process personas in batches
+    for (let i = 0; i < personas.length; i += maxConcurrency) {
+        const batch = personas.slice(i, i + maxConcurrency);
+        console.log(`📦 Batch ${Math.floor(i / maxConcurrency) + 1}: ${batch.join(", ")}`);
+        const batchPromises = batch.map(async (personaName) => {
+            const browser = new CBrowser({ headless });
+            try {
+                const persona = (0, personas_js_1.getPersona)(personaName) || personas_js_1.BUILTIN_PERSONAS["first-timer"];
+                const journeyStart = Date.now();
+                // Run the journey
+                const journey = await browser.journey({
+                    persona: personaName,
+                    startUrl,
+                    goal,
+                    maxSteps,
+                });
+                // Calculate average reaction time from persona config
+                const timing = persona.humanBehavior?.timing;
+                const avgReactionTime = timing
+                    ? (timing.reactionTime.min + timing.reactionTime.max) / 2
+                    : 500;
+                // Calculate error rate from persona config
+                const errors = persona.humanBehavior?.errors;
+                const errorRate = errors
+                    ? (errors.misClickRate + errors.typoRate) / 2
+                    : 0.05;
+                const result = {
+                    persona: personaName,
+                    description: persona.description,
+                    techLevel: persona.demographics.tech_level || "intermediate",
+                    device: persona.demographics.device || "desktop",
+                    success: journey.success,
+                    totalTime: journey.totalTime,
+                    stepCount: journey.steps.length,
+                    frictionCount: journey.frictionPoints.length,
+                    frictionPoints: journey.frictionPoints,
+                    avgReactionTime,
+                    errorRate,
+                    screenshots: {
+                        start: journey.steps[0]?.screenshot || "",
+                        end: journey.steps[journey.steps.length - 1]?.screenshot || "",
+                    },
+                };
+                console.log(`   ✓ ${personaName}: ${journey.success ? "SUCCESS" : "FAILED"} (${journey.totalTime}ms, ${journey.frictionPoints.length} friction)`);
+                return result;
+            }
+            catch (e) {
+                console.log(`   ✗ ${personaName}: ERROR - ${e.message}`);
+                return {
+                    persona: personaName,
+                    description: "Unknown",
+                    techLevel: "unknown",
+                    device: "unknown",
+                    success: false,
+                    totalTime: 0,
+                    stepCount: 0,
+                    frictionCount: 1,
+                    frictionPoints: [`Error: ${e.message}`],
+                    avgReactionTime: 0,
+                    errorRate: 0,
+                    screenshots: { start: "", end: "" },
+                };
+            }
+            finally {
+                await browser.close();
+            }
+        });
+        const batchResults = await Promise.all(batchPromises);
+        results.push(...batchResults);
+    }
+    // Generate summary
+    const successfulResults = results.filter((r) => r.success);
+    const failedResults = results.filter((r) => !r.success);
+    const sortedByTime = [...successfulResults].sort((a, b) => a.totalTime - b.totalTime);
+    const sortedByFriction = [...results].sort((a, b) => b.frictionCount - a.frictionCount);
+    // Collect all friction points
+    const allFrictionPoints = results.flatMap((r) => r.frictionPoints);
+    const frictionCounts = allFrictionPoints.reduce((acc, fp) => {
+        acc[fp] = (acc[fp] || 0) + 1;
+        return acc;
+    }, {});
+    const commonFriction = Object.entries(frictionCounts)
+        .filter(([_, count]) => count > 1)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([fp]) => fp);
+    // Generate recommendations
+    const recommendations = [];
+    if (failedResults.length > 0) {
+        recommendations.push(`⚠️ ${failedResults.length} persona(s) failed to complete the journey: ${failedResults.map((r) => r.persona).join(", ")}`);
+    }
+    if (sortedByFriction[0]?.frictionCount > 0) {
+        recommendations.push(`🔧 "${sortedByFriction[0].persona}" experienced the most friction (${sortedByFriction[0].frictionCount} points) - review for accessibility improvements`);
+    }
+    const beginnerPersonas = results.filter((r) => r.techLevel === "beginner");
+    const expertPersonas = results.filter((r) => r.techLevel === "expert");
+    if (beginnerPersonas.length > 0 && expertPersonas.length > 0) {
+        const avgBeginnerTime = beginnerPersonas.reduce((sum, r) => sum + r.totalTime, 0) / beginnerPersonas.length;
+        const avgExpertTime = expertPersonas.reduce((sum, r) => sum + r.totalTime, 0) / expertPersonas.length;
+        if (avgBeginnerTime > avgExpertTime * 3) {
+            recommendations.push(`📚 Beginners take ${(avgBeginnerTime / avgExpertTime).toFixed(1)}x longer than experts - consider adding more guidance`);
+        }
+    }
+    const mobilePersonas = results.filter((r) => r.device === "mobile");
+    const desktopPersonas = results.filter((r) => r.device === "desktop");
+    if (mobilePersonas.length > 0 && desktopPersonas.length > 0) {
+        const mobileFriction = mobilePersonas.reduce((sum, r) => sum + r.frictionCount, 0) / mobilePersonas.length;
+        const desktopFriction = desktopPersonas.reduce((sum, r) => sum + r.frictionCount, 0) / desktopPersonas.length;
+        if (mobileFriction > desktopFriction * 2) {
+            recommendations.push(`📱 Mobile users experience ${(mobileFriction / desktopFriction).toFixed(1)}x more friction - review mobile UX`);
+        }
+    }
+    if (commonFriction.length > 0) {
+        recommendations.push(`🎯 Common friction points across personas: ${commonFriction.slice(0, 3).join("; ")}`);
+    }
+    if (recommendations.length === 0) {
+        recommendations.push("✅ All personas completed the journey without significant issues");
+    }
+    const avgTime = successfulResults.length > 0
+        ? successfulResults.reduce((sum, r) => sum + r.totalTime, 0) / successfulResults.length
+        : 0;
+    const comparison = {
+        url: startUrl,
+        goal,
+        timestamp: new Date().toISOString(),
+        duration: Date.now() - startTime,
+        personas: results,
+        summary: {
+            totalPersonas: personas.length,
+            successCount: successfulResults.length,
+            failureCount: failedResults.length,
+            fastestPersona: sortedByTime[0]?.persona || "N/A",
+            slowestPersona: sortedByTime[sortedByTime.length - 1]?.persona || "N/A",
+            mostFriction: sortedByFriction[0]?.persona || "N/A",
+            leastFriction: sortedByFriction[sortedByFriction.length - 1]?.persona || "N/A",
+            avgCompletionTime: Math.round(avgTime),
+            commonFrictionPoints: commonFriction,
+        },
+        recommendations,
+    };
+    return comparison;
+}
+/**
+ * Generate a formatted comparison report.
+ */
+function formatComparisonReport(comparison) {
+    const lines = [];
+    lines.push("");
+    lines.push("╔══════════════════════════════════════════════════════════════════════════════╗");
+    lines.push("║                    MULTI-PERSONA COMPARISON REPORT                           ║");
+    lines.push("╚══════════════════════════════════════════════════════════════════════════════╝");
+    lines.push("");
+    lines.push(`📍 URL: ${comparison.url}`);
+    lines.push(`🎯 Goal: ${comparison.goal}`);
+    lines.push(`⏱️  Total Duration: ${(comparison.duration / 1000).toFixed(1)}s`);
+    lines.push(`📅 Timestamp: ${comparison.timestamp}`);
+    lines.push("");
+    // Results table
+    lines.push("┌─────────────────────┬──────────┬──────────┬──────────┬──────────┬─────────────────────────────┐");
+    lines.push("│ Persona             │ Success  │ Time     │ Steps    │ Friction │ Key Issues                  │");
+    lines.push("├─────────────────────┼──────────┼──────────┼──────────┼──────────┼─────────────────────────────┤");
+    for (const result of comparison.personas) {
+        const name = result.persona.padEnd(19).slice(0, 19);
+        const success = result.success ? "✓".padEnd(8) : "✗".padEnd(8);
+        const time = `${(result.totalTime / 1000).toFixed(1)}s`.padEnd(8);
+        const steps = `${result.stepCount}`.padEnd(8);
+        const friction = `${result.frictionCount}`.padEnd(8);
+        const issues = (result.frictionPoints[0] || "-").slice(0, 27).padEnd(27);
+        lines.push(`│ ${name} │ ${success} │ ${time} │ ${steps} │ ${friction} │ ${issues} │`);
+    }
+    lines.push("└─────────────────────┴──────────┴──────────┴──────────┴──────────┴─────────────────────────────┘");
+    lines.push("");
+    // Summary
+    lines.push("📊 SUMMARY");
+    lines.push("─".repeat(60));
+    lines.push(`  Total Personas: ${comparison.summary.totalPersonas}`);
+    lines.push(`  Success Rate: ${comparison.summary.successCount}/${comparison.summary.totalPersonas} (${Math.round((comparison.summary.successCount / comparison.summary.totalPersonas) * 100)}%)`);
+    lines.push(`  Avg Completion Time: ${(comparison.summary.avgCompletionTime / 1000).toFixed(1)}s`);
+    lines.push(`  Fastest: ${comparison.summary.fastestPersona}`);
+    lines.push(`  Slowest: ${comparison.summary.slowestPersona}`);
+    lines.push(`  Most Friction: ${comparison.summary.mostFriction}`);
+    lines.push(`  Least Friction: ${comparison.summary.leastFriction}`);
+    lines.push("");
+    // Recommendations
+    lines.push("💡 RECOMMENDATIONS");
+    lines.push("─".repeat(60));
+    for (const rec of comparison.recommendations) {
+        lines.push(`  ${rec}`);
+    }
+    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);
+}
 //# sourceMappingURL=browser.js.map