@rrlab/cli 1.1.0 → 1.2.0

package/src/types/tool.ts

@@ -1,10 +1,3 @@
-/**
- * The outcome of a check-family tool (lint / format / static check / type
- * check) captured rather than streamed. `ok` is the tool's exit code — never a
- * guess parsed from output, since tool summaries are unstable and not uniform
- * (tsc and oxfmt emit none) — and `output` is the combined stdout+stderr (color
- * preserved), flushed verbatim under the package label. See decisions/013.
- */
 export type RunReport = {
   ok: boolean;
   output: string;
@@ -23,41 +16,35 @@ export type StaticCheckerOptions = {
   fixStaged?: boolean;
 };
 
+export type TypeCheckOptions = {
+  cwd?: string;
+};
+
 export type Doctor = {
-  ui: string;
-  /**
-   * Verifies the tool is wired correctly. Returns a `RunReport` like every
-   * other verb so the board renders it identically — `output` leads with the
-   * `$ <bin> --help` liveness command, plus the error if the bin won't run.
-   */
   doctor: () => Promise<RunReport>;
 };
 
 export type Formatter = {
-  bin: string;
-  ui: string;
+  readonly ui: string;
   format: (options: FormatOptions) => Promise<RunReport>;
 };
 
 export type Linter = {
-  bin: string;
-  ui: string;
+  readonly ui: string;
   lint: (options: LintOptions) => Promise<RunReport>;
 };
 
 export type StaticChecker = {
-  bin: string;
-  ui: string;
+  readonly ui: string;
   check: (options: StaticCheckerOptions) => Promise<RunReport>;
 };
 
-export type TypeCheckOptions = {
-  /** Where to run the type checker. Defaults to the kernel's `cwd`. */
-  cwd?: string;
-};
-
 export type TypeChecker = {
-  bin: string;
-  ui: string;
+  readonly ui: string;
   check: (options?: TypeCheckOptions) => Promise<RunReport>;
 };
+
+export type Packer = {
+  readonly ui: string;
+  pack: () => Promise<RunReport>;
+};

package/src/ui/theme.ts

@@ -0,0 +1,5 @@
+import { colorize, palette } from "@vlandoss/clibuddy";
+
+export const SEP = `  ${palette.dim("·")}  `;
+
+export const runRunColor = colorize("#E8722A");

package/dist/plugin.d.mts

@@ -1,87 +0,0 @@
-import { C as StaticChecker, D as ReleaseService, E as TypeChecker, O as ReleaseServiceOptions, S as RunReport, T as TypeCheckOptions, _ as Doctor, a as InstallFlags, b as LintOptions, c as PLUGIN_KINDS, d as PluginCapabilities, f as PluginContext, g as UninstallResult, h as UninstallFlags, i as InstallContext, l as Packer, m as UninstallContext, n as ClackPromptsSelectOption, o as InstallResult, p as PluginKind, r as FileOp, s as JsonEdit, t as ClackPrompts, u as Plugin, v as FormatOptions, w as StaticCheckerOptions, x as Linter, y as Formatter } from "./types-snfbujDH.mjs";
-import { ShellService } from "@vlandoss/clibuddy";
-
-//#region src/plugin/decide-scaffold.d.ts
-type ScaffoldDecision = "create" | "patch" | "overwrite" | "skip";
-type DecideScaffoldOptions = {
-  /** The config file label shown to the user (e.g. `"biome.json"`, `"tsdown.config.ts"`). */label: string; /** Whether the file currently exists in the app project. */
-  fileExists: boolean; /** Short description of what "patch" does, shown in the select option. */
-  patchHint: string;
-  /**
-   * What to return when the file exists and the run is unattended (`--yes` / non-interactive).
-   * - `"patch"` (default): assume the user wants to merge our config into theirs (safe for JSON we can edit).
-   * - `"skip"`: assume the user owns the file (right for TS modules we'd otherwise rewrite blindly).
-   */
-  unattendedExistingAction?: "patch" | "skip";
-};
-declare function decideScaffold(ctx: InstallContext, opts: DecideScaffoldOptions): Promise<ScaffoldDecision>;
-//#endregion
-//#region src/plugin/define-plugin.d.ts
-type Caps = Partial<PluginCapabilities>;
-type PluginDefinition<TCaps extends Caps> = {
-  name: string;
-  apiVersion: 1;
-  capabilities(ctx: PluginContext): TCaps | Promise<TCaps>;
-  install?(this: void, ctx: InstallContext): Promise<InstallResult>;
-  uninstall?(this: void, ctx: UninstallContext): Promise<UninstallResult>;
-};
-type WithOnly<TOptions, TKind extends PluginKind> = TOptions extends void ? {
-  only?: readonly TKind[];
-} : TOptions & {
-  only?: readonly TKind[];
-};
-declare function definePlugin<TCaps extends Caps, TOptions = void>(factory: (options: TOptions) => PluginDefinition<TCaps>): (options?: WithOnly<TOptions, keyof TCaps & PluginKind>) => Plugin;
-//#endregion
-//#region src/plugin/pick-preset.d.ts
-type PickPresetOptions<K extends string> = {
-  message: string;
-  presets: Record<K, {
-    label: string;
-  }>;
-  defaultPreset: K;
-};
-declare function pickPreset<K extends string>(ctx: InstallContext, opts: PickPresetOptions<K>): Promise<K>;
-//#endregion
-//#region src/plugin/tool-service.d.ts
-type ToolServiceOptions = {
-  pkg: string;
-  bin?: string;
-  ui: string;
-  shellService: ShellService;
-  /**
-   * Module URL the resolver walks up from when looking for `pkg` in
-   * `node_modules`. Plugins MUST pass their own `import.meta.url` so the
-   * binary is resolved from the plugin's own dependency graph (peer-installed
-   * by the host project), not the kernel's. Kernel-internal services pass
-   * `import.meta.url` of their own module file.
-   */
-  from: string;
-};
-type RunReportOptions = {
-  cwd?: string;
-};
-declare class ToolService {
-  #private;
-  get bin(): string;
-  get ui(): string;
-  get pkg(): string;
-  constructor({
-    pkg,
-    bin,
-    ui,
-    shellService,
-    from
-  }: ToolServiceOptions);
-  getBinDir(): Promise<string>;
-  /**
-   * Runs the tool capturing its output instead of streaming it, and reports the
-   * verdict straight from the exit code — never a guess parsed from the output.
-   * The board needs the capture to attribute each parallel run's output to its
-   * package; the non-zero exit is returned (not thrown) so every task settles
-   * and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
-   */
-  runReport(args?: string[], options?: RunReportOptions): Promise<RunReport>;
-  doctor(): Promise<RunReport>;
-}
-//#endregion
-export { type ClackPrompts, type ClackPromptsSelectOption, type DecideScaffoldOptions, type Doctor, type FileOp, type FormatOptions, type Formatter, type InstallContext, type InstallFlags, type InstallResult, type JsonEdit, type LintOptions, type Linter, PLUGIN_KINDS, type Packer, type PickPresetOptions, type Plugin, type PluginCapabilities, type PluginContext, type PluginDefinition, type PluginKind, ReleaseService, type ReleaseServiceOptions, type RunReport, type ScaffoldDecision, type StaticChecker, type StaticCheckerOptions, ToolService, type ToolServiceOptions, type TypeCheckOptions, type TypeChecker, type UninstallContext, type UninstallFlags, type UninstallResult, decideScaffold, definePlugin, pickPreset };

package/dist/plugin.mjs

@@ -1,214 +0,0 @@
-import { palette, resolvePackageBin } from "@vlandoss/clibuddy";
-//#region src/plugin/decide-scaffold.ts
-async function decideScaffold(ctx, opts) {
-	const { label, fileExists, patchHint, unattendedExistingAction = "patch" } = opts;
-	if (!fileExists) {
-		if (ctx.flags.yes || ctx.flags.nonInteractive) return "create";
-		const choice = await ctx.prompts.confirm({
-			message: `Scaffold ${label}?`,
-			initialValue: true
-		});
-		if (ctx.prompts.isCancel(choice)) throw new Error("Cancelled by user.");
-		return choice ? "create" : "skip";
-	}
-	if (ctx.flags.yes || ctx.flags.nonInteractive) return unattendedExistingAction;
-	const choice = await ctx.prompts.select({
-		message: `${label} already exists. What do you want to do?`,
-		options: [
-			{
-				value: "patch",
-				label: `Patch — ${patchHint}`
-			},
-			{
-				value: "skip",
-				label: "Skip — leave it alone"
-			},
-			{
-				value: "overwrite",
-				label: "Overwrite — replace with a fresh scaffold"
-			}
-		],
-		initialValue: "patch"
-	});
-	if (ctx.prompts.isCancel(choice)) throw new Error("Cancelled by user.");
-	return choice;
-}
-//#endregion
-//#region src/plugin/tool-service.ts
-var ToolService = class {
-	#shellService;
-	#pkg;
-	#bin;
-	#ui;
-	#from;
-	get bin() {
-		return this.#bin;
-	}
-	get ui() {
-		return this.#ui;
-	}
-	get pkg() {
-		return this.#pkg;
-	}
-	constructor({ pkg, bin, ui, shellService, from }) {
-		this.#pkg = pkg;
-		this.#bin = bin ?? pkg;
-		this.#ui = ui;
-		this.#shellService = shellService;
-		this.#from = from;
-	}
-	async getBinDir() {
-		return resolvePackageBin(this.#pkg, {
-			from: this.#from,
-			binName: this.#bin
-		});
-	}
-	/**
-	* Runs the tool capturing its output instead of streaming it, and reports the
-	* verdict straight from the exit code — never a guess parsed from the output.
-	* The board needs the capture to attribute each parallel run's output to its
-	* package; the non-zero exit is returned (not thrown) so every task settles
-	* and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
-	*/
-	async runReport(args = [], options = {}) {
-		const output = await (options.cwd ? this.#shellService.at(options.cwd) : this.#shellService).runCaptured(await this.getBinDir(), args, { throwOnError: false });
-		const header = palette.dim(`$ ${[this.#bin, ...args].join(" ")}`);
-		const body = combine(output.stdout, output.stderr);
-		return {
-			ok: output.exitCode === 0,
-			output: body ? `${header}\n${body}` : header
-		};
-	}
-	async doctor() {
-		const output = await this.#shellService.runCaptured(await this.getBinDir(), ["--help"], { throwOnError: false });
-		const ok = output.exitCode === 0;
-		const command = palette.dim(`$ ${this.#bin} --help`);
-		if (ok) return {
-			ok,
-			output: command
-		};
-		const detail = combine(output.stdout, output.stderr);
-		return {
-			ok,
-			output: detail ? `${command}\n${detail}` : command
-		};
-	}
-};
-/** Joins the non-empty, trimmed streams of a captured run. */
-function combine(stdout, stderr) {
-	return [stdout, stderr].map((stream) => stream?.trim()).filter(Boolean).join("\n");
-}
-//#endregion
-//#region src/plugin/bin-probe.ts
-async function probeBins(services, pluginName) {
-	const toolServices = services.filter((s) => s instanceof ToolService);
-	const distinct = /* @__PURE__ */ new Map();
-	for (const svc of toolServices) if (!distinct.has(svc.pkg)) distinct.set(svc.pkg, svc);
-	if (distinct.size === 0) return;
-	const probes = [...distinct.values()].map(async (svc) => {
-		try {
-			await svc.getBinDir();
-		} catch {
-			return svc.pkg;
-		}
-		return null;
-	});
-	const missing = (await Promise.all(probes)).filter((p) => p !== null);
-	if (missing.length === 0) return;
-	const pkgName = `@rrlab/${pluginName}-plugin`;
-	throw new Error(`${pkgName} requires ${missing.join(", ")} to be installed in the host project. Run: rr plugins add ${pluginName}  (or: pnpm add -D ${missing.join(" ")})`);
-}
-//#endregion
-//#region src/plugin/define-plugin.ts
-function definePlugin(factory) {
-	return (options) => {
-		const def = factory(options);
-		const only = options?.only;
-		const pkgName = `@rrlab/${def.name}-plugin`;
-		return {
-			name: def.name,
-			apiVersion: def.apiVersion,
-			install: def.install,
-			uninstall: def.uninstall,
-			async capabilities(ctx) {
-				const map = await def.capabilities(ctx);
-				await probeBins(Object.values(map), def.name);
-				if (!only) return map;
-				for (const k of only) if (!(k in map)) throw new Error(`${pkgName}: unknown capability '${k}' in 'only'. Available: ${Object.keys(map).join(", ")}.`);
-				return Object.fromEntries(only.map((k) => [k, map[k]]));
-			}
-		};
-	};
-}
-//#endregion
-//#region src/plugin/pick-preset.ts
-async function pickPreset(ctx, opts) {
-	const { message, presets, defaultPreset } = opts;
-	if (ctx.flags.yes || ctx.flags.nonInteractive) return defaultPreset;
-	const choice = await ctx.prompts.select({
-		message,
-		options: Object.entries(presets).map(([value, meta]) => ({
-			value,
-			label: meta.label
-		})),
-		initialValue: defaultPreset
-	});
-	if (ctx.prompts.isCancel(choice)) throw new Error("Cancelled by user.");
-	return choice;
-}
-//#endregion
-//#region src/plugin/types.ts
-const PLUGIN_KINDS = [
-	"lint",
-	"format",
-	"jsc",
-	"tsc",
-	"pack"
-];
-//#endregion
-//#region src/services/release.ts
-const REGISTRY = "https://registry.npmjs.org";
-const PROBE_TIMEOUT_MS = 5e3;
-/**
-* Represents the "release" the current `rr plugins add` runs against — the
-* dist-tag the user picked (default: latest), plus the logic to resolve install
-* specs for related packages under that release.
-*
-* - With no `tag`, `resolve()` always returns `"latest"` and never hits the
-*   registry.
-* - With a `tag` (e.g. `"pr-226"`), probes `<pkg>@<tag>`: returns the tag when
-*   it exists, falls back to `"latest"` otherwise so a partial preview release
-*   (where only a subset of packages got published) still installs cleanly.
-* - Per-package result is cached within the service instance.
-*/
-var ReleaseService = class {
-	tag;
-	#fetcher;
-	#cache = /* @__PURE__ */ new Map();
-	constructor(tag, { fetcher = fetch } = {}) {
-		this.tag = tag;
-		this.#fetcher = fetcher;
-	}
-	resolve(pkg) {
-		if (!this.tag || this.tag === "latest") return Promise.resolve("latest");
-		const cached = this.#cache.get(pkg);
-		if (cached) return cached;
-		const promise = this.#probe(pkg);
-		this.#cache.set(pkg, promise);
-		return promise;
-	}
-	async #probe(pkg) {
-		const tag = this.tag;
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
-		try {
-			return (await this.#fetcher(`${REGISTRY}/${pkg}/${encodeURIComponent(tag)}`, { signal: controller.signal })).ok ? tag : "latest";
-		} catch {
-			return "latest";
-		} finally {
-			clearTimeout(timeout);
-		}
-	}
-};
-//#endregion
-export { PLUGIN_KINDS, ReleaseService, ToolService, decideScaffold, definePlugin, pickPreset };

package/src/plugin/define-plugin.ts

@@ -1,54 +0,0 @@
-import { probeBins } from "./bin-probe.ts";
-import type {
-  InstallContext,
-  InstallResult,
-  Plugin,
-  PluginCapabilities,
-  PluginContext,
-  PluginKind,
-  UninstallContext,
-  UninstallResult,
-} from "./types.ts";
-
-type Caps = Partial<PluginCapabilities>;
-
-export type PluginDefinition<TCaps extends Caps> = {
-  name: string;
-  apiVersion: 1;
-  capabilities(ctx: PluginContext): TCaps | Promise<TCaps>;
-  install?(this: void, ctx: InstallContext): Promise<InstallResult>;
-  uninstall?(this: void, ctx: UninstallContext): Promise<UninstallResult>;
-};
-
-type WithOnly<TOptions, TKind extends PluginKind> = TOptions extends void
-  ? { only?: readonly TKind[] }
-  : TOptions & { only?: readonly TKind[] };
-
-export function definePlugin<TCaps extends Caps, TOptions = void>(
-  factory: (options: TOptions) => PluginDefinition<TCaps>,
-): (options?: WithOnly<TOptions, keyof TCaps & PluginKind>) => Plugin {
-  return (options) => {
-    // biome-ignore lint/suspicious/noExplicitAny: factory accepts TOptions; callers without options pass undefined
-    const def = factory(options as any);
-    const only = (options as { only?: readonly string[] } | undefined)?.only;
-    const pkgName = `@rrlab/${def.name}-plugin`;
-
-    return {
-      name: def.name,
-      apiVersion: def.apiVersion,
-      install: def.install,
-      uninstall: def.uninstall,
-      async capabilities(ctx: PluginContext): Promise<PluginCapabilities> {
-        const map = (await def.capabilities(ctx)) as PluginCapabilities;
-        await probeBins(Object.values(map), def.name);
-        if (!only) return map;
-        for (const k of only) {
-          if (!(k in map)) {
-            throw new Error(`${pkgName}: unknown capability '${k}' in 'only'. Available: ${Object.keys(map).join(", ")}.`);
-          }
-        }
-        return Object.fromEntries(only.map((k) => [k, map[k as PluginKind]])) as PluginCapabilities;
-      },
-    };
-  };
-}

package/src/plugin/registry.ts

@@ -1,48 +0,0 @@
-import type { Plugin, PluginCapabilities, PluginKind } from "./types.ts";
-
-type Entry = {
-  plugin: Plugin;
-  capabilities: PluginCapabilities;
-};
-
-export class PluginRegistry {
-  #entries: Entry[] = [];
-
-  register(plugin: Plugin, capabilities: PluginCapabilities): void {
-    this.#entries.push({ plugin, capabilities });
-  }
-
-  get<K extends PluginKind>(kind: K): NonNullable<PluginCapabilities[K]> | undefined {
-    const providers = this.#providersOf(kind);
-    const [first, ...rest] = providers;
-    if (!first) return undefined;
-    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;
-  }
-
-  providersOf<K extends PluginKind>(kind: K): Array<{ name: string; impl: NonNullable<PluginCapabilities[K]> }> {
-    return this.#providersOf(kind).map(({ plugin, impl }) => ({ name: plugin.name, impl }));
-  }
-
-  plugins(): readonly Plugin[] {
-    return this.#entries.map(({ plugin }) => plugin);
-  }
-
-  #providersOf<K extends PluginKind>(kind: K): Array<{ plugin: Plugin; impl: NonNullable<PluginCapabilities[K]> }> {
-    const out: Array<{ plugin: Plugin; impl: NonNullable<PluginCapabilities[K]> }> = [];
-    for (const { plugin, capabilities } of this.#entries) {
-      const impl = capabilities[kind];
-      if (impl != null) {
-        out.push({ plugin, impl: impl as NonNullable<PluginCapabilities[K]> });
-      }
-    }
-    return out;
-  }
-}

package/src/program/board.ts

@@ -1,86 +0,0 @@
-import { basename } from "node:path";
-import { type BoardOptions, type BoardResult, type BoardTask, type Pkg, palette, runTaskBoard } from "@vlandoss/clibuddy";
-import type { PluginKind, RunReport } from "#src/plugin/types.ts";
-import type { Context } from "#src/services/ctx.ts";
-import { missingPluginError } from "./missing-plugin.ts";
-
-export type { BoardResult, BoardTask };
-
-type Provider = { bin?: string; ui: string };
-
-/** `<command> (<tool>)`, deduped to just `<command>` when the tool's binary is the command itself (e.g. `tsc`). */
-function commandTool(command: string, provider: Provider): string {
-  return provider.bin === command ? command : `${command} (${provider.ui})`;
-}
-
-function pkgName(appPkg: Pkg): string {
-  return appPkg.packageJson.name ?? basename(appPkg.dirPath);
-}
-
-/** The canonical single-target row label, `<command> (<tool>) · <package>`, so every command reads alike. */
-export function targetLabel(command: string, provider: Provider, appPkg: Pkg): string {
-  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.
- */
-export function fanoutTitle(command: string, provider: Provider | undefined, count: number, unit: string): string {
-  const head = provider ? commandTool(command, provider) : command;
-  return `${head} · ${count} ${unit}`;
-}
-
-/** Bridges a check-family verb (returns a `RunReport`) to a board row, its `output` becoming the flushed detail. */
-export function reportTask(label: string, run: () => Promise<RunReport>): BoardTask {
-  return {
-    label,
-    async run() {
-      const report = await run();
-      return { ok: report.ok, detail: report.output };
-    },
-  };
-}
-
-// While `rr check` is dispatching, boards stay framed (to divide the sections)
-// and their results land in this collector so `check` can print one verdict.
-let collector: BoardResult[] | null = null;
-
-export async function runCheckSections(run: () => Promise<void>): Promise<BoardResult[]> {
-  const previous = collector;
-  collector = [];
-  try {
-    await run();
-    return collector;
-  } finally {
-    collector = previous;
-  }
-}
-
-/** Runs the rows on the board and returns whether every row passed. */
-export async function runBoard(tasks: BoardTask[], options: BoardOptions = {}): Promise<BoardResult> {
-  const sink = collector;
-  const result = await runTaskBoard(tasks, { ...options, frame: options.frame ?? (sink !== null || undefined) });
-  // Record into the active check collector synchronously (we already awaited the
-  // board), so it's populated before our caller's `await runBoard(...)` resolves
-  // — no microtask race with the section's own continuation.
-  if (sink) sink.push(result);
-  return result;
-}
-
-/**
- * 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.
- */
-export async function runToolCommand<P extends Provider>(
-  ctx: Context,
-  spec: { name: string; kind: PluginKind; provider: P | undefined; run: (provider: P) => Promise<RunReport> },
-): Promise<void> {
-  const { provider } = spec;
-  if (!provider) throw missingPluginError(spec.kind);
-  const result = await runBoard([reportTask(targetLabel(spec.name, provider, ctx.appPkg), () => spec.run(provider))]);
-  if (!result.ok) process.exitCode = 1;
-}

package/src/program/composed-jsc.ts

@@ -1,43 +0,0 @@
-import type { Doctor, Formatter, Linter, RunReport, StaticChecker, StaticCheckerOptions } from "#src/plugin/types.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.
- */
-export function composedJscProvider(linter: Linter & Doctor, formatter: Formatter & Doctor): StaticChecker & Doctor {
-  return {
-    bin: `${linter.bin}+${formatter.bin}`,
-    ui: `${linter.ui} + ${formatter.ui}`,
-    async check({ fix }: StaticCheckerOptions): Promise<RunReport> {
-      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(): Promise<RunReport> {
-      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: Array<{ ui: string; report: RunReport }>): RunReport {
-  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 };
-}

package/src/program/missing-plugin.ts

@@ -1,18 +0,0 @@
-const SUGGESTIONS: Record<string, string[]> = {
-  lint: ["biome", "oxc", "eslint"],
-  format: ["biome", "oxc"],
-  jsc: ["biome"],
-  tsc: ["ts"],
-  pack: ["tsdown"],
-};
-
-export function missingPluginError(kind: string): Error {
-  const aliases = SUGGESTIONS[kind] ?? [];
-  const officialList = aliases.map((a) => `@rrlab/${a}-plugin`).join(", ");
-  const addList = aliases.map((a) => `rr plugins add ${a}`).join(" | ");
-  return new Error(
-    `No plugin provides the '${kind}' capability.` +
-      (officialList ? `\n  Install one of: ${officialList}.` : "") +
-      (addList ? `\n  Try: ${addList}.` : ""),
-  );
-}

package/src/program/ui.ts

@@ -1,59 +0,0 @@
-import { colorize, palette, text } from "@vlandoss/clibuddy";
-
-export 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");
-
-/**
- * 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`.
- */
-export 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.
- */
-export function pluginAnnotation(provider: { ui: string } | undefined): string {
-  if (IS_USAGE_MODE) return "";
-  return provider ? ` (${provider.ui})` : " (not configured)";
-}
-
-// npx figlet -f "ANSI Shadow" "run-run"
-export function getBannerText(version: string) {
-  const uiLogo = runRunColor(
-    `
-██████╗ ██╗   ██╗███╗   ██╗      ██████╗ ██╗   ██╗███╗   ██╗
-██╔══██╗██║   ██║████╗  ██║      ██╔══██╗██║   ██║████╗  ██║
-██████╔╝██║   ██║██╔██╗ ██║█████╗██████╔╝██║   ██║██╔██╗ ██║
-██╔══██╗██║   ██║██║╚██╗██║╚════╝██╔══██╗██║   ██║██║╚██╗██║
-██║  ██║╚██████╔╝██║ ╚████║      ██║  ██║╚██████╔╝██║ ╚████║
-╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝      ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ${text.version(version)}
-`.trim(),
-  );
-
-  return `
-${uiLogo}
-
-🦊 ${palette.italic(palette.muted("The CLI toolbox for"))} ${text.vland}\n`.trimStart();
-}