@sentinelqa/playwright-reporter 0.1.25 → 0.1.26

package/README.md

@@ -36,6 +36,14 @@ so you can quickly understand what failed.
 
 ## Quick Start
 
+`withSentinel()` is the default setup for everyone:
+
+- best for free and local users
+- zero-friction setup
+- local HTML report works exactly as today
+- cloud upload works when configured
+- AI summaries use trace and reporter evidence, but are less precise than live page capture
+
 Install:
 
 ```bash
@@ -122,6 +130,43 @@ npx playwright test
   - screenshot: `only-on-failure`
   - video: `retain-on-failure`
 
+## Recommended Cloud Setup
+
+If you use Sentinel Cloud and want the best AI summaries and fix suggestions, keep `withSentinel()` in your Playwright config and add the live capture fixture.
+
+Why:
+
+- `withSentinel()` alone works from reporter and trace data
+- a Playwright reporter does not get the live `page` fixture
+- the live capture fixture lets Sentinel collect richer DOM and code context at the exact failure moment
+- this is required for the highest-quality DOM-aware patches
+
+Create one shared test wrapper:
+
+```ts
+// tests/test.ts
+import { test as base, expect } from "@playwright/test";
+import { attachSentinelFailureCapture } from "@sentinelqa/playwright-reporter/fixtures";
+
+export const test = attachSentinelFailureCapture(base);
+export { expect };
+```
+
+Then import from that file in your specs instead of `@playwright/test`:
+
+```ts
+import { test, expect } from "./test";
+```
+
+Use this cloud setup when you want:
+
+- best AI summaries
+- best fix suggestions
+- richer DOM-aware diagnosis
+- more reliable code patches grounded in real page state
+
+Free and local-only users do not need this. The standard `withSentinel()` setup remains the simplest path and continues to generate the local report the same way as before.
+
 ## Options
 
 ```ts

package/dist/fixtures.d.ts

@@ -0,0 +1 @@
+export declare function attachSentinelFailureCapture(baseTest: any): any;

package/dist/fixtures.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachSentinelFailureCapture = attachSentinelFailureCapture;
+const { sentinelCaptureFailureContext } = require("@sentinelqa/uploader/playwright");
+function attachSentinelFailureCapture(baseTest) {
+    return baseTest.extend({
+        _sentinelFailureCapture: [
+            async ({ page }, use, testInfo) => {
+                await use();
+                await sentinelCaptureFailureContext(page, testInfo).catch(() => null);
+            },
+            { auto: true }
+        ]
+    });
+}

package/dist/index.d.ts

@@ -29,4 +29,4 @@ export type SentinelPlaywrightOptions = {
 };
 export declare function withSentinel(config: PlaywrightConfig, options?: SentinelPlaywrightOptions): PlaywrightConfig;
 export declare function resolveSentinelPaths(config: PlaywrightConfig, options?: SentinelPlaywrightOptions): SentinelResolvedPaths;
-export {};
+export { attachSentinelFailureCapture } from "./fixtures";

package/dist/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachSentinelFailureCapture = void 0;
 exports.withSentinel = withSentinel;
 exports.resolveSentinelPaths = resolveSentinelPaths;
 const path_1 = __importDefault(require("path"));
@@ -142,3 +143,5 @@ function resolveSentinelPaths(config, options = {}) {
         artifactDirs
     };
 }
+var fixtures_1 = require("./fixtures");
+Object.defineProperty(exports, "attachSentinelFailureCapture", { enumerable: true, get: function () { return fixtures_1.attachSentinelFailureCapture; } });

package/dist/quickDiagnosis.d.ts

@@ -0,0 +1,5 @@
+type QuickDiagnosis = {
+    lines: string[];
+};
+export declare const buildQuickDiagnosis: (playwrightJsonPath: string) => QuickDiagnosis | null;
+export {};

package/dist/quickDiagnosis.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildQuickDiagnosis = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
+const toMessage = (result) => {
+    const direct = result.error?.message ||
+        result.error?.stack ||
+        result.error?.value ||
+        null;
+    if (direct)
+        return stripAnsi(String(direct));
+    const first = result.errors?.find(Boolean);
+    return first ? stripAnsi(String(first.message || first.stack || first.value || "")) : "";
+};
+const classifySignal = (message) => {
+    const lower = message.toLowerCase();
+    if (/timeout|timed out|waiting for/.test(lower))
+        return "timeout";
+    if (/expected substring|expected string|received string|tohavetext|tocontaintext/.test(lower)) {
+        return "assertion_mismatch";
+    }
+    if (/resolved to 0 elements|locator.*not found|never appeared|strict mode violation/.test(lower)) {
+        return "locator_not_found";
+    }
+    if (/not visible|not enabled|not stable|intercepts pointer events|not actionable/.test(lower)) {
+        return "actionability";
+    }
+    if (/status\s*[45]\d{2}|net::|failed to fetch|network|request failed/.test(lower)) {
+        return "network";
+    }
+    if (/typeerror|referenceerror|syntaxerror|unhandled/.test(lower))
+        return "runtime";
+    return "unknown";
+};
+const signalSummary = (signal) => {
+    switch (signal) {
+        case "timeout":
+            return "timeout while waiting for UI or network conditions";
+        case "assertion_mismatch":
+            return "assertion mismatch between expected and rendered UI state";
+        case "locator_not_found":
+            return "missing or changed locator";
+        case "actionability":
+            return "target element was not actionable";
+        case "network":
+            return "network or API failure";
+        case "runtime":
+            return "frontend runtime error";
+        default:
+            return "failure signal could not be classified cleanly";
+    }
+};
+const flattenFailedCases = (node, titlePath = []) => {
+    const currentTitlePath = node.title ? [...titlePath, node.title] : titlePath;
+    const failedCases = [];
+    for (const test of node.tests || []) {
+        const title = [...currentTitlePath, test.title || "Unnamed test"].join(" > ");
+        for (const result of test.results || []) {
+            if (!["failed", "timedOut", "interrupted"].includes(result.status || ""))
+                continue;
+            const message = toMessage(result);
+            failedCases.push({
+                title,
+                message,
+                signal: classifySignal(message)
+            });
+        }
+    }
+    for (const child of node.specs || []) {
+        failedCases.push(...flattenFailedCases(child, currentTitlePath));
+    }
+    for (const child of node.suites || []) {
+        failedCases.push(...flattenFailedCases(child, currentTitlePath));
+    }
+    return failedCases;
+};
+const shortenTitle = (value) => {
+    const parts = value.split(" > ").filter(Boolean);
+    return parts[parts.length - 1] || value;
+};
+const buildQuickDiagnosis = (playwrightJsonPath) => {
+    if (!node_fs_1.default.existsSync(playwrightJsonPath))
+        return null;
+    try {
+        const raw = node_fs_1.default.readFileSync(playwrightJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const failedCases = flattenFailedCases(parsed);
+        if (!failedCases.length)
+            return null;
+        if (failedCases.length === 1) {
+            const failed = failedCases[0];
+            return {
+                lines: [
+                    `Test "${shortenTitle(failed.title)}" likely failed due to ${signalSummary(failed.signal)}.`
+                ]
+            };
+        }
+        const counts = new Map();
+        for (const failed of failedCases) {
+            counts.set(failed.signal, (counts.get(failed.signal) || 0) + 1);
+        }
+        const topSignal = Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
+        return {
+            lines: [
+                `${failedCases.length} tests failed.`,
+                `Most common signal: ${signalSummary(topSignal)}.`
+            ]
+        };
+    }
+    catch {
+        return null;
+    }
+};
+exports.buildQuickDiagnosis = buildQuickDiagnosis;

package/dist/reporter.d.ts

@@ -15,7 +15,7 @@ declare class SentinelReporter {
     private options;
     constructor(options: ReporterOptions);
     onBegin(config: any, suite: any): void;
-    onTestEnd(_test: any, result: any): void;
+    onTestEnd(test: any, result: any): Promise<void>;
     private printLocalReport;
     onEnd(): Promise<void>;
 }

package/dist/reporter.js

@@ -7,6 +7,8 @@ const url_1 = require("url");
 const node_1 = require("@sentinelqa/uploader/node");
 const env_1 = require("./env");
 const localReport_1 = require("./localReport");
+const quickDiagnosis_1 = require("./quickDiagnosis");
+const { sentinelCaptureFailureContextFromReporter } = require("@sentinelqa/uploader/playwright");
 const pluralize = (count, singular, plural) => {
     return count === 1 ? singular : plural;
 };
@@ -49,10 +51,11 @@ class SentinelReporter {
             console.log("");
         }
     }
-    onTestEnd(_test, result) {
+    async onTestEnd(test, result) {
         if (!result)
             return;
         if (["failed", "timedOut", "interrupted"].includes(result.status)) {
+            await sentinelCaptureFailureContextFromReporter(test, result).catch(() => null);
             this.failedCount += 1;
         }
     }
@@ -74,11 +77,17 @@ class SentinelReporter {
         console.log(bold("Open"));
         console.log(`  ${cyan(openCommand)}`);
         console.log("");
+        const quickDiagnosis = (0, quickDiagnosis_1.buildQuickDiagnosis)(this.options.playwrightJsonPath);
+        if (quickDiagnosis?.lines.length) {
+            console.log(yellow("Quick diagnosis"));
+            for (const line of quickDiagnosis.lines) {
+                console.log(`  ${dim(line)}`);
+            }
+            console.log("");
+        }
         console.log(yellow("Tip"));
-        console.log(`  ${dim("Upload runs to Sentinel Cloud for CI history,")}`);
-        console.log(`  ${dim("shareable debugging links, and AI summaries.")}`);
-        console.log("");
-        console.log(`  ${cyan(formatTerminalLink("https://sentinelqa.com", "https://sentinelqa.com"))}`);
+        console.log(`  ${dim("Want full AI analysis, shareable run links, and CI history?")}`);
+        console.log(`  ${dim("Try Sentinel Cloud Beta free:")} ${cyan(formatTerminalLink("https://sentinelqa.com", "https://sentinelqa.com"))}`);
         console.log("");
         console.log(`  ${magenta("★ If this reporter helped you debug faster,")}`);
         console.log(`  ${dim("consider starring the project:")}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/playwright-reporter",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "private": false,
   "description": "Playwright reporter for CI debugging with optional Sentinel cloud dashboards",
   "license": "MIT",
@@ -32,7 +32,8 @@
   },
   "exports": {
     ".": "./dist/index.js",
-    "./reporter": "./dist/reporter.js"
+    "./reporter": "./dist/reporter.js",
+    "./fixtures": "./dist/fixtures.js"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.40.0"