nx 19.7.0-beta.2 → 19.7.0-beta.4

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

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

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

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

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

@@ -4,99 +4,45 @@ exports.prepareSourceRepo = prepareSourceRepo;
 const createSpinner = require("ora");
 const path_1 = require("path");
 const promises_1 = require("node:fs/promises");
-async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl, originName) {
+async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl) {
     const spinner = createSpinner().start(`Fetching ${ref} from ${sourceRemoteUrl}`);
-    await gitClient.addFetchRemote(originName, ref);
-    await gitClient.fetch(originName, ref);
-    spinner.succeed(`Fetched ${ref} from ${sourceRemoteUrl}`);
-    spinner.start(`Checking out a temporary branch, ${tempImportBranch} based on ${ref}`);
-    await gitClient.checkout(tempImportBranch, {
-        new: true,
-        base: `${originName}/${ref}`,
-    });
-    spinner.succeed(`Created a ${tempImportBranch} branch based on ${ref}`);
     const relativeSourceDir = (0, path_1.relative)(gitClient.root, (0, path_1.join)(gitClient.root, source));
-    const destinationInSource = (0, path_1.join)(gitClient.root, relativeDestination);
-    spinner.start(`Moving files and git history to ${destinationInSource}`);
-    if (relativeSourceDir === '') {
-        const files = await gitClient.getGitFiles('.');
-        try {
-            await (0, promises_1.rm)(destinationInSource, {
-                recursive: true,
-            });
-        }
-        catch { }
-        await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-        const gitignores = new Set();
-        for (const file of files) {
-            if ((0, path_1.basename)(file) === '.gitignore') {
-                gitignores.add(file);
-                continue;
-            }
-            spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
-            const newPath = (0, path_1.join)(destinationInSource, file);
-            await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
-            try {
-                await gitClient.move(file, newPath);
-            }
-            catch {
-                await wait(100);
-                await gitClient.move(file, newPath);
-            }
-        }
-        await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-        for (const gitignore of gitignores) {
-            await gitClient.move(gitignore, (0, path_1.join)(destinationInSource, gitignore));
+    if (relativeSourceDir !== '') {
+        if (await gitClient.hasFilterRepoInstalled()) {
+            spinner.start(`Filtering git history to only include files in ${relativeSourceDir}`);
+            await gitClient.filterRepo(relativeSourceDir);
         }
-        await gitClient.amendCommit();
-        for (const gitignore of gitignores) {
-            await (0, promises_1.copyFile)((0, path_1.join)(destinationInSource, gitignore), (0, path_1.join)(gitClient.root, gitignore));
+        else {
+            spinner.start(`Filtering git history to only include files in ${relativeSourceDir} (this might take a few minutes -- install git-filter-repo for faster performance)`);
+            await gitClient.filterBranch(relativeSourceDir, tempImportBranch);
         }
+        spinner.succeed(`Filtered git history to only include files in ${relativeSourceDir}`);
     }
-    else {
-        let needsSquash = false;
-        const needsMove = destinationInSource !== (0, path_1.join)(gitClient.root, source);
-        if (needsMove) {
-            try {
-                await (0, promises_1.rm)(destinationInSource, {
-                    recursive: true,
-                });
-                await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-                needsSquash = true;
-            }
-            catch { }
-            await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-        }
-        const files = await gitClient.getGitFiles('.');
-        for (const file of files) {
-            if (file === '.gitignore') {
-                continue;
-            }
-            spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
-            if (!(0, path_1.relative)(source, file).startsWith('..')) {
-                if (needsMove) {
-                    const newPath = (0, path_1.join)(destinationInSource, file);
-                    await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
-                    try {
-                        await gitClient.move(file, newPath);
-                    }
-                    catch {
-                        await wait(100);
-                        await gitClient.move(file, newPath);
-                    }
-                }
-            }
-            else {
-                await (0, promises_1.rm)((0, path_1.join)(gitClient.root, file), {
-                    recursive: true,
-                });
-            }
+    const destinationInSource = (0, path_1.join)(gitClient.root, relativeDestination);
+    spinner.start(`Moving files and git history to ${destinationInSource}`);
+    // The result of filter-branch will contain only the files in the subdirectory at its root.
+    const files = await gitClient.getGitFiles('.');
+    try {
+        await (0, promises_1.rm)(destinationInSource, {
+            recursive: true,
+        });
+    }
+    catch { }
+    await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
+    for (const file of files) {
+        spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
+        const newPath = (0, path_1.join)(destinationInSource, file);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
+        try {
+            await gitClient.move(file, newPath);
         }
-        await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-        if (needsSquash) {
-            await gitClient.squashLastTwoCommits();
+        catch {
+            await wait(100);
+            await gitClient.move(file, newPath);
         }
     }
+    await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
+    await gitClient.amendCommit();
     spinner.succeed(`${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`);
 }
 function wait(ms) {

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

@@ -6,7 +6,7 @@ exports.yargsListCommand = {
     describe: 'Lists installed plugins, capabilities of installed plugins and other available plugins.',
     builder: (yargs) => yargs.positional('plugin', {
         type: 'string',
-        description: 'The name of an installed plugin to query',
+        description: 'The name of an installed plugin to query.',
     }),
     handler: async (args) => {
         await (await Promise.resolve().then(() => require('./list'))).listHandler(args);

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

@@ -4,7 +4,7 @@ exports.yargsLoginCommand = void 0;
 const shared_options_1 = require("../../command-line/yargs-utils/shared-options");
 exports.yargsLoginCommand = {
     command: 'login [nxCloudUrl]',
-    describe: 'Login to Nx Cloud',
+    describe: false,
     builder: (yargs) => (0, shared_options_1.withVerbose)(yargs.positional('nxCloudUrl', {
         describe: 'The Nx Cloud URL of the instance you are trying to connect to. If no positional argument is provided, this command will connect to https://cloud.nx.app.',
         type: 'string',

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

@@ -4,7 +4,7 @@ exports.yargsLogoutCommand = void 0;
 const shared_options_1 = require("../../command-line/yargs-utils/shared-options");
 exports.yargsLogoutCommand = {
     command: 'logout',
-    describe: 'Logout from Nx Cloud',
+    describe: false,
     builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
     handler: async (args) => {
         process.exit(await (await Promise.resolve().then(() => require('./logout'))).logoutHandler(args));

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

@@ -30,44 +30,44 @@ function withMigrationOptions(yargs) {
     const defaultCommitPrefix = 'chore: [nx migration] ';
     return (0, shared_options_1.withVerbose)(yargs)
         .positional('packageAndVersion', {
-        describe: `The target package and version (e.g, @nx/workspace@16.0.0)`,
+        describe: `The target package and version (e.g, @nx/workspace@16.0.0).`,
         type: 'string',
     })
         .option('runMigrations', {
-        describe: `Execute migrations from a file (when the file isn't provided, execute migrations from migrations.json)`,
+        describe: `Execute migrations from a file (when the file isn't provided, execute migrations from migrations.json).`,
         type: 'string',
     })
         .option('ifExists', {
-        describe: `Run migrations only if the migrations file exists, if not continues successfully`,
+        describe: `Run migrations only if the migrations file exists, if not continues successfully.`,
         type: 'boolean',
         default: false,
     })
         .option('from', {
-        describe: 'Use the provided versions for packages instead of the ones installed in node_modules (e.g., --from="@nx/react@16.0.0,@nx/js@16.0.0")',
+        describe: 'Use the provided versions for packages instead of the ones installed in node_modules (e.g., --from="@nx/react@16.0.0,@nx/js@16.0.0").',
         type: 'string',
     })
         .option('to', {
-        describe: 'Use the provided versions for packages instead of the ones calculated by the migrator (e.g., --to="@nx/react@16.0.0,@nx/js@16.0.0")',
+        describe: 'Use the provided versions for packages instead of the ones calculated by the migrator (e.g., --to="@nx/react@16.0.0,@nx/js@16.0.0").',
         type: 'string',
     })
         .option('createCommits', {
-        describe: 'Automatically create a git commit after each migration runs',
+        describe: 'Automatically create a git commit after each migration runs.',
         type: 'boolean',
         alias: ['C'],
         default: false,
     })
         .option('commitPrefix', {
-        describe: 'Commit prefix to apply to the commit for each migration, when --create-commits is enabled',
+        describe: 'Commit prefix to apply to the commit for each migration, when --create-commits is enabled.',
         type: 'string',
         default: defaultCommitPrefix,
     })
         .option('interactive', {
-        describe: 'Enable prompts to confirm whether to collect optional package updates and migrations',
+        describe: 'Enable prompts to confirm whether to collect optional package updates and migrations.',
         type: 'boolean',
         default: false,
     })
         .option('excludeAppliedMigrations', {
-        describe: 'Exclude migrations that should have been applied on previous updates. To be used with --from',
+        describe: 'Exclude migrations that should have been applied on previous updates. To be used with --from.',
         type: 'boolean',
         default: false,
     })

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

@@ -13,12 +13,12 @@ exports.yargsNewCommand = {
 function withNewOptions(yargs) {
     return yargs
         .option('nxWorkspaceRoot', {
-        describe: 'The folder where the new workspace is going to be created',
+        describe: 'The folder where the new workspace is going to be created.',
         type: 'string',
         required: true,
     })
         .option('interactive', {
-        describe: 'When false disables interactive input prompts for options',
+        describe: 'When false disables interactive input prompts for options.',
         type: 'boolean',
         default: true,
     });

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

@@ -81,7 +81,7 @@ function createAPI(overrideReleaseConfig) {
             process.exit(1);
         }
         const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
         if (args.deleteVersionPlans === undefined) {
             // default to deleting version plans in this command instead of after versioning
             args.deleteVersionPlans = true;
@@ -146,6 +146,15 @@ function createAPI(overrideReleaseConfig) {
                     workspaceChangelogChanges = versionPlans
                         .flatMap((vp) => {
                         const releaseType = versionPlanSemverReleaseTypeToChangelogType(vp.groupVersionBump);
+                        let githubReferences = [];
+                        let author = undefined;
+                        const parsedCommit = vp.commit
+                            ? (0, git_1.parseGitCommit)(vp.commit, true)
+                            : null;
+                        if (parsedCommit) {
+                            githubReferences = parsedCommit.references;
+                            author = parsedCommit.author;
+                        }
                         const changes = !vp.triggeredByProjects
                             ? {
                                 type: releaseType.type,
@@ -153,7 +162,8 @@ function createAPI(overrideReleaseConfig) {
                                 description: vp.message,
                                 body: '',
                                 isBreaking: releaseType.isBreaking,
-                                githubReferences: [],
+                                githubReferences,
+                                author,
                                 affectedProjects: '*',
                             }
                             : vp.triggeredByProjects.map((project) => {
@@ -162,9 +172,9 @@ function createAPI(overrideReleaseConfig) {
                                     scope: project,
                                     description: vp.message,
                                     body: '',
-                                    // TODO: what about github references?
                                     isBreaking: releaseType.isBreaking,
-                                    githubReferences: [],
+                                    githubReferences,
+                                    author,
                                     affectedProjects: [project],
                                 };
                             });
@@ -301,6 +311,15 @@ function createAPI(overrideReleaseConfig) {
                                 return null;
                             }
                             const releaseType = versionPlanSemverReleaseTypeToChangelogType(bumpForProject);
+                            let githubReferences = [];
+                            let author = undefined;
+                            const parsedCommit = vp.commit
+                                ? (0, git_1.parseGitCommit)(vp.commit, true)
+                                : null;
+                            if (parsedCommit) {
+                                githubReferences = parsedCommit.references;
+                                author = parsedCommit.author;
+                            }
                             return {
                                 type: releaseType.type,
                                 scope: project.name,
@@ -308,8 +327,8 @@ function createAPI(overrideReleaseConfig) {
                                 body: '',
                                 isBreaking: releaseType.isBreaking,
                                 affectedProjects: Object.keys(vp.projectVersionBumps),
-                                // TODO: can we include github references when using version plans?
-                                githubReferences: [],
+                                githubReferences,
+                                author,
                             };
                         })
                             .filter(Boolean);
@@ -397,6 +416,15 @@ function createAPI(overrideReleaseConfig) {
                     changes = releaseGroup.resolvedVersionPlans
                         .flatMap((vp) => {
                         const releaseType = versionPlanSemverReleaseTypeToChangelogType(vp.groupVersionBump);
+                        let githubReferences = [];
+                        let author = undefined;
+                        const parsedCommit = vp.commit
+                            ? (0, git_1.parseGitCommit)(vp.commit, true)
+                            : null;
+                        if (parsedCommit) {
+                            githubReferences = parsedCommit.references;
+                            author = parsedCommit.author;
+                        }
                         const changes = !vp.triggeredByProjects
                             ? {
                                 type: releaseType.type,
@@ -404,7 +432,8 @@ function createAPI(overrideReleaseConfig) {
                                 description: vp.message,
                                 body: '',
                                 isBreaking: releaseType.isBreaking,
-                                githubReferences: [],
+                                githubReferences,
+                                author,
                                 affectedProjects: '*',
                             }
                             : vp.triggeredByProjects.map((project) => {
@@ -413,9 +442,9 @@ function createAPI(overrideReleaseConfig) {
                                     scope: project,
                                     description: vp.message,
                                     body: '',
-                                    // TODO: what about github references?
                                     isBreaking: releaseType.isBreaking,
-                                    githubReferences: [],
+                                    githubReferences,
+                                    author,
                                     affectedProjects: [project],
                                 };
                             });
@@ -579,12 +608,22 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     }
     const changedFiles = changes.map((f) => f.path);
     let deletedFiles = [];
-    if (args.deleteVersionPlans && !args.dryRun) {
+    if (args.deleteVersionPlans) {
         const planFiles = new Set();
         releaseGroups.forEach((group) => {
             if (group.resolvedVersionPlans) {
                 group.resolvedVersionPlans.forEach((plan) => {
-                    (0, fs_extra_1.removeSync)(plan.absolutePath);
+                    if (!args.dryRun) {
+                        (0, fs_extra_1.removeSync)(plan.absolutePath);
+                        if (args.verbose) {
+                            console.log(`Removing ${plan.relativePath}`);
+                        }
+                    }
+                    else {
+                        if (args.verbose) {
+                            console.log(`Would remove ${plan.relativePath}, but --dry-run was set`);
+                        }
+                    }
                     planFiles.add(plan.relativePath);
                 });
             }
@@ -801,7 +840,9 @@ async function generateChangelogForProjects({ tree, args, projectGraph, changes,
                 })
                 : false,
             changelogRenderOptions: config.renderOptions,
-            conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
+            conventionalCommitsConfig: releaseGroup.versionPlans
+                ? null
+                : nxReleaseConfig.conventionalCommits,
             dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
         });
         /**

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

@@ -39,11 +39,13 @@ export type PublishOptions = NxReleaseArgs & Partial<RunManyOptions> & {
 } & FirstReleaseArgs & {
     registry?: string;
     tag?: string;
+    access?: string;
     otp?: number;
 };
 export type PlanOptions = NxReleaseArgs & {
     bump?: string;
     message?: string;
+    onlyTouched?: boolean;
 };
 export type PlanCheckOptions = BaseNxReleaseArgs & {
     base?: string;