bun-workspaces 1.8.2 → 1.9.0

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 };

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

@@ -1,21 +1,9 @@
-import fs from "fs";
-import path from "path";
-import { expandHomePath } from "../../../internal/core/index.mjs";
 import { logger } from "../../../internal/logger/index.mjs";
 import {
   handleProjectCommand,
-  splitWorkspacePatterns,
+  splitWhitespaceArg,
 } from "../commandHandlerUtils.mjs";
-import {
-  getDefaultOutputStyle,
-  validateOutputStyle,
-} from "./output/outputStyle.mjs";
-import {
-  createScriptEvent,
-  createScriptEventTarget,
-  renderGroupedOutput,
-} from "./output/renderGroupedOutput.mjs";
-import { renderPlainOutput } from "./output/renderPlainOutput.mjs";
+import { handleScriptRunFlow } from "./scriptRunFlow.mjs";
 
 const runScript = handleProjectCommand(
   "runScript",
@@ -62,200 +50,29 @@ const runScript = handleProjectCommand(
     }
     const workspacePatterns = positionalWorkspacePatterns?.length
       ? positionalWorkspacePatterns
-      : splitWorkspacePatterns(options.workspacePatterns ?? "");
+      : splitWhitespaceArg(options.workspacePatterns ?? "");
     logger.debug(
       `Command: Run ${options.inline ? "inline " : ""}script ${JSON.stringify(script)} for ${workspacePatterns.length ? "workspaces " + workspacePatterns.join(", ") : "all workspaces"}`,
     );
     logger.debug(`Options: ${JSON.stringify(options)}`);
-    const outputStyle = options.outputStyle
-      ? validateOutputStyle(options.outputStyle)
-      : getDefaultOutputStyle();
-    logger.debug(`Effective output style: ${outputStyle}`);
-    const scriptEventTarget = createScriptEventTarget();
-    const { output, summary, workspaces } = project.runScriptAcrossWorkspaces({
-      workspacePatterns: workspacePatterns.length
-        ? workspacePatterns
-        : undefined,
-      script,
-      inline: options.inline
-        ? options.inlineName || options.shell
-          ? {
-              scriptName: options.inlineName,
-              shell: options.shell,
-            }
-          : true
-        : undefined,
-      args: scriptArgs,
-      dependencyOrder: options.depOrder,
-      ignoreDependencyFailure: options.ignoreDepFailure,
-      ignoreOutput: outputStyle === "none",
-      onScriptEvent: (event, { workspace, exitResult }) => {
-        setTimeout(() =>
-          // place at end of call stack so listeners in render func receive event
-          scriptEventTarget.dispatchEvent(
-            createScriptEvent[event]({
-              workspace,
-              exitResult,
-            }),
-          ),
-        );
+    await handleScriptRunFlow({
+      project,
+      context: {
+        outputWriters,
+        terminalWidth,
+        terminalHeight,
       },
-      parallel:
-        typeof options.parallel === "boolean" ||
-        typeof options.parallel === "undefined"
-          ? undefined
-          : options.parallel === "true"
-            ? true
-            : options.parallel === "false"
-              ? false
-              : {
-                  max: options.parallel,
-                },
-    });
-    const scriptName = options.inline
-      ? options.inlineName || "(inline)"
-      : script;
-    logger.debug(`Script name: ${scriptName}`);
-    const stripDisruptiveControls = workspaces.length > 1 || !!options.parallel;
-    logger.debug(`Strip disruptive controls: ${stripDisruptiveControls}`);
-    let groupedLines = "auto";
-    if (options.groupedLines) {
-      if (options.groupedLines === "all") {
-        groupedLines = "all";
-      } else if (options.groupedLines === "auto") {
-        groupedLines = "auto";
-      } else {
-        const parsedGroupedLines = parseInt(options.groupedLines);
-        if (parsedGroupedLines <= 0 || isNaN(parsedGroupedLines)) {
-          logger.error(
-            `Invalid max grouped lines value: ${options.groupedLines}. Must be a positive number or "all".`,
-          );
-          process.exit(1);
-          return;
-        }
-        groupedLines = parsedGroupedLines;
-      }
-    }
-    logger.debug(`Effective grouped lines: ${JSON.stringify(groupedLines)}`);
-    if (!options.prefix) {
-      logger.warn(
-        "--no-prefix is deprecated and will be removed in a future version. Use --output-style=plain instead.",
-      );
-      if (!options.outputStyle) {
-        options.outputStyle = "plain";
-      }
-    }
-    const outputStyleHandlers = {
-      grouped: () =>
-        renderGroupedOutput(
-          workspaces,
-          output,
-          summary,
-          scriptEventTarget,
-          groupedLines,
-          outputWriters,
-          terminalWidth,
-          terminalHeight,
-        ),
-      prefixed: () =>
-        renderPlainOutput(output, outputWriters, {
-          prefix: true,
-          stripDisruptiveControls,
-        }),
-      plain: () =>
-        renderPlainOutput(output, outputWriters, {
-          prefix: false,
-          stripDisruptiveControls,
+      script,
+      scriptArgs,
+      cliOptions: options,
+      runner: (scriptOptions) =>
+        project.runScriptAcrossWorkspaces({
+          ...scriptOptions,
+          workspacePatterns: workspacePatterns.length
+            ? workspacePatterns
+            : undefined,
         }),
-      none: async () => {
-        // no-op
-      },
-    };
-    await outputStyleHandlers[outputStyle]();
-    const exitResults = await summary;
-    exitResults.scriptResults.forEach(
-      ({ success, metadata: { workspace }, 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${skippedMessage}`;
-      logger.info(message);
-    } else {
-      logger.info(
-        `${exitResults.scriptResults.length} script${s} ran successfully${skippedMessage}`,
-      );
-    }
-    if (options.jsonOutfile) {
-      const fullOutputPath = path.resolve(
-        project.rootDirectory,
-        expandHomePath(options.jsonOutfile),
-      );
-      // Check if can make directory
-      const jsonOutputDir = path.dirname(fullOutputPath);
-      if (!fs.existsSync(jsonOutputDir)) {
-        try {
-          logger.debug(
-            `Creating JSON output file directory "${jsonOutputDir}"`,
-          );
-          fs.mkdirSync(jsonOutputDir, {
-            recursive: true,
-          });
-        } catch (error) {
-          logger.error(
-            `Failed to create JSON output file directory "${jsonOutputDir}": ${error}`,
-          );
-          process.exit(1);
-          return;
-        }
-      } else if (fs.statSync(jsonOutputDir).isFile()) {
-        logger.error(
-          `Given JSON output file directory "${jsonOutputDir}" is an existing file`,
-        );
-        process.exit(1);
-        return;
-      }
-      // Check if can make file
-      if (
-        fs.existsSync(fullOutputPath) &&
-        fs.statSync(fullOutputPath).isDirectory()
-      ) {
-        logger.error(
-          `Given JSON output file path "${fullOutputPath}" is an existing directory`,
-        );
-        process.exit(1);
-        return;
-      }
-      try {
-        logger.debug(`Writing JSON output file "${fullOutputPath}"`);
-        fs.writeFileSync(fullOutputPath, JSON.stringify(exitResults, null, 2));
-      } catch (error) {
-        logger.error(
-          `Failed to write JSON output file "${fullOutputPath}": ${error}`,
-        );
-        process.exit(1);
-        return;
-      }
-      logger.info(`JSON output written to ${fullOutputPath}`);
-    }
-    if (exitResults.failureCount) {
-      process.exit(1);
-      return;
-    }
+    });
   },
 );
 

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

@@ -1,4 +1,5 @@
 export * from "./handleRunScript.mjs";
+export * from "./handleRunAffected.mjs";
 export * from "./output/renderPlainOutput.mjs";
 
 export {};