@vlandoss/run-run 0.1.4-git-c3e109d.0 → 0.1.5-git-5823ad3.0

package/dist/main.mjs

@@ -5,11 +5,11 @@ import fs from "node:fs";
 import os from "node:os";
 import { lilconfig } from "lilconfig";
 import { createLoggy } from "@vlandoss/loggy";
+import path from "node:path";
+import memoize from "memoize";
 import { glob } from "glob";
 import { rimraf } from "rimraf";
 import isCI from "is-ci";
-import memoize from "memoize";
-import path from "node:path";
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
@@ -225,9 +225,86 @@ function getBannerText(version) {
 	return `${lines.join("\n")}\n`;
 }
 //#endregion
+//#region src/services/tool.ts
+var ToolService = class {
+	#shellService;
+	#bin;
+	#ui;
+	constructor({ bin, ui, shellService }) {
+		this.#bin = bin;
+		this.#ui = ui ?? bin;
+		this.#shellService = shellService;
+	}
+	async exec(args) {
+		const shell = this.#shell();
+		return this.#run(shell, args);
+	}
+	async doctor() {
+		const shell = this.#shell().mute();
+		const output = await this.#run(shell, "--help");
+		return {
+			ok: output.exitCode === 0,
+			output
+		};
+	}
+	#shell = memoize((cwd) => {
+		const preferLocal = this.#getPreferLocal();
+		return this.#shellService.child({
+			...cwd && { cwd },
+			...preferLocal && { preferLocal }
+		});
+	});
+	#run(shell, args) {
+		return shell.$`${this.#bin} ${typeof args === "string" ? args : args.join(" ")}`;
+	}
+	#getPreferLocal() {
+		if (!this.getBinDir) return;
+		try {
+			const binPath = this.getBinDir();
+			return fs.statSync(binPath).isDirectory() ? binPath : path.dirname(binPath);
+		} catch {
+			return;
+		}
+	}
+	get bin() {
+		return this.#bin;
+	}
+	get ui() {
+		return this.#ui;
+	}
+};
+//#endregion
+//#region src/services/tsdown.ts
+var TsdownService = class extends ToolService {
+	constructor(shellService) {
+		super({
+			bin: "tsdown",
+			ui: TOOL_LABELS.TSDOWN,
+			shellService
+		});
+	}
+};
+//#endregion
+//#region src/program/commands/doctor.ts
+function createDoctorSubcommand(service) {
+	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);
+		}
+	});
+}
+//#endregion
 //#region src/program/commands/build-lib.ts
 function createBuildLibCommand(ctx) {
-	return createCommand("build:lib").summary(`build a ts library 🏗️ (${TOOL_LABELS.TSDOWN})`).description("Compiles TypeScript code into JavaScript and generates type declaration files, making it ready for distribution.").action(async function buildAction() {
+	const tsdownService = new TsdownService(ctx.shell);
+	return createCommand("build:lib").summary(`build a ts library 🏗️ (${TOOL_LABELS.TSDOWN})`).description("Compiles TypeScript code into JavaScript and generates type declaration files, making it ready for distribution.").addCommand(createDoctorSubcommand(tsdownService)).action(async function buildAction() {
 		await ctx.shell.$`tsdown`;
 	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${TOOL_LABELS.TSDOWN} CLI to build the project.`);
 }
@@ -271,49 +348,6 @@ function createConfigCommand(ctx) {
 	});
 }
 //#endregion
-//#region src/utils/gracefullBinDir.ts
-function gracefullBinDir(binPathResolver) {
-	try {
-		const binPath = binPathResolver();
-		return fs.statSync(binPath).isDirectory() ? binPath : path.dirname(binPath);
-	} catch (error) {
-		logger.error("Error getting bin directory:", error);
-		process.exit(1);
-	}
-}
-//#endregion
-//#region src/services/tool.ts
-var ToolService = class {
-	#shellService;
-	#bin;
-	#ui;
-	constructor({ bin, ui, shellService }) {
-		this.#bin = bin;
-		this.#ui = ui ?? bin;
-		this.#shellService = shellService;
-	}
-	exec(args) {
-		const $ = this.#shell();
-		return this.#run($, args);
-	}
-	#shell = memoize((cwd) => {
-		const { getBinDir } = this;
-		return this.#shellService.child({
-			cwd,
-			...getBinDir && { preferLocal: gracefullBinDir(() => getBinDir()) }
-		}).$;
-	});
-	#run(shell, args) {
-		return shell`${this.#bin} ${typeof args === "string" ? args : args.join(" ")}`;
-	}
-	get bin() {
-		return this.#bin;
-	}
-	get ui() {
-		return this.#ui;
-	}
-};
-//#endregion
 //#region src/services/biome.ts
 var BiomeService = class extends ToolService {
 	constructor(shellService) {
@@ -371,7 +405,7 @@ function getToolService$2(ctx) {
 }
 function createFormatCommand(ctx) {
 	const toolService = getToolService$2(ctx);
-	return createCommand("format").summary(`check & fix format errors 🎨 (${toolService.ui})`).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").action(async function formatAction(options) {
+	return createCommand("format").summary(`check & fix format errors 🎨 (${toolService.ui})`).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").addCommand(createDoctorSubcommand(toolService)).action(async function formatAction(options) {
 		await toolService.format(options);
 	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolService.ui} CLI to format the code.`);
 }
@@ -379,7 +413,7 @@ function createFormatCommand(ctx) {
 //#region src/program/commands/jscheck.ts
 function createJsCheckCommand(ctx) {
 	const checkerService = new BiomeService(ctx.shell);
-	return createCommand("jsc").alias("jscheck").alias("check").summary(`check format and lint 🔍 (${checkerService.ui})`).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").action(async function checkAction(options) {
+	return createCommand("jsc").alias("jscheck").alias("check").summary(`check format and lint 🔍 (${checkerService.ui})`).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").addCommand(createDoctorSubcommand(checkerService)).action(async function checkAction(options) {
 		await checkerService.check(options);
 	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${checkerService.ui} CLI to check the code.`);
 }
@@ -411,7 +445,7 @@ function getToolService$1(ctx) {
 }
 function createLintCommand(ctx) {
 	const toolService = getToolService$1(ctx);
-	return createCommand("lint").summary(`check & fix lint errors 🔍 (${toolService.ui})`).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").action(async function lintAction(options) {
+	return createCommand("lint").summary(`check & fix lint errors 🔍 (${toolService.ui})`).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").addCommand(createDoctorSubcommand(toolService)).action(async function lintAction(options) {
 		await toolService.lint(options);
 	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolService.ui} CLI to lint the code.`);
 }
@@ -467,17 +501,6 @@ function createTestStaticCommand(ctx) {
 	});
 }
 //#endregion
-//#region src/services/tsdown.ts
-var TsdownService = class extends ToolService {
-	constructor(shellService) {
-		super({
-			bin: "tsdown",
-			ui: TOOL_LABELS.TSDOWN,
-			shellService
-		});
-	}
-};
-//#endregion
 //#region src/program/commands/tools.ts
 function getToolService(bin, shell) {
 	switch (bin) {
@@ -498,6 +521,17 @@ function createToolsCommand(ctx) {
 	return createCommand("tools").description("expose the internal tools 🛠️").addCommand(createToolCommand("biome", ctx.shell)).addCommand(createToolCommand("oxfmt", ctx.shell)).addCommand(createToolCommand("oxlint", ctx.shell)).addCommand(createToolCommand("tsdown", ctx.shell));
 }
 //#endregion
+//#region src/services/tsc.ts
+var TscService = class extends ToolService {
+	constructor(shellService) {
+		super({
+			bin: "tsc",
+			ui: TOOL_LABELS.TSC,
+			shellService
+		});
+	}
+};
+//#endregion
 //#region src/program/commands/tscheck.ts
 const getPreScript = (scripts) => scripts?.pretsc ?? scripts?.pretypecheck;
 async function typecheckAt({ dir, scripts, log, shell, run }) {
@@ -526,11 +560,12 @@ async function typecheckAt({ dir, scripts, log, shell, run }) {
 function createTsCheckCommand(ctx) {
 	const { appPkg, shell, config: { config } } = ctx;
 	const toolUi = config.future?.oxc ? TOOL_LABELS.OXLINT : TOOL_LABELS.TSC;
-	return createCommand("tsc").alias("tscheck").summary(`check typescript errors 🧩 (${toolUi})`).description("Checks the TypeScript code for type errors, ensuring that the code adheres to the defined type constraints and helps catch potential issues before runtime.").addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolUi} CLI to check the code.`).action(async function typecheckAction() {
+	const doctorService = config.future?.oxc ? new OxlintService(shell) : new TscService(shell);
+	return createCommand("tsc").alias("tscheck").summary(`check typescript errors 🧩 (${toolUi})`).description("Checks the TypeScript code for type errors, ensuring that the code adheres to the defined type constraints and helps catch potential issues before runtime.").addCommand(createDoctorSubcommand(doctorService)).addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolUi} CLI to check the code.`).action(async function typecheckAction() {
 		const isTsProject = (dir) => appPkg.hasFile("tsconfig.json", dir);
 		const runTypecheck = async (shell) => {
 			if (config.future?.oxc) await new OxlintService(shell).exec(`--type-aware --type-check --report-unused-disable-directives`);
-			else await shell.$`tsc --noEmit`;
+			else await new TscService(shell).exec(`--noEmit`);
 		};
 		if (!appPkg.isMonorepo()) {
 			if (!isTsProject(appPkg.dirPath)) {
@@ -578,7 +613,8 @@ async function createProgram(options) {
 const debug = logger.subdebug("parseArgs");
 function parseArgs(argv = process.argv) {
 	const args = argv.slice(2);
-	const allArgsAreValidCommands = args.every((arg) => !arg.startsWith("-")) && args.length > 1 && args[0] !== "tools";
+	const lastArg = args[args.length - 1];
+	const allArgsAreValidCommands = args.every((arg) => !arg.startsWith("-")) && args.length > 1 && args[0] !== "tools" && lastArg !== "doctor";
 	debug("args %O", args);
 	if (allArgsAreValidCommands) {
 		debug("multiple commands detected, adding 'run' command");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/run-run",
-  "version": "0.1.4-git-c3e109d.0",
+  "version": "0.1.5-git-5823ad3.0",
   "description": "The CLI toolbox to fullstack common scripts in Variable Land",
   "homepage": "https://github.com/variableland/dx/tree/main/packages/run-run#readme",
   "bugs": {
@@ -58,7 +58,7 @@
     "rimraf": "6.1.3",
     "tsdown": "0.21.10",
     "typescript": "6.0.3",
-    "@vlandoss/clibuddy": "0.1.1",
+    "@vlandoss/clibuddy": "0.1.2-git-5823ad3.0",
     "@vlandoss/loggy": "0.1.1"
   },
   "publishConfig": {

package/src/program/commands/build-lib.ts

@@ -1,13 +1,18 @@
 import { createCommand } from "commander";
 import { TOOL_LABELS } from "#src/program/ui.ts";
 import type { Context } from "#src/services/ctx.ts";
+import { TsdownService } from "#src/services/tsdown.ts";
+import { createDoctorSubcommand } from "./doctor.ts";
 
 export function createBuildLibCommand(ctx: Context) {
+  const tsdownService = new TsdownService(ctx.shell);
+
   return createCommand("build:lib")
     .summary(`build a ts library 🏗️ (${TOOL_LABELS.TSDOWN})`)
     .description(
       "Compiles TypeScript code into JavaScript and generates type declaration files, making it ready for distribution.",
     )
+    .addCommand(createDoctorSubcommand(tsdownService))
     .action(async function buildAction() {
       await ctx.shell.$`tsdown`;
     })

package/src/program/commands/doctor.ts

@@ -0,0 +1,21 @@
+import { createCommand } from "commander";
+import { logger } from "#src/services/logger.ts";
+import type { Doctor } from "#src/types/tool.ts";
+
+export function createDoctorSubcommand(service: Doctor) {
+  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);
+      }
+    });
+}

package/src/program/commands/format.ts

@@ -2,13 +2,15 @@ import { createCommand } from "commander";
 import { BiomeService } from "#src/services/biome.ts";
 import type { Context } from "#src/services/ctx.ts";
 import { OxfmtService } from "#src/services/oxfmt.ts";
+import type { ToolService } from "#src/services/tool.ts";
 import type { Formatter } from "#src/types/tool.ts";
+import { createDoctorSubcommand } from "./doctor.ts";
 
 type ActionOptions = {
   fix?: boolean;
 };
 
-function getToolService(ctx: Context): Formatter {
+function getToolService(ctx: Context): ToolService & Formatter {
   const { config } = ctx.config;
 
   if (config.future?.oxc) {
@@ -27,6 +29,7 @@ export function createFormatCommand(ctx: Context) {
       "Checks the code for formatting issues and optionally fixes them, ensuring it adheres to the defined style standards.",
     )
     .option("--fix", "format all the code")
+    .addCommand(createDoctorSubcommand(toolService))
     .action(async function formatAction(options: ActionOptions) {
       await toolService.format(options);
     })

package/src/program/commands/jscheck.ts

@@ -1,7 +1,7 @@
 import { createCommand } from "commander";
 import { BiomeService } from "#src/services/biome.ts";
 import type { Context } from "#src/services/ctx.ts";
-import type { StaticChecker } from "#src/types/tool.ts";
+import { createDoctorSubcommand } from "./doctor.ts";
 
 type ActionOptions = {
   fix?: boolean;
@@ -9,7 +9,7 @@ type ActionOptions = {
 };
 
 export function createJsCheckCommand(ctx: Context) {
-  const checkerService: StaticChecker = new BiomeService(ctx.shell);
+  const checkerService = new BiomeService(ctx.shell);
 
   return createCommand("jsc")
     .alias("jscheck")
@@ -20,6 +20,7 @@ export function createJsCheckCommand(ctx: Context) {
     )
     .option("--fix", "try to fix issues automatically")
     .option("--fix-staged", "try to fix staged files only")
+    .addCommand(createDoctorSubcommand(checkerService))
     .action(async function checkAction(options: ActionOptions) {
       await checkerService.check(options);
     })

package/src/program/commands/lint.ts

@@ -2,14 +2,16 @@ import { createCommand } from "commander";
 import { BiomeService } from "#src/services/biome.ts";
 import type { Context } from "#src/services/ctx.ts";
 import { OxlintService } from "#src/services/oxlint.ts";
+import type { ToolService } from "#src/services/tool.ts";
 import type { Linter } from "#src/types/tool.ts";
+import { createDoctorSubcommand } from "./doctor.ts";
 
 type ActionOptions = {
   check?: boolean;
   fix?: boolean;
 };
 
-function getToolService(ctx: Context): Linter {
+function getToolService(ctx: Context): ToolService & Linter {
   const { config } = ctx.config;
 
   if (config.future?.oxc) {
@@ -29,6 +31,7 @@ export function createLintCommand(ctx: Context) {
     )
     .option("-c, --check", "check if the code is valid", true)
     .option("--fix", "try to fix all the code")
+    .addCommand(createDoctorSubcommand(toolService))
     .action(async function lintAction(options: ActionOptions) {
       await toolService.lint(options);
     })

package/src/program/commands/tscheck.ts

@@ -4,7 +4,9 @@ import { createCommand } from "commander";
 import type { Context } from "#src/services/ctx.ts";
 import { logger } from "#src/services/logger.ts";
 import { OxlintService } from "#src/services/oxlint.ts";
+import { TscService } from "#src/services/tsc.ts";
 import { TOOL_LABELS } from "../ui.ts";
+import { createDoctorSubcommand } from "./doctor.ts";
 
 type TypecheckAtOptions = {
   dir: string;
@@ -53,6 +55,7 @@ export function createTsCheckCommand(ctx: Context) {
   } = ctx;
 
   const toolUi = config.future?.oxc ? TOOL_LABELS.OXLINT : TOOL_LABELS.TSC;
+  const doctorService = config.future?.oxc ? new OxlintService(shell) : new TscService(shell);
 
   return createCommand("tsc")
     .alias("tscheck")
@@ -60,6 +63,7 @@ export function createTsCheckCommand(ctx: Context) {
     .description(
       "Checks the TypeScript code for type errors, ensuring that the code adheres to the defined type constraints and helps catch potential issues before runtime.",
     )
+    .addCommand(createDoctorSubcommand(doctorService))
     .addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolUi} CLI to check the code.`)
     .action(async function typecheckAction() {
       const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
@@ -69,7 +73,9 @@ export function createTsCheckCommand(ctx: Context) {
           const oxlint = new OxlintService(shell);
           await oxlint.exec(`--type-aware --type-check --report-unused-disable-directives`);
         } else {
-          await shell.$`tsc --noEmit`;
+          const tsc = new TscService(shell);
+          await tsc.exec(`--noEmit`);
+          // await shell.$`tsc --noEmit`;
         }
       };
 

package/src/program/parse-args.ts

@@ -4,7 +4,9 @@ const debug = logger.subdebug("parseArgs");
 
 export function parseArgs(argv = process.argv) {
   const args = argv.slice(2);
-  const allArgsAreValidCommands = args.every((arg) => !arg.startsWith("-")) && args.length > 1 && args[0] !== "tools";
+  const lastArg = args[args.length - 1];
+  const allArgsAreValidCommands =
+    args.every((arg) => !arg.startsWith("-")) && args.length > 1 && args[0] !== "tools" && lastArg !== "doctor";
 
   debug("args %O", args);
 

package/src/services/tool.ts

@@ -1,6 +1,8 @@
-import type { Shell, ShellService } from "@vlandoss/clibuddy";
+import fs from "node:fs";
+import path from "node:path";
+import type { ShellService } from "@vlandoss/clibuddy";
 import memoize from "memoize";
-import { gracefullBinDir } from "#src/utils/gracefullBinDir.ts";
+import type { DoctorResult } from "#src/types/tool.ts";
 
 type CreateOptions = {
   bin: string;
@@ -21,22 +23,45 @@ export abstract class ToolService {
 
   getBinDir?(): string;
 
-  exec(args: string | string[]) {
-    const $ = this.#shell();
-    return this.#run($, args);
+  async exec(args: string | string[]) {
+    const shell = this.#shell();
+    return this.#run(shell, args);
+  }
+
+  async doctor(): Promise<DoctorResult> {
+    const shell = this.#shell().mute();
+
+    const output = await this.#run(shell, "--help");
+    const ok = output.exitCode === 0;
+
+    return { ok, output };
   }
 
   #shell = memoize((cwd?: string) => {
-    const { getBinDir } = this;
+    const preferLocal = this.#getPreferLocal();
 
     return this.#shellService.child({
-      cwd,
-      ...(getBinDir && { preferLocal: gracefullBinDir(() => getBinDir()) }),
-    }).$;
+      ...(cwd && { cwd }),
+      ...(preferLocal && { preferLocal }),
+    });
   });
 
-  #run(shell: Shell, args: string | string[]) {
-    return shell`${this.#bin} ${typeof args === "string" ? args : args.join(" ")}`;
+  #run(shell: ShellService, args: string | string[]) {
+    return shell.$`${this.#bin} ${typeof args === "string" ? args : args.join(" ")}`;
+  }
+
+  #getPreferLocal() {
+    if (!this.getBinDir) {
+      return undefined;
+    }
+
+    try {
+      const binPath = this.getBinDir();
+      const isDir = fs.statSync(binPath).isDirectory();
+      return isDir ? binPath : path.dirname(binPath);
+    } catch {
+      return undefined;
+    }
   }
 
   get bin() {

package/src/services/tsc.ts

@@ -0,0 +1,9 @@
+import type { ShellService } from "@vlandoss/clibuddy";
+import { TOOL_LABELS } from "#src/program/ui.ts";
+import { ToolService } from "./tool.ts";
+
+export class TscService extends ToolService {
+  constructor(shellService: ShellService) {
+    super({ bin: "tsc", ui: TOOL_LABELS.TSC, shellService });
+  }
+}

package/src/types/tool.ts

@@ -11,6 +11,22 @@ export type StaticCheckerOptions = {
   fixStaged?: boolean;
 };
 
+export type DoctorOutput = {
+  stdout: string;
+  stderr: string;
+  exitCode: number | null;
+};
+
+export type DoctorResult = {
+  ok: boolean;
+  output: DoctorOutput;
+};
+
+export type Doctor = {
+  ui: string;
+  doctor(): Promise<DoctorResult>;
+};
+
 export type Formatter = {
   bin: string;
   ui: string;

package/src/utils/gracefullBinDir.ts

@@ -1,14 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { logger } from "#src/services/logger.ts";
-
-export function gracefullBinDir(binPathResolver: () => string) {
-  try {
-    const binPath = binPathResolver();
-    const isDir = fs.statSync(binPath).isDirectory();
-    return isDir ? binPath : path.dirname(binPath);
-  } catch (error) {
-    logger.error("Error getting bin directory:", error);
-    process.exit(1);
-  }
-}