nx 19.7.0-canary.20240829-0ef6892 → 19.7.0-canary.20240830-83a387a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.7.0-canary.20240829-0ef6892",
+  "version": "19.7.0-canary.20240830-83a387a",
   "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.7.0-canary.20240829-0ef6892"
+    "@nrwl/tao": "19.7.0-canary.20240830-83a387a"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-darwin-arm64": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-linux-x64-gnu": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-linux-x64-musl": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-win32-x64-msvc": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-linux-arm64-gnu": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-linux-arm64-musl": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-linux-arm-gnueabihf": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-win32-arm64-msvc": "19.7.0-canary.20240829-0ef6892",
-    "@nx/nx-freebsd-x64": "19.7.0-canary.20240829-0ef6892"
+    "@nx/nx-darwin-x64": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-darwin-arm64": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-linux-x64-gnu": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-linux-x64-musl": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-win32-x64-msvc": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-linux-arm64-gnu": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-linux-arm64-musl": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-linux-arm-gnueabihf": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-win32-arm64-msvc": "19.7.0-canary.20240830-83a387a",
+    "@nx/nx-freebsd-x64": "19.7.0-canary.20240830-83a387a"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/connect/command-object.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsViewLogsCommand = exports.yargsConnectCommand = void 0;
 const documentation_1 = require("../yargs-utils/documentation");
 const versions_1 = require("../../utils/versions");
+const shared_options_1 = require("../yargs-utils/shared-options");
 exports.yargsConnectCommand = {
     command: 'connect',
     aliases: ['connect-to-nx-cloud'],
     describe: `Connect workspace to Nx Cloud`,
-    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(yargs, 'connect-to-nx-cloud'),
-    handler: async () => {
-        await (await Promise.resolve().then(() => require('./connect-to-nx-cloud'))).connectToNxCloudCommand();
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withConnectOptions(yargs), 'connect-to-nx-cloud'),
+    handler: async (args) => {
+        await (await Promise.resolve().then(() => require('./connect-to-nx-cloud'))).connectToNxCloudCommand(args);
         await (await Promise.resolve().then(() => require('../../utils/ab-testing'))).recordStat({
             command: 'connect',
             nxVersion: versions_1.nxVersion,
@@ -18,6 +19,12 @@ exports.yargsConnectCommand = {
         process.exit(0);
     },
 };
+function withConnectOptions(yargs) {
+    return (0, shared_options_1.withVerbose)(yargs).option('generateToken', {
+        type: 'boolean',
+        description: 'Explicitly asks for a token to be created, do not override existing tokens from Nx Cloud',
+    });
+}
 exports.yargsViewLogsCommand = {
     command: 'view-logs',
     describe: 'Enables you to view and interact with the logs via the advanced analytic UI from Nx Cloud to help you debug your issue. To do this, Nx needs to connect your workspace to Nx Cloud and upload the most recent run details. Only the metrics are uploaded, not the artefacts.',

package/src/command-line/connect/connect-to-nx-cloud.d.ts

@@ -5,6 +5,8 @@ import { MessageKey } from '../../utils/ab-testing';
 export declare function onlyDefaultRunnerIsUsed(nxJson: NxJsonConfiguration): boolean;
 export declare function connectToNxCloudIfExplicitlyAsked(opts: NxArgs): Promise<void>;
 export declare function connectWorkspaceToCloud(options: ConnectToNxCloudOptions, directory?: string): Promise<string>;
-export declare function connectToNxCloudCommand(command?: string): Promise<boolean>;
+export declare function connectToNxCloudCommand(options: {
+    generateToken?: boolean;
+}, command?: string): Promise<boolean>;
 export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey): Promise<boolean>;
 export declare function connectToNxCloudWithPrompt(command: string): Promise<void>;

package/src/command-line/connect/connect-to-nx-cloud.js

@@ -54,7 +54,7 @@ async function connectWorkspaceToCloud(options, directory = workspace_root_1.wor
     (0, tree_1.flushChanges)(directory, tree.listChanges());
     return accessToken;
 }
-async function connectToNxCloudCommand(command) {
+async function connectToNxCloudCommand(options, command) {
     const nxJson = (0, configuration_1.readNxJson)();
     const installationSource = process.env.NX_CONSOLE
         ? 'nx-console'
@@ -66,7 +66,7 @@ async function connectToNxCloudCommand(command) {
         if (!token) {
             throw new Error(`Unable to authenticate. If you are connecting to Nx Cloud locally, set Nx Cloud ID in nx.json. If you are connecting in a CI context, either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable.`);
         }
-        const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)(installationSource, token);
+        const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)(installationSource, token, options?.generateToken !== true);
         output_1.output.log({
             title: '✔ This workspace already has Nx Cloud set up',
             bodyLines: [
@@ -78,9 +78,10 @@ async function connectToNxCloudCommand(command) {
         return false;
     }
     const token = await connectWorkspaceToCloud({
+        generateToken: options?.generateToken,
         installationSource: command ?? installationSource,
     });
-    const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-connect', token);
+    const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-connect', token, options?.generateToken !== true);
     try {
         const cloudConnectSpinner = ora(`Opening Nx Cloud ${connectCloudUrl} in your browser to connect your workspace.`).start();
         await sleep(2000);
@@ -115,7 +116,9 @@ async function connectExistingRepoToNxCloudPrompt(command = 'init', key = 'setup
 }
 async function connectToNxCloudWithPrompt(command) {
     const setNxCloud = await nxCloudPrompt('setupNxCloud');
-    const useCloud = setNxCloud === 'yes' ? await connectToNxCloudCommand(command) : false;
+    const useCloud = setNxCloud === 'yes'
+        ? await connectToNxCloudCommand({ generateToken: false }, command)
+        : false;
     await (0, ab_testing_1.recordStat)({
         command,
         nxVersion: versions_1.nxVersion,

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

@@ -23,6 +23,10 @@ exports.yargsImportCommand = {
         .option('ref', {
         type: 'string',
         description: 'The branch from the source repository to import',
+    })
+        .option('depth', {
+        type: 'number',
+        description: 'The depth to clone the source repository (limit this for faster git clone)',
     })
         .option('interactive', {
         type: 'boolean',

package/src/command-line/import/import.d.ts

@@ -15,6 +15,10 @@ export interface ImportOptions {
      * The directory in the destination repo to import into
      */
     destination: string;
+    /**
+     * The depth to clone the source repository (limit this for faster clone times)
+     */
+    depth: number;
     verbose: boolean;
     interactive: boolean;
 }

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

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importHandler = importHandler;
 const path_1 = require("path");
+const minimatch_1 = require("minimatch");
+const node_fs_1 = require("node:fs");
+const chalk = require("chalk");
+const js_yaml_1 = require("@zkochan/js-yaml");
 const git_utils_1 = require("../../utils/git-utils");
 const promises_1 = require("node:fs/promises");
 const tmp_1 = require("tmp");
@@ -18,6 +22,7 @@ const command_line_utils_1 = require("../../utils/command-line-utils");
 const prepare_source_repo_1 = require("./utils/prepare-source-repo");
 const merge_remote_source_1 = require("./utils/merge-remote-source");
 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) {
     let { sourceRemoteUrl, ref, source, destination } = options;
@@ -54,7 +59,7 @@ async function importHandler(options) {
         // It's a remote url
     }
     const sourceRepoPath = (0, path_1.join)(tempImportDirectory, 'repo');
-    const spinner = createSpinner(`Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath}`).start();
+    const spinner = createSpinner(`Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath} (Use --depth to limit commit history and speed up clone times)`).start();
     try {
         await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
     }
@@ -64,6 +69,7 @@ async function importHandler(options) {
     try {
         sourceGitClient = await (0, git_utils_1.cloneFromUpstream)(sourceRemoteUrl, sourceRepoPath, {
             originName: importRemoteName,
+            depth: options.depth,
         });
     }
     catch (e) {
@@ -72,6 +78,8 @@ async function importHandler(options) {
         throw new Error(errorMessage);
     }
     spinner.succeed(`Cloned into ${sourceRepoPath}`);
+    // Detecting the package manager before preparing the source repo for import.
+    const sourcePackageManager = (0, package_manager_1.detectPackageManager)(sourceGitClient.root);
     if (!ref) {
         const branchChoices = await sourceGitClient.listBranches();
         ref = (await (0, enquirer_1.prompt)([
@@ -104,24 +112,34 @@ async function importHandler(options) {
                 name: 'destination',
                 message: 'Where in this workspace should the code be imported into?',
                 required: true,
+                initial: source ? source : undefined,
             },
         ])).destination;
     }
     const absSource = (0, path_1.join)(sourceRepoPath, source);
     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);
+    await sourceGitClient.fetch(importRemoteName, ref);
+    spinner.succeed(`Fetched ${ref} from ${sourceRemoteUrl}`);
+    spinner.start(`Checking out a temporary branch, ${tempImportBranch} based on ${ref}`);
+    await sourceGitClient.checkout(tempImportBranch, {
+        new: true,
+        base: `${importRemoteName}/${ref}`,
+    });
+    spinner.succeed(`Created a ${tempImportBranch} branch based on ${ref}`);
     try {
         await (0, promises_1.stat)(absSource);
     }
     catch (e) {
         throw new Error(`The source directory ${source} does not exist in ${sourceRemoteUrl}. Please double check to make sure it exists.`);
     }
-    const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
-    await assertDestinationEmpty(destinationGitClient, absDestination);
-    const tempImportBranch = getTempImportBranch(ref);
     const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
     const originalPackageWorkspaces = await (0, needs_install_1.getPackagesInPackageManagerWorkspace)(packageManager);
     const relativeDestination = (0, path_1.relative)(destinationGitClient.root, absDestination);
-    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl, importRemoteName);
+    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl);
     await createTemporaryRemote(destinationGitClient, (0, path_1.join)(sourceRepoPath, '.git'), importRemoteName);
     await (0, merge_remote_source_1.mergeRemoteSource)(destinationGitClient, sourceRemoteUrl, tempImportBranch, destination, importRemoteName, ref);
     spinner.start('Cleaning up temporary files and remotes');
@@ -132,19 +150,69 @@ async function importHandler(options) {
     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);
+    if (packageManager !== sourcePackageManager) {
+        output_1.output.warn({
+            title: `Mismatched package managers`,
+            bodyLines: [
+                `The source repository is using a different package manager (${sourcePackageManager}) than this workspace (${packageManager}).`,
+                `This could lead to install issues due to discrepancies in "package.json" features.`,
+            ],
+        });
+    }
+    // If install fails, we should continue since the errors could be resolved later.
+    let installFailed = false;
     if (plugins.length > 0) {
-        output_1.output.log({ title: 'Installing Plugins' });
-        (0, init_v2_1.installPlugins)(workspace_root_1.workspaceRoot, plugins, pmc, updatePackageScripts);
-        await destinationGitClient.amendCommit();
+        try {
+            output_1.output.log({ title: 'Installing Plugins' });
+            (0, init_v2_1.installPlugins)(workspace_root_1.workspaceRoot, plugins, pmc, updatePackageScripts);
+            await destinationGitClient.amendCommit();
+        }
+        catch (e) {
+            installFailed = true;
+            output_1.output.error({
+                title: `Install failed: ${e.message || 'Unknown error'}`,
+                bodyLines: [e.stack],
+            });
+        }
     }
     else if (await (0, needs_install_1.needsInstall)(packageManager, originalPackageWorkspaces)) {
+        try {
+            output_1.output.log({
+                title: 'Installing dependencies for imported code',
+            });
+            (0, utils_1.runInstall)(workspace_root_1.workspaceRoot, (0, package_manager_1.getPackageManagerCommand)(packageManager));
+            await destinationGitClient.amendCommit();
+        }
+        catch (e) {
+            installFailed = true;
+            output_1.output.error({
+                title: `Install failed: ${e.message || 'Unknown error'}`,
+                bodyLines: [e.stack],
+            });
+        }
+    }
+    console.log(await destinationGitClient.showStat());
+    if (installFailed) {
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+        output_1.output.warn({
+            title: `The import was successful, but the install failed`,
+            bodyLines: [
+                `You may need to run "${pmc.install}" manually to resolve the issue. The error is logged above.`,
+            ],
+        });
+    }
+    await warnOnMissingWorkspacesEntry(packageManager, pmc, relativeDestination);
+    // When only a subdirectory is imported, there might be devDependencies in the root package.json file
+    // that needs to be ported over as well.
+    if (ref) {
         output_1.output.log({
-            title: 'Installing dependencies for imported code',
+            title: `Check root dependencies`,
+            bodyLines: [
+                `"dependencies" and "devDependencies" are not imported from the source repository (${sourceRemoteUrl}).`,
+                `You may need to add some of those dependencies to this workspace in order to run tasks successfully.`,
+            ],
         });
-        (0, utils_1.runInstall)(workspace_root_1.workspaceRoot, (0, package_manager_1.getPackageManagerCommand)(packageManager));
-        await destinationGitClient.amendCommit();
     }
-    console.log(await destinationGitClient.showStat());
     output_1.output.log({
         title: `Merging these changes into ${(0, command_line_utils_1.getBaseRef)(nxJson)}`,
         bodyLines: [
@@ -171,3 +239,70 @@ async function createTemporaryRemote(destinationGitClient, sourceRemoteUrl, remo
     await destinationGitClient.addGitRemote(remoteName, sourceRemoteUrl);
     await destinationGitClient.fetch(remoteName);
 }
+// If the user imports a project that isn't in NPM/Yarn/PNPM workspaces, then its dependencies
+// will not be installed. We should warn users and provide instructions on how to fix this.
+async function warnOnMissingWorkspacesEntry(pm, pmc, pkgPath) {
+    if (!(0, package_manager_1.isWorkspacesEnabled)(pm, workspace_root_1.workspaceRoot)) {
+        output_1.output.warn({
+            title: `Missing workspaces in package.json`,
+            bodyLines: pm === 'npm'
+                ? [
+                    `We recommend enabling NPM workspaces to install dependencies for the imported project.`,
+                    `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
+                    `See: https://docs.npmjs.com/cli/using-npm/workspaces`,
+                ]
+                : pm === 'yarn'
+                    ? [
+                        `We recommend enabling Yarn workspaces to install dependencies for the imported project.`,
+                        `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
+                        `See: https://yarnpkg.com/features/workspaces`,
+                    ]
+                    : pm === 'bun'
+                        ? [
+                            `We recommend enabling Bun workspaces to install dependencies for the imported project.`,
+                            `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
+                            `See: https://bun.sh/docs/install/workspaces`,
+                        ]
+                        : [
+                            `We recommend enabling PNPM workspaces to install dependencies for the imported project.`,
+                            `Add the following entry to to pnpm-workspace.yaml and run "${pmc.install}":`,
+                            chalk.bold(`packages:\n  - '${pkgPath}'`),
+                            `See: https://pnpm.io/workspaces`,
+                        ],
+        });
+    }
+    else {
+        // Check if the new package is included in existing workspaces entries. If not, warn the user.
+        let workspaces = null;
+        if (pm === 'npm' || pm === 'yarn' || pm === 'bun') {
+            const packageJson = (0, file_utils_1.readPackageJson)();
+            workspaces = packageJson.workspaces;
+        }
+        else if (pm === 'pnpm') {
+            const yamlPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'pnpm-workspace.yaml');
+            if ((0, node_fs_1.existsSync)(yamlPath)) {
+                const yamlContent = await node_fs_1.promises.readFile(yamlPath, 'utf-8');
+                const yaml = (0, js_yaml_1.load)(yamlContent);
+                workspaces = yaml.packages;
+            }
+        }
+        if (workspaces) {
+            const isPkgIncluded = workspaces.some((w) => (0, minimatch_1.minimatch)(pkgPath, w));
+            if (!isPkgIncluded) {
+                const pkgsDir = (0, path_1.dirname)(pkgPath);
+                output_1.output.warn({
+                    title: `Project missing in workspaces`,
+                    bodyLines: pm === 'npm' || pm === 'yarn' || pm === 'bun'
+                        ? [
+                            `The imported project (${pkgPath}) is missing the "workspaces" field in package.json.`,
+                            `Add "${pkgsDir}/*" to workspaces run "${pmc.install}".`,
+                        ]
+                        : [
+                            `The imported project (${pkgPath}) is missing the "packages" field in pnpm-workspaces.yaml.`,
+                            `Add "${pkgsDir}/*" to packages run "${pmc.install}".`,
+                        ],
+                });
+            }
+        }
+    }
+}

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

@@ -1,2 +1,2 @@
 import { GitRepository } from '../../../utils/git-utils';
-export declare function prepareSourceRepo(gitClient: GitRepository, ref: string, source: string, relativeDestination: string, tempImportBranch: string, sourceRemoteUrl: string, originName: string): Promise<void>;
+export declare function prepareSourceRepo(gitClient: GitRepository, ref: string, source: string, relativeDestination: string, tempImportBranch: string, sourceRemoteUrl: string): Promise<void>;

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

@@ -4,99 +4,45 @@ 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, originName) {
+async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl) {
     const spinner = createSpinner().start(`Fetching ${ref} from ${sourceRemoteUrl}`);
-    await gitClient.addFetchRemote(originName, ref);
-    await gitClient.fetch(originName, ref);
-    spinner.succeed(`Fetched ${ref} from ${sourceRemoteUrl}`);
-    spinner.start(`Checking out a temporary branch, ${tempImportBranch} based on ${ref}`);
-    await gitClient.checkout(tempImportBranch, {
-        new: true,
-        base: `${originName}/${ref}`,
-    });
-    spinner.succeed(`Created a ${tempImportBranch} branch based on ${ref}`);
     const relativeSourceDir = (0, path_1.relative)(gitClient.root, (0, path_1.join)(gitClient.root, source));
-    const destinationInSource = (0, path_1.join)(gitClient.root, relativeDestination);
-    spinner.start(`Moving files and git history to ${destinationInSource}`);
-    if (relativeSourceDir === '') {
-        const files = await gitClient.getGitFiles('.');
-        try {
-            await (0, promises_1.rm)(destinationInSource, {
-                recursive: true,
-            });
-        }
-        catch { }
-        await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-        const gitignores = new Set();
-        for (const file of files) {
-            if ((0, path_1.basename)(file) === '.gitignore') {
-                gitignores.add(file);
-                continue;
-            }
-            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`);
-        for (const gitignore of gitignores) {
-            await gitClient.move(gitignore, (0, path_1.join)(destinationInSource, gitignore));
+    if (relativeSourceDir !== '') {
+        if (await gitClient.hasFilterRepoInstalled()) {
+            spinner.start(`Filtering git history to only include files in ${relativeSourceDir}`);
+            await gitClient.filterRepo(relativeSourceDir);
         }
-        await gitClient.amendCommit();
-        for (const gitignore of gitignores) {
-            await (0, promises_1.copyFile)((0, path_1.join)(destinationInSource, gitignore), (0, path_1.join)(gitClient.root, gitignore));
+        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}`);
     }
-    else {
-        let needsSquash = false;
-        const needsMove = destinationInSource !== (0, path_1.join)(gitClient.root, source);
-        if (needsMove) {
-            try {
-                await (0, promises_1.rm)(destinationInSource, {
-                    recursive: true,
-                });
-                await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-                needsSquash = true;
-            }
-            catch { }
-            await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-        }
-        const files = await gitClient.getGitFiles('.');
-        for (const file of files) {
-            if (file === '.gitignore') {
-                continue;
-            }
-            spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
-            if (!(0, path_1.relative)(source, file).startsWith('..')) {
-                if (needsMove) {
-                    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);
-                    }
-                }
-            }
-            else {
-                await (0, promises_1.rm)((0, path_1.join)(gitClient.root, file), {
-                    recursive: true,
-                });
-            }
+    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,
+        });
+    }
+    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);
         }
-        await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-        if (needsSquash) {
-            await gitClient.squashLastTwoCommits();
+        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(`${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/yargs-utils/shared-options.js

@@ -209,15 +209,7 @@ function withOutputStyleOption(yargs, choices = [
     'stream-without-prefixes',
 ]) {
     return yargs.option('output-style', {
-        describe: `Defines how Nx emits outputs tasks logs
-
-| option | description |
-| --- | --- |
-| dynamic | use dynamic output life cycle, previous content is overwritten or modified as new outputs are added, display minimal logs by default, always show errors. This output format is recommended on your local development environments. |
-| static | uses static output life cycle, no previous content is rewritten or modified as new outputs are added. This output format is recommened for CI environments. |
-| stream | nx by default logs output to an internal output stream, enable this option to stream logs to stdout / stderr |
-| stream-without-prefixes | nx prefixes the project name the target is running on, use this option remove the project name prefix from output |
-`,
+        describe: `Defines how Nx emits outputs tasks logs. **dynamic**: use dynamic output life cycle, previous content is overwritten or modified as new outputs are added, display minimal logs by default, always show errors. This output format is recommended on your local development environments. **static**: uses static output life cycle, no previous content is rewritten or modified as new outputs are added. This output format is recommened for CI environments. **stream**: nx by default logs output to an internal output stream, enable this option to stream logs to stdout / stderr. **stream-without-prefixes**: nx prefixes the project name the target is running on, use this option remove the project name prefix from output.`,
         type: 'string',
         choices,
     });

package/src/daemon/server/sync-generators.d.ts

@@ -4,3 +4,7 @@ export declare function getCachedSyncGeneratorChanges(generators: string[]): Pro
 export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
 export declare function collectAndScheduleSyncGenerators(projectGraph: ProjectGraph): void;
 export declare function getCachedRegisteredSyncGenerators(): Promise<string[]>;
+/**
+ * @internal
+ */
+export declare function _getConflictingGeneratorGroups(results: SyncGeneratorChangesResult[]): string[][];

package/src/daemon/server/sync-generators.js

@@ -4,6 +4,7 @@ exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
 exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
 exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
 exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+exports._getConflictingGeneratorGroups = _getConflictingGeneratorGroups;
 const nx_json_1 = require("../../config/nx-json");
 const tree_1 = require("../../generators/tree");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -25,7 +26,6 @@ let storedDisabledTaskSyncGeneratorsHash;
 const log = (...messageParts) => {
     logger_1.serverLogger.log('[SYNC]:', ...messageParts);
 };
-// TODO(leo): check conflicts and reuse the Tree where possible
 async function getCachedSyncGeneratorChanges(generators) {
     try {
         log('get sync generators changes on demand', generators);
@@ -37,51 +37,15 @@ async function getCachedSyncGeneratorChanges(generators) {
         }
         // reset the wait time
         waitPeriod = 100;
-        let projects;
-        let errored = false;
-        const getProjectsConfigurations = async () => {
-            if (projects || errored) {
-                return projects;
-            }
-            const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
-            projects = projectGraph
-                ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
-                : null;
-            errored = error !== undefined;
-            return projects;
-        };
-        return (await Promise.all(generators.map(async (generator) => {
-            if (scheduledGenerators.has(generator) ||
-                !syncGeneratorsCacheResultPromises.has(generator)) {
-                // it's scheduled to run (there are pending changes to process) or
-                // it's not scheduled and there's no cached result, so run it
-                const projects = await getProjectsConfigurations();
-                if (projects) {
-                    log(generator, 'already scheduled or not cached, running it now');
-                    runGenerator(generator, projects);
-                }
-                else {
-                    log(generator, 'already scheduled or not cached, project graph errored');
-                    /**
-                     * This should never happen. This is invoked imperatively, and by
-                     * the time it is invoked, the project graph would have already
-                     * been requested. If it errored, it would have been reported and
-                     * this wouldn't have been invoked. We handle it just in case.
-                     *
-                     * Since the project graph would be reported by the relevant
-                     * handlers separately, we just ignore the error, don't cache
-                     * any result and return an empty result, the next time this is
-                     * invoked the process will repeat until it eventually recovers
-                     * when the project graph is fixed.
-                     */
-                    return Promise.resolve({ changes: [], generatorName: generator });
-                }
-            }
-            else {
-                log(generator, 'not scheduled and has cached result, returning cached result');
-            }
-            return syncGeneratorsCacheResultPromises.get(generator);
-        }))).flat();
+        const results = await getFromCacheOrRunGenerators(generators);
+        const conflicts = _getConflictingGeneratorGroups(results);
+        if (!conflicts.length) {
+            // there are no conflicts
+            return results;
+        }
+        // there are conflicts, so we need to re-run the conflicting generators
+        // using the same tree
+        return await processConflictingGenerators(conflicts, results);
     }
     catch (e) {
         console.error(e);
@@ -131,7 +95,7 @@ function collectAndScheduleSyncGenerators(projectGraph) {
         }
         const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
         for (const generator of scheduledGenerators) {
-            runGenerator(generator, projects);
+            syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
         }
         await Promise.all(syncGeneratorsCacheResultPromises.values());
     }, waitPeriod);
@@ -148,6 +112,163 @@ async function getCachedRegisteredSyncGenerators() {
     }
     return [...registeredSyncGenerators];
 }
+async function getFromCacheOrRunGenerators(generators) {
+    let projects;
+    let errored = false;
+    const getProjectsConfigurations = async () => {
+        if (projects || errored) {
+            return projects;
+        }
+        const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        projects = projectGraph
+            ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+            : null;
+        errored = error !== undefined;
+        return projects;
+    };
+    return (await Promise.all(generators.map(async (generator) => {
+        if (scheduledGenerators.has(generator) ||
+            !syncGeneratorsCacheResultPromises.has(generator)) {
+            // it's scheduled to run (there are pending changes to process) or
+            // it's not scheduled and there's no cached result, so run it
+            const projects = await getProjectsConfigurations();
+            if (projects) {
+                log(generator, 'already scheduled or not cached, running it now');
+                syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
+            }
+            else {
+                log(generator, 'already scheduled or not cached, project graph errored');
+                /**
+                 * This should never happen. This is invoked imperatively, and by
+                 * the time it is invoked, the project graph would have already
+                 * been requested. If it errored, it would have been reported and
+                 * this wouldn't have been invoked. We handle it just in case.
+                 *
+                 * Since the project graph would be reported by the relevant
+                 * handlers separately, we just ignore the error, don't cache
+                 * any result and return an empty result, the next time this is
+                 * invoked the process will repeat until it eventually recovers
+                 * when the project graph is fixed.
+                 */
+                return Promise.resolve({ changes: [], generatorName: generator });
+            }
+        }
+        else {
+            log(generator, 'not scheduled and has cached result, returning cached result');
+        }
+        return syncGeneratorsCacheResultPromises.get(generator);
+    }))).flat();
+}
+async function runConflictingGenerators(tree, generators) {
+    const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const projects = projectGraph
+        ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+        : null;
+    if (!projects) {
+        /**
+         * This should never happen. This is invoked imperatively, and by
+         * the time it is invoked, the project graph would have already
+         * been requested. If it errored, it would have been reported and
+         * this wouldn't have been invoked. We handle it just in case.
+         *
+         * Since the project graph would be reported by the relevant
+         * handlers separately, we just ignore the error.
+         */
+        return generators.map((generator) => ({
+            changes: [],
+            generatorName: generator,
+        }));
+    }
+    // we need to run conflicting generators sequentially because they use the same tree
+    const results = [];
+    for (const generator of generators) {
+        log(generator, 'running it now');
+        results.push(await runGenerator(generator, projects, tree));
+    }
+    return results;
+}
+async function processConflictingGenerators(conflicts, initialResults) {
+    const conflictRunResults = (await Promise.all(conflicts.map((generators) => {
+        const [firstGenerator, ...generatorsToRun] = generators;
+        // it must exists because the conflicts were identified from the initial results
+        const firstGeneratorResult = initialResults.find((r) => r.generatorName === firstGenerator);
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generators ${generators.join(',')}`);
+        // pre-apply the changes from the first generator to avoid running it
+        for (const change of firstGeneratorResult.changes) {
+            if (change.type === 'CREATE' || change.type === 'UPDATE') {
+                tree.write(change.path, change.content, change.options);
+            }
+            else if (change.type === 'DELETE') {
+                tree.delete(change.path);
+            }
+        }
+        /**
+         * We don't cache the results of conflicting generators because they
+         * use the same tree, so some files might contain results from multiple
+         * generators and we don't have guarantees that the same combination of
+         * generators will run together.
+         */
+        return runConflictingGenerators(tree, generatorsToRun);
+    }))).flat();
+    /**
+     * The order of the results from the re-run generators is important because
+     * the last result from a group of conflicting generators will contain the
+     * changes from the previous conflicting generators. So, instead of replacing
+     * in-place the initial results, we first add the results from the re-run
+     * generators, and then add the initial results that were not from a
+     * conflicting generator.
+     */
+    const results = [...conflictRunResults];
+    for (const result of initialResults) {
+        if (conflictRunResults.every((r) => r.generatorName !== result.generatorName)) {
+            // this result is not from a conflicting generator, so we add it to the
+            // results
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * @internal
+ */
+function _getConflictingGeneratorGroups(results) {
+    const changedFileToGeneratorMap = new Map();
+    for (const result of results) {
+        for (const change of result.changes) {
+            if (!changedFileToGeneratorMap.has(change.path)) {
+                changedFileToGeneratorMap.set(change.path, new Set());
+            }
+            changedFileToGeneratorMap.get(change.path).add(result.generatorName);
+        }
+    }
+    const conflicts = [];
+    for (const generatorSet of changedFileToGeneratorMap.values()) {
+        if (generatorSet.size === 1) {
+            // no conflicts
+            continue;
+        }
+        if (conflicts.length === 0) {
+            // there are no conflicts yet, so we just add the first group
+            conflicts.push(new Set(generatorSet));
+            continue;
+        }
+        // identify if any of the current generator sets intersect with any of the
+        // existing conflict groups
+        const generatorsArray = Array.from(generatorSet);
+        const existingConflictGroup = conflicts.find((group) => generatorsArray.some((generator) => group.has(generator)));
+        if (existingConflictGroup) {
+            // there's an intersecting group, so we merge the two
+            for (const generator of generatorsArray) {
+                existingConflictGroup.add(generator);
+            }
+        }
+        else {
+            // there's no intersecting group, so we create a new one
+            conflicts.push(new Set(generatorsArray));
+        }
+    }
+    return conflicts.map((group) => Array.from(group));
+}
 function collectAllRegisteredSyncGenerators(projectGraph) {
     const nxJson = (0, nx_json_1.readNxJson)();
     const projectGraphHash = hashProjectGraph(projectGraph);
@@ -191,16 +312,15 @@ function collectAllRegisteredSyncGenerators(projectGraph) {
         }
     }
 }
-function runGenerator(generator, projects) {
+function runGenerator(generator, projects, tree) {
     log('running scheduled generator', generator);
     // remove it from the scheduled set
     scheduledGenerators.delete(generator);
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
-    // run the generator and cache the result
-    syncGeneratorsCacheResultPromises.set(generator, (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+    tree ??= new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    return (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
         log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
         return result;
-    }));
+    });
 }
 function hashProjectGraph(projectGraph) {
     const stringifiedProjects = Object.entries(projectGraph.nodes)

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.d.ts

@@ -7,7 +7,8 @@ export interface ConnectToNxCloudOptions {
     hideFormatLogs?: boolean;
     github?: boolean;
     directory?: string;
+    generateToken?: boolean;
 }
-export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string>;
+export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string | null>;
 declare function connectToNxCloudGenerator(tree: Tree, options: ConnectToNxCloudOptions): Promise<void>;
 export default connectToNxCloudGenerator;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -88,20 +88,22 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
         printCloudConnectionDisabledMessage();
         return null;
     }
-    else {
-        const usesGithub = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
-        let responseFromCreateNxCloudWorkspaceV2;
-        // do NOT create Nx Cloud token (createNxCloudWorkspace)
-        // if user is using github and is running nx-connect
-        if (!(usesGithub && schema.installationSource === 'nx-connect')) {
-            responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
-            addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
-            await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
-                silent: schema.hideFormatLogs,
-            });
-            return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
-        }
-    }
+    const isGitHubDetected = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
+    let responseFromCreateNxCloudWorkspaceV2;
+    /**
+     * Do not create an Nx Cloud token if the user is using GitHub and
+     * is running `nx-connect` AND `token` is undefined (override)
+     */
+    if (!schema.generateToken &&
+        isGitHubDetected &&
+        schema.installationSource === 'nx-connect')
+        return null;
+    responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+    addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+        silent: schema.hideFormatLogs,
+    });
+    return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
 }
 async function connectToNxCloudGenerator(tree, options) {
     await connectToNxCloud(tree, options);

package/src/nx-cloud/generators/connect-to-nx-cloud/schema.json

@@ -21,6 +21,10 @@
       "description": "Hide formatting logs",
       "x-priority": "internal"
     },
+    "generateToken": {
+      "type": "boolean",
+      "description": "Explicitly asks for a token to be created, do not override existing tokens from Nx Cloud"
+    },
     "github": {
       "type": "boolean",
       "description": "If the user will be using GitHub as their git hosting provider",

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

@@ -1,6 +1,6 @@
-import { ExecSyncOptions } from 'child_process';
-export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+export declare function cloneFromUpstream(url: string, destination: string, { originName, depth }?: {
     originName: string;
+    depth?: number;
 }): Promise<GitRepository>;
 export declare class GitRepository {
     private directory;
@@ -8,12 +8,10 @@ export declare class GitRepository {
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
-    private execAsync;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;
     getGitFiles(path: string): Promise<string[]>;
     reset(ref: string): Promise<string>;
-    squashLastTwoCommits(): Promise<string>;
     mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
     fetch(remote: string, ref?: string): Promise<string>;
     checkout(branch: string, opts: {
@@ -25,14 +23,13 @@ export declare class GitRepository {
     commit(message: string): Promise<string>;
     amendCommit(): Promise<string>;
     deleteGitRemote(name: string): Promise<string>;
-    deleteBranch(branch: 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>;
+    private execAsync;
+    private quotePath;
 }
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-export declare function updateRebaseFile(contents: string): string;
-export declare function fetchGitRemote(name: string, branch: string, execOptions: ExecSyncOptions): string | Buffer;
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */

package/src/utils/git-utils.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitRepository = void 0;
 exports.cloneFromUpstream = cloneFromUpstream;
-exports.updateRebaseFile = updateRebaseFile;
-exports.fetchGitRemote = fetchGitRemote;
 exports.getGithubSlugOrNull = getGithubSlugOrNull;
 exports.extractUserAndRepoFromGitHubUrl = extractUserAndRepoFromGitHubUrl;
 exports.commitChanges = commitChanges;
 exports.getLatestCommitSha = getLatestCommitSha;
 const child_process_1 = require("child_process");
-const devkit_exports_1 = require("../devkit-exports");
 const path_1 = require("path");
-const SQUASH_EDITOR = (0, path_1.join)(__dirname, 'squash.js');
+const devkit_exports_1 = require("../devkit-exports");
 function execAsync(command, execOptions) {
     return new Promise((res, rej) => {
         (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
@@ -22,9 +19,12 @@ function execAsync(command, execOptions) {
         });
     });
 }
-async function cloneFromUpstream(url, destination, { originName } = { originName: 'origin' }) {
-    await execAsync(`git clone ${url} ${destination} --depth 1 --origin ${originName}`, {
+async function cloneFromUpstream(url, destination, { originName, depth } = {
+    originName: 'origin',
+}) {
+    await execAsync(`git clone ${url} ${destination} ${depth ? `--depth ${depth}` : ''} --origin ${originName}`, {
         cwd: (0, path_1.dirname)(destination),
+        maxBuffer: 10 * 1024 * 1024,
     });
     return new GitRepository(destination);
 }
@@ -40,13 +40,8 @@ class GitRepository {
             .toString()
             .trim();
     }
-    addFetchRemote(remoteName, branch) {
-        return this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
-    }
-    execAsync(command) {
-        return execAsync(command, {
-            cwd: this.root,
-        });
+    async addFetchRemote(remoteName, branch) {
+        return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
     }
     async showStat() {
         return await this.execAsync(`git show --stat`);
@@ -61,62 +56,84 @@ class GitRepository {
             .replace('refs/heads/', ''));
     }
     async getGitFiles(path) {
-        return (await this.execAsync(`git ls-files ${path}`))
+        // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
+        // This avoids problems with special characters in file names.
+        return (await this.execAsync(`git ls-files -z ${path}`))
             .trim()
-            .split('\n')
+            .split('\x00')
             .map((s) => s.trim())
             .filter(Boolean);
     }
     async reset(ref) {
-        return this.execAsync(`git reset ${ref} --hard`);
-    }
-    async squashLastTwoCommits() {
-        return this.execAsync(`git -c core.editor="node ${SQUASH_EDITOR}" rebase --interactive --no-autosquash HEAD~2`);
+        return await this.execAsync(`git reset ${ref} --hard`);
     }
     async mergeUnrelatedHistories(ref, message) {
-        return this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+        return await this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
     }
     async fetch(remote, ref) {
-        return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+        return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
     }
     async checkout(branch, opts) {
-        return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+        return await this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
     }
     async move(path, destination) {
-        return this.execAsync(`git mv "${path}" "${destination}"`);
+        return await this.execAsync(`git mv ${this.quotePath(path)} ${this.quotePath(destination)}`);
     }
     async push(ref, remoteName) {
-        return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+        return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
     }
     async commit(message) {
-        return this.execAsync(`git commit -am "${message}"`);
+        return await this.execAsync(`git commit -am "${message}"`);
     }
     async amendCommit() {
-        return this.execAsync(`git commit --amend -a --no-edit`);
+        return await this.execAsync(`git commit --amend -a --no-edit`);
     }
-    deleteGitRemote(name) {
-        return this.execAsync(`git remote rm ${name}`);
+    async deleteGitRemote(name) {
+        return await this.execAsync(`git remote rm ${name}`);
     }
-    deleteBranch(branch) {
-        return this.execAsync(`git branch -D ${branch}`);
+    async addGitRemote(name, url) {
+        return await this.execAsync(`git remote add ${name} ${url}`);
+    }
+    async hasFilterRepoInstalled() {
+        try {
+            await this.execAsync(`git filter-repo --help`);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    addGitRemote(name, url) {
-        return this.execAsync(`git remote add ${name} ${url}`);
+    // 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);
+        // 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}`);
+    }
+    execAsync(command) {
+        return execAsync(command, {
+            cwd: this.root,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+    }
+    quotePath(path) {
+        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}"`
+            : // 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}'`;
     }
 }
 exports.GitRepository = GitRepository;
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-function updateRebaseFile(contents) {
-    const lines = contents.split('\n');
-    const lastCommitIndex = lines.findIndex((line) => line === '') - 1;
-    lines[lastCommitIndex] = lines[lastCommitIndex].replace('pick', 'fixup');
-    return lines.join('\n');
-}
-function fetchGitRemote(name, branch, execOptions) {
-    return (0, child_process_1.execSync)(`git fetch ${name} ${branch} --depth 1`, execOptions);
-}
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */

package/src/utils/sync-generators.d.ts

@@ -3,7 +3,7 @@ import { type NxJsonConfiguration } from '../config/nx-json';
 import type { ProjectGraph } from '../config/project-graph';
 import type { TaskGraph } from '../config/task-graph';
 import type { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { FsTree, type FileChange, type Tree } from '../generators/tree';
+import { type FileChange, type Tree } from '../generators/tree';
 export type SyncGeneratorResult = void | {
     callback?: GeneratorCallback;
     outOfSyncMessage?: string;
@@ -18,7 +18,7 @@ export type SyncGeneratorChangesResult = {
 export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
 export declare function flushSyncGeneratorChanges(results: SyncGeneratorChangesResult[]): Promise<void>;
 export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<string[]>;
-export declare function runSyncGenerator(tree: FsTree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
+export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
 export declare function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectRegisteredGlobalSyncGenerators(nxJson?: NxJsonConfiguration<string[] | "*">): Set<string>;

package/src/utils/squash.d.ts

@@ -1 +0,0 @@
-export {};

package/src/utils/squash.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const git_utils_1 = require("./git-utils");
-// This script is used as an editor for git rebase -i
-// This is the file which git creates. When this script exits, the updates should be written to this file.
-const filePath = process.argv[2];
-// Change the second commit from pick to fixup
-const contents = (0, fs_1.readFileSync)(filePath).toString();
-const newContents = (0, git_utils_1.updateRebaseFile)(contents);
-// Write the updated contents back to the file
-(0, fs_1.writeFileSync)(filePath, newContents);