@savvy-web/cli 3.5.0 → 3.6.0

package/commands/clean.js

@@ -1,9 +1,12 @@
-import { Output } from "../internal/output.js";
+import { Report } from "../internal/report.js";
+import { CommandError } from "../internal/command-error.js";
 import { Command, Flag } from "effect/cli";
 import { join, sep } from "node:path";
-import { Data, Effect } from "effect";
+import { CliInteractive } from "@effected/cli";
+import { Console, Effect, PubSub } from "effect";
 import { WorkspaceDiscovery } from "@effected/workspaces";
 import { glob, realpath, rm } from "node:fs/promises";
+import { CliUi } from "@effected/cli/ui";
 
 //#region src/commands/clean.ts
 /**
@@ -25,8 +28,6 @@ const DEFAULT_GLOBS = [
 ];
 /** Directory names a recursive (`**`) glob must never descend into. */
 const NO_DESCEND = /* @__PURE__ */ new Set(["node_modules", ".git"]);
-/** Unexpected failure while planning or removing artifacts. */
-var CleanError = class extends Data.TaggedError("CleanError") {};
 /**
 * Glob `patterns` at the top of `pkgPath`, classify dir vs file, and enforce
 * that every match stays within `pkgPath` (rejecting symlink/`..` escapes and
@@ -58,9 +59,9 @@ function collectTargets(pkgPath, patterns) {
 			}
 			return [...seen.values()];
 		},
-		catch: (e) => new CleanError({
-			step: `glob ${pkgPath}`,
-			reason: e instanceof Error ? e.message : String(e)
+		catch: (e) => CommandError.from(e, {
+			message: `could not list the artifacts in ${pkgPath}`,
+			hint: "Check that the workspace directory exists and is readable, or narrow --globs."
 		})
 	});
 }
@@ -103,16 +104,61 @@ function parseGlobs(raw) {
 	const parts = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
 	return parts.length > 0 ? parts : DEFAULT_GLOBS;
 }
+/** A workspace's display name: its relative path, `<root>` for the root. */
+const groupName = (relativePath) => relativePath === "." ? "<root>" : relativePath;
+/**
+* One workspace's document: its name, then each removed target and each
+* failure. Only targets that actually succeeded are listed as removed (in a
+* dry run `removed` holds every target); a failure gets its own marker.
+*/
+const groupBlocks = (name, report, dryRun) => {
+	const verb = dryRun ? "would remove" : "removed";
+	return [
+		Report.line(""),
+		Report.heading(name),
+		...report.removed.map((t) => Report.detail(`${verb} [${t.kind}] ${t.path}`)),
+		...report.failed.map((f) => Report.warn(`failed [${f.target.kind}] ${f.target.path}: ${f.reason}`))
+	];
+};
+/**
+* Remove each workspace's targets in order (leaves first, the root last),
+* calling `onStart` before and `onDone` after each workspace that has any.
+*/
+const removeGroups = (groups, dryRun, hooks) => Effect.gen(function* () {
+	let total = 0;
+	const failures = [];
+	for (const group of groups) {
+		if (group.targets.length === 0) continue;
+		yield* hooks.onStart(group);
+		const report = yield* removeTargets(group.targets, dryRun);
+		yield* hooks.onDone(group, report);
+		total += report.removed.length;
+		failures.push(...report.failed);
+	}
+	return {
+		total,
+		failures
+	};
+});
 /**
 * Discover packages, plan targets per workspace (leaves first, root last),
 * dedup across overlapping roots, remove (or preview), and report.
+*
+* @remarks
+* A person at a terminal (`CliInteractive`) watches a live progress view
+* whose committed frame is the summary — the counts and a table of anything
+* that could not be removed — with each workspace's document printed above
+* it as the workspace finishes. Every other run (an agent, CI, a pipe)
+* prints each workspace's document as it finishes and a one-line total, and
+* never loads Ink or React. Either way, targets that could not be removed
+* fail the run with a `CommandError` listing them.
 */
 function runClean(opts) {
 	const patterns = parseGlobs(opts.globs);
 	return Effect.gen(function* () {
-		const packages = yield* (yield* WorkspaceDiscovery).listPackages().pipe(Effect.mapError((e) => new CleanError({
-			step: "discover workspaces",
-			reason: e.message
+		const packages = yield* (yield* WorkspaceDiscovery).listPackages().pipe(Effect.mapError((e) => CommandError.from(e, {
+			message: "could not discover the workspace packages",
+			hint: "Run savvy clean from inside the workspace (a directory with pnpm-workspace.yaml or a workspaces field)."
 		})));
 		const leaves = packages.filter((p) => !(p.relativePath === "."));
 		const roots = packages.filter((p) => p.relativePath === ".");
@@ -122,47 +168,64 @@ function runClean(opts) {
 			targets
 		}))));
 		const seen = /* @__PURE__ */ new Set();
-		const groups = planned.map(({ pkg, targets }) => {
-			return {
-				pkg,
-				targets: targets.filter((t) => {
-					if (seen.has(t.path)) return false;
-					seen.add(t.path);
-					return true;
-				})
-			};
-		});
-		const leafGroups = groups.filter((g) => !(g.pkg.relativePath === "."));
-		const rootGroups = groups.filter((g) => g.pkg.relativePath === ".");
-		const verb = opts.dryRun ? "would remove" : "removed";
-		let total = 0;
-		const failures = [];
-		for (const phase of [leafGroups, rootGroups]) {
-			const reports = yield* Effect.forEach(phase, (g) => removeTargets(g.targets, opts.dryRun).pipe(Effect.map((report) => ({
-				g,
-				report
-			}))));
-			for (const { g, report } of reports) {
-				if (g.targets.length === 0) continue;
-				yield* Output.line("");
-				yield* Output.heading(g.pkg.relativePath === "." ? "<root>" : g.pkg.relativePath);
-				for (const t of report.removed) yield* Output.detail(`${verb} [${t.kind}] ${t.path}`);
-				for (const f of report.failed) yield* Output.warn(`failed [${f.target.kind}] ${f.target.path}: ${f.reason}`);
-				total += report.removed.length;
-				failures.push(...report.failed);
-			}
-		}
-		yield* Output.line("");
-		yield* Output.ok(`${opts.dryRun ? "Would remove" : "Removed"} ${total} item(s)`);
-		if (failures.length > 0) {
-			for (const f of failures) yield* Effect.logError(`Failed to remove ${f.target.path}: ${f.reason}`);
-			return yield* Effect.fail(new CleanError({
-				step: "remove",
-				reason: `${failures.length} target(s) could not be removed`
-			}));
-		}
+		const groups = planned.map(({ pkg, targets }) => ({
+			name: groupName(pkg.relativePath),
+			targets: targets.filter((t) => {
+				if (seen.has(t.path)) return false;
+				seen.add(t.path);
+				return true;
+			})
+		}));
+		const printGroup = (group, report) => Report.print(groupBlocks(group.name, report, opts.dryRun));
+		const outcome = (yield* CliInteractive) ? yield* cleanLive(groups, opts.dryRun, printGroup) : yield* removeGroups(groups, opts.dryRun, {
+			onStart: () => Effect.void,
+			onDone: printGroup
+		}).pipe(Effect.tap(({ total }) => Report.print([Report.line(""), Report.ok(`${opts.dryRun ? "Would remove" : "Removed"} ${total} item(s)`)])));
+		if (outcome.failures.length > 0) return yield* Effect.fail(new CommandError({
+			message: `${outcome.failures.length} target(s) could not be removed`,
+			detail: outcome.failures.map((f) => `${f.target.path}: ${f.reason}`),
+			hint: "Check the permissions on those paths and that no process holds them open, then re-run savvy clean."
+		}));
 	});
 }
+/**
+* The removal pass under a live view, for a person at a terminal.
+*
+* @remarks
+* The view's module (the JSX) is imported here, on the one path that draws,
+* so no other run loads React. Every line the pass writes goes through the
+* view's `logConsole`, landing above the frame instead of tearing it.
+*/
+const cleanLive = (groups, dryRun, printGroup) => Effect.scoped(Effect.gen(function* () {
+	const { cleanView } = yield* Effect.promise(() => import("./clean/view.js"));
+	const pubsub = yield* PubSub.unbounded();
+	const events = yield* PubSub.subscribe(pubsub);
+	const view = yield* CliUi.live({
+		...cleanView,
+		events
+	});
+	const workspaces = groups.filter((g) => g.targets.length > 0).length;
+	yield* PubSub.publish(pubsub, {
+		_tag: "Started",
+		workspaces,
+		dryRun
+	});
+	const outcome = yield* removeGroups(groups, dryRun, {
+		onStart: (group) => PubSub.publish(pubsub, {
+			_tag: "WorkspaceStarted",
+			name: group.name
+		}),
+		onDone: (group, report) => Effect.andThen(printGroup(group, report), PubSub.publish(pubsub, {
+			_tag: "WorkspaceDone",
+			name: group.name,
+			removed: report.removed,
+			failed: report.failed
+		}))
+	}).pipe(Effect.provideService(Console.Console, view.logConsole));
+	yield* PubSub.publish(pubsub, { _tag: "Ended" });
+	yield* view.close;
+	return outcome;
+}));
 /* v8 ignore start -- CLI option/registration; orchestration tested via runClean */
 const globsOption = Flag.String("globs").pipe(Flag.withAlias("g"), Flag.withDescription(`Comma-separated glob patterns to remove from each workspace root (default: ${DEFAULT_GLOBS.join(",")})`), Flag.withDefault(DEFAULT_GLOBS.join(",")));
 const dryRunOption = Flag.Boolean("dry-run").pipe(Flag.withAlias("n"), Flag.withDescription("Report what would be removed without deleting anything"), Flag.withDefault(false));
@@ -182,4 +245,4 @@ const _cleanCommand = Command.make("clean", {
 const cleanCommand = _cleanCommand;
 
 //#endregion
-export { CleanError, cleanCommand, collectTargets, parseGlobs, removeTargets, runClean };
+export { cleanCommand, collectTargets, parseGlobs, removeTargets, runClean };

package/commands/commit/check.js

@@ -1,6 +1,8 @@
-import { Output } from "../../internal/output.js";
+import { Report } from "../../internal/report.js";
+import { hookTable } from "../check-section.js";
 import { HUSKY_HOOK_PATH, POST_CHECKOUT_HOOK_PATH, POST_COMMIT_HOOK_PATH, POST_MERGE_HOOK_PATH } from "./constants.js";
 import { SECTION_DEF, savvyCommitBlock } from "./init.js";
+import { CliExit } from "@effected/cli";
 import { ChangesetConfigReader, Commitlint, SavvyBaseSection, SavvyHooksSection, SavvyToolchainSection, savvyBasePreamble, savvyHooksHygiene, savvyInstallBlock, savvyToolchainCheck } from "@savvy-web/silk-effects";
 import { Effect, FileSystem, Option } from "effect";
 import { VersioningStrategy } from "@effected/workspaces";
@@ -82,55 +84,47 @@ const detectReleaseFormat = Effect.gen(function* () {
 	return STRATEGY_TO_FORMAT[strategy.type] ?? "semver";
 });
 /**
-* Run the check validation pipeline.
+* Check the commitlint setup and return it as a {@link CheckSection}.
 *
-* Exported so Task B6's unified `savvy check` orchestrator can invoke the
-* commitlint check step directly without going through the CLI command layer.
-*
-* @returns An Effect that performs validation and logs results
+* @remarks
+* Severity rule: anything `savvy init` would write or rewrite — a missing
+* config file or `commit-msg` hook, a hook file or managed section that is
+* absent or drifted — is a finding (`✗`, verdict `failure`). A missing DCO
+* file is advisory (`↷`): signoff is simply not required.
 *
 * @internal
 */
-function runCommitCheck() {
+function commitCheckSection() {
 	return Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
 		const ms = yield* ManagedSection;
-		yield* Output.heading("commitlint configuration");
+		const blocks = [];
+		const rows = [];
+		const stateOf = (outcome) => CheckOutcome.$is("UpToDate")(outcome) ? "up-to-date" : CheckOutcome.$is("Drifted")(outcome) ? "outdated" : "missing";
 		const foundConfig = yield* findConfigFile(fs);
-		if (foundConfig) yield* Output.ok(`Config file: ${foundConfig}`);
-		else yield* Output.fail(`No commitlint config file found`);
+		blocks.push(foundConfig ? Report.ok(`Config file: ${foundConfig}`) : Report.fail("No commitlint config file found"));
 		const hasHuskyHook = yield* fs.exists(HUSKY_HOOK_PATH);
-		if (hasHuskyHook) yield* Output.ok(`Husky hook: ${HUSKY_HOOK_PATH}`);
-		else yield* Output.fail(`No husky commit-msg hook found`);
-		let sectionsHealthy = true;
+		blocks.push(hasHuskyHook ? Report.ok(`Husky hook: ${HUSKY_HOOK_PATH}`) : Report.fail("No husky commit-msg hook found"));
 		if (hasHuskyHook) {
-			const baseStatus = yield* ms.check(HUSKY_HOOK_PATH, SavvyBaseSection.section(savvyBasePreamble()));
-			if (CheckOutcome.$is("UpToDate")(baseStatus)) yield* Output.ok(`Base section: up-to-date`);
-			else if (CheckOutcome.$is("Drifted")(baseStatus)) {
-				sectionsHealthy = false;
-				yield* Output.warn(`Base section: outdated (run 'savvy init' to update)`);
-			} else {
-				sectionsHealthy = false;
-				yield* Output.skip(`Base section: not found (run 'savvy init' to add)`);
-			}
+			rows.push([
+				HUSKY_HOOK_PATH,
+				"savvy-base",
+				stateOf(yield* ms.check(HUSKY_HOOK_PATH, SavvyBaseSection.section(savvyBasePreamble())))
+			]);
 			const block = yield* ms.read(HUSKY_HOOK_PATH, SECTION_DEF);
 			if (Option.isSome(block)) {
 				const configPath = extractConfigPathFromManaged(block.value.content);
-				if (configPath) {
-					const status = yield* ms.check(HUSKY_HOOK_PATH, savvyCommitBlock(configPath));
-					if (CheckOutcome.$is("UpToDate")(status)) yield* Output.ok(`Commit section: up-to-date`);
-					else {
-						sectionsHealthy = false;
-						yield* Output.warn(`Commit section: outdated (run 'savvy init' to update)`);
-					}
-				} else {
-					sectionsHealthy = false;
-					yield* Output.warn(`Commit section: outdated (run 'savvy init' to update)`);
-				}
-			} else {
-				sectionsHealthy = false;
-				yield* Output.skip(`Commit section: not found (run 'savvy init' to add)`);
-			}
+				const state = configPath ? CheckOutcome.$is("UpToDate")(yield* ms.check(".husky/commit-msg", savvyCommitBlock(configPath))) ? "up-to-date" : "outdated" : "outdated";
+				rows.push([
+					HUSKY_HOOK_PATH,
+					"savvy-commit",
+					state
+				]);
+			} else rows.push([
+				HUSKY_HOOK_PATH,
+				"savvy-commit",
+				"missing"
+			]);
 		}
 		for (const hookPath of [
 			POST_CHECKOUT_HOOK_PATH,
@@ -138,55 +132,64 @@ function runCommitCheck() {
 			POST_COMMIT_HOOK_PATH
 		]) {
 			if (!(yield* fs.exists(hookPath))) {
-				sectionsHealthy = false;
-				yield* Output.skip(`Hygiene hook: ${hookPath} not found (run 'savvy init' to add)`);
+				rows.push([
+					hookPath,
+					"(hook file)",
+					"missing"
+				]);
 				continue;
 			}
-			const hygieneStatus = yield* ms.check(hookPath, SavvyHooksSection.section(savvyHooksHygiene()));
-			if (CheckOutcome.$is("UpToDate")(hygieneStatus)) yield* Output.ok(`Hygiene hook: ${hookPath}`);
-			else if (CheckOutcome.$is("Drifted")(hygieneStatus)) {
-				sectionsHealthy = false;
-				yield* Output.warn(`Hygiene hook: ${hookPath} outdated (run 'savvy init' to update)`);
-			} else {
-				sectionsHealthy = false;
-				yield* Output.skip(`Hygiene hook: ${hookPath} section not found (run 'savvy init' to add)`);
-			}
+			rows.push([
+				hookPath,
+				"savvy-hooks",
+				stateOf(yield* ms.check(hookPath, SavvyHooksSection.section(savvyHooksHygiene())))
+			]);
 			if (hookPath === ".husky/post-commit") continue;
 			const installHook = hookPath === ".husky/post-checkout" ? "post-checkout" : "post-merge";
-			const installStatus = yield* ms.check(hookPath, savvyInstallBlock(installHook));
-			if (CheckOutcome.$is("UpToDate")(installStatus)) yield* Output.ok(`Dependency install: ${hookPath}`);
-			else if (CheckOutcome.$is("Drifted")(installStatus)) {
-				sectionsHealthy = false;
-				yield* Output.warn(`Dependency install: ${hookPath} outdated (run 'savvy init' to update)`);
-			} else {
-				sectionsHealthy = false;
-				yield* Output.skip(`Dependency install: ${hookPath} section not found (run 'savvy init' to add)`);
-			}
-			const toolchainStatus = yield* ms.check(hookPath, SavvyToolchainSection.section(savvyToolchainCheck()));
-			if (CheckOutcome.$is("UpToDate")(toolchainStatus)) yield* Output.ok(`Toolchain check: ${hookPath}`);
-			else if (CheckOutcome.$is("Drifted")(toolchainStatus)) {
-				sectionsHealthy = false;
-				yield* Output.warn(`Toolchain check: ${hookPath} outdated (run 'savvy init' to update)`);
-			} else {
-				sectionsHealthy = false;
-				yield* Output.skip(`Toolchain check: ${hookPath} section not found (run 'savvy init' to add)`);
-			}
+			rows.push([
+				hookPath,
+				"savvy-install",
+				stateOf(yield* ms.check(hookPath, savvyInstallBlock(installHook)))
+			]);
+			rows.push([
+				hookPath,
+				"savvy-toolchain",
+				stateOf(yield* ms.check(hookPath, SavvyToolchainSection.section(savvyToolchainCheck())))
+			]);
 		}
-		if (yield* fs.exists(DCO_FILE_PATH)) yield* Output.ok(`DCO file: ${DCO_FILE_PATH}`);
-		else yield* Output.skip(`No DCO file (signoff not required)`);
-		yield* Output.line("");
-		yield* Output.heading("Detected settings");
-		yield* Output.detail(`DCO required: ${Commitlint.detectDCO()}`);
+		if (rows.length > 0) blocks.push(hookTable(rows));
+		const hasDCOFile = yield* fs.exists(DCO_FILE_PATH);
+		blocks.push(hasDCOFile ? Report.ok(`DCO file: ${DCO_FILE_PATH}`) : Report.skip("No DCO file (signoff not required)"));
 		const releaseFormat = yield* detectReleaseFormat;
-		yield* Output.detail(`Release format: ${releaseFormat}`);
 		const scopes = yield* Effect.catch(Commitlint.detectScopes, () => Effect.succeed([]));
 		const scopeDisplay = scopes.length > 0 ? scopes.join(", ") : "(none - not a monorepo or no packages found)";
-		yield* Output.detail(`Detected scopes: ${scopeDisplay}`);
-		yield* Output.line("");
-		if (!foundConfig || !hasHuskyHook || !sectionsHealthy) yield* Output.fail(`Commitlint needs configuration. Run: savvy init`);
-		else yield* Output.ok(`Commitlint is configured correctly.`);
+		blocks.push(Report.line("Detected settings"), Report.detail(`DCO required: ${Commitlint.detectDCO()}`), Report.detail(`Release format: ${releaseFormat}`), Report.detail(`Detected scopes: ${scopeDisplay}`));
+		const sectionsHealthy = rows.every(([, , state]) => state === "up-to-date");
+		const hasIssues = !foundConfig || !hasHuskyHook || !sectionsHealthy;
+		blocks.push(hasIssues ? Report.fail("Commitlint needs configuration") : Report.ok("Commitlint is configured correctly"));
+		return {
+			title: "commitlint",
+			blocks,
+			verdict: hasIssues ? "failure" : "success",
+			fixedByInit: hasIssues
+		};
+	});
+}
+/**
+* Check the commitlint setup, print its report on stdout, and set exit code 1
+* when it found a misconfiguration (see {@link commitCheckSection}).
+*
+* @returns An Effect that performs validation and prints its report
+*
+* @internal
+*/
+function runCommitCheck() {
+	return Effect.gen(function* () {
+		const section = yield* commitCheckSection();
+		yield* Report.print([Report.heading(section.title), ...section.blocks]);
+		if (section.verdict === "failure") yield* CliExit.set(1);
 	});
 }
 
 //#endregion
-export { runCommitCheck };
+export { commitCheckSection, runCommitCheck };

package/commands/commit/init.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 { HUSKY_HOOK_PATH, POST_CHECKOUT_HOOK_PATH, POST_COMMIT_HOOK_PATH, POST_MERGE_HOOK_PATH } from "./constants.js";
 import { dirname } from "node:path";
 import { SavvyBaseSection, SavvyHooksSection, SavvyToolchainSection, savvyBasePreamble, savvyHooksHygiene, savvyInstallBlock, savvyToolSection, savvyToolchainCheck } from "@savvy-web/silk-effects";
@@ -70,7 +71,18 @@ export default CommitlintConfig.silk();
 function makeExecutable(path) {
 	return Effect.tryPromise({
 		try: () => chmod(path, EXECUTABLE_MODE),
-		catch: (e) => new Error(String(e))
+		catch: (e) => CommandError.from(e, {
+			message: `could not make ${path} executable`,
+			hint: `Check that you own ${path}, then re-run the init.`
+		})
+	});
+}
+/** The failure for a `--config` path given as absolute. */
+function absoluteConfigError(config) {
+	return new CommandError({
+		message: "Config path must be relative to repository root, not absolute",
+		detail: [`got ${config}`],
+		hint: "Pass the config path relative to the repository root, e.g. lib/configs/<name>.config.ts."
 	});
 }
 /**
@@ -89,14 +101,14 @@ function runCommitInit(opts) {
 	return Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
 		const ms = yield* ManagedSection;
-		if (config.startsWith("/")) yield* Effect.fail(/* @__PURE__ */ new Error("Config path must be relative to repository root, not absolute"));
-		yield* Output.heading("commitlint");
+		if (config.startsWith("/")) return yield* Effect.fail(absoluteConfigError(config));
+		yield* Report.print([Report.heading("commitlint")]);
 		yield* fs.makeDirectory(".husky", { recursive: true });
 		if (force) yield* fs.writeFileString(HUSKY_HOOK_PATH, COMMIT_MSG_HEADER);
 		else yield* ensureHookFile(HUSKY_HOOK_PATH, COMMIT_MSG_HEADER);
 		const commitResults = yield* ms.syncAll(HUSKY_HOOK_PATH, [SavvyBaseSection.section(savvyBasePreamble()), savvyCommitBlock(config)]);
 		yield* makeExecutable(HUSKY_HOOK_PATH);
-		yield* Output.ok(`${force ? "Replaced" : "Synced"} ${HUSKY_HOOK_PATH} (${commitResults.map((r) => r._tag).join(", ")})`);
+		yield* Report.print([Report.ok(`${force ? "Replaced" : "Synced"} ${HUSKY_HOOK_PATH} (${commitResults.map((r) => r._tag).join(", ")})`)]);
 		for (const [hookPath, installHook] of HYGIENE_HOOKS) {
 			yield* ensureHookFile(hookPath, HYGIENE_HEADER);
 			const sections = [SavvyHooksSection.section(savvyHooksHygiene())];
@@ -106,17 +118,16 @@ function runCommitInit(opts) {
 			}
 			yield* ms.syncAll(hookPath, sections);
 			yield* makeExecutable(hookPath);
-			yield* Output.ok(`Synced ${hookPath}`);
+			yield* Report.print([Report.ok(`Synced ${hookPath}`)]);
 		}
-		if ((yield* fs.exists(config)) && !force) yield* Output.warn(`${config} already exists (use --force to overwrite)`);
+		if ((yield* fs.exists(config)) && !force) yield* Report.print([Report.warn(`${config} already exists (use --force to overwrite)`)]);
 		else {
 			const configDir = dirname(config);
 			if (configDir && configDir !== ".") yield* fs.makeDirectory(configDir, { recursive: true });
 			yield* fs.writeFileString(config, CONFIG_CONTENT);
-			yield* Output.ok(`Created ${config}`);
+			yield* Report.print([Report.ok(`Created ${config}`)]);
 		}
-		yield* Output.line("");
-		yield* Output.ok("Install @commitlint/cli if it is not already installed");
+		yield* Report.print([Report.line(""), Report.ok("Install @commitlint/cli if it is not already installed")]);
 	});
 }
 

package/commands/commit/lint.js

@@ -1,4 +1,4 @@
-import { Output } from "../../internal/output.js";
+import { Report } from "../../internal/report.js";
 import { buildCommitlintInvocation } from "./commitlint-invocation.js";
 import { Argument, CliError, Command } from "effect/cli";
 import { Commitlint } from "@savvy-web/silk-effects";
@@ -76,7 +76,7 @@ function runCommitLint(file) {
 		if (stdout.length > 0) yield* Effect.sync(() => process.stdout.write(stdout));
 		if (stderr.length > 0) yield* Effect.sync(() => process.stderr.write(stderr));
 		if (!passed) return yield* Effect.fail(new CliError.UserError({ cause: `Commit message at ${file} failed commitlint validation` }));
-		yield* Output.ok("Commit message passes the Silk commitlint preset");
+		yield* Report.print([Report.ok("Commit message passes the Silk commitlint preset")]);
 	});
 }
 /* v8 ignore next */