fair-playwright 1.0.0

package/dist/index.js

@@ -0,0 +1,1387 @@
+// src/reporter/StepTracker.ts
+var StepTracker = class {
+  tests = /* @__PURE__ */ new Map();
+  steps = /* @__PURE__ */ new Map();
+  durationThreshold;
+  autoDetect;
+  constructor(options) {
+    this.durationThreshold = options?.durationThreshold ?? 1e3;
+    this.autoDetect = options?.autoDetect ?? true;
+  }
+  /**
+   * Start tracking a test
+   */
+  startTest(testCase, _result) {
+    const testId = this.getTestId(testCase);
+    const test2 = {
+      id: testId,
+      title: testCase.title,
+      file: testCase.location.file,
+      status: "running",
+      startTime: Date.now(),
+      steps: [],
+      attachments: [],
+      consoleErrors: []
+    };
+    this.tests.set(testId, test2);
+    return testId;
+  }
+  /**
+   * Start tracking a step
+   */
+  startStep(testCase, _result, step, parentStepId) {
+    const testId = this.getTestId(testCase);
+    const stepId = this.getStepId(testCase, step);
+    const stepMetadata = {
+      id: stepId,
+      title: this.cleanStepTitle(step.title),
+      level: this.classifyStep(step, parentStepId),
+      status: "running",
+      startTime: Date.now(),
+      parentId: parentStepId,
+      childIds: []
+    };
+    this.steps.set(stepId, stepMetadata);
+    if (parentStepId) {
+      const parent = this.steps.get(parentStepId);
+      if (parent) {
+        parent.childIds.push(stepId);
+      }
+    }
+    const test2 = this.tests.get(testId);
+    if (test2) {
+      test2.steps.push(stepMetadata);
+    }
+    return stepId;
+  }
+  /**
+   * End tracking a step
+   */
+  endStep(_testCase, _result, step, stepId) {
+    const stepMetadata = this.steps.get(stepId);
+    if (!stepMetadata) return;
+    stepMetadata.endTime = Date.now();
+    stepMetadata.duration = stepMetadata.endTime - stepMetadata.startTime;
+    stepMetadata.status = step.error ? "failed" : "passed";
+    if (step.error) {
+      stepMetadata.error = {
+        message: step.error.message || "Unknown error",
+        stack: step.error.stack
+      };
+    }
+    if (this.autoDetect && stepMetadata.duration > this.durationThreshold) {
+      stepMetadata.level = "major";
+    }
+  }
+  /**
+   * End tracking a test
+   */
+  endTest(testCase, result) {
+    const testId = this.getTestId(testCase);
+    const test2 = this.tests.get(testId);
+    if (!test2) return;
+    test2.endTime = Date.now();
+    test2.duration = result.duration;
+    test2.status = this.mapTestStatus(result.status);
+    if (result.error) {
+      test2.error = {
+        message: result.error.message || "Unknown error",
+        stack: result.error.stack,
+        location: `${testCase.location.file}:${testCase.location.line}:${testCase.location.column}`
+      };
+    }
+    test2.attachments = result.attachments.map((att) => ({
+      name: att.name,
+      path: att.path,
+      contentType: att.contentType
+    }));
+    this.extractConsoleErrors(test2, result);
+  }
+  /**
+   * Extract console errors from test result output
+   */
+  extractConsoleErrors(test2, result) {
+    if (!test2.consoleErrors) {
+      test2.consoleErrors = [];
+    }
+    if (!result.stdout || !result.stderr) {
+      return;
+    }
+    const output = result.stdout.join("\n") + "\n" + result.stderr.join("\n");
+    const errorPatterns = [
+      /console\.error:\s*(.+)/gi,
+      /\[error\]\s*(.+)/gi,
+      /ERROR:\s*(.+)/gi
+    ];
+    errorPatterns.forEach((pattern) => {
+      const matches = output.matchAll(pattern);
+      for (const match of matches) {
+        if (match[1]) {
+          test2.consoleErrors.push({
+            type: "error",
+            message: match[1].trim(),
+            timestamp: Date.now()
+          });
+        }
+      }
+    });
+  }
+  /**
+   * Get test metadata
+   */
+  getTest(testId) {
+    return this.tests.get(testId);
+  }
+  /**
+   * Get all tests
+   */
+  getAllTests() {
+    return Array.from(this.tests.values());
+  }
+  /**
+   * Get step metadata
+   */
+  getStep(stepId) {
+    return this.steps.get(stepId);
+  }
+  /**
+   * Clear all tracking data
+   */
+  clear() {
+    this.tests.clear();
+    this.steps.clear();
+  }
+  /**
+   * Generate unique test ID
+   */
+  getTestId(testCase) {
+    return `${testCase.location.file}::${testCase.title}`;
+  }
+  /**
+   * Generate unique step ID
+   */
+  getStepId(testCase, step) {
+    return `${this.getTestId(testCase)}::${step.title}::${Date.now()}`;
+  }
+  /**
+   * Classify step as MAJOR or MINOR
+   */
+  classifyStep(step, parentStepId) {
+    const prefixMatch = step.title.match(/^\[(MAJOR|MINOR)\]\s*/);
+    if (prefixMatch) {
+      return prefixMatch[1].toLowerCase();
+    }
+    if (parentStepId) {
+      return "minor";
+    }
+    const majorKeywords = ["login", "checkout", "payment", "register", "setup", "flow"];
+    const titleLower = step.title.toLowerCase();
+    if (majorKeywords.some((keyword) => titleLower.includes(keyword))) {
+      return "major";
+    }
+    return "minor";
+  }
+  /**
+   * Clean step title by removing [MAJOR]/[MINOR] prefix
+   */
+  cleanStepTitle(title) {
+    return title.replace(/^\[(MAJOR|MINOR)\]\s*/, "");
+  }
+  /**
+   * Map Playwright test status to our status
+   */
+  mapTestStatus(status) {
+    switch (status) {
+      case "passed":
+        return "passed";
+      case "failed":
+        return "failed";
+      case "skipped":
+        return "skipped";
+      case "timedOut":
+        return "failed";
+      default:
+        return "failed";
+    }
+  }
+};
+
+// src/formatters/ConsoleFormatter.ts
+import pc from "picocolors";
+import logUpdate from "log-update";
+var ConsoleFormatter = class {
+  config;
+  totalTests = 0;
+  completedTests = 0;
+  passedTests = 0;
+  failedTests = 0;
+  skippedTests = 0;
+  runningSteps = /* @__PURE__ */ new Map();
+  isCI;
+  useProgressiveMode;
+  updateTimer;
+  constructor(config) {
+    this.config = config;
+    this.isCI = this.detectCI();
+    this.useProgressiveMode = config.mode === "progressive" && !this.isCI && process.stdout.isTTY === true;
+  }
+  /**
+   * Detect if running in CI environment
+   */
+  detectCI() {
+    return !!(process.env.CI || process.env.CONTINUOUS_INTEGRATION || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.TRAVIS || process.env.JENKINS_URL);
+  }
+  onBegin(totalTests) {
+    this.totalTests = totalTests;
+    const header = pc.bold(pc.blue("\u{1F3AD} Fair Playwright Reporter"));
+    const subheader = pc.dim(`Running ${totalTests} test(s)...`);
+    if (this.useProgressiveMode) {
+      console.log(`
+${header}
+${subheader}
+`);
+    } else {
+      console.log(`
+${header}
+${subheader}
+`);
+    }
+  }
+  onTestBegin(test2) {
+    if (!this.useProgressiveMode && this.config.mode !== "minimal") {
+      console.log(pc.dim(`\u23F3 ${test2.title}`));
+    }
+  }
+  onStepBegin(step) {
+    this.runningSteps.set(step.id, step);
+    if (this.useProgressiveMode) {
+      this.scheduleUpdate();
+    } else if (this.config.mode === "full") {
+      const indent = step.parentId ? "    " : "  ";
+      const icon = step.level === "major" ? "\u25B6" : "\u25B8";
+      console.log(pc.dim(`${indent}${icon} ${step.title}...`));
+    }
+  }
+  onStepEnd(step) {
+    this.runningSteps.delete(step.id);
+    if (this.useProgressiveMode) {
+      this.scheduleUpdate();
+    } else if (this.config.mode === "full") {
+      const indent = step.parentId ? "    " : "  ";
+      const icon = step.status === "passed" ? pc.green("\u2713") : pc.red("\u2717");
+      const duration = step.duration ? pc.dim(` (${step.duration}ms)`) : "";
+      const levelBadge = step.level === "major" ? pc.blue("[MAJOR]") : pc.dim("[minor]");
+      console.log(`${indent}${icon} ${levelBadge} ${step.title}${duration}`);
+    }
+  }
+  onTestEnd(test2) {
+    this.completedTests++;
+    if (test2.status === "passed") {
+      this.passedTests++;
+    } else if (test2.status === "failed") {
+      this.failedTests++;
+    } else if (test2.status === "skipped") {
+      this.skippedTests++;
+    }
+    if (this.useProgressiveMode) {
+      if (test2.status === "failed") {
+        this.clearUpdate();
+        this.printFailedTest(test2);
+      }
+      this.scheduleUpdate();
+    } else {
+      if (test2.status === "passed") {
+        if (this.config.compression.passedTests !== "hide") {
+          const icon = pc.green("\u2713");
+          const duration = pc.dim(` (${test2.duration}ms)`);
+          console.log(`${icon} ${pc.dim(test2.title)}${duration}`);
+        }
+      } else if (test2.status === "failed") {
+        this.printFailedTest(test2);
+      } else if (test2.status === "skipped") {
+        console.log(pc.yellow(`\u2298 ${test2.title} (skipped)`));
+      }
+    }
+  }
+  onEnd(allTests, _result) {
+    if (this.useProgressiveMode) {
+      this.clearUpdate();
+      if (this.updateTimer) {
+        clearTimeout(this.updateTimer);
+      }
+    }
+    console.log("");
+    console.log(pc.bold("\u2500".repeat(60)));
+    console.log("");
+    const passed = allTests.filter((t) => t.status === "passed").length;
+    const failed = allTests.filter((t) => t.status === "failed").length;
+    const skipped = allTests.filter((t) => t.status === "skipped").length;
+    const totalDuration = allTests.reduce((sum, t) => sum + (t.duration || 0), 0);
+    if (failed > 0) {
+      console.log(pc.red(pc.bold(`\u2717 ${failed} failed`)));
+    }
+    if (passed > 0) {
+      console.log(pc.green(`\u2713 ${passed} passed`));
+    }
+    if (skipped > 0) {
+      console.log(pc.yellow(`\u2298 ${skipped} skipped`));
+    }
+    console.log(pc.dim(`
+Total: ${allTests.length} test(s)`));
+    console.log(pc.dim(`Duration: ${(totalDuration / 1e3).toFixed(2)}s`));
+    if (this.config.output.ai) {
+      const aiPath = typeof this.config.output.ai === "string" ? this.config.output.ai : "./test-results/ai-summary.md";
+      console.log(pc.dim(`
+\u{1F4DD} AI Summary: ${aiPath}`));
+    }
+    console.log("");
+  }
+  onError(error) {
+    if (this.useProgressiveMode) {
+      this.clearUpdate();
+    }
+    console.error(pc.red(`
+\u274C Reporter Error: ${error.message}`));
+    if (error.stack) {
+      console.error(pc.dim(error.stack));
+    }
+  }
+  /**
+   * Schedule a progressive update
+   */
+  scheduleUpdate() {
+    if (!this.useProgressiveMode) return;
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+    }
+    this.updateTimer = setTimeout(() => {
+      this.render();
+    }, this.config.progressive.updateInterval);
+  }
+  /**
+   * Render progressive output
+   */
+  render() {
+    if (!this.useProgressiveMode) return;
+    const lines = [];
+    const progress = this.totalTests > 0 ? Math.floor(this.completedTests / this.totalTests * 100) : 0;
+    lines.push(
+      pc.dim(`Progress: ${this.completedTests}/${this.totalTests} tests `) + pc.green(`(${progress}%)`)
+    );
+    const statusParts = [];
+    if (this.passedTests > 0) statusParts.push(pc.green(`\u2713 ${this.passedTests}`));
+    if (this.failedTests > 0) statusParts.push(pc.red(`\u2717 ${this.failedTests}`));
+    if (this.skippedTests > 0) statusParts.push(pc.yellow(`\u2298 ${this.skippedTests}`));
+    if (statusParts.length > 0) {
+      lines.push(statusParts.join(" "));
+    }
+    if (this.runningSteps.size > 0) {
+      lines.push("");
+      lines.push(pc.dim("Running:"));
+      const runningStepsArray = Array.from(this.runningSteps.values());
+      runningStepsArray.slice(0, 5).forEach((step) => {
+        const indent = step.parentId ? "    " : "  ";
+        const icon = step.level === "major" ? "\u25B6" : "\u25B8";
+        const levelBadge = step.level === "major" ? pc.blue("[MAJOR]") : pc.dim("[minor]");
+        const elapsed = Date.now() - step.startTime;
+        lines.push(`${indent}${icon} ${levelBadge} ${step.title} ${pc.dim(`(${elapsed}ms)`)}`);
+      });
+      if (runningStepsArray.length > 5) {
+        lines.push(pc.dim(`  ... and ${runningStepsArray.length - 5} more`));
+      }
+    }
+    logUpdate(lines.join("\n"));
+  }
+  /**
+   * Clear progressive update
+   */
+  clearUpdate() {
+    if (this.useProgressiveMode) {
+      logUpdate.clear();
+    }
+  }
+  /**
+   * Print failed test details with progressive MAJOR step display
+   */
+  printFailedTest(test2) {
+    console.log(pc.red(`\u2717 ${test2.title}`));
+    console.log("");
+    const majorSteps = test2.steps.filter((s) => s.level === "major" && !s.parentId);
+    if (majorSteps.length > 0) {
+      majorSteps.forEach((majorStep, index) => {
+        const stepNumber = index + 1;
+        if (majorStep.status === "passed") {
+          const duration = majorStep.duration ? pc.dim(` (${majorStep.duration}ms)`) : "";
+          const successMsg = majorStep.successMessage ? pc.dim(` - ${majorStep.successMessage}`) : "";
+          console.log(pc.green(`  ${stepNumber}. \u2713 [MAJOR] ${majorStep.title}${successMsg}${duration}`));
+        } else if (majorStep.status === "failed") {
+          console.log(pc.red(`  ${stepNumber}. \u2717 [MAJOR] ${majorStep.title}`));
+          const minorSteps = test2.steps.filter((s) => s.parentId === majorStep.id);
+          if (minorSteps.length > 0) {
+            minorSteps.forEach((minorStep, minorIndex) => {
+              const minorNumber = minorIndex + 1;
+              const duration = minorStep.duration ? pc.dim(` (${minorStep.duration}ms)`) : "";
+              if (minorStep.status === "passed") {
+                console.log(pc.green(`      ${minorNumber}. \u2713 [minor] ${minorStep.title}${duration}`));
+              } else if (minorStep.status === "failed") {
+                console.log(pc.red(`      ${minorNumber}. \u2717 [minor] ${minorStep.title}${duration}`));
+                if (minorStep.error) {
+                  console.log(pc.dim(`         ${minorStep.error.message}`));
+                }
+              } else {
+                console.log(pc.dim(`      ${minorNumber}. \u2298 [minor] ${minorStep.title}`));
+              }
+            });
+          }
+          if (majorStep.error) {
+            console.log("");
+            console.log(pc.red(`  Error: ${majorStep.error.message}`));
+          }
+        } else if (majorStep.status === "skipped") {
+          console.log(pc.yellow(`  ${stepNumber}. \u2298 [MAJOR] ${majorStep.title} (skipped)`));
+        }
+      });
+    }
+    if (test2.error) {
+      console.log("");
+      console.log(pc.red(`  Error Message: ${test2.error.message}`));
+      if (test2.error.stack) {
+        console.log("");
+        console.log(pc.dim("  Stack Trace:"));
+        const stackLines = test2.error.stack.split("\n").slice(0, 5);
+        stackLines.forEach((line) => {
+          console.log(pc.dim(`    ${line}`));
+        });
+      }
+      if (test2.error.location) {
+        console.log(pc.dim(`  Location: ${test2.error.location}`));
+      }
+    }
+    if (test2.consoleErrors && test2.consoleErrors.length > 0) {
+      console.log("");
+      console.log(pc.yellow(`  Browser Console Errors (${test2.consoleErrors.length}):`));
+      test2.consoleErrors.forEach((consoleError, index) => {
+        console.log(pc.yellow(`    ${index + 1}. [${consoleError.type}] ${consoleError.message}`));
+        if (consoleError.location) {
+          console.log(pc.dim(`       at ${consoleError.location}`));
+        }
+      });
+    }
+    console.log("");
+  }
+};
+
+// src/formatters/AIFormatter.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var AIFormatter = class {
+  config;
+  outputPath;
+  constructor(config, outputPath) {
+    this.config = config;
+    this.outputPath = outputPath;
+  }
+  async write(allTests, _result) {
+    const markdown = this.generateMarkdown(allTests, _result);
+    try {
+      await mkdir(dirname(this.outputPath), { recursive: true });
+      await writeFile(this.outputPath, markdown, "utf-8");
+    } catch (error) {
+      console.error(`Failed to write AI summary: ${error}`);
+    }
+  }
+  generateMarkdown(allTests, _result) {
+    const passed = allTests.filter((t) => t.status === "passed").length;
+    const failed = allTests.filter((t) => t.status === "failed").length;
+    const skipped = allTests.filter((t) => t.status === "skipped").length;
+    const totalDuration = allTests.reduce((sum, t) => sum + (t.duration || 0), 0);
+    const overallStatus = failed > 0 ? "\u274C FAILED" : "\u2705 PASSED";
+    let md = `# Test Results
+
+`;
+    md += `**Status**: ${overallStatus} (${passed}/${allTests.length} tests passed)
+`;
+    md += `**Duration**: ${(totalDuration / 1e3).toFixed(2)}s
+`;
+    md += `**Date**: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+`;
+    md += `## Summary
+
+`;
+    md += `- \u2705 Passed: ${passed}
+`;
+    md += `- \u274C Failed: ${failed}
+`;
+    md += `- \u2298 Skipped: ${skipped}
+`;
+    md += `- \u{1F4CA} Total: ${allTests.length}
+
+`;
+    const failedTests = allTests.filter((t) => t.status === "failed");
+    if (failedTests.length > 0) {
+      md += `## \u274C Failed Tests
+
+`;
+      failedTests.forEach((test2) => {
+        md += `### ${test2.title}
+
+`;
+        md += `**File**: \`${test2.file}\`
+`;
+        md += `**Duration**: ${test2.duration}ms
+
+`;
+        if (test2.error) {
+          md += `**Error**: ${test2.error.message}
+
+`;
+          if (test2.error.location) {
+            md += `**Location**: \`${test2.error.location}\`
+
+`;
+          }
+        }
+        if (test2.steps.length > 0) {
+          md += `**Steps Executed**:
+
+`;
+          test2.steps.forEach((step, index) => {
+            const icon = step.status === "passed" ? "\u2705" : step.status === "failed" ? "\u274C" : "\u2298";
+            const level = step.level === "major" ? "**MAJOR**" : "minor";
+            const duration = step.duration ? ` (${step.duration}ms)` : "";
+            md += `${index + 1}. ${icon} [${level}] ${step.title}${duration}
+`;
+            if (step.status === "failed" && step.error) {
+              md += `   - Error: ${step.error.message}
+`;
+            }
+          });
+          md += `
+`;
+        }
+        if (test2.consoleErrors && test2.consoleErrors.length > 0) {
+          md += `**Browser Console Errors** (${test2.consoleErrors.length}):
+
+`;
+          test2.consoleErrors.forEach((consoleError, index) => {
+            md += `${index + 1}. **[${consoleError.type}]** ${consoleError.message}
+`;
+            if (consoleError.location) {
+              md += `   - Location: \`${consoleError.location}\`
+`;
+            }
+          });
+          md += `
+`;
+        }
+        if (test2.attachments.length > 0) {
+          md += `**Artifacts**:
+
+`;
+          test2.attachments.forEach((att) => {
+            if (att.path) {
+              md += `- ${att.name}: \`${att.path}\`
+`;
+            }
+          });
+          md += `
+`;
+        }
+        md += `---
+
+`;
+      });
+    }
+    if (this.config.compression.passedTests !== "hide") {
+      const passedTests = allTests.filter((t) => t.status === "passed");
+      if (passedTests.length > 0) {
+        md += `## \u2705 Passed Tests
+
+`;
+        if (this.config.compression.passedTests === "summary") {
+          md += `All ${passedTests.length} test(s) passed:
+
+`;
+          passedTests.forEach((test2) => {
+            md += `- ${test2.title} (${test2.duration}ms)
+`;
+          });
+          md += `
+`;
+        } else {
+          passedTests.forEach((test2) => {
+            md += `### ${test2.title}
+
+`;
+            md += `**Duration**: ${test2.duration}ms
+
+`;
+            if (test2.steps.length > 0) {
+              md += `**Steps**:
+
+`;
+              test2.steps.forEach((step, index) => {
+                md += `${index + 1}. \u2705 ${step.title} (${step.duration}ms)
+`;
+              });
+            }
+            md += `
+`;
+          });
+        }
+      }
+    }
+    const skippedTests = allTests.filter((t) => t.status === "skipped");
+    if (skippedTests.length > 0) {
+      md += `## \u2298 Skipped Tests
+
+`;
+      skippedTests.forEach((test2) => {
+        md += `- ${test2.title}
+`;
+      });
+      md += `
+`;
+    }
+    md += `---
+
+`;
+    md += `*Generated by [fair-playwright](https://github.com/baranaytas/fair-playwright)*
+`;
+    return md;
+  }
+};
+
+// src/formatters/JSONFormatter.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var JSONFormatter = class {
+  outputPath;
+  constructor(_config, outputPath) {
+    this.outputPath = outputPath;
+  }
+  async write(allTests, _result) {
+    const passed = allTests.filter((t) => t.status === "passed").length;
+    const failed = allTests.filter((t) => t.status === "failed").length;
+    const skipped = allTests.filter((t) => t.status === "skipped").length;
+    const totalDuration = allTests.reduce((sum, t) => sum + (t.duration || 0), 0);
+    const output = {
+      status: failed > 0 ? "failed" : "passed",
+      summary: {
+        total: allTests.length,
+        passed,
+        failed,
+        skipped,
+        duration: totalDuration
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      tests: allTests.map((test2) => ({
+        id: test2.id,
+        title: test2.title,
+        file: test2.file,
+        status: test2.status,
+        duration: test2.duration,
+        startTime: test2.startTime,
+        endTime: test2.endTime,
+        error: test2.error ? {
+          message: test2.error.message,
+          stack: test2.error.stack,
+          location: test2.error.location
+        } : void 0,
+        steps: test2.steps.map((step) => ({
+          id: step.id,
+          title: step.title,
+          level: step.level,
+          status: step.status,
+          duration: step.duration,
+          error: step.error ? {
+            message: step.error.message,
+            stack: step.error.stack
+          } : void 0
+        })),
+        attachments: test2.attachments
+      }))
+    };
+    try {
+      await mkdir2(dirname2(this.outputPath), { recursive: true });
+      await writeFile2(this.outputPath, JSON.stringify(output, null, 2), "utf-8");
+    } catch (error) {
+      console.error(`Failed to write JSON output: ${error}`);
+    }
+  }
+};
+
+// src/reporter/FairReporter.ts
+var FairReporter = class {
+  config;
+  stepTracker;
+  consoleFormatter;
+  aiFormatter;
+  jsonFormatter;
+  stepIdMap = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      mode: config?.mode ?? "progressive",
+      aiOptimized: config?.aiOptimized ?? true,
+      output: {
+        console: config?.output?.console ?? true,
+        ai: config?.output?.ai ?? false,
+        json: config?.output?.json ?? false
+      },
+      stepClassification: {
+        durationThreshold: config?.stepClassification?.durationThreshold ?? 1e3,
+        autoDetect: config?.stepClassification?.autoDetect ?? true
+      },
+      progressive: {
+        clearCompleted: config?.progressive?.clearCompleted ?? true,
+        updateInterval: config?.progressive?.updateInterval ?? 100
+      },
+      compression: {
+        passedTests: config?.compression?.passedTests ?? "summary",
+        failureContext: {
+          steps: config?.compression?.failureContext?.steps ?? 3,
+          screenshot: config?.compression?.failureContext?.screenshot ?? true,
+          trace: config?.compression?.failureContext?.trace ?? true,
+          logs: config?.compression?.failureContext?.logs ?? true
+        }
+      }
+    };
+    this.stepTracker = new StepTracker({
+      durationThreshold: this.config.stepClassification.durationThreshold,
+      autoDetect: this.config.stepClassification.autoDetect
+    });
+    if (this.config.output.console) {
+      this.consoleFormatter = new ConsoleFormatter(this.config);
+    }
+    if (this.config.output.ai) {
+      const outputPath = typeof this.config.output.ai === "string" ? this.config.output.ai : "./test-results/ai-summary.md";
+      this.aiFormatter = new AIFormatter(this.config, outputPath);
+    }
+    if (this.config.output.json) {
+      const outputPath = typeof this.config.output.json === "string" ? this.config.output.json : "./test-results/results.json";
+      this.jsonFormatter = new JSONFormatter(this.config, outputPath);
+    }
+  }
+  /**
+   * Called once before running tests
+   */
+  onBegin(_config, suite) {
+    const totalTests = suite.allTests().length;
+    if (this.consoleFormatter) {
+      this.consoleFormatter.onBegin(totalTests);
+    }
+  }
+  /**
+   * Called when a test begins
+   */
+  onTestBegin(test2, result) {
+    this.stepTracker.startTest(test2, result);
+    if (this.consoleFormatter) {
+      this.consoleFormatter.onTestBegin(test2);
+    }
+  }
+  /**
+   * Called when a test step begins
+   */
+  onStepBegin(test2, result, step) {
+    let parentStepId;
+    if (step.parent) {
+      parentStepId = this.stepIdMap.get(step.parent);
+    }
+    const stepId = this.stepTracker.startStep(test2, result, step, parentStepId);
+    this.stepIdMap.set(step, stepId);
+    if (this.consoleFormatter) {
+      const stepMetadata = this.stepTracker.getStep(stepId);
+      if (stepMetadata) {
+        this.consoleFormatter.onStepBegin(stepMetadata);
+      }
+    }
+  }
+  /**
+   * Called when a test step ends
+   */
+  onStepEnd(test2, result, step) {
+    const stepId = this.stepIdMap.get(step);
+    if (!stepId) return;
+    this.stepTracker.endStep(test2, result, step, stepId);
+    if (this.consoleFormatter) {
+      const stepMetadata = this.stepTracker.getStep(stepId);
+      if (stepMetadata) {
+        this.consoleFormatter.onStepEnd(stepMetadata);
+      }
+    }
+  }
+  /**
+   * Called when a test ends
+   */
+  onTestEnd(test2, result) {
+    this.stepTracker.endTest(test2, result);
+    if (this.consoleFormatter) {
+      const testId = `${test2.location.file}::${test2.title}`;
+      const testMetadata = this.stepTracker.getTest(testId);
+      if (testMetadata) {
+        this.consoleFormatter.onTestEnd(testMetadata);
+      }
+    }
+  }
+  /**
+   * Called once after all tests have finished
+   */
+  async onEnd(result) {
+    const allTests = this.stepTracker.getAllTests();
+    if (this.consoleFormatter) {
+      this.consoleFormatter.onEnd(allTests, result);
+    }
+    if (this.aiFormatter) {
+      await this.aiFormatter.write(allTests, result);
+    }
+    if (this.jsonFormatter) {
+      await this.jsonFormatter.write(allTests, result);
+    }
+    this.stepIdMap.clear();
+  }
+  /**
+   * Optional: Called on error
+   */
+  onError(error) {
+    if (this.consoleFormatter) {
+      this.consoleFormatter.onError(error);
+    }
+  }
+};
+
+// src/e2e.ts
+import { test } from "@playwright/test";
+var E2EHelperImpl = class {
+  /**
+   * Execute a major step
+   * Supports both inline and declarative modes
+   */
+  async major(title, actionOrOptions, options) {
+    if (typeof actionOrOptions === "object" && "steps" in actionOrOptions) {
+      return this.majorDeclarative(title, actionOrOptions);
+    }
+    if (typeof actionOrOptions === "function") {
+      return this.majorInline(title, actionOrOptions, options);
+    }
+    throw new Error("Invalid arguments for e2e.major()");
+  }
+  /**
+   * Execute a minor step (inline mode only)
+   */
+  async minor(title, action, options) {
+    const stepTitle = this.formatStepTitle(title, "minor", options);
+    return test.step(stepTitle, async () => {
+      try {
+        await action();
+      } catch (error) {
+        if (options?.failure) {
+          const enhancedError = new Error(`${options.failure}: ${error.message}`);
+          enhancedError.stack = error.stack;
+          throw enhancedError;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Inline mode for major steps
+   */
+  async majorInline(title, action, options) {
+    const stepTitle = this.formatStepTitle(title, "major", options);
+    return test.step(stepTitle, async () => {
+      try {
+        await action();
+      } catch (error) {
+        if (options?.failure) {
+          const enhancedError = new Error(`${options.failure}: ${error.message}`);
+          enhancedError.stack = error.stack;
+          throw enhancedError;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Declarative mode for major steps with child steps
+   */
+  async majorDeclarative(title, options) {
+    const stepTitle = this.formatStepTitle(title, "major", options);
+    return test.step(stepTitle, async () => {
+      if (!options.steps || options.steps.length === 0) {
+        return;
+      }
+      for (const childStep of options.steps) {
+        const childTitle = this.formatStepTitle(childStep.title, "minor", childStep);
+        await test.step(childTitle, async () => {
+          try {
+            await childStep.action();
+          } catch (error) {
+            if (childStep.failure) {
+              const enhancedError = new Error(
+                `${childStep.failure}: ${error.message}`
+              );
+              enhancedError.stack = error.stack;
+              throw enhancedError;
+            }
+            throw error;
+          }
+        });
+      }
+    });
+  }
+  /**
+   * Format step title with metadata for the reporter
+   * The reporter will parse this metadata to classify steps
+   */
+  formatStepTitle(title, level, _options) {
+    const prefix = level === "major" ? "[MAJOR]" : "[MINOR]";
+    return `${prefix} ${title}`;
+  }
+};
+var e2e = new E2EHelperImpl();
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { readFile } from "fs/promises";
+import { existsSync } from "fs";
+var MCPServer = class {
+  server;
+  config;
+  testResults = [];
+  constructor(config = {}) {
+    this.config = {
+      resultsPath: config.resultsPath ?? "./test-results/results.json",
+      name: config.name ?? "fair-playwright",
+      version: config.version ?? "0.1.0",
+      verbose: config.verbose ?? false
+    };
+    this.server = new Server(
+      {
+        name: this.config.name,
+        version: this.config.version
+      },
+      {
+        capabilities: {
+          resources: {},
+          tools: {}
+        }
+      }
+    );
+    this.setupHandlers();
+  }
+  /**
+   * Setup MCP protocol handlers
+   */
+  setupHandlers() {
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+      resources: [
+        {
+          uri: "fair-playwright://test-results",
+          name: "Test Results",
+          description: "Current Playwright test execution results",
+          mimeType: "application/json"
+        },
+        {
+          uri: "fair-playwright://test-summary",
+          name: "Test Summary",
+          description: "AI-optimized summary of test results",
+          mimeType: "text/markdown"
+        },
+        {
+          uri: "fair-playwright://failures",
+          name: "Failed Tests",
+          description: "Detailed information about failed tests",
+          mimeType: "text/markdown"
+        }
+      ]
+    }));
+    this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+      const uri = request.params.uri.toString();
+      if (this.testResults.length === 0) {
+        await this.loadTestResults();
+      }
+      switch (uri) {
+        case "fair-playwright://test-results":
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "application/json",
+                text: JSON.stringify(this.getTestResults(), null, 2)
+              }
+            ]
+          };
+        case "fair-playwright://test-summary":
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "text/markdown",
+                text: this.getTestSummary()
+              }
+            ]
+          };
+        case "fair-playwright://failures":
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: "text/markdown",
+                text: this.getFailureSummary()
+              }
+            ]
+          };
+        default:
+          throw new Error(`Unknown resource: ${uri}`);
+      }
+    });
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "get_test_results",
+          description: "Get complete test execution results with all details",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "get_failure_summary",
+          description: "Get AI-optimized summary of failed tests",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "query_test",
+          description: "Search for a specific test by title",
+          inputSchema: {
+            type: "object",
+            properties: {
+              title: {
+                type: "string",
+                description: "Test title to search for (case-insensitive partial match)"
+              }
+            },
+            required: ["title"]
+          }
+        },
+        {
+          name: "get_tests_by_status",
+          description: "Get all tests filtered by status",
+          inputSchema: {
+            type: "object",
+            properties: {
+              status: {
+                type: "string",
+                enum: ["passed", "failed", "skipped"],
+                description: "Test status to filter by"
+              }
+            },
+            required: ["status"]
+          }
+        },
+        {
+          name: "get_step_details",
+          description: "Get detailed information about test steps",
+          inputSchema: {
+            type: "object",
+            properties: {
+              testTitle: {
+                type: "string",
+                description: "Title of the test to get step details for"
+              },
+              level: {
+                type: "string",
+                enum: ["major", "minor", "all"],
+                description: "Filter steps by level (default: all)"
+              }
+            },
+            required: ["testTitle"]
+          }
+        }
+      ]
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      if (this.testResults.length === 0) {
+        await this.loadTestResults();
+      }
+      switch (name) {
+        case "get_test_results":
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(this.getTestResults(), null, 2)
+              }
+            ]
+          };
+        case "get_failure_summary":
+          return {
+            content: [
+              {
+                type: "text",
+                text: this.getFailureSummary()
+              }
+            ]
+          };
+        case "query_test": {
+          const title = args.title;
+          const test2 = this.queryTest(title);
+          return {
+            content: [
+              {
+                type: "text",
+                text: test2 ? JSON.stringify(test2, null, 2) : `No test found matching: ${title}`
+              }
+            ]
+          };
+        }
+        case "get_tests_by_status": {
+          const status = args.status;
+          const tests = this.getTestsByStatus(status);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(tests, null, 2)
+              }
+            ]
+          };
+        }
+        case "get_step_details": {
+          const { testTitle, level } = args;
+          const test2 = this.queryTest(testTitle);
+          if (!test2) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No test found matching: ${testTitle}`
+                }
+              ]
+            };
+          }
+          let steps = test2.steps;
+          if (level && level !== "all") {
+            steps = steps.filter((s) => s.level === level);
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(steps, null, 2)
+              }
+            ]
+          };
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    });
+  }
+  /**
+   * Load test results from JSON file
+   */
+  async loadTestResults() {
+    try {
+      if (!existsSync(this.config.resultsPath)) {
+        if (this.config.verbose) {
+          console.error(`[MCP] Results file not found: ${this.config.resultsPath}`);
+        }
+        return;
+      }
+      const content = await readFile(this.config.resultsPath, "utf-8");
+      const data = JSON.parse(content);
+      this.testResults = Array.isArray(data) ? data : data.tests || [];
+      if (this.config.verbose) {
+        console.error(`[MCP] Loaded ${this.testResults.length} test results`);
+      }
+    } catch (error) {
+      if (this.config.verbose) {
+        console.error(`[MCP] Error loading test results:`, error);
+      }
+    }
+  }
+  /**
+   * Start the MCP server with stdio transport
+   */
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    if (this.config.verbose) {
+      console.error("[MCP] Server started and connected via stdio");
+    }
+  }
+  /**
+   * Get current test results
+   */
+  getTestResults() {
+    const passed = this.testResults.filter((t) => t.status === "passed").length;
+    const failed = this.testResults.filter((t) => t.status === "failed").length;
+    const skipped = this.testResults.filter((t) => t.status === "skipped").length;
+    const totalDuration = this.testResults.reduce((sum, t) => sum + (t.duration || 0), 0);
+    return {
+      status: failed > 0 ? "failed" : this.testResults.length > 0 ? "passed" : "unknown",
+      summary: {
+        total: this.testResults.length,
+        passed,
+        failed,
+        skipped,
+        duration: totalDuration
+      },
+      tests: this.testResults
+    };
+  }
+  /**
+   * Get test summary in markdown format
+   */
+  getTestSummary() {
+    const results = this.getTestResults();
+    const { summary } = results;
+    let md = "# Playwright Test Results\n\n";
+    md += `**Status**: ${results.status === "failed" ? "\u274C FAILED" : "\u2705 PASSED"}
+`;
+    md += `**Total Tests**: ${summary.total}
+`;
+    md += `**Duration**: ${(summary.duration / 1e3).toFixed(2)}s
+
+`;
+    md += "## Summary\n\n";
+    md += `- \u2705 Passed: ${summary.passed}
+`;
+    md += `- \u274C Failed: ${summary.failed}
+`;
+    md += `- \u2298 Skipped: ${summary.skipped}
+
+`;
+    if (summary.failed > 0) {
+      md += "## Failed Tests\n\n";
+      const failedTests = this.testResults.filter((t) => t.status === "failed");
+      failedTests.forEach((test2, index) => {
+        md += `${index + 1}. **${test2.title}** (${test2.duration}ms)
+`;
+        md += `   - File: \`${test2.file}\`
+`;
+        if (test2.error) {
+          md += `   - Error: ${test2.error.message}
+`;
+        }
+      });
+    }
+    return md;
+  }
+  /**
+   * Get AI-optimized summary of failures
+   */
+  getFailureSummary() {
+    const failedTests = this.testResults.filter((t) => t.status === "failed");
+    if (failedTests.length === 0) {
+      return "# No Test Failures\n\nAll tests passed! \u2705";
+    }
+    let summary = `# Test Failures Summary
+
+`;
+    summary += `${failedTests.length} test(s) failed:
+
+`;
+    failedTests.forEach((test2, index) => {
+      summary += `## ${index + 1}. ${test2.title}
+
+`;
+      summary += `**File**: \`${test2.file}\`
+`;
+      summary += `**Duration**: ${test2.duration}ms
+
+`;
+      if (test2.error) {
+        summary += `**Error**: ${test2.error.message}
+
+`;
+        if (test2.error.location) {
+          summary += `**Location**: \`${test2.error.location}\`
+
+`;
+        }
+      }
+      const majorSteps = test2.steps.filter((s) => s.level === "major" && !s.parentId);
+      if (majorSteps.length > 0) {
+        summary += `**Test Flow**:
+
+`;
+        majorSteps.forEach((majorStep, idx) => {
+          const icon = majorStep.status === "passed" ? "\u2705" : "\u274C";
+          summary += `${idx + 1}. ${icon} [MAJOR] ${majorStep.title}
+`;
+          if (majorStep.status === "failed") {
+            const minorSteps = test2.steps.filter((s) => s.parentId === majorStep.id);
+            minorSteps.forEach((minorStep) => {
+              const minorIcon = minorStep.status === "passed" ? "\u2705" : "\u274C";
+              summary += `   - ${minorIcon} [minor] ${minorStep.title}
+`;
+              if (minorStep.error) {
+                summary += `     Error: ${minorStep.error.message}
+`;
+              }
+            });
+          }
+        });
+        summary += `
+`;
+      }
+      if (test2.consoleErrors && test2.consoleErrors.length > 0) {
+        summary += `**Browser Console Errors** (${test2.consoleErrors.length}):
+
+`;
+        test2.consoleErrors.forEach((consoleError, idx) => {
+          summary += `${idx + 1}. [${consoleError.type}] ${consoleError.message}
+`;
+        });
+        summary += `
+`;
+      }
+      summary += `---
+
+`;
+    });
+    return summary;
+  }
+  /**
+   * Query specific test by title
+   */
+  queryTest(title) {
+    const test2 = this.testResults.find(
+      (t) => t.title.toLowerCase().includes(title.toLowerCase())
+    );
+    return test2 || null;
+  }
+  /**
+   * Get tests by status
+   */
+  getTestsByStatus(status) {
+    return this.testResults.filter((t) => t.status === status);
+  }
+};
+async function createMCPServer(config) {
+  const server = new MCPServer(config);
+  await server.start();
+  return server;
+}
+export {
+  FairReporter,
+  MCPServer,
+  createMCPServer,
+  FairReporter as default,
+  e2e
+};