nx 23.0.0 → 23.0.2

package/README.md

@@ -7,13 +7,12 @@
 
 <div style="text-align: center;">
 
-[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
 [![License](https://img.shields.io/npm/l/@nx/workspace.svg?style=flat-square)]()
 [![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
 [![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg?style=flat-square)]()
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
-[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Join us on the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+[![Nx Sandboxing](https://staging.nx.app/workspaces/62d013ea0852fe0a2df74438/sandbox-badge.svg)](https://nx.dev/docs/features/ci-features/sandboxing)
 
 </div>
 

package/dist/bin/init-local.js

@@ -162,7 +162,7 @@ function handleAngularCLIFallbacks(workspace) {
         console.log(`- fix migrations that "almost work"`);
         console.log(`- commit a partially migrated state`);
         console.log(`- change versions of packages to match organizational requirements`);
-        console.log(`And, in general, it is lot more reliable for non-trivial workspaces. Read more at: https://nx.dev/getting-started/nx-and-angular#ng-update-and-nx-migrate`);
+        console.log(`And, in general, it is lot more reliable for non-trivial workspaces. Read more at: https://nx.dev/docs/technologies/angular/guides/nx-and-angular#ng-update-vs-nx-migrate`);
         console.log(`Run "nx migrate latest" to update to the latest version of Nx.`);
         console.log(`Running "ng update" can still be useful in some dev workflows, so we aren't planning to remove it.`);
         console.log(`If you need to use it, run "FORCE_NG_UPDATE=true ng update".`);

package/dist/release/changelog-renderer/index.d.ts

@@ -105,5 +105,6 @@ export default class DefaultChangelogRenderer {
     protected groupChangesByType(): Record<string, ChangelogChange[]>;
     protected groupChangesByScope(changes: ChangelogChange[]): Record<string, ChangelogChange[]>;
     protected extractBreakingChangeExplanation(message: string): string | null;
+    private isBreakingChangeBoundary;
     protected formatName(name?: string): string;
 }

package/dist/release/changelog-renderer/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const semver_1 = require("semver");
+// Stripped from breaking change explanations (e.g. bot/session markers).
+const HtmlCommentRegex = /<!--[\s\S]*?-->/g;
 class DefaultChangelogRenderer {
     /**
      * A ChangelogRenderer class takes in the determined changes and other relevant metadata
@@ -342,20 +344,33 @@ class DefaultChangelogRenderer {
             return null;
         }
         const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
-        // Extract all text after BREAKING CHANGE: until we hit a Co-authored-by section or git metadata
-        let endOfBreakingChange = message.length;
-        const coAuthoredBySection = message.indexOf('---------\n\nCo-authored-by:');
-        if (coAuthoredBySection !== -1) {
-            endOfBreakingChange = coAuthoredBySection;
-        }
-        else {
-            // Look for the git metadata delimiter (a line with just ")
-            const gitMetadataMarker = message.indexOf('"\n', startOfBreakingChange);
-            if (gitMetadataMarker !== -1) {
-                endOfBreakingChange = gitMetadataMarker;
+        // A squash-merged PR body can trail the note with template sections,
+        // trailers, and git metadata. Strip comments (they can appear anywhere),
+        // then keep lines until the first boundary.
+        const lines = message
+            .slice(startOfBreakingChange)
+            .replace(HtmlCommentRegex, '')
+            .split('\n');
+        // The rest of the "BREAKING CHANGE:" line is always kept; scan from the next.
+        const explanationLines = [lines[0]];
+        for (let i = 1; i < lines.length; i++) {
+            if (this.isBreakingChangeBoundary(lines[i])) {
+                break;
             }
+            explanationLines.push(lines[i]);
         }
-        return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
+        return explanationLines.join('\n').trim();
+    }
+    isBreakingChangeBoundary(line) {
+        const trimmed = line.trim();
+        return (
+        // Markdown heading (e.g. "## Related issues")
+        /^#{1,6}\s/.test(trimmed) ||
+            // Horizontal rule / separator
+            /^-{3,}$/.test(trimmed) ||
+            /^Co-authored-by:/i.test(trimmed) ||
+            // Git metadata delimiter following the body
+            trimmed === '"');
     }
     formatName(name = '') {
         return name

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.d.ts

@@ -1,5 +1,6 @@
 import { Tree } from '../../../../generators/tree';
 export declare const nxWrapperPath: (p?: typeof import("path")) => string;
+export declare function getDotNxWrapperVersionCommand(platform?: NodeJS.Platform): string;
 export declare function generateDotNxSetup(version?: string): void;
 export declare function normalizeVersionForNxJson(pkg: string, version: string): string;
 export declare function writeMinimalNxJson(host: Tree, version: string): void;

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxWrapperPath = void 0;
+exports.getDotNxWrapperVersionCommand = getDotNxWrapperVersionCommand;
 exports.generateDotNxSetup = generateDotNxSetup;
 exports.normalizeVersionForNxJson = normalizeVersionForNxJson;
 exports.writeMinimalNxJson = writeMinimalNxJson;
@@ -50,6 +51,10 @@ const SHELL_SCRIPT_CONTENTS = [
     // Executes the nx wrapper script
     `node ${path.posix.join('$path_to_root', (0, exports.nxWrapperPath)(path.posix))} "$@"`,
 ].join('\n');
+// cmd.exe can't run the bash './nx' wrapper; use the generated nx.bat on Windows.
+function getDotNxWrapperVersionCommand(platform = process.platform) {
+    return platform === 'win32' ? '.\\nx.bat --version' : './nx --version';
+}
 function generateDotNxSetup(version) {
     const host = new tree_1.FsTree(process.cwd(), false, '.nx setup');
     writeMinimalNxJson(host, version);
@@ -66,7 +71,7 @@ function generateDotNxSetup(version) {
     // This is needed when using a global nx with dot-nx, otherwise running any nx command using global command will fail due to missing modules.
     // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
     try {
-        (0, child_process_1.execSync)('./nx --version', {
+        (0, child_process_1.execSync)(getDotNxWrapperVersionCommand(), {
             stdio: ['ignore', 'ignore', 'pipe'],
             encoding: 'utf8',
             windowsHide: true,

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

@@ -348,7 +348,7 @@ async function runInit(options, baseMeta) {
     }
     else {
         nxCloudChoice = options.interactive
-            ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)()
+            ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)('init', 'setupNxCloud', false)
             : 'skip';
     }
     if (nxCloudChoice === 'yes') {

package/dist/src/command-line/migrate/agentic/prompts/system-prompt.js

@@ -80,9 +80,10 @@ function buildScopeRules(mode) {
     return [
         `<scope_rules>`,
         `- Apply only the changes the migration prompt asks for.`,
-        `- Do not refactor, reformat, or update dependencies beyond what the migration prompt directs.`,
+        `- Do not refactor or update dependencies beyond what the migration prompt directs, and do not reformat files you did not change.`,
+        `- After applying your changes and before writing the handoff, format the files you created or modified so they match the workspace's style. If the workspace uses Prettier, run \`nx format:write\`, which formats your uncommitted changes; if it has no formatter configured, skip this.`,
         `- Do not modify files outside the workspace root.`,
-        `- Do not run other \`nx\` commands that mutate workspace state (\`nx migrate\`, \`nx reset\`, \`nx run-many\`, generators, etc.). Read-only inspection (\`nx show\`, \`nx graph --file\`, reading files) is fine.`,
+        `- Do not run other \`nx\` commands that mutate workspace state (\`nx migrate\`, \`nx reset\`, \`nx run-many\`, generators, etc.), except \`nx format:write\` to format the files you changed. Read-only inspection (\`nx show\`, \`nx graph --file\`, reading files) is fine.`,
         `- If the migration instructions are unclear, internally inconsistent, or conflict with the current workspace state, ask the user for direction (see the handoff contract). Do not guess.`,
         `</scope_rules>`,
     ].join('\n');

package/dist/src/command-line/migrate/migrate.d.ts

@@ -85,6 +85,7 @@ export declare class Migrator {
     }>;
     private createMigrateJson;
     private buildPackageJsonUpdates;
+    private resolveVersionForCascade;
     private populatePackageJsonUpdatesAndGetPackagesToCheck;
     private getPackageJsonUpdatesFromMigrationConfig;
     /**
@@ -172,6 +173,7 @@ export declare function createFetcher(pmc: PackageManagerCommands): ((pkg: strin
     stats?: MigrateFetchStats;
 };
 export { filterDowngradedUpdates };
+export declare function generateMigrationsJsonAndUpdatePackageJson(root: string, opts: GenerateMigrations, fetch?: MigratorOptions['fetch']): Promise<void>;
 /**
  * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
  * error code, which npm consistently emits for this class of failure across

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

@@ -6,6 +6,7 @@ exports.resolveCanonicalNxPackage = resolveCanonicalNxPackage;
 exports.resolveInclude = resolveInclude;
 exports.parseMigrationsOptions = parseMigrationsOptions;
 exports.createFetcher = createFetcher;
+exports.generateMigrationsJsonAndUpdatePackageJson = generateMigrationsJsonAndUpdatePackageJson;
 exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.resolveAgenticRunId = resolveAgenticRunId;
 exports.formatSkippedPromptsNextStep = formatSkippedPromptsNextStep;
@@ -191,16 +192,37 @@ class Migrator {
                     !this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith) &&
                     (!this.interactive ||
                         (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
-                    Object.entries(packageUpdate.packages).forEach(([name, update]) => {
+                    const updateEntries = Object.entries(packageUpdate.packages);
+                    // Validate all up front so invalid metadata fails fast, before any
+                    // resolution does I/O.
+                    for (const [name, update] of updateEntries) {
                         this.validatePackageUpdateVersion(packageToCheck.package, name, update);
-                        filteredUpdates[name] = update;
-                        this.packageUpdates[name] = update;
-                    });
+                    }
+                    // Resolve serially: resolution can prompt (pnpm strict cooldown) and
+                    // append to minimumReleaseAgeExclude, so a serial loop avoids
+                    // overlapping prompts and keeps packageUpdates ordering stable.
+                    for (const [name, update] of updateEntries) {
+                        const resolvedUpdate = {
+                            ...update,
+                            version: await this.resolveVersionForCascade(name, update.version),
+                        };
+                        filteredUpdates[name] = resolvedUpdate;
+                        this.packageUpdates[name] = resolvedUpdate;
+                    }
                 }
             }
             await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
         }
     }
+    async resolveVersionForCascade(packageName, version) {
+        // Already a fully-qualified semver (incl. prereleases) - nothing to resolve.
+        if ((0, semver_1.valid)(version)) {
+            return version;
+        }
+        // Otherwise resolve the spec (range/tag) through the min-release-age policy,
+        // which also honors any configured minimumReleaseAgeExclude entries.
+        return (0, resolve_package_version_1.resolvePackageVersionRespectingMinReleaseAge)(packageName, version);
+    }
     async populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target) {
         let targetVersion = target.version;
         if (this.to[targetPackage]) {
@@ -1347,6 +1369,7 @@ function readNxVersion(packageJson, root) {
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nx/workspace', root, packageJson) ??
         (0, package_json_1.getDependencyVersionFromPackageJson)('@nrwl/workspace', root, packageJson));
 }
+// Exported for testing the optional-include orchestration seam (see NXC-4590).
 async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
     const pmc = (0, package_manager_1.getPackageManagerCommand)();
     let phase = 'fetch_migrations';
@@ -1413,10 +1436,15 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
         // the user already has. Drop those before writing; nx migrate is
         // forward-only, never a downgrade.
         phase = 'package_updates';
-        const writableUpdates = (0, update_filters_1.filterDowngradedUpdates)(packageUpdates, originalPackageJson, installedPackageVersions);
+        // Resolve catalog: specifiers first so the filter compares real versions.
+        const writableUpdates = (0, update_filters_1.filterDowngradedUpdates)(packageUpdates, (0, catalog_1.resolveCatalogSpecifiers)(originalPackageJson), installedPackageVersions);
         const wrotePackageJson = await updatePackageJson(root, writableUpdates);
         const wroteNxJsonInstallation = await updateInstallationDetails(root, writableUpdates);
-        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, packageUpdates[walkedTargetPackage].version);
+        // Under `--include=optional` the target's own entry is filtered out of
+        // `packageUpdates` (it's a required package), so resolve the version
+        // defensively. Also reused by the completion analytics below.
+        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
+        const promptMigrationFiles = (0, prompt_files_1.writePromptMigrationFiles)(root, migrations, promptContents ?? {}, resolvedTargetVersion);
         if (migrations.length > 0) {
             await createMigrationsFile(root, [
                 ...addSplitConfigurationMigrationIfAvailable(from, writableUpdates),
@@ -1428,7 +1456,6 @@ async function generateMigrationsJsonAndUpdatePackageJson(root, opts, fetch) {
             : include === 'optional'
                 ? `- Processed optional dependency updates only (skipped required package updates).`
                 : null;
-        const resolvedTargetVersion = packageUpdates[walkedTargetPackage]?.version ?? opts.targetVersion;
         // The param expressions below evaluate before the report function is
         // entered; `safeReport` keeps them inside the analytics boundary so a
         // param-building throw can't surface here and convert an already

package/dist/src/command-line/migrate/resolve-package-version.js

@@ -137,9 +137,9 @@ async function resolveWithPolicy(packageName, version, policy, applySideEffects)
         if (applySideEffects && outcome.version !== outcome.unconstrained) {
             reportChangedOutcome(packageName, spec, outcome.version, outcome.unconstrained, policy);
         }
-        if (outcome.immature && applySideEffects) {
-            handleImmaturePick(packageName, outcome.version, policy);
-        }
+        // An immature loose pick is returned as-is. nx does not write the
+        // minimumReleaseAgeExclude entry here: migrate does not replace the install,
+        // so the real `pnpm install` (>=11.1.3) auto-writes it itself.
         return outcome.version;
     }
     catch (e) {
@@ -171,28 +171,6 @@ function reportChangedOutcome(packageName, spec, picked, unconstrained, policy)
         title: `Resolved ${packageName}@${picked} instead of ${unconstrained}: ${policy.sourceDescription}.`,
     });
 }
-// pnpm v11 loose installs an immature version; >=11.1.3 also records it as an
-// exclude in pnpm-workspace.yaml. Mirror that so a later real install agrees.
-function handleImmaturePick(packageName, version, policy) {
-    if (policy.behavior.packageManager !== 'pnpm' ||
-        !policy.behavior.writesExcludes) {
-        return;
-    }
-    const added = (0, pnpm_exclude_writer_1.appendMinimumReleaseAgeExcludes)(workspace_root_1.workspaceRoot, [
-        `${packageName}@${version}`,
-    ]);
-    // Already present (e.g. a prior pick or a pre-existing entry): nothing written,
-    // so do not claim we added it.
-    if (added.length === 0) {
-        return;
-    }
-    output_1.output.log({
-        title: `Added ${packageName}@${version} to minimumReleaseAgeExclude in pnpm-workspace.yaml.`,
-        bodyLines: [
-            `It is within the ${policy.sourceDescription} window; this mirrors what pnpm would write at install time.`,
-        ],
-    });
-}
 async function handleViolation(packageName, error, policy) {
     const isPnpmStrict = policy.behavior.packageManager === 'pnpm' &&
         policy.behavior.strict &&

package/dist/src/command-line/migrate/update-filters.js

@@ -35,7 +35,8 @@ function filterDowngradedUpdates(packageUpdates, packageJson, getInstalledVersio
         if (!specifier) {
             continue;
         }
-        const floor = (0, semver_1.minVersion)(specifier);
+        // Skip specifiers that aren't semver ranges (workspace:/npm:/git/file).
+        const floor = (0, semver_1.validRange)(specifier) ? (0, semver_1.minVersion)(specifier) : null;
         if (floor && (0, semver_1.lt)(floor.version, resolvedNorm)) {
             result[name] = update;
         }

package/dist/src/command-line/nx-cloud/connect/connect-to-nx-cloud.d.ts

@@ -9,5 +9,5 @@ export declare function connectToNxCloudCommand(options: {
     generateToken?: boolean;
     checkRemote?: boolean;
 }, command?: string): Promise<boolean>;
-export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey): Promise<MessageOptionKey>;
+export declare function connectExistingRepoToNxCloudPrompt(command?: string, key?: MessageKey, recordCompletion?: boolean): Promise<MessageOptionKey>;
 export declare function connectToNxCloudWithPrompt(command: string): Promise<void>;

package/dist/src/command-line/nx-cloud/connect/connect-to-nx-cloud.js

@@ -180,27 +180,34 @@ async function runConnectToNxCloud(options, command) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function connectExistingRepoToNxCloudPrompt(command = 'init', key = 'setupNxCloud') {
-    const res = await nxCloudPrompt(key);
-    await (0, ab_testing_1.recordStat)({
-        command,
-        nxVersion: versions_1.nxVersion,
-        useCloud: res === 'yes',
-        meta: {
-            type: 'complete',
-            setupCloudPrompt: ab_testing_1.messages.codeOfSelectedPromptMessage(key) || '',
-            nxCloudArg: res,
-            nodeVersion: process.versions.node,
-            os: process.platform,
-            packageManager: (0, package_manager_1.detectPackageManager)(),
-            aiAgent: (0, native_1.isAiAgent)(),
-            isCI: (0, is_ci_1.isCI)(),
-        },
-    });
+async function connectExistingRepoToNxCloudPrompt(command = 'init', key = 'setupNxCloud', recordCompletion = true) {
+    const res = await nxCloudPrompt(key, utmContentForCommand(command));
+    // TODO: once legacy init-v1 (the NX_ADD_PLUGINS=false / useInferencePlugins:false path) is
+    // removed, drop this recordStat and the recordCompletion flag entirely - init-v2 records its
+    // own complete, and view-logs should record its own stat, so this shared helper won't record.
+    // init-v2 records its own init "complete" stat, so it opts out here to avoid double-counting.
+    // Other callers (e.g. view-logs, legacy init-v1) rely on this as their only completion event.
+    if (recordCompletion) {
+        await (0, ab_testing_1.recordStat)({
+            command,
+            nxVersion: versions_1.nxVersion,
+            useCloud: res === 'yes',
+            meta: {
+                type: 'complete',
+                setupCloudPrompt: ab_testing_1.messages.codeOfSelectedPromptMessage(key) || '',
+                nxCloudArg: res,
+                nodeVersion: process.versions.node,
+                os: process.platform,
+                packageManager: (0, package_manager_1.detectPackageManager)(),
+                aiAgent: (0, native_1.isAiAgent)(),
+                isCI: (0, is_ci_1.isCI)(),
+            },
+        });
+    }
     return res;
 }
 async function connectToNxCloudWithPrompt(command) {
-    const setNxCloud = await nxCloudPrompt('setupNxCloud');
+    const setNxCloud = await nxCloudPrompt('setupNxCloud', utmContentForCommand(command));
     let useCloud = false;
     if (setNxCloud === 'yes') {
         useCloud = await connectToNxCloudCommand({ generateToken: false }, command);
@@ -229,7 +236,17 @@ async function connectToNxCloudWithPrompt(command) {
         },
     });
 }
-async function nxCloudPrompt(key) {
+function utmContentForCommand(command) {
+    switch (command) {
+        case 'migrate':
+            return 'nx-migrate';
+        case 'view-logs':
+            return 'nx-connect';
+        default:
+            return 'nx-init';
+    }
+}
+async function nxCloudPrompt(key, utmContent) {
     const { message, choices, initial, footer, hint } = ab_testing_1.messages.getPrompt(key);
     const promptConfig = {
         name: 'NxCloud',
@@ -239,7 +256,7 @@ async function nxCloudPrompt(key) {
         initial,
     }; // meeroslav: types in enquirer are not up to date
     if (footer) {
-        promptConfig.footer = () => pc.dim(footer);
+        promptConfig.footer = () => pc.dim(`${footer} ${(0, ab_testing_1.nxCloudHyperlink)(utmContent)}`);
     }
     if (hint) {
         promptConfig.hint = () => pc.dim(hint);

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

@@ -67,7 +67,10 @@ async function resolveCurrentVersionFromRegistry(tree, projectGraphNode, release
         return cached.currentVersion;
     }
     let registryTxt = '';
-    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`);
+    // Skip non-TTY logging — the resolved version is reported through the
+    // project's batched `ProjectLogger` so the spinner step shouldn't emit an
+    // out-of-band line that would bypass the grouped output.
+    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`, undefined, { skipNonTtyLogging: true });
     try {
         const res = await versionActions.readCurrentVersionFromRegistry(tree, finalConfigForProject.currentVersionResolverMetadata);
         if (!res) {