bun-workspaces 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -0,0 +1,15 @@
+export declare const doctor: (
+  context: import("./commandHandlerUtils").GlobalCommandContext,
+) => import("commander").Command;
+export declare const listWorkspaces: (
+  context: import("./commandHandlerUtils").ProjectCommandContext,
+) => import("commander").Command;
+export declare const listScripts: (
+  context: import("./commandHandlerUtils").ProjectCommandContext,
+) => import("commander").Command;
+export declare const workspaceInfo: (
+  context: import("./commandHandlerUtils").ProjectCommandContext,
+) => import("commander").Command;
+export declare const scriptInfo: (
+  context: import("./commandHandlerUtils").ProjectCommandContext,
+) => import("commander").Command;

package/src/cli/commands/handleSimpleCommands.mjs

@@ -0,0 +1,170 @@
+import { getDoctorInfo } from "../../doctor/index.mjs";
+import { isJsonObject } from "../../internal/core/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import {
+  commandOutputLogger,
+  createJsonLines,
+  createScriptInfoLines,
+  createWorkspaceInfoLines,
+  handleGlobalCommand,
+  handleProjectCommand,
+} from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "../../doctor/index.mjs"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/handleSimpleCommands.ts
+
+const doctor = handleGlobalCommand("doctor", (_, options) => {
+  const info = getDoctorInfo();
+  if (options.json) {
+    commandOutputLogger.info(
+      JSON.stringify(info, null, options.pretty ? 2 : undefined),
+    );
+  } else {
+    const createEntryLine = ([key, value]) => {
+      const keyName = (
+        key[0].toUpperCase() + key.slice(1).replace(/([A-Z])/g, " $1")
+      ).replace(/os|cpu/gi, (m) => m.toUpperCase());
+      return isJsonObject(value)
+        ? keyName +
+            ":\n - " +
+            Object.entries(value).map(createEntryLine).join("\n - ")
+        : `${keyName}: ${value}`;
+    };
+    commandOutputLogger.info(
+      "bun-workspaces\n" + Object.entries(info).map(createEntryLine).join("\n"),
+    );
+  }
+});
+const listWorkspaces = handleProjectCommand(
+  "listWorkspaces",
+  ({ project }, workspacePatterns, options) => {
+    logger.debug(
+      `Command: List workspaces (options: ${JSON.stringify(options)})`,
+    );
+    const lines = [];
+    if (workspacePatterns?.length && options.workspacePatterns?.length) {
+      logger.error(
+        "CLI syntax error: Cannot use both inline workspace patterns and --workspace-patterns|-W option",
+      );
+      process.exit(1);
+    }
+    const patterns = workspacePatterns?.length
+      ? workspacePatterns
+      : options.workspacePatterns?.split(",");
+    const workspaces = patterns?.length
+      ? project.findWorkspacesByPattern(...patterns)
+      : 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 && !options.nameOnly) {
+      logger.info("No workspaces found");
+    }
+    if (lines.length) commandOutputLogger.info(lines.join("\n"));
+  },
+);
+const listScripts = handleProjectCommand(
+  "listScripts",
+  ({ project }, options) => {
+    logger.debug(`Command: List scripts (options: ${JSON.stringify(options)})`);
+    const scripts = project.mapScriptsToWorkspaces();
+    const lines = [];
+    if (!project.workspaces.length && !options.nameOnly) {
+      logger.info("No workspaces found");
+      return;
+    }
+    if (!Object.keys(scripts).length && !options.nameOnly) {
+      logger.info("No scripts found");
+      return;
+    }
+    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) commandOutputLogger.info(lines.join("\n"));
+  },
+);
+const workspaceInfo = handleProjectCommand(
+  "workspaceInfo",
+  ({ project }, workspaceName, options) => {
+    logger.debug(
+      `Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`,
+    );
+    const workspace = project.findWorkspaceByNameOrAlias(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 = handleProjectCommand(
+  "scriptInfo",
+  ({ project }, script, options) => {
+    logger.debug(
+      `Command: Script info for ${script} (options: ${JSON.stringify(options)})`,
+    );
+    const scripts = project.mapScriptsToWorkspaces();
+    const scriptMetadata = scripts[script];
+    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),
+                },
+            options,
+          )
+        : options.workspacesOnly
+          ? scriptMetadata.workspaces.map(({ name }) => name)
+          : createScriptInfoLines(script, scriptMetadata.workspaces)
+      ).join("\n"),
+    );
+  },
+);
+
+export { doctor, listScripts, listWorkspaces, scriptInfo, workspaceInfo };

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

@@ -0,0 +1,2 @@
+export * from "./commands";
+export * from "./commandsConfig";

package/src/cli/commands/index.mjs

@@ -0,0 +1,2 @@
+export * from "./commands.mjs";
+export * from "./commandsConfig.mjs"; // CONCATENATED MODULE: ./src/cli/commands/index.ts

package/src/cli/createCli.d.ts

@@ -0,0 +1,19 @@
+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 CLI {
+  run: (options?: RunCliOptions) => Promise<void>;
+}
+export interface CreateCliOptions {
+  handleError?: (error: Error) => void;
+  postInit?: (program: Command) => unknown;
+  defaultCwd?: string;
+}
+export declare const createCli: ({
+  handleError,
+  postInit,
+  defaultCwd,
+}?: CreateCliOptions) => CLI;

package/src/cli/createCli.mjs

@@ -0,0 +1,113 @@
+import { createCommand } from "commander";
+import package_0 from "../../package.json";
+import { validateCurrentBunVersion } from "../internal/bun/index.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import {
+  defineGlobalCommands,
+  defineProjectCommands,
+} from "./commands/index.mjs";
+import { fatalErrorLogger } from "./fatalErrorLogger.mjs";
+import { initializeWithGlobalOptions } from "./globalOptions/index.mjs"; // CONCATENATED MODULE: external "commander"
+// CONCATENATED MODULE: external "../../package.json"
+// CONCATENATED MODULE: external "../internal/bun/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./commands/index.mjs"
+// CONCATENATED MODULE: external "./fatalErrorLogger.mjs"
+// CONCATENATED MODULE: external "./globalOptions/index.mjs"
+// CONCATENATED MODULE: ./src/cli/createCli.ts
+
+const createCli = ({
+  handleError,
+  postInit,
+  defaultCwd = process.cwd(),
+} = {}) => {
+  const run = async ({ argv = process.argv, programmatic } = {}) => {
+    const errorListener =
+      handleError ??
+      ((error) => {
+        fatalErrorLogger.error(error);
+        process.exit(1);
+      });
+    process.on("unhandledRejection", errorListener);
+    try {
+      const program = createCommand("bun-workspaces")
+        .description("A CLI on top of native Bun workspaces")
+        .version(package_0.version)
+        .showHelpAfterError(true);
+      postInit?.(program);
+      const rawArgs = tempFixCamelCaseOptions(
+        typeof argv === "string" ? argv.split(/s+/) : argv,
+      );
+      const { args, postTerminatorArgs } = (() => {
+        const terminatorIndex = rawArgs.findIndex((arg) => arg === "--");
+        return {
+          args:
+            terminatorIndex !== -1
+              ? rawArgs.slice(0, terminatorIndex)
+              : rawArgs,
+          postTerminatorArgs:
+            terminatorIndex !== -1 ? rawArgs.slice(terminatorIndex + 1) : [],
+        };
+      })();
+      const { project, projectError } = initializeWithGlobalOptions(
+        program,
+        args,
+        defaultCwd,
+      );
+      const bunVersionError = validateCurrentBunVersion();
+      if (bunVersionError) {
+        fatalErrorLogger.error(bunVersionError.message);
+        process.exit(1);
+      }
+      defineProjectCommands({
+        program,
+        project,
+        projectError,
+        postTerminatorArgs,
+      });
+      defineGlobalCommands({
+        program,
+        postTerminatorArgs,
+      });
+      await program.parseAsync(args, {
+        from: programmatic ? "user" : "node",
+      });
+    } catch (error) {
+      if (error instanceof BunWorkspacesError) {
+        logger.debug(error);
+        fatalErrorLogger.error(error.message);
+        process.exit(1);
+      } else {
+        errorListener(error);
+      }
+    } finally {
+      process.off("unhandledRejection", errorListener);
+    }
+  };
+  return {
+    run,
+  };
+};
+/**
+ * @todo
+ * ! Temp backwards support for deprecated camel case options
+ * ! Added October 2025, drop support in some reasonable future release
+ */ const tempOptions = {
+  "--nameOnly": "--name-only",
+  "--noPrefix": "--no-prefix",
+  "--configFile": "--config-file",
+  "--logLevel": "--log-level",
+};
+const tempFixCamelCaseOptions = (args) =>
+  args.map((arg) => {
+    for (const [camel, kebab] of Object.entries(tempOptions)) {
+      if (arg.startsWith(camel)) {
+        return arg.replace(camel, kebab);
+      }
+    }
+    return arg;
+  });
+
+export { createCli };

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,7 @@
+import { createLogger } from "../internal/logger/index.mjs"; // CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/cli/fatalErrorLogger.ts
+
+const fatalErrorLogger = createLogger("fatalError");
+fatalErrorLogger.printLevel = "error";
+
+export { fatalErrorLogger };

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

@@ -0,0 +1,38 @@
+import { type Command } from "commander";
+export declare const initializeWithGlobalOptions: (
+  program: Command,
+  args: string[],
+  defaultCwd: string,
+) => {
+  project: import("../../internal/core").Simplify<{
+    readonly rootDirectory: string;
+    readonly workspaces: import("../..").Workspace[];
+    readonly name: string;
+    readonly sourceType: "fileSystem";
+    runWorkspaceScript(
+      options: import("../..").RunWorkspaceScriptOptions,
+    ): import("../..").RunWorkspaceScriptResult;
+    runScriptAcrossWorkspaces(
+      options: import("../..").RunScriptAcrossWorkspacesOptions,
+    ): import("../..").RunScriptAcrossWorkspacesResult;
+    listWorkspacesWithScript(scriptName: string): import("../..").Workspace[];
+    mapScriptsToWorkspaces(): Record<
+      string,
+      import("../..").WorkspaceScriptMetadata
+    >;
+    findWorkspaceByName(
+      workspaceName: string,
+    ): import("../..").Workspace | null;
+    findWorkspaceByAlias(alias: string): import("../..").Workspace | null;
+    findWorkspaceByNameOrAlias(
+      nameOrAlias: string,
+    ): import("../..").Workspace | null;
+    findWorkspacesByPattern(
+      ...workspacePatterns: string[]
+    ): import("../..").Workspace[];
+    createScriptCommand(
+      options: import("../..").CreateProjectScriptCommandOptions,
+    ): import("../..").CreateProjectScriptCommandResult;
+  }>;
+  projectError: Error | null;
+};

package/src/cli/globalOptions/globalOptions.mjs

@@ -0,0 +1,120 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { Option } from "commander";
+import {
+  DEFAULT_CONFIG_FILE_PATH,
+  loadConfigFile,
+} from "../../config/index.mjs";
+import { defineErrors } from "../../internal/core/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import {
+  _internalCreateFileSystemProject,
+  createMemoryProject,
+} from "../../project/index.mjs";
+import { getCliGlobalOptionConfig } from "./globalOptionsConfig.mjs"; // CONCATENATED MODULE: external "node:fs"
+// CONCATENATED MODULE: external "node:path"
+// CONCATENATED MODULE: external "commander"
+// CONCATENATED MODULE: external "../../config/index.mjs"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../../project/index.mjs"
+// CONCATENATED MODULE: external "./globalOptionsConfig.mjs"
+// CONCATENATED MODULE: ./src/cli/globalOptions/globalOptions.ts
+
+const ERRORS = defineErrors(
+  "WorkingDirectoryNotFound",
+  "WorkingDirectoryNotADirectory",
+);
+const addGlobalOption = (program, optionName, defaultOverride) => {
+  const { mainOption, shortOption, description, param, values, defaultValue } =
+    getCliGlobalOptionConfig(optionName);
+  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 getWorkingDirectoryFromArgs = (program, args, defaultCwd) => {
+  addGlobalOption(program, "cwd", defaultCwd);
+  program.parseOptions(args);
+  return program.opts().cwd;
+};
+const getConfigFileFromArgs = (program, args) => {
+  addGlobalOption(program, "configFile");
+  program.parseOptions(args);
+  return program.opts().configFile;
+};
+const defineGlobalOptions = (program, args, defaultCwd) => {
+  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);
+  if (config) {
+    logger.warn(
+      // TODO link to docs
+      `Using the config file at ${configFilePath || DEFAULT_CONFIG_FILE_PATH} is deprecated. Migrate to the new workspace config file.`,
+    );
+  }
+  addGlobalOption(program, "logLevel");
+  return {
+    cwd,
+    config,
+  };
+};
+const applyGlobalOptions = (options, config) => {
+  logger.printLevel = options.logLevel;
+  logger.debug("Log level: " + options.logLevel);
+  let project;
+  let error = null;
+  try {
+    project = _internalCreateFileSystemProject({
+      rootDirectory: options.cwd,
+      workspaceAliases: config?.project?.workspaceAliases ?? {},
+    });
+    logger.debug(
+      `Project: ${JSON.stringify(project.name)} (${project.workspaces.length} workspace${project.workspaces.length === 1 ? "" : "s"})`,
+    );
+    logger.debug("Project root: " + node_path.resolve(project.rootDirectory));
+  } catch (_error) {
+    error = _error;
+    project = createMemoryProject({
+      workspaces: [],
+    });
+  }
+  return {
+    project,
+    projectError: error,
+  };
+};
+const initializeWithGlobalOptions = (program, args, defaultCwd) => {
+  program.allowUnknownOption(true);
+  const { cwd, config } = defineGlobalOptions(program, args, defaultCwd);
+  program.parseOptions(args);
+  program.allowUnknownOption(false);
+  const options = program.opts();
+  return applyGlobalOptions(
+    {
+      ...options,
+      cwd,
+    },
+    config,
+  );
+};
+
+export { initializeWithGlobalOptions };

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

@@ -0,0 +1,43 @@
+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: "--log-level";
+      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: "--config-file";
+      readonly shortOption: "-c";
+      readonly description: "(DEPRECATED) Config file";
+      readonly defaultValue: "";
+      readonly values: null;
+      readonly param: "path";
+    };
+export declare const getCliGlobalOptionNames: () => CliGlobalOptionName[];

package/src/cli/globalOptions/globalOptionsConfig.mjs

@@ -0,0 +1,34 @@
+import { LOG_LEVELS } from "../../internal/logger/index.mjs"; // CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/cli/globalOptions/globalOptionsConfig.ts
+
+const CLI_GLOBAL_OPTIONS_CONFIG = {
+  logLevel: {
+    mainOption: "--log-level",
+    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: "--config-file",
+    shortOption: "-c",
+    description: "(DEPRECATED) Config file",
+    defaultValue: "",
+    values: null,
+    param: "path",
+  },
+};
+const getCliGlobalOptionConfig = (optionName) =>
+  CLI_GLOBAL_OPTIONS_CONFIG[optionName];
+const getCliGlobalOptionNames = () => Object.keys(CLI_GLOBAL_OPTIONS_CONFIG);
+
+export { getCliGlobalOptionConfig, getCliGlobalOptionNames };

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"; // CONCATENATED MODULE: ./src/cli/globalOptions/index.ts

package/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./createCli";
+export * from "./commands";
+export * from "./globalOptions";

package/src/cli/index.mjs

@@ -0,0 +1,3 @@
+export * from "./createCli.mjs";
+export * from "./commands/index.mjs";
+export * from "./globalOptions/index.mjs"; // CONCATENATED MODULE: ./src/cli/index.ts

package/src/config/bunWorkspacesConfig.d.ts

@@ -0,0 +1,17 @@
+import { type LogLevelSetting } from "../internal/logger";
+export interface CliConfig {
+  logLevel?: LogLevelSetting;
+}
+export interface ProjectConfig {
+  /** @deprecated A map of aliases to a workspace name */
+  workspaceAliases?: Record<string, string>;
+}
+/** @deprecated */
+export interface BunWorkspacesConfig {
+  cli?: CliConfig;
+  project?: ProjectConfig;
+}
+/** @deprecated */
+export declare const validateBunWorkspacesConfig: (
+  config: BunWorkspacesConfig,
+) => void;

package/src/config/bunWorkspacesConfig.mjs

@@ -0,0 +1,50 @@
+import { validateLogLevel } from "../internal/logger/index.mjs";
+import { ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/config/bunWorkspacesConfig.ts
+
+const isJsonObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+const validateCliConfig = (cliConfig) => {
+  if (!isJsonObject(cliConfig)) {
+    throw new ERRORS.InvalidConfigFile(`Config file: "cli" must be an object`);
+  }
+  if (cliConfig?.logLevel) {
+    validateLogLevel(cliConfig.logLevel);
+  }
+};
+const validateProjectConfig = (projectConfig) => {
+  if (!isJsonObject(projectConfig)) {
+    throw new ERRORS.InvalidConfigFile(
+      `Config file: "project" must be an object`,
+    );
+  }
+  if (projectConfig?.workspaceAliases !== undefined) {
+    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 (typeof alias !== "string") {
+        throw new ERRORS.InvalidConfigFile(
+          `Config file: project.workspaceAliases must be an object with string keys and values`,
+        );
+      }
+    }
+  }
+};
+/** @deprecated */ const validateBunWorkspacesConfig = (config) => {
+  if (!isJsonObject(config)) {
+    throw new ERRORS.InvalidConfigFile(`Config file: must be an object`);
+  }
+  if (typeof config.cli !== "undefined") {
+    validateCliConfig(config.cli);
+  }
+  if (typeof config.project !== "undefined") {
+    validateProjectConfig(config.project);
+  }
+};
+
+export { validateBunWorkspacesConfig };

package/src/config/configFile.d.ts

@@ -0,0 +1,8 @@
+import { type BunWorkspacesConfig } from "./bunWorkspacesConfig";
+/** @deprecated The default path for the config file */
+export declare const DEFAULT_CONFIG_FILE_PATH = "bw.json";
+/** @deprecated */
+export declare const loadConfigFile: (
+  filePath?: string,
+  rootDirectory?: string,
+) => BunWorkspacesConfig | null;