@rrlab/cli 1.0.0 → 1.0.1-git-e008b4d.0

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

@@ -27,6 +27,19 @@ declare class ReleaseService {
 }
 //#endregion
 //#region src/types/tool.d.ts
+/**
+ * The outcome of running a check-family tool (lint / format / static check /
+ * type check) captured rather than streamed. `ok` is the tool's own verdict —
+ * its exit code, never a guess parsed from output — and `output` is the
+ * combined captured stdout+stderr (color preserved), flushed verbatim grouped
+ * under the package label. We deliberately do NOT parse tool summaries for
+ * warning/error counts: the formats are unstable and not uniform across tools
+ * (tsc and oxfmt have no machine output at all). See decisions/013.
+ */
+type RunReport = {
+  ok: boolean;
+  output: string;
+};
 type FormatOptions = {
   fix?: boolean;
 };
@@ -37,33 +50,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 +80,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 +211,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-e008b4d.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,7 +56,7 @@
     "memoize": "10.2.0",
     "nypm": "0.6.0",
     "rimraf": "6.1.3",
-    "@vlandoss/clibuddy": "0.6.1",
+    "@vlandoss/clibuddy": "0.6.2-git-e008b4d.0",
     "@vlandoss/loggy": "0.2.1"
   },
   "devDependencies": {

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,99 @@
+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 one canonical row label for a single-target run: `<command> (<tool>) · <package>`.
+ * Every command/subcommand that acts on one target (lint, format, jsc, pack,
+ * single-app tsc, a `doctor` subcommand) builds its row through here so they
+ * all read identically.
+ */
+export function targetLabel(command: string, provider: Provider, appPkg: Pkg): string {
+  return `${commandTool(command, provider)} ${palette.dim(`· ${pkgName(appPkg)}`)}`;
+}
+
+/**
+ * The one canonical section title for a fan-out run: `<command> (<tool>) · <n> <unit>`
+ * (e.g. `tsc (oxlint) · 8 packages`). The tool is omitted when the fan-out
+ * spans several tools (`rr doctor` → `doctor · 3 tools`); the rows then carry
+ * the per-unit 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 (which returns a `RunReport`) to a board row.
+ * The row's spinner reflects the in-flight run; the captured `output` becomes
+ * the detail the board flushes grouped under the label.
+ */
+export function reportTask(label: string, run: () => Promise<RunReport>): BoardTask {
+  return {
+    label,
+    async run() {
+      const report = await run();
+      return { ok: report.ok, detail: report.output };
+    },
+  };
+}
+
+// `rr check` runs several single-task sections (jsc, tsc) back to back. On its
+// own each would render compactly, but the frame is what visually divides the
+// sections — so while check is dispatching, force every board to stay framed.
+// While active, the collector also gathers each section's result in run order
+// so `check` can print one overall 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,4 +1,6 @@
+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";
@@ -20,7 +22,7 @@ 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,35 +32,54 @@ 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}`);
+      // jsc then tsc, sequentially: each renders its own live board and two
+      // boards can't animate the same terminal region at once (decision 012).
+      // Each section runs inside its own `runCheckSections` scope — that both
+      // keeps it framed (so the frames divide the sections) and returns the
+      // boards THAT section rendered, so failure is attributed by section name,
+      // never by a fragile dispatch-vs-render index. A section that runs no
+      // board (tsc with no tsconfig) simply reports no results.
+      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));
 }

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;