@savvy-web/cli 0.3.0 → 0.4.0

package/commands/commit/hooks/user-prompt-submit.js

@@ -0,0 +1,42 @@
+import { Command } from "@effect/cli";
+import { Commitlint } from "@savvy-web/silk-effects";
+import { Effect, Schema } from "effect";
+
+//#region src/commands/commit/hooks/user-prompt-submit.ts
+/**
+* `savvy commit hook user-prompt-submit` — emits a compact reminder when
+* the prompt mentions commit-related verbs.
+*
+* @internal
+*/
+const TRIGGER = /(\bcommit\b|\bcommitting\b|\bship (it|this)\b|\bwrap (it )?up\b|\b(create|open) a (pr|pull request)\b|\bfinalize\b|\/finalize\b|\bsquash\b|\bamend\b)/i;
+function reminderForPrompt(prompt) {
+	if (!TRIGGER.test(prompt)) return null;
+	return [
+		"<commit_reminder>",
+		"Before composing this commit message, invoke the commitlint:commit-create skill.",
+		"It defines the complete type enum, scope rules, DCO signoff format, and body",
+		"constraints enforced by @savvy-web/commitlint.",
+		"</commit_reminder>"
+	].join("\n");
+}
+const userPromptSubmitCommand = Command.make("user-prompt-submit", {}, () => Effect.gen(function* () {
+	const stdin = yield* Effect.promise(readStdin);
+	let envelope;
+	try {
+		envelope = Schema.decodeUnknownSync(Commitlint.UserPromptSubmitEnvelope)(JSON.parse(stdin));
+	} catch {
+		return;
+	}
+	const reminder = reminderForPrompt(envelope.prompt);
+	if (reminder === null) return;
+	yield* Effect.sync(() => process.stdout.write(`${JSON.stringify(Commitlint.userPromptSubmitContext(reminder))}\n`));
+}).pipe(Effect.provide(Commitlint.HookSilencer))).pipe(Command.withDescription("Inject a commit-quality reminder when the user prompt mentions commits"));
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(chunk);
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+//#endregion
+export { userPromptSubmitCommand };

package/commands/commit/index.js

@@ -0,0 +1,20 @@
+import { runCommitInit } from "./init.js";
+import { runCommitCheck } from "./check.js";
+import { hookCommand } from "./hook.js";
+import { Command } from "@effect/cli";
+
+//#region src/commands/commit/index.ts
+/* v8 ignore start -- CLI registration; each command tested via exported handler */
+const _commitCommand = Command.make("commit").pipe(Command.withSubcommands([hookCommand]), Command.withDescription("Commit standards: config, checks, and Claude hook handlers"));
+/**
+* The `savvy commit` command group for use in Task B7 root assembly.
+*
+* @remarks
+* Typed as `unknown` at the export boundary to avoid TypeScript declaration-emit
+* errors from Effect's internal types. Task B7 should import and use this directly
+* as `Command.withSubcommands([commitCommand])` — the cast is for declaration emit only.
+*/
+const commitCommand = _commitCommand;
+
+//#endregion
+export { commitCommand };

package/commands/commit/init.js

@@ -0,0 +1,127 @@
+import { HUSKY_HOOK_PATH, POST_CHECKOUT_HOOK_PATH, POST_MERGE_HOOK_PATH } from "./constants.js";
+import { Command, Options } from "@effect/cli";
+import { ManagedSection, SavvyBaseSection, SavvyHooksSection, SectionDefinition, savvyBasePreamble, savvyHooksHygiene, savvyToolSection } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { dirname } from "node:path";
+import { FileSystem } from "@effect/platform";
+import { chmod } from "node:fs/promises";
+
+//#region src/commands/commit/init.ts
+/**
+* Init command - bootstrap commitlint configuration.
+*
+* @internal
+*/
+/** Executable file permission mode. */
+const EXECUTABLE_MODE = 493;
+/** Default path for the commitlint config file. */
+const DEFAULT_CONFIG_PATH = "lib/configs/commitlint.config.ts";
+/** Section definition for the savvy-commit tool section (identity for read/check/remove). */
+const SECTION_DEF = SectionDefinition.make({ toolName: "savvy-commit" });
+/** Header written when creating a fresh commit-msg hook. */
+const COMMIT_MSG_HEADER = "#!/usr/bin/env sh\n# Commit-msg hook with savvy managed sections\n# Custom hooks can go above, below, or between the managed sections\n\n";
+/** Header written when creating a fresh hygiene hook (post-checkout / post-merge). */
+const HYGIENE_HEADER = "#!/usr/bin/env sh\n# Managed by savvy-hooks\n# Custom hooks can go above or below the managed section\n\n";
+/**
+* Build the commitlint command run inside the savvy-commit tool section.
+*
+* @param configPath - Path to the commitlint config file (relative to repo root)
+*/
+function commitlintCommand(configPath) {
+	return `commitlint --config "$ROOT/${configPath}" --edit "$1"`;
+}
+/**
+* Build the savvy-commit tool section block for the given config path.
+*
+* @remarks
+* Depends on the savvy-base preamble (`in_ci`, `pm_exec`) preceding it in the hook.
+*
+* @remarks
+* Exported for reuse by the check command, which rebuilds this block to compare against the on-disk section.
+*/
+function savvyCommitBlock(configPath) {
+	return savvyToolSection("savvy-commit", commitlintCommand(configPath));
+}
+/** Ensure a hook file exists, writing `header` if it does not. */
+function ensureHookFile(path, header) {
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		if (!(yield* fs.exists(path))) yield* fs.writeFileString(path, header);
+	});
+}
+/* v8 ignore start -- CLI option definitions; handler tested individually */
+const forceOption = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite the commit-msg hook and config file entirely (managed sections in post-checkout/post-merge are never force-reset)"), Options.withDefault(false));
+const configOption = Options.text("config").pipe(Options.withAlias("c"), Options.withDescription("Relative path for the commitlint config file (from repo root)"), Options.withDefault(DEFAULT_CONFIG_PATH));
+/* v8 ignore stop */
+/** Content for the commitlint config file. */
+const CONFIG_CONTENT = `import { CommitlintConfig } from "@savvy-web/silk/commitlint";
+
+export default CommitlintConfig.silk();
+`;
+/** Make a file executable. */
+function makeExecutable(path) {
+	return Effect.tryPromise({
+		try: () => chmod(path, EXECUTABLE_MODE),
+		catch: (e) => new Error(String(e))
+	});
+}
+/**
+* Run the full init pipeline.
+*
+* Exported so Task B5's unified `savvy init` orchestrator can invoke the
+* commitlint init step directly without going through the CLI command layer.
+*
+* @param opts - The same options the CLI command receives
+* @returns An Effect that performs initialization
+*
+* @internal
+*/
+function runCommitInit(opts) {
+	const { force, config } = 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* Effect.log("Initializing commitlint configuration...\n");
+		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.syncMany(HUSKY_HOOK_PATH, [SavvyBaseSection.block(savvyBasePreamble()), savvyCommitBlock(config)]);
+		yield* makeExecutable(HUSKY_HOOK_PATH);
+		yield* Effect.log(`${"✓"} ${force ? "Replaced" : "Synced"} ${HUSKY_HOOK_PATH} (${commitResults.map((r) => r._tag).join(", ")})`);
+		for (const hookPath of [POST_CHECKOUT_HOOK_PATH, POST_MERGE_HOOK_PATH]) {
+			yield* ensureHookFile(hookPath, HYGIENE_HEADER);
+			yield* ms.sync(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
+			yield* makeExecutable(hookPath);
+			yield* Effect.log(`${"✓"} Synced ${hookPath}`);
+		}
+		if ((yield* fs.exists(config)) && !force) yield* Effect.log(`${"⚠"} ${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* Effect.log(`${"✓"} Created ${config}`);
+		}
+		yield* Effect.log("\nDone! Install @commitlint/cli if not already installed.");
+	});
+}
+/**
+* Init command implementation.
+*
+* @remarks
+* Writes:
+* - `.husky/commit-msg` — savvy-base preamble + savvy-commit tool section.
+* - `.husky/post-checkout` and `.husky/post-merge` — savvy-hooks hygiene
+*   (co-owned with `@savvy-web/lint-staged`; idempotent).
+* - The commitlint config file.
+*
+* Users may add custom commands above, below, or between the managed sections.
+*/
+/* v8 ignore next 3 -- CLI registration; handler tested via runCommitInit */
+const initCommand = Command.make("init", {
+	force: forceOption,
+	config: configOption
+}, (opts) => runCommitInit(opts)).pipe(Command.withDescription("Initialize commitlint configuration and husky hooks"));
+
+//#endregion
+export { SECTION_DEF, runCommitInit, savvyCommitBlock };

package/commands/init.js

@@ -0,0 +1,88 @@
+import { runChangesetInit } from "./changeset/commands/init.js";
+import "./changeset/index.js";
+import { runCommitInit } from "./commit/init.js";
+import { runLintInit } from "./lint/init.js";
+import { Command, Options } from "@effect/cli";
+import { Effect } from "effect";
+
+//#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 `runCli`). 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 = Options.boolean("force").pipe(Options.withAlias("f"), Options.withDescription("Overwrite existing config files and hooks across all tools"), Options.withDefault(false));
+const commitConfigOption = Options.text("commit-config").pipe(Options.withDescription("Relative path for the commitlint config file"), Options.withDefault(DEFAULT_COMMIT_CONFIG));
+const lintConfigOption = Options.text("lint-config").pipe(Options.withDescription("Relative path for the lint-staged config file"), Options.withDefault(DEFAULT_LINT_CONFIG));
+const lintPresetOption = Options.choice("lint-preset", [
+	"minimal",
+	"standard",
+	"silk"
+]).pipe(Options.withDescription("lint-staged preset: minimal, standard, or silk"), Options.withDefault("silk"));
+/* v8 ignore stop */
+/**
+* Run the three init step Effects in order: changeset → commit → lint.
+*
+* Monadic sequencing via `Effect.gen` short-circuits on the first failure —
+* if changeset fails, neither commit nor lint will run.
+*
+* @param steps - The three step Effects to sequence. Injected for testability.
+* @returns An Effect that resolves to `void` on success, or fails with the
+*   error of the first failing step.
+*/
+function runInit(steps) {
+	return Effect.gen(function* () {
+		yield* steps.changeset;
+		yield* steps.commit;
+		yield* steps.lint;
+	});
+}
+/* v8 ignore start -- CLI registration; orchestration logic tested via runInit */
+const _initCommand = Command.make("init", {
+	force: forceOption,
+	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({
+		force: opts.force,
+		config: opts.lintConfig,
+		preset: opts.lintPreset
+	})
+})).pipe(Command.withDescription("Bootstrap a repository for all Silk Suite tools in one pass"));
+/* v8 ignore stop */
+/**
+* The `savvy init` command for use in the Task B7 root assembly.
+*
+* @remarks
+* Typed with `any` at the export boundary to avoid TypeScript declaration-emit
+* errors from Effect's internal types. Task B7 should use this via
+* `Command.withSubcommands([initCommand as never])` or re-infer the type.
+*/
+const initCommand = _initCommand;
+
+//#endregion
+export { initCommand, runInit };

package/commands/lint/check.js

@@ -0,0 +1,306 @@
+import { Command, Options } from "@effect/cli";
+import { CheckResult, ConfigDiscovery, Lint, ManagedSection, SavvyBaseSection, SavvyHooksSection, ToolDefinition, ToolDiscovery, savvyBasePreamble, savvyHooksHygiene } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { parse } from "jsonc-effect";
+import { FileSystem } from "@effect/platform";
+import { isDeepStrictEqual } from "node:util";
+
+//#region src/commands/lint/check.ts
+/**
+* Check command - validate current lint-staged setup.
+*
+* @internal
+*/
+/** Unicode checkmark symbol. */
+const CHECK_MARK = "✓";
+/** Unicode cross symbol. */
+const CROSS_MARK = "✗";
+/** Unicode warning symbol. */
+const WARNING = "⚠";
+/** Unicode bullet symbol. */
+const BULLET = "•";
+/** Paths to search for config files. */
+const CONFIG_SEARCH_PATHS = [
+	"lib/configs/lint-staged.config.ts",
+	"lib/configs/lint-staged.config.js",
+	...[
+		"lint-staged.config.ts",
+		"lint-staged.config.js",
+		"lint-staged.config.mjs",
+		"lint-staged.config.cjs",
+		".lintstagedrc",
+		".lintstagedrc.json",
+		".lintstagedrc.yaml",
+		".lintstagedrc.yml",
+		".lintstagedrc.js",
+		".lintstagedrc.cjs",
+		".lintstagedrc.mjs"
+	]
+];
+/**
+* Find the first existing config file.
+*
+* @param fs - FileSystem service
+* @returns Effect yielding the config file name or null
+*/
+function findConfigFile(fs) {
+	return Effect.gen(function* () {
+		for (const file of CONFIG_SEARCH_PATHS) if (yield* fs.exists(file)) return file;
+		return null;
+	});
+}
+/**
+* Find the first existing config file from a list of candidates using ConfigDiscovery.
+*
+* @param discovery - ConfigDiscovery service
+* @param names - Config file names to search for (in priority order)
+* @returns The config file path or null
+*/
+function findConfig(discovery, names) {
+	return Effect.gen(function* () {
+		for (const name of names) {
+			const result = yield* discovery.find(name);
+			if (result) return result.path;
+		}
+		return null;
+	});
+}
+/**
+* Extract the config path from the managed section.
+*
+* @param managedContent - The content between managed section markers
+* @returns The config path found, or null if not found
+*/
+function extractConfigPathFromManaged(managedContent) {
+	const match = managedContent.match(/lint-staged --config "\$ROOT\/([^"]+)"/);
+	return match ? match[1] : null;
+}
+/**
+* Check the markdownlint-cli2 config against the template.
+*
+* @param content - The existing file content
+* @returns Status object with match details
+*/
+function checkMarkdownlintConfig(content) {
+	return Effect.gen(function* () {
+		const parsed = yield* parse(content);
+		const schemaMatches = parsed.$schema === Lint.MARKDOWNLINT_SCHEMA;
+		const existingConfig = parsed.config;
+		const configMatches = existingConfig !== void 0 && isDeepStrictEqual(existingConfig, Lint.MARKDOWNLINT_CONFIG);
+		return {
+			exists: true,
+			schemaMatches,
+			configMatches,
+			isUpToDate: schemaMatches && configMatches
+		};
+	});
+}
+/**
+* Check biome config `$schema` URLs against the expected peer dependency version.
+*
+* @remarks
+* Uses `Lint.Biome.findAllConfigs()` for workspace-aware discovery, then validates
+* each config's `$schema` URL by reading and parsing the file directly with JSONC.
+*
+* @returns Object with warnings and per-config status
+*/
+function checkBiomeSchemas() {
+	return Effect.gen(function* () {
+		const version = process.env.__BIOME_PEER_VERSION__;
+		const statuses = [];
+		if (!version) return {
+			statuses,
+			warnings: []
+		};
+		const fs = yield* FileSystem.FileSystem;
+		const warnings = [];
+		const expectedSchema = `https://biomejs.dev/schemas/${version}/schema.json`;
+		const configPaths = Lint.Biome.findAllConfigs();
+		for (const configPath of configPaths) if ((yield* parse(yield* fs.readFileString(configPath))).$schema === expectedSchema) statuses.push({
+			path: configPath,
+			matches: true
+		});
+		else {
+			statuses.push({
+				path: configPath,
+				matches: false
+			});
+			warnings.push(`${WARNING}  ${configPath}: biome $schema is outdated.\n   Run 'savvy init' to update it.`);
+		}
+		return {
+			statuses,
+			warnings
+		};
+	});
+}
+/* v8 ignore start -- CLI option definition; handler tested individually */
+const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output warnings (for postinstall usage)"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Run the lint check validation pipeline.
+*
+* Exported so Task B6's unified `savvy check` orchestrator can invoke the
+* lint check step directly without going through the CLI command layer.
+*
+* @param opts - Options for the check command
+* @returns An Effect that performs validation and logs results
+*
+* @internal
+*/
+function runLintCheck(opts) {
+	const { quiet } = opts;
+	return Effect.gen(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		const ms = yield* ManagedSection;
+		const td = yield* ToolDiscovery;
+		const discovery = yield* ConfigDiscovery;
+		const warnings = [];
+		const foundConfig = yield* findConfigFile(fs);
+		const hasHuskyHook = yield* fs.exists(Lint.HUSKY_HOOK_PATH);
+		let sectionsHealthy = true;
+		let baseStatusLabel = "missing";
+		let lintStatusLabel = "missing";
+		let detectedConfigPath = null;
+		if (hasHuskyHook) {
+			const baseResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, SavvyBaseSection.block(savvyBasePreamble()));
+			if (CheckResult.$is("Found")(baseResult)) {
+				baseStatusLabel = baseResult.isUpToDate ? "up-to-date" : "outdated";
+				if (!baseResult.isUpToDate) sectionsHealthy = false;
+			} else sectionsHealthy = false;
+			const existing = yield* ms.read(Lint.HUSKY_HOOK_PATH, Lint.SavvyLintSectionDef);
+			if (existing) {
+				const configPath = extractConfigPathFromManaged(existing.content);
+				detectedConfigPath = configPath;
+				if (configPath) {
+					const lintResult = yield* ms.check(Lint.HUSKY_HOOK_PATH, Lint.savvyLintBlock(configPath));
+					if (CheckResult.$is("Found")(lintResult)) {
+						lintStatusLabel = lintResult.isUpToDate ? "up-to-date" : "outdated";
+						if (!lintResult.isUpToDate) sectionsHealthy = false;
+					} else {
+						lintStatusLabel = "outdated";
+						sectionsHealthy = false;
+					}
+				} else {
+					lintStatusLabel = "outdated";
+					sectionsHealthy = false;
+				}
+			} else sectionsHealthy = false;
+			if (baseStatusLabel !== "up-to-date" || lintStatusLabel !== "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.`);
+		}
+		if (!foundConfig) warnings.push(`${WARNING}  No lint-staged config file found.\n   Run 'savvy init' to create one.`);
+		const shellHookPaths = [Lint.POST_CHECKOUT_HOOK_PATH, Lint.POST_MERGE_HOOK_PATH];
+		const shellHookStatuses = [];
+		for (const hookPath of shellHookPaths) {
+			if (!(yield* fs.exists(hookPath))) {
+				shellHookStatuses.push({
+					path: hookPath,
+					found: false,
+					isUpToDate: false
+				});
+				continue;
+			}
+			const hygieneResult = yield* ms.check(hookPath, SavvyHooksSection.block(savvyHooksHygiene()));
+			const found = CheckResult.$is("Found")(hygieneResult);
+			const isUpToDate = CheckResult.$is("Found")(hygieneResult) && hygieneResult.isUpToDate;
+			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 biomeSchemaStatus = yield* checkBiomeSchemas().pipe(Effect.catchAll(() => Effect.succeed({
+			statuses: [],
+			warnings: [`${WARNING}  Could not check biome $schema URLs.`]
+		})));
+		warnings.push(...biomeSchemaStatus.warnings);
+		const hasMarkdownlintConfig = yield* fs.exists(Lint.MARKDOWNLINT_CONFIG_PATH);
+		let markdownlintStatus = {
+			exists: false,
+			schemaMatches: false,
+			configMatches: false,
+			isUpToDate: false
+		};
+		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* Effect.log(warning);
+			return;
+		}
+		yield* Effect.log("Checking lint-staged configuration...\n");
+		if (foundConfig) yield* Effect.log(`${CHECK_MARK} Config file: ${foundConfig}`);
+		else yield* Effect.log(`${CROSS_MARK} No lint-staged config file found`);
+		if (hasHuskyHook) yield* Effect.log(`${CHECK_MARK} Husky hook: ${Lint.HUSKY_HOOK_PATH}`);
+		else yield* Effect.log(`${CROSS_MARK} No husky pre-commit hook found`);
+		if (hasHuskyHook) {
+			if (baseStatusLabel === "up-to-date") yield* Effect.log(`${CHECK_MARK} Base section: up-to-date`);
+			else if (baseStatusLabel === "outdated") yield* Effect.log(`${WARNING} Base section: outdated (run 'savvy init' to update)`);
+			else yield* Effect.log(`${BULLET} Base section: not found (run 'savvy init' to add)`);
+			const lintLabel = detectedConfigPath ? ` (config: ${detectedConfigPath})` : "";
+			if (lintStatusLabel === "up-to-date") yield* Effect.log(`${CHECK_MARK} Lint section: up-to-date${lintLabel}`);
+			else if (lintStatusLabel === "outdated") yield* Effect.log(`${WARNING} Lint section: outdated (run 'savvy init' to update)`);
+			else yield* Effect.log(`${BULLET} Lint section: not found (run 'savvy init' to add)`);
+		}
+		for (const status of shellHookStatuses) if (!status.found) yield* Effect.log(`${BULLET} ${status.path}: savvy-hooks section not found`);
+		else if (status.isUpToDate) yield* Effect.log(`${CHECK_MARK} ${status.path}: up-to-date`);
+		else yield* Effect.log(`${WARNING} ${status.path}: outdated (run 'savvy init' to update)`);
+		yield* Effect.log("\nTool availability:");
+		const biomeAvailable = yield* td.isAvailable(ToolDefinition.make({ name: "biome" }));
+		const biomeConfig = yield* findConfig(discovery, ["biome.jsonc", "biome.json"]);
+		if (biomeAvailable) {
+			const configInfo = biomeConfig ? ` (config: ${biomeConfig})` : "";
+			yield* Effect.log(`  ${CHECK_MARK} Biome${configInfo}`);
+		} else yield* Effect.log(`  ${BULLET} Biome: not installed`);
+		const markdownAvailable = yield* td.isAvailable(ToolDefinition.make({ name: "markdownlint-cli2" }));
+		const markdownConfig = yield* findConfig(discovery, [
+			".markdownlint-cli2.jsonc",
+			".markdownlint-cli2.json",
+			".markdownlint-cli2.yaml",
+			".markdownlint-cli2.cjs",
+			".markdownlint.jsonc",
+			".markdownlint.json",
+			".markdownlint.yaml"
+		]);
+		if (markdownAvailable) {
+			const configInfo = markdownConfig ? ` (config: ${markdownConfig})` : "";
+			yield* Effect.log(`  ${CHECK_MARK} markdownlint-cli2${configInfo}`);
+		} else yield* Effect.log(`  ${BULLET} markdownlint-cli2: not installed`);
+		const tsgoAvailable = yield* td.isAvailable(ToolDefinition.make({ name: "tsgo" }));
+		const tscAvailable = yield* td.isAvailable(ToolDefinition.make({ name: "tsc" }));
+		if (tsgoAvailable) yield* Effect.log(`  ${CHECK_MARK} TypeScript (tsgo)`);
+		else if (tscAvailable) yield* Effect.log(`  ${CHECK_MARK} TypeScript (tsc)`);
+		else yield* Effect.log(`  ${BULLET} TypeScript: not installed`);
+		if (hasMarkdownlintConfig) if (markdownlintStatus.isUpToDate) yield* Effect.log(`  ${CHECK_MARK} ${Lint.MARKDOWNLINT_CONFIG_PATH}: up-to-date`);
+		else {
+			const issues = [];
+			if (!markdownlintStatus.schemaMatches) issues.push("$schema");
+			if (!markdownlintStatus.configMatches) issues.push("config");
+			yield* Effect.log(`  ${WARNING} ${Lint.MARKDOWNLINT_CONFIG_PATH}: ${issues.join(", ")} differ from template`);
+		}
+		else yield* Effect.log(`  ${BULLET} ${Lint.MARKDOWNLINT_CONFIG_PATH}: not found`);
+		for (const status of biomeSchemaStatus.statuses) if (status.matches) yield* Effect.log(`  ${CHECK_MARK} ${status.path}: biome $schema up-to-date`);
+		else yield* Effect.log(`  ${WARNING} ${status.path}: biome $schema outdated (run 'savvy init' to update)`);
+		yield* Effect.log("");
+		const hasMarkdownlintIssues = hasMarkdownlintConfig && !markdownlintStatus.isUpToDate;
+		const hasBiomeSchemaIssues = biomeSchemaStatus.statuses.some((s) => !s.matches);
+		if (!foundConfig || !hasHuskyHook || !sectionsHealthy || hasMarkdownlintIssues || hasBiomeSchemaIssues) yield* Effect.log(`${WARNING} Some issues found. Run 'savvy init' to fix.`);
+		else yield* Effect.log(`${CHECK_MARK} Lint-staged is configured correctly.`);
+	});
+}
+/* v8 ignore next 3 -- CLI registration; handler tested via runLintCheck */
+const checkCommand = Command.make("check", { quiet: quietOption }, (opts) => runLintCheck(opts)).pipe(Command.withDescription("Check current lint-staged configuration and tool availability"));
+
+//#endregion
+export { runLintCheck };

package/commands/lint/fmt.js

@@ -0,0 +1,64 @@
+import { Args, Command } from "@effect/cli";
+import { Lint } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { parse, stringify } from "yaml";
+
+//#region src/commands/lint/fmt.ts
+/**
+* Fmt command - format files in-place for lint-staged staging.
+*
+* @remarks
+* These subcommands modify files via CLI commands rather than in handler
+* function bodies, so lint-staged can detect the modifications and
+* auto-stage them between array steps.
+*
+* @internal
+*/
+/** Default YAML stringify options matching PnpmWorkspace handler. */
+const YAML_STRINGIFY_OPTIONS = {
+	indent: 2,
+	lineWidth: 0,
+	singleQuote: false
+};
+/** Repeated file path arguments. */
+const filesArg = Args.repeated(Args.file({
+	name: "files",
+	exists: "yes"
+}));
+/** Sort package.json files with sort-package-json. */
+const packageJsonCommand = Command.make("package-json", { files: filesArg }, ({ files }) => Effect.sync(() => {
+	for (const filepath of files) {
+		const content = readFileSync(filepath, "utf-8");
+		const sorted = Lint.PackageJson.sortContent(content);
+		if (sorted !== content) writeFileSync(filepath, sorted, "utf-8");
+	}
+}));
+/** Sort and format pnpm-workspace.yaml. */
+const pnpmWorkspaceCommand = Command.make("pnpm-workspace", {}, () => Effect.sync(() => {
+	const filepath = "pnpm-workspace.yaml";
+	if (!existsSync(filepath)) return;
+	const parsed = parse(readFileSync(filepath, "utf-8"));
+	writeFileSync(filepath, stringify(Lint.PnpmWorkspace.sortContent(parsed), YAML_STRINGIFY_OPTIONS), "utf-8");
+}));
+/** Format YAML files with Prettier. */
+const yamlCommand = Command.make("yaml", { files: filesArg }, ({ files }) => Effect.gen(function* () {
+	for (const filepath of files) yield* Effect.promise(() => Lint.Yaml.formatFile(filepath));
+}));
+/** Parent fmt command with formatting subcommands. */
+const _fmtCommand = Command.make("fmt").pipe(Command.withSubcommands([
+	packageJsonCommand,
+	pnpmWorkspaceCommand,
+	yamlCommand
+]));
+/**
+* The `savvy lint fmt` command group with package-json, pnpm-workspace, and yaml subcommands.
+*
+* @remarks
+* Typed as `unknown` at the export boundary to avoid TypeScript declaration-emit
+* errors from Effect's internal types. The cast is for declaration emit only.
+*/
+const fmtCommand = _fmtCommand;
+
+//#endregion
+export { fmtCommand };

package/commands/lint/index.js

@@ -0,0 +1,20 @@
+import { runLintCheck } from "./check.js";
+import { runLintInit } from "./init.js";
+import { fmtCommand } from "./fmt.js";
+import { Command } from "@effect/cli";
+
+//#region src/commands/lint/index.ts
+/* v8 ignore start -- CLI registration; each command tested via exported handler */
+const _lintCommand = Command.make("lint").pipe(Command.withSubcommands([fmtCommand]), Command.withDescription("Code-quality: lint-staged config, checks, and in-place formatting"));
+/**
+* The `savvy lint` command group for use in Task B7 root assembly.
+*
+* @remarks
+* Typed as `unknown` at the export boundary to avoid TypeScript declaration-emit
+* errors from Effect's internal types. Task B7 should import and use this directly
+* as `Command.withSubcommands([lintCommand])` — the cast is for declaration emit only.
+*/
+const lintCommand = _lintCommand;
+
+//#endregion
+export { lintCommand };