@reportforge/playwright-pdf 0.3.1 → 0.4.1

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.4.0] — 2026-06-12
+
+### Added
+
+- **Failure analysis** — every failed test is classified into one of seven root-cause categories (assertion, timeout, selector/locator, network, and more) and failures that share a cause are grouped into clusters, rendered as a ranked breakdown in the `detailed` template. Classification runs fully offline — no network call, no AI service. The classifier model refreshes from the licensing server in the background (offline-tolerant; the bundled model is always the floor), with optional privacy-preserving local feedback collection. See `docs/advanced/failure-analysis`.
+
+---
+
 ## [0.3.1] — 2026-06-09
 
 ### Security

package/README.md

@@ -56,6 +56,8 @@ Three templates, one reporter. Every PDF is fully offline — fonts, charts, and
 - **Shard merging** — combine N Playwright JSON shard reports into one PDF via `shardResults`; accepts glob patterns or explicit paths
 - **Notifications** — post pass/fail summaries to Slack, Teams, Discord, or email after each run; configurable trigger (`always` / `failure` / `success`) per channel; email supports optional PDF attachment via `attachPdf`
 - **Flakiness trend** — top-N flakiest tests table with per-test dot sparkline across stored history runs in the `detailed` template; `flakinessTopN` option (default 5, `0` disables)
+- **Offline failure analysis** — sorts failures into 7 root-cause buckets and clusters them, right inside the `detailed` PDF (one-liner in `executive`). No network, no AI service — a small embedded classifier that updates itself safely over your existing license refresh; pin it any time. Full details at [reportforge.org/docs/advanced/failure-analysis](https://reportforge.org/docs/advanced/failure-analysis).
+- `reportforge-export-feedback` — exports locally-collected unrecognized failures (tokenized, local-only) for optional manual sharing.
 - **Hybrid licensing** — one short key unlocks it; reports keep rendering offline via a cached JWT between refreshes
 
 ---
@@ -190,6 +192,7 @@ All options are the second element of the reporter tuple.
 | `maxFileSizeMb` | `number` | `8` | Soft cap on the final PDF size in MB. If exceeded, the report is re-rendered once with the `'max'` compression preset. |
 | `shardResults` | `string \| string[]` | — | Glob or path array of Playwright JSON shard report files to merge into one PDF. See the Shard Merging docs. |
 | `notify` | `object` | — | Notification channels: `slack`, `teams`, `discord` (each `{ url, enabled, on }`), `email` (`{ to, enabled, on, attachPdf }`). See the Notifications docs. |
+| `failureAnalysis` | `object` | `{ enabled: true }` | Offline failure root-cause analysis (embedded Naive Bayes; no runtime network). Fields: `enabled` (default `true`), `maxClusters` (default `10`), `minStrength` (`weak`\|`moderate`\|`strong`, default `weak`), `maxFailuresToAnalyse` (default `500`), `collectUnclassified` (default `true`), `autoUpdateModel` (default `true`). See the Failure Analysis docs. |
 | `historyFile` | `string` | `~/.reportforge/{key}/history.json` | Path to the history JSON file. Relative paths resolve from `cwd`. Enables pass-rate trending charts in the `detailed` template. |
 | `historySize` | `number` | `10` | Maximum number of test runs to keep in the history file (integer ≥ 2). Older runs are pruned on append. |
 | `showTrend` | `boolean` | `true` | Show the pass-rate sparkline and delta badge in the `detailed` template. Set to `false` to disable history tracking entirely. |

package/dist/cli/export-feedback.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli/export-feedback.ts
+var export_feedback_exports = {};
+__export(export_feedback_exports, {
+  exportFeedback: () => exportFeedback
+});
+module.exports = __toCommonJS(export_feedback_exports);
+var import_node_fs = __toESM(require("fs"));
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+
+// src/analysis/feedback-csv.ts
+var FEEDBACK_HEADER = "category,margin,text";
+function parseFeedbackRows(content) {
+  return content.trim().split("\n").slice(1).filter(Boolean).map((line) => {
+    const parts = line.split(",");
+    return { category: parts[0], margin: parts[1], text: parts.slice(2).join(","), raw: line };
+  });
+}
+
+// src/cli/export-feedback.ts
+function exportFeedback(deps = {}) {
+  const home = deps.home ?? import_node_os.default.homedir();
+  const cwd = deps.cwd ?? process.cwd();
+  const root = import_node_path.default.join(home, ".reportforge");
+  const rows = [];
+  if (import_node_fs.default.existsSync(root)) {
+    for (const entry of import_node_fs.default.readdirSync(root)) {
+      const file = import_node_path.default.join(root, entry, "unclassified.csv");
+      if (!import_node_fs.default.existsSync(file)) continue;
+      for (const r of parseFeedbackRows(import_node_fs.default.readFileSync(file, "utf8"))) {
+        rows.push(r.raw);
+      }
+    }
+  }
+  if (rows.length === 0) return { rowCount: 0, outFile: null };
+  const outFile = import_node_path.default.join(cwd, "reportforge-feedback.csv");
+  import_node_fs.default.writeFileSync(outFile, `${FEEDBACK_HEADER}
+${rows.join("\n")}
+`, "utf8");
+  return { rowCount: rows.length, outFile };
+}
+if (process.argv[1] && process.argv[1].endsWith("export-feedback.js")) {
+  const res = exportFeedback();
+  if (res.rowCount === 0) {
+    process.stdout.write("No locally collected failures found (~/.reportforge/*/unclassified.csv).\n");
+  } else {
+    process.stdout.write(
+      `Saved ${res.rowCount} row(s) to ${res.outFile} - tokenized + redacted, LOCAL only.
+Review it before sharing; there is no upload.
+`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportFeedback
+});