@vlandoss/run-run 0.0.21 → 0.0.22-git-06df4ba.0

package/bin.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import { main } from "./src/main";
 
 main({
-  binDir: __dirname,
+  binDir: dirname(fileURLToPath(import.meta.url)),
 });

package/dist/bin.mjs

@@ -0,0 +1,600 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { colorIsSupported, colorize, createPkgService, createShellService, cwd, getVersion, palette, run } from "@vlandoss/clibuddy";
+import { Option, createCommand } from "commander";
+import fs from "node:fs";
+import os from "node:os";
+import { lilconfig } from "lilconfig";
+import { createLoggy } from "@vlandoss/loggy";
+import { glob } from "glob";
+import { rimraf } from "rimraf";
+import isCI from "is-ci";
+import memoize from "memoize";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/services/logger.ts
+const logger = createLoggy({ namespace: "run-run" });
+//#endregion
+//#region src/services/config.ts
+const DEFAULT_CONFIG = { future: { oxc: false } };
+var ConfigService = class {
+	#searcher;
+	constructor() {
+		this.#searcher = lilconfig("run-run", {
+			searchPlaces: ["run-run.config.ts"],
+			cache: true,
+			stopDir: os.homedir(),
+			loaders: { ".ts": (filepath) => import(filepath).then((mod) => mod.default) }
+		});
+	}
+	async load() {
+		const debug = logger.subdebug("load-config");
+		const searchResult = await this.#searcher.search();
+		if (!searchResult || searchResult?.isEmpty) {
+			debug("loaded default config: %O", DEFAULT_CONFIG);
+			return {
+				config: DEFAULT_CONFIG,
+				meta: {
+					isDefault: true,
+					filepath: void 0
+				}
+			};
+		}
+		const config = searchResult.config;
+		debug("loaded config: %O", config);
+		debug("config file: %s", searchResult.filepath);
+		return {
+			config,
+			meta: {
+				isDefault: false,
+				filepath: searchResult.filepath
+			}
+		};
+	}
+};
+//#endregion
+//#region src/services/ctx.ts
+async function createContext(binDir) {
+	const debug = logger.subdebug("create-context");
+	const binPath = fs.realpathSync(binDir);
+	debug("bin path:", binPath);
+	debug("process cwd:", process.cwd());
+	const [appPkg, binPkg] = await Promise.all([createPkgService(cwd), createPkgService(binPath)]);
+	if (!binPkg) throw new Error("Could not find bin package.json");
+	if (!appPkg) throw new Error("Could not find app package.json");
+	debug("app pkg info: %O", appPkg.info());
+	debug("bin pkg info: %O", binPkg.info());
+	const shell = createShellService({
+		localBaseBinPath: [binDir],
+		stdio: "inherit"
+	});
+	debug("shell service options: %O", shell.options);
+	return {
+		appPkg,
+		binPkg,
+		shell,
+		config: await new ConfigService().load()
+	};
+}
+//#endregion
+//#region src/program/ui.ts
+const CREDITS_TEXT = `\nAcknowledgment:
+- kcd-scripts: for main inspiration
+  ${palette.link("https://github.com/kentcdodds/kcd-scripts")}
+
+- peruvian news: in honor to Run Run
+  ${palette.link("https://es.wikipedia.org/wiki/Run_Run")}`;
+const tsdownColor = colorize("#FF7E18");
+const biomeColor = colorize("#61A5FA");
+const oxlintColor = colorize("#32F3E9");
+const oxfmtColor = colorize("#32F3E9");
+const tscColor = colorize("#3178C6");
+const rimrafColor = colorize("#7C7270");
+const runRunColor = colorize("FC7A1E");
+const TOOL_LABELS = {
+	TSDOWN: tsdownColor("tsdown"),
+	BIOME: biomeColor("biome"),
+	OXLINT: oxlintColor("oxlint"),
+	OXFMT: oxfmtColor("oxfmt"),
+	TSC: tscColor("tsc"),
+	RIMRAF: rimrafColor("rimraf"),
+	RUN_RUN: runRunColor("run-run")
+};
+function getBannerText(version) {
+	const uiLogo = `🦊 ${palette.bold("R")} ${palette.bold("U")} ${palette.bold("N")} - ${palette.bold("R")} ${palette.bold("U")} ${palette.bold("N")}`;
+	const vlandLogo = `${palette.link(palette.vland("https://variable.land"))} 👊`;
+	const title = `${uiLogo} ${palette.muted(`v${version}`)}`;
+	const subtitle = `${palette.italic(palette.muted("The CLI toolbox for"))} ${vlandLogo}`;
+	if (!colorIsSupported()) return `${title}\n${subtitle}\n`;
+	const FOX_COLORS = {
+		BLACK: colorize("#39393A"),
+		ORANGE: runRunColor,
+		WHITE: colorize("#FFFFFF")
+	};
+	const _ = "  ";
+	const B = FOX_COLORS.BLACK("██");
+	const O = FOX_COLORS.ORANGE("██");
+	const W = FOX_COLORS.WHITE("██");
+	const lines = [
+		[
+			_,
+			B,
+			_,
+			_,
+			_,
+			_,
+			_,
+			B,
+			_
+		],
+		[
+			_,
+			O,
+			W,
+			_,
+			_,
+			_,
+			W,
+			O,
+			_
+		],
+		[
+			_,
+			O,
+			W,
+			O,
+			_,
+			O,
+			W,
+			O,
+			_
+		],
+		[
+			B,
+			O,
+			O,
+			O,
+			O,
+			O,
+			O,
+			O,
+			B
+		],
+		[
+			O,
+			O,
+			O,
+			O,
+			O,
+			O,
+			O,
+			O,
+			O
+		],
+		[
+			W,
+			O,
+			B,
+			O,
+			O,
+			O,
+			B,
+			O,
+			W
+		],
+		[
+			_,
+			W,
+			W,
+			O,
+			O,
+			O,
+			W,
+			W,
+			_
+		],
+		[
+			_,
+			_,
+			W,
+			W,
+			B,
+			W,
+			W,
+			_,
+			_
+		],
+		[
+			_,
+			_,
+			_,
+			W,
+			W,
+			W,
+			_,
+			_,
+			_
+		]
+	].map((row) => row.join(""));
+	lines[3] += `    ${title}`;
+	lines[4] += `    ${subtitle}`;
+	return `${lines.join("\n")}\n`;
+}
+//#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() {
+		await ctx.shell.$`tsdown`;
+	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${TOOL_LABELS.TSDOWN} CLI to build the project.`);
+}
+//#endregion
+//#region src/program/commands/clean.ts
+function createCleanCommand() {
+	return createCommand("clean").summary(`delete dirty files 🗑️ (${TOOL_LABELS.RIMRAF})`).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) {
+		async function run(paths, 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.`);
+}
+//#endregion
+//#region src/program/commands/config.ts
+function createConfigCommand(ctx) {
+	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"}`));
+	});
+}
+//#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) {
+		super({
+			bin: "biome",
+			ui: TOOL_LABELS.BIOME,
+			shellService
+		});
+	}
+	getBinDir() {
+		return __require.resolve("@biomejs/biome/bin/biome");
+	}
+	async format(options) {
+		const commonOptions = "format --colors=force --no-errors-on-unmatched";
+		if (options.fix) await this.exec(`${commonOptions} --fix`);
+		else await this.exec(`${commonOptions}`);
+	}
+	async lint(options) {
+		const commonOptions = "check --colors=force --no-errors-on-unmatched --formatter-enabled=false";
+		if (options.fix) await this.exec(`${commonOptions} --fix --unsafe`);
+		else await this.exec(`${commonOptions}`);
+	}
+	async check(options) {
+		const commonOptions = (cmd = "check") => `${cmd} --colors=force --no-errors-on-unmatched`;
+		if (options.fix) await this.exec(`${commonOptions()} --fix`);
+		else if (options.fixStaged) await this.exec(`${commonOptions()}  --fix --staged`);
+		else await this.exec(`${commonOptions(isCI ? "ci" : "check")}`);
+	}
+};
+//#endregion
+//#region src/services/oxfmt.ts
+var OxfmtService = class extends ToolService {
+	constructor(shellService) {
+		super({
+			bin: "oxfmt",
+			ui: TOOL_LABELS.OXFMT,
+			shellService
+		});
+	}
+	getBinDir() {
+		return __require.resolve("oxfmt/bin/oxfmt");
+	}
+	async format(options) {
+		const commonOptions = "--no-error-on-unmatched-pattern";
+		if (options.fix) await this.exec(`${commonOptions} --fix`);
+		else await this.exec(`${commonOptions} --check`);
+	}
+};
+//#endregion
+//#region src/program/commands/format.ts
+function getToolService$2(ctx) {
+	const { config } = ctx.config;
+	if (config.future?.oxc) return new OxfmtService(ctx.shell);
+	return new BiomeService(ctx.shell);
+}
+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) {
+		await toolService.format(options);
+	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolService.ui} CLI to format the code.`);
+}
+//#endregion
+//#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) {
+		await checkerService.check(options);
+	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${checkerService.ui} CLI to check the code.`);
+}
+//#endregion
+//#region src/services/oxlint.ts
+var OxlintService = class extends ToolService {
+	constructor(shellService) {
+		super({
+			bin: "oxlint",
+			ui: TOOL_LABELS.OXLINT,
+			shellService
+		});
+	}
+	getBinDir() {
+		return __require.resolve("oxlint/bin/oxlint");
+	}
+	async lint(options) {
+		const commonOptions = "--report-unused-disable-directives";
+		if (options.fix) await this.exec(`${commonOptions} --fix`);
+		else await this.exec(`${commonOptions} --check`);
+	}
+};
+//#endregion
+//#region src/program/commands/lint.ts
+function getToolService$1(ctx) {
+	const { config } = ctx.config;
+	if (config.future?.oxc) return new OxlintService(ctx.shell);
+	return new BiomeService(ctx.shell);
+}
+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) {
+		await toolService.lint(options);
+	}).addHelpText("afterAll", `\nUnder the hood, this command uses the ${toolService.ui} CLI to lint the code.`);
+}
+//#endregion
+//#region src/program/commands/pkgs.ts
+const decorators = ["turbo"];
+function createPkgsCommand(ctx) {
+	return createCommand("pkgs").summary("list affected packages 📦").description("Given a list of files, returns the list of affected packages. Useful to run commands only on affected packages.").addOption(new Option("--files <files...>", "list of files to check")).addOption(new Option("--decorator [type]", "type of decorator to use").choices(decorators)).action(async function pkgsAction({ files, decorator }, cmd) {
+		const { appPkg } = ctx;
+		if (!appPkg.isMonorepo()) {
+			const cmdName = cmd.parent?.args[0] ?? cmd.args[0] ?? cmd.name();
+			logger.error(`The \`${cmdName}\` command can only be run in a monorepo.`);
+			return process.exit(1);
+		}
+		const projects = await appPkg.getWorkspaceProjects();
+		const getRelativeRootDir = memoize((rootDir) => {
+			const appDir = appPkg.dirPath;
+			if (!path.isAbsolute(rootDir)) return rootDir;
+			return path.relative(appDir, rootDir);
+		});
+		function getPackageForFile(filePath) {
+			for (const project of projects) {
+				const relativeRootDir = getRelativeRootDir(project.rootDir);
+				if (filePath.startsWith(relativeRootDir)) return project;
+			}
+			return null;
+		}
+		const uniquePkgsNames = /* @__PURE__ */ new Set();
+		files.forEach((file) => {
+			const pkg = getPackageForFile(file);
+			if (pkg?.manifest.name) uniquePkgsNames.add(pkg.manifest.name);
+		});
+		if (!uniquePkgsNames.size) return;
+		const pkgsNames = Array.from(uniquePkgsNames);
+		if (decorator === "turbo") console.log(...pkgsNames.map((name) => `--filter=...${name}`));
+		else console.log(...pkgsNames);
+	});
+}
+//#endregion
+//#region src/program/commands/run.ts
+function createRunCommand(ctx) {
+	return createCommand("run").argument("<cmds...>", "commands to execute concurrently (e.g. 'check tsc')").action(async function runRunAction(cmds) {
+		const { $ } = ctx.shell;
+		const commands = cmds.map((cmd) => $`rr ${cmd}`);
+		await Promise.all(commands);
+	});
+}
+//#endregion
+//#region src/program/commands/test-static.ts
+function createTestStaticCommand(ctx) {
+	return createCommand("test:static").summary(`run static tests 🔬 (${TOOL_LABELS.RUN_RUN})`).description("Runs static tests, including linting, formatting checks, and TypeScript type checking, to ensure code quality and correctness without executing the code.").action(async function testStaticAction() {
+		await ctx.shell.$`rr jscheck tscheck`;
+	});
+}
+//#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) {
+		case "biome": return new BiomeService(shell);
+		case "oxfmt": return new OxfmtService(shell);
+		case "oxlint": return new OxlintService(shell);
+		case "tsdown": return new TsdownService(shell);
+		default: throw new Error(`Unknown tool: ${bin}`);
+	}
+}
+function createToolCommand(bin, shell) {
+	const tool = getToolService(bin, shell);
+	return createCommand(tool.bin).helpCommand(false).helpOption(false).allowExcessArguments(true).allowUnknownOption(true).action(async (_, { args }) => {
+		await tool.exec(args);
+	});
+}
+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/program/commands/tscheck.ts
+const getPreScript = (scripts) => scripts?.pretsc ?? scripts?.pretypecheck;
+async function typecheckAt({ dir, scripts, log, shell, run }) {
+	let shellAt;
+	log.debug(`checking types at ${dir}`);
+	if (cwd === dir) shellAt = shell;
+	else {
+		log.debug(`Changing directory to ${dir} for typecheck`);
+		shellAt = shell.at(dir);
+	}
+	try {
+		const preScript = getPreScript(scripts);
+		if (preScript) {
+			log.start(`Running pre-script: ${preScript}`);
+			await shellAt.$`${preScript}`;
+			log.success("Pre-script completed");
+		}
+		log.start("Type checking started");
+		await run(shellAt);
+		log.success("Typecheck completed");
+	} catch (error) {
+		log.error("Typecheck failed");
+		throw error;
+	}
+}
+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 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`;
+		};
+		if (!appPkg.isMonorepo()) {
+			if (!isTsProject(appPkg.dirPath)) {
+				logger.info("No tsconfig.json found, skipping typecheck");
+				return;
+			}
+			await typecheckAt({
+				shell,
+				run: runTypecheck,
+				dir: appPkg.dirPath,
+				scripts: appPkg.packageJson.scripts,
+				log: logger
+			});
+			return;
+		}
+		const tsProjects = (await appPkg.getWorkspaceProjects()).filter((project) => isTsProject(project.rootDir));
+		if (!tsProjects.length) {
+			logger.warn("No ts projects found in the monorepo, skipping typecheck");
+			return;
+		}
+		await Promise.all(tsProjects.map((p) => typecheckAt({
+			shell,
+			run: runTypecheck,
+			dir: p.rootDir,
+			scripts: p.manifest.scripts,
+			log: logger.child({
+				tag: p.manifest.name,
+				namespace: "typecheck"
+			})
+		})));
+	});
+}
+//#endregion
+//#region src/program/index.ts
+async function createProgram(options) {
+	const ctx = await createContext(options.binDir);
+	const version = getVersion(ctx.binPkg);
+	return {
+		program: createCommand("rr").alias("run-run").usage("[options] <command...>").helpCommand(false).version(version, "-v, --version").addHelpText("before", getBannerText(version)).addHelpText("after", CREDITS_TEXT).addCommand(createBuildLibCommand(ctx)).addCommand(createJsCheckCommand(ctx)).addCommand(createTsCheckCommand(ctx)).addCommand(createLintCommand(ctx)).addCommand(createFormatCommand(ctx)).addCommand(createTestStaticCommand(ctx)).addCommand(createCleanCommand()).addCommand(createPkgsCommand(ctx)).addCommand(createConfigCommand(ctx)).addCommand(createRunCommand(ctx), { hidden: true }).addCommand(createToolsCommand(ctx), { hidden: true }),
+		ctx
+	};
+}
+//#endregion
+//#region src/program/parse-args.ts
+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";
+	debug("args %O", args);
+	if (allArgsAreValidCommands) {
+		debug("multiple commands detected, adding 'run' command");
+		return ["run", ...args];
+	}
+	return args;
+}
+//#endregion
+//#region src/main.ts
+async function main(options) {
+	await run(async () => {
+		const { program } = await createProgram(options);
+		await program.parseAsync(parseArgs(), { from: "user" });
+	}, logger);
+}
+//#endregion
+//#region bin.ts
+main({ binDir: dirname(fileURLToPath(import.meta.url)) });
+//#endregion
+export {};

package/dist/config.mjs

@@ -2,6 +2,5 @@
 function defineConfig(config) {
 	return config;
 }
-
 //#endregion
-export { defineConfig };
+export { defineConfig };

package/dist/tools/tsdown.mjs

@@ -1,3 +1,2 @@
-export * from "tsdown"
-
-export {  };
+export * from "tsdown";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/run-run",
-  "version": "0.0.21",
+  "version": "0.0.22-git-06df4ba.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": {
@@ -8,7 +8,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/variableland/dx.git"
+    "url": "git+https://github.com/variableland/dx.git",
+    "directory": "packages/run-run"
   },
   "license": "MIT",
   "author": "rcrd <rcrd@variable.land>",
@@ -19,19 +20,17 @@
   },
   "exports": {
     "./config": {
-      "bun": "./src/lib/config.ts",
       "types": "./dist/config.d.mts",
       "default": "./dist/config.mjs"
     },
     "./tools/*": {
-      "bun": "./src/lib/tools/*.ts",
       "types": "./dist/tools/*.d.mts",
       "default": "./dist/tools/*.mjs"
     }
   },
   "bin": {
-    "rr": "./bin.ts",
-    "run-run": "./bin.ts",
+    "rr": "./dist/bin.mjs",
+    "run-run": "./dist/bin.mjs",
     "biome": "./tools/biome",
     "oxfmt": "./tools/oxfmt",
     "oxlint": "./tools/oxlint"
@@ -40,6 +39,8 @@
     "bin.ts",
     "dist",
     "src",
+    "!src/**/__tests__",
+    "!src/**/*.test.*",
     "tools",
     "tsconfig.json"
   ],
@@ -54,17 +55,21 @@
     "oxlint": "1.50.0",
     "oxlint-tsgolint": "0.15.0",
     "rimraf": "6.1.3",
-    "tsdown": "0.21.0-beta.2",
+    "tsdown": "0.21.10",
     "typescript": "5.9.3",
-    "@vlandoss/clibuddy": "0.0.10",
-    "@vlandoss/loggy": "0.0.7"
+    "@vlandoss/loggy": "0.0.8-git-06df4ba.0",
+    "@vlandoss/clibuddy": "0.0.11-git-06df4ba.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "engines": {
+    "node": ">=20.0.0",
     "bun": ">=1.0.0"
   },
+  "devDependencies": {
+    "@vlandoss/tsdown-config": "^0.0.2-git-06df4ba.0"
+  },
   "scripts": {
     "build": "tsdown",
     "test": "bun test",

package/tools/biome

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-bunx rr tools biome "$@"
+rr tools biome "$@"

package/tools/oxfmt

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-bunx rr tools oxfmt "$@"
+rr tools oxfmt "$@"

package/tools/oxlint

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-bunx rr tools oxlint "$@"
+rr tools oxlint "$@"

package/tools/tsdown

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-bunx rr tools tsdown "$@"
+rr tools tsdown "$@"

package/src/program/__tests__/__snapshots__/snapshots.test.ts.snap

@@ -1,189 +0,0 @@
-// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
-
-exports[`should match all root commands: root-command---help 1`] = `
-"🦊 R U N - R U N v0.0.0-test
-The CLI toolbox for https://variable.land 👊
-
-Usage: rr|run-run [options] <command...>
-
-Options:
-  -v, --version          output the version number
-  -h, --help             display help for command
-
-Commands:
-  build:lib              build a ts library 🏗️ (tsdown)
-  jsc|jscheck [options]  check format and lint 🔍 (biome)
-  tsc|tscheck            check typescript errors 🧩 (tsc)
-  lint [options]         check & fix lint errors 🔍 (biome)
-  format [options]       check & fix format errors 🎨 (biome)
-  test:static            run static tests 🔬 (run-run)
-  clean [options]        delete dirty files 🗑️ (rimraf)
-  pkgs [options]         list affected packages 📦
-  config                 display the current config 🛠️
-
-Acknowledgment:
-- kcd-scripts: for main inspiration
-  https://github.com/kentcdodds/kcd-scripts
-
-- peruvian news: in honor to Run Run
-  https://es.wikipedia.org/wiki/Run_Run
-"
-`;
-
-exports[`should match all root commands: root-command---version 1`] = `
-"0.0.0-test
-"
-`;
-
-exports[`should match all root commands: root-command--v 1`] = `
-"0.0.0-test
-"
-`;
-
-exports[`should match help messages for all commands: help-command-build:lib 1`] = `
-"Usage: rr build:lib [options]
-
-Compiles TypeScript code into JavaScript and generates type declaration files,
-making it ready for distribution.
-
-Options:
-  -h, --help  display help for command
-
-Under the hood, this command uses the tsdown CLI to build the project.
-"
-`;
-
-exports[`should match help messages for all commands: help-command-jsc 1`] = `
-"Usage: rr jsc|jscheck [options]
-
-Checks the code for formatting and linting issues, ensuring it adheres to the
-defined style and quality standards.
-
-Options:
-  --fix         try to fix issues automatically
-  --fix-staged  try to fix staged files only
-  -h, --help    display help for command
-
-Under the hood, this command uses the biome CLI to check the code.
-"
-`;
-
-exports[`should match help messages for all commands: help-command-tsc 1`] = `
-"Usage: rr tsc|tscheck [options]
-
-Checks the TypeScript code for type errors, ensuring that the code adheres to
-the defined type constraints and helps catch potential issues before runtime.
-
-Options:
-  -h, --help  display help for command
-
-Under the hood, this command uses the tsc CLI to check the code.
-"
-`;
-
-exports[`should match help messages for all commands: help-command-lint 1`] = `
-"Usage: rr lint [options]
-
-Checks the code for linting issues and optionally fixes them, ensuring it
-adheres to the defined quality standards.
-
-Options:
-  -c, --check  check if the code is valid (default: true)
-  --fix        try to fix all the code
-  -h, --help   display help for command
-
-Under the hood, this command uses the biome CLI to lint the code.
-"
-`;
-
-exports[`should match help messages for all commands: help-command-format 1`] = `
-"Usage: rr format [options]
-
-Checks the code for formatting issues and optionally fixes them, ensuring it
-adheres to the defined style standards.
-
-Options:
-  --fix       format all the code
-  -h, --help  display help for command
-
-Under the hood, this command uses the biome CLI to format the code.
-"
-`;
-
-exports[`should match help messages for all commands: help-command-test:static 1`] = `
-"Usage: rr test:static [options]
-
-Runs static tests, including linting, formatting checks, and TypeScript type
-checking, to ensure code quality and correctness without executing the code.
-
-Options:
-  -h, --help  display help for command
-"
-`;
-
-exports[`should match help messages for all commands: help-command-clean 1`] = `
-"Usage: rr clean [options]
-
-Deletes generated files and folders such as 'dist', 'node_modules', and lock
-files to ensure a clean state.
-
-Options:
-  --only-dist  delete 'dist' folders only
-  --dry-run    outputs the paths that would be deleted
-  -h, --help   display help for command
-
-Under the hood, this command uses rimraf to delete dirty folders or files.
-"
-`;
-
-exports[`should match help messages for all commands: help-command-pkgs 1`] = `
-"Usage: rr pkgs [options]
-
-Given a list of files, returns the list of affected packages. Useful to run
-commands only on affected packages.
-
-Options:
-  --files <files...>  list of files to check
-  --decorator [type]  type of decorator to use (choices: "turbo")
-  -h, --help          display help for command
-"
-`;
-
-exports[`should match help messages for all commands: help-command-config 1`] = `
-"Usage: rr config [options]
-
-Displays the current configuration settings, including their source file path if
-available.
-
-Options:
-  -h, --help  display help for command
-"
-`;
-
-exports[`should match help messages for all commands: help-command-run 1`] = `
-"Usage: rr run [options] <cmds...>
-
-Arguments:
-  cmds        commands to execute concurrently (e.g. 'check tsc')
-
-Options:
-  -h, --help  display help for command
-"
-`;
-
-exports[`should match help messages for all commands: help-command-tools 1`] = `
-"Usage: rr tools [options] [command]
-
-expose the internal tools 🛠️
-
-Options:
-  -h, --help      display help for command
-
-Commands:
-  biome
-  oxfmt
-  oxlint
-  tsdown
-  help [command]  display help for command
-"
-`;

package/src/program/__tests__/snapshots.test.ts

@@ -1,38 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { createTestProgram, execCli, mocked } from "#test/helpers.ts";
-
-const { program, ctx } = await createTestProgram();
-const $ = ctx.shell.$;
-
-const rootCommands = ["--help", "--version", "-v"];
-
-afterEach(() => {
-  mocked($).mockClear();
-});
-
-test("should match all root commands", async () => {
-  const results = await Promise.all(
-    rootCommands.map(async (cmd) => {
-      const { stdout } = await execCli(cmd);
-      return { cmd, output: stdout };
-    }),
-  );
-
-  for (const { cmd, output } of results) {
-    expect(output).toMatchSnapshot(`root-command-${cmd}`);
-  }
-});
-
-test("should match help messages for all commands", async () => {
-  const results = await Promise.all(
-    program.commands.map(async (command) => {
-      const cmd = command.name();
-      const { stdout } = await execCli(`${cmd} --help`);
-      return { cmd, output: stdout };
-    }),
-  );
-
-  for (const { cmd, output } of results) {
-    expect(output).toMatchSnapshot(`help-command-${cmd}`);
-  }
-});