@rrlab/cli 1.1.0 → 1.2.0

package/dist/run.mjs

@@ -1,57 +1,135 @@
+import { createRequire } from "node:module";
 import path, { basename } from "node:path";
-import { colorize, createPkg, createShellService, cwd, dirnameOf, palette, run, runTaskBoard, text } from "@vlandoss/clibuddy";
-import { generateToStdout } from "@usage-spec/commander";
-import { Argument, Option, createCommand } from "commander";
+import { colorize, createPkg, createShellService, cwd, dirnameOf, palette, runTaskBoard, text } from "@vlandoss/clibuddy";
 import fs from "node:fs";
 import os from "node:os";
 import { lilconfig } from "lilconfig";
 import { createLoggy } from "@vlandoss/loggy";
+import { Argument, Command } from "commander";
+import stringWidth from "fast-string-width";
 import { glob } from "glob";
 import { rimraf } from "rimraf";
-import fs$1 from "node:fs/promises";
 import * as clack from "@clack/prompts";
 import { addDependency, detectPackageManager, removeDependency } from "nypm";
+import fs$1 from "node:fs/promises";
 import { builders, generateCode, loadFile, parseModule, writeFile } from "magicast";
 import * as cjson from "comment-json";
-//#region src/plugin/registry.ts
+import { generateToStdout } from "@usage-spec/commander";
+//#region src/errors/plugin-api-version.ts
+/** Thrown when a configured plugin targets an apiVersion the kernel doesn't support. */
+var PluginApiVersionError = class extends Error {
+	constructor(pluginName, got) {
+		super(`Plugin '${pluginName}' targets apiVersion ${got}, but this kernel supports only apiVersion 1.`);
+	}
+};
+//#endregion
+//#region src/lib/plugin/directory.ts
+const PLUGINS_DIRECTORY = {
+	ts: {
+		pkg: "@rrlab/ts-plugin",
+		name: "ts",
+		capabilities: ["typecheck"]
+	},
+	biome: {
+		pkg: "@rrlab/biome-plugin",
+		name: "biome",
+		capabilities: [
+			"format",
+			"jscheck",
+			"lint"
+		]
+	},
+	oxc: {
+		pkg: "@rrlab/oxc-plugin",
+		name: "oxc",
+		capabilities: [
+			"format",
+			"lint",
+			"jscheck",
+			"typecheck"
+		]
+	},
+	tsdown: {
+		pkg: "@rrlab/tsdown-plugin",
+		name: "tsdown",
+		capabilities: ["pack"]
+	}
+};
+function allPluginNames() {
+	return Object.keys(PLUGINS_DIRECTORY);
+}
+function isPluginName(name) {
+	return Object.hasOwn(PLUGINS_DIRECTORY, name);
+}
+function providersOf(capability) {
+	return Object.values(PLUGINS_DIRECTORY).filter((info) => {
+		return info.capabilities.includes(capability);
+	});
+}
+//#endregion
+//#region src/errors/missing-plugin.ts
+var MissingPluginError = class extends Error {
+	constructor(capability) {
+		const plugins = providersOf(capability);
+		const pkgList = plugins.map((it) => it.pkg).join(", ");
+		const addList = plugins.map((it) => `rr plugins add ${it.name}`).join(" | ");
+		super(`No plugin provides the '${capability}' capability.` + (pkgList ? `\n  Install one of: ${pkgList}.` : "") + (addList ? `\n  Try: ${addList}.` : ""));
+	}
+};
+//#endregion
+//#region src/lib/plugin/errors.ts
+/**
+* Thrown by `PluginRegistry.get` when more than one plugin provides the same
+* capability. The message is load-bearing for the "ambiguity → user narrows
+* config" UX (decision 003) — `registry.test.ts` asserts the plugin names appear.
+*/
+var MultipleProvidersError = class extends Error {
+	constructor(kind, pluginNames) {
+		const names = pluginNames.join(", ");
+		const example = pluginNames.map((name) => `${name}({ only: ['${kind}'] })`).join(" or ");
+		super(`Multiple plugins provide capability '${kind}': ${names}. Narrow each plugin's capabilities in run-run.config.ts using the 'only' option — e.g. ${example}.`);
+	}
+};
+//#endregion
+//#region src/lib/plugin/registry.ts
 var PluginRegistry = class {
 	#entries = [];
-	register(plugin, capabilities) {
+	register(plugin, services) {
 		this.#entries.push({
 			plugin,
-			capabilities
+			services
 		});
 	}
-	get(kind) {
-		const providers = this.#providersOf(kind);
-		const [first, ...rest] = providers;
-		if (!first) return void 0;
-		if (rest.length > 0) {
-			const names = providers.map(({ plugin }) => plugin.name).join(", ");
-			const example = providers.map(({ plugin }) => `${plugin.name}({ only: ['${kind}'] })`).join(" or ");
-			throw new Error(`Multiple plugins provide capability '${kind}': ${names}. Narrow each plugin's capabilities in run-run.config.ts using the 'only' option — e.g. ${example}.`);
-		}
-		return first.impl;
+	getServiceOrThrow(capability) {
+		const provider = this.providerOf(capability);
+		if (!provider) throw new MissingPluginError(capability);
+		return provider.service;
 	}
-	providersOf(kind) {
-		return this.#providersOf(kind).map(({ plugin, impl }) => ({
-			name: plugin.name,
-			impl
-		}));
+	getService(capability) {
+		return this.providerOf(capability)?.service;
 	}
-	plugins() {
-		return this.#entries.map(({ plugin }) => plugin);
+	getAllServices() {
+		const seen = /* @__PURE__ */ new Set();
+		for (const { services } of this.#entries) for (const service of Object.values(services)) if (service) seen.add(service);
+		return [...seen];
 	}
-	#providersOf(kind) {
-		const out = [];
-		for (const { plugin, capabilities } of this.#entries) {
-			const impl = capabilities[kind];
-			if (impl != null) out.push({
+	providersOf(capability) {
+		const providers = [];
+		for (const { plugin, services } of this.#entries) {
+			const service = services[capability];
+			if (service) providers.push({
 				plugin,
-				impl
+				service
 			});
 		}
-		return out;
+		return providers;
+	}
+	providerOf(capability) {
+		const providers = this.providersOf(capability);
+		const [first, ...rest] = providers;
+		if (!first) return;
+		if (rest.length > 0) throw new MultipleProvidersError(capability, providers.map(({ plugin }) => plugin.name));
+		return first;
 	}
 };
 //#endregion
@@ -75,14 +153,17 @@ var ConfigService = class {
 	}
 	async load() {
 		const debug = logger.subdebug("load-config");
+		const start = performance.now();
 		const searchResult = await this.#searcher.search();
+		const loadMs = performance.now() - start;
 		if (!searchResult || searchResult?.isEmpty) {
 			debug("loaded default config: %O", DEFAULT_CONFIG);
 			return {
 				config: DEFAULT_CONFIG,
 				meta: {
 					isDefault: true,
-					filepath: void 0
+					filepath: void 0,
+					loadMs
 				}
 			};
 		}
@@ -93,89 +174,124 @@ var ConfigService = class {
 			config,
 			meta: {
 				isDefault: false,
-				filepath: searchResult.filepath
+				filepath: searchResult.filepath,
+				loadMs
 			}
 		};
 	}
 };
 //#endregion
-//#region src/services/ctx.ts
-async function createContext(binDir) {
-	const debug = logger.subdebug("create-context");
-	const binPath = fs.realpathSync(binDir);
-	debug("bin path:", binPath);
-	debug("process cwd:", process.cwd());
-	const [appPkg, binPkg] = await Promise.all([createPkg(cwd), createPkg(binPath)]);
-	if (!binPkg) throw new Error("Could not find bin package.json");
-	if (!appPkg) throw new Error("Could not find app package.json");
-	debug("app pkg info: %O", appPkg.info());
-	debug("bin pkg info: %O", binPkg.info());
-	const shell = createShellService();
-	debug("shell service options: %O", shell.options);
-	const config = await new ConfigService().load();
-	const registry = new PluginRegistry();
-	const pluginContext = {
-		shell,
-		logger,
-		appPkg,
-		binPkg,
-		cwd
-	};
-	for (const plugin of config.config.plugins ?? []) {
-		const got = plugin.apiVersion;
-		if (got !== 1) throw new Error(`Plugin '${plugin.name}' targets apiVersion ${got}, but this kernel supports only apiVersion 1.`);
-		debug("registering plugin: %s", plugin.name);
-		const capabilities = await plugin.capabilities(pluginContext);
-		registry.register(plugin, capabilities);
+//#region src/services/static-checker.ts
+var StaticCheckService = class {
+	#linter;
+	#formatter;
+	get ui() {
+		return `${this.#linter.ui} + ${this.#formatter.ui}`;
 	}
-	return {
-		appPkg,
-		binPkg,
-		shell,
-		config,
-		registry
-	};
-}
+	constructor(linter, formatter) {
+		this.#linter = linter;
+		this.#formatter = formatter;
+	}
+	async check(options) {
+		const lintReport = await this.#linter.lint(options);
+		const formatReport = await this.#formatter.format(options);
+		return this.#mergeReports([{
+			ui: this.#linter.ui,
+			report: lintReport
+		}, {
+			ui: this.#formatter.ui,
+			report: formatReport
+		}]);
+	}
+	async doctor() {
+		const [lintRes, fmtRes] = await Promise.all([this.#linter.doctor(), this.#formatter.doctor()]);
+		return this.#mergeReports([{
+			ui: this.#linter.ui,
+			report: lintRes
+		}, {
+			ui: this.#formatter.ui,
+			report: fmtRes
+		}]);
+	}
+	#mergeReports(parts) {
+		const sections = parts.filter((part) => part.report.output.trim()).map((part) => `${part.ui}:\n${part.report.output}`).join("\n\n");
+		return {
+			ok: parts.every((part) => part.report.ok),
+			output: sections
+		};
+	}
+};
 //#endregion
-//#region src/program/missing-plugin.ts
-const SUGGESTIONS = {
-	lint: [
-		"biome",
-		"oxc",
-		"eslint"
-	],
-	format: ["biome", "oxc"],
-	jsc: ["biome"],
-	tsc: ["ts"],
-	pack: ["tsdown"]
+//#region src/services/plugin-services.ts
+var PluginServices = class {
+	#registry;
+	constructor(registry) {
+		this.#registry = registry;
+	}
+	getAllServices() {
+		return this.#registry.getAllServices();
+	}
+	providerOf(capability) {
+		return this.#registry.providerOf(capability);
+	}
+	getServiceOrThrow(capability) {
+		return this.#registry.getServiceOrThrow(capability);
+	}
+	getJsChecker() {
+		const checker = this.#registry.getService("jscheck");
+		if (checker) return checker;
+		const linter = this.#registry.getService("lint");
+		const formatter = this.#registry.getService("format");
+		if (linter && formatter) return new StaticCheckService(linter, formatter);
+		throw new MissingPluginError("jscheck");
+	}
 };
-function missingPluginError(kind) {
-	const aliases = SUGGESTIONS[kind] ?? [];
-	const officialList = aliases.map((a) => `@rrlab/${a}-plugin`).join(", ");
-	const addList = aliases.map((a) => `rr plugins add ${a}`).join(" | ");
-	return /* @__PURE__ */ new Error(`No plugin provides the '${kind}' capability.` + (officialList ? `\n  Install one of: ${officialList}.` : "") + (addList ? `\n  Try: ${addList}.` : ""));
-}
 //#endregion
-//#region src/program/board.ts
-/** `<command> (<tool>)`, deduped to just `<command>` when the tool's binary is the command itself (e.g. `tsc`). */
-function commandTool(command, provider) {
-	return provider.bin === command ? command : `${command} (${provider.ui})`;
-}
-function pkgName(appPkg) {
-	return appPkg.packageJson.name ?? basename(appPkg.dirPath);
-}
-/** The canonical single-target row label, `<command> (<tool>) · <package>`, so every command reads alike. */
-function targetLabel(command, provider, appPkg) {
-	return `${commandTool(command, provider)} ${palette.dim(`· ${pkgName(appPkg)}`)}`;
-}
-/**
-* The canonical fan-out section title, `<command> (<tool>) · <n> <unit>`. The
-* tool is omitted when the fan-out spans several tools (`rr doctor` → `doctor ·
-* 3 tools`), since the rows then carry the per-tool name.
-*/
-function fanoutTitle(command, provider, count, unit) {
-	return `${provider ? commandTool(command, provider) : command} · ${count} ${unit}`;
-}
+//#region src/services/context.ts
+var ContextService = class {
+	#binDir;
+	constructor(binDir) {
+		this.#binDir = binDir;
+	}
+	async getContext() {
+		const debug = logger.subdebug("create-context");
+		const binPath = fs.realpathSync(this.#binDir);
+		debug("bin path:", binPath);
+		debug("process cwd:", process.cwd());
+		const [appPkg, binPkg] = await Promise.all([createPkg(cwd), createPkg(binPath)]);
+		if (!binPkg) throw new Error("Could not find bin package.json");
+		if (!appPkg) throw new Error("Could not find app package.json");
+		debug("app pkg info: %O", appPkg.info());
+		debug("bin pkg info: %O", binPkg.info());
+		const shell = createShellService();
+		debug("shell service options: %O", shell.options);
+		const config = await new ConfigService().load();
+		const registry = new PluginRegistry();
+		const pluginContext = {
+			shell,
+			logger,
+			appPkg,
+			binPkg,
+			cwd
+		};
+		for (const plugin of config.config.plugins ?? []) {
+			const got = plugin.apiVersion;
+			if (got !== 1) throw new PluginApiVersionError(plugin.name, got);
+			debug("registering plugin: %s", plugin.name);
+			const services = await plugin.services(pluginContext);
+			registry.register(plugin, services);
+		}
+		return {
+			appPkg,
+			binPkg,
+			shell,
+			config,
+			plugins: new PluginServices(registry)
+		};
+	}
+};
+//#endregion
+//#region src/render/board.ts
 /** Bridges a check-family verb (returns a `RunReport`) to a board row, its `output` becoming the flushed detail. */
 function reportTask(label, run) {
 	return {
@@ -210,105 +326,233 @@ async function runBoard(tasks, options = {}) {
 	if (sink) sink.push(result);
 	return result;
 }
+//#endregion
+//#region src/render/labels.ts
+/** `<command> (<tool>)` — the verb plus the `ui` of the tool that backs it (e.g. `lint (biome)`, `tsc (tsc)`). */
+function commandTool(command, provider) {
+	return `${command} (${provider.ui})`;
+}
+function pkgName(appPkg) {
+	return appPkg.packageJson.name ?? basename(appPkg.dirPath);
+}
+/** The canonical single-target row label, `<command> (<tool>) · <package>`, so every command reads alike. */
+function targetLabel(command, provider, appPkg) {
+	return `${commandTool(command, provider)} ${palette.dim(`· ${pkgName(appPkg)}`)}`;
+}
 /**
-* The shared action body for a single-provider tool command (lint, format, jsc,
-* pack): require the provider, run its verb as one board row labelled
-* `<name> (<tool>) · <pkg>`, and aggregate the exit code. Commands that fan out
-* (tsc) or compose siblings (check) call `runBoard` directly instead.
+* The canonical fan-out section title, `<command> (<tool>) · <n> <unit>`. The
+* tool is omitted when the fan-out spans several tools (`rr doctor` → `doctor ·
+* 3 tools`), since the rows then carry the per-tool name.
 */
-async function runToolCommand(ctx, spec) {
-	const { provider } = spec;
-	if (!provider) throw missingPluginError(spec.kind);
-	if (!(await runBoard([reportTask(targetLabel(spec.name, provider, ctx.appPkg), () => spec.run(provider))])).ok) process.exitCode = 1;
+function fanoutTitle(command, provider, count, unit) {
+	return `${provider ? commandTool(command, provider) : command} · ${count} ${unit}`;
 }
 //#endregion
-//#region src/program/ui.ts
-const CREDITS_TEXT = `\nAcknowledgment:
-- kcd-scripts: for main inspiration
-  ${palette.link("https://github.com/kentcdodds/kcd-scripts")}
-
-- peruvian news: in honor to Run Run
-  ${palette.link("https://es.wikipedia.org/wiki/Run_Run")}`;
-const rimrafColor = colorize("#7C7270");
-const runRunColor = colorize("#E8722A");
-const usageColor = colorize("#24C55E");
+//#region src/actions/run-tool.ts
 /**
-* Labels used by kernel-internal commands. Plugin-owned tools (biome, oxc,
-* tsdown, tsc) define their own colored labels inside each plugin's
-* `src/index.ts`.
+* The shared action for a single-provider tool command (lint, format, jsc,
+* pack): run the provider's verb as one board row labelled `<name> (<tool>) ·
+* <pkg>`, and aggregate the exit code. The command resolves the provider and
+* throws MissingPluginError when it's absent, so the provider is required here.
+* Commands that fan out (tsc) or compose siblings (check) drive the board themselves.
 */
-const TOOL_LABELS = {
-	RIMRAF: rimrafColor("rimraf"),
-	RUN_RUN: runRunColor("run-run"),
-	USAGE: usageColor("usage")
-};
-const IS_USAGE_MODE = process.env.RR_USAGE_MODE === "1";
-/**
-* Renders the parenthesised backend hint that follows a command's summary,
-* e.g. `pack a ts library 📦 (tsdown)` or `… (not configured)` when no plugin
-* provides the capability.
-*
-* Returns an empty string when `RR_USAGE_MODE=1` is set (the kernel's `bin`
-* script exports it during `rr --usage`) so the KDL spec stays free of
-* per-environment state — the active plugin set is a property of the host
-* project, not of the CLI surface.
-*/
-function pluginAnnotation(provider) {
-	if (IS_USAGE_MODE) return "";
-	return provider ? ` (${provider.ui})` : " (not configured)";
+async function runToolAction({ ctx, name, provider, run }) {
+	if (!(await runBoard([reportTask(targetLabel(name, provider, ctx.appPkg), () => run(provider))])).ok) process.exitCode = 1;
 }
-function getBannerText(version) {
-	return `
-${runRunColor(`
-██████╗ ██╗   ██╗███╗   ██╗      ██████╗ ██╗   ██╗███╗   ██╗
-██╔══██╗██║   ██║████╗  ██║      ██╔══██╗██║   ██║████╗  ██║
-██████╔╝██║   ██║██╔██╗ ██║█████╗██████╔╝██║   ██║██╔██╗ ██║
-██╔══██╗██║   ██║██║╚██╗██║╚════╝██╔══██╗██║   ██║██║╚██╗██║
-██║  ██║╚██████╔╝██║ ╚████║      ██║  ██║╚██████╔╝██║ ╚████║
-╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝      ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ${text.version(version)}
-`.trim())}
-
-🦊 ${palette.italic(palette.muted("The CLI toolbox for"))} ${text.vland}\n`.trimStart();
+//#endregion
+//#region src/actions/jsc.ts
+function jscAction({ ctx, checker, options }) {
+	return runToolAction({
+		ctx,
+		name: "jsc",
+		provider: checker,
+		run: (p) => p.check(options)
+	});
+}
+//#endregion
+//#region src/actions/tsc.ts
+const getPreScript = (scripts) => scripts?.pretsc ?? scripts?.pretypecheck;
+async function tscAction({ ctx, tsc }) {
+	const { appPkg, shell } = ctx;
+	const isTsProject = (dir) => appPkg.hasFile("tsconfig.json", dir);
+	const typecheckTask = (label, dir, scripts) => reportTask(label, async () => {
+		const preScript = getPreScript(scripts);
+		if (preScript) {
+			const pre = await shell.at(dir).runCaptured(preScript, [], {
+				shell: true,
+				throwOnError: false
+			});
+			if ((pre.exitCode ?? 0) !== 0) return {
+				ok: false,
+				output: `pre-script \`${preScript}\` failed\n${[pre.stdout, pre.stderr].map((s) => s?.trim()).filter(Boolean).join("\n")}`
+			};
+		}
+		return tsc.check({ cwd: dir });
+	});
+	if (!appPkg.isMonorepo()) {
+		if (!isTsProject(appPkg.dirPath)) {
+			logger.info("No tsconfig.json found, skipping typecheck");
+			return;
+		}
+		if (!(await runBoard([typecheckTask(targetLabel("tsc", tsc, appPkg), appPkg.dirPath, appPkg.packageJson.scripts)])).ok) process.exitCode = 1;
+		return;
+	}
+	const tsProjects = (await appPkg.getWorkspaceProjects()).filter((project) => isTsProject(project.rootDir));
+	if (!tsProjects.length) {
+		logger.warn("No ts projects found in the monorepo, skipping typecheck");
+		return;
+	}
+	if (!(await runBoard(tsProjects.map((p) => typecheckTask(p.manifest.name ?? p.rootDir, p.rootDir, p.manifest.scripts)), { title: fanoutTitle("tsc", tsc, tsProjects.length, "packages") })).ok) process.exitCode = 1;
+}
+//#endregion
+//#region src/render/lines.ts
+var Lines = class {
+	#lines;
+	constructor() {
+		this.#lines = [];
+	}
+	isEmpty() {
+		return !this.#lines.length;
+	}
+	add(data, padStart = 0) {
+		if (Array.isArray(data)) data.forEach((it) => {
+			this.#append(it, padStart);
+		});
+		else this.#append(data, padStart);
+		return this;
+	}
+	addTable(rows, columns, opts = {}) {
+		const { gap = 3, padStart = 0 } = opts;
+		const sized = columns.map((col) => ({
+			...col,
+			width: Math.max(...rows.map((row) => stringWidth(String(row[col.key]))))
+		}));
+		const sep = this.#sep(gap);
+		rows.forEach((row) => {
+			const cells = sized.map((col) => {
+				const raw = String(row[col.key]);
+				return this.#padCell(raw, col.width, col.align ?? "left");
+			});
+			this.#append(cells.join(sep), padStart);
+		});
+		return this;
+	}
+	newline(prepend = false) {
+		if (prepend) this.#prepend("");
+		else this.#append("");
+		return this;
+	}
+	printStdout() {
+		process.stdout.write(`${this.render()}\n`);
+	}
+	render() {
+		return this.#lines.join("\n");
+	}
+	#padCell(str, width, align) {
+		const diff = Math.max(0, width - stringWidth(str));
+		const fill = this.#sep(diff);
+		return align === "right" ? `${fill}${str}` : `${str}${fill}`;
+	}
+	#append(str, padStart = 0) {
+		if (padStart > 0) this.#lines.push(`${this.#sep(padStart)}${str}`);
+		else this.#lines.push(str);
+	}
+	#prepend(str, padStart = 0) {
+		if (padStart > 0) this.#lines.unshift(`${this.#sep(padStart)}${str}`);
+		else this.#lines.unshift(str);
+	}
+	#sep(count) {
+		return " ".repeat(count);
+	}
+};
+//#endregion
+//#region src/program/base.ts
+var Cmd = class Cmd extends Command {
+	capabilities = [];
+	addCapabilities(capabilities) {
+		this.capabilities = capabilities;
+		return this;
+	}
+	addHelpTextAfter(ctx) {
+		super.addHelpText("after", () => {
+			const seeAlso = /* @__PURE__ */ new Set();
+			this.parent?.commands?.forEach((cmd) => {
+				if (cmd instanceof Cmd) {
+					if (cmd.capabilities.some((it) => this.capabilities.includes(it)) && cmd.name() !== this.name()) seeAlso.add(cmd.name());
+				}
+			});
+			const poweredBy = /* @__PURE__ */ new Set();
+			this.capabilities.forEach((it) => {
+				const provider = ctx.plugins.providerOf(it);
+				if (provider) poweredBy.add(provider.plugin.ui);
+			});
+			const lines = new Lines();
+			if (seeAlso.size > 0) lines.add("See also:").add([...seeAlso].map((it) => `- ${it}`), 2);
+			if (seeAlso.size > 0 && poweredBy.size > 0) lines.newline();
+			if (poweredBy.size > 0) lines.add("Powered by:").add([...poweredBy].map((it) => `- ${it}`), 2);
+			if (lines.isEmpty()) return "";
+			return lines.newline(true).render();
+		});
+		return this;
+	}
+	addDoctorCommand(actionFn) {
+		const cmd = new Command("doctor").summary("check if the underlying tool is working correctly").action(actionFn);
+		return this.addCommand(cmd);
+	}
+};
+function createCommand(name) {
+	return new Cmd(name);
 }
 //#endregion
 //#region src/program/commands/check.ts
 /**
-* `rr check` runs `jsc` then `tsc`. Rather than keep a parallel action
-* registry, it reuses commander's command tree: it finds each sibling on
-* `this.parent` and runs it via `parseAsync([])`, which applies the sibling's
-* own option defaults. (`this` is the running command inside a non-arrow
-* action — see cli/CLAUDE.md.)
+* `rr check` — runs jsc then tsc. Rather than dispatch through commander's
+* command tree, it calls the same `jscAction`/`tscAction` directly — each
+* wrapped in its own `runCheckSections` scope so failures are attributed by
+* section name. A blank line separates the sections; `checkVerdict` is the
+* final overall line.
 */
 function createCheckCommand(ctx) {
-	return createCommand("check").summary(`run static checks${checkAnnotation(ctx)}`).description("Runs `rr jsc` then `rr tsc` in-process, each as its own section. Aggregates their exit codes — non-zero when either subcommand fails.").action(async function checkAction() {
-		const program = this.parent;
-		if (!program) throw new Error("`rr check` requires the parent program to dispatch sibling subcommands.");
+	return createCommand("check").addCapabilities([
+		"lint",
+		"format",
+		"jscheck",
+		"typecheck"
+	]).summary("run static checks").description("Runs `rr jsc` then `rr tsc` in-process, each as its own section. Aggregates their exit codes — non-zero when either subcommand fails.").action(async () => {
+		const sections = [{
+			name: "jsc",
+			run: () => jscAction({
+				ctx,
+				checker: ctx.plugins.getJsChecker(),
+				options: {}
+			})
+		}, {
+			name: "tsc",
+			run: () => tscAction({
+				ctx,
+				tsc: ctx.plugins.getServiceOrThrow("typecheck")
+			})
+		}];
 		const start = Date.now();
 		const failed = [];
 		let rendered = false;
-		for (const name of ["jsc", "tsc"]) {
-			const cmd = findCommand(program, name);
-			if (!cmd) {
-				logger.error(`rr check: subcommand "${name}" is not registered.`);
-				failed.push(name);
-				continue;
-			}
+		for (const section of sections) {
 			if (rendered) process.stderr.write("\n");
 			let threw = false;
 			const results = await runCheckSections(async () => {
 				try {
-					await cmd.parseAsync([], { from: "user" });
+					await section.run();
 				} catch (reason) {
-					logger.error(`rr check (${name}): ${reason instanceof Error ? reason.message : String(reason)}`);
+					logger.error(`rr check (${section.name}): ${reason instanceof Error ? reason.message : String(reason)}`);
 					threw = true;
 				}
 			});
-			if (threw || results.some((r) => !r.ok)) failed.push(name);
+			if (threw || results.some((r) => !r.ok)) failed.push(section.name);
 			rendered = true;
 		}
 		process.stderr.write(`\n${checkVerdict(failed, Date.now() - start)}\n`);
 		if (failed.length > 0) process.exitCode = 1;
-	});
+	}).addHelpTextAfter(ctx);
 }
 function checkVerdict(failed, ms) {
 	const elapsed = palette.dim(ms < 1e3 ? `${Math.round(ms)}ms` : `${(ms / 1e3).toFixed(1)}s`);
@@ -316,57 +560,41 @@ function checkVerdict(failed, ms) {
 	if (failed.length > 0) return `${palette.error("✖")} check failed${sep}${[...new Set(failed)].join(", ")}${sep}${elapsed}`;
 	return `${palette.success("✔")} check passed${sep}${elapsed}`;
 }
-function findCommand(program, name) {
-	return program.commands.find((c) => c.name() === name || c.aliases().includes(name));
-}
-/**
-* Flattens the underlying tool labels of `jsc` + `tsc` for the help summary —
-* e.g. `(biome, oxlint)`, deduped, not `(biome + biome, oxlint)`. Falls back to
-* the standard `(not configured)` when neither sibling has a provider.
-*/
-function checkAnnotation(ctx) {
-	const directJsc = ctx.registry.get("jsc");
-	const linter = ctx.registry.get("lint");
-	const formatter = ctx.registry.get("format");
-	const tsc = ctx.registry.get("tsc");
-	const labels = [];
-	if (directJsc) labels.push(directJsc.ui);
-	else {
-		if (linter) labels.push(linter.ui);
-		if (formatter) labels.push(formatter.ui);
+//#endregion
+//#region src/actions/clean.ts
+async function cleanAction({ options }) {
+	async function run(paths, globOptions) {
+		if (options.dryRun) {
+			const toDelete = await glob(paths, globOptions);
+			logger.info("Paths that would be deleted: %O", toDelete);
+			return;
+		}
+		logger.start("Clean started");
+		await rimraf(paths, { glob: globOptions });
+		logger.success("Clean completed");
 	}
-	if (tsc) labels.push(tsc.ui);
-	if (labels.length === 0) return pluginAnnotation(void 0);
-	return pluginAnnotation({ ui: [...new Set(labels)].join(", ") });
+	const BUILD_PATHS = ["**/dist"];
+	const ALL_DIRTY_PATHS = [
+		"**/.turbo",
+		"**/node_modules",
+		"pnpm-lock.yaml",
+		"bun.lock",
+		...BUILD_PATHS
+	];
+	if (options.onlyDist) await run(BUILD_PATHS, {
+		cwd,
+		ignore: ["**/node_modules/**"]
+	});
+	else await run(ALL_DIRTY_PATHS, { cwd });
 }
 //#endregion
 //#region src/program/commands/clean.ts
+const rimrafColor = colorize("#7C7270");
 function createCleanCommand() {
-	return createCommand("clean").summary(`delete dirty files (${TOOL_LABELS.RIMRAF})`).description("Deletes generated files and folders such as 'dist', 'node_modules', and lock files to ensure a clean state.").option("--only-dist", "delete 'dist' folders only").option("--dry-run", "outputs the paths that would be deleted").action(async function cleanCommandAction(options) {
-		async function run(paths, globOptions) {
-			if (options.dryRun) {
-				const toDelete = await glob(paths, globOptions);
-				logger.info("Paths that would be deleted: %O", toDelete);
-				return;
-			}
-			logger.start("Clean started");
-			await rimraf(paths, { glob: globOptions });
-			logger.success("Clean completed");
-		}
-		const BUILD_PATHS = ["**/dist"];
-		const ALL_DIRTY_PATHS = [
-			"**/.turbo",
-			"**/node_modules",
-			"pnpm-lock.yaml",
-			"bun.lock",
-			...BUILD_PATHS
-		];
-		if (options.onlyDist) await run(BUILD_PATHS, {
-			cwd,
-			ignore: ["**/node_modules/**"]
-		});
-		else await run(ALL_DIRTY_PATHS, { cwd });
-	}).addHelpText("afterAll", `\nUnder the hood, this command uses ${TOOL_LABELS.RIMRAF} to delete dirty folders or files.`);
+	return createCommand("clean").summary("delete dirty files").description("Deletes generated files and folders such as 'dist', 'node_modules', and lock files to ensure a clean state.").option("--only-dist", "delete 'dist' folders only").option("--dry-run", "outputs the paths that would be deleted").action((options) => cleanAction({ options: {
+		onlyDist: Boolean(options.onlyDist),
+		dryRun: Boolean(options.dryRun)
+	} })).addHelpText("after", `\nUnder the hood, this command uses ${rimrafColor("rimraf")} to delete dirty folders or files.`);
 }
 //#endregion
 //#region src/program/commands/completion.ts
@@ -375,187 +603,298 @@ const SHELLS = [
 	"zsh",
 	"fish"
 ];
+const usageColor = colorize("#24C55E");
 function createCompletionCommand() {
-	return createCommand("completion").summary(`print shell completion script (${TOOL_LABELS.USAGE})`).description(`Prints a shell completion script for rr. Add to your shell rc file:
+	return createCommand("completion").summary(`print shell completion script`).description(`Prints a shell completion script for rr. Add to your shell rc file:
 
   bash: eval "$(rr completion bash)"
   zsh:  eval "$(rr completion zsh)"
-  fish: rr completion fish | source`).addArgument(new Argument("<shell>", `target shell`).choices(SHELLS)).addHelpText("afterAll", `\nUnder the hood, this command uses ${TOOL_LABELS.USAGE} (https://usage.jdx.dev).
+  fish: rr completion fish | source`).addArgument(new Argument("<shell>", `target shell`).choices(SHELLS)).addHelpText("afterAll", `\nUnder the hood, this command uses ${usageColor("usage")} (https://usage.jdx.dev).
 Make sure to have it installed and available in your PATH.`);
 }
 //#endregion
+//#region src/services/plugin-meta.ts
+const require = createRequire(import.meta.url);
+/** Resolves the installed version of a plugin's npm package from the host's `node_modules`. */
+function readPluginMeta(pkgName, fromDir) {
+	const result = { pkgName };
+	const manifest = readPackageJson(pkgName, fromDir);
+	if (!manifest) return result;
+	result.pluginVersion = typeof manifest.version === "string" ? manifest.version : void 0;
+	return result;
+}
+function readPackageJson(pkgName, fromDir) {
+	try {
+		const resolved = require.resolve(`${pkgName}/package.json`, { paths: [fromDir] });
+		return JSON.parse(fs.readFileSync(resolved, "utf8"));
+	} catch {
+		try {
+			const found = findPackageJsonUpwards(require.resolve(pkgName, { paths: [fromDir] }), pkgName);
+			return found ? JSON.parse(fs.readFileSync(found, "utf8")) : void 0;
+		} catch {
+			return;
+		}
+	}
+}
+function findPackageJsonUpwards(file, pkgName) {
+	let dir = path.dirname(file);
+	for (let i = 0; i < 12; i += 1) {
+		const candidate = path.join(dir, "package.json");
+		if (fs.existsSync(candidate)) try {
+			if (JSON.parse(fs.readFileSync(candidate, "utf8")).name === pkgName) return candidate;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+}
+//#endregion
+//#region src/render/plugin-view.ts
+/**
+* The single source of truth for how a plugin renders across the UI. The two
+* plugin screens (the root help footer and `rr config`) stay separate
+* composing functions, but every painted plugin cell comes from here — so a
+* color/dot/version-format change happens in one place.
+*/
+/** Path of `abs` relative to the host project root, or `abs` itself when already there. */
+function relPath(ctx, abs) {
+	const rel = path.relative(ctx.appPkg.dirPath, abs);
+	return rel === "" ? abs : rel;
+}
+/** The plugin names present in the host's `run-run.config`, in config-file order. */
+function configuredPlugins(ctx) {
+	return ctx.config.config.plugins ?? [];
+}
+/**
+* Partition every plugin name into installed (configured) vs available (not yet
+* configured), preserving `PLUGINS_DIRECTORY` declaration order — the order the
+* root footer renders both rows in.
+*/
+function partitionPlugins(ctx) {
+	const configured = configuredPlugins(ctx);
+	const present = Object.fromEntries(configured.map((it) => [it.name, true]));
+	return {
+		available: allPluginNames().filter((name) => !present[name]),
+		installed: configured
+	};
+}
+/** `● <name>` — a configured plugin in the root footer. */
+function installedCell(plugin) {
+	return `${plugin.color("●")} ${plugin.name}`;
+}
+/** `○ <name>` (dim) — an available-but-unconfigured plugin in the root footer. */
+function availableCell(label) {
+	return `${palette.dim("○")} ${palette.dim(label)}`;
+}
+/** The npm package for a (kernel-trusted) plugin name — official lookup, else the `@rrlab/<name>-plugin` convention. */
+function pkgOf(name) {
+	return isPluginName(name) ? PLUGINS_DIRECTORY[name].pkg : `@rrlab/${name}-plugin`;
+}
+/** The plugin's npm package name (dim) — `rr config` table column. */
+function pkgCell(name) {
+	return palette.dim(pkgOf(name));
+}
+/** `v<plugin-version>` or `v?` — `rr config` table column. */
+function pluginVersionCell(name, appDir) {
+	const { pluginVersion } = readPluginMeta(pkgOf(name), appDir);
+	return pluginVersion ? palette.success(`v${pluginVersion}`) : palette.dim("v?");
+}
+//#endregion
+//#region src/ui/theme.ts
+const SEP = `  ${palette.dim("·")}  `;
+const runRunColor = colorize("#E8722A");
+//#endregion
+//#region src/actions/config.ts
+function configAction({ ctx }) {
+	const { meta } = ctx.config;
+	const lines = new Lines();
+	lines.add(palette.bold("Source:")).add(meta.filepath ? `${relPath(ctx, meta.filepath)}${SEP}${palette.dim(`loaded in ${Math.round(meta.loadMs)}ms`)}` : `${palette.dim("(no run-run.config — using defaults)")}`, 2).add(palette.bold("\nPlugins:"));
+	const plugins = configuredPlugins(ctx);
+	if (!plugins.length) lines.add(palette.dim("No plugins configured. Try `rr plugins add <name>`."), 2);
+	else {
+		const rows = plugins.map((p) => ({
+			name: `${p.color("●")} ${p.name}`,
+			pkg: pkgCell(p.name),
+			version: pluginVersionCell(p.name, ctx.appPkg.dirPath)
+		}));
+		lines.addTable(rows, [
+			{ key: "name" },
+			{
+				key: "pkg",
+				align: "right"
+			},
+			{ key: "version" }
+		], { padStart: 2 });
+	}
+	lines.printStdout();
+}
+//#endregion
 //#region src/program/commands/config.ts
 function createConfigCommand(ctx) {
-	return createCommand("config").summary("display the current config").description("Displays the current configuration settings, including their source file path if available.").action(async function configAction() {
-		const { config, meta } = ctx.config;
-		console.log(palette.muted("Config:"));
-		console.log(config);
-		console.log(palette.muted(`Loaded from ${meta.filepath ? palette.link(meta.filepath) : "n/a"}`));
-	});
+	return createCommand("config").summary("display the current config").description("Displays the current configuration settings, including their source file path and the plugins it registers.").action(() => configAction({ ctx }));
 }
 //#endregion
-//#region src/plugin/types.ts
-const PLUGIN_KINDS = [
-	"lint",
-	"format",
-	"jsc",
-	"tsc",
-	"pack"
-];
-//#endregion
-//#region src/program/commands/doctor.ts
+//#region src/actions/doctor.ts
 /**
-* Subcommand factory used by every plugin-backed command (lint, format, jsc,
-* tsc, pack) to expose a `doctor` subcommand that verifies the underlying tool
-* is wired correctly. Renders the canonical `doctor (<tool>) · <pkg>` row like
-* every other single-target command — `doctor()` returns a `RunReport`.
+* A single tool's `doctor` as one board row (`doctor (<tool>) · <pkg>`) — used
+* by the `doctor` subcommand each plugin-backed command exposes.
 */
-function createDoctorSubcommand(service, appPkg) {
-	return createCommand("doctor").summary("check if the underlying tool is working correctly").action(async function doctorAction() {
-		if (!(await runBoard([reportTask(targetLabel("doctor", service, appPkg), () => service.doctor())])).ok) process.exitCode = 1;
-	});
+async function doctorOneAction({ ctx, service }) {
+	if (!(await runBoard([reportTask(targetLabel("doctor", service, ctx.appPkg), () => service.doctor())])).ok) process.exitCode = 1;
 }
 /**
 * Top-level `rr doctor` — runs the `doctor()` of every distinct capability
 * impl registered with the kernel. Distinct because a single plugin (e.g.
-* biome) often serves multiple kinds (`lint`, `format`, `jsc`) from the same
+* biome) often serves multiple kinds (`lint`, `format`, `jscheck`) from the same
 * `BiomeService` instance; running its doctor three times is wasteful.
 */
+async function doctorAction({ ctx }) {
+	const services = ctx.plugins.getAllServices();
+	if (services.length === 0) {
+		logger.info("No plugins configured. Use `rr plugins add <name>` to install one.");
+		return;
+	}
+	if (!(await runBoard(services.map((svc) => reportTask(svc.ui, () => svc.doctor())), { title: fanoutTitle("doctor", void 0, services.length, "tools") })).ok) process.exitCode = 1;
+}
+//#endregion
+//#region src/program/commands/doctor.ts
 function createDoctorCommand(ctx) {
-	return createCommand("doctor").summary("run all plugin doctors").description("Runs the `doctor()` of every configured plugin capability. Each plugin reports ok / not working. The exit code is non-zero if any reports not working.").action(async () => {
-		const services = collectDistinctDoctors(ctx);
-		if (services.length === 0) {
-			logger.info("No plugins configured. Use `rr plugins add <name>` to install one.");
-			return;
-		}
-		if (!(await runBoard(services.map((svc) => reportTask(svc.ui, () => svc.doctor())), { title: fanoutTitle("doctor", void 0, services.length, "tools") })).ok) process.exitCode = 1;
-	});
+	return createCommand("doctor").summary("run all plugin doctors").description("Runs the `doctor()` of every configured plugin capability. Each plugin reports ok / not working. The exit code is non-zero if any reports not working.").action(() => doctorAction({ ctx }));
 }
-function collectDistinctDoctors(ctx) {
-	const seen = /* @__PURE__ */ new Set();
-	for (const kind of PLUGIN_KINDS) for (const { impl } of ctx.registry.providersOf(kind)) seen.add(impl);
-	return [...seen];
+//#endregion
+//#region src/actions/format.ts
+function formatAction({ ctx, formatter, options }) {
+	return runToolAction({
+		ctx,
+		name: "format",
+		provider: formatter,
+		run: (p) => p.format(options)
+	});
 }
 //#endregion
 //#region src/program/commands/format.ts
 function createFormatCommand(ctx) {
-	const formatter = ctx.registry.get("format");
-	const cmd = createCommand("format").summary(`check & fix format errors${pluginAnnotation(formatter)}`).description("Checks the code for formatting issues and optionally fixes them, ensuring it adheres to the defined style standards.").option("--fix", "format all the code");
-	if (formatter) cmd.addCommand(createDoctorSubcommand(formatter, ctx.appPkg));
-	cmd.action(async (options = {}) => {
-		await runToolCommand(ctx, {
-			name: "format",
-			kind: "format",
-			provider: formatter,
-			run: (p) => p.format(options)
+	return createCommand("format").addCapabilities(["format"]).summary("check & fix format issues").description("Checks the code for formatting issues and optionally fixes them, ensuring it adheres to the defined style standards.").option("--fix", "format all the code").action(async (options = {}) => {
+		await formatAction({
+			ctx,
+			formatter: ctx.plugins.getServiceOrThrow("format"),
+			options: { fix: options.fix }
+		});
+	}).addHelpTextAfter(ctx).addDoctorCommand(async () => {
+		await doctorOneAction({
+			ctx,
+			service: ctx.plugins.getServiceOrThrow("format")
 		});
 	});
-	if (formatter) cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${formatter.ui} CLI to format the code.`);
-	return cmd;
-}
-//#endregion
-//#region src/program/composed-jsc.ts
-/**
-* Synthesises the `jsc` capability (`StaticChecker & Doctor`) by composing a
-* separately-registered linter and formatter — used when the plugin set
-* provides `lint` and `format` independently (e.g. oxc) but no plugin claims
-* `jsc`. Runs lint then format sequentially (parallel stdout interleaves badly)
-* and merges their reports into one board row.
-*/
-function composedJscProvider(linter, formatter) {
-	return {
-		bin: `${linter.bin}+${formatter.bin}`,
-		ui: `${linter.ui} + ${formatter.ui}`,
-		async check({ fix }) {
-			const lintReport = await linter.lint({ fix });
-			const formatReport = await formatter.format({ fix });
-			return mergeReports([{
-				ui: linter.ui,
-				report: lintReport
-			}, {
-				ui: formatter.ui,
-				report: formatReport
-			}]);
-		},
-		async doctor() {
-			const [lintRes, fmtRes] = await Promise.all([linter.doctor(), formatter.doctor()]);
-			return mergeReports([{
-				ui: linter.ui,
-				report: lintRes
-			}, {
-				ui: formatter.ui,
-				report: fmtRes
-			}]);
-		}
-	};
-}
-/**
-* Folds the lint + format reports into one so the composed `jsc` renders as a
-* single board row: ok only when both passed, with each tool's output kept
-* under its own header so the flushed detail stays attributable.
-*/
-function mergeReports(parts) {
-	const sections = parts.filter((part) => part.report.output.trim()).map((part) => `${part.ui}:\n${part.report.output}`).join("\n\n");
-	return {
-		ok: parts.every((part) => part.report.ok),
-		output: sections
-	};
 }
 //#endregion
 //#region src/program/commands/jscheck.ts
 function createJsCheckCommand(ctx) {
-	const direct = ctx.registry.get("jsc");
-	const linter = ctx.registry.get("lint");
-	const formatter = ctx.registry.get("format");
-	const checker = direct ?? (linter && formatter ? composedJscProvider(linter, formatter) : void 0);
-	const cmd = createCommand("jsc").alias("jscheck").summary(`check format and lint${pluginAnnotation(checker)}`).description("Checks the code for formatting and linting issues, ensuring it adheres to the defined style and quality standards.").option("--fix", "try to fix issues automatically").option("--fix-staged", "try to fix staged files only");
-	if (checker) cmd.addCommand(createDoctorSubcommand(checker, ctx.appPkg));
-	cmd.action(async (options = {}) => {
-		await runToolCommand(ctx, {
-			name: "jsc",
-			kind: "jsc",
-			provider: checker,
-			run: (p) => p.check(options)
+	return createCommand("jsc").alias("jscheck").addCapabilities([
+		"lint",
+		"format",
+		"jscheck"
+	]).summary("check format and lint").description("Checks the code for formatting and linting issues, ensuring it adheres to the defined style and quality standards.").option("--fix", "try to fix issues automatically").option("--fix-staged", "try to fix staged files only").action(async (options = {}) => {
+		await jscAction({
+			ctx,
+			checker: ctx.plugins.getJsChecker(),
+			options: {
+				fix: options.fix,
+				fixStaged: options.fixStaged
+			}
+		});
+	}).addHelpTextAfter(ctx).addDoctorCommand(async () => {
+		await doctorOneAction({
+			ctx,
+			service: ctx.plugins.getJsChecker()
 		});
 	});
-	if (checker) cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${checker.ui} CLI to check the code.`);
-	return cmd;
+}
+//#endregion
+//#region src/actions/lint.ts
+function lintAction({ ctx, linter, options }) {
+	return runToolAction({
+		ctx,
+		name: "lint",
+		provider: linter,
+		run: (p) => p.lint(options)
+	});
 }
 //#endregion
 //#region src/program/commands/lint.ts
 function createLintCommand(ctx) {
-	const linter = ctx.registry.get("lint");
-	const cmd = createCommand("lint").summary(`check & fix lint errors${pluginAnnotation(linter)}`).description("Checks the code for linting issues and optionally fixes them, ensuring it adheres to the defined quality standards.").option("-c, --check", "check if the code is valid", true).option("--fix", "try to fix all the code");
-	if (linter) cmd.addCommand(createDoctorSubcommand(linter, ctx.appPkg));
-	cmd.action(async (options = {}) => {
-		await runToolCommand(ctx, {
-			name: "lint",
-			kind: "lint",
-			provider: linter,
-			run: (p) => p.lint(options)
+	return createCommand("lint").addCapabilities(["lint"]).summary("check & fix lint issues").description("Checks the code for linting issues and optionally fixes them, ensuring it adheres to the defined quality standards.").option("-c, --check", "check if the code is valid", true).option("--fix", "try to fix all the code").action(async (options = {}) => {
+		await lintAction({
+			ctx,
+			linter: ctx.plugins.getServiceOrThrow("lint"),
+			options: { fix: options.fix }
+		});
+	}).addHelpTextAfter(ctx).addDoctorCommand(async () => {
+		await doctorOneAction({
+			ctx,
+			service: ctx.plugins.getServiceOrThrow("lint")
 		});
 	});
-	if (linter) cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${linter.ui} CLI to lint the code.`);
-	return cmd;
+}
+//#endregion
+//#region src/actions/pack.ts
+function packAction({ ctx, packer }) {
+	return runToolAction({
+		ctx,
+		name: "pack",
+		provider: packer,
+		run: (p) => p.pack()
+	});
 }
 //#endregion
 //#region src/program/commands/pack.ts
 function createPackCommand(ctx) {
-	const packer = ctx.registry.get("pack");
-	const cmd = createCommand("pack").summary(`pack a ts library${pluginAnnotation(packer)}`).description("Compiles TypeScript code into JavaScript and generates type declaration files, packaging the library for distribution.");
-	if (packer) {
-		cmd.addCommand(createDoctorSubcommand(packer, ctx.appPkg));
-		cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${packer.ui} CLI to pack the project.`);
-	}
-	cmd.action(async () => {
-		await runToolCommand(ctx, {
-			name: "pack",
-			kind: "pack",
-			provider: packer,
-			run: (p) => p.pack()
+	return createCommand("pack").addCapabilities(["pack"]).summary("pack a ts library").description("Compiles TypeScript code into JavaScript and generates type declaration files, packaging the library for distribution.").action(async () => {
+		await packAction({
+			ctx,
+			packer: ctx.plugins.getServiceOrThrow("pack")
+		});
+	}).addHelpTextAfter(ctx).addDoctorCommand(async () => {
+		await doctorOneAction({
+			ctx,
+			service: ctx.plugins.getServiceOrThrow("pack")
 		});
 	});
-	return cmd;
+}
+//#endregion
+//#region src/errors/invalid-plugin-module.ts
+/** Thrown when an installed plugin package doesn't export a default factory function. */
+var InvalidPluginModuleError = class extends Error {
+	constructor(pkgName) {
+		super(`Plugin '${pkgName}' did not export a default factory function.`);
+	}
+};
+//#endregion
+//#region src/errors/unknown-plugin.ts
+var UnknownPluginError = class extends Error {
+	constructor(name) {
+		super(`'${name}' is invalid for argument 'name'. Allowed choices are ${allPluginNames().join(", ")}.`);
+	}
+};
+//#endregion
+//#region src/render/steps.ts
+/**
+* Runs `fn` under a clack spinner: the message stays on success, and is
+* suffixed with `— failed` (error level) before the error re-throws. Used by
+* the interactive `plugins add/remove` flows to frame each install/uninstall
+* step.
+*/
+async function withSpinner(message, fn) {
+	const sp = clack.spinner();
+	sp.start(message);
+	try {
+		const result = await fn();
+		sp.stop(message);
+		return result;
+	} catch (err) {
+		sp.stop(`${message} — failed`, 1);
+		throw err;
+	}
 }
 //#endregion
 //#region src/services/config-ast.ts
@@ -797,40 +1136,97 @@ function deepEqual(a, b) {
 	return JSON.stringify(a) === JSON.stringify(b);
 }
 //#endregion
-//#region src/services/plugins-registry.ts
+//#region src/services/file-ops.ts
 /**
-* Map from short aliases the user types (`rr plugins add ts`) to the
-* full npm package name and the canonical local binding the plugin file
-* is imported as inside `run-run.config.{ts,mts}`.
-*
-* Third-party plugins use their full package name; the binding is derived
-* by stripping a `@scope/<tool>-plugin` (or `@scope/<tool>-run-run-plugin`)
-* suffix and using the tool segment.
+* Applies a single declarative `FileOp` under `cwd`. `force` overrides the
+* `create` overwrite guard. Idempotent for `delete` (absent file is a no-op)
+* and skips edits when the target file is missing.
 */
-const OFFICIAL_PLUGINS = {
-	ts: {
-		pkg: "@rrlab/ts-plugin",
-		exportName: "ts"
-	},
-	eslint: {
-		pkg: "@rrlab/eslint-plugin",
-		exportName: "eslint"
-	},
-	biome: {
-		pkg: "@rrlab/biome-plugin",
-		exportName: "biome"
-	},
-	oxc: {
-		pkg: "@rrlab/oxc-plugin",
-		exportName: "oxc"
-	},
-	tsdown: {
-		pkg: "@rrlab/tsdown-plugin",
-		exportName: "tsdown"
+async function applyFileOp(cwd, op, force) {
+	const abs = path.join(cwd, op.path);
+	if (op.kind === "create") {
+		const exists = await pathExists(abs);
+		if (exists && !op.overwrite && !force) return {
+			op: "create",
+			path: op.path,
+			status: "skipped-exists"
+		};
+		await fs$1.mkdir(path.dirname(abs), { recursive: true });
+		await fs$1.writeFile(abs, op.content, "utf8");
+		return {
+			op: "create",
+			path: op.path,
+			status: exists ? "overwritten" : "created"
+		};
+	}
+	if (op.kind === "edit-json") {
+		if (!await pathExists(abs)) return {
+			op: "edit",
+			path: op.path,
+			status: "missing"
+		};
+		const source = await fs$1.readFile(abs, "utf8");
+		const next = applyJsonEdits(source, op.edits);
+		if (next === source) return {
+			op: "edit",
+			path: op.path,
+			status: "unchanged"
+		};
+		await fs$1.writeFile(abs, next, "utf8");
+		return {
+			op: "edit",
+			path: op.path,
+			status: "edited"
+		};
+	}
+	if (op.kind === "edit-text") {
+		if (!await pathExists(abs)) return {
+			op: "edit",
+			path: op.path,
+			status: "missing"
+		};
+		const source = await fs$1.readFile(abs, "utf8");
+		const next = op.edit(source);
+		if (next === source) return {
+			op: "edit",
+			path: op.path,
+			status: "unchanged"
+		};
+		await fs$1.writeFile(abs, next, "utf8");
+		return {
+			op: "edit",
+			path: op.path,
+			status: "edited"
+		};
+	}
+	if (!await pathExists(abs)) return {
+		op: "delete",
+		path: op.path,
+		status: "absent"
+	};
+	await fs$1.unlink(abs);
+	return {
+		op: "delete",
+		path: op.path,
+		status: "deleted"
+	};
+}
+/** A one-line, side-effect-free description of a `FileOp` for the remove plan. */
+function describeFileOp(op) {
+	switch (op.kind) {
+		case "create": return `${op.overwrite ? "Overwrite" : "Create"} ${op.path}`;
+		case "edit-json": return `Edit ${op.path} (${op.edits.length} change${op.edits.length === 1 ? "" : "s"})`;
+		case "edit-text": return `Edit ${op.path}`;
+		case "delete": return `Delete ${op.path}`;
+	}
+}
+async function pathExists(p) {
+	try {
+		await fs$1.access(p);
+		return true;
+	} catch {
+		return false;
 	}
-};
-function officialAliases() {
-	return Object.keys(OFFICIAL_PLUGINS);
 }
 //#endregion
 //#region src/services/prompts.ts
@@ -923,42 +1319,69 @@ function pmNeedsRootFlag(pm) {
 	return false;
 }
 //#endregion
-//#region src/program/commands/plugins.ts
-function createPluginsCommand(ctx) {
-	const cmd = createCommand("plugins").description("manage @rrlab plugins");
-	cmd.command("list").description("list plugins configured in run-run.config.{ts,mts}").action(() => runList(ctx));
-	cmd.command("add").description("install and configure an @rrlab plugin").addArgument(new Argument("<name>", `plugin alias (${officialAliases().join("|")}), optionally with @<spec> e.g. biome@pr-226`)).option("--force", "re-run install even if the plugin is already configured").option("--yes", "skip prompts and use defaults (non-interactive)").option("--dry-run", "show what would happen, without applying changes").action((name, opts) => runAdd(ctx, name, opts));
-	cmd.command("remove").description("uninstall an @rrlab plugin and undo its config files + deps").addArgument(new Argument("<name>", "plugin alias to remove").choices(officialAliases())).option("--yes", "skip the confirmation prompt").option("--dry-run", "print the plan without applying changes").action((name, opts) => runRemove(ctx, name, opts));
-	return cmd;
+//#region src/actions/plugins/shared.ts
+function hasInPackageJson(ctx, pkgName) {
+	const pkg = ctx.appPkg.packageJson;
+	return pkgName in {
+		...pkg.dependencies,
+		...pkg.devDependencies,
+		...pkg.peerDependencies
+	};
 }
-async function runList(ctx) {
-	const ast = new ConfigAstService();
-	const loaded = await ast.load(ctx.appPkg.dirPath);
-	if (loaded.isNew) {
-		logger.info("No run-run.config.{ts,mts} found. Use `rr plugins add <name>` to start.");
-		return;
-	}
-	const plugins = ast.listPlugins(loaded.mod);
-	const rel = path.relative(ctx.appPkg.dirPath, loaded.filepath) || loaded.filepath;
-	if (plugins.length === 0) {
-		logger.info(`${rel}: no plugins configured.`);
-		return;
+/** Renders a `FileOpOutcome` (from the `file-ops` engine) as the matching clack log line. */
+function reportFileOp(outcome) {
+	switch (outcome.status) {
+		case "skipped-exists":
+			clack.log.warn(`Skipping ${outcome.path} — already exists. Use --force to overwrite.`);
+			return;
+		case "created":
+			clack.log.success(`Created ${outcome.path}`);
+			return;
+		case "overwritten":
+			clack.log.success(`Overwrote ${outcome.path}`);
+			return;
+		case "missing":
+			clack.log.warn(`Skipping ${outcome.path} — file does not exist.`);
+			return;
+		case "edited":
+			clack.log.success(`Edited ${outcome.path}`);
+			return;
+		case "unchanged":
+			clack.log.info(`No changes for ${outcome.path}.`);
+			return;
+		case "deleted":
+			clack.log.success(`Deleted ${outcome.path}`);
+			return;
+		case "absent": return;
 	}
-	logger.info(`${rel}:`);
-	for (const name of plugins) logger.info(`  - ${name}`);
 }
-async function runAdd(ctx, name, opts) {
-	const { alias, spec } = parseAliasSpec(name);
-	if (!(alias in OFFICIAL_PLUGINS)) throw new Error(`'${alias}' is invalid for argument 'name'. Allowed choices are ${officialAliases().join(", ")}.`);
-	const { pkg: pkgName, exportName } = OFFICIAL_PLUGINS[alias];
+//#endregion
+//#region src/actions/plugins/add.ts
+/** Split a `<name>[@<spec>]` input (e.g. `biome@pr-226`) into the plugin name and optional spec. */
+function parsePluginSpec(input) {
+	const at = input.indexOf("@");
+	if (at <= 0) return { name: input };
+	return {
+		name: input.slice(0, at),
+		spec: input.slice(at + 1)
+	};
+}
+/** A dist-tag starts with a letter and contains only safe identifier chars. Version ranges (`^0.1`, `>=1`, `0.0.2`, `*`) don't match. */
+function isDistTag(spec) {
+	return /^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(spec) && spec !== "latest";
+}
+async function addPluginAction({ ctx, args, options }) {
+	const { name: pluginName, spec } = parsePluginSpec(args.name);
+	if (!(pluginName in PLUGINS_DIRECTORY)) throw new UnknownPluginError(pluginName);
+	const { pkg: pkgName, name: binding } = PLUGINS_DIRECTORY[pluginName];
 	const tag = spec && isDistTag(spec) ? spec : void 0;
 	const installSpec = spec ? `${pkgName}@${spec}` : pkgName;
-	clack.intro(` rr plugins add ${name} `);
+	clack.intro(` rr plugins add ${args.name} `);
 	const inPkg = hasInPackageJson(ctx, pkgName);
 	const ast = new ConfigAstService();
 	const loaded = await ast.load(ctx.appPkg.dirPath);
-	const inConfig = !loaded.isNew && ast.hasPlugin(loaded.mod, exportName);
-	if (inPkg && inConfig && !opts.force && !spec) {
+	const inConfig = !loaded.isNew && ast.hasPlugin(loaded.mod, binding);
+	if (inPkg && inConfig && !options.force && !spec) {
 		clack.log.warn(`${pkgName} is already installed and configured. Use --force to re-run install.`);
 		clack.outro("Nothing to do.");
 		return;
@@ -968,12 +1391,12 @@ async function runAdd(ctx, name, opts) {
 	const workspace = toNypmWorkspace(wsChoice);
 	const targetLabel = describeWorkspaceChoice(wsChoice);
 	const willInstall = !inPkg || !!spec;
-	if (opts.dryRun) {
+	if (options.dryRun) {
 		const presence = willInstall ? inPkg ? " (already present, will be updated to this spec)" : "" : " (already present, skipped)";
 		clack.log.info(`Would: install ${installSpec} as a devDependency in ${targetLabel}${presence}.`);
 		if (!inConfig) {
 			const rel = path.relative(ctx.appPkg.dirPath, loaded.filepath) || loaded.filepath;
-			clack.log.info(`Would: add ${exportName}() to ${rel} (plugins[]).`);
+			clack.log.info(`Would: add ${binding}() to ${rel} (plugins[]).`);
 		}
 		clack.log.info("Would: run the plugin's install() hook (if any) to fetch peer deps and create files.");
 		clack.outro("Dry run complete.");
@@ -994,7 +1417,7 @@ async function runAdd(ctx, name, opts) {
 	let installResult;
 	try {
 		const factory = (await import(pkgName)).default;
-		if (typeof factory !== "function") throw new Error(`Plugin '${pkgName}' did not export a default factory function.`);
+		if (typeof factory !== "function") throw new InvalidPluginModuleError(pkgName);
 		const plugin = factory();
 		if (plugin.install) {
 			const installCtx = {
@@ -1003,9 +1426,9 @@ async function runAdd(ctx, name, opts) {
 				appPkg: ctx.appPkg,
 				prompts: createClackPrompts(),
 				flags: {
-					force: !!opts.force,
-					yes: !!opts.yes,
-					nonInteractive: !!opts.yes
+					force: !!options.force,
+					yes: !!options.yes,
+					nonInteractive: !!options.yes
 				},
 				release: new ReleaseService(tag)
 			};
@@ -1033,24 +1456,45 @@ async function runAdd(ctx, name, opts) {
 			});
 		});
 	}
-	for (const op of installResult?.files ?? []) await applyFileOp(ctx.appPkg.dirPath, op, !!opts.force);
+	for (const op of installResult?.files ?? []) reportFileOp(await applyFileOp(ctx.appPkg.dirPath, op, !!options.force));
 	if (!inConfig) {
 		ast.addPlugin(loaded.mod, {
-			exportName,
+			exportName: binding,
 			pkgName
 		});
 		await ast.save(loaded);
 		const rel = path.relative(ctx.appPkg.dirPath, loaded.filepath) || loaded.filepath;
 		clack.log.success(`Updated ${rel}`);
 	}
-	clack.outro(`Plugin '${alias}' ready 🎉`);
+	clack.outro(`Plugin '${pluginName}' ready 🎉`);
 }
-async function runRemove(ctx, alias, opts) {
-	const { pkg: pkgName, exportName } = OFFICIAL_PLUGINS[alias];
-	clack.intro(` rr plugins remove ${alias} `);
+//#endregion
+//#region src/actions/plugins/list.ts
+async function listPluginsAction({ ctx }) {
 	const ast = new ConfigAstService();
 	const loaded = await ast.load(ctx.appPkg.dirPath);
-	const inConfig = !loaded.isNew && ast.hasPlugin(loaded.mod, exportName);
+	if (loaded.isNew) {
+		logger.info("No run-run.config.{ts,mts} found. Use `rr plugins add <name>` to start.");
+		return;
+	}
+	const plugins = ast.listPlugins(loaded.mod);
+	const rel = path.relative(ctx.appPkg.dirPath, loaded.filepath) || loaded.filepath;
+	if (plugins.length === 0) {
+		logger.info(`${rel}: no plugins configured.`);
+		return;
+	}
+	logger.info(`${rel}:`);
+	for (const name of plugins) logger.info(`  - ${name}`);
+}
+//#endregion
+//#region src/actions/plugins/remove.ts
+async function removePluginAction({ ctx, args, options }) {
+	const { name } = args;
+	const { pkg: pkgName, name: binding } = PLUGINS_DIRECTORY[name];
+	clack.intro(` rr plugins remove ${name} `);
+	const ast = new ConfigAstService();
+	const loaded = await ast.load(ctx.appPkg.dirPath);
+	const inConfig = !loaded.isNew && ast.hasPlugin(loaded.mod, binding);
 	let uninstallResult;
 	if (hasInPackageJson(ctx, pkgName)) try {
 		const factory = (await import(pkgName)).default;
@@ -1061,8 +1505,8 @@ async function runRemove(ctx, alias, opts) {
 			appPkg: ctx.appPkg,
 			prompts: createClackPrompts(),
 			flags: {
-				yes: !!opts.yes,
-				nonInteractive: !!opts.yes
+				yes: !!options.yes,
+				nonInteractive: !!options.yes
 			}
 		});
 	} catch (err) {
@@ -1071,7 +1515,7 @@ async function runRemove(ctx, alias, opts) {
 	const planSteps = [];
 	if (inConfig) {
 		const rel = path.relative(ctx.appPkg.dirPath, loaded.filepath) || loaded.filepath;
-		planSteps.push(`Remove ${exportName}() from ${rel}`);
+		planSteps.push(`Remove ${binding}() from ${rel}`);
 	}
 	for (const op of uninstallResult?.files ?? []) planSteps.push(describeFileOp(op));
 	const depsToRemove = (uninstallResult?.removeDependencies ?? []).filter((dep) => hasInPackageJson(ctx, dep));
@@ -1081,16 +1525,16 @@ async function runRemove(ctx, alias, opts) {
 	const workspace = toNypmWorkspace(wsChoice);
 	if (depsToRemove.length > 0) planSteps.push(`Uninstall: ${depsToRemove.join(", ")} (from ${describeWorkspaceChoice(wsChoice)})`);
 	if (planSteps.length === 0) {
-		clack.log.warn(`Plugin '${alias}' is not installed nor configured.`);
+		clack.log.warn(`Plugin '${name}' is not installed nor configured.`);
 		clack.outro("Nothing to do.");
 		return;
 	}
 	clack.log.message(`Plan:\n${planSteps.map((s) => `  • ${s}`).join("\n")}`);
-	if (opts.dryRun) {
+	if (options.dryRun) {
 		clack.outro("Dry run complete.");
 		return;
 	}
-	if (!opts.yes) {
+	if (!options.yes) {
 		const choice = await clack.confirm({
 			message: "Proceed?",
 			initialValue: false
@@ -1100,12 +1544,12 @@ async function runRemove(ctx, alias, opts) {
 			return;
 		}
 	}
-	for (const op of uninstallResult?.files ?? []) await applyFileOp(ctx.appPkg.dirPath, op, true);
+	for (const op of uninstallResult?.files ?? []) reportFileOp(await applyFileOp(ctx.appPkg.dirPath, op, true));
 	if (inConfig) {
-		ast.removePlugin(loaded.mod, exportName);
+		ast.removePlugin(loaded.mod, binding);
 		await ast.save(loaded);
 		const rel = path.relative(ctx.appPkg.dirPath, loaded.filepath) || loaded.filepath;
-		clack.log.success(`Removed ${exportName}() from ${rel}`);
+		clack.log.success(`Removed ${binding}() from ${rel}`);
 	}
 	for (const dep of depsToRemove) await withSpinner(`Uninstalling ${dep}`, async () => {
 		await removeDependency(dep, {
@@ -1114,166 +1558,106 @@ async function runRemove(ctx, alias, opts) {
 			workspace
 		});
 	});
-	clack.outro(`Plugin '${alias}' removed.`);
+	clack.outro(`Plugin '${name}' removed.`);
 }
-function parseAliasSpec(input) {
-	const at = input.indexOf("@");
-	if (at <= 0) return { alias: input };
-	return {
-		alias: input.slice(0, at),
-		spec: input.slice(at + 1)
-	};
+//#endregion
+//#region src/program/commands/plugins.ts
+function createPluginsCommand(ctx) {
+	const cmd = createCommand("plugins").description(`manage ${runRunColor("@rrlab")} plugins`);
+	cmd.command("list").description("list plugins configured in run-run.config.{ts,mts}").action(() => listPluginsAction({ ctx }));
+	cmd.command("add").description("install and configure an @rrlab plugin").addArgument(new Argument("<name>", `plugin alias (${allPluginNames().join("|")}), optionally with @<spec> e.g. biome@pr-226`)).option("--force", "re-run install even if the plugin is already configured").option("--yes", "skip prompts and use defaults (non-interactive)").option("--dry-run", "show what would happen, without applying changes").action((name, options) => addPluginAction({
+		ctx,
+		args: { name },
+		options
+	}));
+	cmd.command("remove").description("uninstall an @rrlab plugin and undo its config files + deps").addArgument(new Argument("<name>", "plugin alias to remove").choices(allPluginNames())).option("--yes", "skip the confirmation prompt").option("--dry-run", "print the plan without applying changes").action((name, options) => removePluginAction({
+		ctx,
+		args: { name },
+		options
+	}));
+	return cmd;
 }
-/** A dist-tag starts with a letter and contains only safe identifier chars. Version ranges (`^0.1`, `>=1`, `0.0.2`, `*`) don't match. */
-function isDistTag(spec) {
-	return /^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(spec) && spec !== "latest";
+//#endregion
+//#region src/program/commands/tscheck.ts
+function createTsCheckCommand(ctx) {
+	return createCommand("tsc").alias("tscheck").addCapabilities(["typecheck"]).summary("check types errors").description("Checks type errors, ensuring that the code adheres to the defined type constraints and helps catch potential issues before runtime.").action(async () => {
+		await tscAction({
+			ctx,
+			tsc: ctx.plugins.getServiceOrThrow("typecheck")
+		});
+	}).addHelpTextAfter(ctx).addDoctorCommand(async () => {
+		await doctorOneAction({
+			ctx,
+			service: ctx.plugins.getServiceOrThrow("typecheck")
+		});
+	});
 }
-function hasInPackageJson(ctx, pkgName) {
-	const pkg = ctx.appPkg.packageJson;
-	return pkgName in {
-		...pkg.dependencies,
-		...pkg.devDependencies,
-		...pkg.peerDependencies
-	};
+//#endregion
+//#region src/render/banner.ts
+function getBannerText(version) {
+	const UI_LOGO = runRunColor(`
+██████╗ ██╗   ██╗███╗   ██╗      ██████╗ ██╗   ██╗███╗   ██╗
+██╔══██╗██║   ██║████╗  ██║      ██╔══██╗██║   ██║████╗  ██║
+██████╔╝██║   ██║██╔██╗ ██║█████╗██████╔╝██║   ██║██╔██╗ ██║
+██╔══██╗██║   ██║██║╚██╗██║╚════╝██╔══██╗██║   ██║██║╚██╗██║
+██║  ██║╚██████╔╝██║ ╚████║      ██║  ██║╚██████╔╝██║ ╚████║
+╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝      ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ${text.version(version)}`.trimStart());
+	return new Lines().add(UI_LOGO).newline().add(`🦊 ${palette.italic(palette.dim("The CLI toolbox for"))} ${text.vland}`).newline().render();
 }
-async function withSpinner(message, fn) {
-	const sp = clack.spinner();
-	sp.start(message);
-	try {
-		const result = await fn();
-		sp.stop(message);
-		return result;
-	} catch (err) {
-		sp.stop(`${message} — failed`, 1);
-		throw err;
-	}
+//#endregion
+//#region src/render/footer.ts
+function getFooterText(ctx) {
+	const { installed, available } = partitionPlugins(ctx);
+	const installedLine = installed.map(installedCell).join("   ");
+	const availableLine = available.map(availableCell).join("   ");
+	const fromLine = ctx.config.meta.filepath ? palette.dim(`from ${relPath(ctx, ctx.config.meta.filepath)}`) : palette.dim("(no run-run.config — using defaults)");
+	const lines = new Lines();
+	lines.newline().add(palette.bold("Plugins:"));
+	if (installed.length > 0) lines.add(`${palette.bold("installed:")}  ${installedLine}${SEP}${fromLine}`, 2);
+	else lines.add(`${palette.bold("installed:")}  ${palette.dim("(none)")}${SEP}${fromLine}`, 2);
+	if (available.length > 0) lines.add(`${palette.bold("available:")}  ${availableLine}${SEP}${palette.dim("install with `rr plugins add <name>`")}`, 2);
+	return lines.render();
 }
-function describeFileOp(op) {
-	switch (op.kind) {
-		case "create": return `${op.overwrite ? "Overwrite" : "Create"} ${op.path}`;
-		case "edit-json": return `Edit ${op.path} (${op.edits.length} change${op.edits.length === 1 ? "" : "s"})`;
-		case "edit-text": return `Edit ${op.path}`;
-		case "delete": return `Delete ${op.path}`;
+//#endregion
+//#region src/program/root.ts
+var RunRunCmd = class extends Command {
+	ctx;
+	constructor(ctx) {
+		super("rr");
+		this.ctx = ctx;
+		this.#init();
 	}
-}
-async function applyFileOp(cwd, op, force) {
-	const abs = path.join(cwd, op.path);
-	if (op.kind === "create") {
-		const exists = await pathExists(abs);
-		if (exists && !op.overwrite && !force) {
-			clack.log.warn(`Skipping ${op.path} — already exists. Use --force to overwrite.`);
-			return;
-		}
-		await fs$1.mkdir(path.dirname(abs), { recursive: true });
-		await fs$1.writeFile(abs, op.content, "utf8");
-		clack.log.success(`${exists ? "Overwrote" : "Created"} ${op.path}`);
-		return;
+	async run() {
+		await this.parseAsync();
 	}
-	if (op.kind === "edit-json") {
-		if (!await pathExists(abs)) {
-			clack.log.warn(`Skipping ${op.path} — file does not exist.`);
-			return;
-		}
-		const source = await fs$1.readFile(abs, "utf8");
-		const next = applyJsonEdits(source, op.edits);
-		if (next !== source) {
-			await fs$1.writeFile(abs, next, "utf8");
-			clack.log.success(`Edited ${op.path}`);
-		} else clack.log.info(`No changes for ${op.path}.`);
-		return;
+	#init() {
+		this.enablePositionalOptions().showSuggestionAfterError(true).helpCommand(false).version(this.ctx.binPkg.version, "-v, --version", "output the version number").addHelpText("before", this.#banner()).addHelpText("after", this.#footer()).option("--about", "show credits & inspiration").option("--usage", `print KDL spec for this CLI (${palette.dim(palette.link("https://kdl.dev"))})`).on("option:about", () => this.#aboutStdout()).on("option:usage", () => this.#usageStdout(this));
 	}
-	if (op.kind === "edit-text") {
-		if (!await pathExists(abs)) {
-			clack.log.warn(`Skipping ${op.path} — file does not exist.`);
-			return;
-		}
-		const source = await fs$1.readFile(abs, "utf8");
-		const next = op.edit(source);
-		if (next !== source) {
-			await fs$1.writeFile(abs, next, "utf8");
-			clack.log.success(`Edited ${op.path}`);
-		} else clack.log.info(`No changes for ${op.path}.`);
-		return;
+	#aboutStdout() {
+		new Lines().add(this.#banner()).add(palette.bold("Inspired by:"), 2).add(`kcd-scripts — ${palette.link("https://github.com/kentcdodds/kcd-scripts")}`, 4).newline().add(palette.bold("Named in honor of:"), 2).add(`Run Run (Peruvian news segment) — ${palette.link("https://es.wikipedia.org/wiki/Run_Run")}`, 4).printStdout();
+		process.exit(0);
 	}
-	if (op.kind === "delete") {
-		if (!await pathExists(abs)) return;
-		await fs$1.unlink(abs);
-		clack.log.success(`Deleted ${op.path}`);
-		return;
+	#usageStdout(cmd) {
+		generateToStdout(cmd);
+		process.exit(0);
 	}
-}
-async function pathExists(p) {
-	try {
-		await fs$1.access(p);
-		return true;
-	} catch {
-		return false;
+	#banner() {
+		return getBannerText(this.ctx.binPkg.version);
 	}
-}
-//#endregion
-//#region src/program/commands/tscheck.ts
-const getPreScript = (scripts) => scripts?.pretsc ?? scripts?.pretypecheck;
-function createTsCheckCommand(ctx) {
-	const { appPkg, shell } = ctx;
-	const tsc = ctx.registry.get("tsc");
-	const cmd = createCommand("tsc").alias("tscheck").summary(`check typescript errors${pluginAnnotation(tsc)}`).description("Checks the TypeScript code for type errors, ensuring that the code adheres to the defined type constraints and helps catch potential issues before runtime.");
-	if (tsc) {
-		cmd.addCommand(createDoctorSubcommand(tsc, ctx.appPkg));
-		cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${tsc.ui} CLI to check the code.`);
-	}
-	cmd.action(async () => {
-		if (!tsc) throw missingPluginError("tsc");
-		const isTsProject = (dir) => appPkg.hasFile("tsconfig.json", dir);
-		const typecheckTask = (label, dir, scripts) => reportTask(label, async () => {
-			const preScript = getPreScript(scripts);
-			if (preScript) {
-				const pre = await shell.at(dir).runCaptured(preScript, [], {
-					shell: true,
-					throwOnError: false
-				});
-				if ((pre.exitCode ?? 0) !== 0) return {
-					ok: false,
-					output: `pre-script \`${preScript}\` failed\n${[pre.stdout, pre.stderr].map((s) => s?.trim()).filter(Boolean).join("\n")}`
-				};
-			}
-			return tsc.check({ cwd: dir });
-		});
-		if (!appPkg.isMonorepo()) {
-			if (!isTsProject(appPkg.dirPath)) {
-				logger.info("No tsconfig.json found, skipping typecheck");
-				return;
-			}
-			if (!(await runBoard([typecheckTask(targetLabel("tsc", tsc, appPkg), appPkg.dirPath, appPkg.packageJson.scripts)])).ok) process.exitCode = 1;
-			return;
-		}
-		const tsProjects = (await appPkg.getWorkspaceProjects()).filter((project) => isTsProject(project.rootDir));
-		if (!tsProjects.length) {
-			logger.warn("No ts projects found in the monorepo, skipping typecheck");
-			return;
-		}
-		if (!(await runBoard(tsProjects.map((p) => typecheckTask(p.manifest.name ?? p.rootDir, p.rootDir, p.manifest.scripts)), { title: fanoutTitle("tsc", tsc, tsProjects.length, "packages") })).ok) process.exitCode = 1;
-	});
-	return cmd;
-}
+	#footer() {
+		return getFooterText(this.ctx);
+	}
+};
 //#endregion
 //#region src/program/index.ts
-async function createProgram(options) {
-	const ctx = await createContext(options.binDir);
-	const version = ctx.binPkg.version;
-	return {
-		program: createCommand("rr").usage("<command...> [options...]").enablePositionalOptions().version(version, "-v, --version").addOption(new Option("--usage", `print KDL spec for this CLI (${palette.muted(palette.link("https://kdl.dev"))})`)).on("option:usage", function onUsage() {
-			generateToStdout(this);
-			process.exit(0);
-		}).addHelpText("before", getBannerText(version)).addHelpText("after", CREDITS_TEXT).addCommand(createCompletionCommand()).addCommand(createPackCommand(ctx)).addCommand(createJsCheckCommand(ctx)).addCommand(createTsCheckCommand(ctx)).addCommand(createLintCommand(ctx)).addCommand(createFormatCommand(ctx)).addCommand(createCheckCommand(ctx)).addCommand(createDoctorCommand(ctx)).addCommand(createPluginsCommand(ctx)).addCommand(createCleanCommand()).addCommand(createConfigCommand(ctx)),
-		ctx
-	};
+async function createProgram(meta) {
+	const ctx = await new ContextService(path.dirname(dirnameOf(meta))).getContext();
+	const cmd = new RunRunCmd(ctx);
+	cmd.commandsGroup("Code quality:").addCommand(createCheckCommand(ctx)).addCommand(createJsCheckCommand(ctx)).addCommand(createTsCheckCommand(ctx)).addCommand(createLintCommand(ctx)).addCommand(createFormatCommand(ctx)).commandsGroup("Build:").addCommand(createPackCommand(ctx)).commandsGroup("Maintenance:").addCommand(createCleanCommand()).addCommand(createDoctorCommand(ctx)).commandsGroup("Meta:").addCommand(createCompletionCommand()).addCommand(createPluginsCommand(ctx)).addCommand(createConfigCommand(ctx));
+	return cmd;
 }
 //#endregion
 //#region src/run.ts
-const BIN_DIR = path.dirname(dirnameOf(import.meta));
-await run(async () => {
-	const { program } = await createProgram({ binDir: BIN_DIR });
-	await program.parseAsync(process.argv, { from: "node" });
-}, logger);
+await (await createProgram(import.meta)).run();
 //#endregion
 export {};