@kinora/vitest-reporter 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present Joris Gallot <https://github.com/joris-gallot>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,46 @@
-# Temporary Holding Version
+# @kinora/vitest-reporter
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Vitest reporter that uploads your browser tests to a [kinora](https://github.com/kinora-dev/kinora) server: pass rates, flaky tests, history across runs, and the Playwright trace of each test. Storybook stories land on kinora's Components page.
+
+It uploads the tests of Vitest projects running in a browser (browser mode, Storybook) at the end of the run, then their traces and screenshot comparisons. Upload never fails your test run.
+
+## Install
+
+```bash
+npm i -D @kinora/vitest-reporter
+# or: pnpm add -D @kinora/vitest-reporter
+```
+
+`vitest` (>=4.1) is a peer dependency. Traces need browser mode with the Playwright provider.
+
+## Usage
+
+Add it to `vitest.config.ts`, next to the default reporter:
+
+```ts
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    reporters: ['default', ['@kinora/vitest-reporter', { project: { slug: 'web-app' } }]],
+  },
+})
+```
+
+```bash
+KINORA_TOKEN=<token> npx vitest run
+```
+
+Create an API token in the kinora dashboard (Settings → Workspace). Self-hosting? Point at your server with `KINORA_URL`.
+
+## Node tests
+
+Only browser tests are uploaded by default: Node unit tests are usually thousands of fast tests with no trace, and would eat your plan's monthly result quota. Upload them too with `include: 'all'`.
+
+## Documentation
+
+**https://docs.kinora.dev/guides/vitest/**
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import { AttachmentKind, CiMeta, GitMeta } from "@kinora/core";
+import { Reporter, TestModule, Vitest } from "vitest/node";
+//#region src/convert.d.ts
+type IncludeTests = 'browser' | 'all';
+//#endregion
+//#region src/index.d.ts
+export interface KinoraVitestReporterOptions {
+  /** kinora server base URL. Defaults to env KINORA_URL, then the hosted cloud. Set for self-host. */
+  url?: string;
+  /** Project API token. Defaults to env KINORA_TOKEN (keep it out of the config file). */
+  token?: string;
+  /** Target project. `name` defaults to `slug`. */
+  project: {
+    slug: string;
+    name?: string;
+  };
+  git?: GitMeta;
+  ci?: CiMeta;
+  /** Which attachment kinds to upload. Defaults to `['trace', 'snapshot']`. */
+  uploadAttachments?: AttachmentKind[];
+  /**
+   * Which tests to upload. `browser` (default) keeps the tests of projects running in a browser
+   * (browser mode, Storybook) and leaves Node unit tests out. `all` uploads everything; mind the
+   * plan's monthly result quota with large unit suites.
+   */
+  include?: IncludeTests;
+}
+export default class KinoraVitestReporter implements Reporter {
+  private readonly options;
+  private startedAt;
+  constructor(options: KinoraVitestReporterOptions);
+  onInit(vitest: Vitest): void;
+  onTestRunStart(): void;
+  onTestRunEnd(modules: ReadonlyArray<TestModule>): Promise<void>;
+}
+//#endregion
+export {};

package/dist/index.mjs

@@ -0,0 +1,268 @@
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { A11Y_IMPACTS, DEFAULT_KINORA_URL, DEFAULT_UPLOAD_ATTACHMENTS, IngestError, MAX_A11Y_NODES, MAX_A11Y_VIOLATIONS, STORY_ANNOTATION, createIngestClient, detectCiEnv, isUploadableAttachment, makeTestKey, stripAnsi } from "@kinora/core";
+//#region src/convert.ts
+function identity(test) {
+	const file = test.module.relativeModuleId;
+	const suites = [];
+	for (let parent = test.parent; parent.type === "suite"; parent = parent.parent) suites.unshift(parent.name);
+	return {
+		file,
+		titlePath: [
+			file,
+			...suites,
+			test.name
+		],
+		projectName: test.project.name
+	};
+}
+function statusOf(test) {
+	const { state } = test.result();
+	if (state === "skipped") return "skipped";
+	if (state === "failed") return "unexpected";
+	if (state === "passed") return test.diagnostic()?.flaky ? "flaky" : "expected";
+}
+function storyOf(test, titlePath) {
+	const meta = test.meta();
+	if (!meta.storyId) return void 0;
+	if (!meta.componentName) return meta.storyId.replace("--", "/");
+	return `${meta.componentName}/${titlePath[1]}`;
+}
+const MAX_TEXT = 300;
+const truncate = (s) => s.length > MAX_TEXT ? `${s.slice(0, MAX_TEXT)}…` : s;
+const isImpact = (v) => A11Y_IMPACTS.includes(v);
+function selector(target) {
+	if (!Array.isArray(target)) return "";
+	return truncate(target.map((t) => Array.isArray(t) ? t.join(" >>> ") : String(t)).join(" "));
+}
+function violation(v) {
+	if (!v.id) return [];
+	const nodes = v.nodes ?? [];
+	return [{
+		id: v.id,
+		...isImpact(v.impact) && { impact: v.impact },
+		help: truncate(v.help ?? v.id),
+		...v.helpUrl && { helpUrl: v.helpUrl },
+		nodes: nodes.slice(0, MAX_A11Y_NODES).map((n) => selector(n.target)).filter(Boolean),
+		nodeCount: nodes.length
+	}];
+}
+const AXE_FAILURE = /Expected the HTML found at \$\('(.+?)'\) to have no violations:[\s\S]*?Received:\s*"(.+?) \(([\w-]+)\)"[\s\S]*?more information on this issue here:\s*(https:\/\/\S+)/g;
+function a11yFromError(test) {
+	const message = test.result().errors?.find((e) => e.message.includes("toHaveNoViolations"))?.message;
+	if (!message) return void 0;
+	const byRule = /* @__PURE__ */ new Map();
+	for (const [, target, help, id, helpUrl] of stripAnsi(message).matchAll(AXE_FAILURE)) {
+		const v = byRule.get(id) ?? {
+			id,
+			help: truncate(help),
+			helpUrl,
+			nodes: [],
+			nodeCount: 0
+		};
+		if (v.nodes.length < MAX_A11Y_NODES) v.nodes.push(truncate(target));
+		v.nodeCount++;
+		byRule.set(id, v);
+	}
+	return byRule.size ? {
+		status: "failed",
+		violations: [...byRule.values()].slice(0, MAX_A11Y_VIOLATIONS)
+	} : void 0;
+}
+function a11yOf(test) {
+	const report = test.meta().reports?.find((r) => r.type === "a11y");
+	const status = report?.status;
+	if (status !== "passed" && status !== "warning" && status !== "failed") return a11yFromError(test);
+	const result = report?.result ?? {};
+	if (result.error) {
+		const { message } = result.error;
+		const text = typeof message === "string" ? message : typeof result.error === "string" ? result.error : "The accessibility check failed.";
+		return {
+			status: "failed",
+			violations: [],
+			error: truncate(text)
+		};
+	}
+	return {
+		status,
+		violations: (result.violations ?? []).slice(0, MAX_A11Y_VIOLATIONS).flatMap(violation)
+	};
+}
+function slug(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "screenshot";
+}
+function attachmentsOf(test) {
+	const attachments = [];
+	let comparisons = 0;
+	for (const annotation of test.annotations()) if (annotation.type === "traces" && annotation.attachment?.path) attachments.push({
+		name: "trace",
+		contentType: "application/zip",
+		path: annotation.attachment.path,
+		hasBody: false
+	});
+	for (const artifact of test.artifacts()) {
+		if (artifact.type === "internal:failureScreenshot") {
+			for (const a of artifact.attachments ?? []) if (a.path) attachments.push({
+				name: "screenshot",
+				contentType: a.contentType ?? "image/png",
+				path: a.path,
+				hasBody: false
+			});
+		}
+		if (artifact.type === "internal:toMatchScreenshot") {
+			comparisons++;
+			const base = `${slug(test.name)}${comparisons > 1 ? `-${comparisons}` : ""}`;
+			for (const a of artifact.attachments ?? []) if (a.path && a.name) attachments.push({
+				name: `${base}-${a.name === "reference" ? "expected" : a.name}.png`,
+				contentType: a.contentType ?? "image/png",
+				path: a.path,
+				hasBody: false
+			});
+		}
+	}
+	return attachments;
+}
+function isBrowserTest(test) {
+	return !!test.project.config.browser?.enabled;
+}
+const STORYBOOK_DEBUG_LINE = /^\s*Click to debug the error directly in Storybook:.*$/m;
+function cleanMessage(message) {
+	return stripAnsi(message).replace(STORYBOOK_DEBUG_LINE, "").trim();
+}
+function toNormTest(test) {
+	const status = statusOf(test);
+	if (!status) return void 0;
+	const { file, titlePath, projectName } = identity(test);
+	const diagnostic = test.diagnostic();
+	const story = storyOf(test, titlePath);
+	const a11y = a11yOf(test);
+	return {
+		testKey: makeTestKey(file, titlePath, projectName),
+		title: test.name,
+		titlePath,
+		file,
+		line: test.location?.line ?? 0,
+		column: test.location?.column ?? 0,
+		projectName,
+		status,
+		ok: status !== "unexpected",
+		duration: Math.round(diagnostic?.duration ?? 0),
+		retries: diagnostic?.retryCount ?? 0,
+		tags: [...test.tags ?? []],
+		annotations: [...test.annotations().filter((a) => a.type !== "traces").map((a) => ({
+			type: a.type,
+			description: a.message
+		})), ...story ? [{
+			type: STORY_ANNOTATION,
+			description: story
+		}] : []],
+		errors: (test.result().errors ?? []).map((e) => ({
+			message: cleanMessage(e.message),
+			stack: e.stack
+		})),
+		attachments: attachmentsOf(test),
+		...a11y && { a11y }
+	};
+}
+function toNormTests(modules, include = "browser") {
+	const tests = [];
+	let skippedNodeTests = 0;
+	for (const module of modules) for (const test of module.children.allTests()) {
+		if (include === "browser" && !isBrowserTest(test)) {
+			skippedNodeTests++;
+			continue;
+		}
+		const norm = toNormTest(test);
+		if (norm) tests.push(norm);
+	}
+	return {
+		tests,
+		skippedNodeTests
+	};
+}
+//#endregion
+//#region src/index.ts
+function countsOf(tests) {
+	const counts = {
+		total: tests.length,
+		expected: 0,
+		unexpected: 0,
+		flaky: 0,
+		skipped: 0
+	};
+	for (const t of tests) counts[t.status]++;
+	return counts;
+}
+var KinoraVitestReporter = class {
+	options;
+	startedAt = /* @__PURE__ */ new Date();
+	constructor(options) {
+		this.options = options;
+	}
+	onInit(vitest) {
+		this.startedAt = /* @__PURE__ */ new Date();
+		vitest.config.includeTaskLocation = true;
+		for (const project of vitest.projects) project.config.includeTaskLocation = true;
+	}
+	onTestRunStart() {
+		this.startedAt = /* @__PURE__ */ new Date();
+	}
+	async onTestRunEnd(modules) {
+		const url = this.options.url ?? process.env.KINORA_URL ?? DEFAULT_KINORA_URL;
+		const token = this.options.token ?? process.env.KINORA_TOKEN;
+		if (!token) {
+			console.warn("[kinora] skipping upload: missing token (set KINORA_TOKEN)");
+			return;
+		}
+		const { tests, skippedNodeTests } = toNormTests(modules, this.options.include);
+		if (!tests.length) {
+			console.warn(skippedNodeTests ? `[kinora] nothing uploaded: no browser tests in this run (${skippedNodeTests} Node tests left out). Set include: 'all' to upload Node tests too.` : "[kinora] nothing uploaded: no tests ran");
+			return;
+		}
+		const detected = detectCiEnv(process.env);
+		const payload = {
+			project: {
+				slug: this.options.project.slug,
+				name: this.options.project.name ?? this.options.project.slug
+			},
+			run: {
+				startedAt: this.startedAt.toISOString(),
+				duration: Date.now() - this.startedAt.getTime(),
+				counts: countsOf(tests),
+				git: this.options.git ?? detected.git,
+				ci: this.options.ci ?? detected.ci
+			},
+			tests
+		};
+		try {
+			const client = createIngestClient({
+				baseUrl: url,
+				token
+			});
+			const res = await client.uploadRun(payload);
+			const kinds = this.options.uploadAttachments ?? DEFAULT_UPLOAD_ATTACHMENTS;
+			let artifacts = 0;
+			for (const t of tests) for (const a of t.attachments) {
+				if (!a.path || !isUploadableAttachment(a, kinds)) continue;
+				try {
+					await client.uploadArtifact({
+						runId: res.runId,
+						testKey: t.testKey,
+						name: a.name,
+						contentType: a.contentType,
+						body: await readFile(a.path)
+					});
+					artifacts++;
+				} catch (err) {
+					console.warn(`[kinora] ${a.name} upload failed for ${t.testKey}:`, err instanceof Error ? err.message : err);
+				}
+			}
+			console.log(`[kinora] uploaded ${res.tests} tests + ${artifacts} artifacts (run ${res.runId})`);
+		} catch (err) {
+			if (err instanceof IngestError && err.status === 402) console.warn(`[kinora] ${err.message}`);
+			else console.error("[kinora] upload failed:", err instanceof Error ? err.message : err);
+		}
+	}
+};
+//#endregion
+export { KinoraVitestReporter as default };

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@kinora/vitest-reporter",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "0.2.0",
+  "description": "Vitest reporter that uploads browser-mode and Storybook test results to a kinora server",
+  "author": "Joris Gallot",
+  "license": "MIT",
+  "homepage": "https://github.com/kinora-dev/kinora#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kinora-dev/kinora.git",
+    "directory": "packages/vitest-reporter"
+  },
+  "bugs": "https://github.com/kinora-dev/kinora/issues",
+  "keywords": [
+    "vitest",
+    "storybook",
+    "reporter",
+    "test-report",
+    "ci",
+    "kinora"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.20.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "vitest": ">=4.1.11"
+  },
+  "dependencies": {
+    "@kinora/core": "0.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "@vitest/coverage-v8": "^5.0.3",
+    "tsdown": "^0.23.1",
+    "typescript": "~6.0.3",
+    "vitest": "^5.0.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --coverage"
+  }
 }