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

package/src/program/commands/tscheck.ts

@@ -1,50 +1,14 @@
-import { cwd, type ShellService } from "@vlandoss/clibuddy";
-import type { AnyLogger } from "@vlandoss/loggy";
 import { createCommand } from "commander";
-import type { Doctor, TypeChecker } from "#src/plugin/types.ts";
 import type { Context } from "#src/services/ctx.ts";
 import { logger } from "#src/services/logger.ts";
+import { type BoardTask, fanoutTitle, reportTask, runBoard, targetLabel } from "../board.ts";
 import { missingPluginError } from "../missing-plugin.ts";
 import { pluginAnnotation } from "../ui.ts";
 import { createDoctorSubcommand } from "./doctor.ts";
 
-type TypecheckAtOptions = {
-  dir: string;
-  scripts: Record<string, string | undefined> | undefined;
-  log: AnyLogger;
-  shell: ShellService;
-  tsc: TypeChecker & Doctor;
-};
+type Scripts = Record<string, string | undefined> | undefined;
 
-const getPreScript = (scripts: Record<string, string | undefined> | undefined) => scripts?.pretsc ?? scripts?.pretypecheck;
-
-async function typecheckAt({ dir, scripts, log, shell, tsc }: TypecheckAtOptions) {
-  log.debug(`checking types at ${dir}`);
-
-  const shellAt = cwd === dir ? shell : shell.at(dir);
-
-  try {
-    const preScript = getPreScript(scripts);
-    if (preScript) {
-      log.start(`Running pre-script: ${preScript}`);
-      // Pre-scripts come from package.json and may contain shell features
-      // (`&&`, pipes, env-var substitution) — run them through `/bin/sh -c`.
-      await shellAt.run(preScript, [], { shell: true });
-      log.success("Pre-script completed");
-    }
-
-    log.start("Type checking started");
-    if (cwd === dir) {
-      await tsc.check();
-    } else {
-      await tsc.check({ cwd: dir });
-    }
-    log.success("Typecheck completed");
-  } catch (error) {
-    log.error("Typecheck failed");
-    throw error;
-  }
-}
+const getPreScript = (scripts: Scripts) => scripts?.pretsc ?? scripts?.pretypecheck;
 
 export function createTsCheckCommand(ctx: Context) {
   const { appPkg, shell } = ctx;
@@ -58,7 +22,7 @@ export function createTsCheckCommand(ctx: Context) {
     );
 
   if (tsc) {
-    cmd.addCommand(createDoctorSubcommand(tsc));
+    cmd.addCommand(createDoctorSubcommand(tsc, ctx.appPkg));
     cmd.addHelpText("afterAll", `\nUnder the hood, this command uses the ${tsc.ui} CLI to check the code.`);
   }
 
@@ -67,20 +31,36 @@ export function createTsCheckCommand(ctx: Context) {
 
     const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
 
+    // A package's `pretsc`/`pretypecheck` runs captured, inside the task, so its
+    // output stays grouped with that package. It may use shell features, so it
+    // goes through `/bin/sh -c`. A failing pre-script fails the task before tsc.
+    const typecheckTask = (label: string, dir: string, scripts: Scripts): BoardTask =>
+      reportTask(label, async () => {
+        const preScript = getPreScript(scripts);
+        if (preScript) {
+          const pre = await shell.at(dir).runCaptured(preScript, [], { shell: true, throwOnError: false });
+          if ((pre.exitCode ?? 0) !== 0) {
+            const output = [pre.stdout, pre.stderr]
+              .map((s) => s?.trim())
+              .filter(Boolean)
+              .join("\n");
+            return { ok: false, output: `pre-script \`${preScript}\` failed\n${output}` };
+          }
+        }
+        return tsc.check({ cwd: dir });
+      });
+
     if (!appPkg.isMonorepo()) {
       if (!isTsProject(appPkg.dirPath)) {
         logger.info("No tsconfig.json found, skipping typecheck");
         return;
       }
 
-      await typecheckAt({
-        shell,
-        tsc,
-        dir: appPkg.dirPath,
-        scripts: appPkg.packageJson.scripts,
-        log: logger,
-      });
-
+      // Single package → compact board; the row carries the canonical
+      // `tsc (<tool>) · <pkg>` label like every other single-target command.
+      const label = targetLabel("tsc", tsc, appPkg);
+      const result = await runBoard([typecheckTask(label, appPkg.dirPath, appPkg.packageJson.scripts)]);
+      if (!result.ok) process.exitCode = 1;
       return;
     }
 
@@ -92,20 +72,9 @@ export function createTsCheckCommand(ctx: Context) {
       return;
     }
 
-    await Promise.all(
-      tsProjects.map((p) =>
-        typecheckAt({
-          shell,
-          tsc,
-          dir: p.rootDir,
-          scripts: p.manifest.scripts,
-          log: logger.child({
-            tag: p.manifest.name,
-            namespace: "typecheck",
-          }),
-        }),
-      ),
-    );
+    const tasks = tsProjects.map((p) => typecheckTask(p.manifest.name ?? p.rootDir, p.rootDir, p.manifest.scripts));
+    const result = await runBoard(tasks, { title: fanoutTitle("tsc", tsc, tsProjects.length, "packages") });
+    if (!result.ok) process.exitCode = 1;
   });
 
   return cmd;

package/src/program/composed-jsc.ts

@@ -1,4 +1,4 @@
-import type { Doctor, DoctorResult, Formatter, Linter, StaticChecker, StaticCheckerOptions } from "#src/plugin/types.ts";
+import type { Doctor, Formatter, Linter, RunReport, StaticChecker, StaticCheckerOptions } from "#src/plugin/types.ts";
 
 /**
  * Synthesises a `StaticChecker & Doctor` (the `jsc` capability) by composing
@@ -7,29 +7,41 @@ import type { Doctor, DoctorResult, Formatter, Linter, StaticChecker, StaticChec
  * prettier) but no single plugin claims `jsc`.
  *
  * The check runs lint then format sequentially — interleaved stdout from a
- * parallel run is hard to read for the user. `fixStaged` is dropped because
+ * parallel run is hard to read for the user — and merges their reports into one
+ * so the board renders the pair as a single row. `fixStaged` is dropped because
  * the underlying tools don't have a uniform staged-aware mode.
  */
 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) {
-      await linter.lint({ fix });
-      await formatter.format({ fix });
+    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<DoctorResult> {
+    async doctor(): Promise<RunReport> {
       const [lintRes, fmtRes] = await Promise.all([linter.doctor(), formatter.doctor()]);
-      const ok = lintRes.ok && fmtRes.ok;
-      const firstFailure = !lintRes.ok ? lintRes : !fmtRes.ok ? fmtRes : undefined;
-      return {
-        ok,
-        output: {
-          stdout: `${linter.ui}:\n${lintRes.output.stdout}\n\n${formatter.ui}:\n${fmtRes.output.stdout}`,
-          stderr: `${linter.ui}:\n${lintRes.output.stderr}\n\n${formatter.ui}:\n${fmtRes.output.stderr}`,
-          exitCode: firstFailure?.output.exitCode ?? 0,
-        },
-      };
+      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/types/tool.ts

@@ -1,3 +1,17 @@
+/**
+ * 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.
+ */
+export type RunReport = {
+  ok: boolean;
+  output: string;
+};
+
 export type FormatOptions = {
   fix?: boolean;
 };
@@ -11,38 +25,32 @@ export type StaticCheckerOptions = {
   fixStaged?: boolean;
 };
 
-export type DoctorOutput = {
-  stdout: string;
-  stderr: string;
-  exitCode: number | undefined;
-};
-
-export type DoctorResult = {
-  ok: boolean;
-  output: DoctorOutput;
-};
-
 export 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>;
 };
 
 export type Formatter = {
   bin: string;
   ui: string;
-  format: (options: FormatOptions) => Promise<void>;
+  format: (options: FormatOptions) => Promise<RunReport>;
 };
 
 export type Linter = {
   bin: string;
   ui: string;
-  lint: (options: LintOptions) => Promise<void>;
+  lint: (options: LintOptions) => Promise<RunReport>;
 };
 
 export type StaticChecker = {
   bin: string;
   ui: string;
-  check: (options: StaticCheckerOptions) => Promise<void>;
+  check: (options: StaticCheckerOptions) => Promise<RunReport>;
 };
 
 export type TypeCheckOptions = {
@@ -53,5 +61,5 @@ export type TypeCheckOptions = {
 export type TypeChecker = {
   bin: string;
   ui: string;
-  check: (options?: TypeCheckOptions) => Promise<void>;
+  check: (options?: TypeCheckOptions) => Promise<RunReport>;
 };