@sentinelqa/playwright-reporter 0.1.45 → 0.1.50

package/dist/terminalSummary.js

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPassingRunSummary = exports.recordReporterHistorySnapshot = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const HISTORY_DIR = node_path_1.default.join(".sentinel", "reporter-history");
+const ensureDir = (dirPath) => {
+    if (!node_fs_1.default.existsSync(dirPath))
+        node_fs_1.default.mkdirSync(dirPath, { recursive: true });
+};
+const readJson = (filePath) => {
+    if (!node_fs_1.default.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+};
+const getCurrentBranch = () => {
+    const fromEnv = process.env.GITHUB_REF_NAME ||
+        process.env.CI_COMMIT_REF_NAME ||
+        process.env.CI_COMMIT_BRANCH ||
+        process.env.BRANCH_NAME ||
+        null;
+    return fromEnv && fromEnv.trim() ? fromEnv.trim() : "main";
+};
+const getCurrentGitSha = () => {
+    const fromEnv = process.env.GITHUB_SHA ||
+        process.env.CI_COMMIT_SHA ||
+        process.env.VERCEL_GIT_COMMIT_SHA ||
+        null;
+    return fromEnv && fromEnv.trim() ? fromEnv.trim() : "unknown";
+};
+const normalizeStatus = (status) => {
+    if (status === "failed" || status === "timedOut" || status === "interrupted")
+        return "failed";
+    if (status === "passed" || status === "flaky")
+        return "passed";
+    return "skipped";
+};
+const formatDuration = (durationMs) => {
+    const totalSeconds = Math.max(0, Math.round(durationMs / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes === 0)
+        return `${seconds}s`;
+    return `${minutes}m ${seconds}s`;
+};
+const formatShortDuration = (durationMs) => {
+    if (durationMs === null || !Number.isFinite(durationMs))
+        return null;
+    if (durationMs < 1000)
+        return `${Math.round(durationMs)}ms`;
+    return `${(durationMs / 1000).toFixed(durationMs >= 10000 ? 0 : 1)}s`;
+};
+const median = (values) => {
+    if (values.length === 0)
+        return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0)
+        return (sorted[mid - 1] + sorted[mid]) / 2;
+    return sorted[mid];
+};
+const medianAbsoluteDeviation = (values) => {
+    const med = median(values);
+    if (med === null)
+        return null;
+    return median(values.map((value) => Math.abs(value - med)));
+};
+const cleanTitlePath = (parts) => {
+    const normalized = parts.map((part) => part.trim()).filter(Boolean);
+    const withoutUnnamed = normalized.filter((part) => part !== "Unnamed test");
+    return withoutUnnamed.length ? withoutUnnamed : normalized;
+};
+const formatHistoryTitle = (value) => {
+    if (!value)
+        return null;
+    return cleanTitlePath(value.split(" > ")).join(" > ") || value;
+};
+const buildMatchKey = (file, projectName, titlePath) => [file || "unknown", projectName || "default", cleanTitlePath(titlePath).join(" > ")].join("::");
+const collectWallDurationMs = (node) => {
+    let minStart = Number.POSITIVE_INFINITY;
+    let maxEnd = 0;
+    const walk = (current) => {
+        if (!current)
+            return;
+        for (const child of current.suites || [])
+            walk(child);
+        for (const child of current.specs || [])
+            walk(child);
+        for (const test of current.tests || []) {
+            for (const result of test.results || []) {
+                if (!result?.startTime || typeof result.duration !== 'number')
+                    continue;
+                const start = Date.parse(result.startTime);
+                if (!Number.isFinite(start))
+                    continue;
+                minStart = Math.min(minStart, start);
+                maxEnd = Math.max(maxEnd, start + result.duration);
+            }
+        }
+    };
+    walk(node);
+    if (!Number.isFinite(minStart) || maxEnd <= minStart)
+        return null;
+    return maxEnd - minStart;
+};
+const collectTests = (node, ancestors = []) => {
+    const currentTitlePath = node.title ? [...ancestors, node.title] : ancestors;
+    const tests = [];
+    for (const child of node.suites || [])
+        tests.push(...collectTests(child, currentTitlePath));
+    for (const child of node.specs || [])
+        tests.push(...collectTests(child, currentTitlePath));
+    const specTests = Array.isArray(node.tests) ? node.tests : [];
+    for (const test of specTests) {
+        const results = Array.isArray(test.results) ? test.results : [];
+        const finalStatus = normalizeStatus(test.results?.[test.results.length - 1]?.status);
+        const finalDurationMs = typeof results[results.length - 1]?.duration === "number" ? results[results.length - 1].duration : 0;
+        let durationMs = finalDurationMs;
+        let retries = 0;
+        for (const result of results) {
+            if (typeof result.retry === "number")
+                retries = Math.max(retries, result.retry);
+        }
+        const titlePath = cleanTitlePath([...currentTitlePath, test.title || "Unnamed test"]);
+        const file = node.file || node.location?.file || test.location?.file || "";
+        const projectName = test.projectName || "";
+        tests.push({
+            matchKey: buildMatchKey(file, projectName, titlePath),
+            title: titlePath.join(" > "),
+            status: finalStatus,
+            durationMs,
+            retries,
+            timeoutMs: typeof test.timeout === "number" ? test.timeout : null
+        });
+    }
+    return tests;
+};
+const buildSnapshot = (playwrightJsonPath) => {
+    const parsed = readJson(playwrightJsonPath);
+    if (!parsed)
+        return null;
+    const tests = collectTests(parsed);
+    const failedTests = tests.filter((test) => test.status === "failed");
+    const passedCount = tests.filter((test) => test.status === "passed").length;
+    const skippedCount = tests.filter((test) => test.status === "skipped").length;
+    return {
+        generatedAt: new Date().toISOString(),
+        branch: getCurrentBranch(),
+        gitSha: getCurrentGitSha(),
+        wallDurationMs: collectWallDurationMs(parsed),
+        totalTests: tests.length,
+        passedCount,
+        failedCount: failedTests.length,
+        skippedCount,
+        retryPassedCount: tests.filter((test) => test.status === "passed" && test.retries > 0).length,
+        failures: failedTests.map((test) => test.title),
+        tests
+    };
+};
+const listSnapshots = (branch) => {
+    const historyDir = node_path_1.default.resolve(process.cwd(), HISTORY_DIR);
+    if (!node_fs_1.default.existsSync(historyDir))
+        return [];
+    return node_fs_1.default
+        .readdirSync(historyDir)
+        .filter((file) => file.endsWith(".json"))
+        .map((file) => readJson(node_path_1.default.join(historyDir, file)))
+        .filter((value) => Boolean(value))
+        .filter((snapshot) => snapshot.branch === branch)
+        .sort((a, b) => b.generatedAt.localeCompare(a.generatedAt));
+};
+const writeSnapshot = (snapshot) => {
+    ensureDir(node_path_1.default.resolve(process.cwd(), HISTORY_DIR));
+    const fileName = `${snapshot.generatedAt.replace(/[:.]/g, "-")}-${snapshot.gitSha}.json`;
+    node_fs_1.default.writeFileSync(node_path_1.default.resolve(process.cwd(), HISTORY_DIR, fileName), JSON.stringify(snapshot, null, 2), "utf8");
+};
+const recordReporterHistorySnapshot = (playwrightJsonPath) => {
+    const snapshot = buildSnapshot(playwrightJsonPath);
+    if (!snapshot)
+        return null;
+    writeSnapshot(snapshot);
+    return snapshot;
+};
+exports.recordReporterHistorySnapshot = recordReporterHistorySnapshot;
+const buildPassingRunSummary = (playwrightJsonPath, options) => {
+    const snapshot = buildSnapshot(playwrightJsonPath);
+    if (!snapshot)
+        return null;
+    const previousRuns = listSnapshots(snapshot.branch);
+    writeSnapshot(snapshot);
+    if (snapshot.failedCount > 0 || snapshot.totalTests === 0 || snapshot.passedCount === 0)
+        return null;
+    let passStreak = 1;
+    let lastFailureRunsAgo = null;
+    for (let i = 0; i < previousRuns.length; i += 1) {
+        const previous = previousRuns[i];
+        if (previous.failedCount === 0) {
+            passStreak += 1;
+            continue;
+        }
+        lastFailureRunsAgo = i + 1;
+        break;
+    }
+    const retryPassedCount = snapshot.retryPassedCount;
+    const durationSamples = new Map();
+    const recentDurationSamples = new Map();
+    const slowPassCounts = new Map();
+    for (const previous of previousRuns.slice(0, 20)) {
+        for (const test of previous.tests || []) {
+            if (test.status !== "passed" || test.durationMs <= 0)
+                continue;
+            const bucket = durationSamples.get(test.matchKey) || [];
+            bucket.push(test.durationMs);
+            durationSamples.set(test.matchKey, bucket);
+            if (durationSamples.get(test.matchKey).length <= 5) {
+                const recentBucket = recentDurationSamples.get(test.matchKey) || [];
+                recentBucket.push(test.durationMs);
+                recentDurationSamples.set(test.matchKey, recentBucket);
+            }
+        }
+    }
+    let slowestRisk = null;
+    const historicalRetryCounts = new Map();
+    const historicalFailureCounts = new Map();
+    for (const previous of previousRuns.slice(0, 10)) {
+        for (const test of previous.tests || []) {
+            if (test.status === "passed" && test.retries > 0) {
+                historicalRetryCounts.set(test.matchKey, (historicalRetryCounts.get(test.matchKey) || 0) + 1);
+            }
+            if (test.status === "failed") {
+                historicalFailureCounts.set(test.matchKey, (historicalFailureCounts.get(test.matchKey) || 0) + 1);
+            }
+            if (test.status === "passed" && test.durationMs > 0) {
+                const all = durationSamples.get(test.matchKey) || [];
+                const historicalMedian = median(all);
+                if (historicalMedian && test.durationMs / historicalMedian >= 1.35) {
+                    slowPassCounts.set(test.matchKey, (slowPassCounts.get(test.matchKey) || 0) + 1);
+                }
+            }
+        }
+    }
+    const nearFailureCandidates = [];
+    for (const test of snapshot.tests) {
+        if (test.status !== "passed" || test.durationMs <= 0)
+            continue;
+        const samples = durationSamples.get(test.matchKey) || [];
+        const med = median(samples);
+        const variability = medianAbsoluteDeviation(samples);
+        const recentMedian = median(recentDurationSamples.get(test.matchKey) || []);
+        const hasReliableMedian = samples.length >= 5 && Boolean(med) && (med || 0) >= 250;
+        const hasReliableRecentMedian = (recentDurationSamples.get(test.matchKey) || []).length >= 3 && Boolean(recentMedian) && Boolean(med) && (med || 0) >= 250;
+        const varianceFloor = Math.max(400, variability ? variability * 3 : 400);
+        const absoluteDelta = hasReliableMedian && med ? test.durationMs - med : null;
+        const ratio = hasReliableMedian && med && absoluteDelta !== null && absoluteDelta >= varianceFloor ? test.durationMs / med : null;
+        const recentTrendDelta = hasReliableRecentMedian && recentMedian && med ? recentMedian - med : null;
+        const recentTrendRatio = hasReliableRecentMedian &&
+            recentMedian &&
+            med &&
+            recentTrendDelta !== null &&
+            recentTrendDelta >= varianceFloor
+            ? recentMedian / med
+            : null;
+        if (ratio && ratio >= 1.8 && (!slowestRisk || ratio > slowestRisk.ratio)) {
+            slowestRisk = { title: test.title, ratio };
+        }
+        const historicalRetries = historicalRetryCounts.get(test.matchKey) || 0;
+        const historicalFailures = historicalFailureCounts.get(test.matchKey) || 0;
+        const repeatedSlowPasses = slowPassCounts.get(test.matchKey) || 0;
+        const timeoutUtilization = test.timeoutMs && test.timeoutMs > 0 ? test.durationMs / test.timeoutMs : null;
+        const recentFailurePressure = historicalFailures >= 5 && lastFailureRunsAgo !== null && lastFailureRunsAgo <= 3;
+        const currentRunSignal = Boolean(test.retries > 0 ||
+            (ratio && ratio >= 1.8) ||
+            (timeoutUtilization && timeoutUtilization >= 0.9));
+        const persistentPassSignal = Boolean(historicalRetries >= 2 ||
+            repeatedSlowPasses >= 3 ||
+            (recentTrendRatio && recentTrendRatio >= 1.5));
+        const score = (test.retries > 0 ? 4 : 0) +
+            (ratio && ratio >= 1.8 ? 2 : 0) +
+            (ratio && ratio >= 2.2 ? 1 : 0) +
+            (recentTrendRatio && recentTrendRatio >= 1.5 ? 1 : 0) +
+            (repeatedSlowPasses >= 2 ? 2 : repeatedSlowPasses > 0 ? 1 : 0) +
+            (timeoutUtilization && timeoutUtilization >= 0.65 ? 1 : 0) +
+            (timeoutUtilization && timeoutUtilization >= 0.85 ? 1 : 0) +
+            (historicalRetries >= 2 ? 2 : historicalRetries > 0 ? 1 : 0) +
+            (recentFailurePressure ? 1 : 0);
+        const strongSignal = Boolean(currentRunSignal ||
+            persistentPassSignal);
+        const primaryReason = test.retries > 0
+            ? `passed after ${test.retries} retr${test.retries === 1 ? 'y' : 'ies'} in this run`
+            : historicalRetries >= 2
+                ? `needed retries in ${historicalRetries} of the last 10 passing runs`
+                : recentFailurePressure
+                    ? `failed in ${historicalFailures} of the last 10 runs`
+                    : ratio && ratio >= 1.8
+                        ? `took ${formatShortDuration(test.durationMs)} vs ${formatShortDuration(med)} recent median (${ratio.toFixed(1)}x)`
+                        : repeatedSlowPasses >= 2
+                            ? `has been unusually slow in ${repeatedSlowPasses} of the last 10 passing runs`
+                            : timeoutUtilization && timeoutUtilization >= 0.85
+                                ? `used ${(timeoutUtilization * 100).toFixed(0)}% of its timeout budget`
+                                : recentTrendRatio && recentTrendRatio >= 1.5
+                                    ? `is trending slower over recent runs`
+                                    : `has weak instability signals`;
+        if (score > 0) {
+            nearFailureCandidates.push({
+                title: test.title,
+                ratio,
+                recentTrendRatio,
+                retries: test.retries,
+                historicalRetries,
+                historicalFailures,
+                repeatedSlowPasses,
+                timeoutUtilization,
+                medianDurationMs: med,
+                currentDurationMs: test.durationMs,
+                score,
+                strongSignal,
+                currentRunSignal,
+                primaryReason
+            });
+        }
+    }
+    nearFailureCandidates.sort((left, right) => Number(right.currentRunSignal) - Number(left.currentRunSignal) ||
+        right.score - left.score ||
+        (right.historicalFailures || 0) - (left.historicalFailures || 0) ||
+        (right.timeoutUtilization || 0) - (left.timeoutUtilization || 0) ||
+        (right.ratio || 0) - (left.ratio || 0));
+    const strongNearFailures = nearFailureCandidates.filter((candidate) => candidate.strongSignal &&
+        (candidate.currentRunSignal ||
+            candidate.historicalRetries >= 2 ||
+            candidate.repeatedSlowPasses >= 3 ||
+            (candidate.recentTrendRatio !== null && candidate.recentTrendRatio >= 1.5)) &&
+        candidate.score >= 3);
+    const topNearFailures = strongNearFailures.slice(0, 2);
+    const flakyLookingCount = strongNearFailures.length;
+    const hasActiveRisk = flakyLookingCount > 0;
+    const totalDurationMs = snapshot.tests.reduce((sum, test) => sum + test.durationMs, 0);
+    const displayedRunDurationMs = options?.observedRunDurationMs || snapshot.wallDurationMs || totalDurationMs;
+    const lines = [
+        `- ${snapshot.passedCount} tests passed in ${formatDuration(displayedRunDurationMs)} of wall time`
+    ];
+    if (hasActiveRisk) {
+        if (retryPassedCount > 0)
+            lines.push(`- Retries detected: ${retryPassedCount}`);
+        lines.push(`- Flaky-looking tests: ${flakyLookingCount}`);
+        if (topNearFailures[0]) {
+            lines.push(`- Most at risk next: ${topNearFailures[0].title} (${topNearFailures[0].primaryReason})`);
+        }
+        if (passStreak > 1)
+            lines.push(`- Pass streak: ${passStreak} runs`);
+        if (lastFailureRunsAgo !== null)
+            lines.push(`- Last failure: ${lastFailureRunsAgo} runs ago`);
+    }
+    else {
+        lines.push(`- Pipeline health: Stable`);
+        if (passStreak > 1)
+            lines.push(`- Pass streak: ${passStreak} runs`);
+        if (lastFailureRunsAgo !== null)
+            lines.push(`- Last failure: ${lastFailureRunsAgo} runs ago`);
+    }
+    lines.push(`- Sentinel active: traces, screenshots, video enabled`);
+    const risks = [];
+    for (const candidate of topNearFailures) {
+        if (candidate.ratio && candidate.ratio >= 1.8) {
+            risks.push(`- ${candidate.title} took ${formatShortDuration(candidate.currentDurationMs)} vs ${formatShortDuration(candidate.medianDurationMs)} recent median (${candidate.ratio.toFixed(1)}x)`);
+        }
+        if (candidate.retries > 0) {
+            risks.push(`- ${candidate.title} passed after ${candidate.retries} retr${candidate.retries === 1 ? 'y' : 'ies'}`);
+        }
+        if (candidate.historicalRetries >= 2) {
+            risks.push(`- ${candidate.title} has needed retries in ${candidate.historicalRetries} of the last 10 passing runs`);
+        }
+        if (candidate.repeatedSlowPasses >= 3) {
+            risks.push(`- ${candidate.title} has been unusually slow in ${candidate.repeatedSlowPasses} of the last 10 passing runs`);
+        }
+        if (candidate.recentTrendRatio && candidate.recentTrendRatio >= 1.5) {
+            risks.push(`- ${candidate.title} is trending slower over recent runs`);
+        }
+        if (candidate.timeoutUtilization && candidate.timeoutUtilization >= 0.65) {
+            risks.push(`- ${candidate.title} used ${(candidate.timeoutUtilization * 100).toFixed(0)}% of its timeout budget`);
+        }
+        if (candidate.historicalFailures >= 5 &&
+            lastFailureRunsAgo !== null &&
+            lastFailureRunsAgo <= 3 &&
+            (candidate.currentRunSignal || candidate.historicalRetries >= 2 || candidate.repeatedSlowPasses >= 3)) {
+            risks.push(`- ${candidate.title} failed in ${candidate.historicalFailures} of the last 10 runs`);
+        }
+    }
+    return { lines, risks: Array.from(new Set(risks)).slice(0, 4) };
+};
+exports.buildPassingRunSummary = buildPassingRunSummary;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentinelqa/playwright-reporter",
-  "version": "0.1.45",
+  "version": "0.1.50",
   "private": false,
   "description": "Playwright reporter for CI debugging with optional Sentinel cloud dashboards",
   "license": "MIT",
@@ -39,7 +39,7 @@
     "@playwright/test": ">=1.40.0"
   },
   "dependencies": {
-    "@sentinelqa/uploader": "^0.1.24"
+    "@sentinelqa/uploader": "^0.1.35"
   },
   "devDependencies": {
     "@types/node": "^20.19.32",