bun-workspaces 1.0.0-alpha.37 → 1.0.0-alpha.38

package/README.md

@@ -67,6 +67,13 @@ bw run lint my-alias-a my-alias-b # Run by alias (set by optional config)
 bw run lint "my-workspace-*" # Run for matching workspace names
 bw run lint "alias:my-alias-pattern-*" "path:my-glob/**/*" # Use matching specifiers
 
+# A workspace's script will wait until any workspaces it depends on have completed
+# Similar to Bun's --filter behavior
+bw run lint --dep-order
+
+# Continue running scripts even if a dependency fails
+bw run lint --dep-order --ignore-dep-failure
+
 bw run lint --args="--my-appended-args" # Add args to each script call
 bw run lint --args="--my-arg=<workspaceName>" # Use the workspace name in args
 
@@ -154,6 +161,14 @@ const runManyScripts = async () => {
 
     // Optional. Whether to run the scripts in parallel
     parallel: true,
+
+    // Optional. When true, a workspace's script will wait
+    // until any workspaces it depends on have completed
+    dependencyOrder: true,
+
+    // Optional. When true and dependencyOrder is true,
+    // continue running scripts even if a dependency fails
+    ignoreDependencyFailure: true,
   });
 
   // Get a stream of script output

package/package.json

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

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

@@ -161,6 +161,14 @@ export declare const CLI_COMMANDS_CONFIG: {
         readonly values: ["bun", "system", "default"];
         readonly description: "When using --inline, the shell to use to run the script";
       };
+      readonly depOrder: {
+        readonly flags: ["-d", "--dep-order"];
+        readonly description: "Scripts for dependent workspaces run only after their dependencies";
+      };
+      readonly ignoreDepFailure: {
+        readonly flags: ["-f", "--ignore-dep-failure"];
+        readonly description: "In dependency order, continue running scripts even if a dependency fails";
+      };
       readonly jsonOutfile: {
         readonly flags: ["-j", "--json-outfile <file>"];
         readonly description: "Output results in a JSON file";
@@ -304,6 +312,14 @@ export declare const getCliCommandConfig: (commandName: CliCommandName) =>
           readonly values: ["bun", "system", "default"];
           readonly description: "When using --inline, the shell to use to run the script";
         };
+        readonly depOrder: {
+          readonly flags: ["-d", "--dep-order"];
+          readonly description: "Scripts for dependent workspaces run only after their dependencies";
+        };
+        readonly ignoreDepFailure: {
+          readonly flags: ["-f", "--ignore-dep-failure"];
+          readonly description: "In dependency order, continue running scripts even if a dependency fails";
+        };
         readonly jsonOutfile: {
           readonly flags: ["-j", "--json-outfile <file>"];
           readonly description: "Output results in a JSON file";

package/src/cli/commands/commandsConfig.mjs

@@ -141,6 +141,16 @@ const CLI_COMMANDS_CONFIG = {
         values: [...SCRIPT_SHELL_OPTIONS, "default"],
         description: `When using --inline, the shell to use to run the script`,
       },
+      depOrder: {
+        flags: ["-d", "--dep-order"],
+        description:
+          "Scripts for dependent workspaces run only after their dependencies",
+      },
+      ignoreDepFailure: {
+        flags: ["-f", "--ignore-dep-failure"],
+        description:
+          "In dependency order, continue running scripts even if a dependency fails",
+      },
       jsonOutfile: {
         flags: ["-j", "--json-outfile <file>"],
         description: "Output results in a JSON file",

package/src/cli/commands/runScript/formatRunScriptOutput.d.ts

@@ -4,12 +4,13 @@ import type {
 } from "../../../project";
 import type { OutputStreamName } from "../../../runScript";
 export type FormatRunScriptOutputOptions = {
+  stripDisruptiveControls?: boolean;
   prefix?: boolean;
   scriptName: string;
 };
 export declare function formatRunScriptOutput(
   output: RunScriptAcrossWorkspacesProcessOutput,
-  { scriptName, prefix }: FormatRunScriptOutputOptions,
+  { scriptName, stripDisruptiveControls, prefix }: FormatRunScriptOutputOptions,
 ): AsyncGenerator<{
   line: string;
   metadata: RunWorkspaceScriptMetadata & {

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

@@ -1,5 +1,8 @@
 // CONCATENATED MODULE: ./src/cli/commands/runScript/formatRunScriptOutput.ts
-const sanitizeChunk = (input) => {
+const sanitizeChunk = (input, stripDisruptiveControls = false) => {
+  if (!stripDisruptiveControls) {
+    return input.replace(/\r\n/g, "\n");
+  }
   // 1) Normalize newline-ish controls
   let s = input
     .replace(/\r\n/g, "\n")
@@ -90,7 +93,10 @@ const sanitizeChunk = (input) => {
   }
   return out;
 };
-async function* formatRunScriptOutput(output, { scriptName, prefix = false }) {
+async function* formatRunScriptOutput(
+  output,
+  { scriptName, stripDisruptiveControls = true, prefix = false },
+) {
   const workspaceLineBuffers = {};
   const formatLine = (line, workspaceName, scriptName) => {
     const prefixedLine = prefix
@@ -100,7 +106,7 @@ async function* formatRunScriptOutput(output, { scriptName, prefix = false }) {
   };
   for await (const { metadata, chunk } of output.text()) {
     const workspaceName = metadata.workspace.name;
-    const sanitizedChunk = sanitizeChunk(chunk);
+    const sanitizedChunk = sanitizeChunk(chunk, stripDisruptiveControls);
     const prior = workspaceLineBuffers[workspaceName] ?? "";
     const content = prior + sanitizedChunk;
     const lines = content.split("\n");

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

@@ -53,6 +53,9 @@ const runScript = handleProjectCommand(
     logger.debug(
       `Command: Run script ${JSON.stringify(script)} for ${workspacePatterns.length ? "workspaces " + workspacePatterns.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, args: ${JSON.stringify(scriptArgs)})`,
     );
+    const workspaceCount = project.findWorkspacesByPattern(
+      ...workspacePatterns,
+    ).length;
     const { output, summary } = project.runScriptAcrossWorkspaces({
       workspacePatterns: workspacePatterns.length
         ? workspacePatterns
@@ -67,6 +70,8 @@ const runScript = handleProjectCommand(
           : true
         : undefined,
       args: scriptArgs,
+      dependencyOrder: options.depOrder,
+      ignoreDependencyFailure: options.ignoreDepFailure,
       parallel:
         typeof options.parallel === "boolean" ||
         typeof options.parallel === "undefined"
@@ -87,6 +92,7 @@ const runScript = handleProjectCommand(
       for await (const { line, metadata } of formatRunScriptOutput(output, {
         prefix: options.prefix,
         scriptName,
+        stripDisruptiveControls: workspaceCount > 1 || !!options.parallel,
       })) {
         process[metadata.streamName].write(line);
       }
@@ -95,18 +101,29 @@ const runScript = handleProjectCommand(
     const exitResults = await summary;
     exitResults.scriptResults.forEach(
       ({ success, metadata: { workspace }, exitCode }) => {
-        logger.info(
-          `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
-        );
+        const isSkipped = exitCode === -1;
+        if (isSkipped) {
+          logger.info(
+            `➖ ${workspace.name}: ${scriptName} (skipped due to dependency failure)`,
+          );
+        } else {
+          logger.info(
+            `${success ? "✅" : "❌"} ${workspace.name}: ${scriptName}${exitCode ? ` (exited with code ${exitCode})` : ""}`,
+          );
+        }
       },
     );
     const s = exitResults.scriptResults.length === 1 ? "" : "s";
+    const skippedCount = exitResults.scriptResults.filter(
+      ({ exitCode }) => exitCode === -1,
+    ).length;
+    const skippedMessage = skippedCount ? ` (${skippedCount} skipped)` : "";
     if (exitResults.failureCount) {
-      const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed`;
+      const message = `${exitResults.failureCount} of ${exitResults.scriptResults.length} script${s} failed${skippedMessage}`;
       logger.info(message);
     } else {
       logger.info(
-        `${exitResults.scriptResults.length} script${s} ran successfully`,
+        `${exitResults.scriptResults.length} script${s} ran successfully${skippedMessage}`,
       );
     }
     if (options.jsonOutfile) {

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

@@ -79,6 +79,10 @@ export type RunScriptAcrossWorkspacesOptions = {
   args?: string;
   /** Whether to run the scripts in parallel (series by default) */
   parallel?: ParallelOption;
+  /** When `true`, run scripts so that dependent workspaces run only after their dependencies */
+  dependencyOrder?: boolean;
+  /** When `true`, continue running scripts even if a dependency fails (Only relevant when `dependencyOrder` is `true`) */
+  ignoreDependencyFailure?: boolean;
 };
 export type RunScriptAcrossWorkspacesOutput = Simplify<
   RunScriptsOutput<RunWorkspaceScriptMetadata>

package/src/project/implementations/fileSystemProject.mjs

@@ -13,6 +13,7 @@ import {
 import { checkIsRecursiveScript } from "../../runScript/recursion.mjs";
 import { resolveScriptShell } from "../../runScript/scriptShellOption.mjs";
 import { findWorkspaces, sortWorkspaces } from "../../workspaces/index.mjs";
+import { preventDependencyCycles } from "../../workspaces/dependencyGraph/index.mjs";
 import { PROJECT_ERRORS } from "../errors.mjs";
 import {
   ProjectBase,
@@ -29,6 +30,7 @@ import {
 // CONCATENATED MODULE: external "../../runScript/recursion.mjs"
 // CONCATENATED MODULE: external "../../runScript/scriptShellOption.mjs"
 // CONCATENATED MODULE: external "../../workspaces/index.mjs"
+// CONCATENATED MODULE: external "../../workspaces/dependencyGraph/index.mjs"
 // CONCATENATED MODULE: external "../errors.mjs"
 // CONCATENATED MODULE: external "./projectBase.mjs"
 // CONCATENATED MODULE: ./src/project/implementations/fileSystemProject.ts
@@ -166,7 +168,7 @@ class _FileSystemProject extends ProjectBase {
         this.workspaces.map((workspace) => workspace.name)
       ).flatMap((pattern) => this.findWorkspacesByPattern(pattern)),
     );
-    const workspaces = matchedWorkspaces
+    let workspaces = matchedWorkspaces
       .filter(
         (workspace) =>
           options.inline || workspace.scripts.includes(options.script),
@@ -195,6 +197,15 @@ class _FileSystemProject extends ProjectBase {
           : `No matching workspaces found with script ${JSON.stringify(options.script)}`,
       );
     }
+    if (options.dependencyOrder) {
+      const cycleDetection = preventDependencyCycles(workspaces);
+      workspaces = cycleDetection.workspaces;
+      for (const cycle of cycleDetection.cycles) {
+        logger.warn(
+          `Dependency cycle detected: ${cycle.dependency} -> ${cycle.dependent} (ignoring)`,
+        );
+      }
+    }
     const recursiveWorkspace = workspaces.find((workspace) =>
       checkIsRecursiveScript(workspace.name, options.script),
     );
@@ -257,8 +268,16 @@ class _FileSystemProject extends ProjectBase {
           scriptCommand,
           env: createScriptRuntimeEnvVars(scriptRuntimeMetadata),
           shell,
+          dependsOn: options.dependencyOrder
+            ? workspace.dependencies
+                .map((dependency) =>
+                  workspaces.findIndex((w) => w.name === dependency),
+                )
+                .filter((index) => index !== -1)
+            : undefined,
         };
       }),
+      ignoreDependencyFailure: options.ignoreDependencyFailure,
       parallel:
         options.parallel === true
           ? {

package/src/runScript/runScript.d.ts

@@ -7,6 +7,8 @@ export type RunScriptExit<ScriptMetadata extends object = object> = {
   exitCode: number;
   signal: NodeJS.Signals | null;
   success: boolean;
+  /** Whether the script was skipped due to a failed dependency */
+  skipped?: boolean;
   startTimeISO: string;
   endTimeISO: string;
   durationMs: number;

package/src/runScript/runScripts.d.ts

@@ -4,10 +4,15 @@ import { type OutputChunk, type OutputStreamName } from "./outputChunk";
 import { type ParallelMaxValue } from "./parallel";
 import { type RunScriptExit, type RunScriptResult } from "./runScript";
 import { type ScriptCommand } from "./scriptCommand";
+import { type ScriptShellOption } from "./scriptShellOption";
 export type RunScriptsScript<ScriptMetadata extends object = object> = {
   scriptCommand: ScriptCommand;
   metadata: ScriptMetadata;
   env: Record<string, string>;
+  /** The shell to use to run the script */
+  shell?: ScriptShellOption;
+  /** Indices of other scripts in the array that must complete before this one starts */
+  dependsOn?: number[];
 };
 export type RunScriptsScriptResult<ScriptMetadata extends object = object> = {
   /** The result of running the script */
@@ -49,9 +54,12 @@ export type RunScriptsParallelOptions = {
 export type RunScriptsOptions<ScriptMetadata extends object = object> = {
   scripts: RunScriptsScript<ScriptMetadata>[];
   parallel: boolean | RunScriptsParallelOptions;
+  /** When true, run scripts even if a dependency failed. Default: false (skip them). */
+  ignoreDependencyFailure?: boolean;
 };
 /** Run a list of scripts */
 export declare const runScripts: <ScriptMetadata extends object = object>({
   scripts,
   parallel,
+  ignoreDependencyFailure,
 }: RunScriptsOptions<ScriptMetadata>) => RunScriptsResult<ScriptMetadata>;

package/src/runScript/runScripts.mjs

@@ -13,7 +13,60 @@ import { runScript } from "./runScript.mjs"; // CONCATENATED MODULE: external ".
 // CONCATENATED MODULE: external "./runScript.mjs"
 // CONCATENATED MODULE: ./src/runScript/runScripts.ts
 
-/** Run a list of scripts */ const runScripts = ({ scripts, parallel }) => {
+/** Validate dependency indices and detect cycles via DFS */ const validateScriptDependencies =
+  (scripts) => {
+    const scriptCount = scripts.length;
+    for (let i = 0; i < scriptCount; i++) {
+      const deps = scripts[i].dependsOn;
+      if (!deps) continue;
+      for (const dep of deps) {
+        if (dep === i) {
+          throw new Error(
+            `Script at index ${i} has a self-referencing dependency`,
+          );
+        }
+        if (dep < 0 || dep >= scriptCount) {
+          throw new Error(
+            `Script at index ${i} depends on invalid index ${dep} (valid range: 0-${scriptCount - 1})`,
+          );
+        }
+      }
+    }
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const colors = new Array(scriptCount).fill(WHITE);
+    const visit = (node, path) => {
+      colors[node] = GRAY;
+      const deps = scripts[node].dependsOn;
+      if (deps) {
+        for (const dep of deps) {
+          if (colors[dep] === GRAY) {
+            const cycleStart = path.indexOf(dep);
+            const cycle = path.slice(cycleStart);
+            throw new Error(
+              `Dependency cycle detected: ${[...cycle, dep].join(" -> ")}`,
+            );
+          }
+          if (colors[dep] === WHITE) {
+            visit(dep, [...path, dep]);
+          }
+        }
+      }
+      colors[node] = BLACK;
+    };
+    for (let i = 0; i < scriptCount; i++) {
+      if (colors[i] === WHITE) {
+        visit(i, [i]);
+      }
+    }
+  };
+/** Run a list of scripts */ const runScripts = ({
+  scripts,
+  parallel,
+  ignoreDependencyFailure = false,
+}) => {
+  validateScriptDependencies(scripts);
   const startTime = new Date();
   const scriptTriggers = scripts.map((_, index) => {
     let trigger = () => {
@@ -48,33 +101,88 @@ import { runScript } from "./runScript.mjs"; // CONCATENATED MODULE: external ".
       `Number of scripts to run in parallel (${parallelBatchSize}) is greater than the available CPUs (${recommendedParallelMax})`,
     );
   }
-  let runningScriptCount = 0;
-  let nextScriptIndex = 0;
-  const queueScript = (index) => {
-    if (runningScriptCount >= parallelMax) {
-      return;
-    }
-    const scriptResult = {
-      ...scripts[index],
-      result: runScript({
-        ...scripts[index],
-        env: {
-          ...scripts[index].env,
-          _BW_PARALLEL_MAX: parallelMax.toString(),
-        },
-      }),
+  const pendingScripts = new Set(scripts.map((_, i) => i));
+  const runningScripts = new Set();
+  const completedScripts = new Set();
+  const exitResults = scripts.map(() => null);
+  const scriptProcessBytes = scripts.map(() => null);
+  const createSkippedExit = (index) => {
+    const now = new Date().toISOString();
+    return {
+      exitCode: -1,
+      signal: null,
+      success: false,
+      skipped: true,
+      startTimeISO: now,
+      endTimeISO: now,
+      durationMs: 0,
+      metadata: scripts[index].metadata,
     };
-    scriptResults[index] = scriptResult;
-    scriptTriggers[index].trigger();
-    runningScriptCount++;
-    nextScriptIndex++;
-    scriptResults[index].result.exit.then(() => {
-      runningScriptCount--;
-      if (nextScriptIndex < scripts.length) {
-        queueScript(nextScriptIndex);
+  };
+  const createSkippedResult = (index) => {
+    const skippedExit = createSkippedExit(index);
+    exitResults[index] = skippedExit;
+    return {
+      result: {
+        output: (async function* () {})(),
+        processOutput: createMultiProcessOutput([]),
+        exit: Promise.resolve(skippedExit),
+        metadata: scripts[index].metadata,
+        kill: () => {},
+      },
+    };
+  };
+  const hasDependencyFailure = (index) => {
+    const deps = scripts[index].dependsOn;
+    if (!deps) return false;
+    return deps.some(
+      (dep) => exitResults[dep] !== null && !exitResults[dep].success,
+    );
+  };
+  const areDependenciesMet = (index) => {
+    const deps = scripts[index].dependsOn;
+    if (!deps) return true;
+    return deps.every((dep) => completedScripts.has(dep));
+  };
+  const scheduleReadyScripts = () => {
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const index of [...pendingScripts]) {
+        if (runningScripts.size >= parallelMax) return;
+        if (!areDependenciesMet(index)) continue;
+        if (!ignoreDependencyFailure && hasDependencyFailure(index)) {
+          pendingScripts.delete(index);
+          completedScripts.add(index);
+          scriptResults[index] = createSkippedResult(index);
+          scriptProcessBytes[index] = (async function* () {})();
+          scriptTriggers[index].trigger();
+          changed = true;
+          continue;
+        }
+        pendingScripts.delete(index);
+        runningScripts.add(index);
+        const scriptResult = {
+          ...scripts[index],
+          result: runScript({
+            ...scripts[index],
+            env: {
+              ...scripts[index].env,
+              _BW_PARALLEL_MAX: parallelMax.toString(),
+            },
+          }),
+        };
+        scriptResults[index] = scriptResult;
+        scriptProcessBytes[index] = scriptResult.result.processOutput.bytes();
+        scriptTriggers[index].trigger();
+        scriptResult.result.exit.then((exit) => {
+          runningScripts.delete(index);
+          completedScripts.add(index);
+          exitResults[index] = exit;
+          scheduleReadyScripts();
+        });
       }
-    });
-    return scriptResult;
+    }
   };
   const scriptOutputQueues = scripts.map(() =>
     ["stdout", "stderr"].map(() => createAsyncIterableQueue()),
@@ -105,9 +213,7 @@ import { runScript } from "./runScript.mjs"; // CONCATENATED MODULE: external ".
       });
       outputReaders.push(
         (async () => {
-          for await (const chunk of scriptResults[
-            index
-          ].result.processOutput.bytes()) {
+          for await (const chunk of scriptProcessBytes[index]) {
             outputQueue.push({
               outputChunk: createOutputChunk(
                 chunk.metadata.streamName,
@@ -134,7 +240,7 @@ import { runScript } from "./runScript.mjs"; // CONCATENATED MODULE: external ".
     });
   };
   const awaitSummary = async () => {
-    scripts.forEach((_, index) => queueScript(index));
+    scheduleReadyScripts();
     await handleScriptProcesses();
     const scriptExitResults = await Promise.all(
       scripts.map((_, index) => scriptResults[index].result.exit),

package/src/workspaces/dependencyGraph/cycles.mjs

@@ -8,6 +8,8 @@ const preventDependencyCycles = (workspaces) => {
   const inStack = new Set();
   // dedupe cycle edges
   const cyclesKeyed = new Map();
+  // all nodes that participate in at least one cycle
+  const cycleNodeSet = new Set();
   const recordCycleEdge = (dependency, dependent) => {
     const key = `${dependency}\u0000${dependent}`;
     if (!cyclesKeyed.has(key))
@@ -34,6 +36,11 @@ const preventDependencyCycles = (workspaces) => {
       // Cycle edge: current `name` depends on `dep`, and `dep` is already in the active stack
       if (inStack.has(dep)) {
         recordCycleEdge(dep, name);
+        // Mark every node between `dep` and `name` (inclusive) as a cycle participant.
+        // `name` is already at stack[stack.length - 1] since it was pushed above.
+        const depIndex = stack.indexOf(dep);
+        for (let i = depIndex; i < stack.length; i++)
+          cycleNodeSet.add(stack[i]);
         continue;
       }
       // Missing dependency name: treat as a leaf chain [dep, name]
@@ -62,17 +69,16 @@ const preventDependencyCycles = (workspaces) => {
     ...workspace,
   }));
   const cycles = [...cyclesKeyed.values()];
-  for (const cycle of cycles) {
-    const { dependency, dependent } = cycle;
-    const dependencyWorkspace = workspaces.find((w) => w.name === dependency);
-    const dependentWorkspace = workspaces.find((w) => w.name === dependent);
-    if (dependencyWorkspace) {
-      dependencyWorkspace.dependencies =
-        dependencyWorkspace.dependencies.filter((d) => d !== dependent);
-    }
-    if (dependentWorkspace) {
-      dependentWorkspace.dependents = dependentWorkspace.dependents.filter(
-        (d) => d !== dependency,
+  // Remove all dependency/dependent edges between workspaces that share a cycle.
+  // This leaves no opinionated "winner": if two workspaces are in the same cycle,
+  // all edges between them are stripped.
+  for (const workspace of workspaces) {
+    if (cycleNodeSet.has(workspace.name)) {
+      workspace.dependencies = workspace.dependencies.filter(
+        (d) => !cycleNodeSet.has(d),
+      );
+      workspace.dependents = workspace.dependents.filter(
+        (d) => !cycleNodeSet.has(d),
       );
     }
   }