@savvy-web/cli 3.5.1 → 3.7.0

package/commands/changeset/commands/transform.js

@@ -1,8 +1,8 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
 import { requireValidConfig } from "../utils/config-gate.js";
 import { Argument, Command, Flag } from "effect/cli";
 import { dirname, resolve } from "node:path";
-import { CliExit } from "@effected/cli";
+import { CliExit, Doc } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
 import { readFileSync, writeFileSync } from "node:fs";
@@ -21,7 +21,8 @@ import { readFileSync, writeFileSync } from "node:fs";
 * - **`--dry-run` / `-n`** -- print the transformed output to stdout
 *   without writing.
 * - **`--check` / `-c`** -- compare the transformed output against the
-*   original and exit with code 1 if they differ (useful in CI).
+*   original and exit with code 1 if they differ (useful in CI), showing
+*   the drifted lines as a capped diff (original against transformed).
 *
 * Before any of those modes run, the command requires a valid
 * `.changeset/config.json` (when one exists). A broken config indicates
@@ -39,6 +40,79 @@ import { readFileSync, writeFileSync } from "node:fs";
 * @internal
 */
 const { ChangelogTransformer } = Changesets;
+/** The most diff lines `--check` shows under its finding; the rest is elided. */
+const DIFF_CAP = 40;
+/** A text's lines; a final line break ends the last line rather than starting an empty one. */
+const lines = (text) => {
+	const all = text.split("\n");
+	if (all.at(-1) === "") all.pop();
+	return all;
+};
+/**
+* Narrow `original` and `transformed` to the lines between their common
+* leading and trailing lines, or `undefined` when the two differ only in the
+* file's final line break. Exported for tests only.
+*
+* @internal
+*/
+const driftWindow = (original, transformed) => {
+	const a = lines(original);
+	const b = lines(transformed);
+	let head = 0;
+	while (head < a.length && head < b.length && a[head] === b[head]) head++;
+	let tail = 0;
+	while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail++;
+	if (head + tail >= a.length && head + tail >= b.length) return void 0;
+	return {
+		removed: a.slice(head, a.length - tail),
+		added: b.slice(head, b.length - tail),
+		head
+	};
+};
+/** `1 line`, `3 blank lines`: a count of `lines`, called blank when every one is. */
+const lineCount = (lines) => {
+	const blank = lines.every((line) => line.trim() === "") ? "blank " : "";
+	return `${lines.length} ${blank}${lines.length === 1 ? "line" : "lines"}`;
+};
+/**
+* `lines` drawn as one side of a diff (`+ text`, or a bare `+` for a blank
+* line), unless every one is blank; capped at {@link DIFF_CAP} lines with an
+* elision line, as `Doc.diff` caps each side.
+*/
+const listed = (sign, lines) => {
+	if (lines.every((line) => line.trim() === "")) return [];
+	const shown = lines.slice(0, DIFF_CAP).map((line) => line === "" ? sign : `${sign} ${line}`);
+	const hidden = lines.length - shown.length;
+	if (hidden > 0) shown.push(`  … ${hidden} more ${hidden === 1 ? "line" : "lines"}`);
+	return [Doc.verbatim(shown.join("\n"), { indent: 2 })];
+};
+/**
+* What `--check` shows under its finding for one drifted region.
+*
+* @remarks
+* `Doc.diff` is not a line diff: it draws every expected line as removed and
+* every received line as added, and an empty side joins to the same `""` as a
+* single blank line. So the window holds only lines that changed (an unchanged
+* context line would read as removed and re-added), and a region that only
+* inserts or only removes lines is described in words, with its non-blank
+* lines listed, rather than drawn as a diff against nothing. A replacement is
+* a `Doc.diff`, capped so a long CHANGELOG never floods the report.
+* Exported for tests only.
+*
+* @internal
+*/
+const driftReport = (file, drift) => {
+	const finding = `${file} would be modified by transform`;
+	if (drift === void 0) return [Report.warn(finding, "only its final line break differs")];
+	const { removed, added, head } = drift;
+	if (removed.length === 0) {
+		const where = head === 0 ? "at the top" : `after line ${head}`;
+		return [Report.warn(finding, `inserts ${lineCount(added)} ${where}`), ...listed("+", added)];
+	}
+	const span = removed.length === 1 ? `line ${head + 1}` : `lines ${head + 1}-${head + removed.length}`;
+	if (added.length === 0) return [Report.warn(finding, `removes ${lineCount(removed)} at ${span}`), ...listed("-", removed)];
+	return [Report.warn(finding, `${span}:`), Doc.diff(removed.join("\n"), added.join("\n"), { cap: DIFF_CAP })];
+};
 /* v8 ignore start -- CLI option definitions; handler tested via runTransform */
 const fileArg = Argument.File("file").pipe(Argument.withDefault("CHANGELOG.md"));
 const dryRunOption = Flag.Boolean("dry-run").pipe(Flag.withAlias("n"), Flag.withDescription("Print transformed output instead of writing"), Flag.withDefault(false));
@@ -65,18 +139,18 @@ function runTransform(file, dryRun, check) {
 		const content = yield* Effect.try(() => readFileSync(resolved, "utf-8"));
 		const result = ChangelogTransformer.transformContent(content);
 		if (dryRun) {
-			yield* Output.line(result);
+			yield* Report.print([Report.verbatim(result)]);
 			return;
 		}
 		if (check) {
 			if (result !== content) {
-				yield* Output.warn(`${resolved} would be modified by transform`);
+				yield* Report.print(driftReport(resolved, driftWindow(content, result)));
 				yield* CliExit.set(1);
-			} else yield* Output.ok(`${resolved} is already formatted`);
+			} else yield* Report.print([Report.ok(`${resolved} is already formatted`)]);
 			return;
 		}
 		yield* Effect.try(() => writeFileSync(resolved, result, "utf-8"));
-		yield* Output.ok(`Transformed ${resolved}`);
+		yield* Report.print([Report.ok(`Transformed ${resolved}`)]);
 	});
 }
 /* v8 ignore next 5 -- CLI registration; handler tested via runTransform */
@@ -87,4 +161,4 @@ const transformCommand = Command.make("transform", {
 }, ({ file, dryRun, check }) => runTransform(file, dryRun, check)).pipe(Command.withDescription("Post-process CHANGELOG.md"));
 
 //#endregion
-export { runTransform, transformCommand };
+export { driftReport, driftWindow, runTransform, transformCommand };

package/commands/changeset/commands/validate-file.js

@@ -1,4 +1,5 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { CommandError } from "../../../internal/command-error.js";
 import { Argument, Command } from "effect/cli";
 import { CliExit } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
@@ -26,8 +27,9 @@ const fileArg = Argument.File("file");
 * Run lint validation on a single changeset file.
 *
 * Outputs one line per error in `file:line:col rule message` format.
-* Logs "Valid." when the file passes. Sets exit code 1 through `CliExit.set`
-* when errors are found or the file cannot be read.
+* Prints `✓ Valid` when the file passes. Sets exit code 1 through
+* `CliExit.set` when errors are found; fails with a {@link CommandError}
+* (reported on stderr, exit 1) when the file cannot be read.
 *
 * @param filePath - Path to the changeset `.md` file
 * @returns An Effect that performs validation and logs results
@@ -36,15 +38,14 @@ const fileArg = Argument.File("file");
 */
 function runValidateFile(filePath) {
 	return Effect.gen(function* () {
-		const result = yield* Effect.try(() => ChangesetLinter.validateFile(filePath)).pipe(Effect.catch((error) => Effect.gen(function* () {
-			yield* Effect.logError(`Error: ${error instanceof Error ? error.message : String(error)}`);
+		const result = yield* Effect.try({
+			try: () => ChangesetLinter.validateFile(filePath),
+			catch: (error) => CommandError.from(error instanceof Error ? error : String(error), { message: `could not validate ${filePath}` })
+		});
+		if (result.length > 0) {
+			yield* Report.print([Report.verbatim(result.map((msg) => `${msg.file}:${msg.line}:${msg.column} ${msg.rule} ${msg.message}`).join("\n"))]);
 			yield* CliExit.set(1);
-			return null;
-		})));
-		if (result === null) return;
-		for (const msg of result) yield* Output.line(`${msg.file}:${msg.line}:${msg.column} ${msg.rule} ${msg.message}`);
-		if (result.length > 0) yield* CliExit.set(1);
-		else yield* Output.ok("Valid");
+		} else yield* Report.print([Report.ok("Valid")]);
 	});
 }
 /* v8 ignore next 3 -- CLI registration; handler tested via runValidateFile */

package/commands/changeset/commands/version.js

@@ -1,20 +1,11 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
 import { requireValidConfig } from "../utils/config-gate.js";
 import { Command, Flag } from "effect/cli";
+import { Doc } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
 
 //#region src/commands/changeset/commands/version.ts
-/**
-* Version command -- natively apply pending changesets and report the result.
-*
-* Validates the config, then runs {@link ReleasePlanner.apply}, which bumps
-* versions, writes + transforms CHANGELOGs, deletes consumed changesets, and
-* updates configured versionFiles -- all without shelling out to a `changeset`
-* CLI binary.
-*
-* @internal
-*/
 /* v8 ignore start -- CLI option definitions; handler tested via runVersion */
 const dryRunOption = Flag.Boolean("dry-run").pipe(Flag.withAlias("n"), Flag.withDescription("Compute and report the release without writing anything"), Flag.withDefault(false));
 /* v8 ignore stop */
@@ -28,17 +19,57 @@ function runVersion(dryRun) {
 	return Effect.gen(function* () {
 		const cwd = process.cwd();
 		yield* requireValidConfig(cwd);
-		const result = yield* (yield* Changesets.ReleasePlanner).apply(cwd, { dryRun });
+		const planner = yield* Changesets.ReleasePlanner;
+		if (dryRun) {
+			const result = yield* planner.apply(cwd, { dryRun });
+			if (result.releases.length === 0) {
+				yield* Report.print([Report.ok("No pending changesets")]);
+				return;
+			}
+			yield* Report.print([...releaseBlocks(result.releases, true), ...versionFileBlocks(result.versionFileUpdates, true)]);
+			return;
+		}
+		let engineReported = false;
+		let versionFilesReported = false;
+		const onStep = (step) => Effect.suspend(() => {
+			if (step._tag === "EngineApplied") {
+				engineReported = true;
+				return step.releases.length === 0 ? Effect.void : Report.print([...releaseBlocks(step.releases, false), Report.detail(`Touched ${step.touchedFiles.length} file(s)`)]);
+			}
+			versionFilesReported = true;
+			return Report.print(versionFileBlocks(step.updates, false));
+		});
+		const result = yield* planner.apply(cwd, { onStep });
 		if (result.releases.length === 0) {
-			yield* Output.ok("No pending changesets");
+			yield* Report.print([Report.ok("No pending changesets")]);
 			return;
 		}
-		const verb = dryRun ? "Would release" : "Released";
-		for (const r of result.releases) yield* Output.ok(`${verb} ${r.name}: ${r.oldVersion} -> ${r.newVersion} (${r.type})`);
-		if (!dryRun) yield* Output.detail(`Touched ${result.touchedFiles.length} file(s)`);
-		for (const u of result.versionFileUpdates) yield* Output.detail(`${dryRun ? "Would update" : "Updated"} ${u.filePath} -> ${u.version}`);
+		const remaining = [];
+		if (!engineReported) remaining.push(...releaseBlocks(result.releases, false), Report.detail(`Touched ${result.touchedFiles.length} file(s)`));
+		if (!versionFilesReported) remaining.push(...versionFileBlocks(result.versionFileUpdates, false));
+		if (remaining.length > 0) yield* Report.print(remaining);
 	});
 }
+/** The columns of the releases table. */
+const RELEASE_COLUMNS = [
+	{ header: "package" },
+	{ header: "version" },
+	{ header: "bump" }
+];
+/**
+* The releases as one status line (plan-phrased on a dry run) over a
+* package / old → new / bump table.
+*/
+const releaseBlocks = (releases, dryRun) => {
+	const count = `${releases.length} package${releases.length === 1 ? "" : "s"}`;
+	return [dryRun ? Report.line(`Would release ${count}:`) : Report.ok(`Released ${count}`), Doc.table(RELEASE_COLUMNS, releases.map((r) => [
+		r.name,
+		`${r.oldVersion} → ${r.newVersion}`,
+		r.type
+	]))];
+};
+/** One detail line per versionFiles update, plan-phrased on a dry run. */
+const versionFileBlocks = (updates, dryRun) => updates.map((u) => Report.detail(`${dryRun ? "Would update" : "Updated"} ${u.filePath} -> ${u.version}`));
 /* v8 ignore next 4 -- CLI registration; handler tested via runVersion */
 const versionCommand = Command.make("version", { dryRun: dryRunOption }, ({ dryRun }) => runVersion(dryRun)).pipe(Command.withDescription("Apply pending changesets: bump versions and transform CHANGELOGs"));
 

package/commands/changeset/index.js

@@ -1,4 +1,4 @@
-import { checkCommand, runChangesetCheck } from "./commands/check.js";
+import { changesetCheckSection, checkCommand, runChangesetCheck } from "./commands/check.js";
 import { configValidateCommand } from "./commands/config-validate.js";
 import { depsDetectCommand } from "./commands/deps-detect.js";
 import { depsRegenCommand } from "./commands/deps-regen.js";
@@ -6,7 +6,7 @@ import { lintCommand } from "./commands/lint.js";
 import { transformCommand } from "./commands/transform.js";
 import { validateFileCommand } from "./commands/validate-file.js";
 import { versionCommand } from "./commands/version.js";
-import { runChangesetInit } from "./commands/init.js";
+import { runChangesetInit, runChangesetInitOrFail } from "./commands/init.js";
 import { Command } from "effect/cli";
 
 //#region src/commands/changeset/index.ts
@@ -40,4 +40,4 @@ const _changesetCommand = Command.make("changeset").pipe(Command.withSubcommands
 const changesetCommand = _changesetCommand;
 
 //#endregion
-export { changesetCommand, runChangesetCheck, runChangesetInit };
+export { changesetCheckSection, changesetCommand, runChangesetCheck, runChangesetInit };

package/commands/changeset/utils/config-gate.js

@@ -1,5 +1,5 @@
+import { CommandError } from "../../../internal/command-error.js";
 import { join, resolve } from "node:path";
-import { CliExit } from "@effected/cli";
 import { Changesets } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
 import { existsSync } from "node:fs";
@@ -26,9 +26,10 @@ import { existsSync } from "node:fs";
 *   pre-0.9.0 behavior where `transform` and `version` worked on
 *   projects that have not yet been bootstrapped.
 * - **Config present**: the gate invokes
-*   {@link ConfigInspector.inspect}. On `ConfigurationError`, it sets
-*   exit code 1 through `CliExit.set` and propagates the error so the caller's
-*   `Effect.gen` short-circuits.
+*   {@link ConfigInspector.inspect}. A `ConfigurationError` becomes a
+*   {@link CommandError} (the refusal, the config problem as its detail, and
+*   a `config validate` hint) that short-circuits the caller's `Effect.gen`;
+*   the runtime reports it on stderr and exits 1.
 *
 * @internal
 */
@@ -36,12 +37,12 @@ const { ConfigInspector } = Changesets;
 /**
 * Require a valid `.changeset/config.json` (when one exists) before
 * proceeding. Resolves to `void` on a clean config OR on a project that
-* doesn't have a config at all; fails with {@link ConfigurationError} on
-* an invalid config.
+* doesn't have a config at all; fails with a {@link CommandError} wrapping
+* the {@link ConfigurationError} on an invalid config.
 *
 * @param cwd - Project root (will be resolved against the process cwd)
 * @returns Effect that succeeds on valid/absent config, fails with
-*   {@link ConfigurationError} otherwise
+*   {@link CommandError} otherwise
 *
 * @internal
 */
@@ -50,9 +51,10 @@ function requireValidConfig(cwd) {
 		const projectDir = resolve(cwd);
 		const configPath = join(projectDir, ".changeset", "config.json");
 		if (!existsSync(configPath)) return;
-		yield* (yield* ConfigInspector).inspect(projectDir).pipe(Effect.catchTag("ConfigurationError", (err) => {
-			return CliExit.set(1).pipe(Effect.andThen(Effect.fail(err)));
-		}));
+		yield* (yield* ConfigInspector).inspect(projectDir).pipe(Effect.catchTag("ConfigurationError", (err) => Effect.fail(CommandError.from(err, {
+			message: `refusing to run: ${configPath} is invalid`,
+			hint: "Run savvy changeset config validate to see the full report."
+		}))));
 	});
 }
 

package/commands/check-section.js

@@ -0,0 +1,34 @@
+import { Doc, Status } from "@effected/cli";
+
+//#region src/commands/check-section.ts
+/**
+* A status cell for a hook table: the glyph and the state, e.g. `✓ up-to-date`.
+* `not installed` is advisory (`↷`); `outdated`/`missing` are findings (`✗`).
+*
+* @internal
+*/
+const stateCell = (state) => {
+	const status = state === "up-to-date" ? "success" : state === "not installed" ? "skip" : "failure";
+	return [
+		Doc.status(Status.core, status),
+		" ",
+		state
+	];
+};
+/**
+* The hook-section table: one row per `[hook, section, state]`.
+*
+* @internal
+*/
+const hookTable = (rows) => Doc.table([
+	{ header: "hook" },
+	{ header: "section" },
+	{ header: "state" }
+], rows.map(([hook, section, state]) => [
+	hook,
+	section,
+	stateCell(state)
+]));
+
+//#endregion
+export { hookTable, stateCell };

package/commands/check.js

@@ -1,54 +1,63 @@
-import { Output } from "../internal/output.js";
-import { runChangesetCheck } from "./changeset/commands/check.js";
+import { Report } from "../internal/report.js";
+import { changesetCheckSection } from "./changeset/commands/check.js";
 import "./changeset/index.js";
-import { runCommitCheck } from "./commit/check.js";
-import { runLintCheck } from "./lint/check.js";
+import { commitCheckSection } from "./commit/check.js";
+import { lintCheckSection } from "./lint/check.js";
 import { Command, Flag } from "effect/cli";
+import { CliExit, Doc } from "@effected/cli";
 import { Effect, Result } from "effect";
 
 //#region src/commands/check.ts
-/**
-* Unified `savvy check` orchestrator.
-*
-* @remarks
-* Runs all three tool-specific check handlers — changeset, commit, lint —
-* sequentially so each tool's console output is cleanly grouped rather than
-* interleaved. Unlike the `init` orchestrator, check MUST NOT short-circuit:
-* the user wants to see every failing check in a single pass. Uses
-* `Effect.all` with `{ concurrency: 1, mode: "validate" }` to run all three
-* regardless of individual failures and then surface the full set of errors.
-*
-* Runtime layer provision (ManagedSection, FileSystem, WorkspaceRoot,
-* ToolDiscovery, etc.) is deferred to Task B7 (root `main`). The Effect
-* returned by `checkCommand`'s handler therefore carries the full union of the
-* three handlers' requirements in its R channel.
-*
-* @internal
-*/
 /* v8 ignore start -- CLI option definitions; orchestration logic tested via runCheck */
 const changesetDirOption = Flag.String("changeset-dir").pipe(Flag.withDescription("Path to the changeset directory"), Flag.withDefault(".changeset"));
 const quietOption = Flag.Boolean("quiet").pipe(Flag.withAlias("q"), Flag.withDescription("Only output warnings from lint check"), Flag.withDefault(false));
 /* v8 ignore stop */
 /**
-* Run all three check step Effects without short-circuiting.
+* Run the three checks without short-circuiting and print them as one
+* document.
 *
-* All three checks always run, sequentially (concurrency 1) so per-tool
-* output stays grouped. If any fail, the combined Effect fails with all
-* accumulated errors. Uses `Effect.all` with `{ concurrency: 1, mode: "validate" }`
-* to collect every failure rather than stopping at the first.
+* @remarks
+* Each step builds a {@link CheckSection}; each section is folded into a
+* collapsible (a `::group::` under GitHub Actions, whose body is where a
+* section's annotations are written, so its blocks are never nested deeper).
+* A step that fails still lets the others run and report; the first failure
+* is re-raised after the document is printed.
 *
-* @param steps - The three step Effects to run. Injected for testability.
-* @returns An Effect that resolves to `void` on success, or fails with the
-*   union of all failing steps' errors.
+* @param steps - The three step Effects. Injected for testability.
+* @returns An Effect that prints the report and sets exit code 1 on any
+*   finding, or fails with the first failing step's error.
 */
 function runCheck(steps) {
 	return Effect.gen(function* () {
-		const results = yield* Effect.all([
-			Effect.result(steps.changeset),
-			Output.line("").pipe(Effect.andThen(Effect.result(steps.commit))),
-			Output.line("").pipe(Effect.andThen(Effect.result(steps.lint)))
-		], { concurrency: 1 });
-		for (const result of results) if (Result.isFailure(result)) return yield* Effect.fail(result.failure);
+		const sections = [
+			["changesets", yield* Effect.result(steps.changeset)],
+			["commitlint", yield* Effect.result(steps.commit)],
+			["lint-staged", yield* Effect.result(steps.lint)]
+		];
+		const blocks = [];
+		const verdicts = [];
+		let initFixes = false;
+		for (const [title, result] of sections) {
+			if (Result.isFailure(result)) {
+				verdicts.push("failure");
+				blocks.push(Report.fail(`${title}: the check could not run`));
+				continue;
+			}
+			const section = result.success;
+			verdicts.push(section.verdict);
+			initFixes ||= section.fixedByInit;
+			if (section.blocks.length > 0) blocks.push(Doc.collapsible(section.title, section.blocks), Report.line(""));
+		}
+		const count = (verdict) => verdicts.filter((v) => v === verdict).length;
+		blocks.push(Report.summary({
+			ok: count("success"),
+			warn: count("warning"),
+			fail: count("failure")
+		}));
+		if (initFixes) blocks.push(Doc.callout("tip", [Doc.paragraph("run savvy init to install or update the missing pieces")]));
+		yield* Report.print(blocks);
+		if (verdicts.includes("failure")) yield* CliExit.set(1);
+		for (const [, result] of sections) if (Result.isFailure(result)) return yield* Effect.fail(result.failure);
 	});
 }
 /* v8 ignore start -- CLI registration; orchestration logic tested via runCheck */
@@ -56,9 +65,9 @@ const _checkCommand = Command.make("check", {
 	changesetDir: changesetDirOption,
 	quiet: quietOption
 }, (opts) => runCheck({
-	changeset: runChangesetCheck(opts.changesetDir),
-	commit: runCommitCheck(),
-	lint: runLintCheck({ quiet: opts.quiet })
+	changeset: changesetCheckSection(opts.changesetDir),
+	commit: commitCheckSection(),
+	lint: lintCheckSection({ quiet: opts.quiet })
 })).pipe(Command.withDescription("Validate all Silk Suite tool configurations in one pass"));
 /* v8 ignore stop */
 /**

package/commands/clean/progress.js

@@ -0,0 +1,71 @@
+import { Doc, Status } from "@effected/cli";
+
+//#region src/commands/clean/progress.ts
+/** The state before a run starts. */
+const initialCleanState = {
+	phase: "idle",
+	dryRun: false,
+	workspaces: 0,
+	finished: 0,
+	current: void 0,
+	removed: 0,
+	failed: []
+};
+/** Fold one event into the state; a start begins afresh. */
+const reduceClean = (state, event) => {
+	switch (event._tag) {
+		case "Started": return {
+			...initialCleanState,
+			phase: "running",
+			dryRun: event.dryRun,
+			workspaces: event.workspaces
+		};
+		case "WorkspaceStarted": return {
+			...state,
+			current: event.name
+		};
+		case "WorkspaceDone": return {
+			...state,
+			finished: state.finished + 1,
+			removed: state.removed + event.removed.length,
+			failed: [...state.failed, ...event.failed]
+		};
+		case "Ended": return {
+			...state,
+			phase: "done",
+			current: void 0
+		};
+	}
+};
+/** `n removed, m failed` (or `would remove` on a dry run); a zero `failed` is left out. */
+const counts = (state) => Doc.counts({
+	layout: "inline",
+	share: false,
+	counters: [Doc.counter(Status.core, "success", {
+		key: "removed",
+		label: state.dryRun ? "would remove" : "removed",
+		n: state.removed,
+		showZero: true
+	}), Doc.counter(Status.core, "failure", {
+		key: "failed",
+		label: "failed",
+		n: state.failed.length
+	})]
+});
+/** The paths that could not be removed, as a table. */
+const failures = (failed) => failed.length === 0 ? [] : [Doc.table([
+	{ header: "could not remove" },
+	{ header: "kind" },
+	{ header: "reason" }
+], failed.map((f) => [
+	Doc.file(f.target.path),
+	f.target.kind,
+	f.reason
+]))];
+/** While the run goes: which workspace, how many are done, and the counts so far. */
+const progressDoc = (state, spinner) => [Doc.line([Doc.text(spinner, "accent"), ` ${state.dryRun ? "Previewing" : "Cleaning"} ${state.current ?? ""} (${state.finished}/${state.workspaces} workspaces)`]), counts(state)];
+/** The committed summary: the counts, then any failures as a table. */
+const summaryDoc = (state) => [counts(state), ...failures(state.failed)];
+
+//#endregion
+export { initialCleanState, progressDoc, reduceClean, summaryDoc };

package/commands/clean/view.js

@@ -0,0 +1,26 @@
+import { initialCleanState, progressDoc, reduceClean, summaryDoc } from "./progress.js";
+import { DocView, useGlyphs } from "@effected/cli/ui";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/commands/clean/view.tsx
+/** Draws the run: progress while it goes, the summary once it has ended. */
+const CleanProgress = ({ state, frame }) => {
+	const glyphs = useGlyphs();
+	if (state.phase === "done") return /* @__PURE__ */ jsx(DocView, { doc: summaryDoc(state) });
+	const spinner = glyphs.spinner[frame % glyphs.spinner.length] ?? "";
+	return /* @__PURE__ */ jsx(DocView, { doc: progressDoc(state, spinner) });
+};
+/** The view `savvy clean` mounts, minus its events; the tests drive this same value. */
+const cleanView = {
+	initial: initialCleanState,
+	reduce: reduceClean,
+	render: (state, frame) => /* @__PURE__ */ jsx(CleanProgress, {
+		state,
+		frame
+	}),
+	isStart: (event) => event._tag === "Started",
+	isTerminal: (event) => event._tag === "Ended"
+};
+
+//#endregion
+export { cleanView };