@rrlab/cli 1.0.1-git-908d2c0.0 → 1.1.1-git-4903a88.0

package/src/program/commands/check.ts

@@ -1,57 +1,54 @@
 import { palette } from "@vlandoss/clibuddy";
-import { type Command, createCommand } from "commander";
-import { runCheckSections } from "#src/program/board.ts";
-import { pluginAnnotation } from "#src/program/ui.ts";
-import type { Context } from "#src/services/ctx.ts";
+import { jscAction } from "#src/actions/jsc.ts";
+import { tscAction } from "#src/actions/tsc.ts";
+import { runCheckSections } from "#src/render/board.ts";
+import type { ContextValue } from "#src/services/context.ts";
 import { logger } from "#src/services/logger.ts";
+import { createCommand } from "../base.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.
  */
-export function createCheckCommand(ctx: Context) {
+export function createCheckCommand(ctx: ContextValue) {
   return createCommand("check")
-    .summary(`run static checks${checkAnnotation(ctx)}`)
+    .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 function checkAction(this: Command) {
-      const program = this.parent;
-      if (!program) {
-        // Can only happen if this command is invoked detached from the root
-        // program — current bin only constructs it as a subcommand.
-        throw new Error("`rr check` requires the parent program to dispatch sibling subcommands.");
-      }
+    .action(async () => {
+      const sections: Array<{ name: string; run: () => Promise<void> }> = [
+        {
+          name: "jsc",
+          run: () => jscAction({ ctx, checker: ctx.plugins.getJsChecker(), options: {} }),
+        },
+        {
+          name: "tsc",
+          run: () => tscAction({ ctx, tsc: ctx.plugins.getServiceOrThrow("typecheck") }),
+        },
+      ];
 
       // Sequentially, not in parallel: two live boards can't animate the same
-      // terminal region at once (decision 012). Each section runs in its own
-      // `runCheckSections` scope, which frames it and returns the boards it
-      // rendered — so a failure is attributed by section name, not a fragile
-      // dispatch-vs-render index.
+      // terminal region at once (decision 012).
       const start = Date.now();
       const failed: string[] = [];
       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"); // one blank line between sections
         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;
       }
 
@@ -60,7 +57,8 @@ export function createCheckCommand(ctx: Context) {
       // of a run that failed in the section above it.
       process.stderr.write(`\n${checkVerdict(failed, Date.now() - start)}\n`);
       if (failed.length > 0) process.exitCode = 1;
-    });
+    })
+    .addHelpTextAfter(ctx);
 }
 
 function checkVerdict(failed: string[], ms: number): string {
@@ -71,32 +69,3 @@ function checkVerdict(failed: string[], ms: number): string {
   }
   return `${palette.success("✔")} check passed${sep}${elapsed}`;
 }
-
-function findCommand(program: Command, name: string): Command | undefined {
-  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: Context): string {
-  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: string[] = [];
-  if (directJsc) {
-    labels.push(directJsc.ui);
-  } else {
-    if (linter) labels.push(linter.ui);
-    if (formatter) labels.push(formatter.ui);
-  }
-  if (tsc) labels.push(tsc.ui);
-
-  if (labels.length === 0) return pluginAnnotation(undefined);
-  const distinct = [...new Set(labels)];
-  return pluginAnnotation({ ui: distinct.join(", ") });
-}

package/src/program/commands/clean.ts

@@ -1,53 +1,22 @@
-import { cwd } from "@vlandoss/clibuddy";
-import { createCommand } from "commander";
-import { type GlobOptions, glob } from "glob";
-import { rimraf } from "rimraf";
-import { logger } from "#src/services/logger.ts";
-import { TOOL_LABELS } from "../ui.ts";
+import { colorize } from "@vlandoss/clibuddy";
+import { cleanAction } from "#src/actions/clean.ts";
+import { createCommand } from "../base.ts";
 
 type Options = {
-  onlyDist: boolean;
-  dryRun: boolean;
+  onlyDist?: boolean;
+  dryRun?: boolean;
 };
 
+const rimrafColor = colorize("#7C7270");
+
 export function createCleanCommand() {
   return createCommand("clean")
-    .summary(`delete dirty files (${TOOL_LABELS.RIMRAF})`)
+    .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(async function cleanCommandAction(options: Options) {
-      async function run(paths: string[], globOptions: 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.`);
+    .action((options: 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.`);
 }

package/src/program/commands/completion.ts

@@ -1,7 +1,9 @@
-import { Argument, createCommand } from "commander";
-import { TOOL_LABELS } from "../ui.ts";
+import { colorize } from "@vlandoss/clibuddy";
+import { Argument } from "commander";
+import { createCommand } from "../base.ts";
 
 const SHELLS = ["bash", "zsh", "fish"] as const;
+const usageColor = colorize("#24C55E");
 
 // Ghost command: registered with Commander purely for discoverability — it surfaces
 // in `rr --help` and is baked into dist/cli.usage.kdl so the completion itself can
@@ -9,7 +11,7 @@ const SHELLS = ["bash", "zsh", "fish"] as const;
 // dispatcher, which intercepts `rr completion <shell>` before reaching Node.
 export function createCompletionCommand() {
   return createCommand("completion")
-    .summary(`print shell completion script (${TOOL_LABELS.USAGE})`)
+    .summary(`print shell completion script`)
     .description(
       `Prints a shell completion script for rr. Add to your shell rc file:
 
@@ -20,7 +22,7 @@ export function createCompletionCommand() {
     .addArgument(new Argument("<shell>", `target shell`).choices(SHELLS))
     .addHelpText(
       "afterAll",
-      `\nUnder the hood, this command uses ${TOOL_LABELS.USAGE} (https://usage.jdx.dev).
+      `\nUnder the hood, this command uses ${usageColor("usage")} (https://usage.jdx.dev).
 Make sure to have it installed and available in your PATH.`,
     );
 }

package/src/program/commands/config.ts

@@ -1,15 +1,10 @@
-import { palette } from "@vlandoss/clibuddy";
-import { createCommand } from "commander";
-import type { Context } from "#src/services/ctx.ts";
+import { configAction } from "#src/actions/config.ts";
+import type { ContextValue } from "#src/services/context.ts";
+import { createCommand } from "../base.ts";
 
-export function createConfigCommand(ctx: Context) {
+export function createConfigCommand(ctx: ContextValue) {
   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"}`));
-    });
+    .description("Displays the current configuration settings, including their source file path and the plugins it registers.")
+    .action(() => configAction({ ctx }));
 }

package/src/program/commands/doctor.ts

@@ -1,61 +1,12 @@
-import type { Pkg } from "@vlandoss/clibuddy";
-import { createCommand } from "commander";
-import type { Doctor } from "#src/plugin/types.ts";
-import { PLUGIN_KINDS } from "#src/plugin/types.ts";
-import type { Context } from "#src/services/ctx.ts";
-import { logger } from "#src/services/logger.ts";
-import { fanoutTitle, reportTask, runBoard, targetLabel } from "../board.ts";
+import { doctorAction } from "#src/actions/doctor.ts";
+import type { ContextValue } from "#src/services/context.ts";
+import { createCommand } from "../base.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`.
- */
-export function createDoctorSubcommand(service: Doctor, appPkg: Pkg) {
-  return createCommand("doctor")
-    .summary("check if the underlying tool is working correctly")
-    .action(async function doctorAction() {
-      const result = await runBoard([reportTask(targetLabel("doctor", service, appPkg), () => service.doctor())]);
-      if (!result.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
- * `BiomeService` instance; running its doctor three times is wasteful.
- */
-export function createDoctorCommand(ctx: Context) {
+export function createDoctorCommand(ctx: ContextValue) {
   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;
-      }
-
-      // Each tool's health check is one parallel board row — a fan-out across
-      // tools, so the rows carry the tool name and the title omits a single tool.
-      const tasks = services.map((svc) => reportTask(svc.ui, () => svc.doctor()));
-      const result = await runBoard(tasks, { title: fanoutTitle("doctor", undefined, services.length, "tools") });
-      if (!result.ok) process.exitCode = 1;
-    });
-}
-
-function collectDistinctDoctors(ctx: Context): Doctor[] {
-  const seen = new Set<Doctor>();
-  for (const kind of PLUGIN_KINDS) {
-    for (const { impl } of ctx.registry.providersOf(kind)) {
-      // Capability impls carry `doctor` via the Doctor intersection; dedup
-      // by reference so a single service that backs multiple kinds runs once.
-      seen.add(impl as unknown as Doctor);
-    }
-  }
-  return [...seen];
+    .action(() => doctorAction({ ctx }));
 }

package/src/program/commands/format.ts

@@ -1,34 +1,27 @@
-import { createCommand } from "commander";
-import type { Context } from "#src/services/ctx.ts";
-import { runToolCommand } from "../board.ts";
-import { pluginAnnotation } from "../ui.ts";
-import { createDoctorSubcommand } from "./doctor.ts";
+import { doctorOneAction } from "#src/actions/doctor.ts";
+import { formatAction } from "#src/actions/format.ts";
+import type { ContextValue } from "#src/services/context.ts";
+import { createCommand } from "../base.ts";
 
 type ActionOptions = {
   fix?: boolean;
 };
 
-export function createFormatCommand(ctx: Context) {
-  const formatter = ctx.registry.get("format");
-
-  const cmd = createCommand("format")
-    .summary(`check & fix format errors${pluginAnnotation(formatter)}`)
+export function createFormatCommand(ctx: ContextValue) {
+  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");
-
-  if (formatter) {
-    cmd.addCommand(createDoctorSubcommand(formatter, ctx.appPkg));
-  }
-
-  cmd.action(async (options: ActionOptions = {}) => {
-    await runToolCommand(ctx, { name: "format", kind: "format", provider: formatter, run: (p) => p.format(options) });
-  });
-
-  if (formatter) {
-    cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${formatter.ui} CLI to format the code.`);
-  }
-
-  return cmd;
+    .option("--fix", "format all the code")
+    .action(async (options: ActionOptions = {}) => {
+      const formatter = ctx.plugins.getServiceOrThrow("format");
+      await formatAction({ ctx, formatter, options: { fix: options.fix } });
+    })
+    .addHelpTextAfter(ctx)
+    .addDoctorCommand(async () => {
+      const formatter = ctx.plugins.getServiceOrThrow("format");
+      await doctorOneAction({ ctx, service: formatter });
+    });
 }

package/src/program/commands/jscheck.ts

@@ -1,43 +1,30 @@
-import { createCommand } from "commander";
-import type { Context } from "#src/services/ctx.ts";
-import { runToolCommand } from "../board.ts";
-import { composedJscProvider } from "../composed-jsc.ts";
-import { pluginAnnotation } from "../ui.ts";
-import { createDoctorSubcommand } from "./doctor.ts";
+import { doctorOneAction } from "#src/actions/doctor.ts";
+import { jscAction } from "#src/actions/jsc.ts";
+import type { ContextValue } from "#src/services/context.ts";
+import { createCommand } from "../base.ts";
 
 type ActionOptions = {
   fix?: boolean;
   fixStaged?: boolean;
 };
 
-export function createJsCheckCommand(ctx: Context) {
-  const direct = ctx.registry.get("jsc");
-  const linter = ctx.registry.get("lint");
-  const formatter = ctx.registry.get("format");
-  // Compose only when no plugin claims `jsc` directly and we have both
-  // building blocks separately (e.g. oxc, or eslint + prettier).
-  const checker = direct ?? (linter && formatter ? composedJscProvider(linter, formatter) : undefined);
-
-  const cmd = createCommand("jsc")
+export function createJsCheckCommand(ctx: ContextValue) {
+  return createCommand("jsc")
     .alias("jscheck")
-    .summary(`check format and lint${pluginAnnotation(checker)}`)
+    .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");
-
-  if (checker) {
-    cmd.addCommand(createDoctorSubcommand(checker, ctx.appPkg));
-  }
-
-  cmd.action(async (options: ActionOptions = {}) => {
-    await runToolCommand(ctx, { name: "jsc", kind: "jsc", provider: checker, run: (p) => p.check(options) });
-  });
-
-  if (checker) {
-    cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${checker.ui} CLI to check the code.`);
-  }
-
-  return cmd;
+    .option("--fix-staged", "try to fix staged files only")
+    .action(async (options: ActionOptions = {}) => {
+      const checker = ctx.plugins.getJsChecker();
+      await jscAction({ ctx, checker, options: { fix: options.fix, fixStaged: options.fixStaged } });
+    })
+    .addHelpTextAfter(ctx)
+    .addDoctorCommand(async () => {
+      const checker = ctx.plugins.getJsChecker();
+      await doctorOneAction({ ctx, service: checker });
+    });
 }

package/src/program/commands/lint.ts

@@ -1,36 +1,28 @@
-import { createCommand } from "commander";
-import type { Context } from "#src/services/ctx.ts";
-import { runToolCommand } from "../board.ts";
-import { pluginAnnotation } from "../ui.ts";
-import { createDoctorSubcommand } from "./doctor.ts";
+import { doctorOneAction } from "#src/actions/doctor.ts";
+import { lintAction } from "#src/actions/lint.ts";
+import type { ContextValue } from "#src/services/context.ts";
+import { createCommand } from "../base.ts";
 
 type ActionOptions = {
-  check?: boolean;
   fix?: boolean;
 };
 
-export function createLintCommand(ctx: Context) {
-  const linter = ctx.registry.get("lint");
-
-  const cmd = createCommand("lint")
-    .summary(`check & fix lint errors${pluginAnnotation(linter)}`)
+export function createLintCommand(ctx: ContextValue) {
+  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");
-
-  if (linter) {
-    cmd.addCommand(createDoctorSubcommand(linter, ctx.appPkg));
-  }
-
-  cmd.action(async (options: ActionOptions = {}) => {
-    await runToolCommand(ctx, { name: "lint", kind: "lint", provider: linter, run: (p) => p.lint(options) });
-  });
-
-  if (linter) {
-    cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${linter.ui} CLI to lint the code.`);
-  }
-
-  return cmd;
+    .option("--fix", "try to fix all the code")
+    .action(async (options: ActionOptions = {}) => {
+      const linter = ctx.plugins.getServiceOrThrow("lint");
+      await lintAction({ ctx, linter, options: { fix: options.fix } });
+    })
+    .addHelpTextAfter(ctx)
+    .addDoctorCommand(async () => {
+      const linter = ctx.plugins.getServiceOrThrow("lint");
+      await doctorOneAction({ ctx, service: linter });
+    });
 }

package/src/program/commands/pack.ts

@@ -1,26 +1,22 @@
-import { createCommand } from "commander";
-import type { Context } from "#src/services/ctx.ts";
-import { runToolCommand } from "../board.ts";
-import { pluginAnnotation } from "../ui.ts";
-import { createDoctorSubcommand } from "./doctor.ts";
+import { doctorOneAction } from "#src/actions/doctor.ts";
+import { packAction } from "#src/actions/pack.ts";
+import type { ContextValue } from "#src/services/context.ts";
+import { createCommand } from "../base.ts";
 
-export function createPackCommand(ctx: Context) {
-  const packer = ctx.registry.get("pack");
-
-  const cmd = createCommand("pack")
-    .summary(`pack a ts library${pluginAnnotation(packer)}`)
+export function createPackCommand(ctx: ContextValue) {
+  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.",
-    );
-
-  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 cmd;
+    )
+    .action(async () => {
+      const packer = ctx.plugins.getServiceOrThrow("pack");
+      await packAction({ ctx, packer });
+    })
+    .addHelpTextAfter(ctx)
+    .addDoctorCommand(async () => {
+      const packer = ctx.plugins.getServiceOrThrow("pack");
+      await doctorOneAction({ ctx, service: packer });
+    });
 }