@vitest-agent/ui 1.0.0

package/dispatcher/helpers.js

@@ -0,0 +1,186 @@
+import { formatDisplayDuration } from "../format-duration.js";
+
+//#region src/dispatcher/helpers.ts
+/**
+* Truncate a line to a maximum width with an ellipsis suffix.
+*/
+const truncate = (line, max) => {
+	if (line.length <= max) return line;
+	const slice = max - 1;
+	if (slice <= 0) return "…";
+	return `${line.slice(0, slice)}…`;
+};
+/**
+* Format the `Tests:` header line — `<pass>/<total> passed[, <fail> failed][, <skip> skipped] (Xms)`.
+*/
+const formatTotals = (state) => {
+	const { passCount, failCount, skipCount, durationMs } = state.totals;
+	const parts = [`${passCount}/${passCount + failCount + skipCount} passed`];
+	if (failCount > 0) parts.push(`${failCount} failed`);
+	if (skipCount > 0) parts.push(`${skipCount} skipped`);
+	return `Tests: ${parts.join(", ")} (${formatDisplayDuration(durationMs)})`;
+};
+/**
+* Locate the sole {@link TestRecord} in a `single-test` shape state.
+* Returns `undefined` for malformed inputs; cells fall through to an
+* empty rendering rather than throwing.
+*/
+const soleTest = (state) => {
+	const moduleEntries = Object.values(state.modules);
+	if (moduleEntries.length !== 1) return void 0;
+	const sole = moduleEntries[0];
+	if (sole?.tests.length !== 1) return void 0;
+	return sole.tests[0];
+};
+/**
+* Locate the sole module path in a `single-file` shape state.
+*/
+const soleModulePath = (state) => {
+	if (state.moduleOrder.length !== 1) return void 0;
+	return state.moduleOrder[0];
+};
+/**
+* Format a test name in `<suite > test name>` form, or just `<test name>`
+* when no suite path is present.
+*/
+const formatTestName = (test) => {
+	if (test.suitePath.length === 0) return test.testName;
+	return `${test.suitePath.join(" > ")} > ${test.testName}`;
+};
+/**
+* Render one failure block — `- <path > suite > name> [classification]`
+* followed by the indented message and diff. Stack traces are omitted
+* by default to keep the agent string compact.
+*/
+const formatFailure = (f, width) => {
+	const suite = f.suitePath.length > 0 ? `${f.suitePath.join(" > ")} > ` : "";
+	const classification = f.classification !== null ? ` [${f.classification}]` : "";
+	const lines = [`- ${f.modulePath} > ${suite}${f.testName}${classification}`];
+	if (f.error?.message !== void 0) {
+		const firstLine = f.error.message.split("\n", 1)[0] ?? "";
+		lines.push(`  ${truncate(firstLine, Math.max(20, width - 2))}`);
+	}
+	if (f.error?.diff !== void 0) for (const diffLine of f.error.diff.split("\n")) lines.push(`  ${truncate(diffLine, Math.max(20, width - 2))}`);
+	return lines;
+};
+/**
+* One coverage judgment line — `Coverage: ✓ all metrics meet thresholds`
+* for a clean run, `Coverage: ✗ <N> files below minimum thresholds (...)`
+* for a violation. Returns `null` when the run carries no coverage block.
+*/
+const formatCoverageJudgmentLine = (state) => {
+	const cov = state.coverage;
+	if (cov === null) return null;
+	if (cov.violations.length === 0) return "Coverage: ✓ all metrics meet thresholds";
+	const metrics = cov.violations.map((v) => v.metric).join(", ");
+	const fileCount = countLowCoverageFiles(cov.gaps);
+	return `Coverage: ✗ ${fileCount} ${fileCount === 1 ? "file" : "files"} below minimum thresholds (${metrics})`;
+};
+const countLowCoverageFiles = (gaps) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const g of gaps) seen.add(g.file);
+	return seen.size;
+};
+/**
+* Format the `Trend: …` line for runs that carry trend history.
+* Returns `null` when no trend is available.
+*/
+const formatTrendLine = (trend) => {
+	if (trend === null) return null;
+	const runs = trend.runCount === 1 ? "1 run" : `${trend.runCount} runs`;
+	return `Trend: ${trend.direction} (${runs})`;
+};
+/**
+* Format a compact projects-table line for one project. Pads the name
+* column to `nameWidth` so a column of rows aligns when joined with
+* newlines. Status glyph is `✓` for clean projects, `✗` for any
+* project carrying failures or violations.
+*/
+const formatProjectRow = (project, nameWidth) => {
+	const total = project.passCount + project.failCount + project.skipCount;
+	const glyph = project.failCount > 0 ? "✗" : "✓";
+	const counts = project.failCount > 0 ? `${project.passCount}/${total} passed, ${project.failCount} failed` : `${project.passCount} passed`;
+	const tagSuffix = formatTagCountSuffix(project.tagCounts);
+	const base = `  ${glyph} ${project.name.padEnd(nameWidth)} ${counts} (${formatDisplayDuration(project.durationMs)})`;
+	return tagSuffix.length === 0 ? base : `${base}  ${tagSuffix}`;
+};
+const formatTagCountSuffix = (tagCounts) => {
+	if (tagCounts === void 0) return "";
+	const entries = Object.entries(tagCounts);
+	if (entries.length <= 1) return "";
+	return [...entries].sort(([a], [b]) => a.localeCompare(b)).map(([tag, count]) => `${tag}:${count}`).join("  ");
+};
+/**
+* Format the `Projects (N):` block as an array of lines including the
+* leading header and each project row. The longest project name sets
+* the padded column width so the counts align vertically.
+*/
+const formatProjectsTable = (projects) => {
+	if (projects.length === 0) return [];
+	const nameWidth = projects.reduce((max, p) => Math.max(max, p.name.length), 0);
+	return [`Projects (${projects.length}):`, ...projects.map((p) => formatProjectRow(p, nameWidth))];
+};
+/**
+* Format the `Total:` footer for a workspace run.
+*/
+const formatWorkspaceTotal = (projects) => {
+	let pass = 0;
+	let fail = 0;
+	let skip = 0;
+	let durationMs = 0;
+	for (const p of projects) {
+		pass += p.passCount;
+		fail += p.failCount;
+		skip += p.skipCount;
+		durationMs += p.durationMs;
+	}
+	const total = pass + fail + skip;
+	const parts = [`${pass}/${total} passed`];
+	if (fail > 0) parts.push(`${fail} failed`);
+	if (skip > 0) parts.push(`${skip} skipped`);
+	return `Total: ${parts.join(", ")} (${formatDisplayDuration(durationMs)})`;
+};
+const TABLE_COL_FILE = 60;
+/**
+* Format the `Files below aspirational target:` block — a pipe-delimited
+* table truncated to the first `limit` files with a "+N more" suffix.
+* Returns an empty array when `belowTarget` is empty.
+*/
+const formatBelowTargetTable = (belowTarget, limit) => {
+	if (belowTarget.length === 0) return [];
+	const top = belowTarget.slice(0, limit);
+	const omitted = belowTarget.length - top.length;
+	const header = [
+		"Files below aspirational target:",
+		buildTableSeparator(),
+		buildTableHeader(),
+		buildTableSeparator()
+	];
+	const rows = top.map((file) => buildTableRow(file));
+	const footer = [];
+	if (omitted > 0) footer.push(`… ${omitted} more (use the test_coverage MCP tool for the full list)`);
+	return [
+		...header,
+		...rows,
+		...footer
+	];
+};
+const buildTableSeparator = () => {
+	return `${"-".repeat(TABLE_COL_FILE)}|---------|---------|---------|---------|-------------------`;
+};
+const buildTableHeader = () => {
+	return ` ${"File".padEnd(TABLE_COL_FILE - 1)}| % Stmts | % Branch| % Funcs | % Lines | Uncovered Line #s`;
+};
+const buildTableRow = (file) => {
+	return `${` ${truncate(file.file, TABLE_COL_FILE - 2).padEnd(TABLE_COL_FILE - 1)}`}|${pctCell(file.summary.statements)}|${pctCell(file.summary.branches)}|${pctCell(file.summary.functions)}|${pctCell(file.summary.lines)}|${` ${file.uncoveredLines}`}`;
+};
+const pctCell = (n) => {
+	const text = `${Math.round(n)}`;
+	const pad = Math.max(0, 9 - text.length);
+	const left = Math.floor(pad / 2);
+	const right = pad - left;
+	return `${" ".repeat(left + 1)}${text}${" ".repeat(right)}`;
+};
+
+//#endregion
+export { formatBelowTargetTable, formatCoverageJudgmentLine, formatFailure, formatProjectsTable, formatTestName, formatTotals, formatTrendLine, formatWorkspaceTotal, soleModulePath, soleTest };

package/dispatcher/ink-helpers.js

@@ -0,0 +1,79 @@
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/dispatcher/ink-helpers.tsx
+/**
+* Ink rendering helpers shared by the dispatcher cells.
+*
+* Most cells re-express their agent-half string in a simple
+* `<Box flexDirection="column">` with one `<Text>` per line plus
+* targeted color coding on glyph characters (✓ green, ✗ red,
+* Trend regressing/improving in matching colors).
+*
+* @packageDocumentation
+*/
+/**
+* Render an agent-string output as a column of Ink Text rows, applying
+* color to the leading status glyph on each line.
+*/
+const renderAgentStringAsInk = (agentString) => {
+	return /* @__PURE__ */ jsx(Box, {
+		flexDirection: "column",
+		children: agentString.split("\n").map((line, idx) => /* @__PURE__ */ jsx(Text, { children: colorize(line) }, `${idx}-${line}`))
+	});
+};
+const PASS_GLYPH = "✓";
+const FAIL_GLYPH = "✗";
+const colorize = (line) => {
+	const trimmed = line.trimStart();
+	if (trimmed.startsWith(PASS_GLYPH)) {
+		const idx = line.indexOf(PASS_GLYPH);
+		return /* @__PURE__ */ jsxs(Fragment, { children: [
+			line.slice(0, idx),
+			/* @__PURE__ */ jsx(Text, {
+				color: "green",
+				children: PASS_GLYPH
+			}),
+			line.slice(idx + 1)
+		] });
+	}
+	if (trimmed.startsWith(FAIL_GLYPH)) {
+		const idx = line.indexOf(FAIL_GLYPH);
+		return /* @__PURE__ */ jsxs(Fragment, { children: [
+			line.slice(0, idx),
+			/* @__PURE__ */ jsx(Text, {
+				color: "red",
+				children: FAIL_GLYPH
+			}),
+			line.slice(idx + 1)
+		] });
+	}
+	if (line.startsWith("Trend: regressing")) return /* @__PURE__ */ jsx(Text, {
+		color: "yellow",
+		children: line
+	});
+	if (line.startsWith("Trend: improving")) return /* @__PURE__ */ jsx(Text, {
+		color: "green",
+		children: line
+	});
+	if (line.startsWith("Coverage: ✓")) return /* @__PURE__ */ jsx(Text, {
+		color: "green",
+		children: line
+	});
+	if (line.startsWith("Coverage: ✗")) return /* @__PURE__ */ jsx(Text, {
+		color: "red",
+		children: line
+	});
+	if (line.startsWith("Failures:")) return /* @__PURE__ */ jsx(Text, {
+		bold: true,
+		children: line
+	});
+	if (line.startsWith("Use `")) return /* @__PURE__ */ jsx(Text, {
+		dimColor: true,
+		children: line
+	});
+	return line;
+};
+
+//#endregion
+export { renderAgentStringAsInk };

package/format-duration.js

@@ -0,0 +1,34 @@
+//#region src/format-duration.ts
+/**
+* Shared display formatter for run / module / test durations.
+*
+* Vitest hands the reporter full-float millisecond durations
+* (`14.87745800000016`). Rendering those verbatim is noise. This is
+* the single formatter every render path calls — `render-agent.ts`,
+* the `render-ink/` components, the dispatcher cells, and `StreamApp`
+* — so a duration looks the same wherever it appears.
+*
+* Display only. Full-precision durations continue to persist to the
+* database unchanged; nothing in the trend / baseline / classification
+* pipeline reads a duration through a formatter.
+*/
+const SECOND_MS = 1e3;
+/**
+* Format a duration in milliseconds for display.
+*
+* Sub-second values round to one decimal place and render as `<N.N>ms`;
+* values at or above one second render as `<N.N>s`. A value that rounds
+* to a whole number drops the trailing `.0` naturally (`Number`
+* stringification), so `1000` → `1s` and `250` → `250ms`.
+*
+* @param ms - duration in milliseconds
+* @returns formatted duration string
+* @public
+*/
+const formatDisplayDuration = (ms) => {
+	if (ms < SECOND_MS) return `${Math.round(ms * 10) / 10}ms`;
+	return `${Math.round(ms / SECOND_MS * 10) / 10}s`;
+};
+
+//#endregion
+export { formatDisplayDuration };