@vlandoss/run-run 0.0.13 → 0.0.14-git-b29f4ca.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vlandoss/run-run",
-  "version": "0.0.13",
+  "version": "0.0.14-git-b29f4ca.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": {
@@ -13,7 +13,9 @@
   "license": "MIT",
   "author": "rcrd <rcrd@variable.land>",
   "type": "module",
-  "module": "src/main.ts",
+  "exports": {
+    "./config": "./src/lib/config.ts"
+  },
   "bin": {
     "rr": "./bin.ts",
     "run-run": "./bin.ts",
@@ -28,14 +30,18 @@
   ],
   "dependencies": {
     "@biomejs/biome": "2.1.4",
+    "c12": "4.0.0-beta.3",
     "commander": "13.1.0",
     "glob": "^11.0.2",
     "is-ci": "4.1.0",
     "memoize": "^10.2.0",
+    "oxfmt": "^0.35.0",
+    "oxlint": "^1.50.0",
+    "oxlint-tsgolint": "^0.15.0",
     "rimraf": "6.0.1",
     "typescript": "5.8.2",
-    "@vlandoss/clibuddy": "0.0.5",
-    "@vlandoss/loggy": "0.0.5"
+    "@vlandoss/loggy": "0.0.5",
+    "@vlandoss/clibuddy": "0.0.5"
   },
   "publishConfig": {
     "access": "public"

package/src/lib/config.ts

@@ -0,0 +1,5 @@
+import type { UserConfig } from "../types/config";
+
+export function defineConfig(config: UserConfig) {
+  return config;
+}

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

@@ -1,4 +1,4 @@
-// Bun Snapshot v1, https://goo.gl/fbAQLP
+// 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: The CLI toolbox to fullstack common scripts in Variable Land 👊
@@ -10,6 +10,7 @@ Options:
   -h, --help                   display help for command
 
 Commands:
+  config|cfg                   display the current config 🛠️
   check|test:static [options]  check format and lint issues 🔍
   lint [options]               lint the code 🧹
   fmt|format [options]         format the code 🎨
@@ -39,6 +40,7 @@ Options:
   -h, --help                   display help for command
 
 Commands:
+  config|cfg                   display the current config 🛠️
   check|test:static [options]  check format and lint issues 🔍
   lint [options]               lint the code 🧹
   fmt|format [options]         format the code 🎨
@@ -79,6 +81,16 @@ Options:
 "
 `;
 
+exports[`should match help messages for all commands: help-command-config 1`] = `
+"Usage: rr config|cfg [options]
+
+display the current config 🛠️
+
+Options:
+  -h, --help  display help for command
+"
+`;
+
 exports[`should match help messages for all commands: help-command-check 1`] = `
 "Usage: rr check|test:static [options]
 
@@ -169,6 +181,8 @@ Options:
 
 Commands:
   biome
+  oxfmt
+  oxlint
   help [command]  display help for command
 "
 `;

package/src/program/commands/config.ts

@@ -0,0 +1,11 @@
+import { createCommand } from "commander";
+import type { Context } from "#/services/ctx";
+
+export function createConfigCommand(ctx: Context) {
+  return createCommand("config")
+    .alias("cfg")
+    .description("display the current config 🛠️")
+    .action(function configAction() {
+      console.log(ctx.config);
+    });
+}

package/src/program/commands/format.ts

@@ -1,25 +1,53 @@
 import { createCommand } from "commander";
 import { BiomeService } from "#/services/biome";
 import type { Context } from "#/services/ctx";
+import { OxfmtService } from "#/services/oxfmt";
+
+type ActionOptions = {
+  check?: boolean;
+  fix?: boolean;
+};
 
 export function createFormatCommand(ctx: Context) {
-  return createCommand("fmt")
+  const fmtCommand = createCommand("fmt")
     .alias("format")
     .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 { $ } = new BiomeService(ctx.shell);
-      const toolCmd = "biome format --no-errors-on-unmatched --colors=force";
-
-      if (options.fix) {
-        await $`${toolCmd} --fix`;
-        return;
-      }
-
-      if (options.check) {
-        await $`${toolCmd}`;
-      }
-    })
-    .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to format the code.");
+    .option("-f, --fix", "format all the code");
+
+  if (ctx.config.future?.oxc) {
+    fmtCommand
+      .action(async function formatAction(options: ActionOptions) {
+        const { $ } = new OxfmtService(ctx.shell);
+        const toolCmd = "oxfmt --no-error-on-unmatched-pattern";
+
+        if (options.fix) {
+          await $`${toolCmd} --fix`;
+          return;
+        }
+
+        if (options.check) {
+          await $`${toolCmd} --check`;
+        }
+      })
+      .addHelpText("afterAll", "\nUnder the hood, this command uses the oxfmt CLI to format the code.");
+  } else {
+    fmtCommand
+      .action(async function formatAction(options: ActionOptions) {
+        const { $ } = new BiomeService(ctx.shell);
+        const toolCmd = "biome format --no-errors-on-unmatched --colors=force";
+
+        if (options.fix) {
+          await $`${toolCmd} --fix`;
+          return;
+        }
+
+        if (options.check) {
+          await $`${toolCmd}`;
+        }
+      })
+      .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to format the code.");
+  }
+
+  return fmtCommand;
 }

package/src/program/commands/lint.ts

@@ -1,24 +1,52 @@
 import { createCommand } from "commander";
 import { BiomeService } from "#/services/biome";
 import type { Context } from "#/services/ctx";
+import { OxlintService } from "#/services/oxlint";
+
+type ActionOptions = {
+  check?: boolean;
+  fix?: boolean;
+};
 
 export function createLintCommand(ctx: Context) {
-  return createCommand("lint")
+  const lintCommand = 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 { $ } = new BiomeService(ctx.shell);
-      const toolCmd = "biome check --colors=force --formatter-enabled=false";
-
-      if (options.fix) {
-        await $`${toolCmd} --fix --unsafe`;
-        return;
-      }
-
-      if (options.check) {
-        await $`${toolCmd}`;
-      }
-    })
-    .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to lint the code.");
+    .option("-f, --fix", "try to fix all the code");
+
+  if (ctx.config.future?.oxc) {
+    lintCommand
+      .action(async function lintAction(options: ActionOptions) {
+        const { $ } = new OxlintService(ctx.shell);
+        const toolCmd = "oxlint --report-unused-disable-directives";
+
+        if (options.fix) {
+          await $`${toolCmd} --fix`;
+          return;
+        }
+
+        if (options.check) {
+          await $`${toolCmd} --check`;
+        }
+      })
+      .addHelpText("afterAll", "\nUnder the hood, this command uses the oxlint CLI to lint the code.");
+  } else {
+    lintCommand
+      .action(async function lintAction(options: ActionOptions) {
+        const { $ } = new BiomeService(ctx.shell);
+        const toolCmd = "biome check --colors=force --formatter-enabled=false";
+
+        if (options.fix) {
+          await $`${toolCmd} --fix --unsafe`;
+          return;
+        }
+
+        if (options.check) {
+          await $`${toolCmd}`;
+        }
+      })
+      .addHelpText("afterAll", "\nUnder the hood, this command uses the biome CLI to lint the code.");
+  }
+
+  return lintCommand;
 }

package/src/program/commands/tools.ts

@@ -1,6 +1,12 @@
 import { createCommand } from "commander";
 import { BiomeService } from "#/services/biome";
 import type { Context } from "#/services/ctx";
+import { OxfmtService } from "#/services/oxfmt";
+import { OxlintService } from "#/services/oxlint";
+
+type ActionParams = {
+  args: string[];
+};
 
 function createToolCommand(toolBin: string) {
   // biome-ignore format: I prefer multi-line here
@@ -15,9 +21,21 @@ export function createToolsCommand(ctx: Context) {
   return createCommand("tools")
     .description("expose the internal tools 🛠️")
     .addCommand(
-      createToolCommand("biome").action((_: unknown, { args }: { args: string[] }) => {
+      createToolCommand("biome").action((_: unknown, { args }: ActionParams) => {
         const biomeService = new BiomeService(ctx.shell);
         biomeService.execute(args);
       }),
+    )
+    .addCommand(
+      createToolCommand("oxfmt").action((_: unknown, { args }: ActionParams) => {
+        const oxfmtService = new OxfmtService(ctx.shell);
+        oxfmtService.execute(args);
+      }),
+    )
+    .addCommand(
+      createToolCommand("oxlint").action((_: unknown, { args }: ActionParams) => {
+        const oxlintService = new OxlintService(ctx.shell);
+        oxlintService.execute(args);
+      }),
     );
 }

package/src/program/commands/typecheck.ts

@@ -3,6 +3,7 @@ import type { AnyLogger } from "@vlandoss/loggy";
 import { createCommand } from "commander";
 import type { Context } from "#/services/ctx";
 import { logger } from "#/services/logger";
+import { OxlintService } from "#/services/oxlint";
 
 type TypecheckAtOptions = {
   dir: string;
@@ -11,71 +12,83 @@ type TypecheckAtOptions = {
 };
 
 export function createTypecheckCommand(ctx: Context) {
-  return createCommand("tsc")
-    .alias("typecheck")
-    .description("check if TypeScript code is well typed 🎨")
-    .action(async function typecheckAction() {
-      const { appPkg, shell } = ctx;
+  const typecheckCommand = createCommand("tsc").alias("typecheck").description("check if TypeScript code is well typed 🎨");
 
-      const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
+  if (ctx.config.future?.oxc) {
+    typecheckCommand
+      .action(async function typecheckAction() {
+        const { $ } = new OxlintService(ctx.shell);
+        await $`oxlint --type-aware --type-check --report-unused-disable-directives`;
+      })
+      .addHelpText("afterAll", "\nUnder the hood, this command uses the oxlint CLI to check the code.");
+  } else {
+    typecheckCommand
+      .action(async function typecheckAction() {
+        const { appPkg, shell } = ctx;
 
-      const getPreScript = (scripts: Record<string, string | undefined> | undefined) => scripts?.pretsc ?? scripts?.pretypecheck;
+        const isTsProject = (dir: string) => appPkg.hasFile("tsconfig.json", dir);
 
-      async function typecheckAt({ dir, scripts, log }: TypecheckAtOptions) {
-        const shellAt = cwd === dir ? shell : shell.at(dir);
+        const getPreScript = (scripts: Record<string, string | undefined> | undefined) =>
+          scripts?.pretsc ?? scripts?.pretypecheck;
 
-        try {
-          const preScript = getPreScript(scripts);
-          if (preScript) {
-            log.start(`Running pre-script: ${preScript}`);
-            await shellAt.$`${preScript}`;
-            log.success("Pre-script completed");
-          }
+        async function typecheckAt({ dir, scripts, log }: TypecheckAtOptions) {
+          const shellAt = cwd === dir ? shell : shell.at(dir);
 
-          log.start("Type checking started");
-          await shellAt.$`tsc --noEmit`;
-          log.success("Typecheck completed");
-        } catch (error) {
-          log.error("Typecheck failed");
-          throw error;
-        }
-      }
+          try {
+            const preScript = getPreScript(scripts);
+            if (preScript) {
+              log.start(`Running pre-script: ${preScript}`);
+              await shellAt.$`${preScript}`;
+              log.success("Pre-script completed");
+            }
 
-      if (!appPkg.isMonorepo()) {
-        if (!isTsProject(appPkg.dirPath)) {
-          logger.info("No tsconfig.json found, skipping typecheck");
-          return;
+            log.start("Type checking started");
+            await shellAt.$`tsc --noEmit`;
+            log.success("Typecheck completed");
+          } catch (error) {
+            log.error("Typecheck failed");
+            throw error;
+          }
         }
 
-        await typecheckAt({
-          dir: appPkg.dirPath,
-          scripts: appPkg.packageJson.scripts,
-          log: logger,
-        });
+        if (!appPkg.isMonorepo()) {
+          if (!isTsProject(appPkg.dirPath)) {
+            logger.info("No tsconfig.json found, skipping typecheck");
+            return;
+          }
 
-        return;
-      }
+          await typecheckAt({
+            dir: appPkg.dirPath,
+            scripts: appPkg.packageJson.scripts,
+            log: logger,
+          });
 
-      const projects = await appPkg.getWorkspaceProjects();
-      const tsProjects = projects.filter((project) => isTsProject(project.rootDir));
+          return;
+        }
 
-      if (!tsProjects.length) {
-        logger.warn("No TypeScript projects found in the monorepo, skipping typecheck");
-        return;
-      }
+        const projects = await appPkg.getWorkspaceProjects();
+        const tsProjects = projects.filter((project) => isTsProject(project.rootDir));
 
-      await Promise.all(
-        tsProjects.map((p) =>
-          typecheckAt({
-            dir: p.rootDir,
-            scripts: p.manifest.scripts,
-            log: logger.child({
-              tag: p.manifest.name,
-              namespace: "typecheck",
+        if (!tsProjects.length) {
+          logger.warn("No TypeScript projects found in the monorepo, skipping typecheck");
+          return;
+        }
+
+        await Promise.all(
+          tsProjects.map((p) =>
+            typecheckAt({
+              dir: p.rootDir,
+              scripts: p.manifest.scripts,
+              log: logger.child({
+                tag: p.manifest.name,
+                namespace: "typecheck",
+              }),
             }),
-          }),
-        ),
-      );
-    })
-    .addHelpText("afterAll", "\nUnder the hood, this command uses the TypeScript CLI to check the code.");
+          ),
+        );
+      })
+      .addHelpText("afterAll", "\nUnder the hood, this command uses the TypeScript CLI to check the code.");
+  }
+
+  return typecheckCommand;
 }

package/src/program/index.ts

@@ -3,6 +3,7 @@ import { createCommand } from "commander";
 import { createContext } from "#/services/ctx";
 import { createCheckCommand } from "./commands/check";
 import { createCleanCommand } from "./commands/clean";
+import { createConfigCommand } from "./commands/config";
 import { createFormatCommand } from "./commands/format";
 import { createLintCommand } from "./commands/lint";
 import { createPkgsCommand } from "./commands/pkgs";
@@ -27,6 +28,7 @@ export async function createProgram(options: Options) {
     .addCommand(createRunCommand(ctx), {
       hidden: true,
     })
+    .addCommand(createConfigCommand(ctx))
     .addCommand(createCheckCommand(ctx))
     .addCommand(createLintCommand(ctx))
     .addCommand(createFormatCommand(ctx))

package/src/services/biome.ts

@@ -1,25 +1,12 @@
 import type { ShellService } from "@vlandoss/clibuddy";
-import { gracefullBinDir } from "#/utils/gracefullBinDir";
-import type { ToolService } from "./models";
-
-export class BiomeService implements ToolService {
-  #shellService: ShellService;
+import { ToolService } from "./tool";
 
+export class BiomeService extends ToolService {
   constructor(shellService: ShellService) {
-    this.#shellService = shellService;
-  }
-
-  get $() {
-    return this.#shellService.child({
-      preferLocal: this.#getBinDir(),
-    }).$;
-  }
-
-  async execute(args: string[]): Promise<void> {
-    this.$`biome ${args.join(" ")}`;
+    super({ cmd: "biome", shellService });
   }
 
-  #getBinDir() {
-    return gracefullBinDir(() => require.resolve("@biomejs/biome/bin/biome"));
+  getBinDir() {
+    return require.resolve("@biomejs/biome/bin/biome");
   }
 }

package/src/services/config.ts

@@ -0,0 +1,27 @@
+import { loadConfig } from "c12";
+import type { UserConfig } from "#/types/config";
+import { logger } from "./logger";
+
+const DEFAULT_CONFIG: UserConfig = {
+  future: {
+    oxc: false,
+  },
+};
+
+export class ConfigService {
+  async load(cwd?: string) {
+    const debug = logger.subdebug("load-config");
+
+    const result = await loadConfig<UserConfig>({
+      cwd,
+      name: "run-run",
+      defaultConfig: DEFAULT_CONFIG,
+    });
+
+    debug("loaded config: %O", result.config);
+    debug("config cwd: %s", result.cwd);
+    debug("config file: %s", result.configFile);
+
+    return result.config;
+  }
+}

package/src/services/ctx.ts

@@ -1,15 +1,18 @@
 import fs from "node:fs";
 import { createPkgService, createShellService, cwd, type PkgService, type ShellService } from "@vlandoss/clibuddy";
+import type { UserConfig } from "#/types/config";
+import { ConfigService } from "./config";
 import { logger } from "./logger";
 
 export type Context = {
   binPkg: PkgService;
   appPkg: PkgService;
   shell: ShellService;
+  config: UserConfig;
 };
 
 export async function createContext(binDir: string): Promise<Context> {
-  const debug = logger.subdebug("create-context-value");
+  const debug = logger.subdebug("create-context");
 
   const binPath = fs.realpathSync(binDir);
 
@@ -36,9 +39,13 @@ export async function createContext(binDir: string): Promise<Context> {
 
   debug("shell service options: %O", shell.options);
 
+  const configService = new ConfigService();
+  const config = await configService.load();
+
   return {
     appPkg,
     binPkg,
     shell,
+    config,
   };
 }

package/src/services/oxfmt.ts

@@ -0,0 +1,12 @@
+import type { ShellService } from "@vlandoss/clibuddy";
+import { ToolService } from "./tool";
+
+export class OxfmtService extends ToolService {
+  constructor(shellService: ShellService) {
+    super({ cmd: "oxfmt", shellService });
+  }
+
+  getBinDir() {
+    return require.resolve("oxfmt/bin/oxfmt");
+  }
+}

package/src/services/oxlint.ts

@@ -0,0 +1,12 @@
+import type { ShellService } from "@vlandoss/clibuddy";
+import { ToolService } from "./tool";
+
+export class OxlintService extends ToolService {
+  constructor(shellService: ShellService) {
+    super({ cmd: "oxlint", shellService });
+  }
+
+  getBinDir() {
+    return require.resolve("oxlint/bin/oxlint");
+  }
+}

package/src/services/tool.ts

@@ -0,0 +1,29 @@
+import type { ShellService } from "@vlandoss/clibuddy";
+import { gracefullBinDir } from "#/utils/gracefullBinDir";
+
+type CreateOptions = {
+  cmd: string;
+  shellService: ShellService;
+};
+
+export abstract class ToolService {
+  #shellService: ShellService;
+  #cmd: string;
+
+  constructor({ cmd, shellService }: CreateOptions) {
+    this.#cmd = cmd;
+    this.#shellService = shellService;
+  }
+
+  abstract getBinDir(): string;
+
+  get $() {
+    return this.#shellService.child({
+      preferLocal: gracefullBinDir(() => this.getBinDir()),
+    }).$;
+  }
+
+  async execute(args: string[]): Promise<void> {
+    this.$`${this.#cmd} ${args.join(" ")}`;
+  }
+}

package/src/types/config.ts

@@ -0,0 +1,5 @@
+export type UserConfig = {
+  future?: {
+    oxc?: boolean;
+  };
+};

package/tools/oxfmt

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

package/tools/oxlint

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

package/src/services/models.ts

@@ -1,6 +0,0 @@
-import type { Shell } from "@vlandoss/clibuddy";
-
-export interface ToolService {
-  $: Shell;
-  execute(args: string[]): Promise<void>;
-}