@savvy-web/cli 3.5.1 → 3.6.0

package/commands/init.js

@@ -1,38 +1,118 @@
+import { Report } from "../internal/report.js";
+import { CommandError } from "../internal/command-error.js";
 import { runChangesetInit } from "./changeset/commands/init.js";
 import "./changeset/index.js";
+import { HUSKY_HOOK_PATH } from "./commit/constants.js";
 import { runCommitInit } from "./commit/init.js";
+import { confirmDestructive, yesFlag } from "../internal/confirm.js";
 import { runLintInit } from "./lint/init.js";
 import { Command, Flag } from "effect/cli";
-import { Effect } from "effect";
+import { Lint } from "@savvy-web/silk-effects";
+import { Effect, FileSystem } from "effect";
+import { CliUi, Select } from "@effected/cli/ui";
 
 //#region src/commands/init.ts
-/**
-* Unified `savvy init` orchestrator.
-*
-* @remarks
-* Sequences the three tool-specific init handlers — changeset → commit → lint —
-* in a single pass. Short-circuits on the first failure. The three step Effects
-* are injected so the orchestration logic is unit-testable in isolation.
-*
-* Runtime layer provision (ManagedSection, FileSystem, WorkspaceRoot,
-* BiomeSchemaSync, etc.) is deferred to Task B7 (root `main`). The Effect
-* returned by `initCommand`'s handler therefore carries the full union of the
-* three handlers' requirements in its R channel.
-*
-* @internal
-*/
 const DEFAULT_COMMIT_CONFIG = "lib/configs/commitlint.config.ts";
 const DEFAULT_LINT_CONFIG = "lib/configs/lint-staged.config.ts";
 /* v8 ignore start -- CLI option definitions; orchestration logic tested via runInit */
 const forceOption = Flag.Boolean("force").pipe(Flag.withAlias("f"), Flag.withDescription("Overwrite existing config files and hooks across all tools"), Flag.withDefault(false));
 const commitConfigOption = Flag.String("commit-config").pipe(Flag.withDescription("Relative path for the commitlint config file"), Flag.withDefault(DEFAULT_COMMIT_CONFIG));
 const lintConfigOption = Flag.String("lint-config").pipe(Flag.withDescription("Relative path for the lint-staged config file"), Flag.withDefault(DEFAULT_LINT_CONFIG));
+/** The preset a run that cannot ask uses: an agent, CI, a pipe. */
+const DEFAULT_LINT_PRESET = "silk";
+/**
+* `--lint-preset`: given, it is used as is; omitted, a person at a terminal
+* picks one from a `Select` (starting on `silk`), and every other run uses
+* `silk` without loading Ink or React.
+*
+* @internal
+*/
 const lintPresetOption = Flag.Literals("lint-preset", [
 	"minimal",
 	"standard",
 	"silk"
-]).pipe(Flag.withDescription("lint-staged preset: minimal, standard, or silk"), Flag.withDefault("silk"));
-/* v8 ignore stop */
+]).pipe(Flag.withDescription("lint-staged preset: minimal, standard, or silk (asked when omitted at a terminal; default silk)"), Flag.withFallbackPrompt(CliUi.fallback(Select.screen({
+	message: "Which lint-staged preset?",
+	choices: [
+		{
+			label: "silk",
+			value: "silk",
+			detail: "Everything in standard, plus the managed markdownlint config"
+		},
+		{
+			label: "standard",
+			value: "standard",
+			detail: "Biome, shell-script hygiene hooks and markdown"
+		},
+		{
+			label: "minimal",
+			value: "minimal",
+			detail: "Biome only"
+		}
+	]
+}), {
+	flag: "lint-preset",
+	otherwise: DEFAULT_LINT_PRESET
+})));
+/**
+* The files `savvy init --force` replaces wholesale, for the given config
+* paths and preset.
+*
+* @remarks
+* Only the files `--force` rewrites from scratch; the managed sections it
+* syncs into the other hooks are re-synced with or without `--force`.
+*
+* @internal
+*/
+function forceTargets(opts) {
+	return [
+		".changeset/config.json",
+		".changeset/.markdownlint.json",
+		HUSKY_HOOK_PATH,
+		opts.commitConfig,
+		Lint.HUSKY_HOOK_PATH,
+		...opts.lintPreset === "silk" ? [Lint.MARKDOWNLINT_CONFIG_PATH] : [],
+		opts.lintConfig
+	];
+}
+/**
+* Whether `savvy init` may go ahead: asks before `--force` overwrites files
+* that already exist.
+*
+* @remarks
+* Asks only when `force` is set and at least one of `targets` exists; `--yes`
+* and a run that cannot prompt proceed without asking, as `init --force`
+* always has. A "no" prints a line saying nothing was changed and answers
+* `false`.
+*
+* @internal
+*/
+function confirmForce(opts) {
+	return Effect.gen(function* () {
+		if (!opts.force) return true;
+		const fs = yield* FileSystem.FileSystem;
+		const existing = yield* Effect.filter(opts.targets, (path) => fs.exists(path).pipe(Effect.orElseSucceed(() => false)));
+		if (existing.length === 0) return true;
+		const confirmed = yield* confirmDestructive({
+			message: `Overwrite ${existing.length} existing file(s) with --force? (${existing.join(", ")})`,
+			yes: opts.yes
+		});
+		if (!confirmed) yield* Report.print([Report.skip("Nothing changed: existing files kept")]);
+		return confirmed;
+	});
+}
+/**
+* The failure a step of `savvy init` stopped with, as a `CommandError` that
+* draws itself; a `CommandError` a step already raised passes through.
+*
+* @internal
+*/
+function initFailure(error) {
+	return error instanceof CommandError ? error : CommandError.from(error, {
+		message: "savvy init stopped before finishing",
+		hint: "Fix the problem above and re-run savvy init; the steps that already ran are safe to repeat."
+	});
+}
 /**
 * Run the three init step Effects in order: changeset → commit → lint.
 *
@@ -53,25 +133,33 @@ function runInit(steps) {
 /* v8 ignore start -- CLI registration; orchestration logic tested via runInit */
 const _initCommand = Command.make("init", {
 	force: forceOption,
+	yes: yesFlag,
 	commitConfig: commitConfigOption,
 	lintConfig: lintConfigOption,
 	lintPreset: lintPresetOption
-}, (opts) => runInit({
-	changeset: runChangesetInit({
-		force: opts.force,
-		quiet: false,
-		skipMarkdownlint: false,
-		check: false
-	}),
-	commit: runCommitInit({
-		force: opts.force,
-		config: opts.commitConfig
-	}),
-	lint: runLintInit({
+}, (opts) => Effect.gen(function* () {
+	if (!(yield* confirmForce({
 		force: opts.force,
-		config: opts.lintConfig,
-		preset: opts.lintPreset
-	})
+		yes: opts.yes,
+		targets: forceTargets(opts)
+	}))) return;
+	yield* runInit({
+		changeset: runChangesetInit({
+			force: opts.force,
+			quiet: false,
+			skipMarkdownlint: false,
+			check: false
+		}),
+		commit: runCommitInit({
+			force: opts.force,
+			config: opts.commitConfig
+		}),
+		lint: runLintInit({
+			force: opts.force,
+			config: opts.lintConfig,
+			preset: opts.lintPreset
+		})
+	}).pipe(Effect.mapError(initFailure));
 })).pipe(Command.withDescription("Bootstrap a repository for all Silk Suite tools in one pass"));
 /* v8 ignore stop */
 /**
@@ -85,4 +173,4 @@ const _initCommand = Command.make("init", {
 const initCommand = _initCommand;
 
 //#endregion
-export { initCommand, runInit };
+export { confirmForce, forceTargets, initCommand, initFailure, lintPresetOption, runInit };

package/commands/lint/check.js

@@ -1,5 +1,7 @@
-import { Output } from "../../internal/output.js";
+import { Report } from "../../internal/report.js";
+import { hookTable } from "../check-section.js";
 import { BIOME_VERSION } from "./biome-version.js";
+import { CliExit } from "@effected/cli";
 import { ConfigDiscovery, Lint, SavvyBaseSection, SavvyHooksSection, SavvyToolchainSection, savvyBasePreamble, savvyHooksHygiene, savvyInstallBlock, savvyOkfBlock, savvyToolchainCheck } from "@savvy-web/silk-effects";
 import { Effect, FileSystem, Option } from "effect";
 import { Jsonc } from "@effected/jsonc";
@@ -132,17 +134,25 @@ function checkBiomeSchemas() {
 	});
 }
 /**
-* Run the lint check validation pipeline.
+* Check the lint-staged setup and return it as a {@link CheckSection}.
 *
-* Exported so Task B6's unified `savvy check` orchestrator can invoke the
-* lint check step directly without going through the CLI command layer.
+* @remarks
+* Severity rule: anything `savvy init` would write or rewrite is a finding
+* (`✗`, verdict `failure`) — a missing config file or `pre-commit` hook, a
+* managed section that is absent or drifted in a hook file that exists, a
+* biome `$schema` behind {@link BIOME_VERSION}, a markdownlint `$schema` that
+* differs from the template. Advice is `⚠` (verdict `warning`): markdownlint
+* rules that differ from the template (only `savvy init --force` overwrites
+* them, so they may be deliberate) and biome configs that could not be read.
+* Absent is not a finding where a preset may leave it out: a missing hygiene
+* hook FILE (the minimal preset writes none) or an uninstalled tool is `↷`.
 *
-* @param opts - Options for the check command
-* @returns An Effect that performs validation and logs results
+* Under `quiet` the body is only the collected warning lines (none when
+* there are none); the verdict is the same.
 *
 * @internal
 */
-function runLintCheck(opts) {
+function lintCheckSection(opts) {
 	const { quiet } = opts;
 	return Effect.gen(function* () {
 		const fs = yield* FileSystem.FileSystem;
@@ -150,173 +160,115 @@ function runLintCheck(opts) {
 		const td = yield* ToolDiscovery;
 		const discovery = yield* ConfigDiscovery;
 		const warnings = [];
+		const rows = [];
+		const stateOf = (outcome) => CheckOutcome.$is("UpToDate")(outcome) ? "up-to-date" : CheckOutcome.$is("Drifted")(outcome) ? "outdated" : "missing";
 		const foundConfig = yield* findConfigFile(fs);
 		const hasHuskyHook = yield* fs.exists(Lint.HUSKY_HOOK_PATH);
-		let sectionsHealthy = true;
-		let baseStatusLabel = "missing";
-		let lintStatusLabel = "missing";
-		let okfStatusLabel = "missing";
 		let detectedConfigPath = null;
 		if (hasHuskyHook) {
-			const baseResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, SavvyBaseSection.section(savvyBasePreamble()));
-			if (CheckOutcome.$is("Absent")(baseResult)) sectionsHealthy = false;
-			else {
-				const upToDate = CheckOutcome.$is("UpToDate")(baseResult);
-				baseStatusLabel = upToDate ? "up-to-date" : "outdated";
-				if (!upToDate) sectionsHealthy = false;
-			}
+			rows.push([
+				Lint.HUSKY_HOOK_PATH,
+				"savvy-base",
+				stateOf(yield* ms.check(Lint.HUSKY_HOOK_PATH, SavvyBaseSection.section(savvyBasePreamble())))
+			]);
 			const existing = yield* ms.read(Lint.HUSKY_HOOK_PATH, Lint.SavvyLintSectionDef);
 			if (Option.isSome(existing)) {
-				const configPath = extractConfigPathFromManaged(existing.value.content);
-				detectedConfigPath = configPath;
-				if (configPath) {
-					const lintResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, Lint.savvyLintBlock(configPath));
-					if (CheckOutcome.$is("Absent")(lintResult)) {
-						lintStatusLabel = "outdated";
-						sectionsHealthy = false;
-					} else {
-						const upToDate = CheckOutcome.$is("UpToDate")(lintResult);
-						lintStatusLabel = upToDate ? "up-to-date" : "outdated";
-						if (!upToDate) sectionsHealthy = false;
-					}
-				} else {
-					lintStatusLabel = "outdated";
-					sectionsHealthy = false;
-				}
-			} else sectionsHealthy = false;
-			const okfResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, savvyOkfBlock());
-			if (CheckOutcome.$is("Absent")(okfResult)) sectionsHealthy = false;
-			else {
-				const upToDate = CheckOutcome.$is("UpToDate")(okfResult);
-				okfStatusLabel = upToDate ? "up-to-date" : "outdated";
-				if (!upToDate) sectionsHealthy = false;
-			}
-			if (baseStatusLabel !== "up-to-date" || lintStatusLabel !== "up-to-date" || okfStatusLabel !== "up-to-date") warnings.push(`${WARNING}  Your ${Lint.HUSKY_HOOK_PATH} managed sections are out of date.\n   Run 'savvy init' to update (preserves your custom hooks).`);
-		} else {
-			sectionsHealthy = false;
-			warnings.push(`${WARNING}  No husky pre-commit hook found.\n   Run 'savvy init' to create it.`);
-		}
+				detectedConfigPath = extractConfigPathFromManaged(existing.value.content);
+				const state = detectedConfigPath ? CheckOutcome.$is("UpToDate")(yield* ms.check(Lint.HUSKY_HOOK_PATH, Lint.savvyLintBlock(detectedConfigPath))) ? "up-to-date" : "outdated" : "outdated";
+				rows.push([
+					Lint.HUSKY_HOOK_PATH,
+					"savvy-lint",
+					state
+				]);
+			} else rows.push([
+				Lint.HUSKY_HOOK_PATH,
+				"savvy-lint",
+				"missing"
+			]);
+			rows.push([
+				Lint.HUSKY_HOOK_PATH,
+				"savvy-okf",
+				stateOf(yield* ms.check(Lint.HUSKY_HOOK_PATH, savvyOkfBlock()))
+			]);
+			if (rows.some(([, , state]) => state !== "up-to-date")) warnings.push(`${WARNING}  Your ${Lint.HUSKY_HOOK_PATH} managed sections are out of date.\n   Run 'savvy init' to update (preserves your custom hooks).`);
+		} else warnings.push(`${WARNING}  No husky pre-commit hook found.\n   Run 'savvy init' to create it.`);
 		if (!foundConfig) warnings.push(`${WARNING}  No lint-staged config file found.\n   Run 'savvy init' to create one.`);
-		const shellHookPaths = [
+		for (const hookPath of [
 			Lint.POST_CHECKOUT_HOOK_PATH,
 			Lint.POST_MERGE_HOOK_PATH,
 			Lint.POST_COMMIT_HOOK_PATH
-		];
-		const shellHookStatuses = [];
-		const toolchainStatuses = [];
-		const installStatuses = [];
-		for (const hookPath of shellHookPaths) {
+		]) {
 			if (!(yield* fs.exists(hookPath))) {
-				shellHookStatuses.push({
-					path: hookPath,
-					found: false,
-					isUpToDate: false
-				});
+				rows.push([
+					hookPath,
+					"(hook file)",
+					"not installed"
+				]);
 				continue;
 			}
-			const hygieneResult = yield* ms.check(hookPath, SavvyHooksSection.section(savvyHooksHygiene()));
-			const found = !CheckOutcome.$is("Absent")(hygieneResult);
-			const isUpToDate = CheckOutcome.$is("UpToDate")(hygieneResult);
-			shellHookStatuses.push({
-				path: hookPath,
-				found,
-				isUpToDate
-			});
-			if (!found) {
-				sectionsHealthy = false;
-				warnings.push(`${WARNING}  ${hookPath} has no savvy-hooks section.\n   Run 'savvy init' to add it.`);
-			} else if (!isUpToDate) {
-				sectionsHealthy = false;
-				warnings.push(`${WARNING}  ${hookPath} savvy-hooks section is outdated.\n   Run 'savvy init' to update.`);
+			const sections = [["savvy-hooks", SavvyHooksSection.section(savvyHooksHygiene())]];
+			if (hookPath !== Lint.POST_COMMIT_HOOK_PATH) {
+				const installHook = hookPath === Lint.POST_CHECKOUT_HOOK_PATH ? "post-checkout" : "post-merge";
+				sections.push(["savvy-install", savvyInstallBlock(installHook)], ["savvy-toolchain", SavvyToolchainSection.section(savvyToolchainCheck())]);
 			}
-			if (hookPath === Lint.POST_COMMIT_HOOK_PATH) continue;
-			const installHook = hookPath === Lint.POST_CHECKOUT_HOOK_PATH ? "post-checkout" : "post-merge";
-			const installResult = yield* ms.check(hookPath, savvyInstallBlock(installHook));
-			const installFound = !CheckOutcome.$is("Absent")(installResult);
-			const installUpToDate = CheckOutcome.$is("UpToDate")(installResult);
-			installStatuses.push({
-				path: hookPath,
-				found: installFound,
-				isUpToDate: installUpToDate
-			});
-			if (!installFound) {
-				sectionsHealthy = false;
-				warnings.push(`${WARNING}  ${hookPath} has no savvy-install section.\n   Run 'savvy init' to add it.`);
-			} else if (!installUpToDate) {
-				sectionsHealthy = false;
-				warnings.push(`${WARNING}  ${hookPath} savvy-install section is outdated.\n   Run 'savvy init' to update.`);
-			}
-			const toolchainResult = yield* ms.check(hookPath, SavvyToolchainSection.section(savvyToolchainCheck()));
-			const toolchainFound = !CheckOutcome.$is("Absent")(toolchainResult);
-			const toolchainUpToDate = CheckOutcome.$is("UpToDate")(toolchainResult);
-			toolchainStatuses.push({
-				path: hookPath,
-				found: toolchainFound,
-				isUpToDate: toolchainUpToDate
-			});
-			if (!toolchainFound) {
-				sectionsHealthy = false;
-				warnings.push(`${WARNING}  ${hookPath} has no savvy-toolchain section.\n   Run 'savvy init' to add it.`);
-			} else if (!toolchainUpToDate) {
-				sectionsHealthy = false;
-				warnings.push(`${WARNING}  ${hookPath} savvy-toolchain section is outdated.\n   Run 'savvy init' to update.`);
+			for (const [name, section] of sections) {
+				const state = stateOf(yield* ms.check(hookPath, section));
+				rows.push([
+					hookPath,
+					name,
+					state
+				]);
+				if (state === "missing") warnings.push(`${WARNING}  ${hookPath} has no ${name} section.\n   Run 'savvy init' to add it.`);
+				else if (state === "outdated") warnings.push(`${WARNING}  ${hookPath} ${name} section is outdated.\n   Run 'savvy init' to update.`);
 			}
 		}
-		const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catch(() => Effect.succeed({
+		const biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.map((status) => ({
+			...status,
+			readable: true
+		})), Effect.catch(() => Effect.succeed({
 			statuses: [],
-			warnings: [`${WARNING}  Could not check biome $schema URLs.`]
+			warnings: [`${WARNING}  Could not check biome $schema URLs.`],
+			readable: false
 		})));
 		warnings.push(...biomeSchemaStatus.warnings);
 		const hasMarkdownlintConfig = yield* fs.exists(Lint.MARKDOWNLINT_CONFIG_PATH);
-		let markdownlintStatus = {
+		const markdownlintStatus = hasMarkdownlintConfig ? yield* checkMarkdownlintConfig(yield* fs.readFileString(Lint.MARKDOWNLINT_CONFIG_PATH)) : {
 			exists: false,
 			schemaMatches: false,
 			configMatches: false,
 			isUpToDate: false
 		};
+		if (hasMarkdownlintConfig && !markdownlintStatus.schemaMatches) warnings.push(`${WARNING}  ${Lint.MARKDOWNLINT_CONFIG_PATH}: $schema differs from template.\n   Run 'savvy init' to update it.`);
+		if (hasMarkdownlintConfig && !markdownlintStatus.configMatches) warnings.push(`${WARNING}  ${Lint.MARKDOWNLINT_CONFIG_PATH}: config rules differ from template.\n   Run 'savvy init --force' to overwrite.`);
+		const sectionsHealthy = rows.every(([, , state]) => state === "up-to-date" || state === "not installed");
+		const findings = !foundConfig || !hasHuskyHook || !sectionsHealthy || hasMarkdownlintConfig && !markdownlintStatus.schemaMatches || biomeSchemaStatus.statuses.some((status) => !status.matches);
+		const advice = hasMarkdownlintConfig && !markdownlintStatus.configMatches || !biomeSchemaStatus.readable;
+		const verdict = findings ? "failure" : advice ? "warning" : "success";
+		const title = "lint-staged";
+		if (quiet) return {
+			title,
+			blocks: warnings.map((warning) => Report.verbatim(warning)),
+			verdict,
+			fixedByInit: findings
+		};
+		const blocks = [];
+		blocks.push(foundConfig ? Report.ok(`Config file: ${foundConfig}`) : Report.fail("No lint-staged config file found"));
+		blocks.push(hasHuskyHook ? Report.ok(`Husky hook: ${Lint.HUSKY_HOOK_PATH}`) : Report.fail("No husky pre-commit hook found"));
+		if (detectedConfigPath) blocks.push(Report.detail(`savvy-lint runs: ${detectedConfigPath}`));
+		if (rows.length > 0) blocks.push(hookTable(rows));
 		if (hasMarkdownlintConfig) {
-			markdownlintStatus = yield* checkMarkdownlintConfig(yield* fs.readFileString(Lint.MARKDOWNLINT_CONFIG_PATH));
-			if (!markdownlintStatus.schemaMatches) warnings.push(`${WARNING}  ${Lint.MARKDOWNLINT_CONFIG_PATH}: $schema differs from template.\n   Run 'savvy init' to update it.`);
-			if (!markdownlintStatus.configMatches) warnings.push(`${WARNING}  ${Lint.MARKDOWNLINT_CONFIG_PATH}: config rules differ from template.\n   Run 'savvy init --force' to overwrite.`);
-		}
-		if (quiet) {
-			if (warnings.length > 0) for (const warning of warnings) yield* Output.line(warning);
-			return;
-		}
-		yield* Output.heading("lint-staged configuration");
-		if (foundConfig) yield* Output.ok(`Config file: ${foundConfig}`);
-		else yield* Output.fail(`No lint-staged config file found`);
-		if (hasHuskyHook) yield* Output.ok(`Husky hook: ${Lint.HUSKY_HOOK_PATH}`);
-		else yield* Output.fail(`No husky pre-commit hook found`);
-		if (hasHuskyHook) {
-			if (baseStatusLabel === "up-to-date") yield* Output.ok(`Base section: up-to-date`);
-			else if (baseStatusLabel === "outdated") yield* Output.warn(`Base section: outdated (run 'savvy init' to update)`);
-			else yield* Output.skip(`Base section: not found (run 'savvy init' to add)`);
-			const lintLabel = detectedConfigPath ? ` (config: ${detectedConfigPath})` : "";
-			if (lintStatusLabel === "up-to-date") yield* Output.ok(`Lint section: up-to-date${lintLabel}`);
-			else if (lintStatusLabel === "outdated") yield* Output.warn(`Lint section: outdated (run 'savvy init' to update)`);
-			else yield* Output.skip(`Lint section: not found (run 'savvy init' to add)`);
-			if (okfStatusLabel === "up-to-date") yield* Output.ok(`OKF section: up-to-date`);
-			else if (okfStatusLabel === "outdated") yield* Output.warn(`OKF section: outdated (run 'savvy init' to update)`);
-			else yield* Output.skip(`OKF section: not found (run 'savvy init' to add)`);
-		}
-		for (const status of shellHookStatuses) if (!status.found) yield* Output.skip(`${status.path}: savvy-hooks section not found`);
-		else if (status.isUpToDate) yield* Output.ok(`${status.path}: up-to-date`);
-		else yield* Output.warn(`${status.path}: outdated (run 'savvy init' to update)`);
-		for (const status of installStatuses) if (!status.found) yield* Output.skip(`${status.path}: savvy-install section not found`);
-		else if (status.isUpToDate) yield* Output.ok(`${status.path}: savvy-install up-to-date`);
-		else yield* Output.warn(`${status.path}: savvy-install outdated (run 'savvy init' to update)`);
-		for (const status of toolchainStatuses) if (!status.found) yield* Output.skip(`${status.path}: savvy-toolchain section not found`);
-		else if (status.isUpToDate) yield* Output.ok(`${status.path}: savvy-toolchain up-to-date`);
-		else yield* Output.warn(`${status.path}: savvy-toolchain outdated (run 'savvy init' to update)`);
-		yield* Output.line("");
-		yield* Output.heading("Tool availability");
+			if (markdownlintStatus.isUpToDate) blocks.push(Report.ok(`${Lint.MARKDOWNLINT_CONFIG_PATH}: up-to-date`));
+			else {
+				if (!markdownlintStatus.schemaMatches) blocks.push(Report.fail(`${Lint.MARKDOWNLINT_CONFIG_PATH}: $schema differs from template`));
+				if (!markdownlintStatus.configMatches) blocks.push(Report.warn(`${Lint.MARKDOWNLINT_CONFIG_PATH}: config rules differ from template (savvy init --force overwrites)`));
+			}
+		} else blocks.push(Report.skip(`${Lint.MARKDOWNLINT_CONFIG_PATH}: not found`));
+		if (!biomeSchemaStatus.readable) blocks.push(Report.warn("Could not check biome $schema URLs"));
+		for (const status of biomeSchemaStatus.statuses) blocks.push(status.matches ? Report.ok(`${status.path}: biome $schema up-to-date`) : Report.fail(`${status.path}: biome $schema outdated`));
+		blocks.push(Report.line("Tool availability"));
 		const biomeAvailable = yield* td.isAvailable(Tool.named("biome"));
 		const biomeConfig = yield* findConfig(discovery, ["biome.jsonc", "biome.json"]);
-		if (biomeAvailable) {
-			const configInfo = biomeConfig ? ` (config: ${biomeConfig})` : "";
-			yield* Output.ok(`Biome${configInfo}`);
-		} else yield* Output.skip(`Biome: not installed`);
+		blocks.push(biomeAvailable ? Report.ok(`Biome${biomeConfig ? ` (config: ${biomeConfig})` : ""}`) : Report.skip("Biome: not installed"));
 		const markdownAvailable = yield* td.isAvailable(Tool.named("markdownlint-cli2"));
 		const markdownConfig = yield* findConfig(discovery, [
 			".markdownlint-cli2.jsonc",
@@ -327,33 +279,36 @@ function runLintCheck(opts) {
 			".markdownlint.json",
 			".markdownlint.yaml"
 		]);
-		if (markdownAvailable) {
-			const configInfo = markdownConfig ? ` (config: ${markdownConfig})` : "";
-			yield* Output.ok(`markdownlint-cli2${configInfo}`);
-		} else yield* Output.skip(`markdownlint-cli2: not installed`);
+		blocks.push(markdownAvailable ? Report.ok(`markdownlint-cli2${markdownConfig ? ` (config: ${markdownConfig})` : ""}`) : Report.skip("markdownlint-cli2: not installed"));
 		const tscAvailable = yield* td.isAvailable(Tool.named("tsc"));
-		const tsgoAvailable = yield* td.isAvailable(Tool.named("tsgo"));
-		if (tscAvailable) yield* Output.ok(`TypeScript (tsc)`);
-		else if (tsgoAvailable) yield* Output.ok(`TypeScript (tsgo)`);
-		else yield* Output.skip(`TypeScript: not installed`);
-		if (hasMarkdownlintConfig) {
-			if (markdownlintStatus.isUpToDate) yield* Output.ok(`${Lint.MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
-			else {
-				const issues = [];
-				if (!markdownlintStatus.schemaMatches) issues.push("$schema");
-				if (!markdownlintStatus.configMatches) issues.push("config");
-				yield* Output.warn(`${Lint.MARKDOWNLINT_CONFIG_PATH}: ${issues.join(", ")} differ from template`);
-			}
-		} else yield* Output.skip(`${Lint.MARKDOWNLINT_CONFIG_PATH}: not found`);
-		for (const status of biomeSchemaStatus.statuses) if (status.matches) yield* Output.ok(`${status.path}: biome $schema up-to-date`);
-		else yield* Output.warn(`${status.path}: biome $schema outdated (run 'savvy init' to update)`);
-		yield* Output.line("");
-		const hasMarkdownlintIssues = hasMarkdownlintConfig && !markdownlintStatus.isUpToDate;
-		const hasBiomeSchemaIssues = biomeSchemaStatus.statuses.some((s) => !s.matches);
-		if (!foundConfig || !hasHuskyHook || !sectionsHealthy || hasMarkdownlintIssues || hasBiomeSchemaIssues) yield* Output.warn(`Some issues found. Run 'savvy init' to fix.`);
-		else yield* Output.ok(`Lint-staged is configured correctly.`);
+		const tsgoAvailable = tscAvailable ? false : yield* td.isAvailable(Tool.named("tsgo"));
+		blocks.push(tscAvailable ? Report.ok("TypeScript (tsc)") : tsgoAvailable ? Report.ok("TypeScript (tsgo)") : Report.skip("TypeScript: not installed"));
+		blocks.push(verdict === "failure" ? Report.fail("lint-staged needs configuration") : verdict === "warning" ? Report.warn("lint-staged is configured, with advisories") : Report.ok("lint-staged is configured correctly"));
+		return {
+			title,
+			blocks,
+			verdict,
+			fixedByInit: findings
+		};
+	});
+}
+/**
+* Check the lint-staged setup, print its report on stdout, and set exit code
+* 1 when it found a misconfiguration (see {@link lintCheckSection} for the
+* severity rule). Under `quiet` only the warnings are printed.
+*
+* @param opts - Options for the check command
+* @returns An Effect that performs validation and prints its report
+*
+* @internal
+*/
+function runLintCheck(opts) {
+	return Effect.gen(function* () {
+		const section = yield* lintCheckSection(opts);
+		yield* Report.print(opts.quiet ? section.blocks : [Report.heading(section.title), ...section.blocks]);
+		if (section.verdict === "failure") yield* CliExit.set(1);
 	});
 }
 
 //#endregion
-export { runLintCheck };
+export { lintCheckSection, runLintCheck };