reposets 2.0.4 → 3.0.0

package/cli/commands/init.js

@@ -1,12 +1,23 @@
 import { CONFIG_FILENAME, CREDENTIALS_FILENAME } from "../../services/ConfigFiles.js";
 import { Invocation } from "../../services/Invocation.js";
-import { Console, Effect, FileSystem, Path } from "effect";
-import { CliExit } from "@effected/cli";
-import { Command, Flag } from "effect/cli";
+import { configSchemaHost, credentialsSchemaHost, schemaDirective } from "../../schemas/hosted.js";
+import { Effect, FileSystem, Option, Path } from "effect";
+import { CliExit, CliMessage } from "@effected/cli";
 import { AppDirs } from "@effected/xdg";
+import { Command, Flag } from "effect/cli";
+import { CliUi, Select } from "@effected/cli/ui";
 
 //#region src/cli/commands/init.ts
-const projectFlag = Flag.Boolean("project").pipe(Flag.withDefault(false), Flag.withDescription("Scaffold into the current directory instead of the XDG config directory"));
+/**
+* `--project` scaffolds into the working directory, `--no-project` (or
+* `--project=false`) into the XDG config directory.
+*
+* @remarks
+* Optional rather than defaulted to `false`, so the handler can tell "not
+* given" from "given as false": only the former asks a person where to put the
+* files. A run that cannot ask takes the XDG directory, as it always has.
+*/
+const projectFlag = Flag.Boolean("project").pipe(Flag.optional, Flag.withDescription("Scaffold into the current directory (--no-project: the XDG config directory). Asked when omitted on a terminal"));
 const CONFIG_TEMPLATE = `# reposets configuration
 # See: https://github.com/spencerbeggs/reposets
 
@@ -101,19 +112,53 @@ const CREDENTIALS_TEMPLATE = `# reposets credentials
 # MY_CERT = "./certs/bot.pem"
 `;
 /**
+* Where the files go when `--project` was not given.
+*
+* @remarks
+* An interactive run asks, showing both resolved paths so the choice is about
+* a directory and not a word; the XDG directory is first and so the default.
+* A run that cannot ask (an agent, CI, a pipe) answers XDG without loading the
+* screen, which is exactly what `init` did before it could ask. A cancel is the
+* kit's `Cancelled` and propagates: exit 130, nothing written.
+*/
+const chooseProject = (configDir, cwd) => CliUi.prompt(Select.screen({
+	message: "Where should reposets keep its config?",
+	choices: [{
+		label: "XDG config directory",
+		value: false,
+		detail: configDir
+	}, {
+		label: "This directory",
+		value: true,
+		detail: cwd
+	}]
+}), { otherwise: false });
+/**
 * `reposets init` — scaffold the config and credentials files.
 *
 * @remarks
-* Writes into the XDG config directory by default, or the current directory
-* with `--project`. Existing files are reported and never overwritten — this
-* command must be safe to re-run against a configured machine.
+* Writes into the XDG config directory with `--no-project`, or the current
+* directory with `--project`. Without either, an interactive run asks (see
+* {@link chooseProject}) and a non-interactive one uses the XDG directory.
+* Existing files are reported and never overwritten — this command must be
+* safe to re-run against a configured machine.
+*
+* Each scaffolded file opens with a `#:schema` directive naming the versioned
+* JSON Schema it was written against, taken from the same `HostedSchema` the
+* schema build writes that document's `$id` from (`src/schemas/hosted.ts`).
+* Taplo and Tombi bind the file to that exact version without consulting
+* SchemaStore's catalog, and to the TOML decoder the line is a comment.
 *
 * The credentials file is added to `.gitignore` in both modes. It contains only
 * references and so is not catastrophic to commit, but it still names a
 * person's vault layout, and the habit is worth keeping.
 *
-* What was created or found goes to stdout; the next-steps guidance to stderr.
-* A file that could not be written is reported on stderr and exits 1.
+* What was created or found goes to stdout as status lines; the next-steps
+* guidance to stderr. A file that could not be written is reported on stderr
+* and exits 1.
+*
+* @param project - `true` for the working directory, `false` for XDG,
+* `undefined` when the flag was omitted
 *
 * @public
 */
@@ -121,7 +166,8 @@ const initHandler = (project) => Effect.gen(function* () {
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const appDirs = yield* AppDirs;
-	const targetDir = project ? (yield* Invocation).cwd : yield* appDirs.ensureConfig;
+	const { cwd } = yield* Invocation;
+	const targetDir = project ?? (yield* chooseProject(appDirs.dirs.config, cwd)) ? cwd : yield* appDirs.ensureConfig;
 	yield* fs.makeDirectory(targetDir, { recursive: true });
 	/**
 	* A write that fails is a real failure of this command — the user asked
@@ -134,22 +180,23 @@ const initHandler = (project) => Effect.gen(function* () {
 	const scaffold = (name, contents) => Effect.gen(function* () {
 		const target = path.join(targetDir, name);
 		if (yield* fs.exists(target).pipe(Effect.orElseSucceed(() => false))) {
-			yield* Console.log(`Already exists: ${target}`);
+			yield* CliMessage.info(`Already exists: ${target}`);
 			return;
 		}
-		yield* (yield* fs.writeFileString(target, contents).pipe(Effect.option))._tag === "Some" ? Console.log(`Created: ${target}`) : failed(target);
+		yield* (yield* fs.writeFileString(target, contents).pipe(Effect.option))._tag === "Some" ? CliMessage.success(`Created: ${target}`) : failed(target);
 	});
-	yield* scaffold(CONFIG_FILENAME, CONFIG_TEMPLATE);
-	yield* scaffold(CREDENTIALS_FILENAME, CREDENTIALS_TEMPLATE);
+	yield* scaffold(CONFIG_FILENAME, `${schemaDirective(configSchemaHost)}${CONFIG_TEMPLATE}`);
+	yield* scaffold(CREDENTIALS_FILENAME, `${schemaDirective(credentialsSchemaHost)}${CREDENTIALS_TEMPLATE}`);
 	const gitignorePath = path.join(targetDir, ".gitignore");
 	const existing = yield* fs.readFileString(gitignorePath).pipe(Effect.orElseSucceed(() => void 0));
-	if (existing === void 0) yield* (yield* fs.writeFileString(gitignorePath, `${"reposets.credentials.toml"}\n`).pipe(Effect.option))._tag === "Some" ? Console.log(`Created .gitignore with ${CREDENTIALS_FILENAME}`) : failed(gitignorePath);
+	if (existing === void 0) yield* (yield* fs.writeFileString(gitignorePath, `${"reposets.credentials.toml"}\n`).pipe(Effect.option))._tag === "Some" ? CliMessage.success(`Created .gitignore with ${CREDENTIALS_FILENAME}`) : failed(gitignorePath);
 	else if (!existing.includes("reposets.credentials.toml")) {
 		const separator = existing.endsWith("\n") ? "" : "\n";
-		yield* (yield* fs.writeFileString(gitignorePath, `${existing}${separator}${"reposets.credentials.toml"}\n`).pipe(Effect.option))._tag === "Some" ? Console.log(`Added ${CREDENTIALS_FILENAME} to .gitignore`) : failed(gitignorePath);
+		yield* (yield* fs.writeFileString(gitignorePath, `${existing}${separator}${"reposets.credentials.toml"}\n`).pipe(Effect.option))._tag === "Some" ? CliMessage.success(`Added ${CREDENTIALS_FILENAME} to .gitignore`) : failed(gitignorePath);
 	}
 	yield* Effect.log("");
-	yield* Effect.log("Done. Edit the config, then add a credential reference with:");
+	yield* Effect.log("Done. Edit the config, then add a credential reference:");
+	yield* Effect.log("  reposets credentials create        (on a terminal, asks for each value)");
 	yield* Effect.log("  reposets credentials create --profile personal --username YOU --op \"op://Vault/item/field\"");
 });
 /**
@@ -157,7 +204,7 @@ const initHandler = (project) => Effect.gen(function* () {
 *
 * @public
 */
-const initCommand = Command.make("init", { project: projectFlag }, ({ project }) => initHandler(project)).pipe(Command.withDescription("Scaffold reposets.config.toml and reposets.credentials.toml"));
+const initCommand = Command.make("init", { project: projectFlag }, ({ project }) => initHandler(Option.getOrUndefined(project))).pipe(Command.withDescription("Scaffold reposets.config.toml and reposets.credentials.toml"));
 
 //#endregion
 export { initCommand, initHandler };

package/cli/commands/list.js

@@ -1,7 +1,7 @@
 import { profileOwner } from "../../schemas/credentials.js";
 import { ReposetsConfigFile, ReposetsCredentialsFile } from "../../services/ConfigFiles.js";
-import { Console, Effect } from "effect";
-import { CliExit } from "@effected/cli";
+import { Effect } from "effect";
+import { CliExit, CliMessage, Doc } from "@effected/cli";
 import { Command } from "effect/cli";
 
 //#region src/cli/commands/list.ts
@@ -30,36 +30,49 @@ const scopeParts = (scopes) => {
 * entry, not a wall of blanks. The summary is the command's output, so it is
 * written to stdout.
 *
+* The summary is a `Doc` — one section per group — printed with `Doc.print`,
+* so the same report is plain text for an agent, painted for a person and a
+* folded log under GitHub Actions. Every name in it is user-supplied, and the
+* document sanitises it on the way out.
+*
 * @public
 */
 const listHandler = Effect.gen(function* () {
 	const configFile = yield* ReposetsConfigFile;
 	const credentialsFile = yield* ReposetsCredentialsFile;
 	if ((yield* configFile.discover).length === 0) {
-		yield* Effect.logError("No config file found. Run 'reposets init' to create one.");
+		yield* CliMessage.failure("No config found. Run 'reposets init' to create one.");
 		return yield* CliExit.set(1);
 	}
 	const config = yield* configFile.load;
 	const credentials = yield* credentialsFile.loadOrDefault({ profiles: {} });
+	const sections = [];
 	for (const [groupName, group] of Object.entries(config.groups)) {
 		const profile = credentials.profiles[group.credentials];
-		const acts = profile === void 0 ? `credentials: ${group.credentials} — NOT FOUND` : `owner: ${profileOwner(profile).owner}, credentials: ${group.credentials}`;
-		yield* Console.log(`[${groupName}] (${acts})`);
+		const acts = profile === void 0 ? Doc.text(`credentials: ${group.credentials} — NOT FOUND`, "failure") : Doc.text(`owner: ${profileOwner(profile).owner}, credentials: ${group.credentials}`, "muted");
 		const owner = profile === void 0 ? "(unknown)" : profileOwner(profile).owner;
-		for (const repo of group.repos) yield* Console.log(`  - ${owner}/${repo}`);
+		const children = [];
+		if (group.repos.length > 0) children.push(Doc.list(group.repos.map((repo) => Doc.paragraph(`${owner}/${repo}`)), { compact: true }));
+		const assignments = [];
 		for (const [label, names] of [
 			["settings", group.settings],
 			["environments", group.environments],
 			["rulesets", group.rulesets],
 			["security", group.security],
 			["code_scanning", group.code_scanning]
-		]) if (names !== void 0 && names.length > 0) yield* Console.log(`  ${label}: ${names.join(", ")}`);
+		]) if (names !== void 0 && names.length > 0) assignments.push(`${label}: ${names.join(", ")}`);
 		const secrets = scopeParts(group.secrets);
-		if (secrets.length > 0) yield* Console.log(`  secrets: ${secrets.join(", ")}`);
+		if (secrets.length > 0) assignments.push(`secrets: ${secrets.join(", ")}`);
 		const variables = scopeParts(group.variables);
-		if (variables.length > 0) yield* Console.log(`  variables: ${variables.join(", ")}`);
-		yield* Console.log("");
+		if (variables.length > 0) assignments.push(`variables: ${variables.join(", ")}`);
+		if (assignments.length > 0) children.push(Doc.lines(assignments));
+		sections.push(Doc.section([
+			`[${groupName}] (`,
+			acts,
+			")"
+		], children));
 	}
+	yield* Doc.print([Doc.section(void 0, sections)]);
 });
 /**
 * `reposets list`.

package/cli/commands/nuke.js

@@ -1,13 +1,67 @@
 import { CONFIG_FILENAME, CREDENTIALS_FILENAME } from "../../services/ConfigFiles.js";
 import { Invocation } from "../../services/Invocation.js";
-import { Console, Effect, FileSystem, Path, Stdio } from "effect";
-import { CliExit } from "@effected/cli";
-import { CliError, Command, Flag, Prompt } from "effect/cli";
-import { AppDirs } from "@effected/xdg";
+import { CACHE_DB_FILENAME, STATE_DB_FILENAME } from "../../store/files.js";
+import { Effect, FileSystem, Path } from "effect";
+import { CliExit, CliInteractive, CliMessage, Doc } from "@effected/cli";
+import { AppDirs, Xdg } from "@effected/xdg";
+import { CliError, Command, Flag } from "effect/cli";
+import { CliUi, Confirm, MultiSelect } from "@effected/cli/ui";
 
 //#region src/cli/commands/nuke.ts
 const forceFlag = Flag.Boolean("force").pipe(Flag.withDefault(false), Flag.withDescription("Delete without asking. Intended for scripts; there is no undo"));
 /**
+* The suffixes SQLite gives a database's companion files.
+*
+* @remarks
+* `-wal` and `-shm` in write-ahead-log mode, which is what the store and cache
+* use; `-journal` in rollback mode. Each is part of the database, not a file
+* of its own: a `-wal` holds committed transactions not yet folded into the
+* main file.
+*/
+const SQLITE_COMPANIONS = [
+	"-wal",
+	"-shm",
+	"-journal"
+];
+/**
+* Whether a regular file exists at a path. A path that cannot be stat'd reads
+* as absent.
+*/
+const isFile = (fs, file) => fs.stat(file).pipe(Effect.map((info) => info.type === "File"), Effect.orElseSucceed(() => false));
+/**
+* A database as one target: the main file and whichever companions exist.
+*
+* @remarks
+* Listed once because it is one thing to a person, and removed as a unit
+* because removing the main file alone strands its `-wal` and `-shm` beside the
+* fresh database the next sync creates. The target is present when **any** of
+* the files is, so companions orphaned by an earlier version — which deleted
+* `store.db` while its own process held it open — are found and cleaned up
+* too. The row shows the main file's path either way: it is the name a person
+* recognises.
+*/
+const databaseTarget = (fs, candidate) => Effect.gen(function* () {
+	const paths = [];
+	for (const file of [candidate.path, ...SQLITE_COMPANIONS.map((suffix) => `${candidate.path}${suffix}`)]) if (yield* isFile(fs, file)) paths.push(file);
+	return paths.length === 0 ? void 0 : {
+		...candidate,
+		paths
+	};
+});
+/**
+* Whether a `.gitignore` holds nothing but what `init` writes.
+*
+* @remarks
+* `init` writes the credentials filename, one line, into the directory it
+* scaffolds. A file with any other non-blank line was written or edited by
+* someone else, and deleting it would take their rules with it, so it is not a
+* target. An empty or blank-only file is not one `init` wrote either.
+*/
+const isInitGitignore = (contents) => {
+	const lines = contents.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+	return lines.length > 0 && lines.every((line) => line === "reposets.credentials.toml");
+};
+/**
 * Everything reposets has written to this machine.
 *
 * @remarks
@@ -20,45 +74,215 @@ const forceFlag = Flag.Boolean("force").pipe(Flag.withDefault(false), Flag.withD
 * file anywhere between the working directory and the filesystem root — because
 * the file a user is thinking of is the one the CLI would load, and that is not
 * always the one in the current directory.
+*
+* The `.gitignore` considered is only the one in the user config directory,
+* where `init` writes it and nobody else is expected to: a project directory's
+* `.gitignore` belongs to that repository, whatever it contains.
 */
 const findTargets = (fs, path, appDirs, from) => Effect.gen(function* () {
-	const candidates = [];
+	const files = [];
 	let dir = from;
 	for (;;) {
-		candidates.push({
+		files.push({
 			path: path.join(dir, CONFIG_FILENAME),
 			what: "project config",
-			cost: "your groups and settings"
+			cost: "loses your groups and settings",
+			location: "project"
 		}, {
 			path: path.join(dir, CREDENTIALS_FILENAME),
 			what: "project credentials",
-			cost: "token references, not tokens"
+			cost: "loses token references, not tokens",
+			location: "project"
 		});
 		const parent = path.dirname(dir);
 		if (parent === dir) break;
 		dir = parent;
 	}
-	candidates.push({
+	files.push({
 		path: path.join(appDirs.dirs.config, CONFIG_FILENAME),
 		what: "user config",
-		cost: "your groups and settings"
+		cost: "loses your groups and settings",
+		location: "user"
 	}, {
 		path: path.join(appDirs.dirs.config, CREDENTIALS_FILENAME),
 		what: "user credentials",
-		cost: "token references, not tokens"
-	}, {
-		path: path.join(appDirs.dirs.state, "store.db"),
-		what: "state database",
-		cost: "run history AND the drift baselines — drift detection restarts from nothing"
+		cost: "loses token references, not tokens",
+		location: "user"
 	});
 	const present = [];
-	for (const candidate of candidates) {
-		const info = yield* fs.stat(candidate.path).pipe(Effect.option);
-		if (info._tag === "Some" && info.value.type === "File") present.push(candidate);
+	for (const candidate of files) if (yield* isFile(fs, candidate.path)) present.push({
+		...candidate,
+		paths: [candidate.path]
+	});
+	const gitignore = path.join(appDirs.dirs.config, ".gitignore");
+	const contents = yield* fs.readFileString(gitignore).pipe(Effect.option);
+	if (contents._tag === "Some" && isInitGitignore(contents.value)) present.push({
+		path: gitignore,
+		paths: [gitignore],
+		what: "user .gitignore",
+		cost: "written by init",
+		location: "user"
+	});
+	const databases = [{
+		path: path.join(appDirs.dirs.state, STATE_DB_FILENAME),
+		what: "state database",
+		cost: "loses run history AND the drift baselines — drift detection restarts from nothing",
+		location: "state"
+	}, {
+		path: path.join(appDirs.dirs.cache, CACHE_DB_FILENAME),
+		what: "cache database",
+		cost: "loses cached GitHub reads — rebuilt on the next sync",
+		location: "cache"
+	}];
+	for (const candidate of databases) {
+		const target = yield* databaseTarget(fs, candidate);
+		if (target !== void 0) present.push(target);
 	}
 	return present;
 });
 /**
+* Remove each of reposets' own directories that is now empty.
+*
+* @remarks
+* Run only after a confirmed or forced removal, so a run that deleted nothing
+* leaves the directories as it found them. The directories are never listed as
+* targets: they are containers, and listing them would ask a person to decide
+* something that follows from the files. A directory with anything left in it
+* — a file deselected in the picker, or one reposets did not write — is kept.
+*
+* Core's `FileSystem.remove` without `recursive` refuses a directory even when
+* it is empty (it is Node's `rm`, not `rmdir`), so emptiness is checked with
+* `readDirectory` first and the removal then passes `recursive`, which on a
+* directory just seen empty removes only the directory. A directory that cannot
+* be read or removed is a warning, not a failure: nobody asked for it by name.
+*/
+const removeEmptyDirs = (fs, appDirs) => Effect.gen(function* () {
+	const { config, state, cache, data } = appDirs.dirs;
+	for (const dir of /* @__PURE__ */ new Set([
+		config,
+		state,
+		cache,
+		data
+	])) {
+		const entries = yield* fs.readDirectory(dir).pipe(Effect.option);
+		if (entries._tag === "None" || entries.value.length > 0) continue;
+		const outcome = yield* fs.remove(dir, { recursive: true }).pipe(Effect.result);
+		if (outcome._tag === "Failure") {
+			yield* Effect.logWarning(`could not remove empty directory ${dir} — ${String(outcome.failure)}`);
+			continue;
+		}
+		yield* CliMessage.success(`removed empty directory ${dir}`);
+	}
+});
+const plural = (n) => `${n} file${n === 1 ? "" : "s"}`;
+/**
+* How many files a set of targets removes.
+*
+* @remarks
+* Counted in files, not targets, because files are what the run reports: a
+* database is one target but up to four files (`-wal`, `-shm`, `-journal`),
+* each with its own `removed` line, and a summary counting targets would read
+* "1 file removed" under three of them.
+*/
+const fileCount = (targets) => targets.reduce((n, target) => n + target.paths.length, 0);
+/**
+* The list of what was found, as a document.
+*
+* @remarks
+* Printed before any question and whether or not one is asked, so a `--force`
+* run in a script leaves the same record in its log that a person reads before
+* answering. When the state database is among the targets its loss is said a
+* second time, as a warning callout: of everything listed it is the only
+* deletion that cannot be undone by restoring or rewriting a file.
+*/
+const targetsDoc = (targets) => [
+	Doc.section("This will delete:", [Doc.list(targets.map((target) => Doc.lines([Doc.file(target.path), target.location === "state" ? [`${target.what} — `, Doc.text(target.cost, "warning")] : `${target.what} — ${target.cost}`])), { compact: true })]),
+	...targets.some((target) => target.location === "state") ? [Doc.callout("warning", [Doc.paragraph("Deleting the state database cannot be undone: the drift baselines it holds cannot be rebuilt.")])] : [],
+	Doc.paragraph("Nothing on GitHub is touched. Everything reposets applied stays applied.")
+];
+const SECTION_TITLES = {
+	project: "Project files",
+	user: "User files",
+	state: "State",
+	cache: "Cache"
+};
+/**
+* A short, still unambiguous name for a target, for the picker's rows.
+*
+* @remarks
+* A picker row is truncated to the terminal, and an absolute path under a
+* temp or home directory loses exactly the part that tells two files apart.
+* A project file is shown relative to the working directory — `./` or a run of
+* `../` — which is short and distinguishes the same filename at different
+* levels of the upward walk; anything under the home directory is shown with
+* `~`. The absolute path stays in the row's detail and in the list printed
+* above the picker.
+*/
+const shortPath = (path, cwd, home, target) => {
+	if (target.location === "project") {
+		const relative = path.relative(cwd, target.path);
+		return relative.startsWith("..") ? relative : `.${path.sep}${relative}`;
+	}
+	const homePrefix = home.endsWith(path.sep) ? home : `${home}${path.sep}`;
+	return target.path.startsWith(homePrefix) ? `~${path.sep}${target.path.slice(homePrefix.length)}` : target.path;
+};
+/**
+* The picker's sections: every target pre-selected, grouped by where it lives.
+*
+* @remarks
+* Pre-selected because the command's name is the request — a person who ran
+* `nuke` and presses enter gets what they asked for, and still has the
+* confirmation after it. An empty section is left out rather than drawn as a
+* heading with nothing under it. Each row reads `what: short path` (see
+* {@link shortPath}); the highlighted row's detail is the absolute path.
+*/
+const pickerSections = (targets, short) => [
+	"project",
+	"user",
+	"state",
+	"cache"
+].map((location) => ({
+	title: SECTION_TITLES[location],
+	items: targets.filter((target) => target.location === location).map((target) => ({
+		key: target.path,
+		label: `${target.what}: ${short(target)}`,
+		value: target,
+		detail: target.path,
+		selected: true
+	}))
+})).filter((section) => section.items.length > 0);
+/**
+* Ask a person which of the targets to delete, then whether to go ahead.
+*
+* @remarks
+* Returns the targets to remove — empty when the person deselected everything
+* or answered no. Both screens run only when {@link nukeHandler} has already
+* established the run is interactive; the `NotInteractive` the kit could still
+* report is mapped to the same refusal, so there is one answer for "nobody is
+* there" however it is detected. A cancel (Esc, `q`, Ctrl-C) is the kit's
+* `Cancelled`, left to propagate: `CliRuntime.main` renders it as one line and
+* exits 130, which is not the same outcome as a deliberate "no".
+*/
+const choose = (targets, short) => Effect.gen(function* () {
+	const chosen = yield* CliUi.run(MultiSelect.screen({
+		message: "Delete which files?",
+		sections: pickerSections(targets, short)
+	}));
+	if (chosen.length === 0) return [];
+	const { confirmed } = yield* CliUi.run(Confirm.screen({ message: `Delete ${plural(fileCount(chosen))}?` }));
+	return confirmed ? chosen : [];
+}).pipe(Effect.catchTag("NotInteractive", () => Effect.fail(refusal())));
+/**
+* The invocation needed `--force`. A usage error, so exit 64.
+*
+* @remarks
+* A non-interactive run — a pipe, CI, an agent — is refused rather than
+* assumed: prompting there either hangs or reads whatever happens to be on
+* stdin, and proceeding because nobody was there to answer is the one failure
+* mode worth engineering against.
+*/
+const refusal = () => new CliError.UserError({ cause: "Refusing: not an interactive terminal, and --force was not given." });
+/**
 * `reposets nuke` — remove everything reposets has written locally.
 *
 * @remarks
@@ -67,10 +291,22 @@ const findTargets = (fs, path, appDirs, from) => Effect.gen(function* () {
 * files and the local database, which is what "leave no trace on this machine"
 * means.
 *
-* Without `--force` it lists what it found and asks. The prompt defaults to
-* **no**, and a non-interactive shell is refused rather than assumed: a
-* destructive command that proceeds because nobody was there to answer is the
-* one failure mode worth engineering against.
+* It always prints what it found first, or "Nothing to remove" when it found
+* nothing. Without `--force`, an interactive run then offers the targets as a
+* pre-selected checklist grouped project / user / state / cache, and asks "Delete N files?" defaulting to **no**; deselecting
+* everything or answering no deletes nothing and succeeds. A non-interactive
+* run without `--force` is refused (exit 64) — see {@link refusal}. Whether the
+* run may prompt is `CliInteractive`, decided once by `CliRuntime.main`'s
+* environment (a human audience on a terminal), not by probing stdin here.
+*
+* Each removal is reported as it happens, a database's companion files each
+* on their own line; one that fails is logged on stderr and the run exits 1
+* after every target has been tried. Then the `reposets` directories under the
+* XDG config, state, cache and data homes are removed if they are now empty —
+* see {@link removeEmptyDirs}.
+*
+* This command never opens a database: the platform provides only the
+* directories, so the files it deletes are not held open by its own process.
 *
 * @public
 */
@@ -79,39 +315,39 @@ const nukeHandler = (force) => Effect.gen(function* () {
 	const path = yield* Path.Path;
 	const appDirs = yield* AppDirs;
 	const { cwd } = yield* Invocation;
-	const targets = yield* findTargets(fs, path, appDirs, cwd);
-	if (targets.length === 0) {
-		yield* Console.log("Nothing to remove — no reposets files found on this machine.");
+	const found = yield* findTargets(fs, path, appDirs, cwd);
+	if (found.length === 0) {
+		yield* CliMessage.info("Nothing to remove — no reposets files found on this machine.");
 		return;
 	}
-	yield* Console.log("This will delete:");
-	for (const target of targets) {
-		yield* Console.log(`  ${target.path}`);
-		yield* Console.log(`    ${target.what} — loses ${target.cost}`);
-	}
-	yield* Console.log("");
-	yield* Console.log("Nothing on GitHub is touched. Everything reposets applied stays applied.");
+	yield* Doc.print(targetsDoc(found));
+	let targets = found;
 	if (!force) {
-		if (!(yield* (yield* Stdio.Stdio).stdinIsTerminal)) return yield* Effect.fail(new CliError.UserError({ cause: "Refusing: not an interactive terminal, and --force was not given." }));
-		yield* Console.log("");
-		if (!(yield* Prompt.Confirm({ message: `Delete ${targets.length} file${targets.length === 1 ? "" : "s"}?` }).pipe(Effect.orElseSucceed(() => false)))) {
-			yield* Console.log("Nothing was deleted.");
+		if (!(yield* CliInteractive)) return yield* Effect.fail(refusal());
+		const { home } = yield* Xdg;
+		targets = yield* choose(found, (target) => shortPath(path, cwd, home, target));
+		if (targets.length === 0) {
+			yield* CliMessage.info("Nothing was deleted.");
 			return;
 		}
 	}
+	const total = fileCount(targets);
 	let removed = 0;
-	for (const target of targets) {
-		const outcome = yield* fs.remove(target.path).pipe(Effect.result);
+	for (const target of targets) for (const file of target.paths) {
+		const outcome = yield* fs.remove(file).pipe(Effect.result);
 		if (outcome._tag === "Failure") {
-			yield* Effect.logError(`  could not remove ${target.path} — ${String(outcome.failure)}`);
+			yield* Effect.logError(`could not remove ${file} — ${String(outcome.failure)}`);
 			continue;
 		}
+		yield* CliMessage.success(`removed ${file}`);
 		removed += 1;
-		yield* Console.log(`  removed ${target.path}`);
 	}
-	yield* Console.log("");
-	yield* Console.log(removed === targets.length ? `Done. ${removed} file${removed === 1 ? "" : "s"} removed.` : `Removed ${removed} of ${targets.length}; the rest are listed above.`);
-	if (removed < targets.length) yield* CliExit.set(1);
+	yield* removeEmptyDirs(fs, appDirs);
+	if (removed === total) yield* CliMessage.success(`Done. ${plural(removed)} removed.`);
+	else {
+		yield* CliMessage.failure(`Removed ${removed} of ${plural(total)}; the failures are listed above.`);
+		yield* CliExit.set(1);
+	}
 });
 /**
 * The `nuke` command.