fair-playwright 1.0.0

package/dist/mcp-cli.js

@@ -0,0 +1,504 @@
+#!/usr/bin/env node
+
+// 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 test = this.queryTest(title);
+          return {
+            content: [
+              {
+                type: "text",
+                text: test ? JSON.stringify(test, 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 test = this.queryTest(testTitle);
+          if (!test) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `No test found matching: ${testTitle}`
+                }
+              ]
+            };
+          }
+          let steps = test.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((test, index) => {
+        md += `${index + 1}. **${test.title}** (${test.duration}ms)
+`;
+        md += `   - File: \`${test.file}\`
+`;
+        if (test.error) {
+          md += `   - Error: ${test.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((test, index) => {
+      summary += `## ${index + 1}. ${test.title}
+
+`;
+      summary += `**File**: \`${test.file}\`
+`;
+      summary += `**Duration**: ${test.duration}ms
+
+`;
+      if (test.error) {
+        summary += `**Error**: ${test.error.message}
+
+`;
+        if (test.error.location) {
+          summary += `**Location**: \`${test.error.location}\`
+
+`;
+        }
+      }
+      const majorSteps = test.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 = test.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 (test.consoleErrors && test.consoleErrors.length > 0) {
+        summary += `**Browser Console Errors** (${test.consoleErrors.length}):
+
+`;
+        test.consoleErrors.forEach((consoleError, idx) => {
+          summary += `${idx + 1}. [${consoleError.type}] ${consoleError.message}
+`;
+        });
+        summary += `
+`;
+      }
+      summary += `---
+
+`;
+    });
+    return summary;
+  }
+  /**
+   * Query specific test by title
+   */
+  queryTest(title) {
+    const test = this.testResults.find(
+      (t) => t.title.toLowerCase().includes(title.toLowerCase())
+    );
+    return test || 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;
+}
+
+// src/mcp/cli.ts
+async function main() {
+  const args = process.argv.slice(2);
+  const config = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        console.log(`
+fair-playwright MCP Server
+
+Usage:
+  npx fair-playwright-mcp [options]
+
+Options:
+  --results-path <path>  Path to test results JSON file
+                         Default: ./test-results/results.json
+  --verbose              Enable verbose logging
+  --help                 Show this help message
+
+Example:
+  npx fair-playwright-mcp --results-path ./custom-results.json
+
+For Claude Desktop integration, add to claude_desktop_config.json:
+{
+  "mcpServers": {
+    "fair-playwright": {
+      "command": "npx",
+      "args": ["fair-playwright-mcp"]
+    }
+  }
+}
+        `);
+        process.exit(0);
+        break;
+      case "--results-path":
+        config.resultsPath = args[++i];
+        break;
+      case "--verbose":
+        config.verbose = true;
+        break;
+      default:
+        console.error(`Unknown option: ${arg}`);
+        console.error(`Run with --help for usage information`);
+        process.exit(1);
+    }
+  }
+  if (process.env.FAIR_PLAYWRIGHT_RESULTS && !config.resultsPath) {
+    config.resultsPath = process.env.FAIR_PLAYWRIGHT_RESULTS;
+  }
+  try {
+    await createMCPServer(config);
+    process.on("SIGINT", () => {
+      if (config.verbose) {
+        console.error("\n[MCP] Shutting down...");
+      }
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "fair-playwright",
+  "version": "1.0.0",
+  "description": "AI-optimized Playwright test reporter with progressive terminal output and hierarchical step management",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "fair-playwright-mcp": "./dist/mcp-cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "test:integration": "npm run build && cd test-project && npm test",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "changeset": "changeset",
+    "release": "changeset publish",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "playwright",
+    "testing",
+    "reporter",
+    "ai",
+    "test-automation",
+    "e2e",
+    "terminal",
+    "progressive",
+    "ai-optimized",
+    "mcp",
+    "model-context-protocol",
+    "llm",
+    "claude"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/baranaytass/fair-playwright.git"
+  },
+  "bugs": {
+    "url": "https://github.com/baranaytass/fair-playwright/issues"
+  },
+  "homepage": "https://github.com/baranaytass/fair-playwright#readme",
+  "author": "Baran Aytas",
+  "license": "MIT",
+  "peerDependencies": {
+    "@playwright/test": ">=1.40.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "log-update": "^6.1.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.27.10",
+    "@playwright/test": "^1.49.1",
+    "@types/node": "^22.10.2",
+    "@typescript-eslint/eslint-plugin": "^8.18.1",
+    "@typescript-eslint/parser": "^8.18.1",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.4.2",
+    "tsup": "^8.3.5",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}