@depup/nx 22.5.4-depup.0

package/src/ai/utils.js

@@ -0,0 +1,215 @@
+"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',
+    'opencode',
+];
+exports.agentDisplayMap = {
+    claude: 'Claude Code',
+    gemini: 'Gemini',
+    codex: 'OpenAI Codex',
+    copilot: 'GitHub Copilot for VSCode',
+    cursor: 'Cursor',
+    opencode: 'OpenCode',
+};
+async function getAgentConfigurations(agentsToConsider, workspaceRoot) {
+    const nonConfiguredAgents = [];
+    const partiallyConfiguredAgents = [];
+    const fullyConfiguredAgents = [];
+    const disabledAgents = [];
+    for (const agent of agentsToConsider) {
+        const configuration = await getAgentConfiguration(agent, workspaceRoot);
+        if (configuration.disabled) {
+            disabledAgents.push(configuration);
+            continue;
+        }
+        if (configuration.mcp && configuration.rules) {
+            fullyConfiguredAgents.push(configuration);
+        }
+        else if (!configuration.mcp && !configuration.rules) {
+            nonConfiguredAgents.push(configuration);
+        }
+        else {
+            partiallyConfiguredAgents.push(configuration);
+        }
+    }
+    return {
+        nonConfiguredAgents,
+        partiallyConfiguredAgents,
+        fullyConfiguredAgents,
+        disabledAgents,
+    };
+}
+async function getAgentConfiguration(agent, workspaceRoot) {
+    let agentConfiguration;
+    switch (agent) {
+        case 'claude': {
+            // Claude uses a plugin from marketplace which includes the MCP server
+            const claudeSettingsPath = (0, path_1.resolve)(workspaceRoot, '.claude', 'settings.json');
+            let pluginConfigured;
+            try {
+                const settingsContents = (0, fileutils_1.readJsonFile)(claudeSettingsPath);
+                pluginConfigured =
+                    !!settingsContents?.['enabledPlugins']?.['nx@nx-claude-plugins'];
+            }
+            catch {
+                pluginConfigured = false;
+            }
+            const rulesPath = (0, constants_1.claudeMdPath)(workspaceRoot);
+            const rulesExists = (0, fs_1.existsSync)(rulesPath);
+            agentConfiguration = {
+                rules: rulesExists,
+                mcp: pluginConfigured,
+                rulesPath: rulesPath,
+                mcpPath: claudeSettingsPath,
+            };
+            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 = typeof geminiSettings?.contextFileName === 'string'
+                ? geminiSettings.contextFileName
+                : undefined;
+            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;
+        }
+        case 'opencode': {
+            const rulesPath = (0, constants_1.agentsMdPath)(workspaceRoot);
+            const agentsMdExists = (0, fs_1.existsSync)(rulesPath);
+            const mcpPath = (0, constants_1.opencodeMcpPath)(workspaceRoot);
+            let mcpConfigured;
+            try {
+                const mcpContents = (0, fileutils_1.readJsonFile)(mcpPath);
+                // OpenCode uses 'mcp' property, not 'mcpServers'
+                mcpConfigured = !!mcpContents?.['mcp']?.['nx-mcp'];
+            }
+            catch {
+                mcpConfigured = false;
+            }
+            agentConfiguration = {
+                mcp: mcpConfigured,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath,
+            };
+            break;
+        }
+    }
+    return {
+        ...agentConfiguration,
+        outdated: agentConfiguration.mcp &&
+            agentConfiguration.rules &&
+            (await agentWouldChangeWithGenerator(agent, workspaceRoot)),
+        name: agent,
+        displayName: exports.agentDisplayMap[agent],
+    };
+}
+async function agentWouldChangeWithGenerator(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/add/add.d.ts

@@ -0,0 +1,4 @@
+import type { AddOptions } from './command-object';
+export declare function addHandler(options: AddOptions): Promise<number>;
+export declare const coreNxPluginVersions: Map<string, string>;
+//# sourceMappingURL=add.d.ts.map

package/src/command-line/add/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/add/add.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AASnD,wBAAgB,UAAU,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAc/D;AAgID,eAAO,MAAM,oBAAoB,qBAUhC,CAAC"}

package/src/command-line/add/add.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreNxPluginVersions = void 0;
+exports.addHandler = addHandler;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const nx_json_1 = require("../../config/nx-json");
+const child_process_2 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
+const handle_errors_1 = require("../../utils/handle-errors");
+const versions_1 = require("../../utils/versions");
+const workspace_root_1 = require("../../utils/workspace-root");
+const add_nx_scripts_1 = require("../init/implementation/dot-nx/add-nx-scripts");
+const semver_1 = require("semver");
+const configure_plugins_1 = require("../init/configure-plugins");
+const spinner_1 = require("../../utils/spinner");
+function addHandler(options) {
+    return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
+        output_1.output.addNewline();
+        const [pkgName, version] = parsePackageSpecifier(options.packageSpecifier);
+        const nxJson = (0, nx_json_1.readNxJson)();
+        await installPackage(pkgName, version, nxJson);
+        await initializePlugin(pkgName, options, nxJson);
+        output_1.output.success({
+            title: `Package ${pkgName} added successfully.`,
+        });
+    });
+}
+async function installPackage(pkgName, version, nxJson) {
+    const spinner = spinner_1.globalSpinner.start(`Installing ${pkgName}@${version}...`);
+    if ((0, fs_1.existsSync)('package.json')) {
+        const pm = (0, package_manager_1.detectPackageManager)();
+        const pmv = (0, package_manager_1.getPackageManagerVersion)(pm);
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(pm);
+        // if we explicitly specify latest in yarn berry, it won't resolve the version
+        const command = pm === 'yarn' && (0, semver_1.gte)(pmv, '2.0.0') && version === 'latest'
+            ? `${pmc.addDev} ${pkgName}`
+            : `${pmc.addDev} ${pkgName}@${version}`;
+        await new Promise((resolve) => (0, child_process_1.exec)(command, {
+            windowsHide: false,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                spinner.fail();
+                output_1.output.addNewline();
+                const errorOutput = [stdout.trim(), stderr.trim()]
+                    .filter(Boolean)
+                    .join('\n');
+                logger_1.logger.error(errorOutput);
+                output_1.output.error({
+                    title: `Failed to install ${pkgName}. Please check the error above for more details.`,
+                });
+                process.exit(1);
+            }
+            return resolve();
+        }));
+    }
+    else {
+        nxJson.installation.plugins ??= {};
+        nxJson.installation.plugins[pkgName] = (0, add_nx_scripts_1.normalizeVersionForNxJson)(pkgName, version);
+        (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+        try {
+            await (0, child_process_2.runNxAsync)('--help', { silent: true });
+        }
+        catch (e) {
+            // revert adding the plugin to nx.json
+            nxJson.installation.plugins[pkgName] = undefined;
+            (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+            spinner.fail();
+            output_1.output.addNewline();
+            logger_1.logger.error(e.message);
+            output_1.output.error({
+                title: `Failed to install ${pkgName}. Please check the error above for more details.`,
+            });
+            process.exit(1);
+        }
+    }
+    spinner.succeed();
+}
+async function initializePlugin(pkgName, options, nxJson) {
+    let updatePackageScripts = false;
+    if (exports.coreNxPluginVersions.has(pkgName) &&
+        (options.updatePackageScripts ||
+            (options.updatePackageScripts === undefined &&
+                nxJson.useInferencePlugins !== false &&
+                process.env.NX_ADD_PLUGINS !== 'false'))) {
+        updatePackageScripts = true;
+    }
+    const spinner = spinner_1.globalSpinner.start(`Initializing ${pkgName}...`);
+    try {
+        await (0, configure_plugins_1.runPluginInitGenerator)(pkgName, workspace_root_1.workspaceRoot, updatePackageScripts, options.verbose);
+    }
+    catch (e) {
+        spinner.fail();
+        output_1.output.addNewline();
+        output_1.output.error({
+            title: `Failed to initialize ${pkgName}`,
+            bodyLines: (0, configure_plugins_1.getFailedToInstallPluginErrorMessages)(e),
+        });
+        process.exit(1);
+    }
+    spinner.succeed();
+}
+function parsePackageSpecifier(packageSpecifier) {
+    const i = packageSpecifier.lastIndexOf('@');
+    if (i <= 0) {
+        if (exports.coreNxPluginVersions.has(packageSpecifier)) {
+            return [packageSpecifier, exports.coreNxPluginVersions.get(packageSpecifier)];
+        }
+        return [packageSpecifier, 'latest'];
+    }
+    const pkgName = packageSpecifier.substring(0, i);
+    const version = packageSpecifier.substring(i + 1);
+    return [pkgName, version];
+}
+exports.coreNxPluginVersions = require('../../../package.json')['nx-migrations'].packageGroup.reduce((map, entry) => {
+    const packageName = typeof entry === 'string' ? entry : entry.package;
+    const version = typeof entry === 'string' ? versions_1.nxVersion : entry.version;
+    return map.set(packageName, version);
+}, 
+// Package Name -> Desired Version
+new Map());

package/src/command-line/add/command-object.d.ts

@@ -0,0 +1,9 @@
+import { CommandModule } from 'yargs';
+export interface AddOptions {
+    packageSpecifier: string;
+    updatePackageScripts?: boolean;
+    verbose?: boolean;
+    __overrides_unparsed__: string[];
+}
+export declare const yargsAddCommand: CommandModule<{}, AddOptions>;
+//# sourceMappingURL=command-object.d.ts.map

package/src/command-line/add/command-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-object.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/add/command-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAGtC,MAAM,WAAW,UAAU;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sBAAsB,EAAE,MAAM,EAAE,CAAC;CAClC;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,CAAC,EAAE,EAAE,UAAU,CAoCzD,CAAC"}

package/src/command-line/add/command-object.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsAddCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsAddCommand = {
+    command: 'add <packageSpecifier>',
+    describe: 'Install a plugin and initialize it.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+    })
+        .positional('packageSpecifier', {
+        type: 'string',
+        description: 'The package name and optional version (e.g. `@nx/react` or `@nx/react@latest`) to install and initialize. If the version is not specified it will install the same version as the `nx` package for Nx core plugins or the latest version for other packages.',
+    })
+        .option('updatePackageScripts', {
+        type: 'boolean',
+        description: 'Update `package.json` scripts with inferred targets. Defaults to `true` when the package is a core Nx plugin.',
+    })
+        .example('$0 add @nx/react', 'Install the latest version of the `@nx/react` package and run its `@nx/react:init` generator')
+        .example('$0 add non-core-nx-plugin', 'Install the latest version of the `non-core-nx-plugin` package and run its `non-core-nx-plugin:init` generator if available')
+        .example('$0 add @nx/react@17.0.0', 'Install version `17.0.0` of the `@nx/react` package and run its `@nx/react:init` generator'),
+    handler: async (args) => {
+        process.exit(await Promise.resolve().then(() => require('./add')).then((m) => m.addHandler((0, shared_options_1.withOverrides)(args))));
+    },
+};

package/src/command-line/affected/affected.d.ts

@@ -0,0 +1,11 @@
+import type { NxArgs } from '../../utils/command-line-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function affected(command: 'graph' | 'print-affected' | 'affected', args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;
+export declare function getAffectedGraphNodes(nxArgs: NxArgs, projectGraph: ProjectGraph): Promise<ProjectGraphProjectNode[]>;
+//# sourceMappingURL=affected.d.ts.map

package/src/command-line/affected/affected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affected.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/affected/affected.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAQ7D,OAAO,EACL,YAAY,EACZ,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAMlF,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,GAAG,gBAAgB,GAAG,UAAU,EAChD,IAAI,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,uBAAuB,GAAE,MAAM,CAC7B,MAAM,EACN,CAAC,sBAAsB,GAAG,MAAM,CAAC,EAAE,CAC/B,EACN,YAAY,GAGP;IACH,uBAAuB,EAAE,OAAO,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC;CAC1B,GACA,OAAO,CAAC,IAAI,CAAC,CAiEf;AAED,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAmBpC"}

package/src/command-line/affected/affected.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.affected = affected;
+exports.getAffectedGraphNodes = getAffectedGraphNodes;
+const file_utils_1 = require("../../project-graph/file-utils");
+const run_command_1 = require("../../tasks-runner/run-command");
+const output_1 = require("../../utils/output");
+const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const perf_hooks_1 = require("perf_hooks");
+const project_graph_1 = require("../../project-graph/project-graph");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const configuration_1 = require("../../config/configuration");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const graph_1 = require("../graph/graph");
+async function affected(command, args, extraTargetDependencies = {}, extraOptions = {
+    excludeTaskDependencies: args.excludeTaskDependencies,
+    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+}) {
+    perf_hooks_1.performance.mark('code-loading:end');
+    perf_hooks_1.performance.measure('code-loading', 'init-local', 'code-loading:end');
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+        printWarnings: command !== 'print-affected' && !args.plain && args.graph !== 'stdout',
+    }, nxJson);
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({
+        exitOnError: true,
+    });
+    const projects = await getAffectedGraphNodes(nxArgs, projectGraph);
+    try {
+        switch (command) {
+            case 'affected': {
+                const projectsWithTarget = allProjectsWithTarget(projects, nxArgs);
+                if (nxArgs.graph) {
+                    const projectNames = projectsWithTarget.map((t) => t.name);
+                    const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+                    return await (0, graph_1.generateGraph)({
+                        watch: true,
+                        open: true,
+                        view: 'tasks',
+                        targets: nxArgs.targets,
+                        all: nxArgs.all &&
+                            (!nxArgs.projects || nxArgs.projects.length === 0),
+                        projects: projectNames,
+                        file,
+                    }, projectNames);
+                }
+                else {
+                    const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+                    process.exit(status);
+                }
+                break;
+            }
+        }
+        await output_1.output.drain();
+    }
+    catch (e) {
+        printError(e, args.verbose);
+        process.exit(1);
+    }
+}
+async function getAffectedGraphNodes(nxArgs, projectGraph) {
+    let affectedGraph = nxArgs.all
+        ? projectGraph
+        : await (0, affected_project_graph_1.filterAffected)(projectGraph, (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, nxArgs));
+    if (nxArgs.exclude) {
+        const excludedProjects = new Set((0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, affectedGraph.nodes));
+        return Object.entries(affectedGraph.nodes)
+            .filter(([projectName]) => !excludedProjects.has(projectName))
+            .map(([, project]) => project);
+    }
+    return Object.values(affectedGraph.nodes);
+}
+function allProjectsWithTarget(projects, nxArgs) {
+    return projects.filter((p) => nxArgs.targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(p, target)));
+}
+function printError(e, verbose) {
+    const bodyLines = [e.message];
+    if (verbose && e.stack) {
+        bodyLines.push('');
+        bodyLines.push(e.stack);
+    }
+    output_1.output.error({
+        title: 'There was a critical error when running your command',
+        bodyLines,
+    });
+}

package/src/command-line/affected/command-object.d.ts

@@ -0,0 +1,7 @@
+import { CommandModule } from 'yargs';
+export declare const yargsAffectedCommand: CommandModule;
+export declare const yargsAffectedTestCommand: CommandModule;
+export declare const yargsAffectedBuildCommand: CommandModule;
+export declare const yargsAffectedLintCommand: CommandModule;
+export declare const yargsAffectedE2ECommand: CommandModule;
+//# sourceMappingURL=command-object.d.ts.map

package/src/command-line/affected/command-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-object.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/affected/command-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AActC,eAAO,MAAM,oBAAoB,EAAE,aAwClC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,aAwBtC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,aAwBvC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,aAwBtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,aAwBrC,CAAC"}

package/src/command-line/affected/command-object.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsAffectedE2ECommand = exports.yargsAffectedLintCommand = exports.yargsAffectedBuildCommand = exports.yargsAffectedTestCommand = exports.yargsAffectedCommand = void 0;
+const handle_errors_1 = require("../../utils/handle-errors");
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsAffectedCommand = {
+    command: 'affected',
+    describe: 'Run target for affected projects. Affected projects are projects that have been changed and projects that depend on the changed projects. See https://nx.dev/ci/features/affected for more details.',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs))))))
+        .option('all', {
+        type: 'boolean',
+        deprecated: 'Use `nx run-many` instead',
+    })
+        .middleware((args) => {
+        if (args.all !== undefined) {
+            throw new Error("The '--all' option has been removed for `nx affected`. Use 'nx run-many' instead.");
+        }
+    }), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', (0, shared_options_1.withOverrides)(args));
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedTestCommand = {
+    command: 'affected:test',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs))))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'test',
+            });
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedBuildCommand = {
+    command: 'affected:build',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs))))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'build',
+            });
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedLintCommand = {
+    command: 'affected:lint',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs))))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'lint',
+            });
+        });
+        process.exit(exitCode);
+    },
+};
+exports.yargsAffectedE2ECommand = {
+    command: 'affected:e2e',
+    describe: false,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withAffectedOptions)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withConfiguration)(yargs))))), 'affected'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./affected'))).affected('affected', {
+                ...(0, shared_options_1.withOverrides)(args),
+                target: 'e2e',
+            });
+        });
+        process.exit(exitCode);
+    },
+};

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 | 'outdated' | 'all';
+}
+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,GAAG,UAAU,GAAG,KAAK,CAAC;CACtC;AAED,eAAO,MAAM,6BAA6B,EAAE,aAAa,CACvD,EAAE,EACF,wBAAwB,CA2DzB,CAAC"}

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

@@ -0,0 +1,46 @@
+"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', 'opencode'],
+    })
+        .option('interactive', {
+        type: 'boolean',
+        description: 'When false disables interactive input prompts for options.',
+        default: true,
+    })
+        .option('check', {
+        type: 'string',
+        description: 'Check agent configurations. Use --check or --check=outdated to check only configured agents, or --check=all to include unconfigured/partial configurations. Does not make any changes.',
+        coerce: (value) => {
+            // --check (no value)
+            if (value === '')
+                return 'outdated';
+            // --check=true
+            if (value === 'true')
+                return 'outdated';
+            // --no-check or --check=false
+            if (value === 'false')
+                return false;
+            // --check=all or --check=outdated
+            return value;
+        },
+        choices: ['outdated', 'all'],
+    })
+        .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 --check=all', 'Checks if any agents are not configured, out of date or partially configured')
+        .example('$0 configure-ai-agents --agents claude gemini --no-interactive', 'Configures and updates Claude and Gemini AI agents without prompts'), // because of the coerce function
+    handler: async (args) => {
+        await (await Promise.resolve().then(() => require('./configure-ai-agents'))).configureAiAgentsHandler(args);
+    },
+};