bun-workspaces 1.8.2 → 1.10.0

package/src/affected/gitAffectedWorkspaces.mjs

@@ -1,22 +1,90 @@
+import fs from "fs";
+import path from "path";
+import { parseBunLockPackageVersions } from "../internal/bun/bunLock.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import { computeExternalDependencyChanges } from "./externalDependencyChanges.mjs";
 import { getFileAffectedWorkspaces } from "./fileAffectedWorkspaces.mjs";
-import { getGitAffectedFiles } from "./gitAffectedFiles.mjs";
+import {
+  getGitAffectedFiles,
+  readProjectFileAtGitRef,
+} from "./gitAffectedFiles.mjs";
 
+const BUN_LOCK_PROJECT_RELATIVE_PATH = "bun.lock";
+const readCurrentBunLock = (rootDirectory) => {
+  const lockPath = path.join(rootDirectory, BUN_LOCK_PROJECT_RELATIVE_PATH);
+  try {
+    return fs.readFileSync(lockPath, "utf8");
+  } catch {
+    return null;
+  }
+};
+const loadVersionsAt = async (rootDirectory, ref) => {
+  const contents = await readProjectFileAtGitRef({
+    rootDirectory,
+    ref,
+    projectRelativePath: BUN_LOCK_PROJECT_RELATIVE_PATH,
+  });
+  if (contents === null) return new Map();
+  const parsed = parseBunLockPackageVersions(contents);
+  if (parsed instanceof BunWorkspacesError) {
+    logger.warn(
+      `Could not parse bun.lock at ref "${ref}": ${parsed.message}. Treating as empty.`,
+    );
+    return new Map();
+  }
+  return parsed;
+};
+const loadCurrentVersions = (rootDirectory) => {
+  const contents = readCurrentBunLock(rootDirectory);
+  if (contents === null) return new Map();
+  const parsed = parseBunLockPackageVersions(contents);
+  if (parsed instanceof BunWorkspacesError) {
+    logger.warn(
+      `Could not parse current bun.lock: ${parsed.message}. Treating as empty.`,
+    );
+    return new Map();
+  }
+  return parsed;
+};
 const getGitAffectedWorkspaces = async ({
   rootDirectory,
   workspacesOptions,
   gitOptions,
 }) => {
-  const { files: gitFiles } = await getGitAffectedFiles({
+  const {
+    files: gitFiles,
+    baseSha,
+    headSha,
+  } = await getGitAffectedFiles({
     rootDirectory,
     ...gitOptions,
   });
   const gitFileByPath = new Map(
     gitFiles.map((file) => [file.projectFilePath, file]),
   );
+  const projectWorkspaces = workspacesOptions.workspaces ?? [];
+  const externalDepChangesByWorkspace =
+    workspacesOptions.ignoreExternalDependencies || !projectWorkspaces.length
+      ? new Map()
+      : computeExternalDependencyChanges({
+          workspaces: projectWorkspaces,
+          baseLock: await loadVersionsAt(rootDirectory, gitOptions.baseRef),
+          headLock:
+            gitOptions.headRef === "HEAD"
+              ? loadCurrentVersions(rootDirectory)
+              : await loadVersionsAt(rootDirectory, gitOptions.headRef),
+        });
+  const {
+    workspaces: _omit,
+    ignoreExternalDependencies: _omit2,
+    ...fileOpts
+  } = workspacesOptions;
   const { affectedWorkspaces } = await getFileAffectedWorkspaces({
     rootDirectory,
-    ...workspacesOptions,
+    ...fileOpts,
     changedFilePaths: gitFiles.map((file) => file.projectFilePath),
+    externalDepChangesByWorkspace,
   });
   const annotatedWorkspaces = affectedWorkspaces.map((result) => ({
     ...result,
@@ -32,6 +100,8 @@ const getGitAffectedWorkspaces = async ({
   }));
   return {
     affectedWorkspaces: annotatedWorkspaces,
+    baseSha,
+    headSha,
   };
 };
 

package/src/affected/index.mjs

@@ -1,5 +1,7 @@
 export * from "./fileAffectedWorkspaces.mjs";
 export * from "./gitAffectedFiles.mjs";
 export * from "./gitAffectedWorkspaces.mjs";
+export * from "./affectedBaseRef.mjs";
+export * from "./externalDependencyChanges.mjs";
 
 export {};

package/src/ai/mcp/serverState.mjs

@@ -1,4 +1,4 @@
-import { createFileSystemProject } from "../../project/implementations/fileSystemProject.mjs";
+import { createFileSystemProject } from "../../project/implementations/fileSystemProject/index.mjs";
 
 const SERVER_STATE = {
   workingDirectory: null,

package/src/cli/commands/commandHandlerUtils.mjs

@@ -3,12 +3,17 @@ import { BunWorkspacesError } from "../../internal/core/error/index.mjs";
 import { createLogger, logger } from "../../internal/logger/index.mjs";
 import { getCliCommandConfig } from "../../2392.mjs";
 
-/** Splits workspace patterns by whitespace, but allows escaping spaces via backslash */ const splitWorkspacePatterns =
-  (workspacePatterns) =>
-    workspacePatterns
-      .split(/(?<!\\)\s+/)
-      .filter(Boolean)
-      .map((pattern) => pattern.replace(/\\\s/g, " "));
+/**
+ * Splits a multi-value CLI arg on whitespace (any of space/tab/newline). A
+ * literal space inside a value can be preserved by escaping it with a
+ * backslash (e.g. `path/with\ space`). Used for `--files` and
+ * `--workspace-patterns`, both of which accept output of `$(bw ...)`
+ * substitutions, which are typically newline-separated.
+ */ const splitWhitespaceArg = (raw) =>
+  raw
+    .split(/(?<!\\)\s+/)
+    .filter(Boolean)
+    .map((value) => value.replace(/\\\s/g, " "));
 const createWorkspaceInfoLines = (workspace) => [
   `Workspace: ${workspace.name}${workspace.isRoot ? " (root)" : ""}`,
   ` - Aliases: ${workspace.aliases.join(", ")}`,
@@ -85,5 +90,5 @@ export {
   createWorkspaceInfoLines,
   handleGlobalCommand,
   handleProjectCommand,
-  splitWorkspacePatterns,
+  splitWhitespaceArg,
 };

package/src/cli/commands/commands.mjs

@@ -7,8 +7,9 @@ import {
   tagInfo,
   workspaceInfo,
 } from "./handleSimpleCommands.mjs";
+import { listAffected } from "./listAffected.mjs";
 import { mcpServer } from "./mcp.mjs";
-import { runScript } from "./runScript/index.mjs";
+import { runAffected, runScript } from "./runScript/index.mjs";
 
 const defineGlobalCommands = (context) => {
   doctor(context);
@@ -22,6 +23,8 @@ const defineProjectCommands = (context) => {
   tagInfo(context);
   mcpServer(context);
   runScript(context);
+  listAffected(context);
+  runAffected(context);
 };
 
 export { defineGlobalCommands, defineProjectCommands };

package/src/cli/commands/handleSimpleCommands.mjs

@@ -7,7 +7,7 @@ import {
   createWorkspaceInfoLines,
   handleGlobalCommand,
   handleProjectCommand,
-  splitWorkspacePatterns,
+  splitWhitespaceArg,
 } from "./commandHandlerUtils.mjs";
 import { isJSONObject } from "../../8257.mjs";
 
@@ -51,7 +51,7 @@ const listWorkspaces = handleProjectCommand(
     }
     const patterns = positionalWorkspacePatterns?.length
       ? positionalWorkspacePatterns
-      : splitWorkspacePatterns(options.workspacePatterns ?? "");
+      : splitWhitespaceArg(options.workspacePatterns ?? "");
     const workspaces = patterns?.length
       ? project.findWorkspacesByPattern(...patterns)
       : project.workspaces;

package/src/cli/commands/listAffected.mjs

@@ -0,0 +1,184 @@
+import path from "path";
+import { logger } from "../../internal/logger/index.mjs";
+import {
+  commandOutputLogger,
+  createJsonLines,
+  handleProjectCommand,
+  splitWhitespaceArg,
+} from "./commandHandlerUtils.mjs";
+
+const SHORT_SHA_LENGTH = 7;
+const shortSha = (sha) => sha.slice(0, SHORT_SHA_LENGTH);
+const formatGitHeader = (metadata) => {
+  if (metadata.diffSource !== "git" || !metadata.git) return null;
+  const { baseRef, headRef, baseSha, headSha } = metadata.git;
+  return [
+    `Git base ref: \x1b[1m${baseRef}\x1b[0m (${shortSha(baseSha)})`,
+    `Git head ref: \x1b[1m${headRef}\x1b[0m (${shortSha(headSha)})`,
+  ].join("\n");
+};
+const formatDependencyChain = (dependency) => {
+  const segments = dependency.chain.map((entry, index) => {
+    if (index === 0 || !entry.edgeSource) return entry.workspaceName;
+    return `\x1b[90m--[${entry.edgeSource}]->\x1b[0m ${entry.workspaceName}`;
+  });
+  return segments.join(" ");
+};
+const formatSourceMarker = (change) =>
+  change.source === "devDependencies" ? " (dev)" : "";
+const formatExternalDepEntryShort = (change) =>
+  `${change.name}${formatSourceMarker(change)}`;
+const formatExternalDepEntryDetailed = (change) => {
+  const versions =
+    change.baseVersion === null && change.headVersion === null
+      ? "lockfile changed; precise diff unavailable"
+      : `${change.baseVersion ?? "(absent)"} -> ${change.headVersion ?? "(absent)"}`;
+  return `${change.name}${formatSourceMarker(change)} \x1b[90m[${versions}]\x1b[0m`;
+};
+const createWorkspaceSummaryLines = (result) => {
+  const { workspace, affectedReasons } = result;
+  const lines = [
+    `\x1b[1mWorkspace: ${workspace.name}\x1b[0m`,
+    `Path: ${workspace.path}`,
+  ];
+  lines.push(
+    `\x1b[96mChanged input files:\x1b[0m ${affectedReasons.changedFiles.length}`,
+  );
+  if (affectedReasons.dependencies.length) {
+    lines.push(
+      `\x1b[96mAffected dependencies:\x1b[0m ${affectedReasons.dependencies.map(({ dependencyName }) => dependencyName).join(", ")}`,
+    );
+  } else {
+    lines.push(`\x1b[96mAffected dependencies:\x1b[0m (none)`);
+  }
+  if (affectedReasons.externalDependencies.length) {
+    lines.push(
+      `\x1b[96mChanged external dependencies:\x1b[0m ${affectedReasons.externalDependencies.map(formatExternalDepEntryShort).join(", ")}`,
+    );
+  } else {
+    lines.push(`\x1b[96mChanged external dependencies:\x1b[0m (none)`);
+  }
+  return lines;
+};
+const createWorkspaceDetailedLines = (result) => {
+  const { workspace, affectedReasons } = result;
+  const lines = [
+    `\x1b[1mWorkspace: ${workspace.name}\x1b[0m`,
+    `Path: ${workspace.path}`,
+  ];
+  if (affectedReasons.changedFiles.length) {
+    lines.push("\x1b[96mChanged input files:\x1b[0m");
+    for (const file of affectedReasons.changedFiles) {
+      const reasons = file.gitReasons
+        ?.filter((reason) => reason !== "diff")
+        .join(", ");
+      lines.push(
+        ` - ${path.relative(workspace.path, file.projectFilePath)} \x1b[90m(input: ${JSON.stringify(file.inputMatch)})${reasons ? ` [${reasons}]` : ""}\x1b[0m`,
+      );
+    }
+  } else {
+    lines.push("\x1b[96mChanged input files:\x1b[0m (none)");
+  }
+  if (affectedReasons.dependencies.length) {
+    lines.push("\x1b[96mAffected dependencies:\x1b[0m");
+    for (const dependency of affectedReasons.dependencies) {
+      lines.push(` - ${dependency.dependencyName}`);
+      lines.push(`   chain: ${formatDependencyChain(dependency)}`);
+    }
+  } else {
+    lines.push("\x1b[96mAffected dependencies:\x1b[0m (none)");
+  }
+  if (affectedReasons.externalDependencies.length) {
+    lines.push("\x1b[96mChanged external dependencies:\x1b[0m");
+    for (const change of affectedReasons.externalDependencies) {
+      lines.push(` - ${formatExternalDepEntryDetailed(change)}`);
+    }
+  } else {
+    lines.push("\x1b[96mChanged external dependencies:\x1b[0m (none)");
+  }
+  return lines;
+};
+const listAffected = handleProjectCommand(
+  "listAffected",
+  async ({ project }, options) => {
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    if (options.files !== undefined && (options.base || options.head)) {
+      logger.error(
+        "CLI syntax error: --files cannot be used with --base or --head",
+      );
+      process.exit(1);
+      return;
+    }
+    if (options.detailed && !options.explain) {
+      logger.error("CLI syntax error: --detailed requires --explain");
+      process.exit(1);
+      return;
+    }
+    const determineOptions =
+      options.files !== undefined
+        ? {
+            diffSource: "fileList",
+            changedFiles: splitWhitespaceArg(options.files),
+            script: options.script,
+            ignoreWorkspaceDependencies:
+              options.ignoreWorkspaceDeps || undefined,
+            ignoreExternalDependencies: options.ignoreExternalDeps || undefined,
+          }
+        : {
+            diffSource: "git",
+            script: options.script,
+            ignoreWorkspaceDependencies:
+              options.ignoreWorkspaceDeps || undefined,
+            ignoreExternalDependencies: options.ignoreExternalDeps || undefined,
+            diffOptions: {
+              baseRef: options.base,
+              headRef: options.head,
+              ignoreUntracked: options.ignoreUntracked || undefined,
+              ignoreUnstaged: options.ignoreUnstaged || undefined,
+              ignoreStaged: options.ignoreStaged || undefined,
+              ignoreUncommitted: options.ignoreUncommitted || undefined,
+            },
+          };
+    const result = await project.determineAffectedWorkspaces(determineOptions);
+    const affectedResults = result.workspaceResults.filter(
+      ({ isAffected }) => isAffected,
+    );
+    if (options.json) {
+      const payload = options.explain
+        ? result
+        : affectedResults.map(({ workspace }) => workspace.name);
+      commandOutputLogger.info(createJsonLines(payload, options).join("\n"));
+      return;
+    }
+    if (!options.explain) {
+      if (affectedResults.length) {
+        commandOutputLogger.info(
+          affectedResults.map(({ workspace }) => workspace.name).join("\n"),
+        );
+      } else {
+        logger.info("No affected workspaces");
+      }
+      return;
+    }
+    const lines = [""];
+    const gitHeader = formatGitHeader(result.metadata);
+    if (gitHeader) lines.push(gitHeader, "");
+    if (!affectedResults.length) {
+      lines.push("No affected workspaces");
+    } else {
+      const renderWorkspace = options.detailed
+        ? createWorkspaceDetailedLines
+        : createWorkspaceSummaryLines;
+      for (const workspaceResult of affectedResults) {
+        lines.push(...renderWorkspace(workspaceResult), "");
+      }
+      if (!options.detailed) {
+        // gray
+        lines.push("\x1b[90mPass --detailed for more info\x1b[0m");
+      }
+    }
+    commandOutputLogger.info(lines.join("\n"));
+  },
+);
+
+export { listAffected };

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

@@ -0,0 +1,99 @@
+import { logger } from "../../../internal/logger/index.mjs";
+import {
+  handleProjectCommand,
+  splitWhitespaceArg,
+} from "../commandHandlerUtils.mjs";
+import { handleScriptRunFlow } from "./scriptRunFlow.mjs";
+
+const runAffected = handleProjectCommand(
+  "runAffected",
+  async (
+    {
+      project,
+      postTerminatorArgs,
+      outputWriters,
+      terminalWidth,
+      terminalHeight,
+    },
+    positionalScript,
+    options,
+  ) => {
+    options.inlineName = options.inlineName?.trim();
+    options.args = options.args?.trim();
+    options.jsonOutfile = options.jsonOutfile?.trim();
+    options.parallel =
+      typeof options.parallel === "string"
+        ? options.parallel.trim()
+        : options.parallel;
+    if (positionalScript && options.script) {
+      logger.error(
+        "CLI syntax error: Cannot use both inline script positional and --script|-S option",
+      );
+      process.exit(1);
+      return;
+    }
+    const script = options.script || positionalScript;
+    if (postTerminatorArgs.length && options.args) {
+      logger.error(
+        "CLI syntax error: Cannot use both --args and inline script args after --",
+      );
+      process.exit(1);
+      return;
+    }
+    const scriptArgs = postTerminatorArgs.length
+      ? postTerminatorArgs
+      : options.args;
+    if (options.files !== undefined && (options.base || options.head)) {
+      logger.error(
+        "CLI syntax error: --files cannot be used with --base or --head",
+      );
+      process.exit(1);
+      return;
+    }
+    const affectedOptions =
+      options.files !== undefined
+        ? {
+            diffSource: "fileList",
+            changedFiles: splitWhitespaceArg(options.files),
+            ignoreWorkspaceDependencies:
+              options.ignoreWorkspaceDeps || undefined,
+            ignoreExternalDependencies: options.ignoreExternalDeps || undefined,
+          }
+        : {
+            diffSource: "git",
+            ignoreWorkspaceDependencies:
+              options.ignoreWorkspaceDeps || undefined,
+            ignoreExternalDependencies: options.ignoreExternalDeps || undefined,
+            diffOptions: {
+              baseRef: options.base,
+              headRef: options.head,
+              ignoreUntracked: options.ignoreUntracked || undefined,
+              ignoreUnstaged: options.ignoreUnstaged || undefined,
+              ignoreStaged: options.ignoreStaged || undefined,
+              ignoreUncommitted: options.ignoreUncommitted || undefined,
+            },
+          };
+    logger.debug(
+      `Command: Run ${options.inline ? "inline " : ""}script ${JSON.stringify(script)} across affected workspaces (${affectedOptions.diffSource})`,
+    );
+    logger.debug(`Options: ${JSON.stringify(options)}`);
+    await handleScriptRunFlow({
+      project,
+      context: {
+        outputWriters,
+        terminalWidth,
+        terminalHeight,
+      },
+      script,
+      scriptArgs,
+      cliOptions: options,
+      runner: (scriptOptions) =>
+        project.runAffectedWorkspaceScript({
+          affectedOptions,
+          scriptOptions,
+        }),
+    });
+  },
+);
+
+export { runAffected };