nx 20.8.4 → 22.7.7

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxWrapperPath = void 0;
+exports.generateDotNxSetup = generateDotNxSetup;
+exports.normalizeVersionForNxJson = normalizeVersionForNxJson;
+exports.writeMinimalNxJson = writeMinimalNxJson;
+exports.updateGitIgnore = updateGitIgnore;
+exports.getNxWrapperContents = getNxWrapperContents;
+exports.getShellScriptContents = getShellScriptContents;
+exports.getBatchScriptContents = getBatchScriptContents;
+exports.sanitizeWrapperScript = sanitizeWrapperScript;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = tslib_1.__importStar(require("path"));
+const semver_1 = require("semver");
+const tree_1 = require("../../../../generators/tree");
+const json_1 = require("../../../../generators/utils/json");
+const nxWrapperPath = (p = path) => p.join('.nx', 'nxw.js');
+exports.nxWrapperPath = nxWrapperPath;
+const NODE_MISSING_ERR = 'Nx requires NodeJS to be available. To install NodeJS and NPM, see: https://nodejs.org/en/download/ .';
+const NPM_MISSING_ERR = 'Nx requires npm to be available. To install NodeJS and NPM, see: https://nodejs.org/en/download/ .';
+const BATCH_SCRIPT_CONTENTS = [
+    // don't log command to console
+    `@ECHO OFF`,
+    // Prevents path_to_root from being inherited by child processes
+    `SETLOCAL`,
+    `SET path_to_root=%~dp0`,
+    // Checks if node is available
+    `WHERE node >nul 2>nul`,
+    `IF %ERRORLEVEL% NEQ 0 (ECHO ${NODE_MISSING_ERR} & GOTO exit)`,
+    // Checks if npm is available
+    `WHERE npm >nul 2>nul`,
+    `IF %ERRORLEVEL% NEQ 0 (ECHO ${NPM_MISSING_ERR} & GOTO exit)`,
+    // Executes the nx wrapper script
+    `node ${path.win32.join('%path_to_root%', (0, exports.nxWrapperPath)(path.win32))} %*`,
+    // Exits with the same error code as the previous command
+    `:exit`,
+    `  cmd /c exit /b %ERRORLEVEL%`,
+].join('\r\n');
+const SHELL_SCRIPT_CONTENTS = [
+    // Execute in bash
+    `#!/bin/bash`,
+    // Checks if node is available
+    `command -v node >/dev/null 2>&1 || { echo >&2 "${NODE_MISSING_ERR}"; exit 1; }`,
+    // Checks if npm is available
+    `command -v npm >/dev/null 2>&1 || { echo >&2 "${NPM_MISSING_ERR}"; exit 1; }`,
+    // Gets the path to the root of the project
+    `path_to_root=$(dirname $BASH_SOURCE)`,
+    // Executes the nx wrapper script
+    `node ${path.posix.join('$path_to_root', (0, exports.nxWrapperPath)(path.posix))} "$@"`,
+].join('\n');
+function generateDotNxSetup(version) {
+    const host = new tree_1.FsTree(process.cwd(), false, '.nx setup');
+    writeMinimalNxJson(host, version);
+    updateGitIgnore(host);
+    host.write((0, exports.nxWrapperPath)(), getNxWrapperContents());
+    host.write('nx.bat', BATCH_SCRIPT_CONTENTS);
+    host.write('nx', SHELL_SCRIPT_CONTENTS, {
+        mode: fs_1.constants.S_IXUSR | fs_1.constants.S_IRUSR | fs_1.constants.S_IWUSR,
+    });
+    const changes = host.listChanges();
+    (0, tree_1.printChanges)(changes);
+    (0, tree_1.flushChanges)(host.root, changes);
+    // Ensure that the dot-nx installation is available.
+    // This is needed when using a global nx with dot-nx, otherwise running any nx command using global command will fail due to missing modules.
+    // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
+    try {
+        (0, child_process_1.execSync)('./nx --version', {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            encoding: 'utf8',
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        if (e?.stderr)
+            process.stderr.write(e.stderr);
+        throw e;
+    }
+}
+function normalizeVersionForNxJson(pkg, version) {
+    if (!(0, semver_1.valid)(version)) {
+        version = (0, child_process_1.execSync)(`npm view ${pkg}@${version} version`, {
+            windowsHide: true,
+        }).toString();
+    }
+    return version.trimEnd();
+}
+function writeMinimalNxJson(host, version) {
+    if (!host.exists('nx.json')) {
+        (0, json_1.writeJson)(host, 'nx.json', {
+            installation: {
+                version: normalizeVersionForNxJson('nx', version),
+            },
+        });
+    }
+}
+function updateGitIgnore(host) {
+    let contents = host.read('.gitignore', 'utf-8') ?? '';
+    [
+        '.nx/installation',
+        '.nx/cache',
+        '.nx/workspace-data',
+        '.nx/self-healing',
+    ].forEach((file) => {
+        if (!contents.includes(file)) {
+            contents = [contents, file].join('\n');
+        }
+    });
+    host.write('.gitignore', contents);
+}
+// Gets the sanitized contents for nxw.js
+function getNxWrapperContents() {
+    return sanitizeWrapperScript((0, fs_1.readFileSync)(path.join(__dirname, 'nxw.js'), 'utf-8'));
+}
+// Gets the contents for the nx bash script
+function getShellScriptContents() {
+    return SHELL_SCRIPT_CONTENTS;
+}
+// Gets the contents for the nx.bat batch script
+function getBatchScriptContents() {
+    return BATCH_SCRIPT_CONTENTS;
+}
+// Remove any empty comments or comments that start with `//#: ` or eslint-disable comments.
+// This removes the sourceMapUrl since it is invalid, as well as any internal comments.
+function sanitizeWrapperScript(input) {
+    const linesToRemove = [
+        // Comments that start with //#
+        '\\/\\/# .*',
+        // Comments that are empty (often used for newlines between internal comments)
+        '\\s*\\/\\/\\s*',
+        // Comments that disable an eslint rule.
+        '\\/\\/ eslint-disable-next-line.*',
+    ];
+    const regex = `(${linesToRemove.join('|')})$`;
+    return input.replace(new RegExp(regex, 'gm'), '');
+}

package/dist/src/command-line/init/implementation/dot-nx/nxw.js

@@ -0,0 +1,123 @@
+"use strict";
+// This file should be committed to your repository! It wraps Nx and ensures
+// that your local installation matches nx.json.
+// See: https://nx.dev/recipes/installation/install-non-javascript for more info.
+//
+//# The contents of this file are executed before packages are installed.
+//# As such, we should not import anything from nx, other @nrwl packages,
+//# or any other npm packages. Only import node builtins. Type Imports are
+//# fine, since they are removed by the typescript compiler.
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+const installationPath = path.join(__dirname, 'installation', 'package.json');
+function matchesCurrentNxInstall(currentInstallation, nxJsonInstallation) {
+    if (!currentInstallation.devDependencies ||
+        !Object.keys(currentInstallation.devDependencies).length) {
+        return false;
+    }
+    try {
+        if (currentInstallation.devDependencies['nx'] !==
+            nxJsonInstallation.version ||
+            require(path.join(path.dirname(installationPath), 'node_modules', 'nx', 'package.json')).version !== nxJsonInstallation.version) {
+            return false;
+        }
+        for (const [plugin, desiredVersion] of Object.entries(nxJsonInstallation.plugins || {})) {
+            if (currentInstallation.devDependencies[plugin] !== desiredVersion) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureDir(p) {
+    if (!fs.existsSync(p)) {
+        fs.mkdirSync(p, { recursive: true });
+    }
+}
+function getCurrentInstallation() {
+    try {
+        return require(installationPath);
+    }
+    catch {
+        return {
+            name: 'nx-installation',
+            version: '0.0.0',
+            devDependencies: {},
+        };
+    }
+}
+function performInstallation(currentInstallation, nxJson) {
+    fs.writeFileSync(installationPath, JSON.stringify({
+        name: 'nx-installation',
+        devDependencies: {
+            nx: nxJson.installation.version,
+            ...nxJson.installation.plugins,
+        },
+    }));
+    try {
+        // --include=dev forces install even if consumer env sets NODE_ENV=production / omit=dev.
+        cp.execSync('npm i --include=dev', {
+            cwd: path.dirname(installationPath),
+            stdio: 'inherit',
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        // revert possible changes to the current installation
+        fs.writeFileSync(installationPath, JSON.stringify(currentInstallation));
+        // rethrow
+        throw e;
+    }
+}
+function ensureUpToDateInstallation() {
+    const nxJsonPath = path.join(__dirname, '..', 'nx.json');
+    let nxJson;
+    try {
+        nxJson = require(nxJsonPath);
+        if (!nxJson.installation) {
+            console.error('[NX]: The "installation" entry in the "nx.json" file is required when running the nx wrapper. See https://nx.dev/recipes/installation/install-non-javascript');
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        if (e instanceof Error &&
+            e.code === 'MODULE_NOT_FOUND') {
+            console.error('[NX]: The "nx.json" file is required when running the nx wrapper. See https://nx.dev/recipes/installation/install-non-javascript');
+        }
+        else {
+            console.error(`[NX]: Failed to parse "nx.json": ${e instanceof Error ? e.message : e}. See https://nx.dev/recipes/installation/install-non-javascript`);
+        }
+        process.exit(1);
+    }
+    try {
+        ensureDir(path.join(__dirname, 'installation'));
+        const currentInstallation = getCurrentInstallation();
+        if (!matchesCurrentNxInstall(currentInstallation, nxJson.installation)) {
+            performInstallation(currentInstallation, nxJson);
+        }
+    }
+    catch (e) {
+        const messageLines = [
+            '[NX]: Nx wrapper failed to synchronize installation.',
+        ];
+        if (e instanceof Error) {
+            messageLines.push('');
+            messageLines.push(e.message);
+            messageLines.push(e.stack);
+        }
+        else {
+            messageLines.push(e.toString());
+        }
+        console.error(messageLines.join('\n'));
+        process.exit(1);
+    }
+}
+if (!process.env.NX_WRAPPER_SKIP_INSTALL) {
+    ensureUpToDateInstallation();
+}
+require('./installation/node_modules/nx/dist/bin/nx');

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

@@ -0,0 +1,27 @@
+import { NxJsonConfiguration } from '../../../config/nx-json';
+import { PackageJson } from '../../../utils/package-json';
+import { PackageManagerCommands } from '../../../utils/package-manager';
+export declare function createNxJsonFile(repoRoot: string, topologicalTargets: string[], cacheableOperations: string[], scriptOutputs: {
+    [name: string]: string;
+}): void;
+export declare function createNxJsonFromTurboJson(turboJson: Record<string, any>): NxJsonConfiguration;
+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;
+/**
+ * Coerce any thrown value into a non-empty telemetry string. The naive
+ * `error.message || String(error)` yields "" for bare `new Error()`.
+ */
+export declare function toErrorString(error: unknown): string;
+export declare function readErrorStderr(error: unknown): string;
+export declare function extractErrorName(error: unknown, stderr: string): string;
+export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo' | 'nx-init-turborepo'): Promise<void>;
+export declare function setNeverConnectToCloud(repoRoot: string): void;
+export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;
+export declare function markRootPackageJsonAsNxProjectLegacy(repoRoot: string, cacheableScripts: string[], pmc: PackageManagerCommands): void;
+export declare function markPackageJsonAsNxProject(packageJsonPath: string): void;
+export declare function printFinalMessage({ learnMoreLink, appendLines, }: {
+    learnMoreLink?: string;
+    appendLines?: string[];
+}): void;
+export declare function isMonorepo(packageJson: PackageJson): boolean;

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

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxJsonFile = createNxJsonFile;
+exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
+exports.addDepsToPackageJson = addDepsToPackageJson;
+exports.updateGitIgnore = updateGitIgnore;
+exports.runInstall = runInstall;
+exports.toErrorString = toErrorString;
+exports.readErrorStderr = readErrorStderr;
+exports.extractErrorName = extractErrorName;
+exports.initCloud = initCloud;
+exports.setNeverConnectToCloud = setNeverConnectToCloud;
+exports.addVsCodeRecommendedExtensions = addVsCodeRecommendedExtensions;
+exports.markRootPackageJsonAsNxProjectLegacy = markRootPackageJsonAsNxProjectLegacy;
+exports.markPackageJsonAsNxProject = markPackageJsonAsNxProject;
+exports.printFinalMessage = printFinalMessage;
+exports.isMonorepo = isMonorepo;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+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");
+const connect_to_nx_cloud_1 = require("../../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud");
+const connect_to_nx_cloud_2 = require("../../nx-cloud/connect/connect-to-nx-cloud");
+const deduce_default_base_1 = require("./deduce-default-base");
+function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scriptOutputs) {
+    const nxJsonPath = (0, path_2.joinPathFragments)(repoRoot, 'nx.json');
+    let nxJson = {};
+    try {
+        nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath);
+    }
+    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) {
+            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;
+    }
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
+    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+}
+function createNxJsonFromTurboJson(turboJson) {
+    const nxJson = {
+        $schema: './node_modules/nx/schemas/nx-schema.json',
+    };
+    // Handle global dependencies
+    if (turboJson.globalDependencies?.length > 0) {
+        nxJson.namedInputs = {
+            sharedGlobals: turboJson.globalDependencies.map((dep) => `{workspaceRoot}/${dep}`),
+            default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        };
+    }
+    // Handle global env vars
+    if (turboJson.globalEnv?.length > 0) {
+        nxJson.namedInputs = nxJson.namedInputs || {};
+        nxJson.namedInputs.sharedGlobals = nxJson.namedInputs.sharedGlobals || [];
+        nxJson.namedInputs.sharedGlobals.push(...turboJson.globalEnv.map((env) => ({ env })));
+        nxJson.namedInputs.default = nxJson.namedInputs.default || [];
+        if (!nxJson.namedInputs.default.includes('{projectRoot}/**/*')) {
+            nxJson.namedInputs.default.push('{projectRoot}/**/*');
+        }
+        if (!nxJson.namedInputs.default.includes('sharedGlobals')) {
+            nxJson.namedInputs.default.push('sharedGlobals');
+        }
+    }
+    // Handle task configurations
+    if (turboJson.tasks) {
+        nxJson.targetDefaults = {};
+        for (const [taskName, taskConfig] of Object.entries(turboJson.tasks)) {
+            // Skip project-specific tasks (containing #)
+            if (taskName.includes('#'))
+                continue;
+            const config = taskConfig;
+            nxJson.targetDefaults[taskName] = {};
+            // Handle dependsOn
+            if (config.dependsOn?.length > 0) {
+                nxJson.targetDefaults[taskName].dependsOn = config.dependsOn;
+            }
+            // Handle inputs
+            if (config.inputs?.length > 0) {
+                nxJson.targetDefaults[taskName].inputs = config.inputs
+                    .map((input) => {
+                    if (input === '$TURBO_DEFAULT$') {
+                        return '{projectRoot}/**/*';
+                    }
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                })
+                    .map((input) => {
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                });
+            }
+            // Handle outputs
+            if (config.outputs?.length > 0) {
+                nxJson.targetDefaults[taskName].outputs = config.outputs.map((output) => {
+                    // Don't add projectRoot if it's already there
+                    if (output.startsWith('{projectRoot}/'))
+                        return output;
+                    // Handle negated patterns by adding projectRoot after the !
+                    if (output.startsWith('!')) {
+                        return `!{projectRoot}/${output.slice(1)}`;
+                    }
+                    return `{projectRoot}/${output}`;
+                });
+            }
+            // Handle cache setting - true by default in Turbo
+            nxJson.targetDefaults[taskName].cache = config.cache !== false;
+        }
+    }
+    /**
+     * The fact that cacheDir was in use suggests the user had a reason for deviating from the default.
+     * We can't know what that reason was, nor if it would still be applicable in Nx, but we can at least
+     * improve discoverability of the relevant Nx option by explicitly including it with its default value.
+     */
+    if (turboJson.cacheDir) {
+        nxJson.cacheDirectory = '.nx/cache';
+    }
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
+    return nxJson;
+}
+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);
+}
+function updateGitIgnore(root) {
+    const ignorePath = (0, path_1.join)(root, '.gitignore');
+    try {
+        let contents = (0, fs_1.readFileSync)(ignorePath, 'utf-8');
+        const lines = contents.split('\n');
+        let sepIncluded = false;
+        if (!contents.includes('.nx/cache')) {
+            if (!sepIncluded) {
+                lines.push('\n');
+                sepIncluded = true;
+            }
+            lines.push('.nx/cache');
+        }
+        if (!contents.includes('.nx/workspace-data')) {
+            if (!sepIncluded) {
+                lines.push('\n');
+                sepIncluded = true;
+            }
+            lines.push('.nx/workspace-data');
+        }
+        (0, fs_1.writeFileSync)(ignorePath, lines.join('\n'), 'utf-8');
+    }
+    catch { }
+}
+function runInstall(repoRoot, pmc = (0, package_manager_1.getPackageManagerCommand)()) {
+    try {
+        (0, child_process_1.execSync)(pmc.install, {
+            stdio: ['ignore', 'ignore', 'pipe'],
+            encoding: 'utf8',
+            cwd: repoRoot,
+            windowsHide: true,
+        });
+    }
+    catch (e) {
+        if (e?.stderr)
+            process.stderr.write(e.stderr);
+        throw e;
+    }
+}
+/**
+ * Coerce any thrown value into a non-empty telemetry string. The naive
+ * `error.message || String(error)` yields "" for bare `new Error()`.
+ */
+function toErrorString(error) {
+    if (error == null)
+        return 'Unknown error';
+    if (error instanceof Error) {
+        if (error.message)
+            return error.message;
+        if (error.name && error.name !== 'Error')
+            return error.name;
+        // Drop `stack` — large and contains absolute paths (PII).
+        const keys = Object.getOwnPropertyNames(error).filter((k) => k !== 'stack');
+        const serialized = safeJsonStringify(error, keys);
+        if (serialized && serialized !== '{}')
+            return serialized;
+        return error.name || 'Error';
+    }
+    if (typeof error === 'object') {
+        const serialized = safeJsonStringify(error);
+        if (serialized && serialized !== '{}')
+            return serialized;
+        return Object.prototype.toString.call(error);
+    }
+    return String(error);
+}
+function readErrorStderr(error) {
+    const raw = error?.stderr;
+    if (typeof raw === 'string')
+        return raw;
+    if (raw && typeof raw.toString === 'function') {
+        return raw.toString('utf8');
+    }
+    return '';
+}
+function extractErrorName(error, stderr) {
+    const nodeCode = error?.code;
+    if (typeof nodeCode === 'string')
+        return nodeCode;
+    const m = stderr.match(/\b(E[A-Z0-9_]{2,}|ERR_[A-Z0-9_]+)\b/);
+    if (m)
+        return m[1];
+    if (error instanceof Error)
+        return error.name;
+    return typeof error;
+}
+function safeJsonStringify(value, replacer) {
+    try {
+        return JSON.stringify(value, replacer);
+    }
+    catch {
+        return '';
+    }
+}
+async function initCloud(installationSource) {
+    const token = await (0, connect_to_nx_cloud_2.connectWorkspaceToCloud)({
+        installationSource,
+    });
+    await (0, connect_to_nx_cloud_1.printSuccessMessage)(token, installationSource);
+}
+function setNeverConnectToCloud(repoRoot) {
+    const nxJsonPath = (0, path_1.join)(repoRoot, 'nx.json');
+    const nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath);
+    nxJson.neverConnectToCloud = true;
+    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+}
+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 });
+    }
+}
+function markRootPackageJsonAsNxProjectLegacy(repoRoot, cacheableScripts, pmc) {
+    const json = (0, fileutils_1.readJsonFile)((0, path_2.joinPathFragments)(repoRoot, `package.json`));
+    json.nx = {};
+    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);
+}
+function markPackageJsonAsNxProject(packageJsonPath) {
+    const json = (0, fileutils_1.readJsonFile)(packageJsonPath);
+    if (!json.scripts) {
+        return;
+    }
+    json.nx = {};
+    (0, fileutils_1.writeJsonFile)(packageJsonPath, json);
+}
+function printFinalMessage({ learnMoreLink, appendLines, }) {
+    output_1.output.success({
+        title: '🎉 Done!',
+        bodyLines: [
+            `- Learn more about what to do next at ${learnMoreLink ?? 'https://nx.dev/getting-started/adding-to-existing'}`,
+            ...(appendLines ?? []),
+        ].filter(Boolean),
+    });
+}
+function isMonorepo(packageJson) {
+    if (!!packageJson.workspaces)
+        return true;
+    try {
+        const content = (0, fs_1.readFileSync)('pnpm-workspace.yaml', 'utf-8');
+        const { load } = require('@zkochan/js-yaml');
+        const { packages } = load(content) ?? {};
+        if (packages) {
+            return true;
+        }
+    }
+    catch { }
+    if ((0, fs_1.existsSync)('lerna.json'))
+        return true;
+    return false;
+}

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

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