@vitest-agent/reporter 4.1.1 → 5.0.1

package/defaultReporter.js

@@ -1,11 +1,8 @@
 import { renderGithubLog, toDisplayPath } from "./githubLog.js";
 import { LiveViewEnv, startLiveView } from "./liveView.js";
 import { Doc, Render, Status } from "@effected/cli";
-import { CliUi, UiProvider } from "@effected/cli/ui";
 import { RUN_REPORT_FILE_SCHEMA_URL, countSuiteFailures, isTimeoutError } from "@vitest-agent/sdk";
-import { classifyOutcome, classifyRunShape, dispatch, dispatcherTable, reduceRenderStateAll, synthesizeFromAgentReport } from "@vitest-agent/ui";
-import { Effect } from "effect";
-import { createElement } from "react";
+import { classifyOutcome, classifyRunShape, dispatch, reduceRenderStateAll, synthesizeFromAgentReport } from "@vitest-agent/ui";
 
 //#region src/defaultReporter.ts
 const countTimeouts = (report) => {
@@ -128,10 +125,21 @@ const renderAgentStringForReport = (report) => {
 * Returns the agent-string fallback when the matched cell has no Ink
 * half.
 *
+* The output is laid out at `options.width` when given, else at the
+* terminal's width (stdout's columns, else the `COLUMNS` variable), else at
+* 80 columns, which is what a non-TTY run gets. React and Ink are loaded on
+* the first call, never by importing this package.
+*
 * @public
 */
-const renderHumanStringForReport = async (report, options = {}) => {
-	const { renderToString } = await import("ink");
+const renderHumanStringForReport = (report, options = {}) => renderHumanString(report, options, LiveViewEnv);
+/**
+* {@link renderHumanStringForReport} over an explicit environment, which
+* decides the theme, the glyphs and the terminal width.
+*
+* @internal
+*/
+const renderHumanString = async (report, options, env) => {
 	const events = synthesizeFromAgentReport(report);
 	const state = reduceRenderStateAll(events);
 	const projects = [summarizeProject(report)];
@@ -148,11 +156,8 @@ const renderHumanStringForReport = async (report, options = {}) => {
 		noColor: false,
 		osc8: (_url, label) => label
 	};
-	const cell = dispatcherTable[inputs.shape][inputs.outcome];
-	if (cell.ink === void 0) return dispatch(inputs, opts);
-	const columns = options.width ?? 80;
-	const context = await Effect.runPromise(CliUi.context.pipe(Effect.provide(LiveViewEnv)));
-	return renderToString(createElement(UiProvider, { value: context }, cell.ink(inputs, opts)), { columns });
+	const { renderInkReport } = await import("./humanReport.js");
+	return await renderInkReport(inputs, opts, env, options.width) ?? dispatch(inputs, opts);
 };
 const NON_STABLE_SUMMARY_CLASSIFICATIONS = [
 	"new-failure",
@@ -329,7 +334,10 @@ const renderGithubSummary = (input) => {
 const DefaultVitestAgentReporter = (kit) => {
 	const live = kit.config.consoleMode === "stream" && kit.runEvents !== void 0 ? startLiveView(kit.runEvents) : void 0;
 	return {
-		...live !== void 0 ? { close: live.close } : {},
+		...live !== void 0 ? {
+			close: live.close,
+			printStrayLine: live.printStrayLine
+		} : {},
 		render(input, renderKit) {
 			const out = [];
 			if (shouldRenderForMode(renderKit.config.consoleMode)) {
@@ -371,4 +379,4 @@ const DefaultVitestAgentReporter = (kit) => {
 };
 
 //#endregion
-export { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };
+export { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanString, renderHumanStringForReport, resolveCellOptions };

package/humanReport.js

@@ -0,0 +1,36 @@
+import { CliUi, UiProvider } from "@effected/cli/ui";
+import { Effect } from "effect";
+import { TerminalEnv } from "@effected/env";
+import { dispatchInk } from "@vitest-agent/ui/ink";
+import { renderToString } from "ink";
+import { createElement } from "react";
+
+//#region src/humanReport.ts
+/** The width a report is laid out at when no terminal width is known. */
+const FALLBACK_COLUMNS = 80;
+/**
+* Render the matched cell's Ink half to a string, or `null` when the cell
+* has no Ink half (the caller falls back to the agent string).
+*
+* The layout width is `width` when given, else the terminal's
+* (`TerminalEnv.width`: stdout's columns, else `COLUMNS`, else 80 — so a
+* non-TTY run lays out at 80).
+*
+* @internal
+*/
+const renderInkReport = async (inputs, opts, env, width) => {
+	const element = dispatchInk(inputs, opts);
+	if (element === null) return null;
+	const { context, columns } = await Effect.runPromise(Effect.gen(function* () {
+		const context = yield* CliUi.context;
+		const terminal = yield* TerminalEnv;
+		return {
+			context,
+			columns: width ?? terminal.width(FALLBACK_COLUMNS)
+		};
+	}).pipe(Effect.provide(env)));
+	return renderToString(createElement(UiProvider, { value: context }, element), { columns });
+};
+
+//#endregion
+export { renderInkReport };

package/index.d.ts

@@ -1,4 +1,6 @@
 import { PubSub, Schema } from "effect";
+import "@effected/cli";
+import "@effected/env";
 //#region ../sdk/dist/dev/pkg/index.d.ts
 /**
  * Per-file coverage data including uncovered line ranges.
@@ -171,6 +173,21 @@ declare const RenderState: Schema.Struct<{
     readonly expected: Schema.optional<Schema.String>;
     readonly received: Schema.optional<Schema.String>;
   }>>;
+  /**
+   * What the run wrote straight to the terminal, past Vitest's console
+   * capture, folded from `RunFinished.strayOutput`. Absent when the run
+   * wrote nothing stray.
+   */
+  readonly strayOutput: Schema.optional<Schema.Struct<{
+    readonly total: Schema.Number;
+    readonly stdout: Schema.Number;
+    readonly stderr: Schema.Number;
+    readonly bytes: Schema.Number;
+    readonly samples: Schema.$Array<Schema.Struct<{
+      readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+      readonly text: Schema.String;
+    }>>;
+  }>>;
 }>;
 /** @public */
 type RenderState = typeof RenderState.Type;
@@ -509,6 +526,16 @@ declare const AgentReport: Schema.Struct<{
       readonly files: Schema.Number;
     }>>;
   }>>;
+  readonly strayOutput: Schema.optional<Schema.Struct<{
+    readonly total: Schema.Number;
+    readonly stdout: Schema.Number;
+    readonly stderr: Schema.Number;
+    readonly bytes: Schema.Number;
+    readonly samples: Schema.$Array<Schema.Struct<{
+      readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+      readonly text: Schema.String;
+    }>>;
+  }>>;
 }>;
 /** @public */
 type AgentReport = typeof AgentReport.Type;
@@ -541,13 +568,6 @@ type Environment = typeof Environment.Type;
 declare const Executor: Schema.Literals<readonly ["human", "agent", "ci"]>;
 /** @public */
 type Executor = typeof Executor.Type;
-/**
- * Output format for the reporter pipeline.
- * @public
- */
-declare const OutputFormat: Schema.Literals<readonly ["terminal", "markdown", "json", "vitest-bypass", "silent", "ci-annotations"]>;
-/** @public */
-type OutputFormat = typeof OutputFormat.Type;
 /**
  * Level of detail in reporter output.
  * @public
@@ -767,6 +787,21 @@ declare const RunEvent: Schema.Union<readonly [Schema.TaggedStruct<"RunStarted",
     readonly expected: Schema.optional<Schema.String>;
     readonly received: Schema.optional<Schema.String>;
   }>>>;
+  /**
+   * What the run wrote straight to the terminal, past Vitest's console
+   * capture (`AgentReport.strayOutput`). Optional: absent when the run
+   * wrote nothing stray, and in older replay data.
+   */
+  readonly strayOutput: Schema.optional<Schema.Struct<{
+    readonly total: Schema.Number;
+    readonly stdout: Schema.Number;
+    readonly stderr: Schema.Number;
+    readonly bytes: Schema.Number;
+    readonly samples: Schema.$Array<Schema.Struct<{
+      readonly stream: Schema.Literals<readonly ["stdout", "stderr"]>;
+      readonly text: Schema.String;
+    }>>;
+  }>>;
 }>]>;
 /** @public */
 type RunEvent = typeof RunEvent.Type;
@@ -829,10 +864,10 @@ type Transport = typeof Transport.Type;
  * plugin always populates it in practice — the option exists for clarity
  * and to leave room for future "no-persistence" experiments.
  *
- * `format` and `detail` are pre-resolved by the plugin (via
- * `FormatSelector` / `DetailResolver`) but reporters that want to override
- * can ignore them. `noColor` is the resolved value of the `NO_COLOR` env
- * var; reporters use it to gate ANSI escapes and OSC-8 hyperlinks.
+ * `detail` is pre-resolved by the plugin (via `DetailResolver`) but
+ * reporters that want to override can ignore it. `noColor` is the resolved
+ * value of the `NO_COLOR` env var; reporters use it to gate ANSI escapes and
+ * OSC-8 hyperlinks.
  * @public
  */
 interface ResolvedReporterConfig {
@@ -871,7 +906,6 @@ interface ResolvedReporterConfig {
    * @internal
    */
   readonly coverageMode: "full" | "ui-only";
-  readonly format: OutputFormat;
   readonly detail: DetailLevel;
   readonly noColor: boolean;
   readonly runCommand?: string;
@@ -993,6 +1027,24 @@ interface VitestAgentReporter {
    * awaits it and treats a rejection as a logged warning.
    */
   readonly close?: () => Promise<void>;
+  /**
+   * Print one whole line of stray output: bytes a test process wrote
+   * straight to the terminal, past Vitest's console capture (a child
+   * process spawned with inherited stdio is the usual source). A reporter
+   * that draws in place (a live view) implements this to print the line
+   * above its drawing instead of under it, where the next redraw would
+   * strand it. Return `true` when the line was taken; `false` sends it to
+   * the terminal unchanged.
+   *
+   * The plugin calls it synchronously, from the factory's return until just
+   * before {@link VitestAgentReporter.close | close}, only for lines bound
+   * for the process's own stdout or stderr (never when Vitest was given
+   * other streams, as MCP's `run_tests` does), and only while it owns the
+   * console (any mode but `passthrough`). The line carries no trailing
+   * newline. Optional; without it every line passes through unchanged. The
+   * run's stray output is reported on `AgentReport.strayOutput` either way.
+   */
+  readonly printStrayLine?: (stream: "stdout" | "stderr", line: string) => boolean;
 }
 /**
  * Factory that the plugin's `reporter` option accepts. The plugin calls
@@ -1056,6 +1108,11 @@ export declare const renderAgentStringForReport: (report: AgentReport) => string
  * Returns the agent-string fallback when the matched cell has no Ink
  * half.
  *
+ * The output is laid out at `options.width` when given, else at the
+ * terminal's width (stdout's columns, else the `COLUMNS` variable), else at
+ * 80 columns, which is what a non-TTY run gets. React and Ink are loaded on
+ * the first call, never by importing this package.
+ *
  * @public
  */
 export declare const renderHumanStringForReport: (report: AgentReport, options?: {
@@ -1097,5 +1154,5 @@ export declare const DefaultVitestAgentReporter: VitestAgentReporterFactory;
  */
 export declare const CURRENT_REPORTER_VERSION: string;
 //#endregion
-export type { AgentReport, CellOptions, ConsoleMode, DetailLevel, DispatchInputs, Environment, Executor, FileCoverageReport, OutputFormat, ProjectSummary, RenderState, RenderedOutput, ReporterKit, ReporterRenderInput, ResolvedReporterConfig, ResolvedThresholds, RunEvent, RunOutcome, RunShape, TestClassification, Transport, TrendSummary, VitestAgentReporter, VitestAgentReporterFactory };
+export type { AgentReport, CellOptions, ConsoleMode, DetailLevel, DispatchInputs, Environment, Executor, FileCoverageReport, ProjectSummary, RenderState, RenderedOutput, ReporterKit, ReporterRenderInput, ResolvedReporterConfig, ResolvedThresholds, RunEvent, RunOutcome, RunShape, TestClassification, Transport, TrendSummary, VitestAgentReporter, VitestAgentReporterFactory };
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -8,7 +8,7 @@ import { DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForRe
 *
 * @public
 */
-const CURRENT_REPORTER_VERSION = "4.1.1";
+const CURRENT_REPORTER_VERSION = "5.0.1";
 
 //#endregion
 export { CURRENT_REPORTER_VERSION, DefaultVitestAgentReporter, buildDispatchInputs, renderAgentStringForReport, renderHumanStringForReport, resolveCellOptions };

package/liveView.js

@@ -1,17 +1,22 @@
 import { CliEnv, Doc } from "@effected/cli";
-import { CliUi } from "@effected/cli/ui";
 import { initialRenderState } from "@vitest-agent/sdk";
-import { SPINNER_FRAME_MS, StreamApp, reduceRenderState, renderAgent } from "@vitest-agent/ui";
-import { Cause, Deferred, Effect, Exit, Layer, PubSub, Scope } from "effect";
-import { createElement } from "react";
+import { SPINNER_FRAME_MS, reduceRenderState, renderAgent } from "@vitest-agent/ui";
 import * as NodeServices from "@effect/platform-node/NodeServices";
+import { CliUi } from "@effected/cli/ui";
+import { Cause, Deferred, Effect, Exit, Layer, PubSub, Scope } from "effect";
 
 //#region src/liveView.ts
 /**
 * The `stream` console mode's live view: the plugin's run-event channel
-* folded through `reduceRenderState` and drawn as {@link StreamApp} by the
+* folded through `reduceRenderState` and drawn as `StreamApp` by the
 * kit's `CliUi.live`.
 *
+* The drawing lives in `streamView.ts`, loaded through `CliUi.lazyView`, so
+* this module (and everything that imports it) loads neither React nor Ink:
+* the view module loads only when a run first mounts its Ink frame, and an
+* agent, CI or piped run, which prints the `final` document instead, never
+* loads it.
+*
 * The kit owns the mount: a run mounts at `RunStarted` (or where `begins`
 * says), redraws on every event and on an 80 ms tick, and commits its final
 * frame to scrollback at the terminal event (`RunFinished` /
@@ -45,11 +50,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices";
 const liveViewOptions = {
 	initial: initialRenderState,
 	reduce: reduceRenderState,
-	render: (state, frame) => createElement(StreamApp, {
-		state,
-		frameIndex: frame,
-		nowMs: frame * SPINNER_FRAME_MS
-	}),
+	render: CliUi.lazyView(() => import("./streamView.js")),
 	isStart: (event) => event._tag === "RunStarted",
 	isTerminal: (event) => event._tag === "RunFinished" || event._tag === "RunTimedOut",
 	begins: (event, before, after) => event._tag === "RunStarted" || before.phase === "idle" && after.phase !== "idle",
@@ -60,13 +61,27 @@ const liveViewOptions = {
 /**
 * The environment a Vitest-hosted live view reads: the kit's `CliEnv` over
 * Node's stdio and terminal. It builds `CliTheme` (colour from the terminal,
-* glyphs `auto`, so `TERM=dumb` draws ASCII) and sets `CliInteractive` (a
+* glyphs `auto`, so `TERM=dumb` draws ASCII) and `TerminalEnv` (the width
+* the report-time human render lays out at), and sets `CliInteractive` (a
 * human audience with a TTY on stdin and stdout).
 *
 * @internal
 */
 const LiveViewEnv = CliEnv.layer().pipe(Layer.provide(NodeServices.layer));
 /**
+* Print one line of stray output (bytes a test process wrote straight to the
+* terminal) through the view's `logConsole`: above the frame while a run is
+* drawn, straight to the stream otherwise, so it never lands under the frame
+* where the next redraw would strand it.
+*
+* @internal
+*/
+const printAbove = (handle) => (stream, line) => {
+	if (stream === "stderr") handle.logConsole.error(line);
+	else handle.logConsole.log(line);
+	return true;
+};
+/**
 * Start a live view over `channel`. The subscription is taken before this
 * returns, so an event published right after is seen.
 *
@@ -86,9 +101,16 @@ const startLiveView = (channel, env = LiveViewEnv) => {
 	}).pipe(Effect.onExit((exit) => Deferred.done(mounted, exit)), Effect.flatMap((handle) => handle.done), Scope.provide(scope), Effect.provide(env));
 	Effect.runFork(program);
 	let closing;
+	let print;
+	const handle = Effect.runPromise(Deferred.await(mounted));
+	handle.then((mountedHandle) => {
+		if (closing === void 0) print = printAbove(mountedHandle);
+	}, () => void 0);
 	return {
-		handle: Effect.runPromise(Deferred.await(mounted)),
+		handle,
+		printStrayLine: (stream, line) => print?.(stream, line) ?? false,
 		close: () => {
+			print = void 0;
 			closing ??= Effect.runPromise(Deferred.await(mounted).pipe(Effect.flatMap((handle) => handle.close), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.logWarning("vitest-agent: the live view ended with an error", cause)), Effect.ensuring(Scope.close(scope, Exit.void))));
 			return closing;
 		}
@@ -96,4 +118,4 @@ const startLiveView = (channel, env = LiveViewEnv) => {
 };
 
 //#endregion
-export { LiveViewEnv, liveViewOptions, startLiveView };
+export { LiveViewEnv, liveViewOptions, printAbove, startLiveView };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitest-agent/reporter",
-	"version": "4.1.1",
+	"version": "5.0.1",
 	"private": false,
 	"description": "Named VitestAgentReporterFactory implementations for the vitest-agent ecosystem.",
 	"keywords": [
@@ -39,15 +39,15 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effect/platform-node": "^4.0.0",
-		"@vitest-agent/sdk": "6.1.0",
-		"@vitest-agent/ui": "4.1.0",
-		"effect": "^4.0.0",
-		"ink": "^7.1.1",
+		"@effect/platform-node": "^4.0.2",
+		"@vitest-agent/sdk": "7.0.0",
+		"@vitest-agent/ui": "5.0.1",
+		"effect": "^4.0.2",
+		"ink": "^8.0.0",
 		"react": "^19.3.0"
 	},
 	"peerDependencies": {
-		"@effected/cli": "^0.12.0",
+		"@effected/cli": "^0.16.0",
 		"@effected/env": "^0.1.0",
 		"@effected/glob": "^0.10.0",
 		"@effected/walker": "^0.15.0",

package/streamView.js

@@ -0,0 +1,13 @@
+import { SPINNER_FRAME_MS } from "@vitest-agent/ui";
+import { StreamApp } from "@vitest-agent/ui/ink";
+import { createElement } from "react";
+
+//#region src/streamView.ts
+const streamView = (state, frame) => createElement(StreamApp, {
+	state,
+	frameIndex: frame,
+	nowMs: frame * SPINNER_FRAME_MS
+});
+
+//#endregion
+export { streamView as default };