@savvy-web/cli 0.3.1 → 0.4.0

package/commands/changeset/commands/release-surface.js

@@ -0,0 +1,96 @@
+import { Args, Command, Options } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { resolve } from "node:path";
+
+//#region src/commands/changeset/commands/release-surface.ts
+/**
+* `release-surface` command -- list every path owned by a named package.
+*
+* @remarks
+* For a given package name, emits the workspace directory, every
+* `additionalScopes` glob and its materialized files, and every
+* `versionFiles` entry and its targets. Useful for debugging "why is this
+* path attributed to this package?" or "what's actually in this package's
+* release surface right now?"
+*
+* @example
+* ```bash
+* savvy changeset release-surface @savvy-web/changesets
+* savvy changeset release-surface @scope/foo --json
+* ```
+*
+* @internal
+*/
+const { ConfigInspector, ConfigurationError } = Changesets;
+/* v8 ignore start -- CLI option definitions */
+const packageArg = Args.text({ name: "package" });
+const cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
+const jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Render a single package's resolved scope as human-readable text.
+*
+* @internal
+*/
+function renderHuman(pkg) {
+	const lines = [];
+	lines.push(`Package:   ${pkg.name}  v${pkg.version}`);
+	lines.push(`Workspace: ${pkg.workspaceDir}`);
+	if (pkg.additionalScopes.length === 0 && pkg.versionFiles.length === 0) {
+		lines.push("");
+		lines.push("(no additionalScopes or versionFiles — workspace dir is the entire release surface)");
+		return lines.join("\n");
+	}
+	if (pkg.additionalScopes.length > 0) {
+		lines.push("");
+		lines.push(`additionalScopes (${pkg.additionalScopes.length} glob${pkg.additionalScopes.length === 1 ? "" : "s"}):`);
+		for (const g of pkg.additionalScopes) lines.push(`  - ${g}`);
+		lines.push(`Resolved files (${pkg.additionalScopeFiles.length}):`);
+		for (const f of pkg.additionalScopeFiles) lines.push(`  ${f}`);
+	}
+	if (pkg.versionFiles.length > 0) {
+		lines.push("");
+		lines.push(`versionFiles (${pkg.versionFiles.length}):`);
+		for (const vf of pkg.versionFiles) {
+			lines.push(`  ${vf.glob} → ${vf.paths.join(", ")}`);
+			for (const f of vf.matchedFiles) lines.push(`    ${f}`);
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Resolve cwd, invoke `ConfigInspector.inspect`, find the named package's
+* scope, and render it. Sets `process.exitCode = 1` on any error.
+*
+* @internal
+*/
+function runReleaseSurface(cwd, pkgName, json) {
+	return Effect.gen(function* () {
+		const inspector = yield* ConfigInspector;
+		const resolvedCwd = resolve(cwd);
+		const config = yield* inspector.inspect(resolvedCwd).pipe(Effect.catchTag("ConfigurationError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		}));
+		const scope = config.packages.find((p) => p.name === pkgName);
+		if (!scope) {
+			process.exitCode = 1;
+			return yield* Effect.fail(new ConfigurationError({
+				field: `packages["${pkgName}"]`,
+				reason: `Package "${pkgName}" is not declared in .changeset/config.json#packages. Declared packages: ${config.packages.map((p) => p.name).join(", ") || "(none)"}.`
+			}));
+		}
+		const output = json ? JSON.stringify(scope, null, 2) : renderHuman(scope);
+		yield* Effect.log(output);
+	});
+}
+/* v8 ignore next 6 -- CLI registration */
+const releaseSurfaceCommand = Command.make("release-surface", {
+	package: packageArg,
+	cwd: cwdOption,
+	json: jsonOption
+}, ({ package: pkgName, cwd, json }) => runReleaseSurface(cwd, pkgName, json)).pipe(Command.withDescription("Print every path owned by a package — workspace dir, additionalScopes, versionFiles"));
+
+//#endregion
+export { releaseSurfaceCommand };

package/commands/changeset/commands/transform.js

@@ -0,0 +1,88 @@
+import { requireValidConfig } from "../utils/config-gate.js";
+import { Args, Command, Options } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { dirname, resolve } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+
+//#region src/commands/changeset/commands/transform.ts
+/**
+* Transform command -- post-process CHANGELOG.md.
+*
+* Runs all remark transform plugins (section reordering, deduplication,
+* contributor footnotes, issue link references, and format normalization)
+* against a changelog file.
+*
+* @remarks
+* The command supports three modes:
+* - **Default** -- read the file, transform, and write back in place.
+* - **`--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).
+*
+* Before any of those modes run, the command requires a valid
+* `.changeset/config.json` (when one exists). A broken config indicates
+* something structurally wrong with the project — refusing here surfaces
+* that to the user rather than producing output the version step couldn't
+* later corroborate.
+*
+* @example
+* ```bash
+* savvy changeset transform CHANGELOG.md
+* savvy changeset transform --dry-run CHANGELOG.md
+* savvy changeset transform --check CHANGELOG.md
+* ```
+*
+* @internal
+*/
+const { ChangelogTransformer } = Changesets;
+/* v8 ignore start -- CLI option definitions; handler tested via runTransform */
+const fileArg = Args.file({ name: "file" }).pipe(Args.withDefault("CHANGELOG.md"));
+const dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Print transformed output instead of writing"), Options.withDefault(false));
+const checkOption = Options.boolean("check").pipe(Options.withAlias("c"), Options.withDescription("Exit 1 if file would change (for CI)"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Run the remark transform pipeline on a single changelog file.
+*
+* Reads the file at `file`, applies all remark transform plugins via
+* {@link ChangelogTransformer.transformContent}, and either writes the result
+* back, prints it to stdout (`dryRun`), or checks for differences (`check`).
+*
+* @param file - Path to the CHANGELOG.md file (resolved relative to cwd)
+* @param dryRun - When `true`, print transformed output instead of writing
+* @param check - When `true`, exit with code 1 if the file would change
+* @returns An Effect that performs the transformation
+*
+* @internal
+*/
+function runTransform(file, dryRun, check) {
+	return Effect.gen(function* () {
+		const resolved = resolve(file);
+		yield* requireValidConfig(dirname(resolved));
+		const content = yield* Effect.try(() => readFileSync(resolved, "utf-8"));
+		const result = ChangelogTransformer.transformContent(content);
+		if (dryRun) {
+			yield* Effect.log(result);
+			return;
+		}
+		if (check) {
+			if (result !== content) {
+				yield* Effect.log(`${resolved} would be modified by transform.`);
+				process.exitCode = 1;
+			} else yield* Effect.log(`${resolved} is already formatted.`);
+			return;
+		}
+		yield* Effect.try(() => writeFileSync(resolved, result, "utf-8"));
+		yield* Effect.log(`Transformed ${resolved}`);
+	});
+}
+/* v8 ignore next 5 -- CLI registration; handler tested via runTransform */
+const transformCommand = Command.make("transform", {
+	file: fileArg,
+	dryRun: dryRunOption,
+	check: checkOption
+}, ({ file, dryRun, check }) => runTransform(file, dryRun, check)).pipe(Command.withDescription("Post-process CHANGELOG.md"));
+
+//#endregion
+export { transformCommand };

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

@@ -0,0 +1,52 @@
+import { Args, Command } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+
+//#region src/commands/changeset/commands/validate-file.ts
+/**
+* Validate-file command — validate a single changeset file.
+*
+* Reads one `.md` file and runs the full lint pipeline against it,
+* outputting machine-readable diagnostics. Designed for use in hooks
+* and editor integrations where only one file needs checking.
+*
+* @example
+* ```bash
+* savvy changeset validate-file .changeset/cool-lions-sing.md
+* ```
+*
+* @internal
+*/
+const { ChangesetLinter } = Changesets;
+/* v8 ignore next */
+const fileArg = Args.file({ name: "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 `process.exitCode = 1`
+* when errors are found or the file cannot be read.
+*
+* @param filePath - Path to the changeset `.md` file
+* @returns An Effect that performs validation and logs results
+*
+* @internal
+*/
+function runValidateFile(filePath) {
+	return Effect.gen(function* () {
+		const result = yield* Effect.try(() => ChangesetLinter.validateFile(filePath)).pipe(Effect.catchAll((error) => Effect.gen(function* () {
+			yield* Effect.log(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			process.exitCode = 1;
+			return null;
+		})));
+		if (result === null) return;
+		for (const msg of result) yield* Effect.log(`${msg.file}:${msg.line}:${msg.column} ${msg.rule} ${msg.message}`);
+		if (result.length > 0) process.exitCode = 1;
+		else yield* Effect.log("Valid.");
+	});
+}
+/* v8 ignore next 3 -- CLI registration; handler tested via runValidateFile */
+const validateFileCommand = Command.make("validate-file", { file: fileArg }, ({ file }) => runValidateFile(file)).pipe(Command.withDescription("Validate a single changeset file"));
+
+//#endregion
+export { validateFileCommand };

package/commands/changeset/commands/version.js

@@ -0,0 +1,178 @@
+import { requireValidConfig } from "../utils/config-gate.js";
+import { Command, Options } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { PackageManagerDetector, WorkspaceDiscovery } from "workspaces-effect";
+import { join, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+
+//#region src/commands/changeset/commands/version.ts
+/**
+* Version command -- orchestrate `changeset version` and changelog transforms.
+*
+* Detects the package manager, validates the config, runs `changeset version`,
+* discovers all workspace CHANGELOG.md files, transforms each one with the
+* remark pipeline, and updates any configured version files.
+*
+* @remarks
+* The command performs six steps:
+* 1. Detect the package manager (`pnpm`, `npm`, `yarn`, `bun`) via
+*    `PackageManagerDetector` from `workspaces-effect`.
+* 2. **Require a valid `.changeset/config.json` via {@link ConfigInspector}**.
+*    If the config has overlap conflicts, unknown package keys, dual-shape,
+*    or schema errors, refuse to run and exit non-zero — a broken config
+*    means we cannot determine the right versions to write.
+* 3. Run `changeset version` (skipped with `--dry-run`).
+* 4. Discover all CHANGELOG.md files across workspace packages via
+*    `WorkspaceDiscovery` from `workspaces-effect`.
+* 5. Transform each discovered changelog with
+*    {@link ChangelogTransformer.transformFile}.
+* 6. Update version files using the **resolved** {@link InspectedConfig}
+*    via {@link VersionFiles.processResolvedVersionFiles}.
+*
+* @example
+* ```bash
+* savvy changeset version
+* savvy changeset version --dry-run
+* ```
+*
+* @internal
+*/
+const { ChangelogTransformer, ConfigInspector, VersionFileError, VersionFiles } = Changesets;
+/**
+* Map package manager to the correct `changeset version` shell command.
+*
+* @internal
+*/
+function getChangesetVersionCommand(pm) {
+	switch (pm) {
+		case "pnpm": return "pnpm exec changeset version";
+		case "yarn": return "yarn exec changeset version";
+		case "bun": return "bun x changeset version";
+		default: return "npx changeset version";
+	}
+}
+/* v8 ignore start -- CLI option definitions; handler tested via runVersion */
+const dryRunOption = Options.boolean("dry-run").pipe(Options.withAlias("n"), Options.withDescription("Skip changeset version, only transform existing CHANGELOGs"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Run the full version orchestration pipeline.
+*
+* Detects the package manager, validates the config, optionally runs
+* `changeset version`, discovers and transforms all workspace changelogs,
+* and updates version files using the resolved per-package scopes.
+*
+* @param dryRun - When `true`, skip `changeset version` and only transform
+*   existing CHANGELOG files
+* @returns An Effect that performs the versioning pipeline
+*
+* @internal
+*/
+function runVersion(dryRun) {
+	return Effect.gen(function* () {
+		const cwd = process.cwd();
+		const pm = (yield* (yield* PackageManagerDetector).detect(cwd).pipe(Effect.catchAll(() => Effect.succeed({
+			type: "npm",
+			version: void 0
+		})))).type;
+		yield* Effect.log(`Detected package manager: ${pm}`);
+		yield* requireValidConfig(cwd);
+		if (!dryRun) {
+			const cmd = getChangesetVersionCommand(pm);
+			yield* Effect.log(`Running: ${cmd}`);
+			yield* Effect.try({
+				try: () => execSync(cmd, {
+					cwd,
+					stdio: "inherit"
+				}),
+				catch: (error) => /* @__PURE__ */ new Error(`changeset version failed: ${error instanceof Error ? error.message : String(error)}`)
+			});
+		} else yield* Effect.log("Dry run: skipping changeset version");
+		const packages = yield* (yield* WorkspaceDiscovery).listPackages().pipe(Effect.catchAll(() => Effect.succeed([])));
+		const changelogs = [];
+		const seen = /* @__PURE__ */ new Set();
+		const resolvedCwd = resolve(cwd);
+		for (const pkg of packages) {
+			const changelogPath = join(pkg.path, "CHANGELOG.md");
+			if (existsSync(changelogPath) && !seen.has(pkg.path)) {
+				seen.add(pkg.path);
+				changelogs.push({
+					name: pkg.name,
+					path: pkg.path,
+					changelogPath
+				});
+			}
+		}
+		if (!seen.has(resolvedCwd)) {
+			const rootChangelog = join(resolvedCwd, "CHANGELOG.md");
+			if (existsSync(rootChangelog)) {
+				let rootName = "root";
+				try {
+					const pkg = JSON.parse(readFileSync(join(resolvedCwd, "package.json"), "utf-8"));
+					if (pkg.name) rootName = pkg.name;
+				} catch {}
+				changelogs.push({
+					name: rootName,
+					path: resolvedCwd,
+					changelogPath: rootChangelog
+				});
+			}
+		}
+		if (changelogs.length === 0) yield* Effect.log("No CHANGELOG.md files found.");
+		else {
+			yield* Effect.log(`Found ${changelogs.length} CHANGELOG.md file(s)`);
+			for (const entry of changelogs) {
+				yield* Effect.try({
+					try: () => ChangelogTransformer.transformFile(entry.changelogPath),
+					catch: (error) => /* @__PURE__ */ new Error(`Failed to transform ${entry.changelogPath}: ${error instanceof Error ? error.message : String(error)}`)
+				});
+				yield* Effect.log(`Transformed ${entry.name} → ${entry.changelogPath}`);
+			}
+		}
+		if (!existsSync(join(resolvedCwd, ".changeset", "config.json"))) return;
+		const scopesWithVersionFiles = (yield* (yield* ConfigInspector).inspect(resolvedCwd)).packages.filter((p) => p.versionFiles.length > 0).map((p) => {
+			const fresh = readPackageVersionFromDisk(p.workspaceDir);
+			return fresh && fresh !== p.version ? {
+				...p,
+				version: fresh
+			} : p;
+		});
+		if (scopesWithVersionFiles.length === 0) return;
+		yield* Effect.log(`Found ${scopesWithVersionFiles.length} package${scopesWithVersionFiles.length === 1 ? "" : "s"} with versionFiles`);
+		const updates = yield* Effect.try({
+			try: () => VersionFiles.processResolvedVersionFiles(scopesWithVersionFiles, dryRun),
+			catch: (error) => {
+				const message = error instanceof Error ? error.message : String(error);
+				return new VersionFileError({
+					filePath: message.match(/Failed to update (.+?):/)?.[1] ?? cwd,
+					reason: message
+				});
+			}
+		});
+		for (const update of updates) {
+			const action = dryRun ? "Would update" : "Updated";
+			yield* Effect.log(`${action} ${update.filePath} → ${update.version}`);
+		}
+	});
+}
+/**
+* Read the `version` field from a workspace package's `package.json` on
+* disk. Used to bypass cached state in `ConfigInspector` and
+* `WorkspaceDiscovery` after `changeset version` has rewritten each
+* workspace's manifest.
+*
+* @internal
+*/
+function readPackageVersionFromDisk(workspaceDir) {
+	try {
+		return JSON.parse(readFileSync(join(workspaceDir, "package.json"), "utf-8")).version ?? null;
+	} catch {
+		return null;
+	}
+}
+/* v8 ignore next 4 -- CLI registration; handler tested via runVersion */
+const versionCommand = Command.make("version", { dryRun: dryRunOption }, ({ dryRun }) => runVersion(dryRun)).pipe(Command.withDescription("Run changeset version and transform all CHANGELOGs"));
+
+//#endregion
+export { versionCommand };

package/commands/changeset/index.js

@@ -0,0 +1,42 @@
+import { analyzeBranchCommand } from "./commands/analyze-branch.js";
+import { classifyCommand } from "./commands/classify.js";
+import { configShowCommand } from "./commands/config-show.js";
+import { configValidateCommand } from "./commands/config-validate.js";
+import { depsDetectCommand } from "./commands/deps-detect.js";
+import { depsRegenCommand } from "./commands/deps-regen.js";
+import { lintCommand } from "./commands/lint.js";
+import { releaseSurfaceCommand } from "./commands/release-surface.js";
+import { transformCommand } from "./commands/transform.js";
+import { validateFileCommand } from "./commands/validate-file.js";
+import { versionCommand } from "./commands/version.js";
+import { runChangesetCheck } from "./commands/check.js";
+import { runChangesetInit } from "./commands/init.js";
+import { Command } from "@effect/cli";
+
+//#region src/commands/changeset/index.ts
+/* v8 ignore start -- CLI registration; each command tested via exported handler */
+const configGroup = Command.make("config").pipe(Command.withSubcommands([configShowCommand, configValidateCommand]), Command.withDescription("Inspect or validate .changeset/config.json"));
+const depsGroup = Command.make("deps").pipe(Command.withSubcommands([depsDetectCommand, depsRegenCommand]), Command.withDescription("Generate or regenerate dependency changesets"));
+const _changesetCommand = Command.make("changeset").pipe(Command.withSubcommands([
+	lintCommand,
+	transformCommand,
+	validateFileCommand,
+	versionCommand,
+	classifyCommand,
+	analyzeBranchCommand,
+	releaseSurfaceCommand,
+	configGroup,
+	depsGroup
+]), Command.withDescription("Section-aware changeset tooling"));
+/**
+* The `savvy changeset` 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 via
+* `Command.withSubcommands([changesetCommand as never])` or re-infer the type.
+*/
+const changesetCommand = _changesetCommand;
+
+//#endregion
+export { changesetCommand };

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

@@ -0,0 +1,59 @@
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+
+//#region src/commands/changeset/utils/config-gate.ts
+/**
+* Shared "refuse on bad config" gate for CLI commands that must not run
+* with an invalid `.changeset/config.json`.
+*
+* @remarks
+* Used by `version` and `transform` in 0.9.0. Both commands are entry
+* points to release-shaped work; running them against a config that
+* fails the new validation contract (overlap, unknown package keys,
+* dual-shape, schema errors) would produce broken or inconsistent
+* output.
+*
+* `lint` deliberately does **not** call this gate — it operates on
+* changeset markdown files and must keep working while the user is
+* iterating on a config fix.
+*
+* Behavior:
+* - **No config present** (`.changeset/config.json` absent): the gate
+*   resolves to `void` and the caller proceeds. This preserves the
+*   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
+*   `process.exitCode = 1` and propagates the error so the caller's
+*   `Effect.gen` short-circuits.
+*
+* @internal
+*/
+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.
+*
+* @param cwd - Project root (will be resolved against the process cwd)
+* @returns Effect that succeeds on valid/absent config, fails with
+*   {@link ConfigurationError} otherwise
+*
+* @internal
+*/
+function requireValidConfig(cwd) {
+	return Effect.gen(function* () {
+		const projectDir = resolve(cwd);
+		if (!existsSync(join(projectDir, ".changeset", "config.json"))) return;
+		yield* (yield* ConfigInspector).inspect(projectDir).pipe(Effect.catchTag("ConfigurationError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		}));
+	});
+}
+
+//#endregion
+export { requireValidConfig };

package/commands/check.js

@@ -0,0 +1,74 @@
+import { runChangesetCheck } from "./changeset/commands/check.js";
+import "./changeset/index.js";
+import { runCommitCheck } from "./commit/check.js";
+import { runLintCheck } from "./lint/check.js";
+import { Command, Options } from "@effect/cli";
+import { Effect } 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 `runCli`). 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 = Options.text("changeset-dir").pipe(Options.withDescription("Path to the changeset directory"), Options.withDefault(".changeset"));
+const quietOption = Options.boolean("quiet").pipe(Options.withAlias("q"), Options.withDescription("Only output warnings from lint check"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Run all three check step Effects without short-circuiting.
+*
+* 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.
+*
+* @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.
+*/
+function runCheck(steps) {
+	return Effect.all([
+		steps.changeset,
+		steps.commit,
+		steps.lint
+	], {
+		concurrency: 1,
+		mode: "validate"
+	}).pipe(Effect.asVoid);
+}
+/* v8 ignore start -- CLI registration; orchestration logic tested via runCheck */
+const _checkCommand = Command.make("check", {
+	changesetDir: changesetDirOption,
+	quiet: quietOption
+}, (opts) => runCheck({
+	changeset: runChangesetCheck(opts.changesetDir),
+	commit: runCommitCheck(),
+	lint: runLintCheck({ quiet: opts.quiet })
+})).pipe(Command.withDescription("Validate all Silk Suite tool configurations in one pass"));
+/* v8 ignore stop */
+/**
+* The `savvy check` 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([checkCommand as never])` or re-infer the type.
+*/
+const checkCommand = _checkCommand;
+
+//#endregion
+export { checkCommand, runCheck };