bun-workspaces 1.8.1 → 1.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-workspaces",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "A monorepo management tool for Bun, with a CLI and API to enhance Bun's native workspaces.",
   "license": "MIT",
   "exports": {

package/src/affected/fileAffectedWorkspaces.mjs

@@ -0,0 +1,321 @@
+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 normalizeChangedFilePath = ({ rootDirectory, filePath }) => {
+  const posixFilePath = toPosixPath(filePath);
+  if (!path.isAbsolute(filePath)) {
+    return 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 computeAffectedWorkspaceSet = ({
+  workspaceInputs,
+  workspaceByName,
+  changedFilesByName,
+  inputDependenciesByName,
+  ignorePackageDependencies,
+}) => {
+  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) {
+    if ((changedFilesByName.get(workspace.name)?.length ?? 0) > 0) {
+      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) ?? []),
+      ...(!ignorePackageDependencies && 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;
+};
+const collectAffectedDependencies = ({
+  startingWorkspace,
+  workspaceByName,
+  inputDependenciesByName,
+  affectedSet,
+  ignorePackageDependencies,
+}) => {
+  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,
+    },
+  ]);
+  return results;
+};
+const getFileAffectedWorkspaces = async ({
+  rootDirectory,
+  workspaceInputs,
+  changedFilePaths,
+  ignorePackageDependencies = 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 inputDependenciesByName = resolveInputWorkspaceDependencies({
+    workspaceInputs,
+  });
+  const affectedSet = computeAffectedWorkspaceSet({
+    workspaceInputs,
+    workspaceByName,
+    changedFilesByName,
+    inputDependenciesByName,
+    ignorePackageDependencies,
+  });
+  const affectedWorkspaces = workspaceInputs.map(({ workspace }) => {
+    const changedFiles = changedFilesByName.get(workspace.name) ?? [];
+    const dependencies = collectAffectedDependencies({
+      startingWorkspace: workspace,
+      workspaceByName,
+      inputDependenciesByName,
+      affectedSet,
+      ignorePackageDependencies,
+    });
+    return {
+      workspace,
+      isAffected: affectedSet.has(workspace.name),
+      affectedReasons: {
+        changedFiles,
+        dependencies,
+      },
+    };
+  });
+  return {
+    affectedWorkspaces,
+  };
+};
+
+export { getFileAffectedWorkspaces };

package/src/affected/gitAffectedFiles.mjs

@@ -0,0 +1,153 @@
+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();
+};
+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 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,
+  };
+};
+
+export { GIT_AFFECTED_ERRORS, GIT_AFFECTED_FILE_REASONS, getGitAffectedFiles };

package/src/affected/gitAffectedWorkspaces.mjs

@@ -0,0 +1,38 @@
+import { getFileAffectedWorkspaces } from "./fileAffectedWorkspaces.mjs";
+import { getGitAffectedFiles } from "./gitAffectedFiles.mjs";
+
+const getGitAffectedWorkspaces = async ({
+  rootDirectory,
+  workspacesOptions,
+  gitOptions,
+}) => {
+  const { files: gitFiles } = await getGitAffectedFiles({
+    rootDirectory,
+    ...gitOptions,
+  });
+  const gitFileByPath = new Map(
+    gitFiles.map((file) => [file.projectFilePath, file]),
+  );
+  const { affectedWorkspaces } = await getFileAffectedWorkspaces({
+    rootDirectory,
+    ...workspacesOptions,
+    changedFilePaths: gitFiles.map((file) => file.projectFilePath),
+  });
+  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,
+  };
+};
+
+export { getGitAffectedWorkspaces };

package/src/affected/index.mjs

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

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

@@ -9,6 +9,10 @@ import {
 } from "../../../../internal/core/language/string/utf/visibleLength.mjs";
 import { logger } from "../../../../internal/logger/index.mjs";
 import { generatePlainOutputLines } from "./renderPlainOutput.mjs";
+import {
+  initializeTuiTerminalState,
+  resetTuiTerminalState,
+} from "./tuiTerminal.mjs";
 
 class ScriptEventTarget extends TypedEventTarget {}
 const createScriptEventTarget = () => new ScriptEventTarget();
@@ -86,8 +90,10 @@ const renderGroupedOutput = async (
     }
     isInitialized = true;
     logger.debug("Initializing TUI state");
-    outputWriters.stdout(cursorOps.hide());
-    process.stdin.setRawMode?.(true);
+    initializeTuiTerminalState({
+      stdout: outputWriters.stdout,
+      stdin: process.stdin,
+    });
   };
   let isReset = false;
   const resetTuiTerminal = () => {
@@ -96,9 +102,10 @@ const renderGroupedOutput = async (
     }
     isReset = true;
     logger.debug("Resetting TUI state");
-    outputWriters.stdout(cursorOps.show());
-    process.stdin.unref?.();
-    process.stdin.setRawMode?.(false);
+    resetTuiTerminalState({
+      stdout: outputWriters.stdout,
+      stdin: process.stdin,
+    });
   };
   let previousHeight = 0;
   let didFinalRender = false;
@@ -285,8 +292,16 @@ const renderGroupedOutput = async (
   process.stdin.on("data", (data) => {
     // 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");
+    const signal =
+      data[0] === 0x03 ? "SIGINT" : data[0] === 0x1c ? "SIGQUIT" : null;
+    if (!signal) return;
+    // Restore the tty before fanning the signal: once SIGINT lands across
+    // the process group, child cleanup races with our own tcsetattr and
+    // setRawMode reliably returns EIO, leaving the user's terminal stuck
+    // in raw mode. Doing it here, synchronously, while we still own the
+    // tty cleanly, is the only place this can run before the race.
+    resetTuiTerminal();
+    process.kill(0, signal);
   });
   runOnExit((reason) => {
     try {

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

@@ -0,0 +1,45 @@
+import { logger } from "../../../../internal/logger/index.mjs";
+
+const SHOW_CURSOR_SEQUENCE = "\x1b[?25h";
+const HIDE_CURSOR_SEQUENCE = "\x1b[?25l";
+/**
+ * Resets the controlling tty after the grouped-output TUI has owned it.
+ *
+ * Each step runs independently: when SIGINT is delivered to the whole
+ * process group via the raw-mode ^C handler, `setRawMode(false)` can
+ * race with child-process tty teardown and return EIO. A throw must
+ * not strand the cursor in a hidden state nor leave the tty in raw
+ * mode for any subsequent step.
+ *
+ * `setRawMode` runs before `unref` so the underlying tty handle is in
+ * a known, ref'd state for tcsetattr.
+ */ const resetTuiTerminalState = ({ stdout, stdin }) => {
+  try {
+    stdout(SHOW_CURSOR_SEQUENCE);
+  } catch (error) {
+    logger.debug("Failed to show cursor during TUI reset", {
+      error,
+    });
+  }
+  try {
+    stdin.setRawMode?.(false);
+  } catch (error) {
+    logger.debug("Failed to reset raw mode during TUI reset", {
+      error,
+    });
+  }
+  try {
+    stdin.pause();
+    stdin.unref?.();
+  } catch (error) {
+    logger.debug("Failed to detach stdin during TUI reset", {
+      error,
+    });
+  }
+};
+const initializeTuiTerminalState = ({ stdout, stdin }) => {
+  stdout(HIDE_CURSOR_SEQUENCE);
+  stdin.setRawMode?.(true);
+};
+
+export { initializeTuiTerminalState, resetTuiTerminalState };

package/src/workspaces/index.mjs

@@ -1,5 +1,6 @@
 export * from "./findWorkspaces.mjs";
 export * from "./packageJson.mjs";
 export * from "./errors.mjs";
+export * from "./workspacePattern.mjs";
 
 export {};

package/src/workspaces/workspacePattern.mjs

@@ -6,11 +6,19 @@ const WORKSPACE_PATTERN_TARGETS = ["path", "alias", "name", "tag"];
 const TARGETS = WORKSPACE_PATTERN_TARGETS;
 const WORKSPACE_PATTERN_ERRORS = defineErrors("InvalidWorkspacePattern");
 const WORKSPACE_PATTERN_NEGATION_PREFIX = "not:";
+const WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX = "!";
+const WORKSPACE_PATTERN_NEGATION_PREFIXES = [
+  WORKSPACE_PATTERN_NEGATION_PREFIX,
+  WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX,
+];
 const WORKSPACE_PATTERN_SEPARATOR = ":";
 const parseWorkspacePattern = (pattern) => {
-  const isNegated = pattern.startsWith(WORKSPACE_PATTERN_NEGATION_PREFIX);
-  const patternValue = isNegated
-    ? pattern.slice(WORKSPACE_PATTERN_NEGATION_PREFIX.length)
+  const negationPrefix = WORKSPACE_PATTERN_NEGATION_PREFIXES.find((prefix) =>
+    pattern.startsWith(prefix),
+  );
+  const isNegated = !!negationPrefix;
+  const patternValue = negationPrefix
+    ? pattern.slice(negationPrefix.length)
     : pattern;
   const target = TARGETS.find((target) =>
     patternValue.startsWith(target + WORKSPACE_PATTERN_SEPARATOR),
@@ -108,6 +116,8 @@ const matchWorkspacesByPatterns = (patterns, workspaces) => {
 export {
   WORKSPACE_PATTERN_ERRORS,
   WORKSPACE_PATTERN_NEGATION_PREFIX,
+  WORKSPACE_PATTERN_NEGATION_PREFIXES,
+  WORKSPACE_PATTERN_NEGATION_SHORT_PREFIX,
   WORKSPACE_PATTERN_SEPARATOR,
   matchWorkspacesByPatterns,
   parseWorkspacePattern,