nx 22.7.0-rc.2 → 22.7.1

package/dist/bin/nx.js

@@ -109,10 +109,10 @@ async function main() {
             warnIfUsingOutdatedGlobalInstall(GLOBAL_NX_VERSION, LOCAL_NX_VERSION);
             if (localNx.includes('.nx')) {
                 const nxWrapperPath = localNx.replace(/\.nx.*/, '.nx/') + 'nxw.js';
-                await import(nxWrapperPath);
+                require(nxWrapperPath);
             }
             else {
-                await import(localNx);
+                require(localNx);
             }
         }
     }

package/dist/src/ai/set-up-ai-agents/set-up-ai-agents.js

@@ -15,38 +15,30 @@ const package_json_1 = require("../../utils/package-json");
 const ignore_1 = require("../../utils/ignore");
 const provenance_1 = require("../../utils/provenance");
 const workspace_root_1 = require("../../utils/workspace-root");
+const installed_nx_version_1 = require("../../utils/installed-nx-version");
 const constants_1 = require("../constants");
 const clone_ai_config_repo_1 = require("../clone-ai-config-repo");
 const utils_1 = require("../utils");
 const handle_import_1 = require("../../utils/handle-import");
 /**
- * Get the installed Nx version, with fallback to workspace package.json or default version.
+ * Best-effort fallback when `getInstalledNxVersion()` can't find an
+ * installed nx — read the version declared in the workspace's
+ * `package.json` (devDependencies/dependencies), stripping any semver
+ * range prefix, and finally a sane default.
  */
-function getNxVersion() {
+function getDeclaredNxVersionOrDefault() {
     try {
-        // Try to read from node_modules first
-        const { packageJson: { version }, } = (0, package_json_1.readModulePackageJson)('nx');
-        return version;
+        const workspacePackageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'), 'utf-8'));
+        const declared = workspacePackageJson.devDependencies?.nx ||
+            workspacePackageJson.dependencies?.nx;
+        if (declared) {
+            return declared.replace(/^[\^~>=<]+/, '');
+        }
     }
     catch {
-        try {
-            // Fallback: try to read from workspace package.json
-            const workspacePackageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'), 'utf-8'));
-            // Check devDependencies first, then dependencies
-            const nxVersion = workspacePackageJson.devDependencies?.nx ||
-                workspacePackageJson.dependencies?.nx;
-            if (nxVersion) {
-                // Remove any semver range characters (^, ~, >=, etc.)
-                return nxVersion.replace(/^[\^~>=<]+/, '');
-            }
-            throw new Error('Nx not found in package.json');
-        }
-        catch {
-            // If we can't determine the version, default to the newer format
-            // This handles cases where nx might not be installed or is globally installed
-            return '22.0.0';
-        }
+        // fall through to default
     }
+    return '22.0.0';
 }
 async function setupAiAgentsGenerator(tree, options, inner = false) {
     const normalizedOptions = normalizeOptions(options);
@@ -77,7 +69,7 @@ function normalizeOptions(options) {
 }
 async function setupAiAgentsGeneratorImpl(tree, options) {
     const hasAgent = (agent) => options.agents.includes(agent);
-    const nxVersion = getNxVersion();
+    const nxVersion = (0, installed_nx_version_1.getInstalledNxVersion)() ?? getDeclaredNxVersionOrDefault();
     const agentsMd = (0, constants_1.agentsMdPath)(options.directory);
     // write AGENTS.md for most agents
     if (hasAgent('cursor') ||

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

@@ -64,7 +64,19 @@ function generateDotNxSetup(version) {
     (0, tree_1.flushChanges)(host.root, changes);
     // Ensure that the dot-nx installation is available.
     // 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.
-    (0, child_process_1.execSync)('./nx --version', { stdio: 'ignore', windowsHide: true });
+    // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
+    try {
+        (0, child_process_1.execSync)('./nx --version', {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        if (e?.stderr)
+            process.stderr.write(e.stderr);
+        throw e;
+    }
 }
 function normalizeVersionForNxJson(pkg, version) {
     if (!(0, semver_1.valid)(version)) {

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

@@ -60,7 +60,8 @@ function performInstallation(currentInstallation, nxJson) {
         },
     }));
     try {
-        cp.execSync('npm i', {
+        // --include=dev forces install even if consumer env sets NODE_ENV=production / omit=dev.
+        cp.execSync('npm i --include=dev', {
             cwd: path.dirname(installationPath),
             stdio: 'inherit',
             windowsHide: true,

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

@@ -61,6 +61,11 @@ function withMigrationOptions(yargs) {
         describe: 'Exclude migrations that should have been applied on previous updates. To be used with --from.',
         type: 'boolean',
         default: false,
+    })
+        .option('skipInstall', {
+        describe: 'Skip installing packages before running migrations. Useful when the installation needs to be performed manually (e.g., to resolve peer dependency conflicts).',
+        type: 'boolean',
+        default: false,
     })
         .check(({ createCommits, commitPrefix, from, excludeAppliedMigrations }) => {
         if (!createCommits && commitPrefix !== defaultCommitPrefix) {

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

@@ -104,12 +104,20 @@ type RunMigrations = {
 export declare function parseMigrationsOptions(options: {
     [k: string]: any;
 }): Promise<GenerateMigrations | RunMigrations>;
+/**
+ * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
+ * error code, which npm consistently emits for this class of failure across
+ * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
+ * small set of stable phrases in case the code line is missing from the
+ * captured output.
+ */
+export declare function isNpmPeerDepsError(stderr: string): boolean;
 export declare function executeMigrations(root: string, migrations: {
     package: string;
     name: string;
     description?: string;
     version: string;
-}[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string): Promise<{
+}[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, shouldSkipInstall?: boolean): Promise<{
     migrationsWithNoChanges: {
         package: string;
         name: string;
@@ -123,7 +131,7 @@ export declare function runNxOrAngularMigration(root: string, migration: {
     name: string;
     description?: string;
     version: string;
-}, isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged?: () => void, handleInstallDeps?: boolean): Promise<{
+}, isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged?: () => Promise<void>, handleInstallDeps?: boolean): Promise<{
     changes: FileChange[];
     nextSteps: string[];
 }>;

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

@@ -4,6 +4,7 @@ exports.Migrator = void 0;
 exports.formatCommandFailure = formatCommandFailure;
 exports.normalizeVersion = normalizeVersion;
 exports.parseMigrationsOptions = parseMigrationsOptions;
+exports.isNpmPeerDepsError = isNpmPeerDepsError;
 exports.executeMigrations = executeMigrations;
 exports.runNxOrAngularMigration = runNxOrAngularMigration;
 exports.migrate = migrate;
@@ -1064,28 +1065,120 @@ function showConnectToCloudMessage() {
         return false;
     }
 }
-function runInstall(nxWorkspaceRoot) {
-    let packageManager;
-    let pmCommands;
-    if (nxWorkspaceRoot) {
-        packageManager = (0, package_manager_1.detectPackageManager)(nxWorkspaceRoot);
-        pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, nxWorkspaceRoot);
-    }
-    else {
-        pmCommands = (0, package_manager_1.getPackageManagerCommand)();
-    }
+function runInstall(nxWorkspaceRoot, phase = 'pre-migration') {
+    const cwd = nxWorkspaceRoot ?? process.cwd();
+    const packageManager = (0, package_manager_1.detectPackageManager)(cwd);
+    const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, cwd);
     const installCommand = `${pmCommands.install} ${pmCommands.ignoreScriptsFlag ?? ''}`;
     output_1.output.log({
         title: `Running '${installCommand}' to make sure necessary packages are installed`,
     });
-    (0, child_process_1.execSync)(installCommand, {
-        stdio: [0, 1, 2],
-        windowsHide: true,
-        cwd: nxWorkspaceRoot ?? process.cwd(),
+    return new Promise((resolve, reject) => {
+        // For npm, pipe stderr so we can detect peer dependency errors while still
+        // mirroring it live to the user's terminal. Other package managers inherit
+        // stderr directly since we don't need to inspect their output.
+        const shouldCaptureStderr = packageManager === 'npm';
+        const child = (0, child_process_1.spawn)(installCommand, {
+            shell: true,
+            stdio: ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
+            windowsHide: true,
+            cwd,
+        });
+        const stderrChunks = [];
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(chunk);
+            stderrChunks.push(chunk);
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            if (shouldCaptureStderr) {
+                const stderr = Buffer.concat(stderrChunks).toString().trim();
+                if (isNpmPeerDepsError(stderr)) {
+                    // Log the remediation guidance here so every caller of `runInstall`
+                    // (CLI migrate, `nx repair`, single-migration runner, etc.) surfaces
+                    // it consistently. Top-level callers catch `NpmPeerDepsInstallError`
+                    // and return a non-zero exit code without re-logging.
+                    logNpmPeerDepsError(phase);
+                    reject(new NpmPeerDepsInstallError());
+                    return;
+                }
+            }
+            reject(new Error(`Command failed: ${installCommand}`));
+        });
     });
 }
-async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix) {
-    const changedDepInstaller = new ChangedDepInstaller(root);
+class NpmPeerDepsInstallError extends Error {
+    constructor() {
+        super('npm install failed due to peer dependency conflicts.');
+        this.name = 'NpmPeerDepsInstallError';
+    }
+}
+/**
+ * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
+ * error code, which npm consistently emits for this class of failure across
+ * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
+ * small set of stable phrases in case the code line is missing from the
+ * captured output.
+ */
+function isNpmPeerDepsError(stderr) {
+    if (/\bERESOLVE\b/.test(stderr)) {
+        return true;
+    }
+    const lowerStderr = stderr.toLowerCase();
+    return (lowerStderr.includes('unable to resolve dependency tree') ||
+        lowerStderr.includes('could not resolve dependency') ||
+        lowerStderr.includes('conflicting peer dependency'));
+}
+function logNpmPeerDepsError(phase) {
+    const peerDepsResolutionSteps = [
+        'Recommended approaches (in order of preference):',
+        '',
+        '1. Use "overrides" in package.json to force compatible versions across the dependency tree.',
+        '   See https://docs.npmjs.com/cli/configuring-npm/package-json#overrides',
+        '2. Persist legacy peer deps resolution in the project ".npmrc":',
+        '   npm config set legacy-peer-deps=true --location=project',
+        '   (bypasses peer dependency resolution; use with caution)',
+        '3. As a last resort, force the installation by running "npm install --force".',
+        '   (does not persist and may produce broken installs)',
+    ];
+    const manualInstallHint = [
+        'If you installed the dependencies manually, pass "--skip-install" to avoid re-installing them:',
+        '   nx migrate --run-migrations --skip-install',
+    ];
+    if (phase === 'pre-migration') {
+        output_1.output.error({
+            title: 'You need to resolve the peer dependency conflicts before the migration can continue',
+            bodyLines: [
+                ...peerDepsResolutionSteps,
+                '',
+                'Once the conflicts are resolved, re-run the migrations:',
+                '   nx migrate --run-migrations',
+                '',
+                ...manualInstallHint,
+            ],
+        });
+    }
+    else {
+        output_1.output.error({
+            title: 'Some migrations have been applied, but installing the updated dependencies failed',
+            bodyLines: [
+                ...peerDepsResolutionSteps,
+                '',
+                'Once the conflicts are resolved, run "npm install" to install the updated dependencies.',
+                'If the migration was interrupted before completing, re-run the remaining migrations:',
+                '   nx migrate --run-migrations',
+                '',
+                ...manualInstallHint,
+            ],
+        });
+    }
+}
+async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall = false) {
+    const changedDepInstaller = new ChangedDepInstaller(root, shouldSkipInstall);
     const migrationsWithNoChanges = [];
     const sortedMigrations = migrations.sort((a, b) => {
         // special case for the split configuration migration to run first
@@ -1114,30 +1207,53 @@ async function executeMigrations(root, migrations, isVerbose, shouldCreateCommit
             logger_1.logger.info(`---------------------------------------------------------`);
         }
         catch (e) {
-            output_1.output.error({
-                title: `Failed to run ${m.name} from ${m.package}. This workspace is NOT up to date!`,
-            });
+            if (!(e instanceof NpmPeerDepsInstallError)) {
+                output_1.output.error({
+                    title: `Failed to run ${m.name} from ${m.package}. This workspace is NOT up to date!`,
+                });
+            }
             throw e;
         }
     }
     if (!shouldCreateCommits) {
-        changedDepInstaller.installDepsIfChanged();
+        await changedDepInstaller.installDepsIfChanged();
+    }
+    if (changedDepInstaller.skippedInstall) {
+        logSkippedPostMigrationInstall(root);
     }
     return { migrationsWithNoChanges, nextSteps: allNextSteps };
 }
 class ChangedDepInstaller {
-    constructor(root) {
+    constructor(root, shouldSkipInstall = false) {
         this.root = root;
+        this.shouldSkipInstall = shouldSkipInstall;
+        this._skippedInstall = false;
         this.initialDeps = getStringifiedPackageJsonDeps(root);
     }
-    installDepsIfChanged() {
+    get skippedInstall() {
+        return this._skippedInstall;
+    }
+    async installDepsIfChanged() {
         const currentDeps = getStringifiedPackageJsonDeps(this.root);
         if (this.initialDeps !== currentDeps) {
-            runInstall(this.root);
+            if (this.shouldSkipInstall) {
+                this._skippedInstall = true;
+            }
+            else {
+                await runInstall(this.root, 'post-migration');
+            }
         }
         this.initialDeps = currentDeps;
     }
 }
+function logSkippedPostMigrationInstall(root) {
+    const packageManager = (0, package_manager_1.detectPackageManager)(root);
+    const installCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager, root).install;
+    output_1.output.warn({
+        title: 'Migrations updated your dependencies, but the install was skipped',
+        bodyLines: [`Run "${installCommand}" to install the updated dependencies.`],
+    });
+}
 async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateCommits, commitPrefix, installDepsIfChanged, handleInstallDeps = false) {
     if (!installDepsIfChanged) {
         const changedDepInstaller = new ChangedDepInstaller(root);
@@ -1173,7 +1289,7 @@ async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateC
         logger_1.logger.info('');
     }
     if (shouldCreateCommits) {
-        installDepsIfChanged();
+        await installDepsIfChanged();
         const commitMessage = `${commitPrefix}${migration.name}`;
         try {
             const committedSha = (0, git_utils_1.commitChanges)(commitMessage, root);
@@ -1190,13 +1306,13 @@ async function runNxOrAngularMigration(root, migration, isVerbose, shouldCreateC
         // if we are running this function alone, we need to install deps internally
     }
     else if (handleInstallDeps) {
-        installDepsIfChanged();
+        await installDepsIfChanged();
     }
     return { changes, nextSteps };
 }
-async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix) {
-    if (!process.env.NX_MIGRATE_SKIP_INSTALL) {
-        runInstall();
+async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits = false, commitPrefix, shouldSkipInstall = false) {
+    if (!shouldSkipInstall && !process.env.NX_MIGRATE_SKIP_INSTALL) {
+        await runInstall();
     }
     if (!__dirname.startsWith(workspace_root_1.workspaceRoot)) {
         // we are running from a temp installation with nx latest, switch to running
@@ -1229,7 +1345,7 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits =
             (shouldCreateCommits ? ', with each applied in a dedicated commit' : ''),
     });
     const migrations = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, opts.runMigrations)).migrations;
-    const { migrationsWithNoChanges, nextSteps } = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix);
+    const { migrationsWithNoChanges, nextSteps } = await executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix, shouldSkipInstall);
     if (migrationsWithNoChanges.length < migrations.length) {
         output_1.output.success({
             title: `Successfully finished running migrations from '${opts.runMigrations}'. This workspace is up to date!`,
@@ -1283,7 +1399,18 @@ async function migrate(root, args, rawArgs) {
             await generateMigrationsJsonAndUpdatePackageJson(root, opts);
         }
         else {
-            return runMigrations(root, opts, rawArgs, args['verbose'], args['createCommits'], args['commitPrefix']);
+            try {
+                return await runMigrations(root, opts, rawArgs, args['verbose'], args['createCommits'], args['commitPrefix'], args['skipInstall']);
+            }
+            catch (e) {
+                // The remediation guidance is already logged by `runInstall`; swallow
+                // the error here so `handleErrors` doesn't print a noisy stack after
+                // the friendly output.
+                if (e instanceof NpmPeerDepsInstallError) {
+                    return 1;
+                }
+                throw e;
+            }
         }
     });
 }

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

@@ -15,6 +15,7 @@ const semver_1 = require("semver");
 const utils_1 = require("../../../tasks-runner/utils");
 const output_1 = require("../../../utils/output");
 const git_1 = require("./git");
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
 exports.noDiffInChangelogMessage = pc.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
 function isPrerelease(version) {
     // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
@@ -329,23 +330,32 @@ async function getCommitsRelevantToProjects(projectGraph, commits, projects, nxR
         // Try to get the graph associated with the commit shortHash
         // if not available, calculate it and store it in the cache
         let affectedGraph = await releaseGraph.resolveAffectedFilesPerCommitInProjectGraph(commit, projectGraph);
+        // Resolve commit scopes using Nx matcher
+        const scopePatterns = commit.scope
+            ? commit.scope.split(',').map((s) => s.trim())
+            : [];
+        let scopedProjects = null;
+        if (scopePatterns.length > 0) {
+            const matches = (0, find_matching_projects_1.findMatchingProjects)(scopePatterns, projectGraph.nodes);
+            // detect ambiguity
+            for (const pattern of scopePatterns) {
+                const perPatternMatches = (0, find_matching_projects_1.findMatchingProjects)([pattern], projectGraph.nodes);
+                if (perPatternMatches.length > 1) {
+                    throw new Error(`Ambiguous scope "${pattern}" in commit "${commit.message}". ` +
+                        `Matches: ${perPatternMatches.join(', ')}`);
+                }
+            }
+            scopedProjects = new Set(matches);
+        }
         for (const projectName of Object.keys(affectedGraph.nodes)) {
             if (projectSet.has(projectName)) {
                 if (!relevantCommits.has(projectName)) {
                     relevantCommits.set(projectName, []);
                 }
-                if (commit.scope === projectName ||
-                    commit.scope.split(',').includes(projectName) ||
-                    !commit.scope) {
-                    relevantCommits
-                        .get(projectName)
-                        ?.push({ commit, isProjectScopedCommit: true });
-                }
-                else {
-                    relevantCommits
-                        .get(projectName)
-                        ?.push({ commit, isProjectScopedCommit: false });
-                }
+                const isProjectScopedCommit = scopedProjects === null || scopedProjects.has(projectName);
+                relevantCommits
+                    .get(projectName)
+                    ?.push({ commit, isProjectScopedCommit });
             }
         }
     }