@vitest-agent/ui 1.0.0

package/synthesize.js

@@ -0,0 +1,335 @@
+import { isTimeoutError } from "@vitest-agent/sdk";
+
+//#region src/synthesize.ts
+const ISO_ZERO = "1970-01-01T00:00:00.000Z";
+const normalizeTestState = (state) => {
+	if (state === "passed") return "passed";
+	if (state === "failed") return "failed";
+	if (state === "skipped") return "skipped";
+	return "pending";
+};
+const formatStack = (stacks) => {
+	if (!stacks || stacks.length === 0) return void 0;
+	return stacks.map((frame) => {
+		if (typeof frame === "string") return frame;
+		return `at ${frame.method.length > 0 ? frame.method : "<anonymous>"} (${frame.file}:${frame.line}:${frame.column})`;
+	}).join("\n");
+};
+const mapTestError = (errors) => {
+	if (!errors || errors.length === 0) return void 0;
+	const first = errors[0];
+	if (first === void 0) return void 0;
+	const stack = formatStack(first.stacks);
+	const out = { message: first.message };
+	if (first.diff !== void 0) out.diff = first.diff;
+	if (stack !== void 0) out.stack = stack;
+	return out;
+};
+const collectSuitePath = (test) => {
+	const path = [];
+	let cursor = test.parent;
+	while (cursor !== void 0 && cursor.type === "suite") {
+		path.unshift(cursor.name);
+		cursor = cursor.parent;
+	}
+	return path;
+};
+/**
+* Project a fully-completed Vitest run into the canonical
+* `RunEvent` stream. The output is deterministic given a
+* stable input.
+*
+* @param modules - the array of completed Vitest test modules
+* @param options - optional metadata to thread into the event stream
+* @returns an ordered array of run events
+* @public
+*/
+const synthesizeRunEvents = (modules, options = {}) => {
+	const runId = options.runId ?? "synthetic-run";
+	const configHash = options.configHash ?? "synthetic-config";
+	const startedAt = options.startedAt ?? ISO_ZERO;
+	const finishedAt = options.finishedAt ?? startedAt;
+	const classifications = options.classifications ?? /* @__PURE__ */ new Map();
+	const events = [];
+	events.push({
+		_tag: "RunStarted",
+		runId,
+		startedAt,
+		configHash
+	});
+	for (const mod of modules) events.push({
+		_tag: "ModuleQueued",
+		modulePath: mod.relativeModuleId
+	});
+	let totalPass = 0;
+	let totalFail = 0;
+	let totalSkip = 0;
+	let totalDuration = 0;
+	let totalTimeout = 0;
+	const failureBatches = [];
+	for (const mod of modules) {
+		events.push({
+			_tag: "ModuleStarted",
+			modulePath: mod.relativeModuleId,
+			startedAt
+		});
+		let pass = 0;
+		let fail = 0;
+		let skip = 0;
+		let moduleTimeout = 0;
+		const moduleDuration = mod.diagnostic()?.duration ?? 0;
+		totalDuration += moduleDuration;
+		const moduleTagCounts = {};
+		for (const test of mod.children.allTests()) {
+			const suitePath = collectSuitePath(test);
+			const result = test.result();
+			const diag = test.diagnostic();
+			const status = normalizeTestState(result?.state);
+			const durationMs = diag?.duration ?? 0;
+			for (const tag of test.tags) moduleTagCounts[tag] = (moduleTagCounts[tag] ?? 0) + 1;
+			events.push({
+				_tag: "TestStarted",
+				modulePath: mod.relativeModuleId,
+				testName: test.name,
+				suitePath
+			});
+			const error = mapTestError(result?.errors);
+			const firstErrorMsg = result?.errors?.[0]?.message;
+			const timedOut = status === "failed" && firstErrorMsg !== void 0 && isTimeoutError({ message: firstErrorMsg });
+			if (timedOut) moduleTimeout++;
+			events.push({
+				_tag: "TestFinished",
+				modulePath: mod.relativeModuleId,
+				testName: test.name,
+				suitePath,
+				status,
+				durationMs,
+				...error !== void 0 && { error },
+				...timedOut && { timedOut: true }
+			});
+			if (status === "passed") pass++;
+			else if (status === "failed") {
+				if (!timedOut) fail++;
+				failureBatches.push({
+					modulePath: mod.relativeModuleId,
+					testName: test.name
+				});
+			} else skip++;
+		}
+		totalTimeout += moduleTimeout;
+		const hasTagCounts = Object.keys(moduleTagCounts).length > 0;
+		events.push({
+			_tag: "ModuleFinished",
+			modulePath: mod.relativeModuleId,
+			passCount: pass,
+			failCount: fail,
+			skipCount: skip,
+			durationMs: moduleDuration,
+			...moduleTimeout > 0 && { timeoutCount: moduleTimeout },
+			...hasTagCounts && { tagCounts: moduleTagCounts }
+		});
+		totalPass += pass;
+		totalFail += fail;
+		totalSkip += skip;
+	}
+	if (options.coverage !== void 0) {
+		const cov = options.coverage;
+		events.push({
+			_tag: "CoverageReady",
+			metrics: cov.metrics,
+			thresholds: cov.thresholds,
+			gaps: cov.gaps
+		});
+		if (cov.violations !== void 0) for (const v of cov.violations) events.push({
+			_tag: "ThresholdViolation",
+			metric: v.metric,
+			expected: v.expected,
+			actual: v.actual
+		});
+	}
+	for (const failure of failureBatches) {
+		const classification = classifications.get(failure.testName);
+		if (classification !== void 0) events.push({
+			_tag: "FailureClassified",
+			modulePath: failure.modulePath,
+			testName: failure.testName,
+			classification
+		});
+	}
+	if (options.suggestedActions !== void 0) for (const action of options.suggestedActions) events.push({
+		_tag: "SuggestedAction",
+		severity: action.severity,
+		title: action.title,
+		detail: action.detail,
+		...action.targetTool !== void 0 && { targetTool: action.targetTool }
+	});
+	events.push({
+		_tag: "RunFinished",
+		runId,
+		finishedAt,
+		passCount: totalPass,
+		failCount: totalFail,
+		skipCount: totalSkip,
+		durationMs: totalDuration,
+		...totalTimeout > 0 && { timeoutCount: totalTimeout }
+	});
+	return events;
+};
+const coverageReportToBlock = (report) => {
+	const cov = report.coverage;
+	if (cov === void 0) return void 0;
+	const violations = [];
+	for (const metric of [
+		"lines",
+		"branches",
+		"functions",
+		"statements"
+	]) {
+		const expected = cov.thresholds.global[metric];
+		const actual = cov.totals[metric];
+		if (expected !== void 0 && actual < expected) violations.push({
+			metric,
+			expected,
+			actual
+		});
+	}
+	const gaps = cov.lowCoverage.map((f) => ({
+		file: f.file,
+		missing: f.summary,
+		uncoveredLines: f.uncoveredLines.length > 0 ? f.uncoveredLines : void 0
+	}));
+	return {
+		metrics: cov.totals,
+		thresholds: cov.thresholds.global,
+		gaps,
+		violations
+	};
+};
+/**
+* Bridge a persisted `AgentReport` into a `RunEvent` stream.
+*
+* `AgentReport` stores only failed modules in detail; passed-only modules
+* are summarized via `summary.passed` without per-module breakdown. The
+* synthesized stream reflects this — it emits per-test events for the
+* failed modules and lets `RunFinished` carry the authoritative totals.
+* Renderers see "N passed, M failed" in the header while the Modules
+* section enumerates only the failing modules.
+*
+* @param report - the persisted agent report to synthesize from
+* @param options - optional overrides for run metadata
+* @returns an ordered array of run events
+* @public
+*/
+const synthesizeFromAgentReport = (report, options = {}) => {
+	const runId = options.runId ?? report.timestamp;
+	const startedAt = options.startedAt ?? report.timestamp;
+	const finishedAt = options.finishedAt ?? report.timestamp;
+	const configHash = options.configHash ?? "agent-report";
+	const events = [];
+	events.push({
+		_tag: "RunStarted",
+		runId,
+		startedAt,
+		configHash
+	});
+	for (const mod of report.failed) events.push({
+		_tag: "ModuleQueued",
+		modulePath: mod.file
+	});
+	let totalTimeoutCount = 0;
+	for (const mod of report.failed) {
+		events.push({
+			_tag: "ModuleStarted",
+			modulePath: mod.file,
+			startedAt
+		});
+		let pass = 0;
+		let fail = 0;
+		let skip = 0;
+		let moduleTimeoutCount = 0;
+		const moduleDuration = mod.duration ?? 0;
+		for (const test of mod.tests) {
+			const suitePath = test.fullName !== test.name && test.fullName.endsWith(` > ${test.name}`) ? test.fullName.slice(0, -` > ${test.name}`.length).split(" > ").filter((s) => s.length > 0) : [];
+			events.push({
+				_tag: "TestStarted",
+				modulePath: mod.file,
+				testName: test.name,
+				suitePath
+			});
+			const firstError = test.errors?.[0];
+			const error = firstError !== void 0 ? {
+				message: firstError.message,
+				...firstError.diff !== void 0 && { diff: firstError.diff },
+				...firstError.stack !== void 0 && { stack: firstError.stack }
+			} : void 0;
+			const timedOut = test.state === "failed" && firstError !== void 0 && isTimeoutError({ message: firstError.message });
+			if (timedOut) moduleTimeoutCount++;
+			events.push({
+				_tag: "TestFinished",
+				modulePath: mod.file,
+				testName: test.name,
+				suitePath,
+				status: test.state,
+				durationMs: test.duration ?? 0,
+				...error !== void 0 && { error },
+				...timedOut && { timedOut: true }
+			});
+			if (test.state === "passed") pass++;
+			else if (test.state === "failed") {
+				if (!timedOut) fail++;
+			} else skip++;
+		}
+		totalTimeoutCount += moduleTimeoutCount;
+		events.push({
+			_tag: "ModuleFinished",
+			modulePath: mod.file,
+			passCount: pass,
+			failCount: fail,
+			skipCount: skip,
+			durationMs: moduleDuration,
+			...moduleTimeoutCount > 0 && { timeoutCount: moduleTimeoutCount }
+		});
+	}
+	const coverage = coverageReportToBlock(report);
+	if (coverage !== void 0) {
+		events.push({
+			_tag: "CoverageReady",
+			metrics: coverage.metrics,
+			thresholds: coverage.thresholds,
+			gaps: coverage.gaps
+		});
+		if (coverage.violations !== void 0) for (const v of coverage.violations) events.push({
+			_tag: "ThresholdViolation",
+			metric: v.metric,
+			expected: v.expected,
+			actual: v.actual
+		});
+	}
+	for (const mod of report.failed) for (const test of mod.tests) if (test.state === "failed" && test.classification !== void 0) events.push({
+		_tag: "FailureClassified",
+		modulePath: mod.file,
+		testName: test.name,
+		classification: test.classification
+	});
+	if (options.suggestedActions !== void 0) for (const action of options.suggestedActions) events.push({
+		_tag: "SuggestedAction",
+		severity: action.severity,
+		title: action.title,
+		detail: action.detail,
+		...action.targetTool !== void 0 && { targetTool: action.targetTool }
+	});
+	events.push({
+		_tag: "RunFinished",
+		runId,
+		finishedAt,
+		passCount: report.summary.passed,
+		failCount: report.summary.failed,
+		skipCount: report.summary.skipped,
+		durationMs: report.summary.duration,
+		...totalTimeoutCount > 0 && { timeoutCount: totalTimeoutCount }
+	});
+	return events;
+};
+
+//#endregion
+export { synthesizeFromAgentReport, synthesizeRunEvents };

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.9"
+    }
+  ]
+}