@vitest-agent/ui 2.5.3 → 4.0.0

package/render-ink/SuggestedActions.js

@@ -1,11 +1,13 @@
+import { inkStyle } from "../theme.js";
 import { Box, Text } from "ink";
+import { Token } from "@effected/cli";
 import { jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/render-ink/SuggestedActions.tsx
-const SEVERITY_COLOR = {
-	info: "blue",
-	warn: "yellow",
-	blocker: "red"
+const SEVERITY_TOKEN = {
+	info: Token.named("blue"),
+	warn: "warning",
+	blocker: "failure"
 };
 /**
 * Renders the suggested-actions queue as severity-prefixed rows with
@@ -24,7 +26,7 @@ const SuggestedActions = ({ actions }) => {
 			flexDirection: "column",
 			children: [/* @__PURE__ */ jsxs(Box, { children: [
 				/* @__PURE__ */ jsx(Text, {
-					color: SEVERITY_COLOR[action.severity],
+					...inkStyle(SEVERITY_TOKEN[action.severity]),
 					bold: true,
 					children: `  ${action.severity}: `
 				}),

package/render-ink/TagColumns.js

@@ -1,3 +1,4 @@
+import { VitestAgentTokens, inkStyle } from "../theme.js";
 import { Text } from "ink";
 import { jsx, jsxs } from "react/jsx-runtime";
 
@@ -34,7 +35,7 @@ const TagColumns = ({ tags, counts }) => {
 	return /* @__PURE__ */ jsx(Text, { children: tags.map((tag, i) => {
 		const count = counts?.[tag] ?? 0;
 		return /* @__PURE__ */ jsxs(Text, {
-			color: count > 0 ? "cyan" : "gray",
+			...inkStyle(count > 0 ? VitestAgentTokens.tag : VitestAgentTokens.zero),
 			children: [
 				i > 0 ? "  " : "",
 				tag,

package/render-ink/TrendLine.js

@@ -1,14 +1,14 @@
+import { VitestAgentTokens, inkStyle } from "../theme.js";
 import { Text } from "ink";
+import { Fmt } from "@effected/cli";
 import { jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/render-ink/TrendLine.tsx
-/**
-* The one-line trend signal — `Trend: <direction> (<N> runs)`.
-*/
-const COLOR = {
-	improving: "green",
-	regressing: "red",
-	stable: "gray"
+/** A regressing trend is a `warning`, not a failure (the kit's drift decision). */
+const TOKEN = {
+	improving: "success",
+	regressing: "warning",
+	stable: VitestAgentTokens.stable
 };
 /**
 * Renders the one-line trend signal: direction (colored) and run count.
@@ -16,7 +16,7 @@ const COLOR = {
 * @public
 */
 const TrendLine = ({ trend }) => {
-	const runs = trend.runCount === 1 ? "1 run" : `${trend.runCount} runs`;
+	const runs = Fmt.plural(trend.runCount, "run");
 	return /* @__PURE__ */ jsxs(Text, { children: [
 		/* @__PURE__ */ jsx(Text, {
 			bold: true,
@@ -24,7 +24,7 @@ const TrendLine = ({ trend }) => {
 		}),
 		" ",
 		/* @__PURE__ */ jsx(Text, {
-			color: COLOR[trend.direction],
+			...inkStyle(TOKEN[trend.direction]),
 			children: trend.direction
 		}),
 		/* @__PURE__ */ jsxs(Text, {

package/render-ink/index.js

@@ -6,10 +6,10 @@ import { StatusIcon } from "./StatusIcon.js";
 import { ModuleHeader } from "./ModuleHeader.js";
 import { TagColumns, tagUnion } from "./TagColumns.js";
 import { ProjectRow } from "./ProjectRow.js";
-import { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame, spinnerFrameForTime } from "./spinner.js";
+import { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame } from "./spinner.js";
 import { TestRow } from "./TestRow.js";
 import { TrendLine } from "./TrendLine.js";
 import { StreamApp } from "./StreamApp.js";
 import { SuggestedActions } from "./SuggestedActions.js";
 
-export { CountColumns, CoverageBlock, DURATION_CELL_WIDTH, FailureSection, FailuresSection, ModuleHeader, ProjectRow, SPINNER_FRAMES, SPINNER_FRAME_MS, StatusIcon, StreamApp, SuggestedActions, TagColumns, TestRow, TrendLine, spinnerFrame, spinnerFrameForTime, tagUnion };
+export { CountColumns, CoverageBlock, DURATION_CELL_WIDTH, FailureSection, FailuresSection, ModuleHeader, ProjectRow, SPINNER_FRAMES, SPINNER_FRAME_MS, StatusIcon, StreamApp, SuggestedActions, TagColumns, TestRow, TrendLine, spinnerFrame, tagUnion };

package/render-ink/spinner.js

@@ -1,63 +1,34 @@
+import { Glyphs } from "@effected/cli";
+
 //#region src/render-ink/spinner.ts
 /**
-* Hand-rolled Braille spinner for the `stream` live renderer.
-*
-* No `ink-spinner` dependency — that package is a thin wrapper over the
-* same ten Braille characters plus a timer. The `stream` renderer
-* already needs a frame clock for the ticking elapsed column, so the
-* timer is shared and only the frame array lives here.
-*
-* The frame index is presentation state: it is derived from wall-clock
-* time by `createLiveInk` and passed to `StreamApp` as a prop. It never
-* enters the event-sourced `RenderState`.
-*/
-/**
-* The ten Braille spinner frames, in animation order.
+* The Unicode spinner frames, in animation order (`Glyphs.unicode.spinner`).
 *
 * @public
 */
-const SPINNER_FRAMES = [
-	"⠋",
-	"⠙",
-	"⠹",
-	"⠸",
-	"⠼",
-	"⠴",
-	"⠦",
-	"⠧",
-	"⠇",
-	"⠏"
-];
+const SPINNER_FRAMES = Glyphs.unicode.spinner;
 /**
-* How long each spinner frame is held, in milliseconds.
+* How long each spinner frame is held, in milliseconds
+* (`Glyphs.unicode.spinnerIntervalMs`).
 *
 * @public
 */
-const SPINNER_FRAME_MS = 80;
+const SPINNER_FRAME_MS = Glyphs.unicode.spinnerIntervalMs;
 /**
 * Resolve the spinner glyph for a frame index. The index wraps modulo
 * the frame count and tolerates negative values, so a wall-clock-derived
 * index is always valid.
 *
 * @param index - the frame index (wraps modulo frame count)
-* @returns the Braille glyph for the given frame
+* @param glyphs - the glyph set whose frames to draw; Unicode by default
+* @returns the spinner glyph for the given frame
 * @public
 */
-const spinnerFrame = (index) => {
-	const count = SPINNER_FRAMES.length;
-	const wrapped = (Math.trunc(index) % count + count) % count;
-	return SPINNER_FRAMES[wrapped];
+const spinnerFrame = (index, glyphs = Glyphs.unicode) => {
+	const frames = glyphs.spinner;
+	const count = frames.length;
+	return frames[(Math.trunc(index) % count + count) % count] ?? "";
 };
-/**
-* Derive the spinner frame index from a wall-clock timestamp. Using the
-* clock — rather than a monotonic counter — keeps the animation correct
-* across watch-mode remounts with no extra closure state to reset.
-*
-* @param nowMs - current wall-clock time in milliseconds
-* @returns the frame index for the given timestamp
-* @public
-*/
-const spinnerFrameForTime = (nowMs) => Math.floor(nowMs / 80);
 
 //#endregion
-export { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame, spinnerFrameForTime };
+export { SPINNER_FRAMES, SPINNER_FRAME_MS, spinnerFrame };

package/theme.js

@@ -0,0 +1,82 @@
+import { Glyphs, Status, Token } from "@effected/cli";
+import { inkProps } from "@effected/cli/ui";
+
+//#region src/theme.ts
+/**
+* The status vocabulary every vitest-agent render path draws from.
+*
+* @remarks
+* Ranks slot the run statuses into the core ladder: `queued` (25) and
+* `running` (35) sit among the not-yet-decided statuses, and `timeout` (85)
+* is just under `failure` (90), so `Status.worst` over a project's
+* outcomes reads failure, then timeout, then warning.
+*
+* @public
+*/
+const VitestAgentStatus = Status.extend({
+	timeout: {
+		glyph: "⧖",
+		ascii: "[time]",
+		token: Token.hex("#e09a4e"),
+		rank: 85
+	},
+	running: {
+		glyph: "…",
+		ascii: "[..]",
+		token: Token.named("yellow"),
+		rank: 35
+	},
+	queued: {
+		glyph: "·",
+		ascii: "[.]",
+		token: Token.named("blackBright"),
+		rank: 25
+	}
+});
+/**
+* Named accents that are not statuses.
+*
+* @public
+*/
+const VitestAgentTokens = {
+	/** The `[flaky]` / `[new-failure]` classification tag on a failure line. */
+	classification: Token.hex("#c98ae0"),
+	/** A zero in a count column: present for alignment, not signal. */
+	zero: Token.named("blackBright"),
+	/** The `stable` trend direction. */
+	stable: Token.named("blackBright"),
+	/** A non-zero tag count. */
+	tag: Token.named("cyan")
+};
+/**
+* Ink `<Text>` props for a semantic token or an explicit style.
+*
+* @remarks
+* Resolves the token through the kit's pure `Token.resolve` and maps the
+* `Style` with the kit's `inkProps`. No colour level reaches this call
+* site, so `inkProps` with no level emits every prop and Ink's own chalk
+* level, set by `CliUi.live` or `CliUi.context`, gates what is drawn.
+*
+* @param token - a token name or a `Style`
+* @public
+*/
+const inkStyle = (token) => inkProps(Token.resolve(token));
+/**
+* The glyph of a status in a glyph set: its Unicode glyph, or its ASCII
+* fallback when `glyphs` is the kit's ASCII set (the kit's `Status.glyph`).
+*
+* @param name - a status in {@link VitestAgentStatus}
+* @param glyphs - the glyph set, from `Glyphs.select`; Unicode by default
+* @public
+*/
+const statusGlyph = (name, glyphs = Glyphs.unicode) => VitestAgentStatus.glyph(name, glyphs);
+/**
+* Ink `<Text>` props for a status's glyph.
+*
+* @param name - a status in {@link VitestAgentStatus}
+* @public
+*/
+const statusInkStyle = (name) => inkStyle(VitestAgentStatus.def(name).token);
+
+//#endregion
+export { VitestAgentStatus, VitestAgentTokens, inkStyle, statusGlyph, statusInkStyle };

package/pubsub/Channel.js

@@ -1,30 +0,0 @@
-import { Context, Layer, PubSub } from "effect";
-
-//#region src/pubsub/Channel.ts
-/**
-* Service tag for the run-event channel. Consumers depend on this tag;
-* the {@link RunEventChannelLive} layer is the single point at which
-* the underlying Effect `PubSub` is constructed.
-*
-* @public
-*/
-var RunEventChannel = class extends Context.Service()("vitest-agent-ui/RunEventChannel") {};
-/**
-* Default live layer providing an unbounded Effect `PubSub` for
-* the run-event channel. The PubSub is scoped — when the surrounding
-* scope closes, the channel shuts down and any pending subscribers
-* receive their dequeue closure.
-*
-* Unbounded is the right default for the plugin and CLI: events arrive
-* faster than a slow renderer can drain (e.g., several `TestFinished`
-* per millisecond during a large suite), and dropping events would
-* leave the rendered state inconsistent with the runner's truth.
-* If memory pressure becomes a concern, swap in `PubSub.sliding`
-* with a tuned capacity at the call site.
-*
-* @public
-*/
-const RunEventChannelLive = Layer.effect(RunEventChannel, PubSub.unbounded());
-
-//#endregion
-export { RunEventChannel, RunEventChannelLive };

package/pubsub/Publisher.js

@@ -1,37 +0,0 @@
-import { RunEventChannel } from "./Channel.js";
-import { Effect, PubSub } from "effect";
-
-//#region src/pubsub/Publisher.ts
-/**
-* Emit one event onto the channel.
-*
-* Resolves when the event is enqueued. Returns the success boolean
-* from `PubSub.publish` so callers can detect a shutdown
-* channel if needed; in normal operation the result is always `true`.
-*
-* @param event - the run event to publish
-* @returns an Effect that resolves to the publish success boolean
-* @public
-*/
-const publish = (event) => Effect.gen(function* () {
-	const channel = yield* RunEventChannel;
-	return yield* PubSub.publish(channel, event);
-});
-/**
-* Emit a batch of events onto the channel in order.
-*
-* Useful for the CLI replay path where the entire event sequence is
-* materialized synchronously from a database query before any
-* subscriber needs to read it.
-*
-* @param events - iterable of run events to publish in order
-* @returns an Effect that resolves when all events are enqueued
-* @public
-*/
-const publishAll = (events) => Effect.gen(function* () {
-	const channel = yield* RunEventChannel;
-	yield* PubSub.publishAll(channel, events);
-});
-
-//#endregion
-export { publish, publishAll };

package/pubsub/Subscriber.js

@@ -1,77 +0,0 @@
-import { RunEventChannel } from "./Channel.js";
-import { reduceRenderState } from "../reducer.js";
-import { initialRenderState } from "@vitest-agent/sdk";
-import { Effect, PubSub, Stream } from "effect";
-
-//#region src/pubsub/Subscriber.ts
-/**
-* Subscribe, fold the run-event stream into a terminal
-* `RenderState`, and return when `RunFinished` arrives.
-*
-* The subscription is scoped — when this effect completes (or is
-* interrupted), the underlying PubSub releases its slot.
-*
-* @param initial - the initial render state to fold from
-* @returns an Effect that resolves to the terminal render state
-* @public
-*/
-const accumulateUntilFinished = (initial = initialRenderState) => Effect.scoped(Effect.gen(function* () {
-	const channel = yield* RunEventChannel;
-	const subscription = yield* PubSub.subscribe(channel);
-	let state = initial;
-	while (state.phase !== "finished" && state.phase !== "timed-out") {
-		const event = yield* PubSub.take(subscription);
-		state = reduceRenderState(state, event);
-	}
-	return state;
-}));
-/**
-* Run a callback for every projected `RenderState` as events
-* arrive. The stream terminates when the PubSub shuts down (typically
-* when the surrounding scope closes).
-*
-* The host runs this in a forked fiber so the publisher and the
-* renderer can make progress concurrently. Returning an Effect from
-* the callback lets the host suspend further rendering on backpressure
-* (e.g. throttling redraws to the next animation frame).
-*
-* @param onState - callback invoked with each projected render state
-* @param initial - the initial render state to fold from
-* @returns an Effect that completes when the PubSub shuts down
-* @public
-*/
-const forEachRenderState = (onState, initial = initialRenderState) => Effect.scoped(Effect.gen(function* () {
-	const channel = yield* RunEventChannel;
-	yield* Stream.fromPubSub(channel).pipe(Stream.scan(() => initial, reduceRenderState), Stream.runForEach(onState));
-}));
-/**
-* Build an Effect `Stream` of accumulated states over the channel.
-*
-* Lower-level than {@link forEachRenderState} — useful when the host
-* wants to compose with other stream operators (debouncing, throttling,
-* tee-to-file) before running the terminal sink.
-*
-* @param initial - the initial render state to fold from
-* @returns an Effect that resolves to a Stream of render states
-* @public
-*/
-const renderStateStream = (initial = initialRenderState) => Effect.gen(function* () {
-	const channel = yield* RunEventChannel;
-	return Stream.fromPubSub(channel).pipe(Stream.scan(() => initial, reduceRenderState));
-});
-/**
-* Convenience: subscribe and produce a low-level dequeue of raw
-* `RunEvent` values. Mostly for tests and ad-hoc consumers; most
-* application code should prefer {@link forEachRenderState} or
-* {@link renderStateStream}.
-*
-* @returns an Effect that resolves to a dequeue of raw run events
-* @public
-*/
-const subscribeRaw = () => Effect.gen(function* () {
-	const channel = yield* RunEventChannel;
-	return yield* PubSub.subscribe(channel);
-});
-
-//#endregion
-export { accumulateUntilFinished, forEachRenderState, renderStateStream, subscribeRaw };

package/pubsub/index.js

@@ -1,5 +0,0 @@
-import { RunEventChannel, RunEventChannelLive } from "./Channel.js";
-import { publish, publishAll } from "./Publisher.js";
-import { accumulateUntilFinished, forEachRenderState, renderStateStream, subscribeRaw } from "./Subscriber.js";
-
-export { RunEventChannel, RunEventChannelLive, accumulateUntilFinished, forEachRenderState, publish, publishAll, renderStateStream, subscribeRaw };