bun-workspaces 0.3.0 → 1.0.1-alpha

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-workspaces",
-  "version": "0.3.0",
+  "version": "1.0.1-alpha",
   "main": "src/index.ts",
   "homepage": "https://github.com/ScottMorse/bun-workspaces#readme",
   "bin": {
@@ -8,35 +8,33 @@
   },
   "custom": {
     "bunVersion": {
-      "build": "1.1.38",
+      "build": "1.2.22",
       "libraryConsumer": "^1.1.x"
     }
   },
   "scripts": {
-    "cli": "NODE_ENV=production bun run bin/cli.js",
-    "cli:dev": "NODE_ENV=development bun run bin/cli.js",
+    "cli": "bun run bin/cli.js",
+    "cli:dev": "_BW_RUNTIME_MODE=development bun run bin/cli.js",
     "type-check": "tsc --noEmit",
     "lint": "eslint .",
     "format": "prettier --write .",
     "format-check": "prettier --check ."
   },
   "devDependencies": {
-    "@types/bun": "^1.1.14",
-    "@typescript-eslint/eslint-plugin": "^8.17.0",
-    "@typescript-eslint/parser": "^8.17.0",
+    "@types/bun": "^1.2.22",
+    "@typescript-eslint/eslint-plugin": "^8.44.1",
+    "@typescript-eslint/parser": "^8.44.1",
     "bun-workspaces": "file:.",
-    "eslint": "^9.16.0",
-    "eslint-plugin-import": "^2.31.0",
-    "prettier": "^3.4.2",
-    "typescript-eslint": "^8.17.0"
+    "eslint": "^9.36.0",
+    "eslint-plugin-import": "^2.32.0",
+    "prettier": "^3.6.2",
+    "typescript-eslint": "^8.44.1"
   },
   "dependencies": {
     "commander": "^12.1.0",
-    "glob": "^11.0.0",
-    "pino": "^9.5.0",
-    "pino-pretty": "^13.0.0"
+    "glob": "^11.0.3"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.9.2"
   }
 }

package/src/cli/cli.ts

@@ -6,7 +6,6 @@ import {
 } from "../internal/bunVersion";
 import { logger } from "../internal/logger";
 import { initializeWithGlobalOptions } from "./globalOptions";
-import { OUTPUT_CONFIG } from "./output";
 import { defineProjectCommands } from "./projectCommands";
 
 export interface RunCliOptions {
@@ -18,16 +17,12 @@ export interface CliProgram {
 }
 
 export interface CreateCliProgramOptions {
-  writeOut?: (s: string) => void;
-  writeErr?: (s: string) => void;
   handleError?: (error: Error) => void;
   postInit?: (program: Command) => unknown;
   defaultCwd?: string;
 }
 
 export const createCliProgram = ({
-  writeOut = OUTPUT_CONFIG.writeOut,
-  writeErr = OUTPUT_CONFIG.writeErr,
   handleError,
   postInit,
   defaultCwd = process.cwd(),
@@ -48,8 +43,9 @@ export const createCliProgram = ({
         .description("CLI for utilities for Bun workspaces")
         .version(packageJson.version)
         .configureOutput({
-          writeOut,
-          writeErr,
+          writeOut: (s) => logger.info(s),
+          writeErr: (s) =>
+            s.startsWith("Usage") ? logger.info(s) : logger.error(s),
         });
 
       postInit?.(program);
@@ -75,7 +71,6 @@ export const createCliProgram = ({
       defineProjectCommands({
         program,
         project,
-        printLines: (...lines: string[]) => writeOut(lines.join("\n") + "\n"),
       });
 
       await program.parseAsync(args);

package/src/cli/globalOptions.ts

@@ -1,22 +1,48 @@
 import path from "path";
 import { type Command, Option } from "commander";
-import { logger } from "../internal/logger";
+import { loadConfigFile, type BunWorkspacesConfig } from "../config";
+import { LOG_LEVELS, logger, type LogLevelSetting } from "../internal/logger";
 import { createProject } from "../project";
 
-const LOG_LEVELS = ["silent", "error", "warn", "info", "debug"] as const;
-
-export type LogLevel = (typeof LOG_LEVELS)[number];
-
 export interface CliGlobalOptions {
-  logLevel: LogLevel;
+  logLevel: LogLevelSetting;
   cwd: string;
+  configFile?: string;
 }
 
 export type CliGlobalOptionName = keyof CliGlobalOptions;
 
-const defineGlobalOptions = (program: Command, defaultCwd: string) => {
+const getWorkingDirectory = (
+  program: Command,
+  args: string[],
+  defaultCwd: string,
+) => {
+  program.addOption(
+    new Option("-d --cwd <path>", "Working directory").default(defaultCwd),
+  );
+  program.parseOptions(args);
+  return program.opts().cwd;
+};
+
+const getConfig = (program: Command, args: string[]) => {
+  program.addOption(new Option("-c --configFile <path>", "Config file"));
+  program.parseOptions(args);
+  return program.opts().configFile;
+};
+
+const defineGlobalOptions = (
+  program: Command,
+  args: string[],
+  defaultCwd: string,
+) => {
+  const cwd = getWorkingDirectory(program, args, defaultCwd);
+
+  const configFilePath = getConfig(program, args);
+
+  const config = loadConfigFile(configFilePath, cwd);
+
   const globalOptions: {
-    [K in CliGlobalOptionName]: {
+    [K in Exclude<CliGlobalOptionName, "configFile" | "cwd">]: {
       shortName: string;
       description: string;
       defaultValue: CliGlobalOptions[K];
@@ -27,36 +53,39 @@ const defineGlobalOptions = (program: Command, defaultCwd: string) => {
     logLevel: {
       shortName: "l",
       description: "Log levels",
-      defaultValue: logger.level as LogLevel,
-      values: LOG_LEVELS,
+      defaultValue:
+        config?.cli?.logLevel ?? (logger.printLevel as LogLevelSetting),
+      values: [...LOG_LEVELS, "silent"],
       param: "level",
     },
-    cwd: {
-      shortName: "d",
-      description: "Working directory",
-      defaultValue: defaultCwd ?? process.cwd(),
-      param: "dir",
-    },
   };
 
   Object.entries(globalOptions).forEach(
-    ([name, { shortName, description, defaultValue, param, values }]) => {
+    ([name, { shortName, description, param, values, defaultValue }]) => {
       const option = new Option(
         `-${shortName} --${name}${param ? ` <${param}>` : ""}`,
         description,
       ).default(defaultValue);
 
-      program.addOption(values?.length ? option.choices(values) : option);
+      program.addOption(
+        values?.length ? option.choices(values as string[]) : option,
+      );
     },
   );
+
+  return { cwd, config };
 };
 
-const applyGlobalOptions = (options: CliGlobalOptions) => {
-  logger.level = options.logLevel;
+const applyGlobalOptions = (
+  options: CliGlobalOptions,
+  config: BunWorkspacesConfig | null,
+) => {
+  logger.printLevel = options.logLevel;
   logger.debug("Log level: " + options.logLevel);
 
   const project = createProject({
     rootDir: options.cwd,
+    workspaceAliases: config?.project?.workspaceAliases ?? {},
   });
 
   logger.debug(
@@ -74,11 +103,20 @@ export const initializeWithGlobalOptions = (
   args: string[],
   defaultCwd: string,
 ) => {
-  defineGlobalOptions(program, defaultCwd);
-
   program.allowUnknownOption(true);
+
+  const { cwd, config } = defineGlobalOptions(program, args, defaultCwd);
+
   program.parseOptions(args);
   program.allowUnknownOption(false);
 
-  return applyGlobalOptions(program.opts() as CliGlobalOptions);
+  const options = program.opts() as CliGlobalOptions;
+
+  return applyGlobalOptions(
+    {
+      ...options,
+      cwd,
+    },
+    config,
+  );
 };

package/src/cli/projectCommands.ts

@@ -7,11 +7,11 @@ import type { Workspace } from "../workspaces";
 export interface ProjectCommandsContext {
   project: Project;
   program: Command;
-  printLines: (...lines: string[]) => void;
 }
 
 const createWorkspaceInfoLines = (workspace: Workspace) => [
   `Workspace: ${workspace.name}`,
+  ` - Aliases: ${workspace.aliases.join(", ")}`,
   ` - Path: ${workspace.path}`,
   ` - Glob Match: ${workspace.matchPattern}`,
   ` - Scripts: ${Object.keys(workspace.packageJson.scripts).sort().join(", ")}`,
@@ -25,11 +25,10 @@ const createScriptInfoLines = (script: string, workspaces: Workspace[]) => [
 const createJsonLines = (data: unknown, options: { pretty: boolean }) =>
   JSON.stringify(data, null, options.pretty ? 2 : undefined).split("\n");
 
-const listWorkspaces = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+export const commandOutputLogger = createLogger("");
+commandOutputLogger.printLevel = "info";
+
+const listWorkspaces = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("list-workspaces [pattern]")
     .aliases(["ls", "list"])
@@ -72,19 +71,15 @@ const listWorkspaces = ({
         }
 
         if (!lines.length) {
-          lines.push("No workspaces found");
+          logger.info("No workspaces found");
         }
 
-        printLines(...lines);
+        if (lines.length) commandOutputLogger.info(lines.join("\n"));
       },
     );
 };
 
-const listScripts = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const listScripts = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("list-scripts")
     .description("List all scripts available with their workspaces")
@@ -126,20 +121,16 @@ const listScripts = ({
             });
 
           if (!lines.length) {
-            lines.push("No scripts found");
+            logger.info("No scripts found");
           }
         }
 
-        printLines(...lines);
+        if (lines.length) commandOutputLogger.info(lines.join("\n"));
       },
     );
 };
 
-const workspaceInfo = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const workspaceInfo = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("workspace-info <workspace>")
     .aliases(["info"])
@@ -152,7 +143,7 @@ const workspaceInfo = ({
           `Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`,
         );
 
-        const workspace = project.findWorkspaceByName(workspaceName);
+        const workspace = project.findWorkspaceByNameOrAlias(workspaceName);
         if (!workspace) {
           logger.error(
             `Workspace not found: (options: ${JSON.stringify(workspaceName)})`,
@@ -160,20 +151,17 @@ const workspaceInfo = ({
           return;
         }
 
-        printLines(
-          ...(options.json
+        commandOutputLogger.info(
+          (options.json
             ? createJsonLines(workspace, options)
-            : createWorkspaceInfoLines(workspace)),
+            : createWorkspaceInfoLines(workspace)
+          ).join("\n"),
         );
       },
     );
 };
 
-const scriptInfo = ({
-  program,
-  project,
-  printLines,
-}: ProjectCommandsContext) => {
+const scriptInfo = ({ program, project }: ProjectCommandsContext) => {
   program
     .command("script-info <script>")
     .description("Show information about a script")
@@ -192,15 +180,15 @@ const scriptInfo = ({
         const scripts = project.listScriptsWithWorkspaces();
         const scriptMetadata = scripts[script];
         if (!scriptMetadata) {
-          printLines(
+          logger.error(
             `Script not found: ${JSON.stringify(
               script,
             )} (available: ${Object.keys(scripts).join(", ")})`,
           );
           return;
         }
-        printLines(
-          ...(options.json
+        commandOutputLogger.info(
+          (options.json
             ? createJsonLines(
                 options.workspacesOnly
                   ? scriptMetadata.workspaces.map(({ name }) => name)
@@ -214,7 +202,8 @@ const scriptInfo = ({
               )
             : options.workspacesOnly
               ? scriptMetadata.workspaces.map(({ name }) => name)
-              : createScriptInfoLines(script, scriptMetadata.workspaces)),
+              : createScriptInfoLines(script, scriptMetadata.workspaces)
+          ).join("\n"),
         );
       },
     );
@@ -285,24 +274,32 @@ const runScript = ({ program, project }: ProjectCommandsContext) => {
           }): ${splitCommand.join(" ")}`,
         );
 
-        const silent = logger.level === "silent";
+        const isSilent = logger.printLevel === "silent";
 
         const proc = Bun.spawn(command.command.split(/\s+/g), {
           cwd: command.cwd,
           env: process.env,
-          stdout: silent ? "ignore" : "pipe",
-          stderr: silent ? "ignore" : "pipe",
+          stdout: isSilent ? "ignore" : "pipe",
+          stderr: isSilent ? "ignore" : "pipe",
         });
 
+        const linePrefix = `[${workspace.name}:${scriptName}] `;
+
         if (proc.stdout) {
           for await (const chunk of proc.stdout) {
-            commandLogger.info(new TextDecoder().decode(chunk).trim());
+            const line = new TextDecoder().decode(chunk).trim();
+            line.split("\n").forEach((line) => {
+              commandLogger.info(linePrefix + line);
+            });
           }
         }
 
         if (proc.stderr) {
           for await (const chunk of proc.stderr) {
-            commandLogger.error(new TextDecoder().decode(chunk).trim());
+            const line = new TextDecoder().decode(chunk).trim();
+            line.split("\n").forEach((line) => {
+              commandLogger.error(linePrefix + line);
+            });
           }
         }
 
@@ -372,16 +369,20 @@ const runScript = ({ program, project }: ProjectCommandsContext) => {
       let failCount = 0;
       results.forEach(({ success, workspaceName }) => {
         if (!success) failCount++;
-        logger.info(`${success ? "✅" : "❌"} ${workspaceName}: ${script}`);
+        commandOutputLogger.info(
+          `${success ? "✅" : "❌"} ${workspaceName}: ${script}`,
+        );
       });
 
       const s = results.length === 1 ? "" : "s";
       if (failCount) {
         const message = `${failCount} of ${results.length} script${s} failed`;
-        logger.info(message);
+        commandOutputLogger.info(message);
         process.exit(1);
       } else {
-        logger.info(`${results.length} script${s} ran successfully`);
+        commandOutputLogger.info(
+          `${results.length} script${s} ran successfully`,
+        );
       }
     });
 };

package/src/config/bunWorkspacesConfig.ts

@@ -0,0 +1,62 @@
+import { validateLogLevel, type LogLevelSetting } from "../internal/logger";
+
+export interface CliConfig {
+  logLevel?: LogLevelSetting;
+}
+
+export interface ProjectConfig {
+  /** A map of aliases to a workspace name */
+  workspaceAliases?: Record<string, string>;
+}
+
+export interface BunWorkspacesConfig {
+  cli?: CliConfig;
+  project?: ProjectConfig;
+}
+
+const validateCliConfig = (cliConfig: CliConfig) => {
+  if (typeof cliConfig !== "object" || Array.isArray(cliConfig)) {
+    throw new Error(`Config file: "cli" must be an object`);
+  }
+
+  if (cliConfig?.logLevel) {
+    validateLogLevel(cliConfig.logLevel);
+  }
+};
+
+const validateProjectConfig = (projectConfig: ProjectConfig) => {
+  if (typeof projectConfig !== "object" || Array.isArray(projectConfig)) {
+    throw new Error(`Config file: "project" must be an object`);
+  }
+
+  if (projectConfig?.workspaceAliases) {
+    if (
+      typeof projectConfig.workspaceAliases !== "object" ||
+      Array.isArray(projectConfig.workspaceAliases)
+    ) {
+      throw new Error(
+        `Config file: project.workspaceAliases must be an object`,
+      );
+    }
+    for (const alias of Object.values(projectConfig.workspaceAliases)) {
+      if (typeof alias !== "string") {
+        throw new Error(
+          `Config file: project.workspaceAliases must be an object with string keys and values`,
+        );
+      }
+    }
+  }
+};
+
+export const validateBunWorkspacesConfig = (config: BunWorkspacesConfig) => {
+  if (typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`Config file: must be an object`);
+  }
+
+  if (typeof config.cli !== "undefined") {
+    validateCliConfig(config.cli);
+  }
+  if (typeof config.project !== "undefined") {
+    validateProjectConfig(config.project);
+  }
+};

package/src/config/configFile.ts

@@ -0,0 +1,33 @@
+import fs from "fs";
+import path from "path";
+import {
+  validateBunWorkspacesConfig,
+  type BunWorkspacesConfig,
+} from "./bunWorkspacesConfig";
+
+export const DEFAULT_CONFIG_FILE_PATH = "bw.json";
+
+export const loadConfigFile = (filePath?: string, rootDir = ".") => {
+  if (!filePath) {
+    const defaultFilePath = path.resolve(rootDir, DEFAULT_CONFIG_FILE_PATH);
+    if (fs.existsSync(defaultFilePath)) {
+      filePath = defaultFilePath;
+    } else {
+      return null;
+    }
+  }
+
+  filePath = path.resolve(rootDir, filePath);
+
+  const configFile = fs.readFileSync(filePath, "utf8");
+
+  try {
+    const json = JSON.parse(configFile);
+    validateBunWorkspacesConfig(json);
+    return json as BunWorkspacesConfig;
+  } catch (error) {
+    throw new Error(
+      `Config file: "${filePath}" is not a valid JSON file: ${error}`,
+    );
+  }
+};

package/src/config/index.ts

@@ -0,0 +1,7 @@
+export {
+  validateBunWorkspacesConfig,
+  type BunWorkspacesConfig,
+  type CliConfig,
+  type ProjectConfig,
+} from "./bunWorkspacesConfig";
+export { loadConfigFile, DEFAULT_CONFIG_FILE_PATH } from "./configFile";

package/src/internal/env.ts

@@ -1 +1,25 @@
-export const IS_TEST = process.env.NODE_ENV === "test";
+const RUNTIME_MODE_VALUES = ["development", "production", "test"] as const;
+
+export type RuntimeMode = "development" | "production" | "test";
+
+const _RUNTIME_MODE: RuntimeMode = ((process.env
+  ._BW_RUNTIME_MODE as RuntimeMode) ||
+  (process.env.NODE_ENV?.match(/test(ing)?/)
+    ? "test"
+    : process.env.NODE_ENV === "development"
+      ? "development"
+      : "production")) as RuntimeMode;
+
+export const RUNTIME_MODE = RUNTIME_MODE_VALUES.includes(_RUNTIME_MODE)
+  ? _RUNTIME_MODE
+  : "production";
+
+if (RUNTIME_MODE !== _RUNTIME_MODE) {
+  console.error(
+    `Env var RUNTIME_MODE has an invalid value: "${_RUNTIME_MODE}". Defaulting to "${RUNTIME_MODE}". Accepted values: ${RUNTIME_MODE_VALUES.join(", ")}.`,
+  );
+}
+
+export const IS_TEST = RUNTIME_MODE === "test";
+export const IS_PRODUCTION = RUNTIME_MODE === "production";
+export const IS_DEVELOPMENT = RUNTIME_MODE === "development";