bun-workspaces 1.8.1 → 1.9.0

package/src/affected/fileAffectedWorkspaces.mjs

@@ -0,0 +1,413 @@
+import path from "path";
+import bun from "bun";
+import { logger } from "../internal/logger/index.mjs";
+import { matchWorkspacesByPatterns } from "../workspaces/index.mjs";
+
+const FILE_PATTERN_NEGATION_PREFIX = "!";
+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 stripDotSlashSegments(posixFilePath);
+  }
+  const posixRoot = stripTrailingSlashes(toPosixPath(rootDirectory));
+  if (posixFilePath === posixRoot) {
+    return "";
+  }
+  if (posixRoot && posixFilePath.startsWith(`${posixRoot}/`)) {
+    return posixFilePath.slice(posixRoot.length + 1);
+  }
+  return posixFilePath;
+};
+const PROJECT_RELATIVE_PREFIX = "/";
+const PARENT_SEGMENT = "..";
+const resolveInputPattern = ({ workspacePath, inputPattern }) => {
+  const posixPattern = toPosixPath(inputPattern);
+  let rawJoined;
+  if (posixPattern.startsWith(PROJECT_RELATIVE_PREFIX)) {
+    rawJoined = stripLeadingSlashes(posixPattern);
+  } else {
+    const normalizedWorkspacePath = stripTrailingSlashes(
+      toPosixPath(workspacePath),
+    );
+    const stripped = stripTrailingSlashes(posixPattern);
+    if (!normalizedWorkspacePath || normalizedWorkspacePath === ".") {
+      rawJoined = stripped;
+    } else if (!stripped || stripped === ".") {
+      rawJoined = normalizedWorkspacePath;
+    } else {
+      rawJoined = `${normalizedWorkspacePath}/${stripped}`;
+    }
+  }
+  if (!rawJoined) return "";
+  const normalized = path.posix.normalize(rawJoined);
+  if (normalized === ".") return "";
+  return stripTrailingSlashes(normalized);
+};
+const isPatternOutsideProject = (resolvedPattern) =>
+  resolvedPattern === PARENT_SEGMENT ||
+  resolvedPattern.startsWith(`${PARENT_SEGMENT}/`);
+const matchesResolvedPattern = ({ filePath, resolvedPattern }) => {
+  if (!resolvedPattern) {
+    return true;
+  }
+  if (GLOB_CHARACTER_REGEX.test(resolvedPattern)) {
+    return new bun.Glob(resolvedPattern).match(filePath);
+  }
+  return (
+    filePath === resolvedPattern || filePath.startsWith(`${resolvedPattern}/`)
+  );
+};
+const splitFilePatterns = (patterns) => {
+  const includes = [];
+  const excludes = [];
+  for (const pattern of patterns) {
+    if (pattern.startsWith(FILE_PATTERN_NEGATION_PREFIX)) {
+      excludes.push(pattern.slice(FILE_PATTERN_NEGATION_PREFIX.length));
+    } else {
+      includes.push(pattern);
+    }
+  }
+  return {
+    includes,
+    excludes,
+  };
+};
+const resolveFilePatterns = ({ workspace, patterns, isExclude }) => {
+  const resolved = [];
+  for (const inputPattern of patterns) {
+    const resolvedPattern = resolveInputPattern({
+      workspacePath: workspace.path,
+      inputPattern,
+    });
+    if (isPatternOutsideProject(resolvedPattern)) {
+      const displayPattern = isExclude
+        ? `${FILE_PATTERN_NEGATION_PREFIX}${inputPattern}`
+        : inputPattern;
+      logger.warn(
+        `Input pattern ${JSON.stringify(displayPattern)} for workspace "${workspace.name}" resolves outside the project root and will be ignored.`,
+      );
+      continue;
+    }
+    resolved.push({
+      inputPattern,
+      resolvedPattern,
+    });
+  }
+  return resolved;
+};
+const matchChangedFilesForWorkspace = ({
+  workspace,
+  inputFilePatterns,
+  changedFilePaths,
+}) => {
+  const { includes, excludes } = splitFilePatterns(inputFilePatterns);
+  const resolvedIncludes = resolveFilePatterns({
+    workspace,
+    patterns: includes,
+    isExclude: false,
+  });
+  const resolvedExcludes = resolveFilePatterns({
+    workspace,
+    patterns: excludes,
+    isExclude: true,
+  });
+  const matchedFiles = [];
+  const matchedFilePaths = new Set();
+  for (const filePath of changedFilePaths) {
+    if (matchedFilePaths.has(filePath)) continue;
+    const matchingInclude = resolvedIncludes.find(({ resolvedPattern }) =>
+      matchesResolvedPattern({
+        filePath,
+        resolvedPattern,
+      }),
+    );
+    if (!matchingInclude) continue;
+    const isExcluded = resolvedExcludes.some(({ resolvedPattern }) =>
+      matchesResolvedPattern({
+        filePath,
+        resolvedPattern,
+      }),
+    );
+    if (isExcluded) continue;
+    matchedFiles.push({
+      filePath,
+      fileMetadata: undefined,
+      inputPattern: matchingInclude.inputPattern,
+    });
+    matchedFilePaths.add(filePath);
+  }
+  return matchedFiles;
+};
+const resolveInputWorkspaceDependencies = ({ workspaceInputs }) => {
+  const inputDependenciesByName = new Map();
+  const allWorkspaces = workspaceInputs.map(({ workspace }) => workspace);
+  for (const { workspace, inputWorkspacePatterns } of workspaceInputs) {
+    if (inputWorkspacePatterns.length === 0) {
+      inputDependenciesByName.set(workspace.name, []);
+      continue;
+    }
+    const matchedNames = matchWorkspacesByPatterns(
+      inputWorkspacePatterns,
+      allWorkspaces,
+    )
+      .map((matchedWorkspace) => matchedWorkspace.name)
+      .filter((matchedName) => matchedName !== workspace.name);
+    inputDependenciesByName.set(workspace.name, matchedNames);
+  }
+  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,
+  ignoreWorkspaceDependencies,
+}) => {
+  const inputDependentsByName = new Map();
+  for (const [workspaceName, dependencyNames] of inputDependenciesByName) {
+    for (const dependencyName of dependencyNames) {
+      const existing = inputDependentsByName.get(dependencyName);
+      if (existing) {
+        existing.push(workspaceName);
+      } else {
+        inputDependentsByName.set(dependencyName, [workspaceName]);
+      }
+    }
+  }
+  const affected = new Set();
+  const queue = [];
+  for (const { workspace } of workspaceInputs) {
+    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);
+    }
+  }
+  while (queue.length > 0) {
+    const currentName = queue.shift();
+    const currentWorkspace = workspaceByName.get(currentName);
+    const dependents = [
+      ...(inputDependentsByName.get(currentName) ?? []),
+      ...(!ignoreWorkspaceDependencies && currentWorkspace
+        ? currentWorkspace.dependents
+        : []),
+    ];
+    for (const dependentName of dependents) {
+      if (!workspaceByName.has(dependentName)) continue;
+      if (affected.has(dependentName)) continue;
+      affected.add(dependentName);
+      queue.push(dependentName);
+    }
+  }
+  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,
+  ignoreWorkspaceDependencies,
+}) => {
+  const results = [];
+  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,
+  externalDepChangesByWorkspace = new Map(),
+  ignoreWorkspaceDependencies = false,
+}) => {
+  const normalizedChangedFilePaths = changedFilePaths.map((filePath) =>
+    normalizeChangedFilePath({
+      rootDirectory,
+      filePath,
+    }),
+  );
+  const workspaceByName = new Map(
+    workspaceInputs.map(({ workspace }) => [workspace.name, workspace]),
+  );
+  const changedFilesByName = new Map();
+  for (const { workspace, inputFilePatterns } of workspaceInputs) {
+    changedFilesByName.set(
+      workspace.name,
+      matchChangedFilesForWorkspace({
+        workspace,
+        inputFilePatterns,
+        changedFilePaths: normalizedChangedFilePaths,
+      }),
+    );
+  }
+  const filteredExternalDepChanges = filterExternalDepChangesByInputs({
+    changesByWorkspace: externalDepChangesByWorkspace,
+    workspaceInputs,
+  });
+  const inputDependenciesByName = resolveInputWorkspaceDependencies({
+    workspaceInputs,
+  });
+  const affectedSet = computeAffectedWorkspaceSet({
+    workspaceInputs,
+    workspaceByName,
+    changedFilesByName,
+    externalDepChangesByWorkspace: filteredExternalDepChanges,
+    inputDependenciesByName,
+    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,
+      ignoreWorkspaceDependencies,
+    });
+    return {
+      workspace,
+      isAffected: affectedSet.has(workspace.name),
+      affectedReasons: {
+        changedFiles,
+        dependencies,
+        externalDependencies,
+      },
+    };
+  });
+  return {
+    affectedWorkspaces,
+  };
+};
+
+export { getFileAffectedWorkspaces };

package/src/affected/gitAffectedFiles.mjs

@@ -0,0 +1,196 @@
+import fs from "fs";
+import path from "path";
+import { defineErrors } from "../internal/core/index.mjs";
+import { createSubprocess } from "../runScript/subprocesses.mjs";
+
+const GIT_AFFECTED_ERRORS = defineErrors("NoGitRepository", "GitCommandFailed");
+const GIT_AFFECTED_FILE_REASONS = ["diff", "staged", "unstaged", "untracked"];
+const runGit = async (args, cwd) => {
+  const proc = createSubprocess(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  return {
+    stdout,
+    stderr,
+    exitCode,
+  };
+};
+const runGitOrThrow = async (args, cwd) => {
+  const { stdout, stderr, exitCode } = await runGit(args, cwd);
+  if (exitCode !== 0) {
+    throw new GIT_AFFECTED_ERRORS.GitCommandFailed(
+      `git ${args.join(" ")} failed (exit ${exitCode}): ${stderr.trim()}`,
+    );
+  }
+  return stdout;
+};
+/**
+ * Git's `-z` flag emits paths separated by NUL bytes with no quoting or
+ * escaping, which is the only safe way to parse output containing paths
+ * with spaces, newlines, or non-ASCII characters under `core.quotePath`.
+ */ const parseNullSeparated = (output) => output.split("\0").filter(Boolean);
+const resolveGitRoot = async (rootDirectory) => {
+  let result;
+  try {
+    result = await runGit(["rev-parse", "--show-toplevel"], rootDirectory);
+  } catch (error) {
+    throw new GIT_AFFECTED_ERRORS.NoGitRepository(
+      `Not a git repository: ${rootDirectory}${error instanceof Error ? ` (${error.message})` : ""}`,
+    );
+  }
+  if (result.exitCode !== 0 || !result.stdout.trim()) {
+    throw new GIT_AFFECTED_ERRORS.NoGitRepository(
+      `Not a git repository: ${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,
+  gitRelativePath,
+}) => {
+  const absolute = path.resolve(gitRoot, gitRelativePath);
+  const relative = path.relative(absoluteProjectRoot, absolute);
+  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return null;
+  }
+  return relative.split(path.sep).join("/");
+};
+const getGitAffectedFiles = async (options) => {
+  const {
+    rootDirectory,
+    baseRef,
+    headRef,
+    ignoreUntracked,
+    ignoreStaged,
+    ignoreUnstaged,
+    ignoreUncommitted,
+  } = options;
+  const gitRoot = fs.realpathSync.native(
+    path.resolve(await resolveGitRoot(rootDirectory)),
+  );
+  const absoluteProjectRoot = fs.realpathSync.native(
+    path.resolve(rootDirectory),
+  );
+  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],
+      gitRoot,
+    ).then((out) => ({
+      reason: "diff",
+      paths: parseNullSeparated(out),
+    })),
+  ];
+  if (includeStaged) {
+    collectors.push(
+      runGitOrThrow(["diff", "--cached", "--name-only", "-z"], gitRoot).then(
+        (out) => ({
+          reason: "staged",
+          paths: parseNullSeparated(out),
+        }),
+      ),
+    );
+  }
+  if (includeUnstaged) {
+    collectors.push(
+      runGitOrThrow(["diff", "--name-only", "-z"], gitRoot).then((out) => ({
+        reason: "unstaged",
+        paths: parseNullSeparated(out),
+      })),
+    );
+  }
+  if (includeUntracked) {
+    collectors.push(
+      runGitOrThrow(
+        ["ls-files", "--others", "--exclude-standard", "-z"],
+        gitRoot,
+      ).then((out) => ({
+        reason: "untracked",
+        paths: parseNullSeparated(out),
+      })),
+    );
+  }
+  const buckets = await Promise.all(collectors);
+  const reasonsByPath = new Map();
+  for (const { reason, paths } of buckets) {
+    for (const gitRelativePath of paths) {
+      const projectFilePath = toProjectFilePath({
+        gitRoot,
+        absoluteProjectRoot,
+        gitRelativePath,
+      });
+      if (!projectFilePath) continue;
+      let set = reasonsByPath.get(projectFilePath);
+      if (!set) {
+        set = new Set();
+        reasonsByPath.set(projectFilePath, set);
+      }
+      set.add(reason);
+    }
+  }
+  const files = Array.from(reasonsByPath.entries())
+    .map(([projectFilePath, reasonSet]) => ({
+      projectFilePath,
+      reasons: GIT_AFFECTED_FILE_REASONS.filter((r) => reasonSet.has(r)),
+    }))
+    .sort((a, b) => a.projectFilePath.localeCompare(b.projectFilePath));
+  return {
+    files,
+    baseSha,
+    headSha,
+  };
+};
+
+export {
+  GIT_AFFECTED_ERRORS,
+  GIT_AFFECTED_FILE_REASONS,
+  getGitAffectedFiles,
+  readProjectFileAtGitRef,
+};

package/src/affected/gitAffectedWorkspaces.mjs

@@ -0,0 +1,108 @@
+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,
+  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,
+    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,
+    ...fileOpts,
+    changedFilePaths: gitFiles.map((file) => file.projectFilePath),
+    externalDepChangesByWorkspace,
+  });
+  const annotatedWorkspaces = affectedWorkspaces.map((result) => ({
+    ...result,
+    affectedReasons: {
+      ...result.affectedReasons,
+      changedFiles: result.affectedReasons.changedFiles.map((changedFile) => ({
+        ...changedFile,
+        fileMetadata: {
+          git: gitFileByPath.get(changedFile.filePath),
+        },
+      })),
+    },
+  }));
+  return {
+    affectedWorkspaces: annotatedWorkspaces,
+    baseSha,
+    headSha,
+  };
+};
+
+export { getGitAffectedWorkspaces };