nx 20.8.4 → 22.7.7

package/dist/src/ai/utils.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentDisplayMap = exports.supportedAgents = void 0;
+exports.getAgentConfigurations = getAgentConfigurations;
+exports.configureAgents = configureAgents;
+const tslib_1 = require("tslib");
+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 = tslib_1.__importDefault(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 = await (0, native_1.isEditorInstalled)(0 /* SupportedEditor.VSCode */);
+            const hasInstalledVSCodeInsiders = await (0, native_1.isEditorInstalled)(1 /* SupportedEditor.VSCodeInsiders */);
+            const hasInstalledNxConsoleForVSCode = hasInstalledVSCode &&
+                !(await (0, native_1.canInstallNxConsoleForEditor)(0 /* SupportedEditor.VSCode */));
+            const hasInstalledNxConsoleForVSCodeInsiders = hasInstalledVSCodeInsiders &&
+                !(await (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 = await (0, native_1.isEditorInstalled)(2 /* SupportedEditor.Cursor */);
+            const hasInstalledNxConsole = !(await (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);
+            const mcpPath = (0, constants_1.codexConfigTomlPath)(workspaceRoot);
+            let mcpConfigured;
+            if ((0, fs_1.existsSync)(mcpPath)) {
+                const tomlContents = (0, fs_1.readFileSync)(mcpPath, 'utf-8');
+                mcpConfigured = tomlContents.includes(constants_1.nxMcpTomlHeader);
+            }
+            else {
+                mcpConfigured = false;
+            }
+            agentConfiguration = {
+                mcp: mcpConfigured,
+                rules: agentsMdExists,
+                rulesPath,
+                mcpPath,
+            };
+            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/dist/src/analytics/analytics.d.ts

@@ -0,0 +1,10 @@
+import type { EventDimensions } from '../native';
+export declare const customDimensions: EventDimensions;
+export type EventParameters = Partial<Record<EventDimensions[keyof EventDimensions], string | number | boolean>>;
+export declare function startAnalytics(): Promise<void>;
+export declare function reportNxAddCommand(packageName: string, version: string): void;
+export declare function reportNxGenerateCommand(generator: string): void;
+export declare function reportCommandRunEvent(command: string, parameters?: Record<string, any>, args?: Record<string, any>): void;
+export declare function reportEvent(name: string, eventParameters?: EventParameters): void;
+export declare function argsToQueryString(args: Record<string, any>): string;
+export declare function flushAnalytics(): void;

package/dist/src/analytics/analytics.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customDimensions = void 0;
+exports.startAnalytics = startAnalytics;
+exports.reportNxAddCommand = reportNxAddCommand;
+exports.reportNxGenerateCommand = reportNxGenerateCommand;
+exports.reportCommandRunEvent = reportCommandRunEvent;
+exports.reportEvent = reportEvent;
+exports.argsToQueryString = argsToQueryString;
+exports.flushAnalytics = flushAnalytics;
+const tslib_1 = require("tslib");
+const nx_json_1 = require("../config/nx-json");
+const workspace_root_1 = require("../utils/workspace-root");
+const versions_1 = require("../utils/versions");
+const native_1 = require("../native");
+const package_manager_1 = require("../utils/package-manager");
+const semver_1 = require("semver");
+const os = tslib_1.__importStar(require("os"));
+const crypto_1 = require("crypto");
+const machine_id_cache_1 = require("../utils/machine-id-cache");
+const is_ci_1 = require("../utils/is-ci");
+const analytics_prompt_1 = require("../utils/analytics-prompt");
+const db_connection_1 = require("../utils/db-connection");
+// Conditionally import telemetry functions only on non-WASM platforms
+let initializeTelemetry;
+let initializeTelemetryWithSessionId;
+let flushTelemetry;
+let trackEventNative;
+let trackPageViewNative;
+let getEventDimensions;
+if (!native_1.IS_WASM) {
+    const nativeModule = require('../native');
+    initializeTelemetry = nativeModule.initializeTelemetry;
+    initializeTelemetryWithSessionId =
+        nativeModule.initializeTelemetryWithSessionId;
+    flushTelemetry = nativeModule.flushTelemetry;
+    trackEventNative = nativeModule.trackEvent;
+    trackPageViewNative = nativeModule.trackPageView;
+    getEventDimensions = nativeModule.getEventDimensions;
+}
+exports.customDimensions = native_1.IS_WASM
+    ? null
+    : (getEventDimensions?.() ?? null);
+let _telemetryInitialized = false;
+async function startAnalytics() {
+    // Analytics not supported on WASM
+    if (native_1.IS_WASM) {
+        return;
+    }
+    if (!isAnalyticsEnabled()) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
+    const workspaceId = (0, analytics_prompt_1.generateWorkspaceId)();
+    if (!workspaceId) {
+        // Not a git repo — no telemetry
+        return;
+    }
+    const isNxCloud = !!(nxJson?.nxCloudId ?? nxJson?.nxCloudAccessToken);
+    const userId = await getTelemetryUserId(workspaceId);
+    const packageManagerInfo = getPackageManagerInfo();
+    const nodeVersion = (0, semver_1.parse)(process.version);
+    const nodeVersionString = nodeVersion
+        ? `${nodeVersion.major}.${nodeVersion.minor}.${nodeVersion.patch}`
+        : 'unknown';
+    const commonArgs = [
+        workspaceId,
+        userId,
+        versions_1.nxVersion,
+        packageManagerInfo.name,
+        packageManagerInfo.version,
+        nodeVersionString,
+        os.arch(),
+        os.platform(),
+        os.release(),
+        !!(0, is_ci_1.isCI)(),
+        isNxCloud,
+    ];
+    try {
+        const sessionId = process.env.NX_ANALYTICS_SESSION_ID;
+        if (sessionId) {
+            // Plugin worker path — reuse session ID from parent, no DB needed
+            initializeTelemetryWithSessionId(sessionId, ...commonArgs);
+        }
+        else {
+            // CLI/daemon path — get session from DB, set env var for children
+            const dbConnection = (0, db_connection_1.getDbConnection)();
+            const newSessionId = initializeTelemetry(dbConnection, ...commonArgs);
+            process.env.NX_ANALYTICS_SESSION_ID = newSessionId;
+        }
+        _telemetryInitialized = true;
+        // Flush analytics automatically on process exit so every code path
+        // is covered without needing explicit exitAndFlushAnalytics() calls.
+        process.on('exit', () => {
+            flushAnalytics();
+        });
+    }
+    catch (error) {
+        // If telemetry service fails to initialize, continue without it
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log(`Failed to initialize telemetry: ${error.message}`);
+        }
+    }
+}
+function reportNxAddCommand(packageName, version) {
+    reportCommandRunEvent('add', {
+        [exports.customDimensions.packageName]: packageName,
+        [exports.customDimensions.packageVersion]: version,
+    });
+}
+function reportNxGenerateCommand(generator) {
+    reportCommandRunEvent('generate', {
+        [exports.customDimensions.generatorName]: generator,
+    });
+}
+function reportCommandRunEvent(command, parameters, args) {
+    command = command === 'g' ? 'generate' : command;
+    let pageLocation = command;
+    if (args) {
+        const qs = argsToQueryString(args);
+        if (qs) {
+            pageLocation = `${command}?${qs}`;
+        }
+    }
+    trackPageView(command, pageLocation, parameters);
+}
+function reportEvent(name, eventParameters) {
+    trackEvent(name, eventParameters);
+}
+const SKIP_ARGS_KEYS = new Set([
+    '$0',
+    '_',
+    '__overrides_unparsed__',
+    '__overrides__',
+]);
+// String args with fixed enum values that are safe to include in analytics.
+// All boolean and number args are included automatically.
+const ALLOWED_STRING_ARGS = new Set([
+    'outputStyle',
+    'type',
+    'view',
+    'access',
+    'preset',
+    'interactive',
+    'printConfig',
+    'resolveVersionPlans',
+]);
+function argsToQueryString(args) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(args)) {
+        if (SKIP_ARGS_KEYS.has(key))
+            continue;
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value === 'boolean' || typeof value === 'number') {
+            params.append(key, String(value));
+        }
+        else if (typeof value === 'string' && ALLOWED_STRING_ARGS.has(key)) {
+            params.append(key, value);
+        }
+        // All other types (strings, arrays, objects) are dropped
+    }
+    return params.toString();
+}
+function trackEvent(eventName, parameters) {
+    if (_telemetryInitialized) {
+        // Convert parameters to string map for Rust
+        const stringParams = {};
+        if (parameters) {
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value !== undefined && value !== null) {
+                    stringParams[key] = String(value);
+                }
+            }
+        }
+        // Fire and forget - synchronous call
+        try {
+            trackEventNative(eventName, stringParams);
+        }
+        catch {
+            // Silently ignore errors
+        }
+    }
+}
+function trackPageView(pageTitle, pageLocation, parameters) {
+    if (_telemetryInitialized) {
+        // Convert parameters to string map for Rust
+        const stringParams = {};
+        if (parameters) {
+            for (const [key, value] of Object.entries(parameters)) {
+                if (value !== undefined && value !== null) {
+                    stringParams[key] = String(value);
+                }
+            }
+        }
+        // Fire and forget - synchronous call
+        try {
+            trackPageViewNative(pageTitle, pageLocation, stringParams);
+        }
+        catch {
+            // Silently ignore errors
+        }
+    }
+}
+function flushAnalytics() {
+    if (_telemetryInitialized) {
+        try {
+            flushTelemetry();
+        }
+        catch (error) {
+            // Failure to report analytics shouldn't crash the CLI
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.log(`Failed to flush telemetry: ${error.message}`);
+            }
+        }
+    }
+}
+function getPackageManagerInfo() {
+    const pm = (0, package_manager_1.detectPackageManager)();
+    return {
+        name: pm,
+        version: (0, package_manager_1.getPackageManagerVersion)(pm),
+    };
+}
+function isAnalyticsEnabled() {
+    const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
+    return nxJson?.analytics === true;
+}
+// Mix workspace id in: shared Docker images (Gitpod, Cypress, etc.) bake
+// in /etc/machine-id, so machine-id alone collapses many users into one.
+async function getTelemetryUserId(workspaceId) {
+    const machineId = await (0, machine_id_cache_1.getCurrentMachineId)();
+    return (0, crypto_1.createHash)('sha256')
+        .update(`${machineId}|${workspaceId}`)
+        .digest('hex');
+}

package/dist/src/analytics/index.d.ts

@@ -0,0 +1 @@
+export { customDimensions, EventParameters, startAnalytics, reportNxAddCommand, reportNxGenerateCommand, reportCommandRunEvent, reportEvent, flushAnalytics, } from './analytics';

package/dist/src/analytics/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushAnalytics = exports.reportEvent = exports.reportCommandRunEvent = exports.reportNxGenerateCommand = exports.reportNxAddCommand = exports.startAnalytics = exports.customDimensions = void 0;
+var analytics_1 = require("./analytics");
+Object.defineProperty(exports, "customDimensions", { enumerable: true, get: function () { return analytics_1.customDimensions; } });
+Object.defineProperty(exports, "startAnalytics", { enumerable: true, get: function () { return analytics_1.startAnalytics; } });
+Object.defineProperty(exports, "reportNxAddCommand", { enumerable: true, get: function () { return analytics_1.reportNxAddCommand; } });
+Object.defineProperty(exports, "reportNxGenerateCommand", { enumerable: true, get: function () { return analytics_1.reportNxGenerateCommand; } });
+Object.defineProperty(exports, "reportCommandRunEvent", { enumerable: true, get: function () { return analytics_1.reportCommandRunEvent; } });
+Object.defineProperty(exports, "reportEvent", { enumerable: true, get: function () { return analytics_1.reportEvent; } });
+Object.defineProperty(exports, "flushAnalytics", { enumerable: true, get: function () { return analytics_1.flushAnalytics; } });

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

@@ -0,0 +1,126 @@
+"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");
+const analytics_1 = require("../../analytics");
+function addHandler(options) {
+    return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
+        output_1.output.addNewline();
+        const [pkgName, version] = parsePackageSpecifier(options.packageSpecifier);
+        (0, analytics_1.reportNxAddCommand)(pkgName, version);
+        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: true,
+        }, (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(require.resolve('nx/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/dist/src/command-line/add/command-object.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsAddCommand = void 0;
+const handle_import_1 = require("../../utils/handle-import");
+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 (0, handle_import_1.handleImport)('./add.js', __dirname).then((m) => m.addHandler((0, shared_options_1.withOverrides)(args))));
+    },
+};