@rrlab/cli 1.0.0 → 1.0.1-git-908d2c0.0

package/dist/{types-DnqiiIxe.d.mts → types-snfbujDH.d.mts}

@@ -27,6 +27,17 @@ declare class ReleaseService {
 }
 //#endregion
 //#region src/types/tool.d.ts
+/**
+ * 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.
+ */
+type RunReport = {
+  ok: boolean;
+  output: string;
+};
 type FormatOptions = {
   fix?: boolean;
 };
@@ -37,33 +48,29 @@ type StaticCheckerOptions = {
   fix?: boolean;
   fixStaged?: boolean;
 };
-type DoctorOutput = {
-  stdout: string;
-  stderr: string;
-  exitCode: number | undefined;
-};
-type DoctorResult = {
-  ok: boolean;
-  output: DoctorOutput;
-};
 type Doctor = {
   ui: string;
-  doctor: () => Promise<DoctorResult>;
+  /**
+   * 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>;
 };
 type Formatter = {
   bin: string;
   ui: string;
-  format: (options: FormatOptions) => Promise<void>;
+  format: (options: FormatOptions) => Promise<RunReport>;
 };
 type Linter = {
   bin: string;
   ui: string;
-  lint: (options: LintOptions) => Promise<void>;
+  lint: (options: LintOptions) => Promise<RunReport>;
 };
 type StaticChecker = {
   bin: string;
   ui: string;
-  check: (options: StaticCheckerOptions) => Promise<void>;
+  check: (options: StaticCheckerOptions) => Promise<RunReport>;
 };
 type TypeCheckOptions = {
   /** Where to run the type checker. Defaults to the kernel's `cwd`. */cwd?: string;
@@ -71,14 +78,14 @@ type TypeCheckOptions = {
 type TypeChecker = {
   bin: string;
   ui: string;
-  check: (options?: TypeCheckOptions) => Promise<void>;
+  check: (options?: TypeCheckOptions) => Promise<RunReport>;
 };
 //#endregion
 //#region src/plugin/types.d.ts
 type Packer = {
   bin: string;
   ui: string;
-  pack: () => Promise<void>;
+  pack: () => Promise<RunReport>;
 };
 declare const PLUGIN_KINDS: readonly ["lint", "format", "jsc", "tsc", "pack"];
 type PluginKind = (typeof PLUGIN_KINDS)[number];
@@ -202,4 +209,4 @@ type UninstallResult = {
   files?: FileOp[];
 };
 //#endregion
-export { Linter as C, TypeChecker as D, TypeCheckOptions as E, ReleaseService as O, LintOptions as S, StaticCheckerOptions as T, Doctor as _, InstallFlags as a, FormatOptions as b, PLUGIN_KINDS as c, PluginCapabilities as d, PluginContext as f, UninstallResult as g, UninstallFlags as h, InstallContext as i, ReleaseServiceOptions as k, Packer as l, UninstallContext as m, ClackPromptsSelectOption as n, InstallResult as o, PluginKind as p, FileOp as r, JsonEdit as s, ClackPrompts as t, Plugin as u, DoctorOutput as v, StaticChecker as w, Formatter as x, DoctorResult as y };
+export { StaticChecker as C, ReleaseService as D, TypeChecker as E, ReleaseServiceOptions as O, RunReport as S, TypeCheckOptions as T, Doctor as _, InstallFlags as a, LintOptions as b, PLUGIN_KINDS as c, PluginCapabilities as d, PluginContext as f, UninstallResult as g, UninstallFlags as h, InstallContext as i, Packer as l, UninstallContext as m, ClackPromptsSelectOption as n, InstallResult as o, PluginKind as p, FileOp as r, JsonEdit as s, ClackPrompts as t, Plugin as u, FormatOptions as v, StaticCheckerOptions as w, Linter as x, Formatter as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rrlab/cli",
-  "version": "1.0.0",
+  "version": "1.0.1-git-908d2c0.0",
   "description": "The CLI toolbox to fullstack common scripts in Variable Land",
   "homepage": "https://github.com/variableland/dx/tree/main/run-run/cli#readme",
   "bugs": {
@@ -56,8 +56,8 @@
     "memoize": "10.2.0",
     "nypm": "0.6.0",
     "rimraf": "6.1.3",
-    "@vlandoss/clibuddy": "0.6.1",
-    "@vlandoss/loggy": "0.2.1"
+    "@vlandoss/loggy": "0.2.1",
+    "@vlandoss/clibuddy": "0.6.2-git-908d2c0.0"
   },
   "devDependencies": {
     "tsdown": "0.22.0",

package/src/lib/plugin.ts

@@ -6,8 +6,6 @@ export type {
   ClackPrompts,
   ClackPromptsSelectOption,
   Doctor,
-  DoctorOutput,
-  DoctorResult,
   FileOp,
   FormatOptions,
   Formatter,
@@ -22,6 +20,7 @@ export type {
   PluginCapabilities,
   PluginContext,
   PluginKind,
+  RunReport,
   StaticChecker,
   StaticCheckerOptions,
   TypeChecker,

package/src/plugin/tool-service.ts

@@ -1,5 +1,5 @@
-import { resolvePackageBin, type ShellService } from "@vlandoss/clibuddy";
-import type { DoctorResult } from "#src/types/tool.ts";
+import { palette, resolvePackageBin, type ShellService } from "@vlandoss/clibuddy";
+import type { RunReport } from "#src/types/tool.ts";
 
 export type ToolServiceOptions = {
   pkg: string;
@@ -16,9 +16,8 @@ export type ToolServiceOptions = {
   from: string;
 };
 
-export type ExecOptions = {
+export type RunReportOptions = {
   cwd?: string;
-  verbose?: boolean;
 };
 
 export class ToolService {
@@ -55,23 +54,44 @@ export class ToolService {
     });
   }
 
-  async exec(args: string[] = [], options: ExecOptions = {}) {
-    const { cwd, verbose } = options;
-    const sh = cwd ? this.#shellService.at(cwd) : this.#shellService;
-    return sh.run(await this.getBinDir(), args, { display: this.#bin, verbose });
+  /**
+   * 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: string[] = [], options: RunReportOptions = {}): Promise<RunReport> {
+    const sh = options.cwd ? this.#shellService.at(options.cwd) : this.#shellService;
+    const output = await sh.runCaptured(await this.getBinDir(), args, { throwOnError: false });
+    // Lead the captured output with the command line that ran — the same
+    // `$ <cmd>` the streaming path prints via `printCmdLine`, so it stays
+    // visible even when captured. It's dim so it reads as context, not result.
+    const header = palette.dim(`$ ${[this.#bin, ...args].join(" ")}`);
+    const body = combine(output.stdout, output.stderr);
+    // Strict `=== 0`: a missing exit code (signal-killed, e.g. OOM) is a
+    // failure, not a pass — `?? 0` would silently report a crashed tool green.
+    return { ok: output.exitCode === 0, output: body ? `${header}\n${body}` : header };
   }
 
-  async doctor(): Promise<DoctorResult> {
+  async doctor(): Promise<RunReport> {
     const output = await this.#shellService.runCaptured(await this.getBinDir(), ["--help"], { throwOnError: false });
     const ok = output.exitCode === 0;
-
-    return {
-      ok,
-      output: {
-        stdout: output.stdout,
-        stderr: output.stderr,
-        exitCode: output.exitCode,
-      },
-    };
+    // Same shape as the other verbs: lead with the `$ <bin> --help` liveness
+    // command (the tool's full help text is noise on success, so it's dropped);
+    // on failure surface whatever the bin printed — stdout AND stderr — so the
+    // reason it won't run is visible.
+    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: string | undefined, stderr: string | undefined): string {
+  return [stdout, stderr]
+    .map((stream) => stream?.trim())
+    .filter(Boolean)
+    .join("\n");
+}

package/src/plugin/types.ts

@@ -1,16 +1,15 @@
 import type { Pkg, ShellService } from "@vlandoss/clibuddy";
 import type { AnyLogger as Logger } from "@vlandoss/loggy";
 import type { ReleaseService } from "#src/services/release.ts";
-import type { Doctor, Formatter, Linter, StaticChecker, TypeChecker } from "#src/types/tool.ts";
+import type { Doctor, Formatter, Linter, RunReport, StaticChecker, TypeChecker } from "#src/types/tool.ts";
 
 export type {
   Doctor,
-  DoctorOutput,
-  DoctorResult,
   FormatOptions,
   Formatter,
   Linter,
   LintOptions,
+  RunReport,
   StaticChecker,
   StaticCheckerOptions,
   TypeChecker,
@@ -20,7 +19,7 @@ export type {
 export type Packer = {
   bin: string;
   ui: string;
-  pack: () => Promise<void>;
+  pack: () => Promise<RunReport>;
 };
 
 export const PLUGIN_KINDS = ["lint", "format", "jsc", "tsc", "pack"] as const;

package/src/program/board.ts

@@ -0,0 +1,86 @@
+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/commands/check.ts

@@ -1,26 +1,22 @@
+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 { logger } from "#src/services/logger.ts";
 
 /**
- * `rr check` is the umbrella that runs the JS check (lint+format) and the
- * TS type check together. Both subcommands are already wired into
- * commander as siblings (`rr jsc`, `rr tsc`), so we reuse the program's
- * command tree as the action registry instead of duplicating it: look the
- * sibling up by name and invoke its action via `parseAsync([])`, which
- * applies its declared option defaults exactly as if the user had typed
- * `rr jsc` directly.
- *
- * Commander binds the running command as `this` inside an action (see
- * `command.js` — `fn.apply(this, actionArgs)`). `this.parent` gives us the
- * parent program without any late-binding ceremony.
+ * `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.)
  */
 export function createCheckCommand(ctx: Context) {
   return createCommand("check")
     .summary(`run static checks${checkAnnotation(ctx)}`)
     .description(
-      "Runs `rr jsc` and `rr tsc` concurrently in-process. Aggregates their exit codes — non-zero when either subcommand fails.",
+      "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;
@@ -30,46 +26,60 @@ export function createCheckCommand(ctx: Context) {
         throw new Error("`rr check` requires the parent program to dispatch sibling subcommands.");
       }
 
-      const targets = ["jsc", "tsc"];
-      const cmds = targets.map((name) => ({ name, cmd: findCommand(program, name) }));
-
-      const missing = cmds.filter(({ cmd }) => !cmd).map(({ name }) => name);
-      if (missing.length > 0) {
-        for (const name of missing) logger.error(`rr check: subcommand "${name}" is not registered.`);
-        process.exitCode = 1;
-        return;
-      }
-
-      const results = await Promise.allSettled(
-        // biome-ignore lint/style/noNonNullAssertion: missing is guarded above
-        cmds.map(({ cmd }) => cmd!.parseAsync([], { from: "user" })),
-      );
-
-      const failed: Array<{ name: string; reason: unknown }> = [];
-      for (const [i, r] of results.entries()) {
-        if (r.status === "rejected") failed.push({ name: cmds[i]?.name ?? "?", reason: r.reason });
-      }
-      if (failed.length > 0) {
-        for (const { name, reason } of failed) {
-          const msg = reason instanceof Error ? reason.message : String(reason);
-          logger.error(`rr check (${name}): ${msg}`);
+      // 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.
+      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;
         }
-        process.exitCode = 1;
+        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" });
+          } catch (reason) {
+            logger.error(`rr check (${name}): ${reason instanceof Error ? reason.message : String(reason)}`);
+            threw = true;
+          }
+        });
+        if (threw || results.some((r) => !r.ok)) failed.push(name);
+        rendered = true;
       }
+
+      // One overall verdict so the bottom of the scroll always answers "did
+      // check pass?" — a green section summary can otherwise be the last line
+      // 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;
     });
 }
 
+function checkVerdict(failed: string[], ms: number): string {
+  const elapsed = palette.dim(ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`);
+  const sep = palette.dim(" · ");
+  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: Command, name: string): Command | undefined {
   return program.commands.find((c) => c.name() === name || c.aliases().includes(name));
 }
 
 /**
- * Mirrors the provider resolution of `jsc` + `tsc` and flattens the
- * underlying tool labels — e.g. biome (composed lint+format) + oxc (tsc)
- * renders as `(biome, oxlint)` rather than `(biome + biome, oxlint)`. When
- * neither sibling has a provider, falls back to the standard `(not
- * configured)` annotation so the help reads consistently with other
- * commands.
+ * 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");

package/src/program/commands/doctor.ts

@@ -1,29 +1,23 @@
+import type { Pkg } from "@vlandoss/clibuddy";
 import { createCommand } from "commander";
-import type { Doctor, DoctorResult } from "#src/plugin/types.ts";
+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";
 
 /**
  * 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. Each calls this with its own provider.
+ * 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) {
+export function createDoctorSubcommand(service: Doctor, appPkg: Pkg) {
   return createCommand("doctor")
     .summary("check if the underlying tool is working correctly")
     .action(async function doctorAction() {
-      const debug = logger.subdebug("doctor");
-      const { ok, output } = await service.doctor();
-
-      if (ok) {
-        logger.success(`${service.ui} ok`);
-        debug("%O", output);
-      } else {
-        logger.error(`${service.ui} not working`);
-        debug("%O", output);
-        process.exit(output.exitCode ?? 1);
-      }
+      const result = await runBoard([reportTask(targetLabel("doctor", service, appPkg), () => service.doctor())]);
+      if (!result.ok) process.exitCode = 1;
     });
 }
 
@@ -46,27 +40,11 @@ export function createDoctorCommand(ctx: Context) {
         return;
       }
 
-      const debug = logger.subdebug("doctor");
-      const results = await Promise.all(
-        services.map(async (svc) => {
-          const result = await svc.doctor();
-          return { svc, result };
-        }),
-      );
-
-      let failures = 0;
-      for (const { svc, result } of results) {
-        if (result.ok) {
-          logger.success(`${svc.ui} ok`);
-          debug("%s: %O", svc.ui, result.output);
-        } else {
-          logger.error(`${svc.ui} not working`);
-          debug("%s: %O", svc.ui, result.output);
-          failures++;
-        }
-      }
-
-      if (failures > 0) process.exitCode = 1;
+      // 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;
     });
 }
 
@@ -81,5 +59,3 @@ function collectDistinctDoctors(ctx: Context): Doctor[] {
   }
   return [...seen];
 }
-
-export type { Doctor as _Doctor, DoctorResult as _DoctorResult };

package/src/program/commands/format.ts

@@ -1,6 +1,6 @@
 import { createCommand } from "commander";
 import type { Context } from "#src/services/ctx.ts";
-import { missingPluginError } from "../missing-plugin.ts";
+import { runToolCommand } from "../board.ts";
 import { pluginAnnotation } from "../ui.ts";
 import { createDoctorSubcommand } from "./doctor.ts";
 
@@ -19,12 +19,11 @@ export function createFormatCommand(ctx: Context) {
     .option("--fix", "format all the code");
 
   if (formatter) {
-    cmd.addCommand(createDoctorSubcommand(formatter));
+    cmd.addCommand(createDoctorSubcommand(formatter, ctx.appPkg));
   }
 
   cmd.action(async (options: ActionOptions = {}) => {
-    if (!formatter) throw missingPluginError("format");
-    await formatter.format(options);
+    await runToolCommand(ctx, { name: "format", kind: "format", provider: formatter, run: (p) => p.format(options) });
   });
 
   if (formatter) {

package/src/program/commands/jscheck.ts

@@ -1,7 +1,7 @@
 import { createCommand } from "commander";
 import type { Context } from "#src/services/ctx.ts";
+import { runToolCommand } from "../board.ts";
 import { composedJscProvider } from "../composed-jsc.ts";
-import { missingPluginError } from "../missing-plugin.ts";
 import { pluginAnnotation } from "../ui.ts";
 import { createDoctorSubcommand } from "./doctor.ts";
 
@@ -28,12 +28,11 @@ export function createJsCheckCommand(ctx: Context) {
     .option("--fix-staged", "try to fix staged files only");
 
   if (checker) {
-    cmd.addCommand(createDoctorSubcommand(checker));
+    cmd.addCommand(createDoctorSubcommand(checker, ctx.appPkg));
   }
 
   cmd.action(async (options: ActionOptions = {}) => {
-    if (!checker) throw missingPluginError("jsc");
-    await checker.check(options);
+    await runToolCommand(ctx, { name: "jsc", kind: "jsc", provider: checker, run: (p) => p.check(options) });
   });
 
   if (checker) {

package/src/program/commands/lint.ts

@@ -1,6 +1,6 @@
 import { createCommand } from "commander";
 import type { Context } from "#src/services/ctx.ts";
-import { missingPluginError } from "../missing-plugin.ts";
+import { runToolCommand } from "../board.ts";
 import { pluginAnnotation } from "../ui.ts";
 import { createDoctorSubcommand } from "./doctor.ts";
 
@@ -21,12 +21,11 @@ export function createLintCommand(ctx: Context) {
     .option("--fix", "try to fix all the code");
 
   if (linter) {
-    cmd.addCommand(createDoctorSubcommand(linter));
+    cmd.addCommand(createDoctorSubcommand(linter, ctx.appPkg));
   }
 
   cmd.action(async (options: ActionOptions = {}) => {
-    if (!linter) throw missingPluginError("lint");
-    await linter.lint(options);
+    await runToolCommand(ctx, { name: "lint", kind: "lint", provider: linter, run: (p) => p.lint(options) });
   });
 
   if (linter) {

package/src/program/commands/pack.ts

@@ -1,6 +1,6 @@
 import { createCommand } from "commander";
 import type { Context } from "#src/services/ctx.ts";
-import { missingPluginError } from "../missing-plugin.ts";
+import { runToolCommand } from "../board.ts";
 import { pluginAnnotation } from "../ui.ts";
 import { createDoctorSubcommand } from "./doctor.ts";
 
@@ -14,13 +14,12 @@ export function createPackCommand(ctx: Context) {
     );
 
   if (packer) {
-    cmd.addCommand(createDoctorSubcommand(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 () => {
-    if (!packer) throw missingPluginError("pack");
-    await packer.pack();
+    await runToolCommand(ctx, { name: "pack", kind: "pack", provider: packer, run: (p) => p.pack() });
   });
 
   return cmd;