nx 21.6.1-beta.3 → 21.6.1-rc.0

package/bin/nx.js

@@ -36,6 +36,7 @@ async function main() {
     if (process.argv[2] === 'new' ||
         process.argv[2] === '_migrate' ||
         process.argv[2] === 'init' ||
+        process.argv[2] === 'configure-ai-agents' ||
         (process.argv[2] === 'graph' && !workspace)) {
         process.env.NX_DAEMON = 'false';
         require('nx/src/command-line/nx-commands').commandsObject.argv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.6.1-beta.3",
+  "version": "21.6.1-rc.0",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.6.1-beta.3",
-    "@nx/nx-darwin-x64": "21.6.1-beta.3",
-    "@nx/nx-freebsd-x64": "21.6.1-beta.3",
-    "@nx/nx-linux-arm-gnueabihf": "21.6.1-beta.3",
-    "@nx/nx-linux-arm64-gnu": "21.6.1-beta.3",
-    "@nx/nx-linux-arm64-musl": "21.6.1-beta.3",
-    "@nx/nx-linux-x64-gnu": "21.6.1-beta.3",
-    "@nx/nx-linux-x64-musl": "21.6.1-beta.3",
-    "@nx/nx-win32-arm64-msvc": "21.6.1-beta.3",
-    "@nx/nx-win32-x64-msvc": "21.6.1-beta.3"
+    "@nx/nx-darwin-arm64": "21.6.1-rc.0",
+    "@nx/nx-darwin-x64": "21.6.1-rc.0",
+    "@nx/nx-freebsd-x64": "21.6.1-rc.0",
+    "@nx/nx-linux-arm-gnueabihf": "21.6.1-rc.0",
+    "@nx/nx-linux-arm64-gnu": "21.6.1-rc.0",
+    "@nx/nx-linux-arm64-musl": "21.6.1-rc.0",
+    "@nx/nx-linux-x64-gnu": "21.6.1-rc.0",
+    "@nx/nx-linux-x64-musl": "21.6.1-rc.0",
+    "@nx/nx-win32-arm64-msvc": "21.6.1-rc.0",
+    "@nx/nx-win32-x64-msvc": "21.6.1-rc.0"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/ai/constants.d.ts

@@ -0,0 +1,15 @@
+export declare function agentsMdPath(root: string): string;
+export declare function geminiMdPath(root: string): string;
+export declare function parseGeminiSettings(root: string): any | undefined;
+export declare function geminiSettingsPath(root: string): string;
+export declare function claudeMdPath(root: string): string;
+export declare function claudeMcpPath(root: string): string;
+export declare const codexConfigTomlPath: string;
+export declare const nxRulesMarkerCommentStart = "<!-- nx configuration start-->";
+export declare const nxRulesMarkerCommentDescription = "<!-- Leave the start & end comments to automatically receive updates. -->";
+export declare const nxRulesMarkerCommentEnd = "<!-- nx configuration end-->";
+export declare const rulesRegex: RegExp;
+export declare const getAgentRulesWrapped: (writeNxCloudRules: boolean) => string;
+export declare const nxMcpTomlHeader = "[mcp_servers.\"nx-mcp\"]";
+export declare const nxMcpTomlConfig = "[mcp_servers.\"nx-mcp\"]\ntype = \"stdio\"\ncommand = \"npx\"\nargs = [\"nx\", \"mcp\"]\n";
+//# sourceMappingURL=constants.d.ts.map

package/src/ai/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/ai/constants.ts"],"names":[],"mappings":"AAMA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAOjE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAED,eAAO,MAAM,mBAAmB,QAA2C,CAAC;AAE5E,eAAO,MAAM,yBAAyB,mCAAmC,CAAC;AAC1E,eAAO,MAAM,+BAA+B,8EAA8E,CAAC;AAC3H,eAAO,MAAM,uBAAuB,iCAAiC,CAAC;AACtE,eAAO,MAAM,UAAU,QAGtB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,mBAAmB,OAAO,WAG9D,CAAC;AAEF,eAAO,MAAM,eAAe,6BAA2B,CAAC;AACxD,eAAO,MAAM,eAAe,8FAI3B,CAAC"}

package/src/ai/constants.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxMcpTomlConfig = exports.nxMcpTomlHeader = exports.getAgentRulesWrapped = exports.rulesRegex = exports.nxRulesMarkerCommentEnd = exports.nxRulesMarkerCommentDescription = exports.nxRulesMarkerCommentStart = exports.codexConfigTomlPath = void 0;
+exports.agentsMdPath = agentsMdPath;
+exports.geminiMdPath = geminiMdPath;
+exports.parseGeminiSettings = parseGeminiSettings;
+exports.geminiSettingsPath = geminiSettingsPath;
+exports.claudeMdPath = claudeMdPath;
+exports.claudeMcpPath = claudeMcpPath;
+const os_1 = require("os");
+const path_1 = require("path");
+const fileutils_1 = require("../utils/fileutils");
+const get_agent_rules_1 = require("./set-up-ai-agents/get-agent-rules");
+function agentsMdPath(root) {
+    return (0, path_1.join)(root, 'AGENTS.md');
+}
+function geminiMdPath(root) {
+    return (0, path_1.join)(root, 'GEMINI.md');
+}
+function parseGeminiSettings(root) {
+    const settingsPath = geminiSettingsPath(root);
+    try {
+        return (0, fileutils_1.readJsonFile)(settingsPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function geminiSettingsPath(root) {
+    return (0, path_1.join)(root, '.gemini', 'settings.json');
+}
+function claudeMdPath(root) {
+    return (0, path_1.join)(root, 'CLAUDE.md');
+}
+function claudeMcpPath(root) {
+    return (0, path_1.join)(root, '.mcp.json');
+}
+exports.codexConfigTomlPath = (0, path_1.join)((0, os_1.homedir)(), '.codex', 'config.toml');
+exports.nxRulesMarkerCommentStart = `<!-- nx configuration start-->`;
+exports.nxRulesMarkerCommentDescription = `<!-- Leave the start & end comments to automatically receive updates. -->`;
+exports.nxRulesMarkerCommentEnd = `<!-- nx configuration end-->`;
+exports.rulesRegex = new RegExp(`${exports.nxRulesMarkerCommentStart}[\\s\\S]*?${exports.nxRulesMarkerCommentEnd}`, 'm');
+const getAgentRulesWrapped = (writeNxCloudRules) => {
+    const agentRulesString = (0, get_agent_rules_1.getAgentRules)(writeNxCloudRules);
+    return `${exports.nxRulesMarkerCommentStart}\n${exports.nxRulesMarkerCommentDescription}\n${agentRulesString}\n${exports.nxRulesMarkerCommentEnd}`;
+};
+exports.getAgentRulesWrapped = getAgentRulesWrapped;
+exports.nxMcpTomlHeader = `[mcp_servers."nx-mcp"]`;
+exports.nxMcpTomlConfig = `${exports.nxMcpTomlHeader}
+type = "stdio"
+command = "npx"
+args = ["nx", "mcp"]
+`;

package/src/ai/set-up-ai-agents/schema.d.ts

@@ -2,6 +2,7 @@ export type SetupAiAgentsGeneratorSchema = {
   directory: string;
   writeNxCloudRules?: boolean;
   packageVersion?: string;
+  agents?: Agent[];
 };
 
 export type NormalizedSetupAiAgentsGeneratorSchema =

package/src/ai/set-up-ai-agents/schema.json

@@ -19,6 +19,15 @@
       "type": "string",
       "description": "The version of the package to use",
       "default": "latest"
+    },
+    "agents": {
+      "type": "array",
+      "description": "The agents to setup Nx configuration for.",
+      "items": {
+        "type": "string",
+        "enum": ["claude", "gemini", "codex", "cursor", "copilot"]
+      },
+      "default": ["claude", "gemini", "codex", "cursor", "copilot"]
     }
   },
   "required": ["directory"]

package/src/ai/set-up-ai-agents/set-up-ai-agents.d.ts

@@ -1,6 +1,11 @@
 import { Tree } from '../../generators/tree';
+import { CLIErrorMessageConfig, CLINoteMessageConfig } from '../../utils/output';
 import { NormalizedSetupAiAgentsGeneratorSchema, SetupAiAgentsGeneratorSchema } from './schema';
-export declare function setupAiAgentsGenerator(tree: Tree, options: SetupAiAgentsGeneratorSchema, inner?: boolean): Promise<any>;
-export declare function setupAiAgentsGeneratorImpl(tree: Tree, options: NormalizedSetupAiAgentsGeneratorSchema): Promise<void>;
+export type ModificationResults = {
+    messages: CLINoteMessageConfig[];
+    errors: CLIErrorMessageConfig[];
+};
+export declare function setupAiAgentsGenerator(tree: Tree, options: SetupAiAgentsGeneratorSchema, inner?: boolean): Promise<(check?: boolean) => Promise<ModificationResults>>;
+export declare function setupAiAgentsGeneratorImpl(tree: Tree, options: NormalizedSetupAiAgentsGeneratorSchema): Promise<() => Promise<ModificationResults>>;
 export default setupAiAgentsGenerator;
 //# sourceMappingURL=set-up-ai-agents.d.ts.map

package/src/ai/set-up-ai-agents/set-up-ai-agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-up-ai-agents.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/ai/set-up-ai-agents/set-up-ai-agents.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAK7C,OAAO,EACL,sCAAsC,EACtC,4BAA4B,EAC7B,MAAM,UAAU,CAAC;AAElB,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,4BAA4B,EACrC,KAAK,UAAQ,gBAoCd;AAYD,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,sCAAsC,iBAgChD;AAqBD,eAAe,sBAAsB,CAAC"}
+{"version":3,"file":"set-up-ai-agents.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/ai/set-up-ai-agents/set-up-ai-agents.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAc5B,OAAO,EACL,sCAAsC,EACtC,4BAA4B,EAC7B,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,oBAAoB,EAAE,CAAC;IACjC,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,4BAA4B,EACrC,KAAK,UAAQ,GACZ,OAAO,CAAC,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAmC5D;AAaD,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,sCAAsC,GAC9C,OAAO,CAAC,MAAM,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAkJ7C;AAwDD,eAAe,sBAAsB,CAAC"}

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

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupAiAgentsGenerator = setupAiAgentsGenerator;
 exports.setupAiAgentsGeneratorImpl = setupAiAgentsGeneratorImpl;
+const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
 const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
 const json_1 = require("../../generators/utils/json");
+const native_1 = require("../../native");
 const package_json_1 = require("../../utils/package-json");
 const provenance_1 = require("../../utils/provenance");
-const get_agent_rules_1 = require("./get-agent-rules");
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const constants_2 = require("../constants");
 async function setupAiAgentsGenerator(tree, options, inner = false) {
     const normalizedOptions = normalizeOptions(options);
     // Use environment variable to force local execution
@@ -32,35 +37,159 @@ function normalizeOptions(options) {
         directory: options.directory,
         writeNxCloudRules: options.writeNxCloudRules ?? false,
         packageVersion: options.packageVersion ?? 'latest',
+        agents: options.agents ?? [...utils_1.supportedAgents],
     };
 }
 async function setupAiAgentsGeneratorImpl(tree, options) {
-    const claudePath = (0, path_1.join)(options.directory, 'CLAUDE.md');
-    if (!tree.exists(claudePath)) {
-        tree.write(claudePath, (0, get_agent_rules_1.getAgentRules)(options.writeNxCloudRules));
+    const hasAgent = (agent) => options.agents.includes(agent);
+    const agentsMd = (0, constants_1.agentsMdPath)(options.directory);
+    // write AGENTS.md for most agents
+    if (hasAgent('cursor') || hasAgent('copilot') || hasAgent('codex')) {
+        writeAgentRules(tree, agentsMd, options.writeNxCloudRules);
     }
-    const agentsPath = (0, path_1.join)(options.directory, 'AGENTS.md');
-    if (!tree.exists(agentsPath)) {
-        tree.write(agentsPath, (0, get_agent_rules_1.getAgentRules)(options.writeNxCloudRules));
+    if (hasAgent('claude')) {
+        const claudePath = (0, path_1.join)(options.directory, 'CLAUDE.md');
+        writeAgentRules(tree, claudePath, options.writeNxCloudRules);
+        const mcpJsonPath = (0, path_1.join)(options.directory, '.mcp.json');
+        if (!tree.exists(mcpJsonPath)) {
+            (0, json_1.writeJson)(tree, mcpJsonPath, {});
+        }
+        (0, json_1.updateJson)(tree, mcpJsonPath, mcpConfigUpdater);
     }
-    const mcpJsonPath = (0, path_1.join)(options.directory, '.mcp.json');
-    if (!tree.exists(mcpJsonPath)) {
-        (0, json_1.writeJson)(tree, mcpJsonPath, {});
+    if (hasAgent('gemini')) {
+        const geminiSettingsPath = (0, path_1.join)(options.directory, '.gemini', 'settings.json');
+        if (!tree.exists(geminiSettingsPath)) {
+            (0, json_1.writeJson)(tree, geminiSettingsPath, {});
+        }
+        (0, json_1.updateJson)(tree, geminiSettingsPath, mcpConfigUpdater);
+        const contextFileName = (0, json_1.readJson)(tree, geminiSettingsPath).contextFileName;
+        const geminiMd = (0, constants_1.geminiMdPath)(options.directory);
+        // Only set contextFileName to AGENTS.md if GEMINI.md doesn't exist already to preserve existing setups
+        if (!contextFileName && !tree.exists(geminiMd)) {
+            writeAgentRules(tree, agentsMd, options.writeNxCloudRules);
+            (0, json_1.updateJson)(tree, geminiSettingsPath, (json) => ({
+                ...json,
+                contextFileName: 'AGENTS.md',
+            }));
+        }
+        else {
+            writeAgentRules(tree, contextFileName ?? geminiMd, options.writeNxCloudRules);
+        }
     }
-    (0, json_1.updateJson)(tree, mcpJsonPath, mcpConfigUpdater);
-    const geminiPath = (0, path_1.join)(options.directory, '.gemini', 'settings.json');
-    if (!tree.exists(geminiPath)) {
-        (0, json_1.writeJson)(tree, geminiPath, {});
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    // we use the check variable to determine if we should actually make changes or just report what would be changed
+    return async (check = false) => {
+        const messages = [];
+        const errors = [];
+        if (hasAgent('codex')) {
+            if ((0, fs_1.existsSync)(constants_1.codexConfigTomlPath)) {
+                const tomlContents = (0, fs_1.readFileSync)(constants_1.codexConfigTomlPath, 'utf-8');
+                if (!tomlContents.includes(constants_2.nxMcpTomlHeader)) {
+                    if (!check) {
+                        (0, fs_1.appendFileSync)(constants_1.codexConfigTomlPath, `\n${constants_2.nxMcpTomlConfig}`);
+                    }
+                    messages.push({
+                        title: `Updated ${constants_1.codexConfigTomlPath} with nx-mcp server`,
+                    });
+                }
+            }
+            else {
+                if (!check) {
+                    (0, fs_1.mkdirSync)((0, path_1.join)((0, os_1.homedir)(), '.codex'), { recursive: true });
+                    (0, fs_1.writeFileSync)(constants_1.codexConfigTomlPath, constants_2.nxMcpTomlConfig);
+                }
+                messages.push({
+                    title: `Created ${constants_1.codexConfigTomlPath} with nx-mcp server`,
+                });
+            }
+        }
+        if (hasAgent('copilot')) {
+            try {
+                if ((0, native_1.isEditorInstalled)(0 /* SupportedEditor.VSCode */) &&
+                    (0, native_1.canInstallNxConsoleForEditor)(0 /* SupportedEditor.VSCode */)) {
+                    if (!check) {
+                        (0, native_1.installNxConsoleForEditor)(0 /* SupportedEditor.VSCode */);
+                    }
+                    messages.push({
+                        title: `Installed Nx Console for VSCode`,
+                    });
+                }
+            }
+            catch (e) {
+                errors.push({
+                    title: `Failed to install Nx Console for VSCode. Please install it manually.`,
+                    bodyLines: [e.message],
+                });
+            }
+            try {
+                if ((0, native_1.isEditorInstalled)(1 /* SupportedEditor.VSCodeInsiders */) &&
+                    (0, native_1.canInstallNxConsoleForEditor)(1 /* SupportedEditor.VSCodeInsiders */)) {
+                    if (!check) {
+                        (0, native_1.installNxConsoleForEditor)(1 /* SupportedEditor.VSCodeInsiders */);
+                    }
+                    messages.push({
+                        title: `Installed Nx Console for VSCode Insiders`,
+                    });
+                }
+            }
+            catch (e) {
+                errors.push({
+                    title: `Failed to install Nx Console for VSCode Insiders. Please install it manually.`,
+                    bodyLines: [e.message],
+                });
+            }
+        }
+        if (hasAgent('cursor')) {
+            try {
+                if ((0, native_1.isEditorInstalled)(2 /* SupportedEditor.Cursor */) &&
+                    (0, native_1.canInstallNxConsoleForEditor)(2 /* SupportedEditor.Cursor */)) {
+                    if (!check) {
+                        (0, native_1.installNxConsoleForEditor)(2 /* SupportedEditor.Cursor */);
+                    }
+                    messages.push({
+                        title: `Installed Nx Console for Cursor`,
+                    });
+                }
+            }
+            catch (e) {
+                errors.push({
+                    title: `Failed to install Nx Console for Cursor. Please install it manually.`,
+                    bodyLines: [e.message],
+                });
+            }
+        }
+        return {
+            messages,
+            errors,
+        };
+    };
+}
+function writeAgentRules(tree, path, writeNxCloudRules) {
+    const expectedRules = (0, constants_2.getAgentRulesWrapped)(writeNxCloudRules);
+    if (!tree.exists(path)) {
+        tree.write(path, expectedRules);
+        return;
     }
-    (0, json_1.updateJson)(tree, geminiPath, mcpConfigUpdater);
-    // Only set contextFileName to AGENTS.md if GEMINI.md doesn't exist already to preserve existing setups
-    if (!tree.exists((0, path_1.join)(options.directory, 'GEMINI.md'))) {
-        (0, json_1.updateJson)(tree, geminiPath, (json) => ({
-            ...json,
-            contextFileName: 'AGENTS.md',
-        }));
+    const existing = tree.read(path, 'utf-8');
+    const regex = constants_2.rulesRegex;
+    const existingNxConfiguration = existing.match(regex);
+    if (existingNxConfiguration) {
+        const contentOnly = (str) => str
+            .replace(constants_2.nxRulesMarkerCommentStart, '')
+            .replace(constants_2.nxRulesMarkerCommentEnd, '')
+            .replace(constants_2.nxRulesMarkerCommentDescription, '')
+            .replace(/\s/g, '');
+        // we don't want to make updates on whitespace-only changes
+        if (contentOnly(existingNxConfiguration[0]) === contentOnly(expectedRules)) {
+            return;
+        }
+        // otherwise replace the existing configuration
+        const updatedContent = existing.replace(regex, expectedRules);
+        tree.write(path, updatedContent);
+    }
+    else {
+        tree.write(path, existing + '\n\n' + expectedRules);
     }
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
 }
 function mcpConfigUpdater(existing) {
     if (existing.mcpServers) {

package/src/ai/utils.d.ts

@@ -0,0 +1,20 @@
+export declare const supportedAgents: readonly ["claude", "codex", "copilot", "cursor", "gemini"];
+export type Agent = (typeof supportedAgents)[number];
+export declare const agentDisplayMap: Record<Agent, string>;
+export type AgentConfiguration = {
+    rules: boolean;
+    mcp: boolean;
+    rulesPath: string;
+    mcpPath: string | null;
+    outdated: boolean;
+    disabled?: boolean;
+};
+export declare function getAgentConfigurations(agentsToConsider: Agent[], workspaceRoot: string): Promise<{
+    nonConfiguredAgents: Agent[];
+    partiallyConfiguredAgents: Agent[];
+    fullyConfiguredAgents: Agent[];
+    disabledAgents: Agent[];
+    agentConfigurations: Map<Agent, AgentConfiguration>;
+}>;
+export declare function configureAgents(agents: Agent[], workspaceRoot: string, useLatest?: boolean): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/src/ai/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/ai/utils.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,eAAe,6DAMlB,CAAC;AACX,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AACrD,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAMjD,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,GAAG,EAAE,OAAO,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,KAAK,EAAE,EACzB,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC;IACT,mBAAmB,EAAE,KAAK,EAAE,CAAC;IAC7B,yBAAyB,EAAE,KAAK,EAAE,CAAC;IACnC,qBAAqB,EAAE,KAAK,EAAE,CAAC;IAC/B,cAAc,EAAE,KAAK,EAAE,CAAC;IACxB,mBAAmB,EAAE,GAAG,CAAC,KAAK,EAAE,kBAAkB,CAAC,CAAC;CACrD,CAAC,CA8BD;AA8ID,wBAAsB,eAAe,CACnC,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,MAAM,EACrB,SAAS,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,IAAI,CAAC,CAoBf"}

package/src/ai/utils.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentDisplayMap = exports.supportedAgents = void 0;
+exports.getAgentConfigurations = getAgentConfigurations;
+exports.configureAgents = configureAgents;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const configuration_1 = require("../config/configuration");
+const tree_1 = require("../generators/tree");
+const native_1 = require("../native");
+const fileutils_1 = require("../utils/fileutils");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+const output_1 = require("../utils/output");
+const constants_1 = require("./constants");
+const set_up_ai_agents_1 = require("./set-up-ai-agents/set-up-ai-agents");
+// when adding new agents, be sure to also update the list in
+// packages/create-nx-workspace/src/create-workspace-options.ts
+exports.supportedAgents = [
+    'claude',
+    'codex',
+    'copilot',
+    'cursor',
+    'gemini',
+];
+exports.agentDisplayMap = {
+    claude: 'Claude Code',
+    gemini: 'Gemini',
+    codex: 'OpenAI Codex',
+    copilot: 'GitHub Copilot for VSCode',
+    cursor: 'Cursor',
+};
+async function getAgentConfigurations(agentsToConsider, workspaceRoot) {
+    const nonConfiguredAgents = [];
+    const partiallyConfiguredAgents = [];
+    const fullyConfiguredAgents = [];
+    const disabledAgents = [];
+    const agentConfigurations = new Map();
+    for (const agent of agentsToConsider) {
+        const configured = await getAgentConfiguration(agent, workspaceRoot);
+        if (configured.disabled) {
+            disabledAgents.push(agent);
+            continue;
+        }
+        agentConfigurations.set(agent, configured);
+        if (configured.mcp && configured.rules) {
+            fullyConfiguredAgents.push(agent);
+        }
+        else if (!configured.mcp && !configured.rules) {
+            nonConfiguredAgents.push(agent);
+        }
+        else {
+            partiallyConfiguredAgents.push(agent);
+        }
+    }
+    return {
+        nonConfiguredAgents,
+        partiallyConfiguredAgents,
+        fullyConfiguredAgents,
+        disabledAgents,
+        agentConfigurations,
+    };
+}
+async function getAgentConfiguration(agent, workspaceRoot) {
+    let agentConfiguration;
+    switch (agent) {
+        case 'claude': {
+            const mcpPath = (0, constants_1.claudeMcpPath)(workspaceRoot);
+            let mcpConfigured;
+            try {
+                const mcpContents = (0, fileutils_1.readJsonFile)(mcpPath);
+                mcpConfigured = !!mcpContents?.['mcpServers']?.['nx-mcp'];
+            }
+            catch {
+                mcpConfigured = false;
+            }
+            const rulesPath = (0, constants_1.claudeMdPath)(workspaceRoot);
+            const rulesExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                rules: rulesExists,
+                mcp: mcpConfigured,
+                rulesPath: rulesPath,
+                mcpPath: mcpPath,
+            };
+            break;
+        }
+        case 'gemini': {
+            const geminiRulePath = (0, constants_1.geminiMdPath)(workspaceRoot);
+            const geminiMdExists = (0, fs_1.existsSync)(geminiRulePath);
+            const settingsPath = (0, constants_1.geminiSettingsPath)(workspaceRoot);
+            let mcpConfigured;
+            const geminiSettings = (0, constants_1.parseGeminiSettings)(workspaceRoot);
+            const customContextFilePath = geminiSettings?.contextFileName;
+            const customContextFilePathExists = customContextFilePath
+                ? (0, fs_1.existsSync)((0, path_1.resolve)(workspaceRoot, customContextFilePath))
+                : false;
+            mcpConfigured = geminiSettings?.['mcpServers']?.['nx-mcp'];
+            agentConfiguration = {
+                rules: (!customContextFilePath && geminiMdExists) ||
+                    (customContextFilePath && customContextFilePathExists),
+                mcp: mcpConfigured,
+                rulesPath: customContextFilePath ?? geminiRulePath,
+                mcpPath: settingsPath,
+            };
+            break;
+        }
+        case 'copilot': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const hasInstalledVSCode = (0, native_1.isEditorInstalled)(0 /* SupportedEditor.VSCode */);
+            const hasInstalledVSCodeInsiders = (0, native_1.isEditorInstalled)(1 /* SupportedEditor.VSCodeInsiders */);
+            const hasInstalledNxConsoleForVSCode = hasInstalledVSCode &&
+                !(0, native_1.canInstallNxConsoleForEditor)(0 /* SupportedEditor.VSCode */);
+            const hasInstalledNxConsoleForVSCodeInsiders = hasInstalledVSCodeInsiders &&
+                !(0, native_1.canInstallNxConsoleForEditor)(1 /* SupportedEditor.VSCodeInsiders */);
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                mcp: hasInstalledNxConsoleForVSCode ||
+                    hasInstalledNxConsoleForVSCodeInsiders,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath: null,
+                disabled: !hasInstalledVSCode && !hasInstalledVSCodeInsiders,
+            };
+            break;
+        }
+        case 'cursor': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const hasInstalledCursor = (0, native_1.isEditorInstalled)(2 /* SupportedEditor.Cursor */);
+            const hasInstalledNxConsole = !(0, native_1.canInstallNxConsoleForEditor)(2 /* SupportedEditor.Cursor */);
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                mcp: hasInstalledCursor ? hasInstalledNxConsole : false,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath: null,
+                disabled: !hasInstalledCursor,
+            };
+            break;
+        }
+        case 'codex': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            let mcpConfigured;
+            if ((0, fs_1.existsSync)(constants_1.codexConfigTomlPath)) {
+                const tomlContents = (0, fs_1.readFileSync)(constants_1.codexConfigTomlPath, 'utf-8');
+                mcpConfigured = tomlContents.includes(constants_1.nxMcpTomlHeader);
+            }
+            else {
+                mcpConfigured = false;
+            }
+            agentConfiguration = {
+                mcp: mcpConfigured,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath: constants_1.codexConfigTomlPath,
+            };
+            break;
+        }
+    }
+    return {
+        ...agentConfiguration,
+        outdated: await isAgentOutdated(agent, workspaceRoot),
+    };
+}
+async function isAgentOutdated(agent, workspaceRoot) {
+    const tree = new tree_1.FsTree(workspaceRoot, false);
+    const callback = await (0, set_up_ai_agents_1.default)(tree, {
+        directory: '.',
+        agents: [agent],
+        writeNxCloudRules: (0, nx_cloud_utils_1.isNxCloudUsed)((0, configuration_1.readNxJson)()),
+    }, true);
+    const modificationResults = await callback(true);
+    return (tree.listChanges().length > 0 || modificationResults.messages.length > 0);
+}
+async function configureAgents(agents, workspaceRoot, useLatest) {
+    const writeNxCloudRules = (0, nx_cloud_utils_1.isNxCloudUsed)((0, configuration_1.readNxJson)());
+    const tree = new tree_1.FsTree(workspaceRoot, false);
+    const callback = await (0, set_up_ai_agents_1.default)(tree, {
+        directory: '.',
+        agents,
+        writeNxCloudRules,
+    }, !useLatest);
+    // changes that are out of scope for the generator itself because they do more than modify the tree
+    (0, tree_1.flushChanges)(workspaceRoot, tree.listChanges());
+    const modificationResults = await callback();
+    modificationResults.messages.forEach((message) => output_1.output.log(message));
+    modificationResults.errors.forEach((error) => output_1.output.error(error));
+}

package/src/command-line/configure-ai-agents/command-object.d.ts

@@ -0,0 +1,9 @@
+import { CommandModule } from 'yargs';
+export interface ConfigureAiAgentsOptions {
+    agents?: string[];
+    interactive?: boolean;
+    verbose?: boolean;
+    check?: boolean;
+}
+export declare const yargsConfigureAiAgentsCommand: CommandModule<{}, ConfigureAiAgentsOptions>;
+//# sourceMappingURL=command-object.d.ts.map

package/src/command-line/configure-ai-agents/command-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-object.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/configure-ai-agents/command-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,eAAO,MAAM,6BAA6B,EAAE,aAAa,CACvD,EAAE,EACF,wBAAwB,CA6CzB,CAAC"}

package/src/command-line/configure-ai-agents/command-object.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsConfigureAiAgentsCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsConfigureAiAgentsCommand = {
+    command: 'configure-ai-agents',
+    describe: 'Configure and update AI agent configurations for your workspace.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .option('agents', {
+        type: 'array',
+        string: true,
+        description: 'List of AI agents to set up.',
+        choices: ['claude', 'codex', 'copilot', 'cursor', 'gemini'],
+    })
+        .option('interactive', {
+        type: 'boolean',
+        description: 'When false disables interactive input prompts for options.',
+        default: true,
+    })
+        .option('check', {
+        type: 'boolean',
+        description: 'Check if any configured agents are out of date and need to be updated. Does not make any changes.',
+        default: false,
+    })
+        .example('$0 configure-ai-agents', 'Interactively select AI agents to update and configure')
+        .example('$0 configure-ai-agents --agents claude gemini', 'Prompts for updates and and configuration of Claude and Gemini AI agents')
+        .example('$0 configure-ai-agents --check', 'Checks if any configured agents are out of date and need to be updated')
+        .example('$0 configure-ai-agents --agents claude gemini --no-interactive', 'Configures and updates Claude and Gemini AI agents without prompts'),
+    handler: async (args) => {
+        await (await Promise.resolve().then(() => require('./configure-ai-agents'))).configureAiAgentsHandler(args);
+    },
+};

package/src/command-line/configure-ai-agents/configure-ai-agents.d.ts

@@ -0,0 +1,4 @@
+import { ConfigureAiAgentsOptions } from './command-object';
+export declare function configureAiAgentsHandler(args: ConfigureAiAgentsOptions, inner?: boolean): Promise<void>;
+export declare function configureAiAgentsHandlerImpl(options: ConfigureAiAgentsOptions): Promise<void>;
+//# sourceMappingURL=configure-ai-agents.d.ts.map

package/src/command-line/configure-ai-agents/configure-ai-agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure-ai-agents.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/configure-ai-agents/configure-ai-agents.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAI5D,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,wBAAwB,EAC9B,KAAK,UAAQ,GACZ,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC,CAkMf"}