@vlandoss/run-run 0.0.1

package/README.md

@@ -0,0 +1,46 @@
+# 🦊 run-run
+
+CLI toolbox to fullstack common scripts in Variable Land 👊
+
+## Prerequisites
+
+- Bun >= 1.2.4
+
+## Toolbox
+
+- [Biome](https://biomejs.dev)
+- [TSC](https://www.typescriptlang.org)
+- [rimraf](https://www.npmjs.com/package/rimraf)
+
+## Installation
+
+```sh
+pnpm add @vlandoss/run-run
+```
+
+It will adds the `rr` and `run-run` command to your project
+
+## Usage
+
+> [!NOTE]
+> The documentation is WIP
+
+Run the help command:
+
+```sh
+rr help
+```
+
+## Troubleshooting
+
+To enable debug mode, set the `DEBUG` environment variable to `run-run:*` before running *any* command.
+
+```sh
+DEBUG=run-run:* rr help
+```
+
+Additionally, there is an special command to display `package.json` information:
+
+```sh
+rr info:pkg --help
+```

package/bin.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+import { main } from "./src/main";
+
+main({
+  binDir: __dirname,
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@vlandoss/run-run",
+  "version": "0.0.1",
+  "description": "The CLI toolbox to fullstack common scripts in Variable Land",
+  "homepage": "https://github.com/variableland/dx/tree/main/packages/run-run#readme",
+  "bugs": {
+    "url": "https://github.com/variableland/dx/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/variableland/dx.git"
+  },
+  "license": "MIT",
+  "author": "rcrd <rcrd@variable.land>",
+  "type": "module",
+  "module": "src/main.ts",
+  "bin": {
+    "rr": "./bin.ts",
+    "run-run": "./bin.ts"
+  },
+  "files": [
+    "bin",
+    "src",
+    "plopfiles",
+    "tsconfig.json"
+  ],
+  "dependencies": {
+    "@biomejs/biome": "1.9.4",
+    "commander": "13.1.0",
+    "is-ci": "4.1.0",
+    "rimraf": "6.0.1",
+    "typescript": "5.8.2",
+    "@vlandoss/clibuddy": "0.0.1",
+    "@vlandoss/loggy": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "rr tsc"
+  }
+}

package/src/main.ts

@@ -0,0 +1,12 @@
+import { type Options, createProgram } from "./program";
+import { logger } from "./services/logger";
+
+export async function main(options: Options) {
+  try {
+    const { cmd } = await createProgram(options);
+    await cmd.parseAsync();
+  } catch (error) {
+    logger.error("Cannot run main successfully", error);
+    process.exit(1);
+  }
+}

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

@@ -0,0 +1,154 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`should match command: "help" 1`] = `
+"🦊 R U N - R U N: The CLI toolbox to fullstack common scripts in Variable Land 👊
+
+Usage: rr|run-run [options] [command]
+
+Options:
+  -v, --version          output the version number
+  -h, --help             display help for command
+
+Commands:
+  format|fmt [options]   format the code 🎨
+  lint [options]         lint the code 🧹
+  test:static [options]  check format and lint issues ✅
+  clean [options]        delete dirty folders or files such as node_modules, etc
+                         🗑️
+  typecheck|tsc          check if TypeScript code is well typed 🎨
+  info:pkg [options]     display run-run package.json ℹ️
+  help [command]         display help for command
+
+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 command: "--help" 1`] = `
+"🦊 R U N - R U N: The CLI toolbox to fullstack common scripts in Variable Land 👊
+
+Usage: rr|run-run [options] [command]
+
+Options:
+  -v, --version          output the version number
+  -h, --help             display help for command
+
+Commands:
+  format|fmt [options]   format the code 🎨
+  lint [options]         lint the code 🧹
+  test:static [options]  check format and lint issues ✅
+  clean [options]        delete dirty folders or files such as node_modules, etc
+                         🗑️
+  typecheck|tsc          check if TypeScript code is well typed 🎨
+  info:pkg [options]     display run-run package.json ℹ️
+  help [command]         display help for command
+
+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 command: "--version" 1`] = `
+"0.0.0-test
+"
+`;
+
+exports[`should match command: "-v" 1`] = `
+"0.0.0-test
+"
+`;
+
+exports[`should match help message for command "format" 1`] = `
+"Usage: rr format|fmt [options]
+
+format the code 🎨
+
+Options:
+  -c, --check  check if the code is formatted (default: true)
+  -f, --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 message for command "lint" 1`] = `
+"Usage: rr lint [options]
+
+lint the code 🧹
+
+Options:
+  -c, --check  check if the code is valid (default: true)
+  -f, --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 message for command "test:static" 1`] = `
+"Usage: rr test:static [options]
+
+check format and lint issues ✅
+
+Options:
+  -f, --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 message for command "clean" 1`] = `
+"Usage: rr clean [options]
+
+delete dirty folders or files such as node_modules, etc 🗑️
+
+Options:
+  --only-dist  delete 'dist' folders only
+  -h, --help   display help for command
+
+Under the hood, this command uses the rimraf.js to delete dirty folders or files.
+"
+`;
+
+exports[`should match help message for command "typecheck" 1`] = `
+"Usage: rr typecheck|tsc [options]
+
+check if TypeScript code is well typed 🎨
+
+Options:
+  -h, --help  display help for command
+
+Under the hood, this command uses the TSC CLI to check the code.
+"
+`;
+
+exports[`should match help message for command "info:pkg" 1`] = `
+"Usage: rr info:pkg [options]
+
+display run-run package.json ℹ️
+
+Options:
+  -f, --filter <filter>  lodash get id like to filter info by
+  -c, --current          display package.json where run-run will be executed
+  -h, --help             display help for command
+"
+`;
+
+exports[`should match "format" command 1`] = `"biome format --no-errors-on-unmatched --colors=force"`;
+
+exports[`should match "lint" command 1`] = `"biome check --colors=force --formatter-enabled=false"`;
+
+exports[`should match "test:static" command 1`] = `"biome check --colors=force"`;
+
+exports[`should match "typecheck" command 1`] = `"tsc --noEmit"`;

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

@@ -0,0 +1,48 @@
+import { afterEach, expect, test } from "bun:test";
+import { createTestProgram, execCli, mocked, parseProgram } from "test/helpers";
+
+const { cmd, ctx } = await createTestProgram();
+const $ = ctx.shell.$;
+
+const rootCommands = ["help", "--help", "--version", "-v"];
+
+afterEach(() => {
+  mocked($).mockClear();
+});
+
+for (const cmd of rootCommands) {
+  test(`should match command: "${cmd}"`, async () => {
+    const { stdout } = await execCli(cmd);
+
+    expect(stdout).toMatchSnapshot();
+  });
+}
+
+for (const command of cmd.commands) {
+  const cmd = command.name();
+
+  test(`should match help message for command "${cmd}"`, async () => {
+    const { stdout } = await execCli(`${cmd} --help`);
+
+    expect(stdout).toMatchSnapshot();
+  });
+}
+
+// these command don't use shell ($) instance
+const hardCommands = ["info:pkg", "clean"];
+
+const easyTesteableCommands = cmd.commands.filter((command) => {
+  const isHard = hardCommands.some((cmd) => command.name() === cmd);
+  return !isHard;
+});
+
+for (const command of easyTesteableCommands) {
+  const cmd = command.name();
+
+  test(`should match "${cmd}" command`, async () => {
+    await parseProgram([cmd]);
+
+    expect($).toHaveBeenCalledTimes(1);
+    expect(mocked($).mock.results[0]?.value).toMatchSnapshot();
+  });
+}

package/src/program/commands/clean.ts

@@ -0,0 +1,46 @@
+import { cwd } from "@vlandoss/clibuddy";
+import { createCommand } from "commander";
+import { rimraf } from "rimraf";
+import { logger } from "~/services/logger";
+
+export function createCleanCommand() {
+  return createCommand("clean")
+    .description("delete dirty folders or files such as node_modules, etc 🗑️")
+    .option("--only-dist", "delete 'dist' folders only")
+    .action(async function cleanCommandAction(options) {
+      try {
+        if (options.onlyDist) {
+          logger.info("Cleaning only 'dist' folders... ⌛");
+
+          await rimraf("**/dist", {
+            glob: {
+              cwd,
+              ignore: ["**/node_modules/**"],
+            },
+          });
+
+          logger.info("Done ✅");
+
+          return;
+        }
+
+        logger.info("Cleaning all... ⌛");
+
+        const dirtyPaths = ["**/.turbo", "**/dist", "**/node_modules", "pnpm-lock.yaml", "bun.lock"];
+
+        logger.info(dirtyPaths.join("\n"));
+
+        await rimraf(dirtyPaths, {
+          glob: {
+            cwd,
+          },
+        });
+
+        logger.info("Done ✅");
+      } catch (error) {
+        logger.error(error);
+        process.exit(1);
+      }
+    })
+    .addHelpText("afterAll", "\nUnder the hood, this command uses the rimraf.js to delete dirty folders or files.");
+}

package/src/program/commands/format.ts

@@ -0,0 +1,30 @@
+import { createCommand } from "commander";
+import type { Context } from "~/services/ctx";
+import { logger } from "~/services/logger";
+
+export function createFormatCommand(ctx: Context) {
+  return createCommand("format")
+    .alias("fmt")
+    .description("format the code 🎨")
+    .option("-c, --check", "check if the code is formatted", true)
+    .option("-f, --fix", "format all the code")
+    .action(async function formatAction(options) {
+      const $ = ctx.shell.$;
+      const toolCmd = "biome format --no-errors-on-unmatched --colors=force";
+
+      try {
+        if (options.fix) {
+          await $`${toolCmd} --fix`;
+          return;
+        }
+
+        if (options.check) {
+          await $`${toolCmd}`;
+        }
+      } catch (error) {
+        logger.error(error);
+        process.exit(1);
+      }
+    })
+    .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to format the code.");
+}

package/src/program/commands/info-pkg.ts

@@ -0,0 +1,36 @@
+import { createCommand } from "commander";
+import type { Context } from "~/services/ctx";
+import { logger } from "~/services/logger";
+import { get } from "~/utils/get";
+
+export function createInfoPkgCommand(ctx: Context) {
+  return createCommand("info:pkg")
+    .description("display run-run package.json ℹ️")
+    .option("-f, --filter <filter>", "lodash get id like to filter info by")
+    .option("-c, --current", "display package.json where run-run will be executed")
+    .action(async function pkgAction(options) {
+      try {
+        const { appPkg, binPkg } = ctx;
+
+        const infoObject = options.current ? appPkg.info() : binPkg.info();
+
+        if (!options.filter) {
+          logger.info("%O", infoObject);
+          return;
+        }
+
+        const { filter } = options;
+        const subInfoObject = get(infoObject.packageJson, filter);
+
+        if (!subInfoObject) {
+          logger.info("No info found");
+          return;
+        }
+
+        logger.info("%O", { [filter]: subInfoObject });
+      } catch (error) {
+        logger.error(error);
+        process.exit(1);
+      }
+    });
+}

package/src/program/commands/lint.ts

@@ -0,0 +1,29 @@
+import { createCommand } from "commander";
+import type { Context } from "~/services/ctx";
+import { logger } from "~/services/logger";
+
+export function createLintCommand(ctx: Context) {
+  return createCommand("lint")
+    .description("lint the code 🧹")
+    .option("-c, --check", "check if the code is valid", true)
+    .option("-f, --fix", "try to fix all the code")
+    .action(async function lintAction(options) {
+      const $ = ctx.shell.$;
+      const toolCmd = "biome check --colors=force --formatter-enabled=false";
+
+      try {
+        if (options.fix) {
+          await $`${toolCmd} --fix --unsafe`;
+          return;
+        }
+
+        if (options.check) {
+          await $`${toolCmd}`;
+        }
+      } catch (error) {
+        logger.error(error);
+        process.exit(1);
+      }
+    })
+    .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to lint the code.");
+}

package/src/program/commands/test-static.ts

@@ -0,0 +1,33 @@
+import { createCommand } from "commander";
+import isCI from "is-ci";
+import type { Context } from "~/services/ctx";
+import { logger } from "~/services/logger";
+
+export function createTestStaticCommand(ctx: Context) {
+  return createCommand("test:static")
+    .description("check format and lint issues ✅")
+    .option("-f, --fix", "try to fix issues automatically")
+    .option("--fix-staged", "try to fix staged files only")
+    .action(async function testStaticAction(options) {
+      const $ = ctx.shell.$;
+      const toolCmd = (cmd = "check") => `biome ${cmd} --colors=force`;
+
+      try {
+        if (options.fix) {
+          await $`${toolCmd()} --fix --unsafe`;
+          return;
+        }
+
+        if (options.fixStaged) {
+          await $`${toolCmd()} --no-errors-on-unmatched --fix --unsafe --staged`;
+          return;
+        }
+
+        await $`${toolCmd(isCI ? "ci" : "check")}`;
+      } catch (error) {
+        logger.error(error);
+        process.exit(1);
+      }
+    })
+    .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to check the code.");
+}

package/src/program/commands/typecheck.ts

@@ -0,0 +1,25 @@
+import { createCommand } from "commander";
+import type { Context } from "~/services/ctx";
+import { logger } from "~/services/logger";
+
+export function createTypecheckCommand(ctx: Context) {
+  return createCommand("typecheck")
+    .alias("tsc")
+    .description("check if TypeScript code is well typed 🎨")
+    .action(async function typecheckAction() {
+      const { appPkg } = ctx;
+      const $ = ctx.shell.$;
+
+      try {
+        if (appPkg?.hasFile("tsconfig.json")) {
+          await $`tsc --noEmit`;
+        } else {
+          logger.info("No tsconfig.json found. Skipping type checking.");
+        }
+      } catch (error) {
+        logger.error(error);
+        process.exit(1);
+      }
+    })
+    .addHelpText("afterAll", "\nUnder the hood, this command uses the TSC CLI to check the code.");
+}

package/src/program/index.ts

@@ -0,0 +1,32 @@
+import { getVersion } from "@vlandoss/clibuddy";
+import { Command } from "commander";
+import { createContext } from "~/services/ctx";
+import { createCleanCommand } from "./commands/clean";
+import { createFormatCommand } from "./commands/format";
+import { createInfoPkgCommand } from "./commands/info-pkg";
+import { createLintCommand } from "./commands/lint";
+import { createTestStaticCommand } from "./commands/test-static";
+import { createTypecheckCommand } from "./commands/typecheck";
+import { BANNER_TEXT, CREDITS_TEXT } from "./ui";
+
+export type Options = {
+  binDir: string;
+};
+
+export async function createProgram(options: Options) {
+  const ctx = await createContext(options.binDir);
+
+  const cmd = new Command("rr")
+    .alias("run-run")
+    .version(getVersion(ctx.binPkg), "-v, --version")
+    .addHelpText("before", BANNER_TEXT)
+    .addHelpText("after", CREDITS_TEXT)
+    .addCommand(createFormatCommand(ctx))
+    .addCommand(createLintCommand(ctx))
+    .addCommand(createTestStaticCommand(ctx))
+    .addCommand(createCleanCommand())
+    .addCommand(createTypecheckCommand(ctx))
+    .addCommand(createInfoPkgCommand(ctx));
+
+  return { cmd, ctx };
+}

package/src/program/ui.ts

@@ -0,0 +1,14 @@
+import { colors } from "@vlandoss/clibuddy";
+
+const UI_LOGO = `🦊 ${colors.blueBright("R")} ${colors.redBright("U")} ${colors.greenBright("N")} - ${colors.blueBright("R")} ${colors.redBright("U")} ${colors.greenBright("N")}`;
+
+const COMPANY_LOGO = `${colors.redBright("Variable Land")} 👊`;
+
+export const BANNER_TEXT = `${UI_LOGO}: The CLI toolbox to fullstack common scripts in ${COMPANY_LOGO}\n`;
+
+export const CREDITS_TEXT = `\nAcknowledgment:
+- 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`;

package/src/services/ctx.ts

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import { type PkgService, type ShellService, createPkgService, createShellService, cwd } from "@vlandoss/clibuddy";
+import { logger } from "./logger";
+
+export type Context = {
+  binPkg: PkgService;
+  appPkg: PkgService;
+  shell: ShellService;
+};
+
+export async function createContext(binDir: string): Promise<Context> {
+  const debug = logger.subdebug("create-context-value");
+
+  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],
+  });
+
+  return {
+    appPkg,
+    binPkg,
+    shell,
+  };
+}

package/src/services/logger.ts

@@ -0,0 +1,5 @@
+import { createLoggy } from "@vlandoss/loggy";
+
+export const logger = createLoggy({
+  namespace: "run-run",
+});

package/src/utils/__tests__/get.test.ts

@@ -0,0 +1,22 @@
+import { expect, it } from "bun:test";
+import { get } from "../get";
+
+it("should get the value when the key is found", () => {
+  const obj = { a: 1 };
+  expect(get(obj, "a")).toBe(1);
+});
+
+it("should get the value when the nested key is found", () => {
+  const obj = { a: { b: { c: 1 } } };
+  expect(get(obj, "a.b.c")).toBe(1);
+});
+
+it("should get undefined when the key is not found", () => {
+  const obj = { a: 1 };
+  expect(get(obj, "b")).toBeUndefined();
+});
+
+it("should get undefined when the nested key is not found", () => {
+  const obj = { a: { b: { c: 1 } } };
+  expect(get(obj, "a.b.d")).toBeUndefined();
+});

package/src/utils/get.ts

@@ -0,0 +1,30 @@
+export function get(obj: unknown, key: string) {
+  if (typeof obj !== "object" || obj === null) {
+    return undefined;
+  }
+
+  if (typeof key !== "string") {
+    throw new Error("Key must be a string");
+  }
+
+  const parts = key.split(".");
+
+  let value = {
+    ...obj,
+  };
+
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i] as string;
+
+    // @ts-expect-error value is type to {}
+    const subValue = value[key];
+
+    if (!subValue) {
+      return undefined;
+    }
+
+    value = subValue;
+  }
+
+  return value;
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": ["@total-typescript/tsconfig/bundler/no-dom/app"],
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["./src/*"],
+      "test/*": ["./test/*"],
+      "@vlandoss/*": ["../../packages/*/src"]
+    }
+  }
+}