@ohos-ports/nx 17.3.2-beta.0

package/src/command-line/init/implementation/react/write-craco-config.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCracoConfig = void 0;
+const fs_1 = require("fs");
+function writeCracoConfig(appName, isCRA5, isStandalone) {
+    const configOverride = `
+  const path = require('path');
+  const TsConfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
+  const ModuleScopePlugin = require('react-dev-utils/ModuleScopePlugin');
+  module.exports = {
+    webpack: {
+      configure: (config) => {
+        // Remove guard against importing modules outside of \`src\`.
+        // Needed for workspace projects.
+        config.resolve.plugins = config.resolve.plugins.filter(
+          (plugin) => !(plugin instanceof ModuleScopePlugin)
+        );
+        // Add support for importing workspace projects.
+        config.resolve.plugins.push(
+          new TsConfigPathsPlugin({
+            configFile: path.resolve(__dirname, 'tsconfig.json'),
+            extensions: ['.ts', '.tsx', '.js', '.jsx'],
+            mainFields: ['browser', 'module', 'main'],
+          })
+        );
+        ${isCRA5
+        ? `
+        // Replace include option for babel loader with exclude
+        // so babel will handle workspace projects as well.
+        config.module.rules[1].oneOf.forEach((r) => {
+          if (r.loader && r.loader.indexOf('babel') !== -1) {
+            r.exclude = /node_modules/;
+            delete r.include;
+          }
+        });`
+        : `
+        // Replace include option for babel loader with exclude
+        // so babel will handle workspace projects as well.
+        config.module.rules.forEach((r) => {
+          if (r.oneOf) {
+            const babelLoader = r.oneOf.find(
+              (rr) => rr.loader.indexOf('babel-loader') !== -1
+            );
+            babelLoader.exclude = /node_modules/;
+            delete babelLoader.include;
+          }
+        });
+        `}
+        return config;
+      },
+    },
+    jest: {
+      configure: (config) => {
+        config.resolver = '@nx/jest/plugins/resolver';
+        return config;
+      },
+    },
+  };
+  `;
+    (0, fs_1.writeFileSync)(isStandalone ? 'craco.config.js' : `apps/${appName}/craco.config.js`, configOverride);
+}
+exports.writeCracoConfig = writeCracoConfig;

package/src/command-line/init/implementation/react/write-vite-config.d.ts

@@ -0,0 +1 @@
+export declare function writeViteConfig(appName: string, isStandalone: boolean, isJs: boolean): void;

package/src/command-line/init/implementation/react/write-vite-config.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeViteConfig = void 0;
+const fs_1 = require("fs");
+function writeViteConfig(appName, isStandalone, isJs) {
+    let port = 4200;
+    // Use PORT from .env file if it exists in project.
+    if ((0, fs_1.existsSync)(`../.env`)) {
+        const envFile = (0, fs_1.readFileSync)(`../.env`).toString();
+        const result = envFile.match(/\bport=(?<port>\d{4})/i);
+        const portCandidate = Number(result?.groups?.port);
+        if (!isNaN(portCandidate)) {
+            port = portCandidate;
+        }
+    }
+    (0, fs_1.writeFileSync)(isStandalone ? 'vite.config.js' : `apps/${appName}/vite.config.js`, `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  build: {
+    outDir: ${isStandalone ? `'./dist/${appName}'` : `'../../dist/apps/${appName}'`}
+  },
+  server: {
+    port: ${port},
+    open: true,
+  },
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: 'src/setupTests.${isJs ? 'js' : 'ts'}',
+    css: true,
+  },
+  plugins: [react()],
+});
+`);
+}
+exports.writeViteConfig = writeViteConfig;

package/src/command-line/init/implementation/react/write-vite-index-html.d.ts

@@ -0,0 +1 @@
+export declare function writeViteIndexHtml(appName: string, isStandalone: boolean, isJs: boolean): void;

package/src/command-line/init/implementation/react/write-vite-index-html.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeViteIndexHtml = void 0;
+const fs_1 = require("fs");
+function writeViteIndexHtml(appName, isStandalone, isJs) {
+    const indexPath = isStandalone ? 'index.html' : `apps/${appName}/index.html`;
+    if ((0, fs_1.existsSync)(indexPath)) {
+        (0, fs_1.copyFileSync)(indexPath, indexPath + '.old');
+    }
+    const indexFile = isJs ? '/src/index.jsx' : '/src/index.tsx';
+    (0, fs_1.writeFileSync)(indexPath, `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" href="/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React + Nx</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="${indexFile}"></script>
+  </body>
+</html>`);
+}
+exports.writeViteIndexHtml = writeViteIndexHtml;

package/src/command-line/init/implementation/utils.d.ts

@@ -0,0 +1,16 @@
+import { PackageManagerCommands } from '../../../utils/package-manager';
+export declare function createNxJsonFile(repoRoot: string, topologicalTargets: string[], cacheableOperations: string[], scriptOutputs: {
+    [name: string]: string;
+}): void;
+export declare function addDepsToPackageJson(repoRoot: string, additionalPackages?: string[]): void;
+export declare function updateGitIgnore(root: string): void;
+export declare function runInstall(repoRoot: string, pmc?: PackageManagerCommands): void;
+export declare function initCloud(repoRoot: string, installationSource: 'nx-init-angular' | 'nx-init-cra' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo'): void;
+export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;
+export declare function markRootPackageJsonAsNxProject(repoRoot: string, cacheableScripts: string[], scriptOutputs: {
+    [script: string]: string;
+}, pmc: PackageManagerCommands): void;
+export declare function printFinalMessage({ learnMoreLink, bodyLines, }: {
+    learnMoreLink?: string;
+    bodyLines?: string[];
+}): void;

package/src/command-line/init/implementation/utils.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printFinalMessage = exports.markRootPackageJsonAsNxProject = exports.addVsCodeRecommendedExtensions = exports.initCloud = exports.runInstall = exports.updateGitIgnore = exports.addDepsToPackageJson = exports.createNxJsonFile = void 0;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const child_process_2 = require("../../../utils/child-process");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const package_manager_1 = require("../../../utils/package-manager");
+const path_2 = require("../../../utils/path");
+const versions_1 = require("../../../utils/versions");
+const fs_1 = require("fs");
+function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scriptOutputs) {
+    const nxJsonPath = (0, path_2.joinPathFragments)(repoRoot, 'nx.json');
+    let nxJson = {};
+    try {
+        nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath);
+        // eslint-disable-next-line no-empty
+    }
+    catch { }
+    nxJson.$schema = './node_modules/nx/schemas/nx-schema.json';
+    nxJson.targetDefaults ??= {};
+    if (topologicalTargets.length > 0) {
+        for (const scriptName of topologicalTargets) {
+            nxJson.targetDefaults[scriptName] ??= {};
+            nxJson.targetDefaults[scriptName] = { dependsOn: [`^${scriptName}`] };
+        }
+        for (const [scriptName, output] of Object.entries(scriptOutputs)) {
+            if (!output) {
+                // eslint-disable-next-line no-continue
+                continue;
+            }
+            nxJson.targetDefaults[scriptName] ??= {};
+            nxJson.targetDefaults[scriptName].outputs = [`{projectRoot}/${output}`];
+        }
+    }
+    for (const target of cacheableOperations) {
+        nxJson.targetDefaults[target] ??= {};
+        nxJson.targetDefaults[target].cache ??= true;
+    }
+    if (Object.keys(nxJson.targetDefaults).length === 0) {
+        delete nxJson.targetDefaults;
+    }
+    nxJson.affected ??= {};
+    nxJson.affected.defaultBase ??= deduceDefaultBase();
+    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+}
+exports.createNxJsonFile = createNxJsonFile;
+function deduceDefaultBase() {
+    try {
+        (0, child_process_1.execSync)(`git rev-parse --verify main`, {
+            stdio: ['ignore', 'ignore', 'ignore'],
+        });
+        return 'main';
+    }
+    catch {
+        try {
+            (0, child_process_1.execSync)(`git rev-parse --verify dev`, {
+                stdio: ['ignore', 'ignore', 'ignore'],
+            });
+            return 'dev';
+        }
+        catch {
+            try {
+                (0, child_process_1.execSync)(`git rev-parse --verify develop`, {
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                });
+                return 'develop';
+            }
+            catch {
+                try {
+                    (0, child_process_1.execSync)(`git rev-parse --verify next`, {
+                        stdio: ['ignore', 'ignore', 'ignore'],
+                    });
+                    return 'next';
+                }
+                catch {
+                    return 'master';
+                }
+            }
+        }
+    }
+}
+function addDepsToPackageJson(repoRoot, additionalPackages) {
+    const path = (0, path_2.joinPathFragments)(repoRoot, `package.json`);
+    const json = (0, fileutils_1.readJsonFile)(path);
+    if (!json.devDependencies)
+        json.devDependencies = {};
+    json.devDependencies['nx'] = versions_1.nxVersion;
+    if (additionalPackages) {
+        for (const p of additionalPackages) {
+            json.devDependencies[p] = versions_1.nxVersion;
+        }
+    }
+    (0, fileutils_1.writeJsonFile)(path, json);
+}
+exports.addDepsToPackageJson = addDepsToPackageJson;
+function updateGitIgnore(root) {
+    const ignorePath = (0, path_1.join)(root, '.gitignore');
+    try {
+        let contents = (0, fs_1.readFileSync)(ignorePath, 'utf-8');
+        if (!contents.includes('.nx/cache')) {
+            contents = [contents, '', '.nx/cache'].join('\n');
+            (0, fs_1.writeFileSync)(ignorePath, contents, 'utf-8');
+        }
+    }
+    catch { }
+}
+exports.updateGitIgnore = updateGitIgnore;
+function runInstall(repoRoot, pmc = (0, package_manager_1.getPackageManagerCommand)()) {
+    (0, child_process_1.execSync)(pmc.install, { stdio: [0, 1, 2], cwd: repoRoot });
+}
+exports.runInstall = runInstall;
+function initCloud(repoRoot, installationSource) {
+    (0, child_process_2.runNxSync)(`g nx:connect-to-nx-cloud --installationSource=${installationSource} --quiet --no-interactive`, {
+        stdio: [0, 1, 2],
+        cwd: repoRoot,
+    });
+}
+exports.initCloud = initCloud;
+function addVsCodeRecommendedExtensions(repoRoot, extensions) {
+    const vsCodeExtensionsPath = (0, path_1.join)(repoRoot, '.vscode/extensions.json');
+    if ((0, fileutils_1.fileExists)(vsCodeExtensionsPath)) {
+        const vsCodeExtensionsJson = (0, fileutils_1.readJsonFile)(vsCodeExtensionsPath);
+        vsCodeExtensionsJson.recommendations ??= [];
+        extensions.forEach((extension) => {
+            if (!vsCodeExtensionsJson.recommendations.includes(extension)) {
+                vsCodeExtensionsJson.recommendations.push(extension);
+            }
+        });
+        (0, fileutils_1.writeJsonFile)(vsCodeExtensionsPath, vsCodeExtensionsJson);
+    }
+    else {
+        (0, fileutils_1.writeJsonFile)(vsCodeExtensionsPath, { recommendations: extensions });
+    }
+}
+exports.addVsCodeRecommendedExtensions = addVsCodeRecommendedExtensions;
+function markRootPackageJsonAsNxProject(repoRoot, cacheableScripts, scriptOutputs, pmc) {
+    const json = (0, fileutils_1.readJsonFile)((0, path_2.joinPathFragments)(repoRoot, `package.json`));
+    json.nx = { targets: {} };
+    for (let script of Object.keys(scriptOutputs)) {
+        if (scriptOutputs[script]) {
+            json.nx.targets[script] = {
+                outputs: [`{projectRoot}/${scriptOutputs[script]}`],
+            };
+        }
+    }
+    for (let script of cacheableScripts) {
+        const scriptDefinition = json.scripts[script];
+        if (!scriptDefinition) {
+            continue;
+        }
+        if (scriptDefinition.includes('&&') || scriptDefinition.includes('||')) {
+            let backingScriptName = `_${script}`;
+            json.scripts[backingScriptName] = scriptDefinition;
+            json.scripts[script] = `nx exec -- ${pmc.run(backingScriptName, '')}`;
+        }
+        else {
+            json.scripts[script] = `nx exec -- ${json.scripts[script]}`;
+        }
+    }
+    (0, fileutils_1.writeJsonFile)(`package.json`, json);
+}
+exports.markRootPackageJsonAsNxProject = markRootPackageJsonAsNxProject;
+function printFinalMessage({ learnMoreLink, bodyLines, }) {
+    const normalizedBodyLines = (bodyLines ?? []).map((l) => l.startsWith('- ') ? l : `- ${l}`);
+    output_1.output.success({
+        title: '🎉 Done!',
+        bodyLines: [
+            '- Enabled computation caching!',
+            ...normalizedBodyLines,
+            learnMoreLink ? `- Learn more at ${learnMoreLink}.` : undefined,
+        ].filter(Boolean),
+    });
+}
+exports.printFinalMessage = printFinalMessage;

package/src/command-line/init/init-v1.d.ts

@@ -0,0 +1,11 @@
+export interface InitArgs {
+    addE2e: boolean;
+    force: boolean;
+    integrated: boolean;
+    interactive: boolean;
+    vite: boolean;
+    nxCloud?: boolean;
+    cacheable?: string[];
+    useDotNxInstallation?: boolean;
+}
+export declare function initHandler(options: InitArgs): Promise<void>;

package/src/command-line/init/init-v1.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initHandler = void 0;
+const child_process_1 = require("child_process");
+const enquirer_1 = require("enquirer");
+const fs_1 = require("fs");
+const semver_1 = require("semver");
+const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const add_nx_to_nest_1 = require("./implementation/add-nx-to-nest");
+const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
+const angular_1 = require("./implementation/angular");
+const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const react_1 = require("./implementation/react");
+const child_process_2 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const versions_1 = require("../../utils/versions");
+async function initHandler(options) {
+    // strip the 'init' command itself so we don't forward it
+    const args = process.argv.slice(3).join(' ');
+    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
+    if (process.env.NX_VERSION) {
+        console.log(`Using version ${process.env.NX_VERSION}`);
+    }
+    if (options.useDotNxInstallation === true) {
+        setupDotNxInstallation(version);
+    }
+    else if ((0, fs_1.existsSync)('package.json')) {
+        const packageJson = (0, fileutils_1.readJsonFile)('package.json');
+        if ((0, fs_1.existsSync)('angular.json')) {
+            await (0, angular_1.addNxToAngularCliRepo)(options);
+        }
+        else if (isCRA(packageJson)) {
+            await (0, react_1.addNxToCraRepo)(options);
+        }
+        else if (isNestCLI(packageJson)) {
+            await (0, add_nx_to_nest_1.addNxToNest)(options, packageJson);
+        }
+        else if (isMonorepo(packageJson)) {
+            await (0, add_nx_to_monorepo_1.addNxToMonorepo)(options);
+        }
+        else {
+            await (0, add_nx_to_npm_repo_1.addNxToNpmRepo)(options);
+        }
+    }
+    else {
+        const useDotNxFolder = await (0, enquirer_1.prompt)([
+            {
+                name: 'useDotNxFolder',
+                type: 'autocomplete',
+                message: 'Where should your workspace be created?',
+                choices: [
+                    {
+                        name: 'In a new folder under this directory',
+                        value: 'false',
+                    },
+                    {
+                        name: 'In this directory',
+                        value: 'true',
+                    },
+                ],
+            },
+        ]).then((r) => r.useDotNxFolder === 'true');
+        if (useDotNxFolder) {
+            setupDotNxInstallation(version);
+        }
+        else {
+            (0, child_process_1.execSync)(`npx --yes create-nx-workspace@${version} ${args}`, {
+                stdio: [0, 1, 2],
+            });
+        }
+    }
+}
+exports.initHandler = initHandler;
+function isCRA(packageJson) {
+    const combinedDependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    return (
+    // Required dependencies for CRA projects
+    combinedDependencies['react'] &&
+        combinedDependencies['react-dom'] &&
+        combinedDependencies['react-scripts'] &&
+        // // Don't convert customized CRA projects
+        !combinedDependencies['react-app-rewired'] &&
+        !combinedDependencies['@craco/craco'] &&
+        (0, fileutils_1.directoryExists)('src') &&
+        (0, fileutils_1.directoryExists)('public'));
+}
+function isNestCLI(packageJson) {
+    const combinedDependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    };
+    return ((0, fs_1.existsSync)('nest-cli.json') &&
+        combinedDependencies['@nestjs/core'] &&
+        combinedDependencies['@nestjs/cli']);
+}
+function isMonorepo(packageJson) {
+    if (!!packageJson.workspaces)
+        return true;
+    if ((0, fs_1.existsSync)('pnpm-workspace.yaml') || (0, fs_1.existsSync)('pnpm-workspace.yml'))
+        return true;
+    if ((0, fs_1.existsSync)('lerna.json'))
+        return true;
+    return false;
+}
+function setupDotNxInstallation(version) {
+    if (process.platform !== 'win32') {
+        console.log('Setting Nx up installation in `.nx`. You can run nx commands like: `./nx --help`');
+    }
+    else {
+        console.log('Setting Nx up installation in `.nx`. You can run nx commands like: `./nx.bat --help`');
+    }
+    (0, add_nx_scripts_1.generateDotNxSetup)(version);
+    // invokes the wrapper, thus invoking the initial installation process
+    (0, child_process_2.runNxSync)('--version');
+}

package/src/command-line/init/init-v2.d.ts

@@ -0,0 +1,7 @@
+export interface InitArgs {
+    interactive: boolean;
+    nxCloud?: boolean;
+    useDotNxInstallation?: boolean;
+    integrated?: boolean;
+}
+export declare function initHandler(options: InitArgs): Promise<void>;

package/src/command-line/init/init-v2.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initHandler = void 0;
+const fs_1 = require("fs");
+const semver_1 = require("semver");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
+const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const child_process_1 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const versions_1 = require("../../utils/versions");
+const utils_1 = require("./implementation/utils");
+const enquirer_1 = require("enquirer");
+const child_process_2 = require("child_process");
+const angular_1 = require("./implementation/angular");
+const workspace_context_1 = require("../../utils/workspace-context");
+const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
+async function initHandler(options) {
+    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
+    if (process.env.NX_VERSION) {
+        output_1.output.log({ title: `Using version ${process.env.NX_VERSION}` });
+    }
+    if (!(0, fs_1.existsSync)('package.json') || options.useDotNxInstallation) {
+        if (process.platform !== 'win32') {
+            console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx --help`');
+        }
+        else {
+            console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx.bat --help`');
+        }
+        (0, add_nx_scripts_1.generateDotNxSetup)(version);
+        // invokes the wrapper, thus invoking the initial installation process
+        (0, child_process_1.runNxSync)('');
+        return;
+    }
+    // TODO(jack): Remove this Angular logic once `@nx/plugin` is compatible with PCv3.
+    if ((0, fs_1.existsSync)('angular.json')) {
+        await (0, angular_1.addNxToAngularCliRepo)({
+            ...options,
+            integrated: !!options.integrated,
+        });
+        return;
+    }
+    const repoRoot = process.cwd();
+    const cacheableOperations = [];
+    (0, utils_1.createNxJsonFile)(repoRoot, [], cacheableOperations, {});
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    const detectPluginsResponse = await detectPlugins();
+    const useNxCloud = options.nxCloud ??
+        (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
+    (0, utils_1.addDepsToPackageJson)(repoRoot, detectPluginsResponse?.plugins ?? []);
+    output_1.output.log({ title: '📦 Installing Nx' });
+    (0, utils_1.runInstall)(repoRoot, pmc);
+    if (detectPluginsResponse) {
+        output_1.output.log({ title: '🔨 Configuring plugins' });
+        for (const plugin of detectPluginsResponse.plugins) {
+            (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${detectPluginsResponse.updatePackageScripts
+                ? '--updatePackageScripts'
+                : ''} --no-interactive`, {
+                stdio: [0, 1, 2],
+                cwd: repoRoot,
+            });
+        }
+    }
+    if (useNxCloud) {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        (0, child_process_2.execSync)(`${pmc.exec} nx g nx:connect-to-nx-cloud --installationSource=nx-init-pcv3 --quiet --hideFormatLogs --no-interactive`, {
+            stdio: [0, 1, 2],
+            cwd: repoRoot,
+        });
+    }
+    output_1.output.log({
+        title: '👀 Explore Your Workspace',
+        bodyLines: [
+            `Run "nx graph" to show the graph of the workspace. It will show tasks that you can run with Nx.`,
+            `Read this guide on exploring your workspace: https://nx.dev/core-features/explore-graph`,
+        ],
+    });
+}
+exports.initHandler = initHandler;
+const npmPackageToPluginMap = {
+    // Generic JS tools
+    eslint: '@nx/eslint',
+    storybook: '@nx/storybook',
+    // Bundlers
+    vite: '@nx/vite',
+    vitest: '@nx/vite',
+    webpack: '@nx/webpack',
+    // Testing tools
+    jest: '@nx/jest',
+    cypress: '@nx/cypress',
+    '@playwright/test': '@nx/playwright',
+    // Frameworks
+    detox: '@nx/detox',
+    expo: '@nx/expo',
+    next: '@nx/next',
+    nuxt: '@nx/nuxt',
+    'react-native': '@nx/react-native',
+    '@remix-run/dev': '@nx/remix',
+};
+async function detectPlugins() {
+    let files = ['package.json'].concat((0, workspace_context_1.globWithWorkspaceContext)(process.cwd(), ['**/*/package.json']));
+    const detectedPlugins = new Set();
+    for (const file of files) {
+        if (!(0, fs_1.existsSync)(file))
+            continue;
+        let packageJson;
+        try {
+            packageJson = (0, fileutils_1.readJsonFile)(file);
+        }
+        catch {
+            // Could have malformed JSON for unit tests, etc.
+            continue;
+        }
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        for (const [dep, plugin] of Object.entries(npmPackageToPluginMap)) {
+            if (deps[dep]) {
+                detectedPlugins.add(plugin);
+            }
+        }
+    }
+    const plugins = Array.from(detectedPlugins);
+    if (plugins.length === 0)
+        return undefined;
+    output_1.output.log({
+        title: `Recommended Plugins:`,
+        bodyLines: [
+            `Add these Nx plugins to integrate with the tools used in your workspace.`,
+        ],
+    });
+    const pluginsToInstall = await (0, enquirer_1.prompt)([
+        {
+            name: 'plugins',
+            type: 'multiselect',
+            message: `Which plugins would you like to add?`,
+            choices: plugins.map((p) => ({ name: p, value: p })),
+            initial: plugins.map((_, i) => i), // casting to avoid type error due to bad d.ts file from enquirer
+        },
+    ]).then((r) => r.plugins);
+    if (pluginsToInstall?.length === 0)
+        return undefined;
+    const updatePackageScripts = await (0, enquirer_1.prompt)([
+        {
+            name: 'updatePackageScripts',
+            type: 'autocomplete',
+            message: `Do you want to start using Nx in your package.json scripts?`,
+            choices: [
+                {
+                    name: 'Yes',
+                },
+                {
+                    name: 'No',
+                },
+            ],
+            initial: 0,
+        },
+    ]).then((r) => r.updatePackageScripts === 'Yes');
+    return {
+        plugins: pluginsToInstall,
+        updatePackageScripts,
+    };
+}

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

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsListCommand: CommandModule;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsListCommand = void 0;
+exports.yargsListCommand = {
+    command: 'list [plugin]',
+    describe: 'Lists installed plugins, capabilities of installed plugins and other available plugins.',
+    builder: (yargs) => yargs.positional('plugin', {
+        type: 'string',
+        description: 'The name of an installed plugin to query',
+    }),
+    handler: async (args) => {
+        await (await Promise.resolve().then(() => require('./list'))).listHandler(args);
+        process.exit(0);
+    },
+};

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

@@ -0,0 +1,13 @@
+export interface ListArgs {
+    /** The name of an installed plugin to query  */
+    plugin?: string | undefined;
+}
+/**
+ * List available plugins or capabilities within a specific plugin
+ *
+ * @remarks
+ *
+ * Must be run within an Nx workspace
+ *
+ */
+export declare function listHandler(args: ListArgs): Promise<void>;