bun-workspaces 1.0.0-alpha.7 → 1.0.0-alpha.8

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Scott Morse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,8 +1,12 @@
+<img src="./packages/doc-website/src/docs/public/bw-eye.png" alt="bun-workspaces" width="50" />
+
 # bun-workspaces
 
-This is a CLI meant to help manage [Bun workspaces](https://bun.sh/docs/install/workspaces).
+This is a CLI that works on top of native [Bun workspaces](https://bun.sh/docs/install/workspaces) with no additional setup required. Get metadata about your workspaces and scripts, and run scripts across your workspaces.
+
+### **[See Full Documentation Here](https://bunworkspaces.com)**
 
-## Installation
+## Quick Start
 
 You can install the CLI in your project or simply use `bunx bun-workspaces`.
 
@@ -11,107 +15,25 @@ $ bun add --dev bun-workspaces
 $ bunx bun-workspaces --help
 ```
 
-### Config file
-
-You can create a config file at `bw.json` in your project root, or you can pass a config file to the CLI with the `--configFile` (or `-c`) option.
-
-#### Example config
-
-In this config, "app-a" is an alias for package "@my-org/application-a" and "app-b" is an alias for package "@my-org/application-b".
-
-CLI log levels are `debug`, `info`, `warn`, and `error` or `silent`. The default log level is `info`. Commands that are intended to print specific output will still print at `silent`, such as `list-workspaces`, `list-scripts`, `workspace-info`, `script-info`, etc., but other logs will be suppressed.
-
-```json
-{
-  "workspaceAliases": {
-    "app-a": "@my-org/application-a",
-    "app-b": "@my-org/application-b"
-  },
-  "cli": {
-    "logLevel": "warn"
-  }
-}
-```
-
-You can also pass a config file to the CLI with the `-c` or `--configFile` option.
-
-### Examples
-
-You might consider making a shorter alias in your `.bashrc`, `.zshrc`, or similar shell configuration file, such as `alias bw="bunx bun-workspaces"`, for convenience.
-
 ```bash
 alias bw="bunx bun-workspaces"
 
-# List all workspaces
-bw list-workspaces
-bw ls
-
-# List workspace names only
-bw list-workspaces --name-only
-
-# Filter list of workspaces with wildcard
-bw list-workspaces "my-*"
-
-# List all workspace scripts
-bw list-scripts
-
-# List script names only
-bw list-scripts --name-only
-
-# Get info about a workspace
-bw workspace-info my-workspace
-bw info my-workspace
-
-# Get info about a script
-bw script-info my-script
-
-# Only print list of workspace names that have the script
-bw script-info my-script --workspaces-only
+# Usage (--help can also be passed to any command)
+bw help
+bw --help
 
-# Get JSON output
+# Get JSON metadata
 bw list-workspaces --json --pretty # optionally pretty print JSON
 bw list-scripts --json
 bw workspace-info my-workspace --json
 bw script-info my-script --json
 
-# Run a script for all
-# workspaces that have it
-# in their `scripts` field
+# Run scripts across workspaces
 bw run my-script
-
-# By default, a prefix is added to the script output with the workspace name
-# This can be disabled with the --noPrefix option
-bw run my-script --noPrefix
-
-# Run a script for a specific workspace by its package.json name or alias from the config
 bw run my-script my-workspace
-
-# Run a script for multiple workspaces
 bw run my-script workspace-a workspace-b
-
-# Run a script for workspaces using wildcard (does not take into account workspace aliases)
 bw run my-script "my-workspace-*"
-
-# Run script in parallel for all workspaces
 bw run my-script --parallel
-
-# Append args to each script call
 bw run my-script --args "--my --args"
-
-# Use the workspace name in args
 bw run my-script --args "--my --args=<workspace>"
-
-# Help (--help can also be passed to any command)
-bw help
-bw --help
-
-# Pass --cwd to any command
-bw --cwd /path/to/your/project ls
-bw --cwd /path/to/your/project run-script my-script
-
-# Pass --configFile to any command
-bw --configFile /path/to/your/config.json ls
-
-# Pass --logLevel to any command (debug, info, warn, error, or silent)
-bw --logLevel silent run my-script
 ```

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "bun-workspaces",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-alpha.8",
+  "license": "MIT",
   "main": "src/index.mjs",
   "types": "src/index.d.ts",
   "homepage": "https://github.com/ScottMorse/bun-workspaces",

package/src/cli/{cli.d.ts → createCli.d.ts}

@@ -10,4 +10,4 @@ export interface CreateCliProgramOptions {
     postInit?: (program: Command) => unknown;
     defaultCwd?: string;
 }
-export declare const createCliProgram: ({ handleError, postInit, defaultCwd, }?: CreateCliProgramOptions) => CliProgram;
+export declare const createCli: ({ handleError, postInit, defaultCwd, }?: CreateCliProgramOptions) => CliProgram;

package/src/cli/{cli.mjs → createCli.mjs}

@@ -2,9 +2,9 @@ import { createCommand } from "commander";
 import package_0 from "../../package.json";
 import { getRequiredBunVersion, validateCurrentBunVersion } from "../internal/bunVersion.mjs";
 import { logger } from "../internal/logger.mjs";
-import { initializeWithGlobalOptions } from "./globalOptions.mjs";
-import { defineProjectCommands } from "./projectCommands.mjs";
-const createCliProgram = ({ handleError, postInit, defaultCwd = process.cwd() } = {})=>{
+import { initializeWithGlobalOptions } from "./globalOptions/index.mjs";
+import { defineProjectCommands } from "./projectCommands/index.mjs";
+const createCli = ({ handleError, postInit, defaultCwd = process.cwd() } = {})=>{
     const run = async ({ argv = process.argv } = {})=>{
         const errorListener = handleError ?? ((error)=>{
             logger.error(error);
@@ -40,4 +40,4 @@ const createCliProgram = ({ handleError, postInit, defaultCwd = process.cwd() }
         run
     };
 };
-export { createCliProgram };
+export { createCli };

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

@@ -0,0 +1,4 @@
+import { type Command } from "commander";
+export declare const initializeWithGlobalOptions: (program: Command, args: string[], defaultCwd: string) => {
+    project: import("../..").Project;
+};

package/src/cli/{globalOptions.mjs → globalOptions/globalOptions.mjs}

@@ -1,15 +1,21 @@
 import path from "path";
 import { Option } from "commander";
-import { loadConfigFile } from "../config/index.mjs";
-import { LOG_LEVELS, logger } from "../internal/logger.mjs";
-import { createProject } from "../project/index.mjs";
+import { loadConfigFile } from "../../config/index.mjs";
+import { logger } from "../../internal/logger.mjs";
+import { createProject } from "../../project/index.mjs";
+import { getCliGlobalOptionConfig } from "./globalOptionsConfig.mjs";
+const addGlobalOption = (program, optionName, defaultOverride)=>{
+    const { mainOption, shortOption, description, param, values, defaultValue } = getCliGlobalOptionConfig(optionName);
+    const option = new Option(`${shortOption} ${mainOption}${param ? ` <${param}>` : ""}`, description).default(defaultOverride ?? defaultValue);
+    program.addOption(values?.length ? option.choices(values) : option);
+};
 const getWorkingDirectory = (program, args, defaultCwd)=>{
-    program.addOption(new Option("-d --cwd <path>", "Working directory").default(defaultCwd));
+    addGlobalOption(program, "cwd", defaultCwd);
     program.parseOptions(args);
     return program.opts().cwd;
 };
 const getConfig = (program, args)=>{
-    program.addOption(new Option("-c --configFile <path>", "Config file"));
+    addGlobalOption(program, "configFile");
     program.parseOptions(args);
     return program.opts().configFile;
 };
@@ -17,22 +23,7 @@ const defineGlobalOptions = (program, args, defaultCwd)=>{
     const cwd = getWorkingDirectory(program, args, defaultCwd);
     const configFilePath = getConfig(program, args);
     const config = loadConfigFile(configFilePath, cwd);
-    const globalOptions = {
-        logLevel: {
-            shortName: "l",
-            description: "Log levels",
-            defaultValue: config?.cli?.logLevel ?? logger.printLevel,
-            values: [
-                ...LOG_LEVELS,
-                "silent"
-            ],
-            param: "level"
-        }
-    };
-    Object.entries(globalOptions).forEach(([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);
-    });
+    addGlobalOption(program, "logLevel");
     return {
         cwd,
         config

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

@@ -0,0 +1,37 @@
+import { type LogLevelSetting } from "../../internal/logger";
+export interface CliGlobalOptions {
+    logLevel: LogLevelSetting;
+    cwd: string;
+    configFile?: string;
+}
+export interface CliGlobalOptionConfig {
+    mainOption: string;
+    shortOption: string;
+    description: string;
+    defaultValue: string;
+    values: LogLevelSetting[] | null;
+    param: string;
+}
+export type CliGlobalOptionName = keyof CliGlobalOptions;
+export declare const getCliGlobalOptionConfig: (optionName: CliGlobalOptionName) => {
+    readonly mainOption: "--logLevel";
+    readonly shortOption: "-l";
+    readonly description: "Log levels";
+    readonly defaultValue: "info";
+    readonly values: ["debug", "info", "warn", "error", "silent"];
+    readonly param: "level";
+} | {
+    readonly mainOption: "--cwd";
+    readonly shortOption: "-d";
+    readonly description: "Working directory";
+    readonly defaultValue: ".";
+    readonly values: null;
+    readonly param: "path";
+} | {
+    readonly mainOption: "--configFile";
+    readonly shortOption: "-c";
+    readonly description: "Config file";
+    readonly defaultValue: "";
+    readonly values: null;
+    readonly param: "path";
+};

package/src/cli/globalOptions/globalOptionsConfig.mjs

@@ -0,0 +1,32 @@
+import { LOG_LEVELS } from "../../internal/logger.mjs";
+const CLI_GLOBAL_OPTIONS_CONFIG = {
+    logLevel: {
+        mainOption: "--logLevel",
+        shortOption: "-l",
+        description: "Log levels",
+        defaultValue: "info",
+        values: [
+            ...LOG_LEVELS,
+            "silent"
+        ],
+        param: "level"
+    },
+    cwd: {
+        mainOption: "--cwd",
+        shortOption: "-d",
+        description: "Working directory",
+        defaultValue: ".",
+        values: null,
+        param: "path"
+    },
+    configFile: {
+        mainOption: "--configFile",
+        shortOption: "-c",
+        description: "Config file",
+        defaultValue: "",
+        values: null,
+        param: "path"
+    }
+};
+const getCliGlobalOptionConfig = (optionName)=>CLI_GLOBAL_OPTIONS_CONFIG[optionName];
+export { getCliGlobalOptionConfig };

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

@@ -0,0 +1,2 @@
+export * from "./globalOptionsConfig";
+export * from "./globalOptions";

package/src/cli/globalOptions/index.mjs

@@ -0,0 +1,2 @@
+export * from "./globalOptionsConfig.mjs";
+export * from "./globalOptions.mjs";

package/src/cli/index.d.ts

@@ -1 +1 @@
-export { createCliProgram as createCli } from "./cli";
+export { createCli } from "./createCli";

package/src/cli/index.mjs

@@ -1,2 +1,2 @@
-import { createCliProgram } from "./cli.mjs";
-export { createCliProgram as createCli };
+import { createCli } from "./createCli.mjs";
+export { createCli };

package/src/cli/projectCommands/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./projectCommandHandlers";
+export * from "./projectCommandsConfig";

package/src/cli/projectCommands/index.mjs

@@ -0,0 +1,2 @@
+export * from "./projectCommandHandlers.mjs";
+export * from "./projectCommandsConfig.mjs";

package/src/cli/projectCommands/projectCommandHandlers.d.ts

@@ -0,0 +1,8 @@
+import { type Command } from "commander";
+import type { Project } from "../../project";
+export interface ProjectCommandContext {
+    project: Project;
+    program: Command;
+}
+export declare const commandOutputLogger: import("../../internal/logger").Logger;
+export declare const defineProjectCommands: (context: ProjectCommandContext) => void;

package/src/cli/projectCommands/projectCommandHandlers.mjs

@@ -0,0 +1,180 @@
+import { BunWorkspacesError } from "../../internal/error.mjs";
+import { createLogger, logger } from "../../internal/logger.mjs";
+import { getProjectCommandConfig } from "./projectCommandsConfig.mjs";
+const createWorkspaceInfoLines = (workspace)=>[
+        `Workspace: ${workspace.name}`,
+        ` - Aliases: ${workspace.aliases.join(", ")}`,
+        ` - Path: ${workspace.path}`,
+        ` - Glob Match: ${workspace.matchPattern}`,
+        ` - Scripts: ${Object.keys(workspace.packageJson.scripts).sort().join(", ")}`
+    ];
+const createScriptInfoLines = (script, workspaces)=>[
+        `Script: ${script}`,
+        ...workspaces.map((workspace)=>` - ${workspace.name}`)
+    ];
+const createJsonLines = (data, options)=>JSON.stringify(data, null, options.pretty ? 2 : void 0).split("\n");
+const commandOutputLogger = createLogger("");
+commandOutputLogger.printLevel = "info";
+const handleCommand = (commandName, handler)=>{
+    const config = getProjectCommandConfig(commandName);
+    return ({ program, project })=>{
+        program = program.command(config.command).aliases(config.aliases).description(config.description);
+        for (const option of Object.values(config.options))program.option(option.flags, option.description);
+        program = program.action((...actionArgs)=>handler({
+                program,
+                project
+            }, ...actionArgs));
+        return program;
+    };
+};
+const listWorkspaces = handleCommand("listWorkspaces", ({ project }, pattern, options)=>{
+    logger.debug(`Command: List workspaces (options: ${JSON.stringify(options)})`);
+    const lines = [];
+    const workspaces = pattern ? project.findWorkspacesByPattern(pattern) : project.workspaces;
+    if (options.json) lines.push(...createJsonLines(options.nameOnly ? workspaces.map(({ name })=>name) : workspaces, options));
+    else workspaces.forEach((workspace)=>{
+        if (options.nameOnly) lines.push(workspace.name);
+        else lines.push(...createWorkspaceInfoLines(workspace));
+    });
+    if (!lines.length) logger.info("No workspaces found");
+    if (lines.length) commandOutputLogger.info(lines.join("\n"));
+});
+const listScripts = handleCommand("listScripts", ({ project }, options)=>{
+    logger.debug(`Command: List scripts (options: ${JSON.stringify(options)})`);
+    const scripts = project.listScriptsWithWorkspaces();
+    const lines = [];
+    if (options.json) lines.push(...createJsonLines(options.nameOnly ? Object.keys(scripts) : Object.values(scripts).map(({ workspaces, ...rest })=>({
+            ...rest,
+            workspaces: workspaces.map(({ name })=>name)
+        })), options));
+    else {
+        Object.values(scripts).sort(({ name: nameA }, { name: nameB })=>nameA.localeCompare(nameB)).forEach(({ name, workspaces })=>{
+            if (options.nameOnly) lines.push(name);
+            else lines.push(...createScriptInfoLines(name, workspaces));
+        });
+        if (!lines.length) logger.info("No scripts found");
+    }
+    if (lines.length) commandOutputLogger.info(lines.join("\n"));
+});
+const workspaceInfo = handleCommand("workspaceInfo", ({ project }, workspaceName, options)=>{
+    logger.debug(`Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`);
+    const workspace = project.findWorkspaceByNameOrAlias(workspaceName);
+    if (!workspace) return void logger.error(`Workspace not found: (options: ${JSON.stringify(workspaceName)})`);
+    commandOutputLogger.info((options.json ? createJsonLines(workspace, options) : createWorkspaceInfoLines(workspace)).join("\n"));
+});
+const scriptInfo = handleCommand("scriptInfo", ({ project }, script, options)=>{
+    logger.debug(`Command: Script info for ${script} (options: ${JSON.stringify(options)})`);
+    const scripts = project.listScriptsWithWorkspaces();
+    const scriptMetadata = scripts[script];
+    if (!scriptMetadata) return void logger.error(`Script not found: ${JSON.stringify(script)} (available: ${Object.keys(scripts).join(", ")})`);
+    commandOutputLogger.info((options.json ? createJsonLines(options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : {
+        name: scriptMetadata.name,
+        workspaces: scriptMetadata.workspaces.map(({ name })=>name)
+    }, options) : options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : createScriptInfoLines(script, scriptMetadata.workspaces)).join("\n"));
+});
+const runScript = handleCommand("runScript", async ({ project }, script, _workspaces, options)=>{
+    logger.debug(`Command: Run script ${JSON.stringify(script)} for ${_workspaces.length ? "workspaces " + _workspaces.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, args: ${JSON.stringify(options.args)})`);
+    const workspaces = _workspaces.length ? _workspaces.flatMap((workspacePattern)=>{
+        if (workspacePattern.includes("*")) return project.findWorkspacesByPattern(workspacePattern).filter(({ packageJson: { scripts } })=>scripts?.[script]).map(({ name })=>name);
+        return [
+            workspacePattern
+        ];
+    }).filter((workspace)=>project.workspaces.some(({ name })=>name === workspace)) : project.listWorkspacesWithScript(script).map(({ name })=>name);
+    if (!workspaces.length) {
+        if (1 === _workspaces.length && !_workspaces[0].includes("*")) {
+            const message = `Workspace not found: ${JSON.stringify(_workspaces[0])}`;
+            logger.error(message);
+            throw new Error(message);
+        }
+        const message = `No ${_workspaces.length ? "matching " : ""}workspaces found for script ${JSON.stringify(script)}`;
+        logger.error(message);
+        throw new Error(message);
+    }
+    const scriptCommands = workspaces.map((workspaceName)=>project.createScriptCommand({
+            scriptName: script,
+            workspaceName,
+            method: "cd",
+            args: options.args?.replace(/<workspace>/g, workspaceName) ?? ""
+        }));
+    const runCommand = async ({ command, scriptName, workspace })=>{
+        const commandLogger = createLogger(`${workspace.name}:${scriptName}`);
+        const splitCommand = command.command.split(/\s+/g);
+        commandLogger.debug(`Running script ${scriptName} in workspace ${workspace.name} (cwd: ${command.cwd}): ${splitCommand.join(" ")}`);
+        const isSilent = "silent" === logger.printLevel;
+        const proc = Bun.spawn(command.command.split(/\s+/g), {
+            cwd: command.cwd,
+            env: {
+                ...process.env,
+                FORCE_COLOR: "1"
+            },
+            stdout: isSilent ? "ignore" : "pipe",
+            stderr: isSilent ? "ignore" : "pipe"
+        });
+        const linePrefix = options.noPrefix ? "" : `[${workspace.name}:${scriptName}] `;
+        if (proc.stdout) for await (const chunk of proc.stdout)commandLogger.logOutput(chunk, "info", process.stdout, linePrefix);
+        if (proc.stderr) for await (const chunk of proc.stderr)commandLogger.logOutput(chunk, "error", process.stderr, linePrefix);
+        await proc.exited;
+        return {
+            scriptName,
+            workspace,
+            command,
+            success: 0 === proc.exitCode,
+            error: 0 === proc.exitCode ? null : new BunWorkspacesError(`Script exited with code ${proc.exitCode}`)
+        };
+    };
+    const results = [];
+    if (options.parallel) {
+        let i = 0;
+        for await (const result of (await Promise.allSettled(scriptCommands.map(runCommand)))){
+            if ("rejected" === result.status) results.push({
+                success: false,
+                workspaceName: workspaces[i],
+                error: result.reason
+            });
+            else results.push({
+                success: result.value.success,
+                workspaceName: workspaces[i],
+                error: result.value.error
+            });
+            i++;
+        }
+    } else {
+        let i = 0;
+        for (const command of scriptCommands){
+            try {
+                const result = await runCommand(command);
+                results.push({
+                    success: result.success,
+                    workspaceName: workspaces[i],
+                    error: result.error
+                });
+            } catch (error) {
+                results.push({
+                    success: false,
+                    workspaceName: workspaces[i],
+                    error: error
+                });
+            }
+            i++;
+        }
+    }
+    let failCount = 0;
+    results.forEach(({ success, workspaceName })=>{
+        if (!success) failCount++;
+        logger.info(`${success ? "✅" : "❌"} ${workspaceName}: ${script}`);
+    });
+    const s = 1 === results.length ? "" : "s";
+    if (failCount) {
+        const message = `${failCount} of ${results.length} script${s} failed`;
+        logger.error(message);
+        process.exit(1);
+    } else logger.info(`${results.length} script${s} ran successfully`);
+});
+const defineProjectCommands = (context)=>{
+    listWorkspaces(context);
+    listScripts(context);
+    workspaceInfo(context);
+    scriptInfo(context);
+    runScript(context);
+};
+export { commandOutputLogger, defineProjectCommands };

package/src/cli/projectCommands/projectCommandsConfig.d.ts

@@ -0,0 +1,191 @@
+export interface ProjectCommandConfig {
+    command: string;
+    aliases: string[];
+    description: string;
+    options: Record<string, {
+        flags: string;
+        description: string;
+    }>;
+}
+export type ProjectCommandName = keyof typeof PROJECT_COMMANDS_CONFIG;
+declare const PROJECT_COMMANDS_CONFIG: {
+    readonly listWorkspaces: {
+        readonly command: "list-workspaces [pattern]";
+        readonly aliases: ["ls", "list"];
+        readonly description: "List all workspaces";
+        readonly options: {
+            readonly nameOnly: {
+                readonly flags: "--name-only";
+                readonly description: "Only show workspace names";
+            };
+            readonly json: {
+                readonly flags: "--json";
+                readonly description: "Output as JSON";
+            };
+            readonly pretty: {
+                readonly flags: "--pretty";
+                readonly description: "Pretty print JSON";
+            };
+        };
+    };
+    readonly listScripts: {
+        readonly command: "list-scripts";
+        readonly aliases: [];
+        readonly description: "List all scripts available with their workspaces";
+        readonly options: {
+            readonly nameOnly: {
+                readonly flags: "--name-only";
+                readonly description: "Only show script names";
+            };
+            readonly json: {
+                readonly flags: "--json";
+                readonly description: "Output as JSON";
+            };
+            readonly pretty: {
+                readonly flags: "--pretty";
+                readonly description: "Pretty print JSON";
+            };
+        };
+    };
+    readonly workspaceInfo: {
+        readonly command: "workspace-info <workspace>";
+        readonly aliases: ["info"];
+        readonly description: "Show information about a workspace";
+        readonly options: {
+            readonly json: {
+                readonly flags: "--json";
+                readonly description: "Output as JSON";
+            };
+            readonly pretty: {
+                readonly flags: "--pretty";
+                readonly description: "Pretty print JSON";
+            };
+        };
+    };
+    readonly scriptInfo: {
+        readonly command: "script-info <script>";
+        readonly aliases: [];
+        readonly description: "Show information about a script";
+        readonly options: {
+            readonly workspacesOnly: {
+                readonly flags: "--workspaces-only";
+                readonly description: "Only show script's workspace names";
+            };
+            readonly json: {
+                readonly flags: "--json";
+                readonly description: "Output as JSON";
+            };
+            readonly pretty: {
+                readonly flags: "--pretty";
+                readonly description: "Pretty print JSON";
+            };
+        };
+    };
+    readonly runScript: {
+        readonly command: "run <script> [workspaces...]";
+        readonly aliases: [];
+        readonly description: "Run a script in all workspaces that have it in their \"scripts\" field in package.json";
+        readonly options: {
+            readonly parallel: {
+                readonly flags: "--parallel";
+                readonly description: "Run the scripts in parallel";
+            };
+            readonly args: {
+                readonly flags: "--args <args>";
+                readonly description: "Args to append to the script command";
+            };
+            readonly noPrefix: {
+                readonly flags: "--noPrefix";
+                readonly description: "Do not prefix the workspace name to the script output";
+            };
+        };
+    };
+};
+export declare const getProjectCommandConfig: (commandName: ProjectCommandName) => {
+    readonly command: "list-workspaces [pattern]";
+    readonly aliases: ["ls", "list"];
+    readonly description: "List all workspaces";
+    readonly options: {
+        readonly nameOnly: {
+            readonly flags: "--name-only";
+            readonly description: "Only show workspace names";
+        };
+        readonly json: {
+            readonly flags: "--json";
+            readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+            readonly flags: "--pretty";
+            readonly description: "Pretty print JSON";
+        };
+    };
+} | {
+    readonly command: "list-scripts";
+    readonly aliases: [];
+    readonly description: "List all scripts available with their workspaces";
+    readonly options: {
+        readonly nameOnly: {
+            readonly flags: "--name-only";
+            readonly description: "Only show script names";
+        };
+        readonly json: {
+            readonly flags: "--json";
+            readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+            readonly flags: "--pretty";
+            readonly description: "Pretty print JSON";
+        };
+    };
+} | {
+    readonly command: "workspace-info <workspace>";
+    readonly aliases: ["info"];
+    readonly description: "Show information about a workspace";
+    readonly options: {
+        readonly json: {
+            readonly flags: "--json";
+            readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+            readonly flags: "--pretty";
+            readonly description: "Pretty print JSON";
+        };
+    };
+} | {
+    readonly command: "script-info <script>";
+    readonly aliases: [];
+    readonly description: "Show information about a script";
+    readonly options: {
+        readonly workspacesOnly: {
+            readonly flags: "--workspaces-only";
+            readonly description: "Only show script's workspace names";
+        };
+        readonly json: {
+            readonly flags: "--json";
+            readonly description: "Output as JSON";
+        };
+        readonly pretty: {
+            readonly flags: "--pretty";
+            readonly description: "Pretty print JSON";
+        };
+    };
+} | {
+    readonly command: "run <script> [workspaces...]";
+    readonly aliases: [];
+    readonly description: "Run a script in all workspaces that have it in their \"scripts\" field in package.json";
+    readonly options: {
+        readonly parallel: {
+            readonly flags: "--parallel";
+            readonly description: "Run the scripts in parallel";
+        };
+        readonly args: {
+            readonly flags: "--args <args>";
+            readonly description: "Args to append to the script command";
+        };
+        readonly noPrefix: {
+            readonly flags: "--noPrefix";
+            readonly description: "Do not prefix the workspace name to the script output";
+        };
+    };
+};
+export {};

package/src/cli/projectCommands/projectCommandsConfig.mjs

@@ -0,0 +1,100 @@
+const PROJECT_COMMANDS_CONFIG = {
+    listWorkspaces: {
+        command: "list-workspaces [pattern]",
+        aliases: [
+            "ls",
+            "list"
+        ],
+        description: "List all workspaces",
+        options: {
+            nameOnly: {
+                flags: "--name-only",
+                description: "Only show workspace names"
+            },
+            json: {
+                flags: "--json",
+                description: "Output as JSON"
+            },
+            pretty: {
+                flags: "--pretty",
+                description: "Pretty print JSON"
+            }
+        }
+    },
+    listScripts: {
+        command: "list-scripts",
+        aliases: [],
+        description: "List all scripts available with their workspaces",
+        options: {
+            nameOnly: {
+                flags: "--name-only",
+                description: "Only show script names"
+            },
+            json: {
+                flags: "--json",
+                description: "Output as JSON"
+            },
+            pretty: {
+                flags: "--pretty",
+                description: "Pretty print JSON"
+            }
+        }
+    },
+    workspaceInfo: {
+        command: "workspace-info <workspace>",
+        aliases: [
+            "info"
+        ],
+        description: "Show information about a workspace",
+        options: {
+            json: {
+                flags: "--json",
+                description: "Output as JSON"
+            },
+            pretty: {
+                flags: "--pretty",
+                description: "Pretty print JSON"
+            }
+        }
+    },
+    scriptInfo: {
+        command: "script-info <script>",
+        aliases: [],
+        description: "Show information about a script",
+        options: {
+            workspacesOnly: {
+                flags: "--workspaces-only",
+                description: "Only show script's workspace names"
+            },
+            json: {
+                flags: "--json",
+                description: "Output as JSON"
+            },
+            pretty: {
+                flags: "--pretty",
+                description: "Pretty print JSON"
+            }
+        }
+    },
+    runScript: {
+        command: "run <script> [workspaces...]",
+        aliases: [],
+        description: 'Run a script in all workspaces that have it in their "scripts" field in package.json',
+        options: {
+            parallel: {
+                flags: "--parallel",
+                description: "Run the scripts in parallel"
+            },
+            args: {
+                flags: "--args <args>",
+                description: "Args to append to the script command"
+            },
+            noPrefix: {
+                flags: "--noPrefix",
+                description: "Do not prefix the workspace name to the script output"
+            }
+        }
+    }
+};
+const getProjectCommandConfig = (commandName)=>PROJECT_COMMANDS_CONFIG[commandName];
+export { getProjectCommandConfig };

package/src/config/configFile.d.ts

@@ -1,3 +1,3 @@
 import { type BunWorkspacesConfig } from "./bunWorkspacesConfig";
 export declare const DEFAULT_CONFIG_FILE_PATH = "bw.json";
-export declare const loadConfigFile: (filePath?: string | undefined, rootDir?: string) => BunWorkspacesConfig | null;
+export declare const loadConfigFile: (filePath?: string, rootDir?: string) => BunWorkspacesConfig | null;

package/src/internal/bunVersion.d.ts

@@ -1,14 +1,14 @@
 export declare const LIBRARY_CONSUMER_BUN_VERSION: string;
 export declare const BUILD_BUN_VERSION: string;
-export declare const getRequiredBunVersion: (build?: boolean | undefined) => string;
+export declare const getRequiredBunVersion: (build?: boolean) => string;
 /**
  * Validates that the provided version satisfies the required Bun version
  * specified in the root `package.json`.
  */
-export declare const validateBunVersion: (version: string, build?: boolean | undefined) => boolean;
+export declare const validateBunVersion: (version: string, build?: boolean) => boolean;
 /**
  *
  * Validates that the Bun version of the current script satisfies the
  * required Bun version specified in the root `package.json`.
  */
-export declare const validateCurrentBunVersion: (build?: boolean | undefined) => boolean;
+export declare const validateCurrentBunVersion: (build?: boolean) => boolean;

package/src/internal/env.mjs

@@ -1,9 +1,12 @@
+const _process = "undefined" == typeof process ? {
+    env: {}
+} : process;
 const RUNTIME_MODE_VALUES = [
     "development",
     "production",
     "test"
 ];
-const _RUNTIME_MODE = process.env._BW_RUNTIME_MODE || (process.env.NODE_ENV?.match(/test(ing)?/) ? "test" : "development" === process.env.NODE_ENV ? "development" : "production");
+const _RUNTIME_MODE = _process.env._BW_RUNTIME_MODE || (process.env.NODE_ENV?.match(/test(ing)?/) ? "test" : "development" === process.env.NODE_ENV ? "development" : "production");
 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(", ")}.`);
 const IS_TEST = "test" === RUNTIME_MODE;

package/src/workspaces/errors.d.ts

@@ -1 +1 @@
-export declare const ERRORS: import("../internal/error").DefinedErrors<"AliasConflict" | "AliasedWorkspaceNotFound" | "DuplicateWorkspaceName" | "InvalidPackageJson" | "InvalidScripts" | "InvalidWorkspaceName" | "InvalidWorkspacePattern" | "InvalidWorkspaces" | "NoWorkspaceName" | "PackageNotFound">;
+export declare const ERRORS: import("../internal/error").DefinedErrors<"PackageNotFound" | "InvalidPackageJson" | "DuplicateWorkspaceName" | "InvalidWorkspaceName" | "NoWorkspaceName" | "InvalidScripts" | "InvalidWorkspaces" | "InvalidWorkspacePattern" | "AliasConflict" | "AliasedWorkspaceNotFound">;

package/src/workspaces/findWorkspaces.d.ts

@@ -8,10 +8,10 @@ export interface FindWorkspacesOptions {
 export declare const findWorkspaces: ({ rootDir, workspaceGlobs, workspaceAliases, }: FindWorkspacesOptions) => {
     workspaces: Workspace[];
 };
-export declare const validateWorkspaceAliases: (workspaces: Workspace[], workspaceAliases: Record<string, string> | undefined) => void;
+export declare const validateWorkspaceAliases: (workspaces: Workspace[], workspaceAliases: ProjectConfig["workspaceAliases"]) => void;
 export declare const findWorkspacesFromPackage: ({ rootDir, workspaceAliases, }: ProjectConfig & {
     rootDir: string;
 }) => {
-    workspaces: Workspace[];
     name: string;
+    workspaces: Workspace[];
 };

package/src/workspaces/packageJson.d.ts

@@ -5,4 +5,4 @@ export type ResolvedPackageJsonContent = {
     scripts: Record<string, string>;
 } & Record<string, unknown>;
 export declare const scanWorkspaceGlob: (pattern: string, rootDir: string) => Generator<string, void, void>;
-export declare const resolvePackageJsonContent: (packageJsonPath: string, rootDir: string, validations: ("name" | "scripts" | "workspaces")[]) => ResolvedPackageJsonContent;
+export declare const resolvePackageJsonContent: (packageJsonPath: string, rootDir: string, validations: ("workspaces" | "name" | "scripts")[]) => ResolvedPackageJsonContent;

package/src/cli/globalOptions.d.ts

@@ -1,11 +0,0 @@
-import { type Command } from "commander";
-import { type LogLevelSetting } from "../internal/logger";
-export interface CliGlobalOptions {
-    logLevel: LogLevelSetting;
-    cwd: string;
-    configFile?: string;
-}
-export type CliGlobalOptionName = keyof CliGlobalOptions;
-export declare const initializeWithGlobalOptions: (program: Command, args: string[], defaultCwd: string) => {
-    project: import("..").Project;
-};

package/src/cli/projectCommands.d.ts

@@ -1,8 +0,0 @@
-import { type Command } from "commander";
-import type { Project } from "../project";
-export interface ProjectCommandsContext {
-    project: Project;
-    program: Command;
-}
-export declare const commandOutputLogger: import("../internal/logger").Logger;
-export declare const defineProjectCommands: (context: ProjectCommandsContext) => void;

package/src/cli/projectCommands.mjs

@@ -1,179 +0,0 @@
-import { BunWorkspacesError } from "../internal/error.mjs";
-import { createLogger, logger } from "../internal/logger.mjs";
-const createWorkspaceInfoLines = (workspace)=>[
-        `Workspace: ${workspace.name}`,
-        ` - Aliases: ${workspace.aliases.join(", ")}`,
-        ` - Path: ${workspace.path}`,
-        ` - Glob Match: ${workspace.matchPattern}`,
-        ` - Scripts: ${Object.keys(workspace.packageJson.scripts).sort().join(", ")}`
-    ];
-const createScriptInfoLines = (script, workspaces)=>[
-        `Script: ${script}`,
-        ...workspaces.map((workspace)=>` - ${workspace.name}`)
-    ];
-const createJsonLines = (data, options)=>JSON.stringify(data, null, options.pretty ? 2 : void 0).split("\n");
-const commandOutputLogger = createLogger("");
-commandOutputLogger.printLevel = "info";
-const listWorkspaces = ({ program, project })=>{
-    program.command("list-workspaces [pattern]").aliases([
-        "ls",
-        "list"
-    ]).description("List all workspaces").option("--name-only", "Only show workspace names").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((pattern, options)=>{
-        logger.debug(`Command: List workspaces (options: ${JSON.stringify(options)})`);
-        const lines = [];
-        const workspaces = pattern ? project.findWorkspacesByPattern(pattern) : project.workspaces;
-        if (options.json) lines.push(...createJsonLines(options.nameOnly ? workspaces.map(({ name })=>name) : workspaces, options));
-        else workspaces.forEach((workspace)=>{
-            if (options.nameOnly) lines.push(workspace.name);
-            else lines.push(...createWorkspaceInfoLines(workspace));
-        });
-        if (!lines.length) logger.info("No workspaces found");
-        if (lines.length) commandOutputLogger.info(lines.join("\n"));
-    });
-};
-const listScripts = ({ program, project })=>{
-    program.command("list-scripts").description("List all scripts available with their workspaces").option("--name-only", "Only show script names").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((options)=>{
-        logger.debug(`Command: List scripts (options: ${JSON.stringify(options)})`);
-        const scripts = project.listScriptsWithWorkspaces();
-        const lines = [];
-        if (options.json) lines.push(...createJsonLines(options.nameOnly ? Object.keys(scripts) : Object.values(scripts).map(({ workspaces, ...rest })=>({
-                ...rest,
-                workspaces: workspaces.map(({ name })=>name)
-            })), options));
-        else {
-            Object.values(scripts).sort(({ name: nameA }, { name: nameB })=>nameA.localeCompare(nameB)).forEach(({ name, workspaces })=>{
-                if (options.nameOnly) lines.push(name);
-                else lines.push(...createScriptInfoLines(name, workspaces));
-            });
-            if (!lines.length) logger.info("No scripts found");
-        }
-        if (lines.length) commandOutputLogger.info(lines.join("\n"));
-    });
-};
-const workspaceInfo = ({ program, project })=>{
-    program.command("workspace-info <workspace>").aliases([
-        "info"
-    ]).description("Show information about a workspace").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((workspaceName, options)=>{
-        logger.debug(`Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`);
-        const workspace = project.findWorkspaceByNameOrAlias(workspaceName);
-        if (!workspace) return void logger.error(`Workspace not found: (options: ${JSON.stringify(workspaceName)})`);
-        commandOutputLogger.info((options.json ? createJsonLines(workspace, options) : createWorkspaceInfoLines(workspace)).join("\n"));
-    });
-};
-const scriptInfo = ({ program, project })=>{
-    program.command("script-info <script>").description("Show information about a script").option("--workspaces-only", "Only show script's workspace names").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((script, options)=>{
-        logger.debug(`Command: Script info for ${script} (options: ${JSON.stringify(options)})`);
-        const scripts = project.listScriptsWithWorkspaces();
-        const scriptMetadata = scripts[script];
-        if (!scriptMetadata) return void logger.error(`Script not found: ${JSON.stringify(script)} (available: ${Object.keys(scripts).join(", ")})`);
-        commandOutputLogger.info((options.json ? createJsonLines(options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : {
-            name: scriptMetadata.name,
-            workspaces: scriptMetadata.workspaces.map(({ name })=>name)
-        }, options) : options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : createScriptInfoLines(script, scriptMetadata.workspaces)).join("\n"));
-    });
-};
-const runScript = ({ program, project })=>{
-    program.command("run <script> [workspaces...]").description("Run a script in all workspaces").option("--parallel", "Run the scripts in parallel").option("--args <args>", "Args to append to the script command", "").option("--noPrefix", "Do not prefix the workspace name to the script output", "").action(async (script, _workspaces, options)=>{
-        logger.debug(`Command: Run script ${JSON.stringify(script)} for ${_workspaces.length ? "workspaces " + _workspaces.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, method: ${JSON.stringify(options.method)}, args: ${JSON.stringify(options.args)})`);
-        const workspaces = _workspaces.length ? _workspaces.flatMap((workspacePattern)=>{
-            if (workspacePattern.includes("*")) return project.findWorkspacesByPattern(workspacePattern).filter(({ packageJson: { scripts } })=>scripts?.[script]).map(({ name })=>name);
-            return [
-                workspacePattern
-            ];
-        }) : project.listWorkspacesWithScript(script).map(({ name })=>name);
-        if (!workspaces.length) program.error(`No ${_workspaces.length ? "matching " : ""}workspaces found for script ${JSON.stringify(script)}`);
-        let scriptCommands;
-        try {
-            scriptCommands = workspaces.map((workspaceName)=>project.createScriptCommand({
-                    scriptName: script,
-                    workspaceName,
-                    method: "cd",
-                    args: options.args.replace(/<workspace>/g, workspaceName)
-                }));
-        } catch (error) {
-            program.error(error.message);
-            throw error;
-        }
-        const runCommand = async ({ command, scriptName, workspace })=>{
-            const commandLogger = createLogger(`${workspace.name}:${scriptName}`);
-            const splitCommand = command.command.split(/\s+/g);
-            commandLogger.debug(`Running script ${scriptName} in workspace ${workspace.name} (cwd: ${command.cwd}): ${splitCommand.join(" ")}`);
-            const isSilent = "silent" === logger.printLevel;
-            const proc = Bun.spawn(command.command.split(/\s+/g), {
-                cwd: command.cwd,
-                env: {
-                    ...process.env,
-                    FORCE_COLOR: "1"
-                },
-                stdout: isSilent ? "ignore" : "pipe",
-                stderr: isSilent ? "ignore" : "pipe"
-            });
-            const linePrefix = options.noPrefix ? "" : `[${workspace.name}:${scriptName}] `;
-            if (proc.stdout) for await (const chunk of proc.stdout)commandLogger.logOutput(chunk, "info", process.stdout, linePrefix);
-            if (proc.stderr) for await (const chunk of proc.stderr)commandLogger.logOutput(chunk, "error", process.stderr, linePrefix);
-            await proc.exited;
-            return {
-                scriptName,
-                workspace,
-                command,
-                success: 0 === proc.exitCode,
-                error: 0 === proc.exitCode ? null : new BunWorkspacesError(`Script exited with code ${proc.exitCode}`)
-            };
-        };
-        const results = [];
-        if (options.parallel) {
-            let i = 0;
-            for await (const result of (await Promise.allSettled(scriptCommands.map(runCommand)))){
-                if ("rejected" === result.status) results.push({
-                    success: false,
-                    workspaceName: workspaces[i],
-                    error: result.reason
-                });
-                else results.push({
-                    success: result.value.success,
-                    workspaceName: workspaces[i],
-                    error: result.value.error
-                });
-                i++;
-            }
-        } else {
-            let i = 0;
-            for (const command of scriptCommands){
-                try {
-                    const result = await runCommand(command);
-                    results.push({
-                        success: result.success,
-                        workspaceName: workspaces[i],
-                        error: result.error
-                    });
-                } catch (error) {
-                    results.push({
-                        success: false,
-                        workspaceName: workspaces[i],
-                        error: error
-                    });
-                }
-                i++;
-            }
-        }
-        let failCount = 0;
-        results.forEach(({ success, workspaceName })=>{
-            if (!success) failCount++;
-            logger.info(`${success ? "✅" : "❌"} ${workspaceName}: ${script}`);
-        });
-        const s = 1 === results.length ? "" : "s";
-        if (failCount) {
-            const message = `${failCount} of ${results.length} script${s} failed`;
-            logger.error(message);
-            process.exit(1);
-        } else logger.info(`${results.length} script${s} ran successfully`);
-    });
-};
-const defineProjectCommands = (context)=>{
-    listWorkspaces(context);
-    listScripts(context);
-    workspaceInfo(context);
-    scriptInfo(context);
-    runScript(context);
-};
-export { commandOutputLogger, defineProjectCommands };