bun-workspaces 1.4.0 → 1.5.0

package/src/ai/mcp/tools.mjs

@@ -0,0 +1,210 @@
+import { getDoctorInfo } from "../../doctor/index.mjs";
+import { BUN_WORKSPACES_VERSION } from "../../internal/version.mjs";
+import { ROOT_WORKSPACE_SELECTOR } from "../../project/implementations/projectBase.mjs"; // CONCATENATED MODULE: external "../../doctor/index.mjs"
+// CONCATENATED MODULE: external "../../internal/version.mjs"
+// CONCATENATED MODULE: external "../../project/implementations/projectBase.mjs"
+// CONCATENATED MODULE: ./src/ai/mcp/tools.ts
+
+const textResult = (data) => ({
+  content: [
+    {
+      type: "text",
+      text: JSON.stringify(data, null, 2),
+    },
+  ],
+});
+const errorResult = (message) => ({
+  content: [
+    {
+      type: "text",
+      text: message,
+    },
+  ],
+  isError: true,
+});
+const registerBwTools = (server, project) => {
+  server.registerTool(
+    {
+      name: "version",
+      description: "Get the version of bun-workspaces used by this MCP server",
+      inputSchema: {
+        type: "object",
+      },
+    },
+    () =>
+      textResult({
+        version: BUN_WORKSPACES_VERSION,
+      }),
+  );
+  server.registerTool(
+    {
+      name: "list_workspaces",
+      description:
+        "List workspaces in the project. Optionally filter by workspace patterns (name, alias, path glob, or tag).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          patterns: {
+            type: "array",
+            items: {
+              type: "string",
+            },
+            description:
+              'Workspace patterns to match. Examples: "my-workspace", "name:api-*", "alias:my-alias", "path:packages/**/*", "tag:backend", "@root"',
+          },
+        },
+      },
+    },
+    ({ patterns }) => {
+      const workspaces =
+        patterns && Array.isArray(patterns) && patterns.length > 0
+          ? project.findWorkspacesByPattern(...patterns)
+          : project.workspaces;
+      return textResult(workspaces);
+    },
+  );
+  server.registerTool(
+    {
+      name: "workspace_info",
+      description:
+        'Get detailed information about a single workspace by its name or alias. Use "@root" for the root workspace.',
+      inputSchema: {
+        type: "object",
+        properties: {
+          nameOrAlias: {
+            type: "string",
+            description:
+              'The workspace name, alias, or "@root" for the root workspace',
+          },
+        },
+        required: ["nameOrAlias"],
+      },
+    },
+    ({ nameOrAlias }) => {
+      const name = nameOrAlias;
+      const workspace =
+        name === ROOT_WORKSPACE_SELECTOR
+          ? project.rootWorkspace
+          : project.findWorkspaceByNameOrAlias(name);
+      if (!workspace) {
+        return errorResult(`Workspace not found: "${name}"`);
+      }
+      return textResult(workspace);
+    },
+  );
+  server.registerTool(
+    {
+      name: "root_info",
+      description: "Get information about the root workspace",
+      inputSchema: {
+        type: "object",
+      },
+    },
+    () => textResult(project.rootWorkspace),
+  );
+  server.registerTool(
+    {
+      name: "list_scripts",
+      description:
+        "List all scripts available across the project, with the workspaces that have each script.",
+      inputSchema: {
+        type: "object",
+      },
+    },
+    () => {
+      const scriptMap = project.mapScriptsToWorkspaces();
+      const scripts = Object.values(scriptMap).map(({ name, workspaces }) => ({
+        name,
+        workspaces: workspaces.map((w) => w.name),
+      }));
+      return textResult(scripts);
+    },
+  );
+  server.registerTool(
+    {
+      name: "script_info",
+      description:
+        "Get information about a specific script, including all workspaces that have it in their package.json.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          script: {
+            type: "string",
+            description: "The script name to look up",
+          },
+        },
+        required: ["script"],
+      },
+    },
+    ({ script }) => {
+      const scriptMap = project.mapScriptsToWorkspaces();
+      const scriptMetadata = scriptMap[script];
+      if (!scriptMetadata) {
+        return errorResult(`Script not found: "${script}"`);
+      }
+      return textResult({
+        name: scriptMetadata.name,
+        workspaces: scriptMetadata.workspaces.map((w) => w.name),
+      });
+    },
+  );
+  server.registerTool(
+    {
+      name: "list_tags",
+      description:
+        "List all tags defined across workspaces, with the workspaces that have each tag.",
+      inputSchema: {
+        type: "object",
+      },
+    },
+    () => {
+      const tagMap = project.mapTagsToWorkspaces();
+      const tags = Object.entries(tagMap).map(([tag, workspaces]) => ({
+        tag,
+        workspaces: workspaces.map((w) => w.name),
+      }));
+      return textResult(tags);
+    },
+  );
+  server.registerTool(
+    {
+      name: "tag_info",
+      description:
+        "Get information about a specific tag, including all workspaces that have it.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          tag: {
+            type: "string",
+            description: "The tag name to look up",
+          },
+        },
+        required: ["tag"],
+      },
+    },
+    ({ tag }) => {
+      const tagMap = project.mapTagsToWorkspaces();
+      const tagWorkspaces = tagMap[tag];
+      if (!tagWorkspaces) {
+        return errorResult(`Tag not found: "${tag}"`);
+      }
+      return textResult({
+        name: tag,
+        workspaces: tagWorkspaces.map((w) => w.name),
+      });
+    },
+  );
+  server.registerTool(
+    {
+      name: "doctor",
+      description:
+        "Get diagnostic information about the bun-workspaces installation: version, Bun version, OS, and environment.",
+      inputSchema: {
+        type: "object",
+      },
+    },
+    () => textResult(getDoctorInfo()),
+  );
+};
+
+export { registerBwTools };

package/src/cli/commands/commandHandlerUtils.mjs

@@ -77,6 +77,7 @@ const handleProjectCommand = (commandName, handler) => (context) =>
       context.middleware.catchError(projectError);
       logger.error(projectError.message);
       process.exit(1);
+      return;
     }
     await handler(context, ...actionArgs);
   })(context);

package/src/cli/commands/commands.mjs

@@ -7,7 +7,9 @@ import {
   tagInfo,
   workspaceInfo,
 } from "./handleSimpleCommands.mjs";
+import { mcpServer } from "./mcp.mjs";
 import { runScript } from "./runScript/index.mjs"; // CONCATENATED MODULE: external "./handleSimpleCommands.mjs"
+// CONCATENATED MODULE: external "./mcp.mjs"
 // CONCATENATED MODULE: external "./runScript/index.mjs"
 // CONCATENATED MODULE: ./src/cli/commands/commands.ts
 
@@ -21,6 +23,7 @@ const defineProjectCommands = (context) => {
   scriptInfo(context);
   listTags(context);
   tagInfo(context);
+  mcpServer(context);
   runScript(context);
 };
 

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

@@ -159,6 +159,13 @@ export declare const CLI_COMMANDS_CONFIG: {
       };
     };
   };
+  readonly mcpServer: {
+    readonly command: "mcp-server";
+    readonly isGlobal: false;
+    readonly aliases: [];
+    readonly description: "Start the bun-workspaces MCP (Model Context Protocol) server over stdio";
+    readonly options: {};
+  };
   readonly runScript: {
     readonly command: "run-script [script] [workspacePatterns...]";
     readonly isGlobal: false;
@@ -356,6 +363,13 @@ export declare const getCliCommandConfig: (commandName: CliCommandName) =>
         };
       };
     }
+  | {
+      readonly command: "mcp-server";
+      readonly isGlobal: false;
+      readonly aliases: [];
+      readonly description: "Start the bun-workspaces MCP (Model Context Protocol) server over stdio";
+      readonly options: {};
+    }
   | {
       readonly command: "run-script [script] [workspacePatterns...]";
       readonly isGlobal: false;

package/src/cli/commands/commandsConfig.mjs

@@ -137,6 +137,14 @@ const CLI_COMMANDS_CONFIG = {
       },
     },
   },
+  mcpServer: {
+    command: "mcp-server",
+    isGlobal: false,
+    aliases: [],
+    description:
+      "Start the bun-workspaces MCP (Model Context Protocol) server over stdio",
+    options: {},
+  },
   runScript: {
     command: "run-script [script] [workspacePatterns...]",
     isGlobal: false,

package/src/cli/commands/handleSimpleCommands.mjs

@@ -53,6 +53,7 @@ const listWorkspaces = handleProjectCommand(
         "CLI syntax error: Cannot use both inline workspace patterns and --workspace-patterns|-W option",
       );
       process.exit(1);
+      return;
     }
     const patterns = positionalWorkspacePatterns?.length
       ? positionalWorkspacePatterns
@@ -133,6 +134,7 @@ const workspaceInfo = handleProjectCommand(
     if (!workspace) {
       logger.error(`Workspace ${JSON.stringify(workspaceName)} not found`);
       process.exit(1);
+      return;
     }
     commandOutputLogger.info(
       (options.json
@@ -151,6 +153,7 @@ const scriptInfo = handleProjectCommand(
     if (!scriptMetadata) {
       logger.error(`Script not found: ${JSON.stringify(script)}`);
       process.exit(1);
+      return;
     }
     commandOutputLogger.info(
       (options.json
@@ -211,6 +214,7 @@ const handleSimpleCommands_tagInfo = handleProjectCommand(
     if (!tagMetadata) {
       logger.error(`Tag not found: ${JSON.stringify(tag)}`);
       process.exit(1);
+      return;
     }
     const tagInfo = {
       name: tag,

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

@@ -1,3 +1,4 @@
 export * from "./commands";
 export * from "./commandsConfig";
+export * from "./mcp";
 export * from "./runScript";

package/src/cli/commands/index.mjs

@@ -1,3 +1,4 @@
 export * from "./commands.mjs";
 export * from "./commandsConfig.mjs";
+export * from "./mcp.mjs";
 export * from "./runScript/index.mjs"; // CONCATENATED MODULE: ./src/cli/commands/index.ts

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

@@ -0,0 +1,3 @@
+export declare const mcpServer: (
+  context: import("./commandHandlerUtils").ProjectCommandContext,
+) => import("commander").Command;

package/src/cli/commands/mcp.mjs

@@ -0,0 +1,13 @@
+import { startBwMcpServer } from "../../ai/mcp/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import { handleProjectCommand } from "./commandHandlerUtils.mjs"; // CONCATENATED MODULE: external "../../ai/mcp/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./commandHandlerUtils.mjs"
+// CONCATENATED MODULE: ./src/cli/commands/mcp.ts
+
+const mcpServer = handleProjectCommand("mcpServer", async ({ project }) => {
+  logger.printLevel = "silent";
+  await startBwMcpServer(project);
+});
+
+export { mcpServer };

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

@@ -56,6 +56,7 @@ const runScript = handleProjectCommand(
         "CLI syntax error: Cannot use both --args and inline script args after --",
       );
       process.exit(1);
+      return;
     }
     const scriptArgs = postTerminatorArgs.length
       ? postTerminatorArgs
@@ -65,6 +66,7 @@ const runScript = handleProjectCommand(
         "CLI syntax error: Cannot use both inline workspace patterns and --workspace-patterns|-W option",
       );
       process.exit(1);
+      return;
     }
     const workspacePatterns = positionalWorkspacePatterns?.length
       ? positionalWorkspacePatterns
@@ -137,6 +139,7 @@ const runScript = handleProjectCommand(
             `Invalid max grouped lines value: ${options.groupedLines}. Must be a positive number or "all".`,
           );
           process.exit(1);
+          return;
         }
         groupedLines = parsedGroupedLines;
       }
@@ -225,12 +228,14 @@ const runScript = handleProjectCommand(
             `Failed to create JSON output file directory "${jsonOutputDir}": ${error}`,
           );
           process.exit(1);
+          return;
         }
       } else if (fs.statSync(jsonOutputDir).isFile()) {
         logger.error(
           `Given JSON output file directory "${jsonOutputDir}" is an existing file`,
         );
         process.exit(1);
+        return;
       }
       // Check if can make file
       if (
@@ -241,6 +246,7 @@ const runScript = handleProjectCommand(
           `Given JSON output file path "${fullOutputPath}" is an existing directory`,
         );
         process.exit(1);
+        return;
       }
       try {
         logger.debug(`Writing JSON output file "${fullOutputPath}"`);
@@ -250,11 +256,13 @@ const runScript = handleProjectCommand(
           `Failed to write JSON output file "${fullOutputPath}": ${error}`,
         );
         process.exit(1);
+        return;
       }
       logger.info(`JSON output written to ${fullOutputPath}`);
     }
     if (exitResults.failureCount) {
       process.exit(1);
+      return;
     }
   },
 );

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

@@ -288,8 +288,10 @@ const renderGroupedOutput = async (
   });
   process.on("SIGWINCH", render);
   process.stdin.on("data", (data) => {
-    if (data[0] === 0x03) process.kill(process.pid, "SIGINT");
-    if (data[0] === 0x1c) process.kill(process.pid, "SIGQUIT");
+    // Send to the entire process group (pid=0) so child processes also receive
+    // the signal — raw mode prevents the terminal from doing this automatically.
+    if (data[0] === 0x03) process.kill(0, "SIGINT");
+    if (data[0] === 0x1c) process.kill(0, "SIGQUIT");
   });
   runOnExit((reason) => {
     try {

package/src/cli/createCli.mjs

@@ -90,6 +90,7 @@ const createCli = ({ defaultCwd = process.cwd(), defaultMiddleware } = {}) => {
       if (bunVersionError) {
         fatalErrorLogger.error(bunVersionError.message);
         process.exit(1);
+        return;
       }
       const { project, projectError } = initializeWithGlobalOptions(
         program,

package/src/config/public.d.ts

@@ -2,6 +2,9 @@ export type { RootConfig, ResolvedRootConfig } from "./rootConfig";
 export type {
   WorkspaceConfig,
   ResolvedWorkspaceConfig,
+  WorkspaceDependenciesRule,
+  WorkspaceRules,
+  ScriptConfig,
 } from "./workspaceConfig";
 export { defineRootConfig } from "./rootConfig/defineRootConfig";
 export { defineWorkspaceConfig } from "./workspaceConfig/defineWorkspaceConfig";

package/src/config/workspaceConfig/workspaceConfig.d.ts

@@ -1,3 +1,11 @@
+export type WorkspaceDependenciesRule = {
+  allowPatterns?: string[];
+  denyPatterns?: string[];
+};
+export type WorkspaceRules = {
+  /** Allowed or denied workspace dependencies */
+  workspaceDependencies?: WorkspaceDependenciesRule;
+};
 /** Configuration that applies to a specific package.json script */
 export type ScriptConfig = {
   /**
@@ -30,11 +38,16 @@ export type WorkspaceConfig = {
    * Configuration that maps to a script name in the workspace's package.json.
    */
   scripts?: Record<string, ScriptConfig>;
+  /**
+   * Rules that validate the workspace.
+   */
+  rules?: WorkspaceRules;
 };
 export type ResolvedWorkspaceConfig = {
   aliases: string[];
   tags: string[];
   scripts: Record<string, ScriptConfig>;
+  rules: WorkspaceRules;
 };
 export declare const validateWorkspaceConfig: (config: WorkspaceConfig) => void;
 export declare const resolveWorkspaceConfig: (

package/src/config/workspaceConfig/workspaceConfig.mjs

@@ -8,7 +8,7 @@ import { WORKSPACE_CONFIG_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE:
 // CONCATENATED MODULE: ./src/config/workspaceConfig/workspaceConfig.ts
 
 const validate = validateWorkspaceConfig;
-const workspaceConfig_validateWorkspaceConfig = (config) =>
+const workspaceConfig_validateWorkspaceConfig = (config) => {
   executeValidator(
     validate,
     "WorkspaceConfig",
@@ -17,6 +17,15 @@ const workspaceConfig_validateWorkspaceConfig = (config) =>
     },
     WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig,
   );
+  if (
+    config.rules?.workspaceDependencies?.allowPatterns &&
+    config.rules?.workspaceDependencies?.denyPatterns
+  ) {
+    throw new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+      "Cannot use both allowPatterns and denyPatterns in workspaceDependencies rule",
+    );
+  }
+};
 const resolveWorkspaceConfig = (config) => {
   if (Array.isArray(config.aliases)) {
     const { aliases, ...rest } = config;
@@ -34,6 +43,7 @@ const resolveWorkspaceConfig = (config) => {
     aliases: resolveOptionalArray(config.alias ?? []),
     tags: config.tags ?? [],
     scripts: config.scripts ?? {},
+    rules: config.rules ?? {},
   };
 };
 const createDefaultWorkspaceConfig = () => resolveWorkspaceConfig({});

package/src/config/workspaceConfig/workspaceConfigSchema.d.ts

@@ -28,5 +28,29 @@ export declare const WORKSPACE_CONFIG_JSON_SCHEMA: {
         readonly additionalProperties: false;
       };
     };
+    readonly rules: {
+      readonly type: "object";
+      readonly additionalProperties: false;
+      readonly properties: {
+        readonly workspaceDependencies: {
+          readonly type: "object";
+          readonly properties: {
+            readonly allowPatterns: {
+              readonly type: "array";
+              readonly items: {
+                readonly type: "string";
+              };
+            };
+            readonly denyPatterns: {
+              readonly type: "array";
+              readonly items: {
+                readonly type: "string";
+              };
+            };
+          };
+          readonly additionalProperties: false;
+        };
+      };
+    };
   };
 };

package/src/config/workspaceConfig/workspaceConfigSchema.mjs

@@ -29,6 +29,30 @@ const WORKSPACE_CONFIG_JSON_SCHEMA = {
         additionalProperties: false,
       },
     },
+    rules: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        workspaceDependencies: {
+          type: "object",
+          properties: {
+            allowPatterns: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+            },
+            denyPatterns: {
+              type: "array",
+              items: {
+                type: "string",
+              },
+            },
+          },
+          additionalProperties: false,
+        },
+      },
+    },
   },
 };
 let _validateSchemaType;

package/src/internal/docs/apiQuickstart.d.ts

@@ -0,0 +1,3 @@
+export declare const RUN_WORKSPACE_SCRIPT_EXAMPLE: string;
+export declare const RUN_SCRIPT_ACROSS_WORKSPACES_EXAMPLE: string;
+export declare const API_QUICKSTART: string;