bun-workspaces 1.0.0-alpha.13 → 1.0.0-alpha.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-workspaces",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.15",
   "license": "MIT",
   "main": "src/index.mjs",
   "types": "src/index.d.ts",
@@ -10,11 +10,12 @@
     "url": "https://github.com/ScottMorse/bun-workspaces.git"
   },
   "bin": {
-    "bun-workspaces": "bin/cli.js"
+    "bun-workspaces": "bin/cli.js",
+    "bw": "bun-workspaces"
   },
   "custom": {
     "bunVersion": {
-      "build": "1.3.0",
+      "build": "1.3.1",
       "libraryConsumer": "^1.1.x"
     }
   },

package/src/cli/createCli.d.ts

@@ -1,6 +1,8 @@
 import { type Command } from "commander";
 export interface RunCliOptions {
     argv?: string | string[];
+    /** Should be `true` if args do not include the binary name (e.g. `bunx bun-workspaces`) */
+    programmatic?: true;
 }
 export interface CliProgram {
     run: (options?: RunCliOptions) => Promise<void>;

package/src/cli/createCli.mjs

@@ -1,25 +1,23 @@
 import { createCommand } from "commander";
 import package_0 from "../../package.json";
 import { getRequiredBunVersion, validateCurrentBunVersion } from "../internal/bunVersion.mjs";
+import { BunWorkspacesError } from "../internal/error.mjs";
 import { logger } from "../internal/logger.mjs";
+import { fatalErrorLogger } from "./fatalErrorLogger.mjs";
 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 run = async ({ argv = process.argv, programmatic } = {})=>{
         const errorListener = handleError ?? ((error)=>{
-            logger.error(error);
-            logger.error("Unhandled rejection");
+            fatalErrorLogger.error(error);
             process.exit(1);
         });
         process.on("unhandledRejection", errorListener);
         try {
-            const program = createCommand("bunx bun-workspaces").description("CLI for utilities for Bun workspaces").version(package_0.version).configureOutput({
-                writeOut: (s)=>logger.info(s),
-                writeErr: (s)=>s.startsWith("Usage") ? logger.info(s) : logger.error(s)
-            });
+            const program = createCommand("bunx bun-workspaces").description("A CLI on top of native Bun workspaces").version(package_0.version).showHelpAfterError(true);
             postInit?.(program);
             if (!validateCurrentBunVersion()) {
-                logger.error(`Bun version mismatch. Required: ${getRequiredBunVersion()}, Found: ${Bun.version}`);
+                fatalErrorLogger.error(`Bun version mismatch. Required: ${getRequiredBunVersion()}, Found: ${Bun.version}`);
                 process.exit(1);
             }
             const args = tempFixCamelCaseOptions("string" == typeof argv ? argv.split(/s+/) : argv);
@@ -29,9 +27,15 @@ const createCli = ({ handleError, postInit, defaultCwd = process.cwd() } = {})=>
                 program,
                 project
             });
-            await program.parseAsync(args);
+            await program.parseAsync(args, {
+                from: programmatic ? "user" : "node"
+            });
         } catch (error) {
-            errorListener(error);
+            if (error instanceof BunWorkspacesError) {
+                logger.debug(error);
+                fatalErrorLogger.error(error.message);
+                process.exit(1);
+            } else errorListener(error);
         } finally{
             process.off("unhandledRejection", errorListener);
         }

package/src/cli/fatalErrorLogger.d.ts

@@ -0,0 +1 @@
+export declare const fatalErrorLogger: import("../internal/logger").Logger;

package/src/cli/fatalErrorLogger.mjs

@@ -0,0 +1,4 @@
+import { createLogger } from "../internal/logger.mjs";
+const fatalErrorLogger = createLogger("fatalError");
+fatalErrorLogger.printLevel = "error";
+export { fatalErrorLogger };

package/src/cli/globalOptions/globalOptions.mjs

@@ -1,27 +1,35 @@
-import path from "path";
+import node_fs from "node:fs";
+import node_path from "node:path";
 import { Option } from "commander";
 import { loadConfigFile } from "../../config/index.mjs";
+import { defineErrors } from "../../internal/error.mjs";
 import { logger } from "../../internal/logger.mjs";
-import { createProject } from "../../project/index.mjs";
+import { createFileSystemProject } from "../../project/index.mjs";
 import { getCliGlobalOptionConfig } from "./globalOptionsConfig.mjs";
+const ERRORS = defineErrors("WorkingDirectoryNotFound", "WorkingDirectoryNotADirectory");
 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);
+    let option = new Option(`${shortOption} ${mainOption}${param ? ` <${param}>` : ""}`, description);
+    const effectiveDefaultValue = defaultOverride ?? defaultValue;
+    if (effectiveDefaultValue) option = option.default(effectiveDefaultValue);
+    if (values?.length) option = option.choices(values);
+    program.addOption(option);
 };
-const getWorkingDirectory = (program, args, defaultCwd)=>{
+const getWorkingDirectoryFromArgs = (program, args, defaultCwd)=>{
     addGlobalOption(program, "cwd", defaultCwd);
     program.parseOptions(args);
     return program.opts().cwd;
 };
-const getConfig = (program, args)=>{
+const getConfigFileFromArgs = (program, args)=>{
     addGlobalOption(program, "configFile");
     program.parseOptions(args);
     return program.opts().configFile;
 };
 const defineGlobalOptions = (program, args, defaultCwd)=>{
-    const cwd = getWorkingDirectory(program, args, defaultCwd);
-    const configFilePath = getConfig(program, args);
+    const cwd = getWorkingDirectoryFromArgs(program, args, defaultCwd);
+    if (!node_fs.existsSync(cwd)) throw new ERRORS.WorkingDirectoryNotFound(`Working directory not found at path "${cwd}"`);
+    if (!node_fs.statSync(cwd).isDirectory()) throw new ERRORS.WorkingDirectoryNotADirectory(`Working directory is not a directory at path "${cwd}"`);
+    const configFilePath = getConfigFileFromArgs(program, args);
     const config = loadConfigFile(configFilePath, cwd);
     addGlobalOption(program, "logLevel");
     return {
@@ -32,12 +40,12 @@ const defineGlobalOptions = (program, args, defaultCwd)=>{
 const applyGlobalOptions = (options, config)=>{
     logger.printLevel = options.logLevel;
     logger.debug("Log level: " + options.logLevel);
-    const project = createProject({
+    const project = createFileSystemProject({
         rootDir: options.cwd,
         workspaceAliases: config?.project?.workspaceAliases ?? {}
     });
     logger.debug(`Project: ${JSON.stringify(project.name)} (${project.workspaces.length} workspace${1 === project.workspaces.length ? "" : "s"})`);
-    logger.debug("Project root: " + path.resolve(project.rootDir));
+    logger.debug("Project root: " + node_path.resolve(project.rootDir));
     return {
         project
     };

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

@@ -35,3 +35,4 @@ export declare const getCliGlobalOptionConfig: (optionName: CliGlobalOptionName)
     readonly values: null;
     readonly param: "path";
 };
+export declare const getCliGlobalOptionNames: () => CliGlobalOptionName[];

package/src/cli/globalOptions/globalOptionsConfig.mjs

@@ -29,4 +29,5 @@ const CLI_GLOBAL_OPTIONS_CONFIG = {
     }
 };
 const getCliGlobalOptionConfig = (optionName)=>CLI_GLOBAL_OPTIONS_CONFIG[optionName];
-export { getCliGlobalOptionConfig };
+const getCliGlobalOptionNames = ()=>Object.keys(CLI_GLOBAL_OPTIONS_CONFIG);
+export { getCliGlobalOptionConfig, getCliGlobalOptionNames };

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

@@ -1,5 +1,6 @@
 import { type Command } from "commander";
 import type { Project } from "../../project";
+/** @todo DRY use of output text in cases such as having no workspaces/scripts */
 export interface ProjectCommandContext {
     project: Project;
     program: Command;

package/src/cli/projectCommands/projectCommandHandlers.mjs

@@ -6,7 +6,7 @@ const createWorkspaceInfoLines = (workspace)=>[
         ` - Aliases: ${workspace.aliases.join(", ")}`,
         ` - Path: ${workspace.path}`,
         ` - Glob Match: ${workspace.matchPattern}`,
-        ` - Scripts: ${Object.keys(workspace.packageJson.scripts).sort().join(", ")}`
+        ` - Scripts: ${workspace.scripts.join(", ")}`
     ];
 const createScriptInfoLines = (script, workspaces)=>[
         `Script: ${script}`,
@@ -36,37 +36,42 @@ const listWorkspaces = handleCommand("listWorkspaces", ({ project }, pattern, op
         if (options.nameOnly) lines.push(workspace.name);
         else lines.push(...createWorkspaceInfoLines(workspace));
     });
-    if (!lines.length) logger.info("No workspaces found");
+    if (!lines.length && !options.nameOnly) 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 (!project.workspaces.length && !options.nameOnly) return void logger.info("No workspaces found");
+    if (!Object.keys(scripts).length && !options.nameOnly) return void logger.info("No scripts found");
     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");
-    }
+    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) 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)})`);
+    if (!workspace) {
+        logger.error(`Workspace ${JSON.stringify(workspaceName)} not found`);
+        process.exit(1);
+    }
     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(", ")})`);
+    if (!scriptMetadata) {
+        logger.error(`Script not found: ${JSON.stringify(script)}`);
+        process.exit(1);
+    }
     commandOutputLogger.info((options.json ? createJsonLines(options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : {
         name: scriptMetadata.name,
         workspaces: scriptMetadata.workspaces.map(({ name })=>name)
@@ -75,98 +80,105 @@ const scriptInfo = handleCommand("scriptInfo", ({ project }, script, options)=>{
 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);
+        if (workspacePattern.includes("*")) return project.findWorkspacesByPattern(workspacePattern).filter(({ scripts })=>scripts.includes(script)).map(({ name })=>name);
         return [
             workspacePattern
         ];
-    }).filter((workspace)=>project.workspaces.some(({ name })=>name === workspace)) : project.listWorkspacesWithScript(script).map(({ name })=>name);
+    }).map((workspaceName)=>project.findWorkspaceByNameOrAlias(workspaceName)).filter(Boolean) : project.listWorkspacesWithScript(script);
     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);
+        if (1 !== _workspaces.length || _workspaces[0].includes("*")) logger.error(`No ${_workspaces.length ? "matching " : ""}workspaces found with script ${JSON.stringify(script)}`);
+        else logger.error(`Workspace not found: ${JSON.stringify(_workspaces[0])}`);
+        process.exit(1);
     }
-    const scriptCommands = workspaces.map((workspaceName)=>project.createScriptCommand({
+    const scriptCommands = workspaces.map((workspace)=>project.createScriptCommand({
             scriptName: script,
-            workspaceName,
+            workspaceName: workspace.name,
             method: "cd",
-            args: options.args?.replace(/<workspace>/g, workspaceName) ?? ""
+            args: options.args?.replace(/<workspace>/g, workspace.name) ?? ""
         }));
     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;
+        logger.debug(`Running script ${scriptName} in workspace ${workspace.name} (cwd: ${command.cwd}): ${splitCommand.join(" ")}`);
         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"
+            stdout: "pipe",
+            stderr: "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;
+        const pipeOutput = async (streamName)=>{
+            const stream = proc[streamName];
+            if (stream && "silent" !== logger.printLevel) for await (const chunk of stream)commandOutputLogger.logOutput(chunk, "info", process[streamName], linePrefix);
+        };
+        await Promise.all([
+            pipeOutput("stdout"),
+            pipeOutput("stderr"),
+            proc.exited
+        ]);
         return {
             scriptName,
             workspace,
             command,
             success: 0 === proc.exitCode,
+            exitCode: proc.exitCode,
             error: 0 === proc.exitCode ? null : new BunWorkspacesError(`Script exited with code ${proc.exitCode}`)
         };
     };
     const results = [];
-    if (options.parallel) {
+    const runParallel = async ()=>{
         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
+                workspaceName: workspaces[i].name,
+                error: result.reason,
+                exitCode: null
             });
             else results.push({
                 success: result.value.success,
-                workspaceName: workspaces[i],
-                error: result.value.error
+                workspaceName: workspaces[i].name,
+                error: result.value.error,
+                exitCode: result.value.exitCode
             });
             i++;
         }
-    } else {
+    };
+    const runSeries = async ()=>{
         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
+                    workspaceName: workspaces[i].name,
+                    error: result.error,
+                    exitCode: result.exitCode
                 });
             } catch (error) {
                 results.push({
                     success: false,
-                    workspaceName: workspaces[i],
-                    error: error
+                    workspaceName: workspaces[i].name,
+                    error: error,
+                    exitCode: null
                 });
             }
             i++;
         }
-    }
+    };
+    if (options.parallel) await runParallel();
+    else await runSeries();
     let failCount = 0;
-    results.forEach(({ success, workspaceName })=>{
+    results.forEach(({ success, workspaceName, exitCode })=>{
         if (!success) failCount++;
-        logger.info(`${success ? "✅" : "❌"} ${workspaceName}: ${script}`);
+        logger.info(`${success ? "✅" : "❌"} ${workspaceName}: ${script}${exitCode ? ` (exited with code ${exitCode})` : ""}`);
     });
     const s = 1 === results.length ? "" : "s";
     if (failCount) {
         const message = `${failCount} of ${results.length} script${s} failed`;
-        logger.error(message);
+        logger.info(message);
         process.exit(1);
     } else logger.info(`${results.length} script${s} ran successfully`);
 });

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

@@ -1,4 +1,4 @@
-export interface ProjectCommandConfig {
+export interface CliProjectCommandConfig {
     command: string;
     aliases: string[];
     description: string;
@@ -7,8 +7,8 @@ export interface ProjectCommandConfig {
         description: string;
     }>;
 }
-export type ProjectCommandName = keyof typeof PROJECT_COMMANDS_CONFIG;
-declare const PROJECT_COMMANDS_CONFIG: {
+export type CliProjectCommandName = keyof typeof CLI_PROJECT_COMMANDS_CONFIG;
+declare const CLI_PROJECT_COMMANDS_CONFIG: {
     readonly listWorkspaces: {
         readonly command: "list-workspaces [pattern]";
         readonly aliases: ["ls", "list"];
@@ -101,7 +101,7 @@ declare const PROJECT_COMMANDS_CONFIG: {
         };
     };
 };
-export declare const getProjectCommandConfig: (commandName: ProjectCommandName) => {
+export declare const getProjectCommandConfig: (commandName: CliProjectCommandName) => {
     readonly command: "list-workspaces [pattern]";
     readonly aliases: ["ls", "list"];
     readonly description: "List all workspaces";
@@ -188,4 +188,5 @@ export declare const getProjectCommandConfig: (commandName: ProjectCommandName)
         };
     };
 };
+export declare const getCliProjectCommandNames: () => CliProjectCommandName[];
 export {};

package/src/cli/projectCommands/projectCommandsConfig.mjs

@@ -1,4 +1,4 @@
-const PROJECT_COMMANDS_CONFIG = {
+const CLI_PROJECT_COMMANDS_CONFIG = {
     listWorkspaces: {
         command: "list-workspaces [pattern]",
         aliases: [
@@ -100,5 +100,6 @@ const PROJECT_COMMANDS_CONFIG = {
         }
     }
 };
-const getProjectCommandConfig = (commandName)=>PROJECT_COMMANDS_CONFIG[commandName];
-export { getProjectCommandConfig };
+const getProjectCommandConfig = (commandName)=>CLI_PROJECT_COMMANDS_CONFIG[commandName];
+const getCliProjectCommandNames = ()=>Object.keys(CLI_PROJECT_COMMANDS_CONFIG);
+export { getCliProjectCommandNames, getProjectCommandConfig };

package/src/config/bunWorkspacesConfig.mjs

@@ -1,17 +1,19 @@
 import { validateLogLevel } from "../internal/logger.mjs";
+import { ERRORS } from "./errors.mjs";
+const isJsonObject = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
 const validateCliConfig = (cliConfig)=>{
-    if ("object" != typeof cliConfig || Array.isArray(cliConfig)) throw new Error('Config file: "cli" must be an object');
+    if (!isJsonObject(cliConfig)) throw new ERRORS.InvalidConfigFile('Config file: "cli" must be an object');
     if (cliConfig?.logLevel) validateLogLevel(cliConfig.logLevel);
 };
 const validateProjectConfig = (projectConfig)=>{
-    if ("object" != typeof projectConfig || Array.isArray(projectConfig)) throw new Error('Config file: "project" must be an object');
-    if (projectConfig?.workspaceAliases) {
-        if ("object" != typeof projectConfig.workspaceAliases || Array.isArray(projectConfig.workspaceAliases)) throw new Error("Config file: project.workspaceAliases must be an object");
-        for (const alias of Object.values(projectConfig.workspaceAliases))if ("string" != typeof alias) throw new Error("Config file: project.workspaceAliases must be an object with string keys and values");
+    if (!isJsonObject(projectConfig)) throw new ERRORS.InvalidConfigFile('Config file: "project" must be an object');
+    if (projectConfig?.workspaceAliases !== void 0) {
+        if (!isJsonObject(projectConfig.workspaceAliases)) throw new ERRORS.InvalidConfigFile("Config file: project.workspaceAliases must be an object");
+        for (const alias of Object.values(projectConfig.workspaceAliases))if ("string" != typeof alias) throw new ERRORS.InvalidConfigFile("Config file: project.workspaceAliases must be an object with string keys and values");
     }
 };
 const validateBunWorkspacesConfig = (config)=>{
-    if ("object" != typeof config || Array.isArray(config)) throw new Error("Config file: must be an object");
+    if (!isJsonObject(config)) throw new ERRORS.InvalidConfigFile("Config file: must be an object");
     if (void 0 !== config.cli) validateCliConfig(config.cli);
     if (void 0 !== config.project) validateProjectConfig(config.project);
 };

package/src/config/configFile.mjs

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { validateBunWorkspacesConfig } from "./bunWorkspacesConfig.mjs";
+import { ERRORS } from "./errors.mjs";
 const DEFAULT_CONFIG_FILE_PATH = "bw.json";
 const loadConfigFile = (filePath, rootDir = ".")=>{
     if (!filePath) {
@@ -9,13 +10,15 @@ const loadConfigFile = (filePath, rootDir = ".")=>{
         filePath = defaultFilePath;
     }
     filePath = path.resolve(rootDir, filePath);
+    if (!fs.existsSync(filePath)) throw new ERRORS.ConfigFileNotFound(`Config file not found at path "${filePath}"`);
     const configFile = fs.readFileSync(filePath, "utf8");
+    let json = null;
     try {
-        const json = JSON.parse(configFile);
-        validateBunWorkspacesConfig(json);
-        return json;
+        json = JSON.parse(configFile);
     } catch (error) {
-        throw new Error(`Config file: "${filePath}" is not a valid JSON file: ${error}`);
+        throw new ERRORS.InvalidConfigFileFormat(`Failed to parse config file at path "${filePath}": ${error.message}`);
     }
+    if (json) validateBunWorkspacesConfig(json);
+    return json;
 };
 export { DEFAULT_CONFIG_FILE_PATH, loadConfigFile };

package/src/config/errors.d.ts

@@ -0,0 +1 @@
+export declare const ERRORS: import("../internal/error").DefinedErrors<"ConfigFileNotFound" | "InvalidConfigFile" | "InvalidConfigFileFormat">;

package/src/config/errors.mjs

@@ -0,0 +1,3 @@
+import { defineErrors } from "../internal/error.mjs";
+const ERRORS = defineErrors("ConfigFileNotFound", "InvalidConfigFile", "InvalidConfigFileFormat");
+export { ERRORS };

package/src/internal/logger.d.ts

@@ -2,7 +2,7 @@ export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
 export type LogLevel = (typeof LOG_LEVELS)[number];
 export type LogLevelSetting = LogLevel | "silent";
 export declare const validateLogLevel: (level: LogLevelSetting) => void;
-export type LogMetadata = Record<string, any>;
+export type LogMetadata = Record<string, unknown>;
 export interface Log<Message extends string | Error = string, Metadata extends LogMetadata = LogMetadata> {
     message: Message;
     level: LogLevel;

package/src/internal/logger.mjs

@@ -1,4 +1,5 @@
 import { IS_PRODUCTION, IS_TEST } from "./env.mjs";
+import { defineErrors } from "./error.mjs";
 const LOG_LEVELS = [
     "debug",
     "info",
@@ -6,9 +7,10 @@ const LOG_LEVELS = [
     "error"
 ];
 const getLevelNumber = (level)=>LOG_LEVELS.indexOf(level);
+const ERRORS = defineErrors("InvalidLogLevel");
 const validateLogLevel = (level)=>{
     if ("silent" === level) return;
-    if (!LOG_LEVELS.includes(level)) throw new Error(`Invalid log level: "${level}". Accepted values: ${LOG_LEVELS.join(", ")}`);
+    if (!LOG_LEVELS.includes(level)) throw new ERRORS.InvalidLogLevel(`Invalid log level: "${level}". Accepted values: ${LOG_LEVELS.join(", ")}`);
 };
 const createLogger = (name)=>new _Logger(name);
 class _Logger {

package/src/project/implementations/fileSystemProject.d.ts

@@ -0,0 +1,6 @@
+import { type Project } from "./projectBase";
+export interface CreateFileSystemProjectOptions {
+    rootDir: string;
+    workspaceAliases?: Record<string, string>;
+}
+export declare const createFileSystemProject: (options: CreateFileSystemProjectOptions) => Project;

package/src/project/implementations/fileSystemProject.mjs

@@ -0,0 +1,19 @@
+import { findWorkspacesFromPackage } from "../../workspaces/index.mjs";
+import { ProjectBase } from "./projectBase.mjs";
+class FileSystemProject extends ProjectBase {
+    rootDir;
+    workspaces;
+    name;
+    constructor(options){
+        super();
+        this.rootDir = options.rootDir;
+        const { name, workspaces } = findWorkspacesFromPackage({
+            rootDir: options.rootDir,
+            workspaceAliases: options.workspaceAliases
+        });
+        this.name = name;
+        this.workspaces = workspaces;
+    }
+}
+const createFileSystemProject = (options)=>new FileSystemProject(options);
+export { createFileSystemProject };

package/src/project/implementations/memoryProject.d.ts

@@ -0,0 +1,8 @@
+import { type Workspace } from "../../workspaces";
+import { type Project } from "./projectBase";
+export interface CreateMemoryProjectOptions {
+    name: string;
+    workspaces: Workspace[];
+    rootDir: string;
+}
+export declare const createMemoryProject: (options: CreateMemoryProjectOptions) => Project;

package/src/project/implementations/memoryProject.mjs

@@ -0,0 +1,14 @@
+import { ProjectBase } from "./projectBase.mjs";
+class MemoryProject extends ProjectBase {
+    rootDir;
+    workspaces;
+    name;
+    constructor(options){
+        super();
+        this.rootDir = options.rootDir;
+        this.name = options.name;
+        this.workspaces = options.workspaces;
+    }
+}
+const createMemoryProject = (options)=>new MemoryProject(options);
+export { createMemoryProject };

package/src/project/{project.d.ts → implementations/projectBase.d.ts}

@@ -1,5 +1,5 @@
-import { type Workspace } from "../workspaces";
-import { type CreateScriptCommandOptions, type ScriptCommand } from "./scriptCommand";
+import { type Workspace } from "../../workspaces";
+import { type CreateScriptCommandOptions, type ScriptCommand } from "../scriptCommand";
 export interface ScriptMetadata {
     name: string;
     workspaces: Workspace[];
@@ -24,8 +24,16 @@ export interface Project {
     findWorkspacesByPattern(workspaceName: string): Workspace[];
     createScriptCommand(options: CreateProjectScriptCommandOptions): CreateProjectScriptCommandResult;
 }
-export interface CreateProjectOptions {
-    rootDir: string;
-    workspaceAliases?: Record<string, string>;
+export declare abstract class ProjectBase implements Project {
+    abstract readonly name: string;
+    abstract readonly rootDir: string;
+    abstract readonly workspaces: Workspace[];
+    listWorkspacesWithScript(scriptName: string): Workspace[];
+    listScriptsWithWorkspaces(): Record<string, ScriptMetadata>;
+    findWorkspaceByName(workspaceName: string): Workspace | null;
+    findWorkspaceByAlias(alias: string): Workspace | null;
+    findWorkspaceByNameOrAlias(nameOrAlias: string): Workspace | null;
+    /** Accepts wildcard for finding a list of workspaces */
+    findWorkspacesByPattern(workspacePattern: string): Workspace[];
+    createScriptCommand(options: CreateProjectScriptCommandOptions): CreateProjectScriptCommandResult;
 }
-export declare const createProject: (options: CreateProjectOptions) => Project;

package/src/project/{project.mjs → implementations/projectBase.mjs}

@@ -1,32 +1,15 @@
 import path from "path";
-import { createWildcardRegex } from "../internal/regex.mjs";
-import { findWorkspacesFromPackage } from "../workspaces/index.mjs";
-import { ERRORS } from "./errors.mjs";
-import { createScriptCommand } from "./scriptCommand.mjs";
-class _Project {
-    options;
-    rootDir;
-    workspaceAliases;
-    workspaces;
-    name;
-    constructor(options){
-        this.options = options;
-        this.rootDir = options.rootDir;
-        this.workspaceAliases = options.workspaceAliases;
-        const { name, workspaces } = findWorkspacesFromPackage({
-            rootDir: options.rootDir,
-            workspaceAliases: options.workspaceAliases
-        });
-        this.name = name;
-        this.workspaces = workspaces;
-    }
+import { createWildcardRegex } from "../../internal/regex.mjs";
+import { ERRORS } from "../errors.mjs";
+import { createScriptCommand } from "../scriptCommand.mjs";
+class ProjectBase {
     listWorkspacesWithScript(scriptName) {
-        return this.workspaces.filter((workspace)=>workspace.packageJson.scripts?.[scriptName]);
+        return this.workspaces.filter((workspace)=>workspace.scripts.includes(scriptName));
     }
     listScriptsWithWorkspaces() {
         const scripts = new Set();
         this.workspaces.forEach((workspace)=>{
-            Object.keys(workspace.packageJson.scripts ?? {}).forEach((script)=>scripts.add(script));
+            workspace.scripts.forEach((script)=>scripts.add(script));
         });
         return Array.from(scripts).sort((a, b)=>a.localeCompare(b)).map((name)=>({
                 name,
@@ -56,7 +39,7 @@ class _Project {
     createScriptCommand(options) {
         const workspace = this.findWorkspaceByNameOrAlias(options.workspaceName);
         if (!workspace) throw new ERRORS.ProjectWorkspaceNotFound(`Workspace not found: ${JSON.stringify(options.workspaceName)}`);
-        if (!workspace.packageJson.scripts?.[options.scriptName]) throw new ERRORS.WorkspaceScriptDoesNotExist(`Script not found in workspace ${JSON.stringify(workspace.name)}: ${JSON.stringify(options.scriptName)} (available: ${Object.keys(workspace.packageJson.scripts).join(", ") || "none"}`);
+        if (!workspace.scripts.includes(options.scriptName)) throw new ERRORS.WorkspaceScriptDoesNotExist(`Script not found in workspace ${JSON.stringify(workspace.name)}: ${JSON.stringify(options.scriptName)} (available: ${workspace.scripts.join(", ") || "none"})`);
         return {
             workspace,
             scriptName: options.scriptName,
@@ -68,5 +51,4 @@ class _Project {
         };
     }
 }
-const createProject = (options)=>new _Project(options);
-export { createProject };
+export { ProjectBase };

package/src/project/index.d.ts

@@ -1 +1,2 @@
-export { type Project, type CreateProjectOptions, type CreateProjectScriptCommandOptions, createProject, } from "./project";
+export { type Project, type CreateProjectScriptCommandOptions, type ScriptMetadata, } from "./implementations/projectBase";
+export { createFileSystemProject as createFileSystemProject, type CreateFileSystemProjectOptions, } from "./implementations/fileSystemProject";

package/src/project/index.mjs

@@ -1,2 +1,2 @@
-import { createProject } from "./project.mjs";
-export { createProject };
+import { createFileSystemProject } from "./implementations/fileSystemProject.mjs";
+export { createFileSystemProject };

package/src/workspaces/findWorkspaces.mjs

@@ -19,7 +19,6 @@ const findWorkspaces = ({ rootDir, workspaceGlobs, workspaceAliases })=>{
         const packageJsonPath = resolvePackageJsonPath(item);
         if (packageJsonPath) excludedWorkspacePaths.push(path.relative(rootDir, path.dirname(packageJsonPath)));
     }
-    console.log(negativePatterns, excludedWorkspacePaths);
     for (const pattern of positivePatterns)for (const item of scanWorkspaceGlob(pattern.replace(/^!/, ""), rootDir)){
         const packageJsonPath = resolvePackageJsonPath(item);
         if (packageJsonPath) {
@@ -31,7 +30,7 @@ const findWorkspaces = ({ rootDir, workspaceGlobs, workspaceAliases })=>{
                 name: packageJsonContent.name ?? "",
                 matchPattern: pattern,
                 path: path.relative(rootDir, path.dirname(packageJsonPath)),
-                packageJson: packageJsonContent,
+                scripts: Object.keys(packageJsonContent.scripts ?? {}).sort(),
                 aliases: Object.entries(workspaceAliases ?? {}).filter(([_, value])=>value === packageJsonContent.name).map(([key])=>key)
             };
             if (!excludedWorkspacePaths.includes(workspace.path) && validateWorkspace(workspace, workspaces)) workspaces.push(workspace);

package/src/workspaces/index.d.ts

@@ -1,3 +1,3 @@
 export { findWorkspaces, findWorkspacesFromPackage, type FindWorkspacesOptions, } from "./findWorkspaces";
 export { type Workspace } from "./workspace";
-export type { ResolvedPackageJsonContent } from "./packageJson";
+export type { resolvePackageJsonContent, resolvePackageJsonPath, scanWorkspaceGlob, ResolvedPackageJsonContent, } from "./packageJson";

package/src/workspaces/packageJson.d.ts

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

package/src/workspaces/packageJson.mjs

@@ -8,7 +8,7 @@ const resolvePackageJsonPath = (directoryItem)=>{
     if (fs.existsSync(path.join(directoryItem, "package.json"))) return path.join(directoryItem, "package.json");
     return "";
 };
-const scanWorkspaceGlob = (pattern, rootDir)=>new Glob(pattern, {
+const scanWorkspaceGlob = (globPattern, rootDir)=>new Glob(globPattern, {
         absolute: true,
         cwd: rootDir
     }).iterateSync();

package/src/workspaces/workspace.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedPackageJsonContent } from "./packageJson";
+/** Metadata about a nested package within a Bun monorepo */
 export interface Workspace {
     /** The name of the workspace from its `package.json` */
     name: string;
@@ -6,8 +6,8 @@ export interface Workspace {
     path: string;
     /** The pattern from `"workspaces"` in the root `package.json`that this workspace was matched from*/
     matchPattern: string;
-    /** The contents of the workspace's package.json, with `"workspaces"` and `"scripts"` resolved */
-    packageJson: ResolvedPackageJsonContent;
+    /** The scripts available in package.json */
+    scripts: string[];
     /** Aliases assigned to the workspace via the `"workspaceAliases"` field in the config */
     aliases: string[];
 }