nx 23.0.0-beta.21 → 23.0.0-beta.23

package/dist/src/command-line/release/changelog/version-plan-filtering.js

@@ -89,7 +89,7 @@ async function getFilesAddedInCommitRange(fromSHA, toSHA, isVerbose) {
  * Resolves the "from SHA" for changelog purposes.
  * This determines the starting point for changelog generation and optional version plan filtering.
  */
-async function resolveChangelogFromSHA({ fromRef, tagPattern, tagPatternValues, checkAllBranchesWhen, preid, requireSemver, strictPreid, useAutomaticFromRef, resolveRepositoryTags, }) {
+async function resolveChangelogFromSHA({ fromRef, tagPattern, tagPatternValues, checkAllBranchesWhen, preid, requireSemver, strictPreid, useAutomaticFromRef, resolveRepositoryTags, projectRoot, }) {
     // If user provided a from ref, resolve it to a SHA
     if (fromRef) {
         return await (0, git_1.getCommitHash)(fromRef);
@@ -104,9 +104,13 @@ async function resolveChangelogFromSHA({ fromRef, tagPattern, tagPatternValues,
     if (latestTag?.tag) {
         return await (0, git_1.getCommitHash)(latestTag.tag);
     }
-    // Finally, if automatic from ref is enabled, use the first commit as a fallback
+    // Finally, if automatic from ref is enabled, use the first commit as a fallback.
+    // When a projectRoot is provided, scope the fallback to the project's first commit
+    // to avoid scanning the entire repo history for projects added after the repo was created.
     if (useAutomaticFromRef) {
-        return await (0, git_1.getFirstGitCommit)();
+        return projectRoot
+            ? await (0, git_1.getFirstProjectCommit)(projectRoot)
+            : await (0, git_1.getFirstGitCommit)();
     }
     return null;
 }

package/dist/src/command-line/release/changelog.d.ts

@@ -1,5 +1,6 @@
 import { NxReleaseConfiguration } from '../../config/nx-json';
 import { ChangelogOptions } from './command-object';
+import { NxReleaseConfig } from './config/config';
 import { ReleaseVersion } from './utils/shared';
 export interface NxReleaseChangelogResult {
     workspaceChangelog?: {
@@ -17,5 +18,11 @@ export interface NxReleaseChangelogResult {
 }
 export type { ChangelogChange } from './changelog/version-plan-utils';
 export type PostGitTask = (latestCommit: string) => Promise<void>;
+/**
+ * Determines whether a changelog configuration will actually produce any output.
+ * A changelog config is effectively enabled when it would produce a changelog file
+ * or create a remote release.
+ */
+export declare function isChangelogEffectivelyEnabled(config?: NxReleaseConfig['changelog']['workspaceChangelog'] | NxReleaseConfig['groups'][string]['changelog']): boolean | undefined;
 export declare const releaseChangelogCLIHandler: (args: ChangelogOptions) => Promise<number>;
 export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig: boolean): (args: ChangelogOptions) => Promise<NxReleaseChangelogResult>;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseChangelogCLIHandler = void 0;
+exports.isChangelogEffectivelyEnabled = isChangelogEffectivelyEnabled;
 exports.createAPI = createAPI;
 const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
@@ -35,6 +36,17 @@ const resolve_changelog_renderer_1 = require("./utils/resolve-changelog-renderer
 const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
 const shared_1 = require("./utils/shared");
 const version_plan_utils_2 = require("./utils/version-plan-utils");
+/**
+ * Determines whether a changelog configuration will actually produce any output.
+ * A changelog config is effectively enabled when it would produce a changelog file
+ * or create a remote release.
+ */
+function isChangelogEffectivelyEnabled(config) {
+    if (!config) {
+        return false;
+    }
+    return config.file !== false || config.createRelease !== false;
+}
 const releaseChangelogCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({}, false)(args));
 exports.releaseChangelogCLIHandler = releaseChangelogCLIHandler;
 function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
@@ -100,13 +112,8 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG !== 'true') {
             output_1.output.note(releaseGraph.filterLog);
         }
-        let rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        if (args.deleteVersionPlans === undefined) {
-            // default to deleting version plans in this command instead of after versioning
-            args.deleteVersionPlans = true;
-        }
-        const changelogGenerationEnabled = !!nxReleaseConfig.changelog.workspaceChangelog ||
-            Object.values(nxReleaseConfig.groups).some((g) => g.changelog);
+        const changelogGenerationEnabled = isChangelogEffectivelyEnabled(nxReleaseConfig.changelog.workspaceChangelog) ||
+            Object.values(nxReleaseConfig.groups).some((g) => isChangelogEffectivelyEnabled(g.changelog));
         if (!changelogGenerationEnabled) {
             output_1.output.warn({
                 title: `Changelogs are disabled. No changelog entries will be generated`,
@@ -116,6 +123,11 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             });
             return {};
         }
+        let rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        if (args.deleteVersionPlans === undefined) {
+            // default to deleting version plans in this command instead of after versioning
+            args.deleteVersionPlans = true;
+        }
         const useAutomaticFromRef = nxReleaseConfig.changelog?.automaticFromRef || args.firstRelease;
         /**
          * For determining the versions to use within changelog files, there are a few different possibilities:
@@ -214,7 +226,7 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             fromSHACache.set('workspace', fromSHA);
         }
         // Helper function to get cached from SHA or resolve and cache it
-        const getCachedFromSHA = async (cacheKey, pattern, templateValues, preid, checkAllBranchesWhen, requireSemver, strictPreid) => {
+        const getCachedFromSHA = async (cacheKey, pattern, templateValues, preid, checkAllBranchesWhen, requireSemver, strictPreid, projectRoot) => {
             if (fromSHACache.has(cacheKey)) {
                 return fromSHACache.get(cacheKey);
             }
@@ -228,6 +240,7 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
                 requireSemver,
                 strictPreid,
                 useAutomaticFromRef,
+                projectRoot,
             });
             fromSHACache.set(cacheKey, sha);
             return sha;
@@ -296,7 +309,7 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
                         const fromSHA = await getCachedFromSHA(projectCacheKey, releaseGroup.releaseTag.pattern, {
                             projectName: project.name,
                             releaseGroupName: releaseGroup.name,
-                        }, projectsPreid[project.name], releaseGroup.releaseTag.checkAllBranchesWhen, releaseGroup.releaseTag.requireSemver, releaseGroup.releaseTag.strictPreid);
+                        }, projectsPreid[project.name], releaseGroup.releaseTag.checkAllBranchesWhen, releaseGroup.releaseTag.requireSemver, releaseGroup.releaseTag.strictPreid, project.data.root);
                         let commits;
                         let fromRef = fromSHA;
                         if (!fromRef && useAutomaticFromRef) {

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

@@ -84,19 +84,6 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
         });
         // Suppress the filter log for the changelog command as it would have already been printed by the version command
         process.env.NX_RELEASE_INTERNAL_SUPPRESS_FILTER_LOG = 'true';
-        const changelogResult = await releaseChangelog({
-            ...args,
-            // Re-use existing release graph
-            releaseGraph,
-            versionData: projectsVersionData,
-            version: workspaceVersion,
-            stageChanges: shouldStage,
-            gitCommit: false,
-            gitTag: false,
-            gitPush: false,
-            createRelease: false,
-            deleteVersionPlans: false,
-        });
         await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGraph.releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
         // Validate version plans against the filter after resolution
         const versionPlanValidationError = (0, version_plan_utils_1.validateResolvedVersionPlansAgainstFilter)(releaseGraph.releaseGroups, releaseGraph.releaseGroupToFilteredProjects);
@@ -150,6 +137,27 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
                 verbose: args.verbose,
             });
         }
+        // Check if any changelog generation is actually enabled before calling releaseChangelog,
+        // to avoid expensive operations (project graph recreation, git log, etc.) when changelogs are disabled
+        const changelogGenerationEnabled = (0, changelog_1.isChangelogEffectivelyEnabled)(nxReleaseConfig.changelog.workspaceChangelog) ||
+            releaseGraph.releaseGroups.some((g) => (0, changelog_1.isChangelogEffectivelyEnabled)(g.changelog));
+        // Run changelog generation before git commit/tag so that changelog files are
+        // included in the same commit as the version bump
+        const changelogResult = changelogGenerationEnabled
+            ? await releaseChangelog({
+                ...args,
+                // Re-use existing release graph
+                releaseGraph,
+                versionData: projectsVersionData,
+                version: workspaceVersion,
+                stageChanges: shouldStage,
+                gitCommit: false,
+                gitTag: false,
+                gitPush: false,
+                createRelease: false,
+                deleteVersionPlans: false,
+            })
+            : undefined;
         if (shouldCommit) {
             output_1.output.logSingleLine(`Committing changes with git`);
             const commitMessage = nxReleaseConfig.git.commitMessage;
@@ -190,51 +198,53 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             });
             hasPushedChanges = true;
         }
-        let latestCommit;
-        if (shouldCreateWorkspaceRemoteRelease &&
-            changelogResult.workspaceChangelog) {
-            const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
-            // shouldCreateWorkspaceRemoteRelease() ensures that the createRelease property exists and is not false
-            nxReleaseConfig.changelog.workspaceChangelog
-                .createRelease);
-            if (!hasPushedChanges) {
-                throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the workspace without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
-            }
-            output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} Release`);
-            latestCommit = await (0, git_1.getCommitHash)('HEAD');
-            await remoteReleaseClient.createOrUpdateRelease(changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
-        }
-        for (const releaseGroupName of releaseGraph.sortedReleaseGroups) {
-            const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === releaseGroupName);
-            if (!releaseGroup) {
-                continue;
-            }
-            const shouldCreateProjectRemoteReleases = shouldCreateRemoteRelease(releaseGroup.changelog);
-            if (shouldCreateProjectRemoteReleases &&
-                changelogResult.projectChangelogs) {
+        if (changelogResult) {
+            let latestCommit;
+            if (shouldCreateWorkspaceRemoteRelease &&
+                changelogResult.workspaceChangelog) {
                 const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
-                // shouldCreateProjectRemoteReleases() ensures that the createRelease property exists and is not false
-                releaseGroup.changelog
+                // shouldCreateWorkspaceRemoteRelease() ensures that the createRelease property exists and is not false
+                nxReleaseConfig.changelog.workspaceChangelog
                     .createRelease);
-                const projects = args.projects?.length
-                    ? // If the user has passed a list of projects, we need to use the filtered list of projects within the release group
-                        Array.from(releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup))
-                    : // Otherwise, we use the full list of projects within the release group
-                        releaseGroup.projects;
-                const projectNodes = projects.map((name) => projectGraph.nodes[name]);
-                for (const project of projectNodes) {
-                    const changelog = changelogResult.projectChangelogs[project.name];
-                    if (!changelog) {
-                        continue;
-                    }
-                    if (!hasPushedChanges) {
-                        throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the project without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
-                    }
-                    output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} Release`);
-                    if (!latestCommit) {
-                        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                if (!hasPushedChanges) {
+                    throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the workspace without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
+                }
+                output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} Release`);
+                latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                await remoteReleaseClient.createOrUpdateRelease(changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+            }
+            for (const releaseGroupName of releaseGraph.sortedReleaseGroups) {
+                const releaseGroup = releaseGraph.releaseGroups.find((g) => g.name === releaseGroupName);
+                if (!releaseGroup) {
+                    continue;
+                }
+                const shouldCreateProjectRemoteReleases = shouldCreateRemoteRelease(releaseGroup.changelog);
+                if (shouldCreateProjectRemoteReleases &&
+                    changelogResult.projectChangelogs) {
+                    const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
+                    // shouldCreateProjectRemoteReleases() ensures that the createRelease property exists and is not false
+                    releaseGroup.changelog
+                        .createRelease);
+                    const projects = args.projects?.length
+                        ? // If the user has passed a list of projects, we need to use the filtered list of projects within the release group
+                            Array.from(releaseGraph.releaseGroupToFilteredProjects.get(releaseGroup))
+                        : // Otherwise, we use the full list of projects within the release group
+                            releaseGroup.projects;
+                    const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+                    for (const project of projectNodes) {
+                        const changelog = changelogResult.projectChangelogs[project.name];
+                        if (!changelog) {
+                            continue;
+                        }
+                        if (!hasPushedChanges) {
+                            throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the project without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
+                        }
+                        output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} Release`);
+                        if (!latestCommit) {
+                            latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                        }
+                        await remoteReleaseClient.createOrUpdateRelease(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
                     }
-                    await remoteReleaseClient.createOrUpdateRelease(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
                 }
             }
         }

package/dist/src/command-line/release/utils/git.d.ts

@@ -118,3 +118,9 @@ export declare function parseVersionPlanCommit(commit: RawGitCommit): {
 export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;
 export declare function getCommitHash(ref: string): Promise<string>;
 export declare function getFirstGitCommit(): Promise<string>;
+/**
+ * Returns the parent of the first commit that touched the given project root,
+ * so that `from..HEAD` ranges include the project's creation commit.
+ * Falls back to getFirstGitCommit() if the project history cannot be determined.
+ */
+export declare function getFirstProjectCommit(projectRoot: string): Promise<string>;

package/dist/src/command-line/release/utils/git.js

@@ -15,6 +15,7 @@ exports.parseVersionPlanCommit = parseVersionPlanCommit;
 exports.parseGitCommit = parseGitCommit;
 exports.getCommitHash = getCommitHash;
 exports.getFirstGitCommit = getFirstGitCommit;
+exports.getFirstProjectCommit = getFirstProjectCommit;
 /**
  * Special thanks to changelogen for the original inspiration for many of these utilities:
  * https://github.com/unjs/changelogen
@@ -542,6 +543,38 @@ async function getFirstGitCommit() {
         throw new Error(`Unable to find first commit in git history`);
     }
 }
+/**
+ * Returns the parent of the first commit that touched the given project root,
+ * so that `from..HEAD` ranges include the project's creation commit.
+ * Falls back to getFirstGitCommit() if the project history cannot be determined.
+ */
+async function getFirstProjectCommit(projectRoot) {
+    try {
+        const result = (await (0, exec_command_1.execCommand)('git', [
+            'rev-list',
+            '--reverse',
+            'HEAD',
+            '--first-parent',
+            '--',
+            projectRoot,
+        ])).trim();
+        const firstCommit = result.split('\n')[0];
+        if (firstCommit) {
+            // Return the parent so the creation commit is included in from..to ranges
+            try {
+                return (await (0, exec_command_1.execCommand)('git', ['rev-parse', `${firstCommit}~1`])).trim();
+            }
+            catch {
+                // No parent (project was added in the repo's very first commit)
+                return firstCommit;
+            }
+        }
+    }
+    catch {
+        // fall through to fallback
+    }
+    return getFirstGitCommit();
+}
 async function getGitRoot() {
     try {
         return (await (0, exec_command_1.execCommand)('git', ['rev-parse', '--show-toplevel'])).trim();

package/dist/src/command-line/release/version/derive-specifier-from-conventional-commits.js

@@ -15,11 +15,12 @@ isPrerelease, latestMatchingGitTag, releaseGraph, fallbackCurrentVersionResolver
         ? [projectGraphNode.name]
         : releaseGroup.projects;
     // latestMatchingGitTag will be undefined if the current version was resolved from the disk fallback.
-    // In this case, we want to use the first commit as the ref to be consistent with the changelog command.
+    // In this case, use the first commit that touched this project rather than the repo's first commit,
+    // to avoid scanning the entire git history for projects that were added after the repo was created.
     const previousVersionRef = latestMatchingGitTag
         ? latestMatchingGitTag.tag
         : fallbackCurrentVersionResolver === 'disk'
-            ? await (0, git_1.getFirstGitCommit)()
+            ? await (0, git_1.getFirstProjectCommit)(projectGraphNode.data.root)
             : undefined;
     if (!previousVersionRef) {
         // This should never happen since the checks above should catch if the current version couldn't be resolved

package/dist/src/command-line/release/version.d.ts

@@ -1,5 +1,7 @@
 import { NxReleaseConfiguration } from '../../config/nx-json';
+import type { ProjectGraph } from '../../config/project-graph';
 import { VersionOptions } from './command-object';
+import { type NxReleaseConfig } from './config/config';
 import { ReleaseGraph } from './utils/release-graph';
 import { VersionData } from './utils/shared';
 export interface NxReleaseVersionResult {
@@ -23,3 +25,4 @@ export interface NxReleaseVersionResult {
 }
 export declare const releaseVersionCLIHandler: (args: VersionOptions) => Promise<number>;
 export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration, ignoreNxJsonConfig: boolean): (args: VersionOptions) => Promise<NxReleaseVersionResult>;
+export declare function hasDockerReleaseConfiguration(nxReleaseConfig: NxReleaseConfig, releaseGraph: ReleaseGraph, projectGraph: ProjectGraph): boolean;

package/dist/src/command-line/release/version.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseVersionCLIHandler = void 0;
 exports.createAPI = createAPI;
+exports.hasDockerReleaseConfiguration = hasDockerReleaseConfiguration;
 const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
 const node_child_process_1 = require("node:child_process");
@@ -212,17 +213,17 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
                 }, releaseGroup, true);
             }
         }
+        const shouldProcessDockerProjects = hasDockerReleaseConfiguration(nxReleaseConfig, releaseGraph, projectGraph);
         // TODO(colum): Remove when Docker support is no longer experimental
-        if (nxReleaseConfig.docker ||
-            releaseGraph.releaseGroups.some((rg) => rg.docker)) {
+        if (shouldProcessDockerProjects) {
             output_1.output.warn({
                 title: 'Warning',
                 bodyLines: [
                     `Docker support is experimental. Breaking changes may occur and not adhere to semver versioning.`,
                 ],
             });
+            await processor.processDockerProjects(args.dockerVersionScheme, args.dockerVersion);
         }
-        await processor.processDockerProjects(args.dockerVersionScheme, args.dockerVersion);
         const versionData = processor.getVersionData();
         // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
         const gitTagValues = (args.gitTag ?? nxReleaseConfig.version.git.tag)
@@ -298,6 +299,15 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
         };
     };
 }
+function hasDockerReleaseConfiguration(nxReleaseConfig, releaseGraph, projectGraph) {
+    if (nxReleaseConfig.docker) {
+        return true;
+    }
+    if (releaseGraph.releaseGroups.some((rg) => rg.docker)) {
+        return true;
+    }
+    return Array.from(releaseGraph.allProjectsToProcess).some((projectName) => projectGraph.nodes[projectName]?.data.release?.docker !== undefined);
+}
 function printAndFlushChanges(tree, isDryRun) {
     const changes = tree.listChanges();
     console.log('');

package/dist/src/config/misc-interfaces.d.ts

@@ -84,6 +84,13 @@ export interface MigrationsJsonEntry {
     factory?: string;
     prompt?: string;
     requires?: Record<string, string>;
+    /**
+     * Path to a markdown doc describing the migration, relative to the
+     * `migrations.json` and resolved like `implementation`/`factory`. Always
+     * supplementary; never stands in for them. Under `--run-migrations
+     * --agentic` the resolved path is passed to the agent as extra context.
+     */
+    documentation?: string;
 }
 export type MigrationDetailsWithId = GeneratedMigrationDetails & {
     id: string;
@@ -95,6 +102,7 @@ export interface GeneratedMigrationDetails {
     description: string;
     implementation?: string;
     prompt?: string;
+    documentation?: string;
 }
 export interface MigrationsJson {
     name?: string;

package/dist/src/config/nx-json.d.ts

@@ -1,6 +1,8 @@
 import type ChangelogRenderer from '../../release/changelog-renderer';
 import type { ChangelogRenderOptions } from '../../release/changelog-renderer';
 import type { validReleaseVersionPrefixes } from '../command-line/release/utils/release-graph';
+import type { AgentId } from '../command-line/migrate/agentic/cli-args';
+import type { MigrateMode, MultiMajorMode } from '../command-line/migrate/command-object';
 import type { PackageManager } from '../utils/package-manager';
 import type { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
 export type ImplicitDependencyEntry<T = '*' | string[]> = {
@@ -651,6 +653,49 @@ export interface NxSyncConfiguration {
      */
     disabledTaskSyncGenerators?: string[];
 }
+export interface NxMigrateConfiguration {
+    /**
+     * Whether to automatically create a git commit after each migration runs.
+     * Equivalent to the `--create-commits` flag. Defaults to `false`.
+     */
+    createCommits?: boolean;
+    /**
+     * Commit message prefix applied to each migration commit when commits are
+     * enabled (via `createCommits` or `--create-commits`). Equivalent to the
+     * `--commit-prefix` flag. Defaults to `"chore: [nx migration] "`.
+     */
+    commitPrefix?: string;
+    /**
+     * Restricts which packages to migrate when migrating Nx itself. Equivalent to
+     * the `--mode` flag.
+     * - `first-party`: only Nx and its plugins.
+     * - `third-party`: only the third-party dependencies referenced by Nx.
+     * - `all`: everything (default).
+     */
+    mode?: MigrateMode;
+    /**
+     * How to handle a migration that crosses more than one major version.
+     * Equivalent to the `--multi-major-mode` flag. The `NX_MULTI_MAJOR_MODE`
+     * environment variable takes precedence over this setting.
+     * - `direct`: migrate straight to the requested target.
+     * - `gradual`: migrate to the smallest recommended step.
+     */
+    multiMajorMode?: MultiMajorMode;
+    /**
+     * Default for the agentic flow used by `nx migrate --run-migrations`.
+     * Equivalent to the `--agentic` flag.
+     * - `false`: never use the agentic flow.
+     * - `true`: use the agentic flow and resolve the installed agent.
+     * - an agent id (`"claude-code"`, `"codex"`, `"opencode"`): always use that agent.
+     */
+    agentic?: boolean | AgentId;
+    /**
+     * Whether to run agent-driven validation after generator-only migrations when
+     * the agentic flow is enabled. Equivalent to the `--validate` flag. Defaults
+     * to `true` when the agentic flow is enabled.
+     */
+    validate?: boolean;
+}
 /**
  * Nx.json configuration
  *
@@ -810,6 +855,10 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * Configuration for the `nx sync` command.
      */
     sync?: NxSyncConfiguration;
+    /**
+     * Configuration for the `nx migrate` command.
+     */
+    migrate?: NxMigrateConfiguration;
     /**
      * Sets the maximum size of the local cache. Accepts a number followed by a unit (e.g. 100MB). Accepted units are B, KB, MB, and GB.
      */