nx 19.6.0-beta.3 → 19.6.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.6.0-beta.3",
+  "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.3"
+    "@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.3",
-    "@nx/nx-darwin-arm64": "19.6.0-beta.3",
-    "@nx/nx-linux-x64-gnu": "19.6.0-beta.3",
-    "@nx/nx-linux-x64-musl": "19.6.0-beta.3",
-    "@nx/nx-win32-x64-msvc": "19.6.0-beta.3",
-    "@nx/nx-linux-arm64-gnu": "19.6.0-beta.3",
-    "@nx/nx-linux-arm64-musl": "19.6.0-beta.3",
-    "@nx/nx-linux-arm-gnueabihf": "19.6.0-beta.3",
-    "@nx/nx-win32-arm64-msvc": "19.6.0-beta.3",
-    "@nx/nx-freebsd-x64": "19.6.0-beta.3"
+    "@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/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: [

package/src/command-line/nx-commands.js

@@ -10,21 +10,22 @@ const command_object_4 = require("./graph/command-object");
 const command_object_5 = require("./exec/command-object");
 const command_object_6 = require("./format/command-object");
 const command_object_7 = require("./generate/command-object");
-const command_object_8 = require("./init/command-object");
-const command_object_9 = require("./list/command-object");
-const command_object_10 = require("./migrate/command-object");
-const command_object_11 = require("./new/command-object");
-const command_object_12 = require("./repair/command-object");
-const command_object_13 = require("./report/command-object");
-const command_object_14 = require("./run/command-object");
-const command_object_15 = require("./run-many/command-object");
-const command_object_16 = require("./show/command-object");
-const command_object_17 = require("./watch/command-object");
-const command_object_18 = require("./reset/command-object");
-const command_object_19 = require("./release/command-object");
-const command_object_20 = require("./add/command-object");
+const command_object_8 = require("./import/command-object");
+const command_object_9 = require("./init/command-object");
+const command_object_10 = require("./list/command-object");
+const command_object_11 = require("./migrate/command-object");
+const command_object_12 = require("./new/command-object");
+const command_object_13 = require("./repair/command-object");
+const command_object_14 = require("./report/command-object");
+const command_object_15 = require("./run/command-object");
+const command_object_16 = require("./run-many/command-object");
+const command_object_17 = require("./show/command-object");
+const command_object_18 = require("./watch/command-object");
+const command_object_19 = require("./reset/command-object");
+const command_object_20 = require("./release/command-object");
+const command_object_21 = require("./add/command-object");
 const command_objects_1 = require("./deprecated/command-objects");
-const command_object_21 = require("./sync/command-object");
+const command_object_22 = require("./sync/command-object");
 // Ensure that the output takes up the available width of the terminal.
 yargs.wrap(yargs.terminalWidth());
 exports.parserConfiguration = {
@@ -41,7 +42,7 @@ exports.commandsObject = yargs
     .parserConfiguration(exports.parserConfiguration)
     .usage(chalk.bold('Smart Monorepos · Fast CI'))
     .demandCommand(1, '')
-    .command(command_object_20.yargsAddCommand)
+    .command(command_object_21.yargsAddCommand)
     .command(command_object_1.yargsAffectedBuildCommand)
     .command(command_object_1.yargsAffectedCommand)
     .command(command_object_1.yargsAffectedE2ECommand)
@@ -55,24 +56,25 @@ exports.commandsObject = yargs
     .command(command_object_6.yargsFormatCheckCommand)
     .command(command_object_6.yargsFormatWriteCommand)
     .command(command_object_7.yargsGenerateCommand)
-    .command(command_object_8.yargsInitCommand)
-    .command(command_object_10.yargsInternalMigrateCommand)
-    .command(command_object_9.yargsListCommand)
-    .command(command_object_10.yargsMigrateCommand)
-    .command(command_object_11.yargsNewCommand)
+    .command(command_object_8.yargsImportCommand)
+    .command(command_object_9.yargsInitCommand)
+    .command(command_object_11.yargsInternalMigrateCommand)
+    .command(command_object_10.yargsListCommand)
+    .command(command_object_11.yargsMigrateCommand)
+    .command(command_object_12.yargsNewCommand)
     .command(command_objects_1.yargsPrintAffectedCommand)
-    .command(command_object_19.yargsReleaseCommand)
-    .command(command_object_12.yargsRepairCommand)
-    .command(command_object_13.yargsReportCommand)
-    .command(command_object_18.yargsResetCommand)
-    .command(command_object_14.yargsRunCommand)
-    .command(command_object_15.yargsRunManyCommand)
-    .command(command_object_16.yargsShowCommand)
-    .command(command_object_21.yargsSyncCommand)
-    .command(command_object_21.yargsSyncCheckCommand)
+    .command(command_object_20.yargsReleaseCommand)
+    .command(command_object_13.yargsRepairCommand)
+    .command(command_object_14.yargsReportCommand)
+    .command(command_object_19.yargsResetCommand)
+    .command(command_object_15.yargsRunCommand)
+    .command(command_object_16.yargsRunManyCommand)
+    .command(command_object_17.yargsShowCommand)
+    .command(command_object_22.yargsSyncCommand)
+    .command(command_object_22.yargsSyncCheckCommand)
     .command(command_object_2.yargsViewLogsCommand)
-    .command(command_object_17.yargsWatchCommand)
-    .command(command_object_14.yargsNxInfixCommand)
+    .command(command_object_18.yargsWatchCommand)
+    .command(command_object_15.yargsNxInfixCommand)
     .scriptName('nx')
     .help()
     // NOTE: we handle --version in nx.ts, this just tells yargs that the option exists

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -29,7 +29,7 @@ export declare function withTargetAndConfigurationOption(yargs: Argv, demandOpti
 export declare function withConfiguration(yargs: Argv): Argv<{
     configuration: string;
 }>;
-export declare function withVerbose(yargs: Argv): Argv<{
+export declare function withVerbose<T>(yargs: Argv<T>): Argv<T & {
     verbose: boolean;
 }>;
 export declare function withBatch(yargs: Argv): any;

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

@@ -32,6 +32,7 @@ export interface NxArgs {
     excludeTaskDependencies?: boolean;
 }
 export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
+export declare function getBaseRef(nxJson: NxJsonConfiguration): string;
 export declare function splitArgsIntoNxArgsAndOverrides(args: {
     [k: string]: any;
 }, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOverrides = createOverrides;
+exports.getBaseRef = getBaseRef;
 exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
 exports.readParallelFromArgsAndEnv = readParallelFromArgsAndEnv;
 exports.parseFiles = parseFiles;
@@ -24,6 +25,9 @@ function createOverrides(__overrides_unparsed__ = []) {
     overrides.__overrides_unparsed__ = __overrides_unparsed__;
     return overrides;
 }
+function getBaseRef(nxJson) {
+    return nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+}
 function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings: true }, nxJson) {
     // this is to lerna case when this function is invoked imperatively
     if (args['target'] && !args['targets']) {
@@ -88,8 +92,7 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
             }
         }
         if (!nxArgs.base) {
-            nxArgs.base =
-                nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+            nxArgs.base = getBaseRef(nxJson);
             // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
             if (options.printWarnings &&
                 !nxArgs.head &&

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

@@ -1,3 +1,38 @@
+import { ExecSyncOptions } from 'child_process';
+export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+    originName: string;
+}): Promise<GitRepository>;
+export declare class GitRepository {
+    private directory;
+    root: string;
+    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: {
+        new: boolean;
+        base: string;
+    }): Promise<string>;
+    move(path: string, destination: string): Promise<string>;
+    push(ref: string, remoteName: string): Promise<string>;
+    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>;
+}
+/**
+ * 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;
 export declare function getGithubSlugOrNull(): string | null;
 export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
 export declare function commitChanges(commitMessage: string, directory?: string): string | null;

package/src/utils/git-utils.js

@@ -1,11 +1,122 @@
 "use strict";
 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');
+function execAsync(command, execOptions) {
+    return new Promise((res, rej) => {
+        (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
+            if (err) {
+                return rej(err);
+            }
+            res(stdout);
+        });
+    });
+}
+async function cloneFromUpstream(url, destination, { originName } = { originName: 'origin' }) {
+    await execAsync(`git clone ${url} ${destination} --depth 1 --origin ${originName}`, {
+        cwd: (0, path_1.dirname)(destination),
+    });
+    return new GitRepository(destination);
+}
+class GitRepository {
+    constructor(directory) {
+        this.directory = directory;
+        this.root = this.getGitRootPath(this.directory);
+    }
+    getGitRootPath(cwd) {
+        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd,
+        })
+            .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 showStat() {
+        return await this.execAsync(`git show --stat`);
+    }
+    async listBranches() {
+        return (await this.execAsync(`git ls-remote --heads --quiet`))
+            .trim()
+            .split('\n')
+            .map((s) => s
+            .trim()
+            .substring(s.indexOf('\t') + 1)
+            .replace('refs/heads/', ''));
+    }
+    async getGitFiles(path) {
+        return (await this.execAsync(`git ls-files ${path}`))
+            .trim()
+            .split('\n')
+            .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`);
+    }
+    async mergeUnrelatedHistories(ref, message) {
+        return this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+    }
+    async fetch(remote, ref) {
+        return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+    }
+    async checkout(branch, opts) {
+        return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+    }
+    async move(path, destination) {
+        return this.execAsync(`git mv ${path} ${destination}`);
+    }
+    async push(ref, remoteName) {
+        return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+    }
+    async commit(message) {
+        return this.execAsync(`git commit -am "${message}"`);
+    }
+    async amendCommit() {
+        return this.execAsync(`git commit --amend -a --no-edit`);
+    }
+    deleteGitRemote(name) {
+        return this.execAsync(`git remote rm ${name}`);
+    }
+    deleteBranch(branch) {
+        return this.execAsync(`git branch -D ${branch}`);
+    }
+    addGitRemote(name, url) {
+        return this.execAsync(`git remote add ${name} ${url}`);
+    }
+}
+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);
+}
 function getGithubSlugOrNull() {
     try {
         const gitRemote = (0, child_process_1.execSync)('git remote -v', {

package/src/utils/package-manager.js

@@ -49,7 +49,7 @@ function isWorkspacesEnabled(packageManager = detectPackageManager(), root = wor
     if (packageManager === 'pnpm') {
         return (0, fs_1.existsSync)((0, path_1.join)(root, 'pnpm-workspace.yaml'));
     }
-    // yarn and pnpm both use the same 'workspaces' property in package.json
+    // yarn and npm both use the same 'workspaces' property in package.json
     const packageJson = (0, file_utils_1.readPackageJson)();
     return !!packageJson?.workspaces;
 }

package/src/utils/squash.d.ts

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

package/src/utils/squash.js

@@ -0,0 +1,12 @@
+"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);