@savvy-web/cli 0.3.1 → 0.4.1

package/bin/savvy.d.ts

@@ -0,0 +1 @@
+export { };

package/bin/savvy.js

@@ -1,3 +1,19 @@
 #!/usr/bin/env node
-import { runCli } from "../841.js";
+import { runCli } from "../cli/index.js";
+
+//#region src/bin/cli.ts
+/**
+* Binary entry point for the `savvy` CLI.
+*
+* This file is the `bin` target in `package.json`. It delegates immediately
+* to {@link runCli} which assembles the `\@effect/cli` command tree and
+* executes it via `\@effect/platform-node`.
+*
+* @internal
+*/
+/* v8 ignore start -- CLI bootstrap; commands tested individually */
 runCli();
+/* v8 ignore stop */
+
+//#endregion
+export {  };

package/cli/index.js

@@ -0,0 +1,123 @@
+import { changesetCommand } from "../commands/changeset/index.js";
+import { checkCommand } from "../commands/check.js";
+import { cleanCommand } from "../commands/clean.js";
+import { commitCommand } from "../commands/commit/index.js";
+import { initCommand } from "../commands/init.js";
+import { lintCommand } from "../commands/lint/index.js";
+import { Command } from "@effect/cli";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { BiomeSchemaSyncLive, ChangesetConfigReaderLive, Changesets, ConfigDiscoveryLive, ManagedSectionLive, SilkPublishabilityDetectorLive, ToolDiscoveryLive, VersioningStrategyLive } from "@savvy-web/silk-effects";
+import { Effect, Layer } from "effect";
+import { PackageManagerDetectorLive, WorkspaceDiscoveryLive, WorkspaceRootLive } from "workspaces-effect";
+
+//#region src/cli/index.ts
+/**
+* Root `savvy` CLI entry point using `@effect/cli`.
+*
+* @remarks
+* Assembles the five Phase-B command pieces — the `init` and `check` top-level
+* orchestrators plus the `changeset`, `commit`, and `lint` groups — under a
+* single `savvy` root command, then provides the merged runtime Layer stack
+* that satisfies every command's service requirements.
+*
+* The layer stack is the union of the three standalone CLIs' stacks
+* (`@savvy-web/changesets`, `@savvy-web/commitlint`, `@savvy-web/lint-staged`),
+* with each service's transitive dependencies wired:
+*
+* - `NodeContext.layer` — `FileSystem`, `Path`, and `CommandExecutor`, consumed
+*   by every config reader, workspace service, and tool-discovery layer.
+* - Workspace services — `WorkspaceRootLive`, `PackageManagerDetectorLive`, and
+*   `WorkspaceDiscoveryLive` (provided `WorkspaceRootLive`), the minimal hand-wired
+*   trio shared by the three source CLIs.
+* - Flat silk-effects services — `ChangesetConfigReaderLive`,
+*   `SilkPublishabilityDetectorLive`, `ManagedSectionLive`, `BiomeSchemaSyncLive`,
+*   `ConfigDiscoveryLive`, `ToolDiscoveryLive`, and `VersioningStrategyLive`
+*   (provided `ChangesetConfigReaderLive`).
+* - Changesets-namespace services — `Changesets.ConfigInspectorLive` (provided
+*   `ChangesetConfigReaderLive`), `Changesets.WorkspaceSnapshotReaderLive`, and
+*   `Changesets.BranchAnalyzerLive`, which shares the single `ConfigInspectorLive`
+*   instance built once via `provideMerge`.
+*
+* The CLI version is injected at build time via `__PACKAGE_VERSION__`.
+*
+* @internal
+*/
+/* v8 ignore start -- CLI registration; each command tested via exported handler */
+/**
+* Root `savvy` command nesting the two orchestrators and three command groups.
+*/
+const rootCommand = Command.make("savvy").pipe(Command.withSubcommands([
+	initCommand,
+	checkCommand,
+	cleanCommand,
+	commitCommand,
+	changesetCommand,
+	lintCommand
+]));
+const cli = Command.run(rootCommand, {
+	name: "savvy",
+	version: process.env.__PACKAGE_VERSION__ ?? "0.0.0"
+});
+/**
+* Shared base layer: workspace services, the changeset config reader, and the
+* leaf silk-effects services that depend only on the platform. Built once and
+* `provideMerge`d so the upper services draw from it AND it stays exposed in the
+* final context for the handlers that yield these tags directly.
+*
+* @remarks
+* The workspace services (`WorkspaceRoot`, `WorkspaceDiscovery`,
+* `PackageManagerDetector`) are wired as a self-contained unit:
+* `WorkspaceDiscoveryLive` is provided `WorkspaceRootLive`, and the bare
+* `WorkspaceRootLive` / `PackageManagerDetectorLive` are exposed for the
+* handlers that yield those tags directly. This mirrors the three source CLIs'
+* minimal workspace wiring rather than pulling in the heavier `WorkspacesLive`
+* (which also forks `DependencyGraph` / `PublishabilityDetector` background work).
+*/
+const WorkspaceLive = Layer.mergeAll(WorkspaceRootLive, PackageManagerDetectorLive, WorkspaceDiscoveryLive.pipe(Layer.provide(WorkspaceRootLive)));
+/**
+* Base layer membership: silk-effects leaf services (`ManagedSection`,
+* `BiomeSchemaSync`, `ConfigDiscovery`, `SilkPublishabilityDetector`,
+* `WorkspaceSnapshotReader`) that depend only on the platform, plus the
+* changeset base layers (`WorkspaceLive`, `ChangesetConfigReader`) that
+* `AppLive`'s upper services build upon.
+*/
+const BaseLive = Layer.mergeAll(WorkspaceLive, ChangesetConfigReaderLive, ManagedSectionLive, BiomeSchemaSyncLive, ConfigDiscoveryLive, SilkPublishabilityDetectorLive, Changesets.WorkspaceSnapshotReaderLive);
+/**
+* Merged runtime Layer stack — the union of the three source CLIs' stacks with
+* every inter-layer dependency satisfied.
+*
+* @remarks
+* The upper services depend on members of `BaseLive`:
+* `ToolDiscoveryLive` needs `WorkspaceRoot`, `PackageManagerDetector`, and
+* `CommandExecutor`; `VersioningStrategyLive` needs `ChangesetConfigReader`;
+* `Changesets.ConfigInspectorLive` needs `ChangesetConfigReader` and
+* `WorkspaceDiscovery`; `Changesets.BranchAnalyzerLive` needs `ConfigInspector`.
+*
+* `ConfigInspectorLive` is built once via {@link Layer.provideMerge}: the merge
+* feeds that single `ConfigInspector` instance into `BranchAnalyzerLive` AND
+* re-exposes it for the `classify` / `config` handlers that yield it directly,
+* so it is never constructed twice per run.
+*
+* `provideMerge(BaseLive)` feeds the remaining deps and re-exposes the base
+* services for handlers that yield them directly. `provideMerge(NodeContext.layer)`
+* supplies `FileSystem`, `Path`, and `CommandExecutor` to everything underneath.
+*/
+const InspectorAndAnalyzerLive = Changesets.BranchAnalyzerLive.pipe(Layer.provideMerge(Changesets.ConfigInspectorLive));
+const AppLive = Layer.mergeAll(ToolDiscoveryLive, VersioningStrategyLive, InspectorAndAnalyzerLive).pipe(Layer.provideMerge(BaseLive), Layer.provideMerge(NodeContext.layer));
+/**
+* Bootstrap and run the `savvy` CLI application.
+*
+* @remarks
+* Builds an Effect from the parsed `process.argv`, provides the merged layer
+* stack, and hands execution to `NodeRuntime.runMain`.
+*
+* @internal
+*/
+function runCli() {
+	const main = Effect.suspend(() => cli(process.argv)).pipe(Effect.provide(AppLive));
+	NodeRuntime.runMain(main);
+}
+/* v8 ignore stop */
+
+//#endregion
+export { runCli };

package/commands/changeset/commands/analyze-branch.js

@@ -0,0 +1,108 @@
+import { Command, Options } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect, Option } from "effect";
+import { resolve } from "node:path";
+
+//#region src/commands/changeset/commands/analyze-branch.ts
+/**
+* `analyze-branch` command -- diff the current branch and classify every
+* changed file.
+*
+* @remarks
+* Wraps {@link BranchAnalyzer.analyzeBranch}. Returns the merge-base SHA,
+* the per-file classification, the deduped package list affected by the
+* branch, and the list of paths that didn't map to any release surface
+* (candidates for an AskUserQuestion in agent workflows).
+*
+* @example
+* ```bash
+* savvy changeset analyze-branch
+* savvy changeset analyze-branch --base main --json
+* savvy changeset analyze-branch --cwd ./project --base develop
+* ```
+*
+* @internal
+*/
+const { BranchAnalyzer } = Changesets;
+/* v8 ignore start -- CLI option definitions */
+const cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
+const baseOption = Options.text("base").pipe(Options.withDescription("Override the base branch (defaults to config baseBranch or origin/HEAD)"), Options.optional);
+const jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Render a {@link BranchAnalysis} as human-readable text.
+*
+* @internal
+*/
+function renderHuman(analysis) {
+	const lines = [];
+	lines.push(`Base branch:    ${analysis.baseBranch}`);
+	lines.push(`Merge base SHA: ${analysis.mergeBaseSha}`);
+	lines.push("");
+	if (analysis.packagesAffected.length > 0) {
+		lines.push(`Packages affected (${analysis.packagesAffected.length}):`);
+		for (const p of analysis.packagesAffected) lines.push(`  ${p}`);
+	} else lines.push("Packages affected: (none)");
+	lines.push("");
+	if (analysis.files.length === 0) lines.push("Changes: (no files changed)");
+	else {
+		lines.push(`Changes (${analysis.files.length}):`);
+		const statusGlyph = {
+			added: "A",
+			modified: "M",
+			deleted: "D",
+			renamed: "R",
+			copied: "C",
+			typechange: "T",
+			unmerged: "U",
+			unknown: "?"
+		};
+		for (const f of analysis.files) {
+			const glyph = statusGlyph[f.status] ?? "?";
+			const owner = f.package ?? "<unmapped>";
+			const reason = f.reason === "workspace" ? "workspace" : f.reason !== null ? `${f.reason.kind}: ${f.reason.glob}` : "—";
+			lines.push(`  ${glyph}  ${f.path}\t${owner}\t${reason}`);
+		}
+	}
+	if (analysis.unmappedFiles.length > 0) {
+		lines.push("");
+		lines.push(`Unmapped (${analysis.unmappedFiles.length}):`);
+		for (const p of analysis.unmappedFiles) lines.push(`  ${p}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Resolve cwd + base branch, invoke `BranchAnalyzer.analyzeBranch`, and
+* render the result. Sets `process.exitCode = 1` on `ConfigurationError`
+* or `GitError`.
+*
+* @internal
+*/
+function runAnalyzeBranch(cwd, base, json) {
+	return Effect.gen(function* () {
+		const analyzer = yield* BranchAnalyzer;
+		const resolvedCwd = resolve(cwd);
+		const baseBranch = Option.getOrUndefined(base);
+		const analysis = yield* analyzer.analyzeBranch(resolvedCwd, baseBranch ? { baseBranch } : void 0).pipe(Effect.catchTags({
+			ConfigurationError: (err) => {
+				process.exitCode = 1;
+				return Effect.fail(err);
+			},
+			GitError: (err) => {
+				process.exitCode = 1;
+				return Effect.fail(err);
+			}
+		}));
+		const output = json ? JSON.stringify(analysis, null, 2) : renderHuman(analysis);
+		yield* Effect.log(output);
+	});
+}
+/* v8 ignore next 6 -- CLI registration */
+const analyzeBranchCommand = Command.make("analyze-branch", {
+	cwd: cwdOption,
+	base: baseOption,
+	json: jsonOption
+}, ({ cwd, base, json }) => runAnalyzeBranch(cwd, base, json)).pipe(Command.withDescription("Diff the current branch and classify every changed file by owning package"));
+
+//#endregion
+export { analyzeBranchCommand };

package/commands/changeset/commands/check.js

@@ -0,0 +1,71 @@
+import { Args, Command } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { resolve } from "node:path";
+
+//#region src/commands/changeset/commands/check.ts
+/**
+* Check command -- full validation pipeline with human-readable output.
+*
+* Runs lint on all changeset files in a directory and reports a grouped
+* summary with pass/fail counts. Unlike the `lint` command, output is
+* formatted for human consumption rather than machine parsing.
+*
+* @remarks
+* The command resolves the directory argument, delegates to
+* {@link ChangesetLinter.validate}, groups the resulting
+* {@link LintMessage} objects by file path, and logs each file's errors
+* indented under the file name. Sets `process.exitCode = 1` when errors
+* are found.
+*
+* @example
+* ```bash
+* savvy changeset check .changeset
+* ```
+*
+* @internal
+*/
+const { ChangesetLinter } = Changesets;
+/* v8 ignore next */
+const dirArg = Args.directory({ name: "dir" }).pipe(Args.withDefault(".changeset"));
+/**
+* Run the check validation pipeline on all changeset files in `dir`.
+*
+* Groups lint messages by file and logs a human-readable summary. Sets
+* `process.exitCode = 1` when one or more errors are found.
+*
+* @param dir - Path to the changeset directory (resolved relative to cwd)
+* @returns An Effect that performs validation and logs results
+*
+* @internal
+*/
+function runChangesetCheck(dir) {
+	return Effect.gen(function* () {
+		const resolved = resolve(dir);
+		const messages = yield* Effect.try({
+			try: () => ChangesetLinter.validate(resolved),
+			catch: (e) => new Error(String(e))
+		});
+		const byFile = /* @__PURE__ */ new Map();
+		for (const msg of messages) {
+			const existing = byFile.get(msg.file);
+			if (existing) existing.push(msg);
+			else byFile.set(msg.file, [msg]);
+		}
+		for (const [file, fileMessages] of byFile) {
+			yield* Effect.log(`\n${file}`);
+			for (const msg of fileMessages) yield* Effect.log(`  ${msg.line}:${msg.column}  ${msg.rule}  ${msg.message}`);
+		}
+		const errorCount = messages.length;
+		const filesWithErrors = byFile.size;
+		if (errorCount > 0) {
+			yield* Effect.log(`\n${filesWithErrors} file(s) with errors, ${errorCount} error(s) found`);
+			process.exitCode = 1;
+		} else yield* Effect.log("All changeset files passed validation.");
+	});
+}
+/* v8 ignore next 3 -- CLI registration; handler tested via runChangesetCheck */
+const checkCommand = Command.make("check", { dir: dirArg }, ({ dir }) => runChangesetCheck(dir)).pipe(Command.withDescription("Full changeset validation with summary"));
+
+//#endregion
+export { runChangesetCheck };

package/commands/changeset/commands/classify.js

@@ -0,0 +1,69 @@
+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/classify.ts
+/**
+* `classify` command -- map one or more paths to their owning package.
+*
+* @remarks
+* Wraps {@link ConfigInspector.classify}. Each path resolves to a package
+* via (in order): workspace match → `additionalScopes` glob → `versionFiles`
+* glob → `null` (unmapped).
+*
+* @example
+* ```bash
+* savvy changeset classify packages/foo/src/index.ts plugin/SKILL.md
+* savvy changeset classify --cwd ./monorepo plugin/x.md --json
+* ```
+*
+* @internal
+*/
+const { ConfigInspector } = Changesets;
+/* v8 ignore start -- CLI option definitions */
+const pathsArg = Args.text({ name: "path" }).pipe(Args.repeated);
+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 */
+/**
+* Format a single {@link Classification} as a human-readable line.
+*
+* @internal
+*/
+function renderClassificationLine(c) {
+	if (c.package === null) return `${c.path}\t<unmapped>`;
+	if (c.reason === "workspace") return `${c.path}\t${c.package}\tworkspace`;
+	if (c.reason !== null) return `${c.path}\t${c.package}\t${c.reason.kind}: ${c.reason.glob}`;
+	return `${c.path}\t${c.package}`;
+}
+/**
+* Resolve the cwd, invoke `ConfigInspector.classify`, and render the result.
+* Sets `process.exitCode = 1` on `ConfigurationError`.
+*
+* @internal
+*/
+function runClassify(cwd, paths, json) {
+	return Effect.gen(function* () {
+		const inspector = yield* ConfigInspector;
+		const resolvedCwd = resolve(cwd);
+		const classifications = yield* inspector.classify(resolvedCwd, paths).pipe(Effect.catchTag("ConfigurationError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		}));
+		if (json) {
+			yield* Effect.log(JSON.stringify(classifications, null, 2));
+			return;
+		}
+		for (const c of classifications) yield* Effect.log(renderClassificationLine(c));
+	});
+}
+/* v8 ignore next 6 -- CLI registration */
+const classifyCommand = Command.make("classify", {
+	paths: pathsArg,
+	cwd: cwdOption,
+	json: jsonOption
+}, ({ paths, cwd, json }) => runClassify(cwd, paths, json)).pipe(Command.withDescription("Map paths to their owning package per .changeset/config.json"));
+
+//#endregion
+export { classifyCommand };

package/commands/changeset/commands/config-show.js

@@ -0,0 +1,100 @@
+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/config-show.ts
+/**
+* `config show` command -- emit the resolved `.changeset/config.json`.
+*
+* @remarks
+* Wraps {@link ConfigInspector.inspect} and renders either human-readable
+* output (default) or JSON (`--json` / `--format=json`). The same data shape
+* the agent consumes is what the user sees, so debugging an unexpected
+* classification result becomes a single `savvy changeset config show --json`
+* invocation.
+*
+* @example
+* ```bash
+* savvy changeset config show
+* savvy changeset config show --json
+* savvy changeset config show ./path/to/project --json
+* ```
+*
+* @internal
+*/
+const { ConfigInspector } = Changesets;
+/* v8 ignore start -- CLI option definitions */
+const dirArg = Args.directory({ name: "dir" }).pipe(Args.withDefault("."));
+const jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON instead of human-readable output"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Render an {@link InspectedConfig} as human-readable text.
+*
+* @internal
+*/
+function renderHuman(config) {
+	const lines = [];
+	lines.push(`Config:    ${config.configPath}`);
+	lines.push(`Project:   ${config.projectDir}`);
+	lines.push(`Changelog: ${config.changelog ?? "(none)"}`);
+	lines.push(`Base:      ${config.baseBranch}`);
+	lines.push(`Access:    ${config.access}`);
+	if (config.ignore.length > 0) lines.push(`Ignore:    ${config.ignore.join(", ")}`);
+	if (config.legacyVersionFilesUsed) {
+		lines.push("");
+		lines.push("⚠ This config still uses the deprecated top-level `versionFiles[]`.");
+		lines.push("  Migrate to `packages[<name>].versionFiles` — required for 1.0.0.");
+	}
+	lines.push("");
+	if (config.packages.length === 0) {
+		lines.push("Packages: (none declared)");
+		return lines.join("\n");
+	}
+	lines.push(`Packages (${config.packages.length}):`);
+	for (const pkg of config.packages) {
+		lines.push("");
+		lines.push(`  ${pkg.name}  v${pkg.version}`);
+		lines.push(`    workspace: ${pkg.workspaceDir}`);
+		if (pkg.additionalScopes.length > 0) {
+			lines.push(`    additionalScopes (${pkg.additionalScopes.length}):`);
+			for (const g of pkg.additionalScopes) lines.push(`      - ${g}`);
+			lines.push(`    additionalScopeFiles (${pkg.additionalScopeFiles.length}):`);
+			for (const f of pkg.additionalScopeFiles) lines.push(`      ${f}`);
+		}
+		if (pkg.versionFiles.length > 0) {
+			lines.push(`    versionFiles (${pkg.versionFiles.length}):`);
+			for (const vf of pkg.versionFiles) {
+				lines.push(`      ${vf.glob} → ${vf.paths.join(", ")}  (${vf.matchedFiles.length} file${vf.matchedFiles.length === 1 ? "" : "s"} matched)`);
+				for (const f of vf.matchedFiles) lines.push(`        ${f}`);
+			}
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Resolve the project dir, invoke `ConfigInspector.inspect`, and render the
+* result. Sets `process.exitCode = 1` on `ConfigurationError`.
+*
+* @internal
+*/
+function runConfigShow(dir, json) {
+	return Effect.gen(function* () {
+		const inspector = yield* ConfigInspector;
+		const resolved = resolve(dir);
+		const config = yield* inspector.inspect(resolved).pipe(Effect.catchTag("ConfigurationError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		}));
+		const output = json ? JSON.stringify(config, null, 2) : renderHuman(config);
+		yield* Effect.log(output);
+	});
+}
+/* v8 ignore next 6 -- CLI registration */
+const configShowCommand = Command.make("show", {
+	dir: dirArg,
+	json: jsonOption
+}, ({ dir, json }) => runConfigShow(dir, json)).pipe(Command.withDescription("Print the resolved .changeset/config.json"));
+
+//#endregion
+export { configShowCommand };

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

@@ -0,0 +1,63 @@
+import { Args, Command } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+import { resolve } from "node:path";
+
+//#region src/commands/changeset/commands/config-validate.ts
+/**
+* `config validate` command -- validate-only mode for `.changeset/config.json`.
+*
+* @remarks
+* Invokes {@link ConfigInspector.inspect} solely for its side effect of
+* surfacing {@link ConfigurationError}. On success prints a short OK
+* summary and exits 0. On error prints the structured failure (field +
+* reason) and exits non-zero.
+*
+* Used by CI gates and by the `version` / `transform` commands' refusal
+* posture in Phase 5.
+*
+* @example
+* ```bash
+* savvy changeset config validate
+* savvy changeset config validate ./path/to/project
+* ```
+*
+* @internal
+*/
+const { ConfigInspector } = Changesets;
+/* v8 ignore next */
+const dirArg = Args.directory({ name: "dir" }).pipe(Args.withDefault("."));
+/**
+* Run validation. Logs a one-line OK on success; logs the error and sets
+* `process.exitCode = 1` on failure.
+*
+* @internal
+*/
+function runConfigValidate(dir) {
+	return Effect.gen(function* () {
+		const inspector = yield* ConfigInspector;
+		const resolved = resolve(dir);
+		const result = yield* inspector.inspect(resolved).pipe(Effect.map((config) => ({
+			ok: true,
+			config
+		})), Effect.catchTag("ConfigurationError", (err) => Effect.succeed({
+			ok: false,
+			field: err.field,
+			reason: err.reason
+		})));
+		if (result.ok) {
+			const { config } = result;
+			const pkgCount = config.packages.length;
+			const note = config.legacyVersionFilesUsed ? " (warning: legacy versionFiles in use)" : "";
+			yield* Effect.log(`OK  ${config.configPath} — ${pkgCount} package${pkgCount === 1 ? "" : "s"} declared${note}`);
+			return;
+		}
+		yield* Effect.log(`FAIL  ${result.field}: ${result.reason}`);
+		process.exitCode = 1;
+	});
+}
+/* v8 ignore next 5 -- CLI registration */
+const configValidateCommand = Command.make("validate", { dir: dirArg }, ({ dir }) => runConfigValidate(dir)).pipe(Command.withDescription("Validate .changeset/config.json without rendering it"));
+
+//#endregion
+export { configValidateCommand };

package/commands/changeset/commands/deps-detect.js

@@ -0,0 +1,103 @@
+import { Command, Options } from "@effect/cli";
+import { Changesets } from "@savvy-web/silk-effects";
+import { Effect, Option } from "effect";
+import { WorkspaceDiscovery } from "workspaces-effect";
+import { resolve } from "node:path";
+
+//#region src/commands/changeset/commands/deps-detect.ts
+/**
+* `deps detect` command — read-only dependency-diff inspection.
+*
+* @remarks
+* Computes the per-workspace-package dependency changes between two git
+* refs and renders them either as structured JSON (one row per change)
+* or as ready-to-paste CSH005 markdown. No file writes.
+*
+* Defaults:
+* - `--from` → `git merge-base <baseBranch> HEAD`
+* - `--to`   → working tree (i.e., `HEAD` plus staged + unstaged + untracked,
+*   matching `analyze-branch`'s coverage). Passed as the special value
+*   `WORKTREE` to {@link WorkspaceSnapshotReader} — implementations resolve
+*   this against the live working tree rather than `git show`.
+*
+* @example
+* ```bash
+* savvy changeset deps detect
+* savvy changeset deps detect --from HEAD~5 --to HEAD --json
+* savvy changeset deps detect --package @scope/foo --markdown
+* ```
+*
+* @internal
+*/
+const { ConfigInspector, WorkspaceSnapshotReader, computeWorkspaceDependencyDiffs, gitMergeBase, listPublishablePackageNames, serializeDependencyTableToMarkdown, snapshotFromWorktree } = Changesets;
+/* v8 ignore start -- CLI option definitions */
+const fromOption = Options.text("from").pipe(Options.withDescription("Older ref to diff from (defaults to merge-base with base branch)"), Options.optional);
+const toOption = Options.text("to").pipe(Options.withDescription("Newer ref to diff to (defaults to working tree)"), Options.optional);
+const cwdOption = Options.directory("cwd").pipe(Options.withDescription("Project root (defaults to the current working directory)"), Options.withDefault("."));
+const packageOption = Options.text("package").pipe(Options.withDescription("Restrict output to a single workspace package"), Options.optional);
+const jsonOption = Options.boolean("json").pipe(Options.withDescription("Emit JSON (default)"), Options.withDefault(false));
+const markdownOption = Options.boolean("markdown").pipe(Options.withDescription("Emit one CSH005 markdown block per workspace package"), Options.withDefault(false));
+/* v8 ignore stop */
+/**
+* Render a per-workspace diff as markdown — one frontmatter+section block
+* per affected workspace package, suitable for pasting into individual
+* `.changeset/*.md` files.
+*
+* @internal
+*/
+function renderMarkdownBlocks(diffs) {
+	const blocks = [];
+	for (const diff of diffs) {
+		const frontmatter = `---\n"${diff.package}": patch\n---`;
+		const table = serializeDependencyTableToMarkdown([...diff.rows]);
+		blocks.push(`${frontmatter}\n\n## Dependencies\n\n${table}\n`);
+	}
+	return blocks.join("\n");
+}
+/**
+* Handler exported for direct invocation in tests.
+*
+* @internal
+*/
+function runDepsDetect(cwd, from, to, pkg, json, markdown) {
+	return Effect.gen(function* () {
+		const reader = yield* WorkspaceSnapshotReader;
+		const resolvedCwd = resolve(cwd);
+		let fromRef = Option.getOrUndefined(from);
+		if (!fromRef) fromRef = yield* gitMergeBase(resolvedCwd, (yield* (yield* ConfigInspector).inspect(resolvedCwd).pipe(Effect.catchTag("ConfigurationError", () => Effect.succeed({ baseBranch: "main" })))).baseBranch).pipe(Effect.catchTag("GitError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		}));
+		const toRef = Option.getOrUndefined(to);
+		let diffs = computeWorkspaceDependencyDiffs(yield* reader.snapshotAt(resolvedCwd, fromRef).pipe(Effect.catchTag("GitError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		})), toRef ? yield* reader.snapshotAt(resolvedCwd, toRef).pipe(Effect.catchTag("GitError", (err) => {
+			process.exitCode = 1;
+			return Effect.fail(err);
+		})) : snapshotFromWorktree(resolvedCwd));
+		const targetPkg = Option.getOrUndefined(pkg);
+		if (targetPkg) diffs = diffs.filter((d) => d.package === targetPkg);
+		else {
+			const publishable = yield* listPublishablePackageNames(yield* (yield* WorkspaceDiscovery).listPackages(resolvedCwd).pipe(Effect.catchAll(() => Effect.succeed([]))));
+			diffs = diffs.filter((d) => publishable.has(d.package));
+		}
+		if (markdown && !json) {
+			yield* Effect.log(renderMarkdownBlocks(diffs));
+			return;
+		}
+		yield* Effect.log(JSON.stringify(diffs, null, 2));
+	});
+}
+/* v8 ignore next 7 */
+const depsDetectCommand = Command.make("detect", {
+	from: fromOption,
+	to: toOption,
+	cwd: cwdOption,
+	package: packageOption,
+	json: jsonOption,
+	markdown: markdownOption
+}, ({ from, to, cwd, package: pkg, json, markdown }) => runDepsDetect(cwd, from, to, pkg, json, markdown)).pipe(Command.withDescription("Compute the dependency diff between two refs"));
+
+//#endregion
+export { depsDetectCommand };