@savvy-web/cli 3.5.1 → 3.6.0

package/commands/repos/commands/pin.js

@@ -1,8 +1,9 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { ReposCli } from "../shared.js";
 import { Argument, Command, Flag } from "effect/cli";
-import { CliExit } from "@effected/cli";
+import { CliInteractive, Doc } from "@effected/cli";
 import { Repos } from "@savvy-web/silk-effects";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 
 //#region src/commands/repos/commands/pin.ts
 /**
@@ -19,8 +20,14 @@ import { Effect } from "effect";
 * `GitSubmoduleError` means the underlying git command failed,
 * `RepoNotFoundError` means the named repo isn't in the manifest, and
 * `ReposLockdownError` means the OS-permission lockdown pass on a vendored
-* tree failed -- all four are real failures, logged and reported via a
-* non-zero exit code.
+* tree failed -- all four are real failures, failing as a `CommandError`
+* (exit 1) with a hint.
+*
+* Both positionals are optional to the parser so a person can leave them off:
+* at a terminal a missing name is picked from the vendored repos (`Select`)
+* and a missing ref typed (`TextInput`, starting at the current pin). Anywhere
+* else (an agent, CI, a pipe) a missing one is the usage error it always was,
+* exit 64, and nothing is read.
 *
 * @example
 * ```bash
@@ -30,37 +37,45 @@ import { Effect } from "effect";
 * @internal
 */
 /* v8 ignore start -- CLI option/arg definitions */
-const nameArg = Argument.String("name");
-const refArg = Argument.String("ref");
+const nameArg = Argument.String("name").pipe(Argument.optional);
+const refArg = Argument.String("ref").pipe(Argument.optional);
 const cwdOption = Flag.Directory("cwd").pipe(Flag.withDescription("Repo root to pin within"), Flag.withDefault("."));
 /* v8 ignore stop */
 /**
-* Pin handler; exported for tests.
+* Pin handler; exported for tests. `name`/`ref` are `undefined` when left off.
 *
 * @internal
 */
 const runReposPin = (cwd, name, ref) => Effect.gen(function* () {
-	const result = yield* (yield* Repos.ReposManager).pin(cwd, name, ref);
-	yield* Output.ok(`${result.name}: ${result.oldCommit ?? "unknown"} -> ${result.newCommit}`);
-	yield* Output.detail(result.commitMessage);
-	yield* Output.detail("staged — review and commit");
-	for (const staleId of result.staleNoteIds) yield* Output.warn(`note ${staleId} is now stale against ${ref}`);
-}).pipe(Effect.catchTag("ReposConfigError", (error) => {
-	if (error.kind === "missing") return Output.skip("no .repos/config.json — nothing vendored");
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("GitSubmoduleError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("RepoNotFoundError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("ReposLockdownError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}));
+	const target = yield* ReposCli.nameOrPick(cwd, name, {
+		command: ["pin"],
+		argument: "name",
+		message: "Re-pin which repo?"
+	});
+	const current = ref === void 0 && (yield* CliInteractive) ? (yield* ReposCli.vendored(cwd)).find((repo) => repo.name === target)?.ref : void 0;
+	const newRef = yield* ReposCli.textOrAsk(ref, {
+		command: ["pin"],
+		argument: "ref",
+		message: `Re-pin ${target} to which ref? (tag, branch, or commit)`,
+		initial: current
+	});
+	const result = yield* (yield* Repos.ReposManager).pin(cwd, target, newRef);
+	yield* Report.print([
+		Report.ok(`${result.name}: ${result.oldCommit ?? "unknown"} -> ${result.newCommit}`, "staged — review and commit"),
+		Doc.codeBlock(result.commitMessage),
+		...result.staleNoteIds.map((staleId) => Report.warn(`note ${staleId} is now stale against ${newRef}`))
+	]);
+}).pipe(Effect.catchTag("ReposConfigError", (error) => error.kind === "missing" ? ReposCli.nothingVendored : ReposCli.fail("re-pin the repo")(error)), Effect.catchTag([
+	"GitSubmoduleError",
+	"RepoNotFoundError",
+	"ReposLockdownError"
+], ReposCli.fail("re-pin the repo")));
 /* v8 ignore start -- CLI registration; handler tested via runReposPin */
 const pinCommand = Command.make("pin", {
 	name: nameArg,
 	ref: refArg,
 	cwd: cwdOption
-}, ({ name, ref, cwd }) => runReposPin(cwd, name, ref)).pipe(Command.withDescription("Re-pin a vendored repo to a new ref; stages the change without committing"));
+}, ({ name, ref, cwd }) => runReposPin(cwd, Option.getOrUndefined(name), Option.getOrUndefined(ref))).pipe(Command.withDescription("Re-pin a vendored repo to a new ref; stages the change without committing"));
 /* v8 ignore stop */
 
 //#endregion

package/commands/repos/commands/remove.js

@@ -1,73 +1,47 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { confirmDestructive, yesFlag } from "../../../internal/confirm.js";
+import { ReposCli } from "../shared.js";
 import { Argument, Command, Flag } from "effect/cli";
-import { CliExit } from "@effected/cli";
+import { Doc } from "@effected/cli";
 import { Repos } from "@savvy-web/silk-effects";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 
 //#region src/commands/repos/commands/remove.ts
-/**
-* `repos remove` command -- unvendor a `.repos/` submodule.
-*
-* @remarks
-* A thin adapter over {@link Repos.ReposManager.remove}: deinitializes and
-* removes the submodule's gitlink, worktree, and module gitdir, drops its
-* `.gitmodules` section, and removes the manifest entry -- it does not
-* commit, so the caller reviews and commits the staged removal with the
-* ready-made message the result carries. Any notes the entry carried are
-* surfaced in the result so a durable one can be promoted elsewhere first.
-*
-* A `ReposConfigError` with kind `"missing"` -- nothing vendored yet -- is
-* the common, friendly case and always exits 0. A `ReposConfigError` with
-* kind `"invalid"` means the manifest exists but is corrupt or unreadable.
-* `RepoNotFoundError` means the named repo isn't in the manifest -- this is
-* a REAL failure (unlike the "missing manifest" case above), since removing
-* a name that was never vendored is almost always a typo the caller should
-* see. `GitSubmoduleError` means the underlying git command failed, and
-* `ReposLockdownError` means the OS-permission lockdown pass on a vendored
-* tree failed -- all four (invalid config, not-found, git failure, lockdown
-* failure) are real failures, logged and reported via a non-zero exit code.
-*
-* @example
-* ```bash
-* savvy repos remove my-repo
-* ```
-*
-* @internal
-*/
 /* v8 ignore start -- CLI option/arg definitions */
-const nameArg = Argument.String("name");
+const nameArg = Argument.String("name").pipe(Argument.optional);
 const cwdOption = Flag.Directory("cwd").pipe(Flag.withDescription("Repo root to remove within"), Flag.withDefault("."));
-/* v8 ignore stop */
 /**
-* Remove handler; exported for tests.
+* Remove handler; exported for tests. `name` is `undefined` when left off.
 *
 * @internal
 */
-const runReposRemove = (cwd, name) => Effect.gen(function* () {
-	const result = yield* (yield* Repos.ReposManager).remove(cwd, name);
-	yield* Output.ok(`${result.name}: removed (${result.path})`);
-	yield* Output.detail(result.commitMessage);
-	yield* Output.detail("staged — review and commit");
-	for (const note of result.removedNotes) yield* Output.warn(`note ${note.id} (${note.ref}) was removed with the entry — promote first if durable`);
-	if (result.removedEntry.orientation) {
-		yield* Output.warn(`the orientation block for ${result.name} was removed with the entry and add will NOT restore it — re-vendoring? capture it now:`);
-		yield* Output.line(JSON.stringify(result.removedEntry.orientation, null, 2));
-	}
-}).pipe(Effect.catchTag("ReposConfigError", (error) => {
-	if (error.kind === "missing") return Output.skip("no .repos/config.json — nothing vendored");
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("RepoNotFoundError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("GitSubmoduleError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("ReposLockdownError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}));
+const runReposRemove = (cwd, name, options = {}) => Effect.gen(function* () {
+	const target = yield* ReposCli.nameOrPick(cwd, name, {
+		command: ["remove"],
+		argument: "name",
+		message: "Unvendor which repo?"
+	});
+	if (!(yield* confirmDestructive({
+		message: `Remove ${target} from .repos/? (staged, not committed)`,
+		yes: options.yes === true
+	}))) return yield* Report.print([Report.skip(`remove cancelled — ${target} left vendored`)]);
+	const result = yield* (yield* Repos.ReposManager).remove(cwd, target);
+	const blocks = [Report.ok(`${result.name}: removed (${result.path})`, "staged — review and commit"), Doc.codeBlock(result.commitMessage)];
+	const lost = result.removedNotes.map((note) => Doc.paragraph(`note ${note.id} (${note.ref}) was removed with the entry — promote it first if it is durable`));
+	if (result.removedEntry.orientation) lost.push(Doc.paragraph(`the orientation block for ${result.name} was removed with the entry and add will NOT restore it — re-vendoring? capture it now:`), Doc.codeBlock(JSON.stringify(result.removedEntry.orientation, null, 2), "json"));
+	if (lost.length > 0) blocks.push(Doc.callout("warning", lost));
+	yield* Report.print(blocks);
+}).pipe(Effect.catchTag("ReposConfigError", (error) => error.kind === "missing" ? ReposCli.nothingVendored : ReposCli.fail("remove the repo")(error)), Effect.catchTag([
+	"RepoNotFoundError",
+	"GitSubmoduleError",
+	"ReposLockdownError"
+], ReposCli.fail("remove the repo")));
 /* v8 ignore start -- CLI registration; handler tested via runReposRemove */
 const removeCommand = Command.make("remove", {
 	name: nameArg,
+	yes: yesFlag,
 	cwd: cwdOption
-}, ({ name, cwd }) => runReposRemove(cwd, name)).pipe(Command.withDescription("Unvendor a repo under .repos/; stages the removal without committing"));
+}, ({ name, yes, cwd }) => runReposRemove(cwd, Option.getOrUndefined(name), { yes })).pipe(Command.withDescription("Unvendor a repo under .repos/; stages the removal without committing"));
 /* v8 ignore stop */
 
 //#endregion

package/commands/repos/commands/rename.js

@@ -1,8 +1,9 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { ReposCli } from "../shared.js";
 import { Argument, Command, Flag } from "effect/cli";
-import { CliExit } from "@effected/cli";
+import { Doc } from "@effected/cli";
 import { Repos } from "@savvy-web/silk-effects";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 
 //#region src/commands/repos/commands/rename.ts
 /**
@@ -25,8 +26,13 @@ import { Effect } from "effect";
 * should see. `GitSubmoduleError` means the underlying git command failed,
 * and `ReposLockdownError` means the OS-permission lockdown pass on a
 * vendored tree failed -- all four (invalid config, not-found, git failure,
-* lockdown failure) are real failures, logged and reported via a non-zero
-* exit code.
+* lockdown failure) are real failures, failing as a `CommandError` (exit 1)
+* with a hint.
+*
+* Both positionals are optional to the parser so a person can leave them off:
+* at a terminal a missing old name is picked from the vendored repos
+* (`Select`) and a missing new name typed (`TextInput`). Anywhere else a
+* missing one is the usage error it always was, exit 64.
 *
 * @example
 * ```bash
@@ -36,36 +42,39 @@ import { Effect } from "effect";
 * @internal
 */
 /* v8 ignore start -- CLI option/arg definitions */
-const oldNameArg = Argument.String("old-name");
-const newNameArg = Argument.String("new-name");
+const oldNameArg = Argument.String("old-name").pipe(Argument.optional);
+const newNameArg = Argument.String("new-name").pipe(Argument.optional);
 const cwdOption = Flag.Directory("cwd").pipe(Flag.withDescription("Repo root to rename within"), Flag.withDefault("."));
 /* v8 ignore stop */
 /**
-* Rename handler; exported for tests.
+* Rename handler; exported for tests. Either name is `undefined` when left off.
 *
 * @internal
 */
 const runReposRename = (cwd, oldName, newName) => Effect.gen(function* () {
-	const result = yield* (yield* Repos.ReposManager).rename(cwd, oldName, newName);
-	yield* Output.ok(`${result.oldName}: renamed to ${result.newName} (${result.path})`);
-	yield* Output.detail(result.commitMessage);
-	yield* Output.detail("staged — review and commit");
-}).pipe(Effect.catchTag("ReposConfigError", (error) => {
-	if (error.kind === "missing") return Output.skip("no .repos/config.json — nothing vendored");
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("RepoNotFoundError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("GitSubmoduleError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("ReposLockdownError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}));
+	const from = yield* ReposCli.nameOrPick(cwd, oldName, {
+		command: ["rename"],
+		argument: "old-name",
+		message: "Rename which repo?"
+	});
+	const to = yield* ReposCli.textOrAsk(newName, {
+		command: ["rename"],
+		argument: "new-name",
+		message: `Rename ${from} to?`
+	});
+	const result = yield* (yield* Repos.ReposManager).rename(cwd, from, to);
+	yield* Report.print([Report.ok(`${result.oldName}: renamed to ${result.newName} (${result.path})`, "staged — review and commit"), Doc.codeBlock(result.commitMessage)]);
+}).pipe(Effect.catchTag("ReposConfigError", (error) => error.kind === "missing" ? ReposCli.nothingVendored : ReposCli.fail("rename the repo", "the manifest is unreadable, or the new name is invalid or already vendored; run `savvy repos status`")(error)), Effect.catchTag([
+	"RepoNotFoundError",
+	"GitSubmoduleError",
+	"ReposLockdownError"
+], ReposCli.fail("rename the repo")));
 /* v8 ignore start -- CLI registration; handler tested via runReposRename */
 const renameCommand = Command.make("rename", {
 	oldName: oldNameArg,
 	newName: newNameArg,
 	cwd: cwdOption
-}, ({ oldName, newName, cwd }) => runReposRename(cwd, oldName, newName)).pipe(Command.withDescription("Rename a vendored repo's manifest key and worktree; stages the change without committing"));
+}, ({ oldName, newName, cwd }) => runReposRename(cwd, Option.getOrUndefined(oldName), Option.getOrUndefined(newName))).pipe(Command.withDescription("Rename a vendored repo's manifest key and worktree; stages the change without committing"));
 /* v8 ignore stop */
 
 //#endregion

package/commands/repos/commands/restore.js

@@ -1,77 +1,63 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { confirmDestructive, yesFlag } from "../../../internal/confirm.js";
+import { ReposCli } from "../shared.js";
 import { Argument, Command, Flag } from "effect/cli";
-import { CliExit } from "@effected/cli";
+import { CliExit, CliInteractive } from "@effected/cli";
 import { Repos } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
 
 //#region src/commands/repos/commands/restore.ts
-/**
-* `repos restore` command -- hard-reset one or more vendored `.repos/`
-* submodules back to their pinned gitlink commit.
-*
-* @remarks
-* A thin adapter over {@link Repos.ReposManager.restore}: explicit only --
-* never invoked by `sync` or any other implicit path. DESTRUCTIVE to
-* uncommitted worktree edits and untracked files in the repos it touches:
-* each targeted repo is hard-reset to its staged gitlink commit (falling
-* back to the committed one) and its sparse-checkout paths re-applied.
-* With one or more `name` arguments, exactly those repos are restored, even
-* if already clean -- an explicit ask is always honored. With no names, every
-* DIRTY repo (per `status`) is restored and the clean ones are reported as
-* skipped.
-*
-* A `ReposConfigError` with kind `"missing"` -- nothing vendored yet -- is
-* the common, friendly case and always exits 0. A `ReposConfigError` with
-* kind `"invalid"` means the manifest exists but is corrupt or unreadable.
-* `RepoNotFoundError` means an explicitly named repo isn't in the manifest --
-* a real failure, since restoring a name that was never vendored is almost
-* always a typo the caller should see. `GitSubmoduleError` means the
-* underlying git command failed (including the case where a repo has
-* neither a staged nor a committed gitlink commit to restore to), and
-* `ReposLockdownError` means the OS-permission lockdown pass on a vendored
-* tree failed -- all four are real failures, logged and reported via a
-* non-zero exit code.
-*
-* @example
-* ```bash
-* savvy repos restore my-repo
-* savvy repos restore my-repo other-repo
-* savvy repos restore
-* ```
-*
-* @internal
-*/
 /* v8 ignore start -- CLI option/arg definitions */
 const namesArg = Argument.String("name").pipe(Argument.variadic());
 const cwdOption = Flag.Directory("cwd").pipe(Flag.withDescription("Repo root to restore within"), Flag.withDefault("."));
-/* v8 ignore stop */
+/** Which repos to restore: the names given, or (at a terminal, with none given) the dirty ones a person picks. */
+const choose = (cwd, names) => Effect.gen(function* () {
+	if (names.length > 0 || !(yield* CliInteractive)) return {
+		names,
+		asked: false
+	};
+	const dirty = (yield* ReposCli.vendored(cwd)).filter((repo) => repo.dirty).map((repo) => repo.name);
+	if (dirty.length === 0) return {
+		names,
+		asked: false
+	};
+	return {
+		names: yield* ReposCli.pickDirty(dirty),
+		asked: true
+	};
+});
 /**
 * Restore handler; exported for tests.
 *
 * @internal
 */
-const runReposRestore = (cwd, names) => Effect.gen(function* () {
-	const result = yield* (yield* Repos.ReposManager).restore(cwd, names.length > 0 ? names : void 0);
-	for (const entry of result.restored) yield* Output.ok(`${entry.name}: restored to ${entry.commit}`);
-	for (const name of result.skippedClean) yield* Output.skip(`${name}: clean — skipped`);
-	for (const name of result.stillDirty) yield* Output.fail(`${name}: reset ran but the worktree is STILL dirty; run \`savvy repos status --drift\``);
+const runReposRestore = (cwd, names, options = {}) => Effect.gen(function* () {
+	const chosen = yield* choose(cwd, names);
+	if (chosen.asked && chosen.names.length === 0) return yield* Report.print([Report.skip("nothing selected — left unchanged")]);
+	const targets = chosen.names;
+	if (targets.length > 0) {
+		if (!(yield* confirmDestructive({
+			message: `Hard-reset ${targets.join(", ")}? Uncommitted edits and untracked files there are lost.`,
+			yes: options.yes === true
+		}))) return yield* Report.print([Report.skip("restore cancelled — nothing changed")]);
+	}
+	const result = yield* (yield* Repos.ReposManager).restore(cwd, targets.length > 0 ? targets : void 0);
+	const blocks = [...result.restored.map((entry) => Report.ok(`${entry.name}: restored to ${entry.commit}`)), ...result.skippedClean.map((name) => Report.skip(`${name}: clean — skipped`))];
+	for (const name of result.stillDirty) blocks.push(Report.fail(`${name}: reset ran but the worktree is STILL dirty; run \`savvy repos status --drift\``));
 	if (result.stillDirty.length > 0) yield* CliExit.set(1);
-	if (result.restored.length === 0 && result.skippedClean.length === 0) yield* Output.ok("nothing to restore");
-}).pipe(Effect.catchTag("ReposConfigError", (error) => {
-	if (error.kind === "missing") return Output.skip("no .repos/config.json — nothing vendored");
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("RepoNotFoundError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("GitSubmoduleError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("ReposLockdownError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}));
+	if (result.restored.length === 0 && result.skippedClean.length === 0) blocks.push(Report.ok("nothing to restore"));
+	yield* Report.print(blocks);
+}).pipe(Effect.catchTag("ReposConfigError", (error) => error.kind === "missing" ? ReposCli.nothingVendored : ReposCli.fail("restore the vendored repos")(error)), Effect.catchTag([
+	"RepoNotFoundError",
+	"GitSubmoduleError",
+	"ReposLockdownError"
+], ReposCli.fail("restore the vendored repos")));
 /* v8 ignore start -- CLI registration; handler tested via runReposRestore */
 const restoreCommand = Command.make("restore", {
 	names: namesArg,
+	yes: yesFlag,
 	cwd: cwdOption
-}, ({ names, cwd }) => runReposRestore(cwd, names)).pipe(Command.withDescription("Hard-reset vendored repos to their pinned commit; DESTRUCTIVE to uncommitted worktree edits. Given no names, restores every dirty repo"));
+}, ({ names, yes, cwd }) => runReposRestore(cwd, names, { yes })).pipe(Command.withDescription("Hard-reset vendored repos to their pinned commit; DESTRUCTIVE to uncommitted worktree edits. Given no names, restores every dirty repo (asks first at a terminal)"));
 /* v8 ignore stop */
 
 //#endregion

package/commands/repos/commands/status.js

@@ -1,41 +1,43 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { ReposCli } from "../shared.js";
 import { Command, Flag } from "effect/cli";
-import { CliExit } from "@effected/cli";
+import { CliExit, Doc, Status } from "@effected/cli";
 import { Repos } from "@savvy-web/silk-effects";
 import { Console, Effect } from "effect";
 
 //#region src/commands/repos/commands/status.ts
-/**
-* `repos status` command -- drift report for vendored `.repos/` submodules.
-*
-* @remarks
-* A thin adapter over {@link Repos.ReposManager.status}: reports, per vendored
-* repo, whether the submodule is present, dirty, and whether any agent notes
-* have gone stale relative to the pinned ref. A `ReposConfigError` with kind
-* `"missing"` is the common, friendly case (nothing has been vendored yet) --
-* not an error -- so it is rendered as a plain message (or an empty JSON
-* report, in `--json` mode) with exit code 0. A `ReposConfigError` with kind
-* `"invalid"` means the manifest exists but is corrupt or unreadable -- that
-* is a real failure, logged and reported via a non-zero exit code.
-*
-* With `--drift`, {@link Repos.ReposDrift.check} also runs (after the status
-* check), reconciling the manifest, `.gitmodules`, the worktree, and `git
-* submodule status`. Each detected drift prints as one line
-* (`<name>: <kind> — <detail>`), and any drift flips the exit code to 1,
-* mirroring the existing `!clean` rule for the status report itself. Because
-* both calls read the same manifest, a missing manifest fails at the status
-* call before the drift check ever runs, so the friendly exit-0 case is
-* unaffected by `--drift`.
-*
-* @example
-* ```bash
-* savvy repos status
-* savvy repos status --json
-* savvy repos status --drift
-* ```
-*
-* @internal
-*/
+/** The human status report: a table of repos, and one of drifts under `--drift`. */
+var ReposStatusView = class {
+	constructor() {}
+	/** One row per repo: its name, pinned ref, and a status cell naming every flag it carries. */
+	static repos = (repos) => Doc.table([
+		{ header: "name" },
+		{ header: "ref" },
+		{ header: "state" }
+	], repos.map((repo) => {
+		const flags = [
+			repo.present ? void 0 : "missing",
+			repo.dirty ? "dirty" : void 0,
+			repo.staleNoteIds.length > 0 ? `${repo.staleNoteIds.length} stale notes` : void 0
+		].filter((f) => f !== void 0);
+		const state = flags.length > 0 ? [Doc.status(Status.core, "warning"), ` ${flags.join(", ")}`] : [Doc.status(Status.core, "success"), " clean"];
+		return [
+			repo.name,
+			repo.ref,
+			state
+		];
+	}));
+	/** One row per drift: the repo, the drift kind, and what disagrees. */
+	static drifts = (drifts) => Doc.table([
+		{ header: "name" },
+		{ header: "kind" },
+		{ header: "detail" }
+	], drifts.map((item) => [
+		[Doc.status(Status.core, "failure"), ` ${item.name}`],
+		item.kind,
+		item.detail
+	]));
+};
 /* v8 ignore start -- CLI option definitions */
 const jsonOption = Flag.Boolean("json").pipe(Flag.withDescription("Emit the structured drift report as JSON"), Flag.withDefault(false));
 const driftOption = Flag.Boolean("drift").pipe(Flag.withDescription("Also reconcile the manifest, .gitmodules, worktree, and git submodule status"), Flag.withDefault(false));
@@ -62,32 +64,26 @@ const runReposStatus = (cwd, json, drift = false) => Effect.gen(function* () {
 		yield* Console.log(JSON.stringify(payload, null, 2));
 		return;
 	}
-	for (const repo of report.repos) {
-		const flags = [
-			repo.present ? void 0 : "missing",
-			repo.dirty ? "dirty" : void 0,
-			repo.staleNoteIds.length > 0 ? `${repo.staleNoteIds.length} stale notes` : void 0
-		].filter((f) => f !== void 0);
-		yield* flags.length > 0 ? Output.warn(`${repo.name} @ ${repo.ref} [${flags.join(", ")}]`) : Output.ok(`${repo.name} @ ${repo.ref}`);
-	}
-	if (driftReport !== void 0) for (const item of driftReport.drifts) yield* Output.fail(`${item.name}: ${item.kind} — ${item.detail}`);
+	const blocks = [report.repos.length > 0 ? ReposStatusView.repos(report.repos) : Report.skip("the manifest lists no repos")];
+	if (driftReport !== void 0 && driftReport.drifts.length > 0) blocks.push(Report.line(""), Report.heading("drift"), ReposStatusView.drifts(driftReport.drifts));
+	yield* Report.print(blocks);
 }).pipe(Effect.catchTag("ReposConfigError", (error) => {
 	if (error.kind === "missing") {
 		if (json) return Console.log(JSON.stringify({
 			repos: [],
 			clean: true
 		}, null, 2));
-		return Output.skip("no .repos/config.json — nothing vendored");
+		return Report.print([Report.skip("no .repos/config.json — nothing vendored")]);
 	}
-	const report = json ? Console.log(JSON.stringify({
+	if (json) return CliExit.set(1).pipe(Effect.andThen(Console.log(JSON.stringify({
 		error: error.message,
 		clean: false
-	}, null, 2)) : Effect.void;
-	return CliExit.set(1).pipe(Effect.andThen(report), Effect.andThen(Effect.logError(error.message)));
+	}, null, 2))), Effect.andThen(Effect.logError(error.message)));
+	return ReposCli.fail("read the repos manifest")(error);
 }), Effect.catchTag("GitSubmoduleError", (error) => json ? CliExit.set(1).pipe(Effect.andThen(Console.log(JSON.stringify({
 	error: error.message,
 	clean: false
-}, null, 2))), Effect.andThen(Effect.logError(error.message))) : Effect.fail(error)));
+}, null, 2))), Effect.andThen(Effect.logError(error.message))) : ReposCli.fail("check the vendored repos")(error)));
 /* v8 ignore start -- CLI registration; handler tested via runReposStatus */
 const statusCommand = Command.make("status", {
 	json: jsonOption,

package/commands/repos/commands/sync.js

@@ -1,34 +1,10 @@
-import { Output } from "../../../internal/output.js";
+import { Report } from "../../../internal/report.js";
+import { ReposCli } from "../shared.js";
 import { Command, Flag } from "effect/cli";
-import { CliExit } from "@effected/cli";
 import { Repos } from "@savvy-web/silk-effects";
 import { Effect } from "effect";
 
 //#region src/commands/repos/commands/sync.ts
-/**
-* `repos sync` command -- reconcile vendored `.repos/` submodules with the manifest.
-*
-* @remarks
-* A thin adapter over {@link Repos.ReposManager.sync}: initializes missing
-* submodules, re-applies sparse-checkout patterns, clears stale git locks
-* left behind by an interrupted fetch, reconciles a submodule's URL when it
-* drifts from the manifest, and registers an orphan manifest entry (no
-* gitlink at all) from scratch. Sync is idempotent repair, so
-* a `ReposConfigError` with kind `"missing"` -- the common, friendly case
-* (nothing to sync yet) -- always exits 0. A `ReposConfigError` with kind
-* `"invalid"` means the manifest exists but is corrupt or unreadable,
-* `GitSubmoduleError` means the underlying git command failed, and
-* `ReposLockdownError` means the OS-permission lockdown pass on a vendored
-* tree failed -- all three are real failures, logged and reported via a
-* non-zero exit code.
-*
-* @example
-* ```bash
-* savvy repos sync
-* ```
-*
-* @internal
-*/
 /* v8 ignore start -- CLI option definitions */
 const cwdOption = Flag.Directory("cwd").pipe(Flag.withDescription("Repo root to sync"), Flag.withDefault("."));
 /* v8 ignore stop */
@@ -39,20 +15,15 @@ const cwdOption = Flag.Directory("cwd").pipe(Flag.withDescription("Repo root to
 */
 const runReposSync = (cwd) => Effect.gen(function* () {
 	const report = yield* (yield* Repos.ReposManager).sync(cwd);
-	for (const name of report.clearedLocks) yield* Output.ok(`${name}: cleared stale lock`);
-	for (const name of report.initialized) yield* Output.ok(`${name}: initialized`);
-	for (const name of report.sparseApplied) yield* Output.ok(`${name}: sparse-checkout applied`);
-	for (const name of report.urlSynced) yield* Output.ok(`${name}: url reconciled`);
-	for (const name of report.registered) yield* Output.ok(`${name}: registered`);
-	if (report.initialized.length === 0 && report.sparseApplied.length === 0 && report.clearedLocks.length === 0 && report.urlSynced.length === 0 && report.registered.length === 0) yield* Output.ok("all vendored repos up to date");
-}).pipe(Effect.catchTag("ReposConfigError", (error) => {
-	if (error.kind === "missing") return Output.skip("no .repos/config.json — nothing vendored");
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("GitSubmoduleError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}), Effect.catchTag("ReposLockdownError", (error) => {
-	return CliExit.set(1).pipe(Effect.andThen(Effect.logError(error.message)));
-}));
+	const blocks = [];
+	for (const name of report.clearedLocks) blocks.push(Report.ok(`${name}: cleared stale lock`));
+	for (const name of report.initialized) blocks.push(Report.ok(`${name}: initialized`));
+	for (const name of report.sparseApplied) blocks.push(Report.ok(`${name}: sparse-checkout applied`));
+	for (const name of report.urlSynced) blocks.push(Report.ok(`${name}: url reconciled`));
+	for (const name of report.registered) blocks.push(Report.ok(`${name}: registered`));
+	if (report.initialized.length === 0 && report.sparseApplied.length === 0 && report.clearedLocks.length === 0 && report.urlSynced.length === 0 && report.registered.length === 0) blocks.push(Report.ok("all vendored repos up to date"));
+	yield* Report.print(blocks);
+}).pipe(Effect.catchTag("ReposConfigError", (error) => error.kind === "missing" ? ReposCli.nothingVendored : ReposCli.fail("sync the vendored repos")(error)), Effect.catchTag(["GitSubmoduleError", "ReposLockdownError"], ReposCli.fail("sync the vendored repos")));
 /* v8 ignore start -- CLI registration; handler tested via runReposSync */
 const syncCommand = Command.make("sync", { cwd: cwdOption }, ({ cwd }) => runReposSync(cwd)).pipe(Command.withDescription("Reconcile vendored submodules with the manifest: init missing, apply sparse, clear locks"));
 /* v8 ignore stop */

package/commands/repos/index.js

@@ -39,16 +39,13 @@ const _reposCommand = Command.make("repos").pipe(Command.withSubcommands([
 * discharges via `AppLive`. `Repos.ReposDrift` joins the union because
 * `status --drift` runs `Repos.ReposDrift.check` after the status check.
 *
-* The error channel is `Repos.GitSubmoduleError` alone: `add`/`pin`/`note`/
-* `remove`/`rename`/`restore`/`sync`/`deregister` each `catchTag` every error
-* their underlying `ReposManager` method can produce — `ReposConfigError`,
-* `GitSubmoduleError`, `RepoNotFoundError`, `NoteNotFoundError`, and (for the
-* six ops that unlock/re-lock the vendored tree around a git mutation)
-* `ReposLockdownError` — down to a logged message and a non-zero exit code,
-* so none of those propagate past the handler. `status` only `catchTag`s
-* `ReposConfigError`; `GitSubmoduleError` from either `ReposManager.status`
-* or (under `--drift`) `Repos.ReposDrift.check` is the sole channel that
-* escapes uncaught, so it is the only member left in this union.
+* The error channel is what a handler fails with, never a raw `Repos` error:
+* every handler maps each error its `ReposManager` method (or the picker's
+* `status` read) can produce to a self-rendering `CommandError` (exit 1),
+* except the friendly missing-manifest case and `status --json`'s JSON error
+* document. A repo name or other positional left off is a
+* `CliError.ShowHelp` (exit 64) when no one can be asked, and backing out of
+* a picker or a confirm is the kit's `Cancelled` (exit 130).
 */
 const reposCommand = _reposCommand;