nx 19.6.0-canary.20240809-d3747e0 → 19.6.0-canary.20240814-6d83ae2

package/bin/post-install.js

@@ -28,6 +28,7 @@ const logger_1 = require("../src/utils/logger");
             if ((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
                 tasks.push((0, update_manager_1.verifyOrUpdateNxCloudClient)((0, get_cloud_options_1.getCloudOptions)()));
             }
+            process.env.NX_DAEMON = 'false';
             await Promise.all(tasks.map((promise) => {
                 return promise.catch((e) => {
                     if (process.env.NX_VERBOSE_LOGGING === 'true') {
@@ -53,3 +54,11 @@ function isMainNxPackage() {
     const thisNxPath = require.resolve('nx');
     return mainNxPath === thisNxPath;
 }
+process.on('uncaughtException', (e) => {
+    logger_1.logger.verbose(e);
+    process.exit(0);
+});
+process.on('unhandledRejection', (e) => {
+    logger_1.logger.verbose(e);
+    process.exit(0);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.6.0-canary.20240809-d3747e0",
+  "version": "19.6.0-canary.20240814-6d83ae2",
   "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.6.0-canary.20240809-d3747e0"
+    "@nrwl/tao": "19.6.0-canary.20240814-6d83ae2"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-darwin-arm64": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-linux-x64-gnu": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-linux-x64-musl": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-win32-x64-msvc": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-linux-arm64-gnu": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-linux-arm64-musl": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-linux-arm-gnueabihf": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-win32-arm64-msvc": "19.6.0-canary.20240809-d3747e0",
-    "@nx/nx-freebsd-x64": "19.6.0-canary.20240809-d3747e0"
+    "@nx/nx-darwin-x64": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-darwin-arm64": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-linux-x64-gnu": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-linux-x64-musl": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-win32-x64-msvc": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-linux-arm64-gnu": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-linux-arm64-musl": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-linux-arm-gnueabihf": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-win32-arm64-msvc": "19.6.0-canary.20240814-6d83ae2",
+    "@nx/nx-freebsd-x64": "19.6.0-canary.20240814-6d83ae2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/schemas/nx-schema.json

@@ -186,8 +186,15 @@
                 "type": "string"
               },
               "versionPlans": {
-                "type": "boolean",
-                "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+                "oneOf": [
+                  {
+                    "$ref": "#/definitions/NxReleaseVersionPlansConfiguration"
+                  },
+                  {
+                    "type": "boolean",
+                    "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+                  }
+                ]
               }
             },
             "required": ["projects"]
@@ -239,13 +246,45 @@
           "$ref": "#/definitions/NxReleaseVersionConfiguration"
         },
         "versionPlans": {
-          "type": "boolean",
-          "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+          "oneOf": [
+            {
+              "$ref": "#/definitions/NxReleaseVersionPlansConfiguration"
+            },
+            {
+              "type": "boolean",
+              "description": "Enables using version plans as a specifier source for versioning and to determine changes for changelog generation."
+            }
+          ]
         },
         "releaseTagPattern": {
           "type": "string"
         }
       }
+    },
+    "sync": {
+      "type": "object",
+      "description": "Configuration for the `nx sync` command",
+      "properties": {
+        "globalGenerators": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "List of workspace-wide sync generators to be run (not attached to targets)"
+        },
+        "generatorOptions": {
+          "type": "object",
+          "description": "Options for the sync generators.",
+          "additionalProperties": {
+            "type": "object"
+          }
+        },
+        "applyChanges": {
+          "type": "boolean",
+          "description": "Whether to automatically apply sync generator changes when running tasks. If not set, the user will be prompted. If set to `true`, the user will not be prompted and the changes will be applied. If set to `false`, the user will not be prompted and the changes will not be applied."
+        }
+      },
+      "additionalProperties": false
     }
   },
   "definitions": {
@@ -673,6 +712,18 @@
         }
       }
     },
+    "NxReleaseVersionPlansConfiguration": {
+      "type": "object",
+      "properties": {
+        "ignorePatternsForPlanCheck": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Changes to files matching any of these optional patterns will be excluded from the affected project logic within the `nx release plan:check` command. This is useful for ignoring files that are not relevant to the versioning process, such as documentation or configuration files."
+        }
+      }
+    },
     "ChangelogRenderOptions": {
       "type": "object",
       "additionalProperties": true

package/schemas/project-schema.json

@@ -153,6 +153,13 @@
               }
             },
             "additionalProperties": true
+          },
+          "syncGenerators": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "List of generators to run before the target to ensure the workspace is up to date"
           }
         }
       }

package/src/adapter/compat.d.ts

@@ -1,2 +1,2 @@
 export declare const allowedProjectExtensions: readonly ["tags", "implicitDependencies", "configFilePath", "$schema", "generators", "namedInputs", "name", "files", "root", "sourceRoot", "projectType", "release", "includedScripts", "metadata"];
-export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudId", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud"];
+export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudId", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud", "sync"];

package/src/adapter/compat.js

@@ -62,6 +62,7 @@ exports.allowedWorkspaceExtensions = [
     'useDaemonProcess',
     'useInferencePlugins',
     'neverConnectToCloud',
+    'sync',
 ];
 if (!patched) {
     Module.prototype.require = function () {

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

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsImportCommand: CommandModule;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsImportCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const params_1 = require("../../utils/params");
+exports.yargsImportCommand = {
+    command: 'import [sourceRemoteUrl] [destination]',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withVerbose)(yargs
+        .positional('sourceRemoteUrl', {
+        type: 'string',
+        description: 'The remote URL of the source to import',
+    })
+        .positional('destination', {
+        type: 'string',
+        description: 'The directory in the current workspace to import into',
+    })
+        .option('source', {
+        type: 'string',
+        description: 'The directory in the source repository to import from',
+    })
+        .option('ref', {
+        type: 'string',
+        description: 'The branch from the source repository to import',
+    })
+        .option('interactive', {
+        type: 'boolean',
+        description: 'Interactive mode',
+        default: true,
+    })), 'import'),
+    handler: async (args) => {
+        const exitCode = await (0, params_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./import'))).importHandler(args);
+        });
+        process.exit(exitCode);
+    },
+};

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

@@ -0,0 +1,21 @@
+export interface ImportOptions {
+    /**
+     * The remote URL of the repository to import
+     */
+    sourceRemoteUrl: string;
+    /**
+     * The branch or reference to import
+     */
+    ref: string;
+    /**
+     * The directory in the source repo to import
+     */
+    source: string;
+    /**
+     * The directory in the destination repo to import into
+     */
+    destination: string;
+    verbose: boolean;
+    interactive: boolean;
+}
+export declare function importHandler(options: ImportOptions): Promise<void>;

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

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importHandler = importHandler;
+const path_1 = require("path");
+const git_utils_1 = require("../../utils/git-utils");
+const promises_1 = require("node:fs/promises");
+const tmp_1 = require("tmp");
+const enquirer_1 = require("enquirer");
+const output_1 = require("../../utils/output");
+const createSpinner = require("ora");
+const init_v2_1 = require("../init/init-v2");
+const nx_json_1 = require("../../config/nx-json");
+const workspace_root_1 = require("../../utils/workspace-root");
+const package_manager_1 = require("../../utils/package-manager");
+const workspace_context_1 = require("../../utils/workspace-context");
+const utils_1 = require("../init/implementation/utils");
+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 importRemoteName = '__tmp_nx_import__';
+async function importHandler(options) {
+    let { sourceRemoteUrl, ref, source, destination } = options;
+    output_1.output.log({
+        title: 'Nx will walk you through the process of importing code from another repository into this workspace:',
+        bodyLines: [
+            `1. Nx will clone the other repository into a temporary directory`,
+            `2. Code to be imported will be moved to the same directory it will be imported into on a temporary branch`,
+            `3. The code will be merged into the current branch in this workspace`,
+            `4. Nx will recommend plugins to integrate tools used in the imported code with Nx`,
+            `5. The code will be successfully imported into this workspace`,
+            '',
+            `Git history will be preserved during this process`,
+        ],
+    });
+    const tempImportDirectory = (0, path_1.join)(tmp_1.tmpdir, 'nx-import');
+    if (!sourceRemoteUrl) {
+        sourceRemoteUrl = (await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                name: 'sourceRemoteUrl',
+                message: 'What is the URL of the repository you want to import? (This can be a local git repository or a git remote URL)',
+                required: true,
+            },
+        ])).sourceRemoteUrl;
+    }
+    try {
+        const maybeLocalDirectory = await (0, promises_1.stat)(sourceRemoteUrl);
+        if (maybeLocalDirectory.isDirectory()) {
+            sourceRemoteUrl = (0, path_1.resolve)(sourceRemoteUrl);
+        }
+    }
+    catch (e) {
+        // It's a remote url
+    }
+    const sourceRepoPath = (0, path_1.join)(tempImportDirectory, 'repo');
+    const spinner = createSpinner(`Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath}`).start();
+    try {
+        await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
+    }
+    catch { }
+    await (0, promises_1.mkdir)(tempImportDirectory, { recursive: true });
+    let sourceGitClient;
+    try {
+        sourceGitClient = await (0, git_utils_1.cloneFromUpstream)(sourceRemoteUrl, sourceRepoPath, {
+            originName: importRemoteName,
+        });
+    }
+    catch (e) {
+        spinner.fail(`Failed to clone ${sourceRemoteUrl} into ${sourceRepoPath}`);
+        let errorMessage = `Failed to clone ${sourceRemoteUrl} into ${sourceRepoPath}. Please double check the remote and try again.\n${e.message}`;
+        throw new Error(errorMessage);
+    }
+    spinner.succeed(`Cloned into ${sourceRepoPath}`);
+    if (!ref) {
+        const branchChoices = await sourceGitClient.listBranches();
+        ref = (await (0, enquirer_1.prompt)([
+            {
+                type: 'autocomplete',
+                name: 'ref',
+                message: `Which branch do you want to import?`,
+                choices: branchChoices,
+                /**
+                 * Limit the number of choices so that it fits on screen
+                 */
+                limit: process.stdout.rows - 3,
+                required: true,
+            },
+        ])).ref;
+    }
+    if (!source) {
+        source = (await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                name: 'source',
+                message: `Which directory do you want to import into this workspace? (leave blank to import the entire repository)`,
+            },
+        ])).source;
+    }
+    if (!destination) {
+        destination = (await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                name: 'destination',
+                message: 'Where in this workspace should the code be imported into?',
+                required: true,
+            },
+        ])).destination;
+    }
+    const absSource = (0, path_1.join)(sourceRepoPath, source);
+    const absDestination = (0, path_1.join)(process.cwd(), destination);
+    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 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');
+    await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
+    await destinationGitClient.deleteGitRemote(importRemoteName);
+    spinner.succeed('Cleaned up temporary files and remotes');
+    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);
+    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();
+    }
+    else if (await (0, needs_install_1.needsInstall)(packageManager, originalPackageWorkspaces)) {
+        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();
+    }
+    console.log(await destinationGitClient.showStat());
+    output_1.output.log({
+        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"`,
+        ],
+    });
+}
+async function assertDestinationEmpty(gitClient, absDestination) {
+    const files = await gitClient.getGitFiles(absDestination);
+    if (files.length > 0) {
+        throw new Error(`Destination directory ${absDestination} is not empty. Please make sure it is empty before importing into it.`);
+    }
+}
+function getTempImportBranch(sourceBranch) {
+    return `__nx_tmp_import__/${sourceBranch}`;
+}
+async function createTemporaryRemote(destinationGitClient, sourceRemoteUrl, remoteName) {
+    try {
+        await destinationGitClient.deleteGitRemote(remoteName);
+    }
+    catch { }
+    await destinationGitClient.addGitRemote(remoteName, sourceRemoteUrl);
+    await destinationGitClient.fetch(remoteName);
+}

package/src/command-line/import/utils/merge-remote-source.d.ts

@@ -0,0 +1,2 @@
+import { GitRepository } from '../../../utils/git-utils';
+export declare function mergeRemoteSource(destinationGitClient: GitRepository, sourceRemoteUrl: string, tempBranch: string, destination: string, remoteName: string, branchName: string): Promise<void>;

package/src/command-line/import/utils/merge-remote-source.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRemoteSource = mergeRemoteSource;
+const createSpinner = require("ora");
+async function mergeRemoteSource(destinationGitClient, sourceRemoteUrl, tempBranch, destination, remoteName, branchName) {
+    const spinner = createSpinner();
+    spinner.start(`Merging ${branchName} from ${sourceRemoteUrl} into ${destination}`);
+    spinner.start(`Fetching ${tempBranch} from ${remoteName}`);
+    await destinationGitClient.fetch(remoteName, tempBranch);
+    spinner.succeed(`Fetched ${tempBranch} from ${remoteName}`);
+    spinner.start(`Merging files and git history from ${branchName} from ${sourceRemoteUrl} into ${destination}`);
+    await destinationGitClient.mergeUnrelatedHistories(`${remoteName}/${tempBranch}`, `feat(repo): merge ${branchName} from ${sourceRemoteUrl}`);
+    spinner.succeed(`Merged files and git history from ${branchName} from ${sourceRemoteUrl} into ${destination}`);
+}

package/src/command-line/import/utils/needs-install.d.ts

@@ -0,0 +1,3 @@
+import { PackageManager } from '../../../utils/package-manager';
+export declare function getPackagesInPackageManagerWorkspace(packageManager: PackageManager): Promise<Set<string>>;
+export declare function needsInstall(packageManager: PackageManager, originalPackagesInPackageManagerWorkspaces: Set<string>): Promise<boolean>;

package/src/command-line/import/utils/needs-install.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackagesInPackageManagerWorkspace = getPackagesInPackageManagerWorkspace;
+exports.needsInstall = needsInstall;
+const package_manager_1 = require("../../../utils/package-manager");
+const workspace_root_1 = require("../../../utils/workspace-root");
+const package_json_1 = require("../../../plugins/package-json");
+const workspace_context_1 = require("../../../utils/workspace-context");
+async function getPackagesInPackageManagerWorkspace(packageManager) {
+    if (!(0, package_manager_1.isWorkspacesEnabled)(packageManager, workspace_root_1.workspaceRoot)) {
+        return new Set();
+    }
+    const patterns = (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(workspace_root_1.workspaceRoot);
+    return new Set(await (0, workspace_context_1.globWithWorkspaceContext)(workspace_root_1.workspaceRoot, patterns));
+}
+async function needsInstall(packageManager, originalPackagesInPackageManagerWorkspaces) {
+    if (!(0, package_manager_1.isWorkspacesEnabled)(packageManager, workspace_root_1.workspaceRoot)) {
+        return false;
+    }
+    const updatedPackagesInPackageManagerWorkspaces = await getPackagesInPackageManagerWorkspace(packageManager);
+    if (updatedPackagesInPackageManagerWorkspaces.size !==
+        originalPackagesInPackageManagerWorkspaces.size) {
+        return true;
+    }
+    for (const pkg of updatedPackagesInPackageManagerWorkspaces) {
+        if (!originalPackagesInPackageManagerWorkspaces.has(pkg)) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -0,0 +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>;

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

@@ -0,0 +1,104 @@
+"use strict";
+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, originName) {
+    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));
+        }
+        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 {
+        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): prepare for import');
+                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,
+                });
+            }
+        }
+        await gitClient.commit('chore(repo): prepare for import 2');
+        if (needsSquash) {
+            await gitClient.squashLastTwoCommits();
+        }
+    }
+    spinner.succeed(`${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`);
+}
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -1,7 +1,14 @@
+import { PackageManagerCommands } from '../../utils/package-manager';
+import { NxJsonConfiguration } from '../../config/nx-json';
 export interface InitArgs {
     interactive: boolean;
     nxCloud?: boolean;
     useDotNxInstallation?: boolean;
     integrated?: boolean;
 }
+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<{
+    plugins: string[];
+    updatePackageScripts: boolean;
+}>;