@epicat/toon-reporter 0.0.4 → 0.0.6

package/README.md

@@ -1,6 +1,6 @@
 # toon-reporter
 
-A minimal Vitest reporter optimized for LLM consumption. Outputs test results in a compact, token-efficient format.
+A minimal Vitest and Playwright reporter optimized for LLM consumption. Outputs test results in a compact, token-efficient format.
 
 ## Installation
 
@@ -10,13 +10,15 @@ npm install @epicat/toon-reporter
 
 ## Usage
 
-### CLI
+### Vitest
+
+#### CLI
 
 ```bash
 npx vitest run --reporter=@epicat/toon-reporter
 ```
 
-### Config
+#### Config
 
 ```ts
 // vitest.config.ts
@@ -29,6 +31,34 @@ export default defineConfig({
 })
 ```
 
+### Playwright
+
+#### Config
+
+```ts
+// playwright.config.ts
+import { defineConfig } from '@playwright/test'
+
+export default defineConfig({
+  reporter: [['@epicat/toon-reporter/playwright']],
+})
+```
+
+#### With options
+
+```ts
+// playwright.config.ts
+import { defineConfig } from '@playwright/test'
+
+export default defineConfig({
+  reporter: [
+    ['@epicat/toon-reporter/playwright', {
+      outputFile: 'test-results.toon'
+    }]
+  ],
+})
+```
+
 ## Output Format
 
 ### All tests passing
@@ -37,7 +67,7 @@ export default defineConfig({
 passing: 42
 ```
 
-### With failures
+### With failures (Vitest)
 
 ```
 passing: 40
@@ -49,7 +79,15 @@ failing[2]:
     error: TypeError: Cannot read property 'id' of undefined
 ```
 
-### With parameterized test failures
+### With failures (Playwright)
+
+```
+passing: 1
+failing[1]{at,expected,got}:
+  "login.spec.ts:7:42",Welcome,Hello World
+```
+
+### With parameterized test failures (Vitest)
 
 Uses TOON tabular format for uniform parameter arrays:
 
@@ -69,16 +107,60 @@ Uses TOON tabular format for uniform arrays:
 ```
 passing: 38
 todo[1]{at,name}:
-  src/api.test.ts,implement error handling
+  "src/api.test.ts:15:3",implement error handling
 skipped[2]{at,name}:
-  src/utils.test.ts,handles edge case
+  "src/utils.test.ts:8:3",handles edge case
+```
+
+### With flaky tests (Playwright)
+
+Tests that fail initially but pass on retry are reported as flaky:
+
+```
+passing: 5
+flaky[1]{at,name,retries}:
+  "checkout.spec.ts:12:3",should complete payment,2
+```
+
+### With coverage (Vitest only)
+
+Coverage is automatically included when running with `--coverage`. No extra configuration needed:
+
+```bash
+npx vitest run --coverage --reporter=@epicat/toon-reporter
+```
+
+Output includes total percentages and uncovered lines per file:
+
+```
+passing: 8
+coverage:
+  "total%":
+    lines: 60.99
+    stmts: 58.82
+    branch: 44.34
+    funcs: 57.57
+  files[1]{file,uncoveredLines}:
+    src/toon-reporter.ts,"12-14,19-23,32,99"
+```
+
+- **Total percentages**: Help teams track coverage thresholds
+- **Per-file uncovered lines**: Give LLMs actionable info to improve coverage
+- **100% covered files are hidden** by default to reduce noise
+
+With `verbose: true`, all files appear with per-file percentages:
+
+```
+  files[2]{file,uncoveredLines,"lines%","stmts%","branch%","funcs%"}:
+    src/toon-reporter.ts,"12-14,19-23,32,99",56.89,55.63,43.63,61.53
+    test/test-utils.ts,"",100,100,100,100
 ```
 
 ## Colors
 
 - **Green**: `passing` count
 - **Red**: `failing` header
-- **Yellow**: file paths
+- **Yellow**: `flaky` header, file paths
 - **Gray**: `skipped` tests
 - **Cyan**: `todo` tests
 
@@ -119,11 +201,21 @@ COLOR=1 npx vitest run --reporter=@epicat/toon-reporter
 Write report to a file instead of stdout.
 
 ```ts
-reporters: [['toon-reporter', { outputFile: 'test-results.txt' }]]
+reporters: [['@epicat/toon-reporter', { outputFile: 'test-results.txt' }]]
+```
+
+### `verbose`
+
+Include per-file coverage percentages (lines, stmts, branch, funcs) alongside uncovered lines.
+
+```ts
+reporters: [new ToonReporter({ verbose: true })]
 ```
 
 ## Skipped/Todo Line Numbers
 
+### Vitest
+
 To get line:column information for skipped and todo tests, enable `includeTaskLocation` in your vitest config:
 
 ```ts
@@ -131,7 +223,7 @@ To get line:column information for skipped and todo tests, enable `includeTaskLo
 export default defineConfig({
   test: {
     includeTaskLocation: true,
-    reporters: ['toon-reporter'],
+    reporters: ['@epicat/toon-reporter'],
   },
 })
 ```
@@ -139,18 +231,40 @@ export default defineConfig({
 Or via CLI:
 
 ```bash
-npx vitest run --reporter=toon-reporter --includeTaskLocation
+npx vitest run --reporter=@epicat/toon-reporter --includeTaskLocation
 ```
 
 Without this option, skipped/todo tests will only show the file path (not line:column). This is a Vitest limitation - test locations are only collected when this config is enabled before test collection.
 
+### Playwright
+
+Playwright always includes test locations. Tests marked with `test.fixme()` are reported as `todo`, while `test.skip()` tests are reported as `skipped`.
+
+## Playwright-Specific Features
+
+### Flaky Test Detection
+
+When `retries` is configured in your Playwright config, tests that fail initially but pass on retry are reported as flaky:
+
+```ts
+// playwright.config.ts
+export default defineConfig({
+  retries: 2,
+  reporter: [['@epicat/toon-reporter/playwright']],
+})
+```
+
+Output: `flaky[1]{at,name,retries}: "test.spec.ts:5:3",should work,1`
+
 ## Why?
 
 Traditional test reporters output verbose information optimized for human readability. When feeding test results to an LLM for automated fixing, this verbosity wastes tokens. This reporter outputs only what's needed:
 
 - Pass count
 - Failure locations with expected/got values
+- Flaky test detection with retry counts (Playwright)
 - Skipped/todo test names for context
+- Coverage totals and uncovered lines (Vitest with `--coverage`)
 
 ## Token Efficiency
 

package/dist/index.d.mts

@@ -5,6 +5,8 @@ import { Reporter, TestRunEndReason, Vitest } from "vitest/node";
 interface ToonReporterOptions {
   outputFile?: string;
   color?: boolean;
+  /** Include per-file coverage percentages (lines, stmts, branch, funcs) */
+  verbose?: boolean;
   /** @internal Used for testing to capture output */
   _captureOutput?: (output: string) => void;
 }
@@ -13,8 +15,12 @@ declare class ToonReporter implements Reporter {
   ctx: Vitest;
   options: ToonReporterOptions;
   private useColor;
+  private coverageMap;
   constructor(options?: ToonReporterOptions);
   onInit(ctx: Vitest): void;
+  onCoverage(coverage: unknown): void;
+  private getCoverageSummary;
+  private formatLineRanges;
   private formatLocation;
   private parseErrorLocation;
   private parseExpectedGot;

package/dist/index.mjs

@@ -54,6 +54,63 @@ var ToonReporter = class {
 	onInit(ctx) {
 		this.ctx = ctx;
 		this.start = Date.now();
+		this.coverageMap = void 0;
+		const coverage = ctx.config.coverage;
+		if (coverage?.reporter) coverage.reporter = [];
+	}
+	onCoverage(coverage) {
+		this.coverageMap = coverage;
+	}
+	getCoverageSummary() {
+		if (!this.coverageMap) return void 0;
+		const map = this.coverageMap;
+		if (typeof map.getCoverageSummary !== "function") return void 0;
+		const summary = map.getCoverageSummary().toJSON();
+		const rootDir = this.ctx.config.root;
+		const result = { "total%": {
+			lines: summary.lines?.pct ?? 0,
+			stmts: summary.statements?.pct ?? 0,
+			branch: summary.branches?.pct ?? 0,
+			funcs: summary.functions?.pct ?? 0
+		} };
+		if (map.files && map.fileCoverageFor) {
+			const entries = [];
+			const verbose = this.options.verbose;
+			for (const file of map.files()) {
+				const fc = map.fileCoverageFor(file);
+				const uncoveredLines = fc.getUncoveredLines();
+				const hasGaps = uncoveredLines.length > 0;
+				if (!verbose && !hasGaps) continue;
+				const entry = {
+					file: relative(rootDir, file),
+					uncoveredLines: this.formatLineRanges(uncoveredLines)
+				};
+				if (verbose) {
+					const fileSummary = fc.toSummary().toJSON();
+					entry["lines%"] = fileSummary.lines?.pct ?? 0;
+					entry["stmts%"] = fileSummary.statements?.pct ?? 0;
+					entry["branch%"] = fileSummary.branches?.pct ?? 0;
+					entry["funcs%"] = fileSummary.functions?.pct ?? 0;
+				}
+				entries.push(entry);
+			}
+			if (entries.length > 0) result.files = entries;
+		}
+		return result;
+	}
+	formatLineRanges(lines) {
+		if (lines.length === 0) return "";
+		const sorted = lines.map(Number).sort((a, b) => a - b);
+		const ranges = [];
+		let start = sorted[0];
+		let end = start;
+		for (let i = 1; i <= sorted.length; i++) if (sorted[i] === end + 1) end = sorted[i];
+		else {
+			ranges.push(start === end ? String(start) : `${start}-${end}`);
+			start = sorted[i];
+			end = start;
+		}
+		return ranges.join(",");
 	}
 	formatLocation(relPath, line, column) {
 		return line ? `${relPath}:${line}:${column || 0}` : relPath;
@@ -135,6 +192,8 @@ var ToonReporter = class {
 		if (failures.length > 0) report.failing = failures;
 		if (todoTests.length > 0) report.todo = todoTests.map(mapToSkipped);
 		if (skippedTests.length > 0) report.skipped = skippedTests.map(mapToSkipped);
+		const coverage = this.getCoverageSummary();
+		if (coverage) report.coverage = coverage;
 		await this.writeReport(encode(report));
 	}
 	colorize(report) {

package/dist/playwright.d.mts

@@ -0,0 +1,25 @@
+import { FullConfig, FullResult, Reporter, Suite } from "@playwright/test/reporter";
+
+//#region src/toon-playwright-reporter.d.ts
+interface ToonPlaywrightReporterOptions {
+  outputFile?: string;
+  /** @internal Used for testing to capture output */
+  _captureOutput?: (output: string) => void;
+}
+declare class ToonPlaywrightReporter implements Reporter {
+  private config;
+  private suite;
+  private options;
+  constructor(options?: ToonPlaywrightReporterOptions);
+  onBegin(config: FullConfig, suite: Suite): void;
+  private get rootDir();
+  private formatLocation;
+  private stripAnsi;
+  private stripOuterQuotes;
+  private parseExpectedGot;
+  onEnd(result: FullResult): Promise<void>;
+  writeReport(report: string): Promise<void>;
+  printsToStdio(): boolean;
+}
+//#endregion
+export { ToonPlaywrightReporter, ToonPlaywrightReporter as default, type ToonPlaywrightReporterOptions };

package/dist/playwright.mjs

@@ -0,0 +1,111 @@
+import { existsSync, promises } from "node:fs";
+import { dirname, relative, resolve } from "pathe";
+import { encode } from "@toon-format/toon";
+
+//#region src/toon-playwright-reporter.ts
+var ToonPlaywrightReporter = class {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	onBegin(config, suite) {
+		this.config = config;
+		this.suite = suite;
+	}
+	get rootDir() {
+		return this.config.rootDir;
+	}
+	formatLocation(filePath, line, column) {
+		const relPath = relative(this.rootDir, filePath);
+		return line ? `${relPath}:${line}:${column || 0}` : relPath;
+	}
+	stripAnsi(str) {
+		return str.replace(/\x1b\[[0-9;]*m/g, "");
+	}
+	stripOuterQuotes(str) {
+		if (str.startsWith("\"") && str.endsWith("\"") || str.startsWith("'") && str.endsWith("'")) return str.slice(1, -1);
+		return str;
+	}
+	parseExpectedGot(error) {
+		const message = this.stripAnsi(error?.message || "");
+		const expectedMatch = message.match(/Expected:\s*(.+?)(?:\n|$)/i);
+		const receivedMatch = message.match(/Received:\s*(.+?)(?:\n|$)/i);
+		if (expectedMatch && receivedMatch) return {
+			expected: this.stripOuterQuotes(expectedMatch[1].trim()),
+			got: this.stripOuterQuotes(receivedMatch[1].trim())
+		};
+		const toBeMatch = message.match(/expect\((.+?)\)\.toBe\((.+?)\)/i);
+		if (toBeMatch) return {
+			expected: this.stripOuterQuotes(toBeMatch[2].trim()),
+			got: this.stripOuterQuotes(toBeMatch[1].trim())
+		};
+		return {};
+	}
+	async onEnd(result) {
+		const allTests = this.suite.allTests();
+		const passedTests = [];
+		const failedTests = [];
+		const skippedTests = [];
+		const todoTests = [];
+		const flakyTests = [];
+		for (const test of allTests) {
+			const lastResult = test.results[test.results.length - 1];
+			if (!lastResult) continue;
+			const status = lastResult.status;
+			const isFixme = test.annotations.some((a) => a.type === "fixme");
+			if (status === "passed" && test.results.length > 1 && test.results.some((r) => r.status === "failed")) flakyTests.push(test);
+			else if (status === "passed") passedTests.push(test);
+			else if (status === "failed" || status === "timedOut" || status === "interrupted") failedTests.push(test);
+			else if (status === "skipped") if (isFixme) todoTests.push(test);
+			else skippedTests.push(test);
+		}
+		const failures = [];
+		for (const test of failedTests) {
+			const error = test.results[test.results.length - 1]?.errors?.[0];
+			const loc = error?.location || test.location;
+			const failure = { at: this.formatLocation(loc.file, loc.line, loc.column) };
+			if (error) {
+				const { expected, got } = this.parseExpectedGot(error);
+				if (expected !== void 0 && got !== void 0) {
+					failure.expected = expected;
+					failure.got = got;
+				} else failure.error = error.message;
+			}
+			failures.push(failure);
+		}
+		const mapToSkipped = (test) => ({
+			at: this.formatLocation(test.location.file, test.location.line, test.location.column),
+			name: test.title
+		});
+		const mapToFlaky = (test) => ({
+			at: this.formatLocation(test.location.file, test.location.line, test.location.column),
+			name: test.title,
+			retries: test.results.length - 1
+		});
+		const report = { passing: passedTests.length };
+		if (flakyTests.length > 0) report.flaky = flakyTests.map(mapToFlaky);
+		if (failures.length > 0) report.failing = failures;
+		if (todoTests.length > 0) report.todo = todoTests.map(mapToSkipped);
+		if (skippedTests.length > 0) report.skipped = skippedTests.map(mapToSkipped);
+		await this.writeReport(encode(report));
+	}
+	async writeReport(report) {
+		if (this.options._captureOutput) {
+			this.options._captureOutput(report);
+			return;
+		}
+		const outputFile = this.options.outputFile;
+		if (outputFile) {
+			const reportFile = resolve(this.rootDir, outputFile);
+			const outputDirectory = dirname(reportFile);
+			if (!existsSync(outputDirectory)) await promises.mkdir(outputDirectory, { recursive: true });
+			await promises.writeFile(reportFile, report, "utf-8");
+			console.log(`TOON report written to ${reportFile}`);
+		} else console.log(report);
+	}
+	printsToStdio() {
+		return !this.options.outputFile;
+	}
+};
+
+//#endregion
+export { ToonPlaywrightReporter, ToonPlaywrightReporter as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicat/toon-reporter",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A minimal Vitest reporter optimized for LLM consumption",
   "repository": {
     "type": "git",
@@ -16,20 +16,35 @@
   "types": "./dist/index.d.mts",
   "exports": {
     ".": "./dist/index.mjs",
+    "./playwright": "./dist/playwright.mjs",
     "./package.json": "./package.json"
   },
   "peerDependencies": {
+    "@playwright/test": ">=1.40.0",
     "vitest": ">=2.0.0"
   },
+  "peerDependenciesMeta": {
+    "@playwright/test": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "@toon-format/toon": "^2.0.1",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",
+    "@playwright/test": "^1.57.0",
     "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.15",
     "@vitest/runner": "4.0.15",
     "@vitest/utils": "4.0.15",
+    "gpt-tokenizer": "^3.4.0",
+    "istanbul-lib-coverage": "^3.2.2",
+    "serve": "^14.2.5",
     "tsdown": "^0.16.4",
     "typescript": "^5.9.3",
     "vitest": "4.0.15"
@@ -38,6 +53,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
     "test:watch": "vitest"
   }
 }