nx 19.6.0-beta.2 → 19.6.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.6.0-beta.2",
+  "version": "19.6.0-beta.4",
   "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-beta.2"
+    "@nrwl/tao": "19.6.0-beta.4"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.6.0-beta.2",
-    "@nx/nx-darwin-arm64": "19.6.0-beta.2",
-    "@nx/nx-linux-x64-gnu": "19.6.0-beta.2",
-    "@nx/nx-linux-x64-musl": "19.6.0-beta.2",
-    "@nx/nx-win32-x64-msvc": "19.6.0-beta.2",
-    "@nx/nx-linux-arm64-gnu": "19.6.0-beta.2",
-    "@nx/nx-linux-arm64-musl": "19.6.0-beta.2",
-    "@nx/nx-linux-arm-gnueabihf": "19.6.0-beta.2",
-    "@nx/nx-win32-arm64-msvc": "19.6.0-beta.2",
-    "@nx/nx-freebsd-x64": "19.6.0-beta.2"
+    "@nx/nx-darwin-x64": "19.6.0-beta.4",
+    "@nx/nx-darwin-arm64": "19.6.0-beta.4",
+    "@nx/nx-linux-x64-gnu": "19.6.0-beta.4",
+    "@nx/nx-linux-x64-musl": "19.6.0-beta.4",
+    "@nx/nx-win32-x64-msvc": "19.6.0-beta.4",
+    "@nx/nx-linux-arm64-gnu": "19.6.0-beta.4",
+    "@nx/nx-linux-arm64-musl": "19.6.0-beta.4",
+    "@nx/nx-linux-arm-gnueabihf": "19.6.0-beta.4",
+    "@nx/nx-win32-arm64-msvc": "19.6.0-beta.4",
+    "@nx/nx-freebsd-x64": "19.6.0-beta.4"
   },
   "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,8 +246,15 @@
           "$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"
@@ -698,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/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;
+}>;

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPlugins = installPlugins;
 exports.initHandler = initHandler;
+exports.detectPlugins = detectPlugins;
 const fs_1 = require("fs");
 const semver_1 = require("semver");
 const output_1 = require("../../utils/output");
@@ -17,6 +19,22 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
 const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
 const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const nx_json_1 = require("../../config/nx-json");
+const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
+function installPlugins(repoRoot, plugins, pmc, updatePackageScripts) {
+    if (plugins.length === 0) {
+        return;
+    }
+    (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
+    (0, utils_1.runInstall)(repoRoot, pmc);
+    output_1.output.log({ title: '🔨 Configuring plugins' });
+    for (const plugin of plugins) {
+        (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${updatePackageScripts ? '--updatePackageScripts' : ''} --no-interactive`, {
+            stdio: [0, 1, 2],
+            cwd: repoRoot,
+        });
+    }
+}
 async function initHandler(options) {
     process.env.NX_RUNNING_NX_INIT = 'true';
     const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
@@ -31,7 +49,8 @@ async function initHandler(options) {
             console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx.bat --help`');
         }
         (0, add_nx_scripts_1.generateDotNxSetup)(version);
-        const { plugins } = await detectPlugins();
+        const nxJson = (0, nx_json_1.readNxJson)(process.cwd());
+        const { plugins } = await detectPlugins(nxJson, options.interactive);
         plugins.forEach((plugin) => {
             (0, child_process_1.runNxSync)(`add ${plugin}`, {
                 stdio: 'inherit',
@@ -52,8 +71,6 @@ async function initHandler(options) {
         });
         return;
     }
-    output_1.output.log({ title: '🧐 Checking dependencies' });
-    const { plugins, updatePackageScripts } = await detectPlugins();
     const packageJson = (0, fileutils_1.readJsonFile)('package.json');
     if ((0, utils_1.isMonorepo)(packageJson)) {
         await (0, add_nx_to_monorepo_1.addNxToMonorepo)({
@@ -76,18 +93,11 @@ async function initHandler(options) {
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
     (0, utils_1.createNxJsonFile)(repoRoot, [], [], {});
     (0, utils_1.updateGitIgnore)(repoRoot);
-    (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
+    const nxJson = (0, nx_json_1.readNxJson)(repoRoot);
+    output_1.output.log({ title: '🧐 Checking dependencies' });
+    const { plugins, updatePackageScripts } = await detectPlugins(nxJson, options.interactive);
     output_1.output.log({ title: '📦 Installing Nx' });
-    (0, utils_1.runInstall)(repoRoot, pmc);
-    if (plugins.length > 0) {
-        output_1.output.log({ title: '🔨 Configuring plugins' });
-        for (const plugin of plugins) {
-            (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${updatePackageScripts ? '--updatePackageScripts' : ''} --no-interactive`, {
-                stdio: [0, 1, 2],
-                cwd: repoRoot,
-            });
-        }
-    }
+    installPlugins(repoRoot, plugins, pmc, updatePackageScripts);
     if (useNxCloud) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
         await (0, utils_1.initCloud)('nx-init');
@@ -117,8 +127,12 @@ const npmPackageToPluginMap = {
     'react-native': '@nx/react-native',
     '@remix-run/dev': '@nx/remix',
 };
-async function detectPlugins() {
+async function detectPlugins(nxJson, interactive) {
     let files = ['package.json'].concat(await (0, workspace_context_1.globWithWorkspaceContext)(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);
+    }));
     const detectedPlugins = new Set();
     for (const file of files) {
         if (!(0, fs_1.existsSync)(file))
@@ -144,6 +158,12 @@ async function detectPlugins() {
     if ((0, fs_1.existsSync)('gradlew') || (0, fs_1.existsSync)('gradlew.bat')) {
         detectedPlugins.add('@nx/gradle');
     }
+    // Remove existing plugins
+    for (const plugin of detectedPlugins) {
+        if (currentPlugins.has(plugin)) {
+            detectedPlugins.delete(plugin);
+        }
+    }
     const plugins = Array.from(detectedPlugins);
     if (plugins.length === 0) {
         return {
@@ -151,6 +171,19 @@ async function detectPlugins() {
             updatePackageScripts: false,
         };
     }
+    if (!interactive) {
+        output_1.output.log({
+            title: `Recommended Plugins:`,
+            bodyLines: [
+                `Adding these Nx plugins to integrate with the tools used in your workspace:`,
+                ...plugins.map((p) => `- ${p}`),
+            ],
+        });
+        return {
+            plugins,
+            updatePackageScripts: true,
+        };
+    }
     output_1.output.log({
         title: `Recommended Plugins:`,
         bodyLines: [