bun-workspaces 1.8.2 → 1.9.0

package/src/affected/fileAffectedWorkspaces.mjs

@@ -8,10 +8,15 @@ const GLOB_CHARACTER_REGEX = /[*?[{]/;
 const toPosixPath = (filePath) => filePath.replaceAll("\\", "/");
 const stripTrailingSlashes = (filePath) => filePath.replace(/\/+$/, "");
 const stripLeadingSlashes = (filePath) => filePath.replace(/^\/+/, "");
+const stripDotSlashSegments = (filePath) => {
+  let stripped = filePath;
+  while (stripped.startsWith("./")) stripped = stripped.slice(2);
+  return stripped === "." ? "" : stripped;
+};
 const normalizeChangedFilePath = ({ rootDirectory, filePath }) => {
   const posixFilePath = toPosixPath(filePath);
   if (!path.isAbsolute(filePath)) {
-    return posixFilePath;
+    return stripDotSlashSegments(posixFilePath);
   }
   const posixRoot = stripTrailingSlashes(toPosixPath(rootDirectory));
   if (posixFilePath === posixRoot) {
@@ -160,12 +165,36 @@ const resolveInputWorkspaceDependencies = ({ workspaceInputs }) => {
   }
   return inputDependenciesByName;
 };
+const collectDirectEdges = ({
+  workspace,
+  inputDependenciesByName,
+  ignoreWorkspaceDependencies,
+}) => {
+  const edges = [];
+  for (const dependencyName of inputDependenciesByName.get(workspace.name) ??
+    []) {
+    edges.push({
+      dependencyName,
+      edgeSource: "input",
+    });
+  }
+  if (!ignoreWorkspaceDependencies) {
+    for (const dependencyName of workspace.dependencies) {
+      edges.push({
+        dependencyName,
+        edgeSource: "package",
+      });
+    }
+  }
+  return edges;
+};
 const computeAffectedWorkspaceSet = ({
   workspaceInputs,
   workspaceByName,
   changedFilesByName,
+  externalDepChangesByWorkspace,
   inputDependenciesByName,
-  ignorePackageDependencies,
+  ignoreWorkspaceDependencies,
 }) => {
   const inputDependentsByName = new Map();
   for (const [workspaceName, dependencyNames] of inputDependenciesByName) {
@@ -181,7 +210,11 @@ const computeAffectedWorkspaceSet = ({
   const affected = new Set();
   const queue = [];
   for (const { workspace } of workspaceInputs) {
-    if ((changedFilesByName.get(workspace.name)?.length ?? 0) > 0) {
+    const hasChangedFiles =
+      (changedFilesByName.get(workspace.name)?.length ?? 0) > 0;
+    const hasExternalDepChanges =
+      (externalDepChangesByWorkspace.get(workspace.name)?.length ?? 0) > 0;
+    if (hasChangedFiles || hasExternalDepChanges) {
       affected.add(workspace.name);
       queue.push(workspace.name);
     }
@@ -191,7 +224,7 @@ const computeAffectedWorkspaceSet = ({
     const currentWorkspace = workspaceByName.get(currentName);
     const dependents = [
       ...(inputDependentsByName.get(currentName) ?? []),
-      ...(!ignorePackageDependencies && currentWorkspace
+      ...(!ignoreWorkspaceDependencies && currentWorkspace
         ? currentWorkspace.dependents
         : []),
     ];
@@ -204,66 +237,117 @@ const computeAffectedWorkspaceSet = ({
   }
   return affected;
 };
+/**
+ * Walk forward from `directDependencyName` through the affected dep graph,
+ * appending each next affected dep edge to the chain until we run out of
+ * affected dep edges to follow. Stops on:
+ *   - no further affected dep edges,
+ *   - revisiting a workspace already in the chain (cycle).
+ *
+ * Branching is broken deterministically by edge insertion order
+ * (input edges before package edges, declaration order within each).
+ */ const extendChainThroughAffectedDeps = ({
+  startingWorkspaceName,
+  directDependencyName,
+  directEdgeSource,
+  workspaceByName,
+  inputDependenciesByName,
+  affectedSet,
+  ignoreWorkspaceDependencies,
+}) => {
+  const chain = [
+    {
+      workspaceName: startingWorkspaceName,
+    },
+    {
+      workspaceName: directDependencyName,
+      edgeSource: directEdgeSource,
+    },
+  ];
+  const visited = new Set([startingWorkspaceName, directDependencyName]);
+  let currentName = directDependencyName;
+  while (true) {
+    const currentWorkspace = workspaceByName.get(currentName);
+    if (!currentWorkspace) break;
+    const nextEdge = collectDirectEdges({
+      workspace: currentWorkspace,
+      inputDependenciesByName,
+      ignoreWorkspaceDependencies,
+    }).find(
+      ({ dependencyName }) =>
+        !visited.has(dependencyName) &&
+        workspaceByName.has(dependencyName) &&
+        affectedSet.has(dependencyName),
+    );
+    if (!nextEdge) break;
+    chain.push({
+      workspaceName: nextEdge.dependencyName,
+      edgeSource: nextEdge.edgeSource,
+    });
+    visited.add(nextEdge.dependencyName);
+    currentName = nextEdge.dependencyName;
+  }
+  return chain;
+};
 const collectAffectedDependencies = ({
   startingWorkspace,
   workspaceByName,
   inputDependenciesByName,
   affectedSet,
-  ignorePackageDependencies,
+  ignoreWorkspaceDependencies,
 }) => {
   const results = [];
-  const visited = new Set([startingWorkspace.name]);
-  const visit = (currentName, chain) => {
-    const currentWorkspace = workspaceByName.get(currentName);
-    if (!currentWorkspace) return;
-    const edges = [];
-    for (const dependencyName of inputDependenciesByName.get(currentName) ??
-      []) {
-      edges.push({
-        dependencyName,
-        edgeSource: "input",
-      });
-    }
-    if (!ignorePackageDependencies) {
-      for (const dependencyName of currentWorkspace.dependencies) {
-        edges.push({
-          dependencyName,
-          edgeSource: "package",
-        });
-      }
-    }
-    for (const { dependencyName, edgeSource } of edges) {
-      if (visited.has(dependencyName)) continue;
-      if (!workspaceByName.has(dependencyName)) continue;
-      visited.add(dependencyName);
-      const dependencyChain = [
-        ...chain,
-        {
-          workspaceName: dependencyName,
-          edgeSource,
-        },
-      ];
-      if (affectedSet.has(dependencyName)) {
-        results.push({
-          dependencyName,
-          chain: dependencyChain,
-        });
-      }
-      visit(dependencyName, dependencyChain);
-    }
-  };
-  visit(startingWorkspace.name, [
-    {
-      workspaceName: startingWorkspace.name,
-    },
-  ]);
+  const seen = new Set([startingWorkspace.name]);
+  const directEdges = collectDirectEdges({
+    workspace: startingWorkspace,
+    inputDependenciesByName,
+    ignoreWorkspaceDependencies,
+  });
+  for (const { dependencyName, edgeSource } of directEdges) {
+    if (seen.has(dependencyName)) continue;
+    if (!workspaceByName.has(dependencyName)) continue;
+    seen.add(dependencyName);
+    if (!affectedSet.has(dependencyName)) continue;
+    results.push({
+      dependencyName,
+      chain: extendChainThroughAffectedDeps({
+        startingWorkspaceName: startingWorkspace.name,
+        directDependencyName: dependencyName,
+        directEdgeSource: edgeSource,
+        workspaceByName,
+        inputDependenciesByName,
+        affectedSet,
+        ignoreWorkspaceDependencies,
+      }),
+    });
+  }
   return results;
 };
+const filterExternalDepChangesByInputs = ({
+  changesByWorkspace,
+  workspaceInputs,
+}) => {
+  const filtered = new Map();
+  for (const { workspace, inputExternalDependencyNames } of workspaceInputs) {
+    const changes = changesByWorkspace.get(workspace.name);
+    if (!changes?.length) continue;
+    if (inputExternalDependencyNames === undefined) {
+      filtered.set(workspace.name, changes);
+      continue;
+    }
+    if (inputExternalDependencyNames.length === 0) continue;
+    const allowed = new Set(inputExternalDependencyNames);
+    const matched = changes.filter((change) => allowed.has(change.name));
+    if (matched.length) filtered.set(workspace.name, matched);
+  }
+  return filtered;
+};
 const getFileAffectedWorkspaces = async ({
   rootDirectory,
   workspaceInputs,
   changedFilePaths,
-  ignorePackageDependencies = false,
+  externalDepChangesByWorkspace = new Map(),
+  ignoreWorkspaceDependencies = false,
 }) => {
   const normalizedChangedFilePaths = changedFilePaths.map((filePath) =>
     normalizeChangedFilePath({
@@ -285,6 +369,10 @@ const getFileAffectedWorkspaces = async ({
       }),
     );
   }
+  const filteredExternalDepChanges = filterExternalDepChangesByInputs({
+    changesByWorkspace: externalDepChangesByWorkspace,
+    workspaceInputs,
+  });
   const inputDependenciesByName = resolveInputWorkspaceDependencies({
     workspaceInputs,
   });
@@ -292,17 +380,20 @@ const getFileAffectedWorkspaces = async ({
     workspaceInputs,
     workspaceByName,
     changedFilesByName,
+    externalDepChangesByWorkspace: filteredExternalDepChanges,
     inputDependenciesByName,
-    ignorePackageDependencies,
+    ignoreWorkspaceDependencies,
   });
   const affectedWorkspaces = workspaceInputs.map(({ workspace }) => {
     const changedFiles = changedFilesByName.get(workspace.name) ?? [];
+    const externalDependencies =
+      filteredExternalDepChanges.get(workspace.name) ?? [];
     const dependencies = collectAffectedDependencies({
       startingWorkspace: workspace,
       workspaceByName,
       inputDependenciesByName,
       affectedSet,
-      ignorePackageDependencies,
+      ignoreWorkspaceDependencies,
     });
     return {
       workspace,
@@ -310,6 +401,7 @@ const getFileAffectedWorkspaces = async ({
       affectedReasons: {
         changedFiles,
         dependencies,
+        externalDependencies,
       },
     };
   });

package/src/affected/gitAffectedFiles.mjs

@@ -52,6 +52,38 @@ const resolveGitRoot = async (rootDirectory) => {
   }
   return result.stdout.trim();
 };
+/**
+ * Read a project-root-relative file's contents at a specific git ref via
+ * `git show <ref>:<repo-relative-path>`. Returns `null` if the file does not
+ * exist at that ref (e.g. it was added later). Throws on other git errors.
+ */ const readProjectFileAtGitRef = async ({
+  rootDirectory,
+  ref,
+  projectRelativePath,
+}) => {
+  const gitRoot = fs.realpathSync.native(
+    path.resolve(await resolveGitRoot(rootDirectory)),
+  );
+  const absoluteProjectRoot = fs.realpathSync.native(
+    path.resolve(rootDirectory),
+  );
+  const absoluteFile = path.resolve(absoluteProjectRoot, projectRelativePath);
+  const repoRelative = path
+    .relative(gitRoot, absoluteFile)
+    .split(path.sep)
+    .join("/");
+  const result = await runGit(["show", `${ref}:${repoRelative}`], gitRoot);
+  if (result.exitCode === 0) return result.stdout;
+  if (
+    result.stderr.includes("does not exist") ||
+    result.stderr.includes("exists on disk, but not in")
+  ) {
+    return null;
+  }
+  throw new GIT_AFFECTED_ERRORS.GitCommandFailed(
+    `git show ${ref}:${repoRelative} failed (exit ${result.exitCode}): ${result.stderr.trim()}`,
+  );
+};
 const toProjectFilePath = ({
   gitRoot,
   absoluteProjectRoot,
@@ -83,6 +115,10 @@ const getGitAffectedFiles = async (options) => {
   const includeStaged = !ignoreUncommitted && !ignoreStaged;
   const includeUnstaged = !ignoreUncommitted && !ignoreUnstaged;
   const includeUntracked = !ignoreUncommitted && !ignoreUntracked;
+  const [baseSha, headSha] = await Promise.all([
+    runGitOrThrow(["rev-parse", baseRef], gitRoot).then((out) => out.trim()),
+    runGitOrThrow(["rev-parse", headRef], gitRoot).then((out) => out.trim()),
+  ]);
   const collectors = [
     runGitOrThrow(
       ["diff", "--name-only", "-z", baseRef, headRef],
@@ -147,7 +183,14 @@ const getGitAffectedFiles = async (options) => {
     .sort((a, b) => a.projectFilePath.localeCompare(b.projectFilePath));
   return {
     files,
+    baseSha,
+    headSha,
   };
 };
 
-export { GIT_AFFECTED_ERRORS, GIT_AFFECTED_FILE_REASONS, getGitAffectedFiles };
+export {
+  GIT_AFFECTED_ERRORS,
+  GIT_AFFECTED_FILE_REASONS,
+  getGitAffectedFiles,
+  readProjectFileAtGitRef,
+};

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;