fix(core): use nx-mcp for older nx versions instead of nx mcp (#33553)

MaxKless · FrozenPandaz · commit e993d05e9b03 · 2025-11-25T18:45:04.000-05:00
## Current Behavior Older versions don't support the `nx mcp` command yet - but they CAN use the `nx-mcp` package via npx ## Expected Behavior We generatee the proper command into their MCP config by matching on their version ## Related Issue(s)  Fixes #
diff --git a/packages/nx/src/ai/constants.ts b/packages/nx/src/ai/constants.ts
@@ -1,6 +1,6 @@
-import { readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { major } from 'semver';
 import { readJsonFile } from '../utils/fileutils';
 import { getAgentRules } from './set-up-ai-agents/get-agent-rules';
 
@@ -49,8 +49,18 @@ export const getAgentRulesWrapped = (writeNxCloudRules: boolean) => {
 };
 
 export const nxMcpTomlHeader = `[mcp_servers."nx-mcp"]`;
-export const nxMcpTomlConfig = `${nxMcpTomlHeader}
+
+/**
+ * Get the MCP TOML configuration based on the Nx version.
+ * For Nx 22+, uses 'nx mcp'
+ * For Nx < 22, uses 'nx-mcp'
+ */
+export function getNxMcpTomlConfig(nxVersion: string): string {
+  const majorVersion = major(nxVersion);
+  const args = majorVersion >= 22 ? '["nx", "mcp"]' : '["nx-mcp"]';
+  return `${nxMcpTomlHeader}
 type = "stdio"
 command = "npx"
-args = ["nx", "mcp"]
+args = ${args}
 `;
+}
diff --git a/packages/nx/src/ai/set-up-ai-agents/set-up-ai-agents.spec.ts b/packages/nx/src/ai/set-up-ai-agents/set-up-ai-agents.spec.ts
@@ -5,18 +5,33 @@ import { setupAiAgentsGenerator } from './set-up-ai-agents';
 import { SetupAiAgentsGeneratorSchema } from './schema';
 import { readJson } from '../../generators/utils/json';
 import { getAgentRulesWrapped } from '../constants';
+import * as packageJsonUtils from '../../utils/package-json';
+import * as fs from 'fs';
 
 describe('setup-ai-agents generator', () => {
   let tree: Tree;
+  let readModulePackageJsonSpy: jest.SpyInstance;
 
   beforeEach(() => {
     tree = createTreeWithEmptyWorkspace();
     // Use local implementation instead of fetching from latest
     process.env.NX_AI_FILES_USE_LOCAL = 'true';
+
+    // Mock readModulePackageJson to return Nx 22+ by default
+    // This ensures existing tests pass by defaulting to the new format
+    readModulePackageJsonSpy = jest
+      .spyOn(packageJsonUtils, 'readModulePackageJson')
+      .mockReturnValue({
+        packageJson: { name: 'nx', version: '22.0.0' },
+        path: '/fake/path/package.json',
+      });
   });
 
   afterEach(() => {
     delete process.env.NX_AI_FILES_USE_LOCAL;
+    if (readModulePackageJsonSpy) {
+      readModulePackageJsonSpy.mockRestore();
+    }
   });
 
   it('should respect writeNxCloudRules option', async () => {
@@ -466,5 +481,101 @@ describe('setup-ai-agents generator', () => {
         expect(tree.exists('.gemini/settings.json')).toBe(false);
       });
     });
+
+    describe('Nx version-specific MCP configuration', () => {
+      it('should use "nx mcp" for Nx 22+', async () => {
+        readModulePackageJsonSpy.mockReturnValue({
+          packageJson: { name: 'nx', version: '22.0.0' },
+          path: '/fake/path/package.json',
+        });
+
+        const options: SetupAiAgentsGeneratorSchema = {
+          directory: '.',
+          agents: ['claude'],
+        };
+
+        await setupAiAgentsGenerator(tree, options);
+
+        const config = JSON.parse(tree.read('.mcp.json')?.toString() ?? '{}');
+        expect(config.mcpServers['nx-mcp']).toEqual({
+          type: 'stdio',
+          command: 'npx',
+          args: ['nx', 'mcp'],
+        });
+      });
+
+      it('should use "nx-mcp" for Nx < 22', async () => {
+        readModulePackageJsonSpy.mockReturnValue({
+          packageJson: { name: 'nx', version: '21.0.0' },
+          path: '/fake/path/package.json',
+        });
+
+        const options: SetupAiAgentsGeneratorSchema = {
+          directory: '.',
+          agents: ['claude'],
+        };
+
+        await setupAiAgentsGenerator(tree, options);
+
+        const config = JSON.parse(tree.read('.mcp.json')?.toString() ?? '{}');
+        expect(config.mcpServers['nx-mcp']).toEqual({
+          type: 'stdio',
+          command: 'npx',
+          args: ['nx-mcp'],
+        });
+      });
+
+      it('should use "nx mcp" as fallback when version cannot be determined', async () => {
+        readModulePackageJsonSpy.mockImplementation(() => {
+          throw new Error('Module not found');
+        });
+
+        // Also mock readFileSync to fail so it falls back to default version
+        const readFileSyncSpy = jest
+          .spyOn(fs, 'readFileSync')
+          .mockImplementation(() => {
+            throw new Error('File not found');
+          });
+
+        const options: SetupAiAgentsGeneratorSchema = {
+          directory: '.',
+          agents: ['claude'],
+        };
+
+        await setupAiAgentsGenerator(tree, options);
+
+        const config = JSON.parse(tree.read('.mcp.json')?.toString() ?? '{}');
+        expect(config.mcpServers['nx-mcp']).toEqual({
+          type: 'stdio',
+          command: 'npx',
+          args: ['nx', 'mcp'],
+        });
+
+        readFileSyncSpy.mockRestore();
+      });
+
+      it('should use "nx mcp" for Nx 23+', async () => {
+        readModulePackageJsonSpy.mockReturnValue({
+          packageJson: { name: 'nx', version: '23.1.0' },
+          path: '/fake/path/package.json',
+        });
+
+        const options: SetupAiAgentsGeneratorSchema = {
+          directory: '.',
+          agents: ['gemini'],
+        };
+
+        await setupAiAgentsGenerator(tree, options);
+
+        const config = JSON.parse(
+          tree.read('.gemini/settings.json')?.toString() ?? '{}'
+        );
+        expect(config.mcpServers['nx-mcp']).toEqual({
+          type: 'stdio',
+          command: 'npx',
+          args: ['nx', 'mcp'],
+        });
+      });
+    });
   });
 });
diff --git a/packages/nx/src/ai/set-up-ai-agents/set-up-ai-agents.ts b/packages/nx/src/ai/set-up-ai-agents/set-up-ai-agents.ts
@@ -7,6 +7,7 @@ import {
 } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
+import { major } from 'semver';
 import { formatChangedFilesWithPrettierIfAvailable } from '../../generators/internal-utils/format-changed-files-with-prettier-if-available';
 import { Tree } from '../../generators/tree';
 import { readJson, updateJson, writeJson } from '../../generators/utils/json';
@@ -20,13 +21,17 @@ import {
   CLIErrorMessageConfig,
   CLINoteMessageConfig,
 } from '../../utils/output';
-import { installPackageToTmp } from '../../utils/package-json';
+import {
+  installPackageToTmp,
+  readModulePackageJson,
+} from '../../utils/package-json';
 import { ensurePackageHasProvenance } from '../../utils/provenance';
+import { workspaceRoot } from '../../utils/workspace-root';
 import { agentsMdPath, codexConfigTomlPath, geminiMdPath } from '../constants';
 import { Agent, supportedAgents } from '../utils';
 import {
   getAgentRulesWrapped,
-  nxMcpTomlConfig,
+  getNxMcpTomlConfig,
   nxMcpTomlHeader,
   nxRulesMarkerCommentDescription,
   nxRulesMarkerCommentEnd,
@@ -43,6 +48,39 @@ export type ModificationResults = {
   errors: CLIErrorMessageConfig[];
 };
 
+/**
+ * Get the installed Nx version, with fallback to workspace package.json or default version.
+ */
+function getNxVersion(): string {
+  try {
+    // Try to read from node_modules first
+    const {
+      packageJson: { version },
+    } = readModulePackageJson('nx');
+    return version;
+  } catch {
+    try {
+      // Fallback: try to read from workspace package.json
+      const workspacePackageJson = JSON.parse(
+        readFileSync(join(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';
+    }
+  }
+}
+
 export async function setupAiAgentsGenerator(
   tree: Tree,
   options: SetupAiAgentsGeneratorSchema,
@@ -100,6 +138,7 @@ export async function setupAiAgentsGeneratorImpl(
   options: NormalizedSetupAiAgentsGeneratorSchema
 ): Promise<() => Promise<ModificationResults>> {
   const hasAgent = (agent: Agent) => options.agents.includes(agent);
+  const nxVersion = getNxVersion();
 
   const agentsMd = agentsMdPath(options.directory);
 
@@ -116,7 +155,7 @@ export async function setupAiAgentsGeneratorImpl(
     if (!tree.exists(mcpJsonPath)) {
       writeJson(tree, mcpJsonPath, {});
     }
-    updateJson(tree, mcpJsonPath, mcpConfigUpdater);
+    updateJson(tree, mcpJsonPath, (json) => mcpConfigUpdater(json, nxVersion));
   }
 
   if (hasAgent('gemini')) {
@@ -128,7 +167,9 @@ export async function setupAiAgentsGeneratorImpl(
     if (!tree.exists(geminiSettingsPath)) {
       writeJson(tree, geminiSettingsPath, {});
     }
-    updateJson(tree, geminiSettingsPath, mcpConfigUpdater);
+    updateJson(tree, geminiSettingsPath, (json) =>
+      mcpConfigUpdater(json, nxVersion)
+    );
 
     const contextFileName: string | undefined = readJson(
       tree,
@@ -164,7 +205,10 @@ export async function setupAiAgentsGeneratorImpl(
         const tomlContents = readFileSync(codexConfigTomlPath, 'utf-8');
         if (!tomlContents.includes(nxMcpTomlHeader)) {
           if (!check) {
-            appendFileSync(codexConfigTomlPath, `\n${nxMcpTomlConfig}`);
+            appendFileSync(
+              codexConfigTomlPath,
+              `\n${getNxMcpTomlConfig(nxVersion)}`
+            );
           }
           messages.push({
             title: `Updated ${codexConfigTomlPath} with nx-mcp server`,
@@ -173,7 +217,7 @@ export async function setupAiAgentsGeneratorImpl(
       } else {
         if (!check) {
           mkdirSync(join(homedir(), '.codex'), { recursive: true });
-          writeFileSync(codexConfigTomlPath, nxMcpTomlConfig);
+          writeFileSync(codexConfigTomlPath, getNxMcpTomlConfig(nxVersion));
         }
         messages.push({
           title: `Created ${codexConfigTomlPath} with nx-mcp server`,
@@ -281,19 +325,22 @@ function writeAgentRules(tree: Tree, path: string, writeNxCloudRules: boolean) {
   }
 }
 
-function mcpConfigUpdater(existing: any): any {
+function mcpConfigUpdater(existing: any, nxVersion: string): any {
+  const majorVersion = major(nxVersion);
+  const mcpArgs = majorVersion >= 22 ? ['nx', 'mcp'] : ['nx-mcp'];
+
   if (existing.mcpServers) {
     existing.mcpServers['nx-mcp'] = {
       type: 'stdio',
       command: 'npx',
-      args: ['nx', 'mcp'],
+      args: mcpArgs,
     };
   } else {
     existing.mcpServers = {
       'nx-mcp': {
         type: 'stdio',
         command: 'npx',
-        args: ['nx', 'mcp'],
+        args: mcpArgs,
       },
     };
   }
