nx 19.8.0-canary.20240917-5b34ea5 → 19.8.0-canary.20240918-eb61254

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.8.0-canary.20240917-5b34ea5",
+  "version": "19.8.0-canary.20240918-eb61254",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -71,7 +71,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.8.0-canary.20240917-5b34ea5"
+    "@nrwl/tao": "19.8.0-canary.20240918-eb61254"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-darwin-arm64": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-linux-x64-gnu": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-linux-x64-musl": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-win32-x64-msvc": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-linux-arm64-gnu": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-linux-arm64-musl": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-linux-arm-gnueabihf": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-win32-arm64-msvc": "19.8.0-canary.20240917-5b34ea5",
-    "@nx/nx-freebsd-x64": "19.8.0-canary.20240917-5b34ea5"
+    "@nx/nx-darwin-x64": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-darwin-arm64": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-linux-x64-gnu": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-linux-x64-musl": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-win32-x64-msvc": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-linux-arm64-gnu": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-linux-arm64-musl": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-linux-arm-gnueabihf": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-win32-arm64-msvc": "19.8.0-canary.20240918-eb61254",
+    "@nx/nx-freebsd-x64": "19.8.0-canary.20240918-eb61254"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/schemas/nx-schema.json

@@ -634,7 +634,7 @@
           "description": "Custom git commit message to use when committing the changes made by this command"
         },
         "commitArgs": {
-          "type": "string",
+          "type": ["string", "array"],
           "description": "Additional arguments (added after the --message argument, which may or may not be customized with --git-commit-message) to pass to the `git commit` command invoked behind the scenes"
         },
         "stageChanges": {
@@ -650,7 +650,7 @@
           "description": "Custom git tag message to use when tagging the changes made by this command. This defaults to be the same value as the tag itself."
         },
         "tagArgs": {
-          "type": "string",
+          "type": ["string", "array"],
           "description": "Additional arguments to pass to the `git tag` command invoked behind the scenes"
         }
       }

package/src/command-line/import/import.js

@@ -25,7 +25,12 @@ const needs_install_1 = require("./utils/needs-install");
 const file_utils_1 = require("../../project-graph/file-utils");
 const importRemoteName = '__tmp_nx_import__';
 async function importHandler(options) {
+    process.env.NX_RUNNING_NX_IMPORT = 'true';
     let { sourceRepository, ref, source, destination } = options;
+    const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
+    if (await destinationGitClient.hasUncommittedChanges()) {
+        throw new Error(`You have uncommitted changes in the destination repository. Commit or revert the changes and try again.`);
+    }
     output_1.output.log({
         title: 'Nx will walk you through the process of importing code from the source repository into this repository:',
         bodyLines: [
@@ -120,7 +125,6 @@ async function importHandler(options) {
         throw new Error(`The destination directory must be a relative path in this repository.`);
     }
     const absDestination = (0, path_1.join)(process.cwd(), destination);
-    const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
     await assertDestinationEmpty(destinationGitClient, absDestination);
     const tempImportBranch = getTempImportBranch(ref);
     await sourceGitClient.addFetchRemote(importRemoteName, ref);
@@ -152,7 +156,7 @@ async function importHandler(options) {
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
     const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
     (0, workspace_context_1.resetWorkspaceContext)();
-    const { plugins, updatePackageScripts } = await (0, init_v2_1.detectPlugins)(nxJson, options.interactive);
+    const { plugins, updatePackageScripts } = await (0, init_v2_1.detectPlugins)(nxJson, options.interactive, true);
     if (packageManager !== sourcePackageManager) {
         output_1.output.warn({
             title: `Mismatched package managers`,
@@ -232,8 +236,9 @@ async function importHandler(options) {
         title: `Merging these changes into ${(0, command_line_utils_1.getBaseRef)(nxJson)}`,
         bodyLines: [
             `MERGE these changes when merging these changes.`,
-            `Do NOT squash and do NOT rebase these changes when merging these changes.`,
-            `If you would like to UNDO these changes, run "git reset HEAD~1 --hard"`,
+            `Do NOT squash these commits when merging these changes.`,
+            `If you rebase, make sure to use "--rebase-merges" to preserve merge commits.`,
+            `To UNDO these changes, run "git reset HEAD~1 --hard"`,
         ],
     });
 }

package/src/command-line/import/utils/prepare-source-repo.js

@@ -3,46 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareSourceRepo = prepareSourceRepo;
 const createSpinner = require("ora");
 const path_1 = require("path");
-const promises_1 = require("node:fs/promises");
 async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl) {
     const spinner = createSpinner().start(`Fetching ${ref} from ${sourceRemoteUrl}`);
     const relativeSourceDir = (0, path_1.relative)(gitClient.root, (0, path_1.join)(gitClient.root, source));
-    if (relativeSourceDir !== '') {
-        if (await gitClient.hasFilterRepoInstalled()) {
-            spinner.start(`Filtering git history to only include files in ${relativeSourceDir}`);
-            await gitClient.filterRepo(relativeSourceDir);
-        }
-        else {
-            spinner.start(`Filtering git history to only include files in ${relativeSourceDir} (this might take a few minutes -- install git-filter-repo for faster performance)`);
-            await gitClient.filterBranch(relativeSourceDir, tempImportBranch);
-        }
-        spinner.succeed(`Filtered git history to only include files in ${relativeSourceDir}`);
+    if (await gitClient.hasFilterRepoInstalled()) {
+        spinner.start(`Filtering git history to only include files in ${relativeSourceDir}`);
+        await gitClient.filterRepo(relativeSourceDir, relativeDestination);
     }
-    const destinationInSource = (0, path_1.join)(gitClient.root, relativeDestination);
-    spinner.start(`Moving files and git history to ${destinationInSource}`);
-    // The result of filter-branch will contain only the files in the subdirectory at its root.
-    const files = await gitClient.getGitFiles('.');
-    try {
-        await (0, promises_1.rm)(destinationInSource, {
-            recursive: true,
-        });
+    else {
+        spinner.start(`Filtering git history to only include files in ${relativeSourceDir} (this might take a few minutes -- install git-filter-repo for faster performance)`);
+        await gitClient.filterBranch(relativeSourceDir, relativeDestination, tempImportBranch);
     }
-    catch { }
-    await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-    for (const file of files) {
-        spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
-        const newPath = (0, path_1.join)(destinationInSource, file);
-        await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
-        try {
-            await gitClient.move(file, newPath);
-        }
-        catch {
-            await wait(100);
-            await gitClient.move(file, newPath);
-        }
-    }
-    await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-    await gitClient.amendCommit();
+    spinner.succeed(`Filtered git history to only include files in ${relativeSourceDir}`);
     spinner.succeed(`${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`);
 }
 function wait(ms) {

package/src/command-line/init/init-v2.d.ts

@@ -8,7 +8,7 @@ export interface InitArgs {
 }
 export declare function installPlugins(repoRoot: string, plugins: string[], pmc: PackageManagerCommands, updatePackageScripts: boolean): void;
 export declare function initHandler(options: InitArgs): Promise<void>;
-export declare function detectPlugins(nxJson: NxJsonConfiguration, interactive: boolean): Promise<{
+export declare function detectPlugins(nxJson: NxJsonConfiguration, interactive: boolean, includeAngularCli?: boolean): Promise<{
     plugins: string[];
     updatePackageScripts: boolean;
 }>;

package/src/command-line/init/init-v2.js

@@ -127,8 +127,8 @@ const npmPackageToPluginMap = {
     'react-native': '@nx/react-native',
     '@remix-run/dev': '@nx/remix',
 };
-async function detectPlugins(nxJson, interactive) {
-    let files = ['package.json'].concat(await (0, workspace_context_1.globWithWorkspaceContext)(process.cwd(), ['**/*/package.json']));
+async function detectPlugins(nxJson, interactive, includeAngularCli) {
+    let files = ['package.json'].concat((0, workspace_context_1.globWithWorkspaceContextSync)(process.cwd(), ['**/*/package.json']));
     const currentPlugins = new Set((nxJson.plugins ?? []).map((p) => {
         const plugin = typeof p === 'string' ? p : p.plugin;
         return (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(plugin);
@@ -149,13 +149,19 @@ async function detectPlugins(nxJson, interactive) {
             ...packageJson.dependencies,
             ...packageJson.devDependencies,
         };
-        for (const [dep, plugin] of Object.entries(npmPackageToPluginMap)) {
+        const _npmPackageToPluginMap = {
+            ...npmPackageToPluginMap,
+        };
+        if (includeAngularCli) {
+            _npmPackageToPluginMap['@angular/cli'] = '@nx/angular';
+        }
+        for (const [dep, plugin] of Object.entries(_npmPackageToPluginMap)) {
             if (deps[dep]) {
                 detectedPlugins.add(plugin);
             }
         }
     }
-    let gradlewFiles = ['gradlew', 'gradlew.bat'].concat(await (0, workspace_context_1.globWithWorkspaceContext)(process.cwd(), [
+    let gradlewFiles = ['gradlew', 'gradlew.bat'].concat((0, workspace_context_1.globWithWorkspaceContextSync)(process.cwd(), [
         '**/gradlew',
         '**/gradlew.bat',
     ]));

package/src/command-line/release/command-object.d.ts

@@ -14,10 +14,10 @@ interface GitCommitAndTagOptions {
     stageChanges?: boolean;
     gitCommit?: boolean;
     gitCommitMessage?: string;
-    gitCommitArgs?: string;
+    gitCommitArgs?: string | string[];
     gitTag?: boolean;
     gitTagMessage?: string;
-    gitTagArgs?: string;
+    gitTagArgs?: string | string[];
 }
 export type VersionOptions = NxReleaseArgs & GitCommitAndTagOptions & VersionPlanArgs & FirstReleaseArgs & {
     specifier?: string;

package/src/command-line/release/config/config.js

@@ -155,6 +155,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             conventionalCommits: false,
             generator: '@nx/js:release-version',
             generatorOptions: {},
+            groupPreVersionCommand: '',
         },
         changelog: {
             createRelease: false,
@@ -206,7 +207,9 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
         WORKSPACE_DEFAULTS.versionPlans);
     const rootConventionalCommitsConfig = deepMergeDefaults([WORKSPACE_DEFAULTS.conventionalCommits], fillUnspecifiedConventionalCommitsProperties(normalizeConventionalCommitsConfig(userConfig.conventionalCommits)));
     // these options are not supported at the group level, only the root/command level
-    const rootVersionWithoutGlobalOptions = { ...rootVersionConfig };
+    const rootVersionWithoutGlobalOptions = {
+        ...rootVersionConfig,
+    };
     delete rootVersionWithoutGlobalOptions.git;
     delete rootVersionWithoutGlobalOptions.preVersionCommand;
     // Apply conventionalCommits shorthand to the final group defaults if explicitly configured in the original user config
@@ -316,7 +319,10 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             projects: matchingProjects,
             version: deepMergeDefaults(
             // First apply any group level defaults, then apply actual root level config, then group level config
-            [GROUP_DEFAULTS.version, rootVersionWithoutGlobalOptions], releaseGroup.version),
+            [
+                GROUP_DEFAULTS.version,
+                { ...rootVersionWithoutGlobalOptions, groupPreVersionCommand: '' },
+            ], releaseGroup.version),
             // If the user has set any changelog config at all, including at the root level, then use one set of defaults, otherwise default to false for the whole feature
             changelog: releaseGroup.changelog || rootChangelogConfig.projectChangelogs
                 ? deepMergeDefaults(groupChangelogDefaults, releaseGroup.changelog || {})

package/src/command-line/release/utils/git.d.ts

@@ -37,7 +37,7 @@ export declare function gitAdd({ changedFiles, deletedFiles, dryRun, verbose, lo
 }): Promise<string>;
 export declare function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }: {
     messages: string[];
-    additionalArgs?: string;
+    additionalArgs?: string | string[];
     dryRun?: boolean;
     verbose?: boolean;
     logFn?: (message: string) => void;
@@ -45,7 +45,7 @@ export declare function gitCommit({ messages, additionalArgs, dryRun, verbose, l
 export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, }: {
     tag: string;
     message?: string;
-    additionalArgs?: string;
+    additionalArgs?: string | string[];
     dryRun?: boolean;
     verbose?: boolean;
     logFn?: (message: string) => void;

package/src/command-line/release/utils/git.js

@@ -188,7 +188,12 @@ async function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, })
         commandArgs.push('--message', message);
     }
     if (additionalArgs) {
-        commandArgs.push(...additionalArgs.split(' '));
+        if (Array.isArray(additionalArgs)) {
+            commandArgs.push(...additionalArgs);
+        }
+        else {
+            commandArgs.push(...additionalArgs.split(' '));
+        }
     }
     if (verbose) {
         logFn(dryRun
@@ -224,7 +229,12 @@ async function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, })
         message || tag,
     ];
     if (additionalArgs) {
-        commandArgs.push(...additionalArgs.split(' '));
+        if (Array.isArray(additionalArgs)) {
+            commandArgs.push(...additionalArgs);
+        }
+        else {
+            commandArgs.push(...additionalArgs.split(' '));
+        }
     }
     if (verbose) {
         logFn(dryRun

package/src/command-line/release/utils/shared.d.ts

@@ -45,7 +45,7 @@ export declare function commitChanges({ changedFiles, deletedFiles, isDryRun, is
     isDryRun?: boolean;
     isVerbose?: boolean;
     gitCommitMessages?: string[];
-    gitCommitArgs?: string;
+    gitCommitArgs?: string | string[];
 }): Promise<void>;
 export declare function createCommitMessageValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData, commitMessage: string): string[];
 export declare function createGitTagValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData): string[];

package/src/command-line/release/version.js

@@ -207,6 +207,10 @@ function createAPI(overrideReleaseConfig) {
          */
         for (const releaseGroup of releaseGroups) {
             const releaseGroupName = releaseGroup.name;
+            runPreVersionCommand(releaseGroup.version.groupPreVersionCommand, {
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
             const projectBatches = (0, batch_projects_by_generator_config_1.batchProjectsByGeneratorConfig)(projectGraph, releaseGroup, 
             // Batch based on all projects within the release group
             releaseGroup.projects);

package/src/config/nx-json.d.ts

@@ -101,9 +101,9 @@ export interface NxReleaseGitConfiguration {
      */
     commitMessage?: string;
     /**
-     * Additional arguments (added after the --message argument, which may or may not be customized with --git-commit-message) to pass to the `git commit` command invoked behind the scenes
+     * Additional arguments (added after the --message argument, which may or may not be customized with --git-commit-message) to pass to the `git commit` command invoked behind the scenes. May be a string or array of strings.
      */
-    commitArgs?: string;
+    commitArgs?: string | string[];
     /**
      * Whether or not to stage the changes made by this command. Always treated as true if commit is true.
      */
@@ -117,9 +117,9 @@ export interface NxReleaseGitConfiguration {
      */
     tagMessage?: string;
     /**
-     * Additional arguments to pass to the `git tag` command invoked behind the scenes
+     * Additional arguments to pass to the `git tag` command invoked behind the scenes. . May be a string or array of strings.
      */
-    tagArgs?: string;
+    tagArgs?: string | string[];
 }
 export interface NxReleaseConventionalCommitsConfiguration {
     types?: Record<string, 
@@ -179,7 +179,15 @@ export interface NxReleaseConfiguration {
          *
          * NOTE: git configuration is not supported at the group level, only the root/command level
          */
-        version?: NxReleaseVersionConfiguration;
+        version?: NxReleaseVersionConfiguration & {
+            /**
+             * A command to run after validation of nx release configuration, but before versioning begins.
+             * Used for preparing build artifacts. If --dry-run is passed, the command is still executed, but
+             * with the NX_DRY_RUN environment variable set to 'true'.
+             * It will run in addition to the global `preVersionCommand`
+             */
+            groupPreVersionCommand?: string;
+        };
         /**
          * Project changelogs are disabled by default.
          *

package/src/tasks-runner/init-tasks-runner.d.ts

@@ -6,7 +6,7 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
         tasks: Task[];
         parallel: number;
     }) => Promise<{
-        status: number;
+        status: NodeJS.Process["exitCode"];
         taskGraph: TaskGraph;
         taskResults: Record<string, TaskResult>;
     }>;

package/src/tasks-runner/init-tasks-runner.js

@@ -39,7 +39,7 @@ async function initTasksRunner(nxArgs) {
                     return acc;
                 }, {}),
             };
-            const status = await (0, run_command_1.invokeTasksRunner)({
+            const taskResults = await (0, run_command_1.invokeTasksRunner)({
                 tasks: opts.tasks,
                 projectGraph,
                 taskGraph,
@@ -50,9 +50,11 @@ async function initTasksRunner(nxArgs) {
                 initiatingProject: null,
             });
             return {
-                status,
+                status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+                    ? 1
+                    : 0,
                 taskGraph,
-                taskResults: lifeCycle.getTaskResults(),
+                taskResults,
             };
         },
     };

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.d.ts

@@ -5,11 +5,9 @@ export declare class InvokeRunnerTerminalOutputLifeCycle implements LifeCycle {
     private readonly tasks;
     failedTasks: Task[];
     cachedTasks: Task[];
-    private taskResults;
     constructor(tasks: Task[]);
     startCommand(): void;
     endCommand(): void;
     endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
-    getTaskResults(): Record<string, TaskResult>;
 }

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -8,7 +8,6 @@ class InvokeRunnerTerminalOutputLifeCycle {
         this.tasks = tasks;
         this.failedTasks = [];
         this.cachedTasks = [];
-        this.taskResults = {};
     }
     startCommand() {
         output_1.output.log({
@@ -46,7 +45,6 @@ class InvokeRunnerTerminalOutputLifeCycle {
     }
     endTasks(taskResults) {
         for (let t of taskResults) {
-            this.taskResults[t.task.id] = t;
             if (t.status === 'failure') {
                 this.failedTasks.push(t.task);
             }
@@ -65,8 +63,5 @@ class InvokeRunnerTerminalOutputLifeCycle {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
         output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
     }
-    getTaskResults() {
-        return this.taskResults;
-    }
 }
 exports.InvokeRunnerTerminalOutputLifeCycle = InvokeRunnerTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { TaskStatus } from '../tasks-runner';
-import type { LifeCycle } from '../life-cycle';
+import type { LifeCycle, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 /**
  * The following life cycle's outputs are static, meaning no previous content
@@ -24,10 +24,6 @@ export declare class StaticRunManyTerminalOutputLifeCycle implements LifeCycle {
     startCommand(): void;
     endCommand(): void;
     private skippedTasks;
-    endTasks(taskResults: {
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }[]): void;
+    endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
 }

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { TaskStatus } from '../tasks-runner';
-import type { LifeCycle } from '../life-cycle';
+import type { LifeCycle, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 /**
  * The following life cycle's outputs are static, meaning no previous content
@@ -23,10 +23,6 @@ export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
     });
     startCommand(): void;
     endCommand(): void;
-    endTasks(taskResults: {
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }[]): void;
+    endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
 }

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.d.ts

@@ -1,6 +1,5 @@
-import { LifeCycle } from '../../tasks-runner/life-cycle';
+import { LifeCycle, TaskResult } from '../../tasks-runner/life-cycle';
 import { Task } from '../../config/task-graph';
-import { TaskStatus } from '../../tasks-runner/tasks-runner';
 export declare class StoreRunInformationLifeCycle implements LifeCycle {
     private readonly command;
     private readonly storeFile;
@@ -10,11 +9,7 @@ export declare class StoreRunInformationLifeCycle implements LifeCycle {
     private taskResults;
     constructor(command?: string, storeFile?: typeof storeFileFunction, now?: () => string);
     startTasks(tasks: Task[]): void;
-    endTasks(taskResults: Array<{
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }>): void;
+    endTasks(taskResults: TaskResult[]): void;
     startCommand(): void;
     endCommand(): any;
 }

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.d.ts

@@ -1,5 +1,4 @@
-import { LifeCycle, TaskMetadata } from '../life-cycle';
-import { TaskStatus } from '../tasks-runner';
+import { LifeCycle, TaskMetadata, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 export declare class TaskProfilingLifeCycle implements LifeCycle {
     private timings;
@@ -8,11 +7,7 @@ export declare class TaskProfilingLifeCycle implements LifeCycle {
     private registeredGroups;
     constructor(_profileFile: string);
     startTasks(tasks: Task[], { groupId }: TaskMetadata): void;
-    endTasks(taskResults: Array<{
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }>, metadata: TaskMetadata): void;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
     endCommand(): void;
     private recordTaskCompletions;
     private registerGroup;

package/src/tasks-runner/life-cycles/task-results-life-cycle.d.ts

@@ -0,0 +1,6 @@
+import type { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskResultsLifeCycle implements LifeCycle {
+    private taskResults;
+    endTasks(taskResults: TaskResult[]): void;
+    getTaskResults(): Record<string, TaskResult>;
+}

package/src/tasks-runner/life-cycles/task-results-life-cycle.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskResultsLifeCycle = void 0;
+class TaskResultsLifeCycle {
+    constructor() {
+        this.taskResults = {};
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.taskResults[t.task.id] = t;
+        }
+    }
+    getTaskResults() {
+        return this.taskResults;
+    }
+}
+exports.TaskResultsLifeCycle = TaskResultsLifeCycle;

package/src/tasks-runner/life-cycles/task-timings-life-cycle.d.ts

@@ -1,13 +1,8 @@
 import { Task } from '../../config/task-graph';
-import { LifeCycle } from '../life-cycle';
-import { TaskStatus } from '../tasks-runner';
+import { LifeCycle, TaskResult } from '../life-cycle';
 export declare class TaskTimingsLifeCycle implements LifeCycle {
     private timings;
     startTasks(tasks: Task[]): void;
-    endTasks(taskResults: Array<{
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }>): void;
+    endTasks(taskResults: TaskResult[]): void;
     endCommand(): void;
 }

package/src/tasks-runner/run-command.d.ts

@@ -3,7 +3,7 @@ import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
-import { LifeCycle } from './life-cycle';
+import { LifeCycle, TaskResult } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
 export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
@@ -11,6 +11,14 @@ export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], cur
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<NodeJS.Process['exitCode']>;
+export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+    nxJson: NxJsonConfiguration;
+}, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<{
+    [id: string]: TaskResult;
+}>;
 export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
@@ -20,7 +28,9 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     nxArgs: NxArgs;
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
-}): Promise<1 | 0>;
+}): Promise<{
+    [id: string]: TaskResult;
+}>;
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;

package/src/tasks-runner/run-command.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
+exports.runCommandForTasks = runCommandForTasks;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
@@ -31,6 +32,7 @@ const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle
 const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
+const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
@@ -99,25 +101,31 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
 }
 async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
-        const projectNames = projectsToRun.map((t) => t.name);
-        const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
-        const tasks = Object.values(taskGraph.tasks);
-        const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
-        const status = await invokeTasksRunner({
-            tasks,
-            projectGraph,
-            taskGraph,
-            lifeCycle,
-            nxJson,
-            nxArgs,
-            loadDotEnvFiles: extraOptions.loadDotEnvFiles,
-            initiatingProject,
-        });
-        await renderIsDone;
-        return status;
+        const taskResults = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions);
+        return Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+            ? 1
+            : 0;
     });
     return status;
 }
+async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    const projectNames = projectsToRun.map((t) => t.name);
+    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
+    const tasks = Object.values(taskGraph.tasks);
+    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
+    const taskResults = await invokeTasksRunner({
+        tasks,
+        projectGraph,
+        taskGraph,
+        lifeCycle,
+        nxJson,
+        nxArgs,
+        loadDotEnvFiles: extraOptions.loadDotEnvFiles,
+        initiatingProject,
+    });
+    await renderIsDone;
+    return taskResults;
+}
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
     if (nxArgs.skipSync) {
@@ -359,9 +367,14 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
     await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
-    const promiseOrObservable = tasksRunner(tasks, {
+    const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
+    const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
+        ...constructLifeCycles(lifeCycle),
+        taskResultsLifecycle,
+    ]);
+    let promiseOrObservable = tasksRunner(tasks, {
         ...runnerOptions,
-        lifeCycle: new life_cycle_1.CompositeLifeCycle(constructLifeCycles(lifeCycle)),
+        lifeCycle: compositedLifeCycle,
     }, {
         initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
         projectGraph,
@@ -418,15 +431,11 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         },
         daemon: client_1.daemonClient,
     });
-    let anyFailures;
     if (promiseOrObservable.subscribe) {
-        anyFailures = await anyFailuresInObservable(promiseOrObservable);
-    }
-    else {
-        // simply await the promise
-        anyFailures = await anyFailuresInPromise(promiseOrObservable);
+        promiseOrObservable = convertObservableToPromise(promiseOrObservable);
     }
-    return anyFailures ? 1 : 0;
+    await promiseOrObservable;
+    return taskResultsLifecycle.getTaskResults();
 }
 function constructLifeCycles(lifeCycle) {
     const lifeCycles = [];
@@ -445,41 +454,23 @@ function constructLifeCycles(lifeCycle) {
     }
     return lifeCycles;
 }
-function mergeTargetDependencies(defaults, deps) {
-    const res = {};
-    Object.keys(defaults ?? {}).forEach((k) => {
-        res[k] = defaults[k].dependsOn;
-    });
-    if (deps) {
-        Object.keys(deps).forEach((k) => {
-            if (res[k]) {
-                res[k] = [...res[k], deps[k]];
-            }
-            else {
-                res[k] = deps[k];
-            }
-        });
-        return res;
-    }
-}
-async function anyFailuresInPromise(promise) {
-    return Object.values(await promise).some((v) => v === 'failure' || v === 'skipped');
-}
-async function anyFailuresInObservable(obs) {
+async function convertObservableToPromise(obs) {
     return await new Promise((res) => {
-        let anyFailures = false;
-        obs.subscribe((t) => {
-            if (!t.success) {
-                anyFailures = true;
-            }
-        }, (error) => {
-            output_1.output.error({
-                title: 'Unhandled error in task executor',
-            });
-            console.error(error);
-            res(true);
-        }, () => {
-            res(anyFailures);
+        let tasksResults = {};
+        obs.subscribe({
+            next: (t) => {
+                tasksResults[t.task.id] = t.success ? 'success' : 'failure';
+            },
+            error: (error) => {
+                output_1.output.error({
+                    title: 'Unhandled error in task executor',
+                });
+                console.error(error);
+                res(tasksResults);
+            },
+            complete: () => {
+                res(tasksResults);
+            },
         });
     });
 }

package/src/tasks-runner/task-orchestrator.d.ts

@@ -40,7 +40,6 @@ export declare class TaskOrchestrator {
     private runTaskInForkedProcess;
     private preRunSteps;
     private postRunSteps;
-    private scheduleNextTasks;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;

package/src/tasks-runner/task-orchestrator.js

@@ -46,7 +46,7 @@ class TaskOrchestrator {
             this.tasksSchedule.init(),
         ]);
         // initial scheduling
-        await this.scheduleNextTasks();
+        await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
         const threads = [];
         process.stdout.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
@@ -68,6 +68,7 @@ class TaskOrchestrator {
         }
         const doNotSkipCache = this.options.skipNxCache === false ||
             this.options.skipNxCache === undefined;
+        this.processAllScheduledTasks();
         const batch = this.tasksSchedule.nextBatch();
         if (batch) {
             const groupId = this.closeGroup();
@@ -376,15 +377,11 @@ class TaskOrchestrator {
                 status,
             };
         }));
-        await this.scheduleNextTasks();
+        await this.tasksSchedule.scheduleNextTasks();
         // release blocked threads
         this.waitingForTasks.forEach((f) => f(null));
         this.waitingForTasks.length = 0;
     }
-    async scheduleNextTasks() {
-        await this.tasksSchedule.scheduleNextTasks();
-        this.processAllScheduledTasks();
-    }
     complete(taskResults) {
         this.tasksSchedule.complete(taskResults.map(({ taskId }) => taskId));
         for (const { taskId, status } of taskResults) {

package/src/utils/git-utils.d.ts

@@ -7,6 +7,7 @@ export declare class GitRepository {
     root: string;
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
+    hasUncommittedChanges(): Promise<boolean>;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;
@@ -25,10 +26,11 @@ export declare class GitRepository {
     deleteGitRemote(name: string): Promise<string>;
     addGitRemote(name: string, url: string): Promise<string>;
     hasFilterRepoInstalled(): Promise<boolean>;
-    filterRepo(subdirectory: string): Promise<string>;
-    filterBranch(subdirectory: string, branchName: string): Promise<string>;
+    filterRepo(source: string, destination: string): Promise<void>;
+    filterBranch(source: string, destination: string, branchName: string): Promise<void>;
     private execAsync;
     private quotePath;
+    private quoteArg;
 }
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.

package/src/utils/git-utils.index-filter.js

@@ -0,0 +1,20 @@
+/**
+ * This is meant to be used with `git filter-branch --index-filter` to rewrite
+ * history such that only commits related to the subdirectory is kept.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> git filter-branch --index-filter 'node git-utils.index-filter.js' --prune-empty -- --all
+ */
+try {
+    const { execSync } = require('child_process');
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    execSync('git read-tree --empty', { stdio: 'inherit' });
+    execSync(`git reset ${process.env.GIT_COMMIT} -- "${src}"`, {
+        stdio: 'inherit',
+    });
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}

package/src/utils/git-utils.js

@@ -40,6 +40,10 @@ class GitRepository {
             .toString()
             .trim();
     }
+    async hasUncommittedChanges() {
+        const data = await this.execAsync(`git status --porcelain`);
+        return data.trim() !== '';
+    }
     async addFetchRemote(remoteName, branch) {
         return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
     }
@@ -105,32 +109,63 @@ class GitRepository {
     }
     // git-filter-repo is much faster than filter-branch, but needs to be installed by user
     // Use `hasFilterRepoInstalled` to check if it's installed
-    async filterRepo(subdirectory) {
-        // filter-repo requires POSIX path to work
-        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
-        return await this.execAsync(`git filter-repo -f --subdirectory-filter ${this.quotePath(posixPath)}`);
-    }
-    async filterBranch(subdirectory, branchName) {
-        // filter-repo requires POSIX path to work
-        const posixPath = subdirectory.split(path_1.sep).join(path_1.posix.sep);
+    async filterRepo(source, destination) {
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        await this.execAsync(`git filter-repo -f ${source !== '' ? `--path ${this.quotePath(sourcePosixPath)}` : ''} ${source !== destination
+            ? `--path-rename ${this.quotePath(sourcePosixPath, true)}:${this.quotePath(destinationPosixPath, true)}`
+            : ''}`);
+    }
+    async filterBranch(source, destination, branchName) {
         // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
         await this.execAsync(`git config core.quotepath false`);
-        return await this.execAsync(`git filter-branch --subdirectory-filter ${this.quotePath(posixPath)} -- ${branchName}`);
+        // NOTE: filter-repo requires POSIX path to work
+        const sourcePosixPath = source.split(path_1.sep).join(path_1.posix.sep);
+        const destinationPosixPath = destination.split(path_1.sep).join(path_1.posix.sep);
+        // First, if the source is not a root project, then only include commits relevant to the subdirectory.
+        if (source !== '') {
+            const indexFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.index-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --index-filter ${indexFilterCommand} --prune-empty -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
+        // Then, move files to their new location if necessary.
+        if (source === '' || source !== destination) {
+            const treeFilterCommand = this.quoteArg(`node ${(0, path_1.join)(__dirname, 'git-utils.tree-filter.js')}`);
+            await this.execAsync(`git filter-branch -f --tree-filter ${treeFilterCommand} -- ${branchName}`, {
+                NX_IMPORT_SOURCE: sourcePosixPath,
+                NX_IMPORT_DESTINATION: destinationPosixPath,
+            });
+        }
     }
-    execAsync(command) {
+    execAsync(command, env) {
         return execAsync(command, {
             cwd: this.root,
             maxBuffer: 10 * 1024 * 1024,
+            env: {
+                ...process.env,
+                ...env,
+            },
         });
     }
-    quotePath(path) {
+    quotePath(path, ensureTrailingSlash) {
+        return this.quoteArg(ensureTrailingSlash && path !== '' && !path.endsWith('/')
+            ? `${path}/`
+            : path);
+    }
+    quoteArg(arg) {
         return process.platform === 'win32'
             ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
                 // Bash and other shells will substitute `$` in file names with a variable value.
-                `"${path}"`
+                `"${arg
+                    // Need to keep two slashes for Windows or else the path will be invalid.
+                    // e.g. 'C:\Users\bob\projects\repo' is invalid, but 'C:\\Users\\bob\\projects\\repo' is valid
+                    .replaceAll('\\', '\\\\')}"`
             : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
                 // Using single-quotes prevents this substitution.
-                `'${path}'`;
+                `'${arg}'`;
     }
 }
 exports.GitRepository = GitRepository;

package/src/utils/git-utils.tree-filter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+declare const execSync: any;
+declare const existsSync: any, mkdirSync: any, renameSync: any, rmSync: any;
+declare const posix: any;

package/src/utils/git-utils.tree-filter.js

@@ -0,0 +1,43 @@
+/**
+ * This is meant to be used with `git filter-branch --tree-filter` to rewrite
+ * history to only include commits related to the source project folder. If the
+ * destination folder is different, this script also moves the files over.
+ *
+ * Example:
+ * NX_IMPORT_SOURCE=<source> NX_IMPORT_DESTINATION=<destination> git filter-branch --tree-filter 'node git-utils.tree-filter.js' --prune-empty -- --all
+ */
+const { execSync } = require('child_process');
+const { existsSync, mkdirSync, renameSync, rmSync } = require('fs');
+// NOTE: The path passed to `git filter-branch` is POSIX, so we need to use the `posix` module.
+const { posix } = require('path');
+try {
+    // NOTE: Using env vars because Windows PowerShell has its own handling of quotes (") messes up quotes in args, even if escaped.
+    const src = process.env.NX_IMPORT_SOURCE;
+    const dest = process.env.NX_IMPORT_DESTINATION;
+    const files = execSync(`git ls-files -z ${src}`)
+        .toString()
+        .trim()
+        .split('\x00')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    for (const file of files) {
+        if (src === '' || file.startsWith(src)) {
+            // If source and destination are the same, then keep the file as is.
+            if (src === dest)
+                continue;
+            const destFile = posix.join(dest, file.replace(src, ''));
+            const dir = posix.dirname(destFile);
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            renameSync(file, destFile);
+        }
+        else {
+            // If not matching the source we are filtering, remove it.
+            rmSync(file);
+        }
+    }
+}
+catch (error) {
+    console.error(`Error executing Git commands: ${error}`);
+    process.exit(1);
+}