bun-workspaces 1.0.1 → 1.1.0

package/README.md

@@ -10,7 +10,7 @@ A CLI and API to enhance your monorepo development with Bun's [native workspaces
 
 - Works right away, with no boilerplate required 🍔🍴
 - Get metadata about your monorepo 🤖
-- Run package.json scripts across workspaces 📋
+- Orchestrate your workspaces' `package.json` scripts 📋
 - Run inline [Bun Shell](https://bun.com/docs/runtime/shell) scripts in workspaces 🐚
 
 This is a tool to help manage a Bun monorepo, offering features beyond what [Bun's --filter feature](https://bun.com/docs/pm/filter) can do. It can be used to get a variety of metadata about your project and run scripts across your workspaces with advanced control.
@@ -84,6 +84,7 @@ bw run "bun build" --inline # Run an inline command via the Bun shell
 bw run lint --parallel=false # Run in series
 bw run lint --parallel=2 # Run in parallel with a max of 2 concurrent scripts
 bw run lint --parallel=auto # Default, based on number of available logical CPUs
+bw run lint --parallel=50% # Run in parallel with a max of 50% of the "auto" limit
 
 # Use the grouped output style (default when on a TTY)
 bw run my-script --output-style=grouped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-workspaces",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "A monorepo management tool for Bun, with a CLI and API to enhance Bun's native workspaces.",
   "license": "MIT",
   "main": "src/index.mjs",

package/src/cli/commands/commandHandlerUtils.d.ts

@@ -13,6 +13,7 @@ export type GlobalCommandContext = {
   postTerminatorArgs: string[];
   middleware: CliMiddleware;
   outputWriters: Required<WriteOutputOptions>;
+  terminalWidth: number;
 };
 export type ProjectCommandContext = GlobalCommandContext & {
   project: FileSystemProject;

package/src/cli/commands/runScript/handleRunScript.mjs

@@ -28,7 +28,7 @@ import { renderPlainOutput } from "./output/renderPlainOutput.mjs"; // CONCATENA
 const runScript = handleProjectCommand(
   "runScript",
   async (
-    { project, postTerminatorArgs, outputWriters },
+    { project, postTerminatorArgs, outputWriters, terminalWidth },
     positionalScript,
     positionalWorkspacePatterns,
     options,
@@ -147,6 +147,7 @@ const runScript = handleProjectCommand(
           scriptEventTarget,
           groupedLines,
           outputWriters,
+          terminalWidth,
         ),
       prefixed: () =>
         renderPlainOutput(output, outputWriters, {

package/src/cli/commands/runScript/output/renderGroupedOutput.d.ts

@@ -69,5 +69,6 @@ export declare const renderGroupedOutput: (
   scriptEventTarget: ScriptEventTarget,
   activeScriptLines: number | "all",
   outputWriters: Required<WriteOutputOptions>,
+  terminalWidth: number,
 ) => Promise<void>;
 export {};

package/src/cli/commands/runScript/output/renderGroupedOutput.mjs

@@ -71,6 +71,7 @@ const renderGroupedOutput = async (
   scriptEventTarget,
   activeScriptLines,
   outputWriters,
+  terminalWidth,
 ) => {
   const workspaceState = workspaces.reduce((acc, workspace) => {
     acc[workspace.name] = {
@@ -99,7 +100,7 @@ const renderGroupedOutput = async (
     isReset = true;
     logger.debug("Resetting TUI state");
     outputWriters.stdout(cursorOps.show());
-    process.stdin.unref();
+    process.stdin.unref?.();
     process.stdin.setRawMode?.(false);
   };
   let previousHeight = 0;
@@ -111,18 +112,59 @@ const renderGroupedOutput = async (
     if (isFinal) {
       didFinalRender = true;
     }
-    const width = Math.max(2, process.stdout.columns);
+    const width = Math.max(2, terminalWidth || process.stdout.columns);
     const linesToWrite = [];
+    const workspaceBoxContents = {};
     workspaces.forEach((workspace) => {
       const state = workspaceState[workspace.name];
+      let statusText = state.status;
+      const hasExitCode = state.exitCode && state.exitCode !== -1;
+      const exitState =
+        hasExitCode && state.signal
+          ? "exitAndSignal"
+          : hasExitCode
+            ? "exit"
+            : state.signal
+              ? "signal"
+              : null;
+      if (exitState === "exitAndSignal") {
+        statusText += ` (exit code: ${state.exitCode}, signal: ${state.signal})`;
+      } else if (exitState === "exit") {
+        statusText += ` (exit code: ${state.exitCode})`;
+      } else if (exitState === "signal") {
+        statusText += ` (signal: ${state.signal})`;
+      }
+      const workspaceLine = "Workspace: " + textOps.bold(workspace.name);
+      const statusLine =
+        "   Status: " + textOps[STATUS_COLORS[state.status]](statusText);
+      workspaceBoxContents[workspace.name] = {
+        name: workspaceLine,
+        status: statusLine,
+      };
+    });
+    const padding = 4; // left border, spaces, right border
+    const workspaceBoxWidth = Math.min(
+      width,
+      Math.max(
+        ...Object.values(workspaceBoxContents).map((content) =>
+          Math.max(
+            calculateVisibleLength(content.name),
+            calculateVisibleLength(content.status),
+          ),
+        ),
+      ) + padding,
+    );
+    workspaces.forEach((workspace) => {
+      const state = workspaceState[workspace.name];
+      const { name: workspaceNameContent, status: statusTextContent } =
+        workspaceBoxContents[workspace.name];
       linesToWrite.push({
         text: textOps[BORDER_COLOR](
-          "┌" + "─".repeat(Math.max(0, width - 2)) + "┐",
+          "┌" + "─".repeat(workspaceBoxWidth - 2) + "┐",
         ),
         type: "border",
       });
       const borderText = (text) => {
-        const padding = 4; // left border, spaces, right border
         const visibleLength = calculateVisibleLength(text);
         const truncated =
           visibleLength > width - padding
@@ -131,40 +173,21 @@ const renderGroupedOutput = async (
         return (
           textOps[BORDER_COLOR]("│ ") +
           truncated +
-          " ".repeat(Math.max(0, width - visibleLength - padding)) +
+          " ".repeat(Math.max(0, workspaceBoxWidth - visibleLength - padding)) +
           textOps[BORDER_COLOR](" │")
         );
       };
       linesToWrite.push({
-        text: borderText("Workspace: " + textOps.bold(workspace.name)),
+        text: borderText(workspaceNameContent),
         type: "borderedContent",
       });
-      let statusText = state.status;
-      const hasExitCode = state.exitCode && state.exitCode !== -1;
-      const exitState =
-        hasExitCode && state.signal
-          ? "exitAndSignal"
-          : hasExitCode
-            ? "exit"
-            : state.signal
-              ? "signal"
-              : null;
-      if (exitState === "exitAndSignal") {
-        statusText += ` (exit code: ${state.exitCode}, signal: ${state.signal})`;
-      } else if (exitState === "exit") {
-        statusText += ` (exit code: ${state.exitCode})`;
-      } else if (exitState === "signal") {
-        statusText += ` (signal: ${state.signal})`;
-      }
       linesToWrite.push({
-        text: borderText(
-          "   Status: " + textOps[STATUS_COLORS[state.status]](statusText),
-        ),
+        text: borderText(statusTextContent),
         type: "borderedContent",
       });
       linesToWrite.push({
         text: textOps[BORDER_COLOR](
-          "└" + "─".repeat(Math.max(0, width - 2)) + "┘",
+          "└" + "─".repeat(workspaceBoxWidth - 2) + "┘",
         ),
         type: "border",
       });

package/src/cli/createCli.mjs

@@ -29,7 +29,7 @@ const createCli = ({ defaultCwd = process.cwd(), defaultMiddleware } = {}) => {
     programmatic,
     middleware: _runMiddleware,
     writeOutput,
-    terminalWidth,
+    terminalWidth = process.stdout.columns,
   } = {}) => {
     const middleware = resolveMiddleware(
       defaultMiddleware ?? {},
@@ -93,7 +93,7 @@ const createCli = ({ defaultCwd = process.cwd(), defaultMiddleware } = {}) => {
       const { project, projectError } = initializeWithGlobalOptions(
         program,
         args,
-        defaultCwd,
+        middleware,
       );
       middleware.findProject({
         ...defaultContext,
@@ -111,12 +111,14 @@ const createCli = ({ defaultCwd = process.cwd(), defaultMiddleware } = {}) => {
         postTerminatorArgs,
         middleware,
         outputWriters,
+        terminalWidth,
       });
       defineGlobalCommands({
         program,
         postTerminatorArgs,
         middleware,
         outputWriters,
+        terminalWidth,
       });
       logger.debug(`Commands initialized. Parsing args...`);
       middleware.preParse({

package/src/cli/globalOptions/globalOptions.d.ts

@@ -1,8 +1,9 @@
 import { type Command } from "commander";
+import type { CliMiddleware } from "../middleware";
 export declare const initializeWithGlobalOptions: (
   program: Command,
   args: string[],
-  defaultCwd: string,
+  middleware: CliMiddleware,
 ) => {
   project: import("../../internal/core").Simplify<{
     readonly rootDirectory: string;

package/src/cli/globalOptions/globalOptions.mjs

@@ -19,6 +19,8 @@ import { getCliGlobalOptionConfig } from "./globalOptionsConfig.mjs"; // CONCATE
 const ERRORS = defineErrors(
   "WorkingDirectoryNotFound",
   "WorkingDirectoryNotADirectory",
+  "NoCwdAndWorkspaceRoot",
+  "ProjectRootNotFound",
 );
 const addGlobalOption = (program, optionName, defaultOverride) => {
   const { mainOption, shortOption, description, param, values, defaultValue } =
@@ -42,19 +44,68 @@ const addGlobalOption = (program, optionName, defaultOverride) => {
     );
   }
 };
-const getWorkingDirectoryFromArgs = (program, args, defaultCwd) => {
-  addGlobalOption(program, "cwd", defaultCwd);
+const getWorkingDirectoryFromArgs = (program, args) => {
+  addGlobalOption(program, "cwd");
+  addGlobalOption(program, "workspaceRoot");
   program.parseOptions(args);
-  return program.opts().cwd;
+  const { cwd, workspaceRoot } = program.opts();
+  if (cwd && workspaceRoot) {
+    throw new ERRORS.NoCwdAndWorkspaceRoot(
+      `Cannot use both ${getCliGlobalOptionConfig("cwd").mainOption} (${getCliGlobalOptionConfig("cwd").shortOption}) and ${getCliGlobalOptionConfig("workspaceRoot").mainOption} (${getCliGlobalOptionConfig("workspaceRoot").shortOption}) options together`,
+    );
+  }
+  return {
+    cwdOption: cwd,
+    workspaceRootOption: workspaceRoot,
+  };
 };
-const defineGlobalOptions = (program, args, defaultCwd) => {
-  const cwd = getWorkingDirectoryFromArgs(program, args, defaultCwd);
-  if (!fs.existsSync(cwd)) {
+const findRootFromCwd = () => {
+  let currentDirectory = process.cwd();
+  while (true) {
+    const packageJsonPath = path.join(currentDirectory, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJsonContent = JSON.parse(
+          fs.readFileSync(packageJsonPath, "utf8"),
+        );
+        if (packageJsonContent.workspaces) {
+          return currentDirectory;
+        }
+      } catch {
+        continue;
+      }
+    }
+    const parentDirectory = path.dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      break;
+    }
+    currentDirectory = parentDirectory;
+  }
+  throw new ERRORS.ProjectRootNotFound(
+    `${getCliGlobalOptionConfig("workspaceRoot").shortOption}|${getCliGlobalOptionConfig("workspaceRoot").mainOption} option: Project root not found from current working directory "${process.cwd()}"`,
+  );
+};
+const defineGlobalOptions = (program, args, middleware) => {
+  const { cwdOption, workspaceRootOption } = getWorkingDirectoryFromArgs(
+    program,
+    args,
+  );
+  const cwd =
+    cwdOption || (workspaceRootOption ? findRootFromCwd() : process.cwd());
+  const exists = fs.existsSync(cwd);
+  const isDirectory = exists ? fs.statSync(cwd).isDirectory() : false;
+  middleware.processWorkingDirectory({
+    commanderProgram: program,
+    workingDirectory: cwd,
+    exists,
+    isDirectory,
+  });
+  if (!exists) {
     throw new ERRORS.WorkingDirectoryNotFound(
       `Working directory not found at path "${cwd}"`,
     );
   }
-  if (!fs.statSync(cwd).isDirectory()) {
+  if (!isDirectory) {
     throw new ERRORS.WorkingDirectoryNotADirectory(
       `Working directory is not a directory at path "${cwd}"`,
     );
@@ -90,9 +141,9 @@ const applyGlobalOptions = (options) => {
     projectError: error,
   };
 };
-const initializeWithGlobalOptions = (program, args, defaultCwd) => {
+const initializeWithGlobalOptions = (program, args, middleware) => {
   program.allowUnknownOption(true);
-  const { cwd } = defineGlobalOptions(program, args, defaultCwd);
+  const { cwd } = defineGlobalOptions(program, args, middleware);
   program.parseOptions(args);
   program.allowUnknownOption(false);
   const options = program.opts();

package/src/cli/globalOptions/globalOptionsConfig.d.ts

@@ -3,6 +3,7 @@ export interface CliGlobalOptions {
   logLevel: LogLevelSetting;
   cwd: string;
   includeRoot: boolean;
+  workspaceRoot: boolean;
 }
 export interface CliGlobalOptionConfig {
   mainOption: string;
@@ -28,7 +29,7 @@ export declare const getCliGlobalOptionConfig: (
       readonly mainOption: "--cwd";
       readonly shortOption: "-d";
       readonly description: "Working directory";
-      readonly defaultValue: ".";
+      readonly defaultValue: "";
       readonly values: null;
       readonly param: "path";
     }
@@ -39,5 +40,13 @@ export declare const getCliGlobalOptionConfig: (
       readonly defaultValue: "";
       readonly values: null;
       readonly param: "";
+    }
+  | {
+      readonly mainOption: "--workspace-root";
+      readonly shortOption: "-w";
+      readonly description: "Run from the project root above the current working directory";
+      readonly defaultValue: "";
+      readonly values: null;
+      readonly param: "";
     };
 export declare const getCliGlobalOptionNames: () => CliGlobalOptionName[];

package/src/cli/globalOptions/globalOptionsConfig.mjs

@@ -14,7 +14,7 @@ const CLI_GLOBAL_OPTIONS_CONFIG = {
     mainOption: "--cwd",
     shortOption: "-d",
     description: "Working directory",
-    defaultValue: ".",
+    defaultValue: "",
     values: null,
     param: "path",
   },
@@ -26,6 +26,15 @@ const CLI_GLOBAL_OPTIONS_CONFIG = {
     values: null,
     param: "",
   },
+  workspaceRoot: {
+    mainOption: "--workspace-root",
+    shortOption: "-w",
+    description:
+      "Run from the project root above the current working directory",
+    defaultValue: "",
+    values: null,
+    param: "",
+  },
 };
 const getCliGlobalOptionConfig = (optionName) =>
   CLI_GLOBAL_OPTIONS_CONFIG[optionName];

package/src/cli/middleware.d.ts

@@ -10,9 +10,16 @@ export type InitProgramContext = {
   argv: string[];
 };
 export type ProcessArgvContext = {
+  commanderProgram: CommanderProgram;
   args: string[];
   postTerminatorArgs: string[];
 };
+export type ProcessWorkingDirectoryContext = {
+  commanderProgram: CommanderProgram;
+  workingDirectory: string;
+  exists: boolean;
+  isDirectory: boolean;
+};
 export type FindProjectContext = {
   commanderProgram: CommanderProgram;
   project: FileSystemProject;
@@ -52,6 +59,10 @@ export type CliMiddleware = {
   initProgram: (context: InitProgramContext) => CommanderProgram;
   /** Before the true parsing, just splitting the argv into args and post-terminator args */
   processArgv: (context: ProcessArgvContext) => CommanderProgram;
+  /** Before the working directory is changed */
+  processWorkingDirectory: (
+    context: ProcessWorkingDirectoryContext,
+  ) => CommanderProgram;
   /** After the project has been initialized from global options */
   findProject: (context: FindProjectContext) => CommanderProgram;
   /** Before the Commander program parses the args */

package/src/cli/middleware.mjs

@@ -9,6 +9,7 @@ const resolveMiddleware = (defaultMiddleware, runMiddleware) =>
     catchError: null,
     initProgram: null,
     processArgv: null,
+    processWorkingDirectory: null,
     findProject: null,
     preParse: null,
     postParse: null,

package/src/internal/core/runtime/os.d.ts

@@ -1,4 +1,4 @@
 export declare const IS_WINDOWS: boolean;
 export declare const IS_MACOS: boolean;
 export declare const IS_LINUX: boolean;
-export declare const IS_UNIX: boolean;
+export declare const IS_POSIX: boolean;

package/src/internal/core/runtime/os.mjs

@@ -2,6 +2,6 @@
 const IS_WINDOWS = process.platform === "win32";
 const IS_MACOS = process.platform === "darwin";
 const IS_LINUX = process.platform === "linux";
-const IS_UNIX = IS_MACOS || IS_LINUX;
+const IS_POSIX = IS_MACOS || IS_LINUX;
 
-export { IS_LINUX, IS_MACOS, IS_UNIX, IS_WINDOWS };
+export { IS_LINUX, IS_MACOS, IS_POSIX, IS_WINDOWS };