nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/utils/child-process.js

@@ -13,8 +13,8 @@ const exit_codes_1 = require("./exit-codes");
 function getRunNxBaseCommand(packageManagerCommand, cwd = process.cwd()) {
     if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
         if (!packageManagerCommand) {
-            const pm = (0, package_manager_1.detectPackageManager)();
-            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm);
+            const pm = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
+            packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)(pm, workspace_root_1.workspaceRoot);
         }
         return `${packageManagerCommand.exec} nx`;
     }

package/dist/src/utils/compile-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Enables V8's on-disk bytecode cache for the current process.
+ *
+ * Calls `module.enableCompileCache()` with no arguments and lets Node pick
+ * the location, which means Node's standard env vars work transparently:
+ *  - `NODE_COMPILE_CACHE=<dir>`     — override the cache directory.
+ *  - `NODE_DISABLE_COMPILE_CACHE=1` — disable entirely.
+ *
+ * The default location lives under the OS temp dir keyed by V8 version, so
+ * the cache is shared across workspaces and self-invalidates on Node
+ * upgrades — no nx-specific cleanup needed.
+ *
+ * Called at the entry point of every long-lived nx process (main CLI,
+ * daemon, plugin workers) via `enable-compile-cache.ts`, which side-effects
+ * this on import.
+ *
+ * Set `NX_COMPILE_CACHE=false` to opt out without disabling the cache for
+ * non-nx Node processes the way `NODE_DISABLE_COMPILE_CACHE` would.
+ *
+ * No-op on Node versions without the `module.enableCompileCache` API.
+ * Errors are swallowed — the compile cache is a pure performance
+ * optimization and must never break the CLI.
+ */
+export declare function enableCompileCache(...override: [unknown?]): boolean;

package/dist/src/utils/compile-cache.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableCompileCache = enableCompileCache;
+const tslib_1 = require("tslib");
+const nodeModule = tslib_1.__importStar(require("node:module"));
+/**
+ * Enables V8's on-disk bytecode cache for the current process.
+ *
+ * Calls `module.enableCompileCache()` with no arguments and lets Node pick
+ * the location, which means Node's standard env vars work transparently:
+ *  - `NODE_COMPILE_CACHE=<dir>`     — override the cache directory.
+ *  - `NODE_DISABLE_COMPILE_CACHE=1` — disable entirely.
+ *
+ * The default location lives under the OS temp dir keyed by V8 version, so
+ * the cache is shared across workspaces and self-invalidates on Node
+ * upgrades — no nx-specific cleanup needed.
+ *
+ * Called at the entry point of every long-lived nx process (main CLI,
+ * daemon, plugin workers) via `enable-compile-cache.ts`, which side-effects
+ * this on import.
+ *
+ * Set `NX_COMPILE_CACHE=false` to opt out without disabling the cache for
+ * non-nx Node processes the way `NODE_DISABLE_COMPILE_CACHE` would.
+ *
+ * No-op on Node versions without the `module.enableCompileCache` API.
+ * Errors are swallowed — the compile cache is a pure performance
+ * optimization and must never break the CLI.
+ */
+function enableCompileCache(
+// Test seam: production callers omit this. `unknown` (rather than
+// `EnableCompileCacheFn | undefined`) lets tests pass a non-function to
+// simulate pre-22.8 Node where `module.enableCompileCache` is missing. We
+// read `arguments.length` so callers can *explicitly* pass `undefined`.
+...override) {
+    if (process.env.NX_COMPILE_CACHE === 'false')
+        return false;
+    const impl = override.length === 0
+        ? nodeModule.enableCompileCache
+        : override[0];
+    if (typeof impl !== 'function')
+        return false;
+    try {
+        impl();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/enable-compile-cache.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/enable-compile-cache.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Side-effect-only module: import this as the *first* import in any nx
+// process entry point so V8's compile cache is enabled before the rest of
+// the import chain (which is what we actually want to cache) starts loading.
+const compile_cache_1 = require("./compile-cache");
+(0, compile_cache_1.enableCompileCache)();

package/dist/src/utils/fileutils.d.ts

@@ -63,13 +63,5 @@ export declare function directoryExists(path: PathLike): boolean;
 export declare function fileExists(path: PathLike): boolean;
 export declare function createDirectory(path: PathLike): void;
 export declare function isRelativePath(path: string): boolean;
-/**
- * Extracts a file from a given tarball to the specified destination.
- * @param tarballPath The path to the tarball from where the file should be extracted.
- * @param file The path to the file inside the tarball.
- * @param destinationFilePath The destination file path.
- * @returns True if the file was extracted successfully, false otherwise.
- */
-export declare function extractFileFromTarball(tarballPath: string, file: string, destinationFilePath: string): Promise<string>;
 export declare function readFileIfExisting(path: string): string;
 export {};

package/dist/src/utils/fileutils.js

@@ -8,15 +8,11 @@ exports.directoryExists = directoryExists;
 exports.fileExists = fileExists;
 exports.createDirectory = createDirectory;
 exports.isRelativePath = isRelativePath;
-exports.extractFileFromTarball = extractFileFromTarball;
 exports.readFileIfExisting = readFileIfExisting;
-const tslib_1 = require("tslib");
 const json_1 = require("./json");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const path_1 = require("path");
-const tar = tslib_1.__importStar(require("tar-stream"));
-const zlib_1 = require("zlib");
 /**
  * Reads a JSON file and returns the object the JSON content represents.
  *
@@ -111,42 +107,6 @@ function isRelativePath(path) {
         path.startsWith('./') ||
         path.startsWith('../'));
 }
-/**
- * Extracts a file from a given tarball to the specified destination.
- * @param tarballPath The path to the tarball from where the file should be extracted.
- * @param file The path to the file inside the tarball.
- * @param destinationFilePath The destination file path.
- * @returns True if the file was extracted successfully, false otherwise.
- */
-async function extractFileFromTarball(tarballPath, file, destinationFilePath) {
-    return new Promise((resolve, reject) => {
-        (0, node_fs_1.mkdirSync)((0, path_1.dirname)(destinationFilePath), { recursive: true });
-        var tarExtractStream = tar.extract();
-        const destinationFileStream = (0, node_fs_1.createWriteStream)(destinationFilePath);
-        let isFileExtracted = false;
-        tarExtractStream.on('entry', function (header, stream, next) {
-            if (header.name === file) {
-                stream.pipe(destinationFileStream);
-                stream.on('end', () => {
-                    isFileExtracted = true;
-                });
-                destinationFileStream.on('close', () => {
-                    resolve(destinationFilePath);
-                });
-            }
-            stream.on('end', function () {
-                next();
-            });
-            stream.resume();
-        });
-        tarExtractStream.on('finish', function () {
-            if (!isFileExtracted) {
-                reject();
-            }
-        });
-        (0, node_fs_1.createReadStream)(tarballPath).pipe((0, zlib_1.createGunzip)()).pipe(tarExtractStream);
-    });
-}
 function readFileIfExisting(path) {
     return (0, node_fs_1.existsSync)(path) ? (0, node_fs_1.readFileSync)(path, 'utf-8') : '';
 }

package/dist/src/utils/git-utils.d.ts

@@ -38,5 +38,20 @@ export interface VcsRemoteInfo {
 }
 export declare function parseVcsRemoteUrl(url: string): VcsRemoteInfo | null;
 export declare function getVcsRemoteInfo(directory?: string): VcsRemoteInfo | null;
+export declare function isGitRepository(directory?: string): boolean;
+export declare function hasUncommittedChanges(directory?: string): boolean;
+export declare function getUncommittedChangesSnapshot(directory?: string): string;
 export declare function commitChanges(commitMessage: string, directory?: string): string | null;
+/**
+ * Throws on git failure with the real stderr attached. Use this when the
+ * caller needs to distinguish hook rejection / GPG signing failures / LFS
+ * lock errors from a successful no-op. Callers should pre-check
+ * `hasUncommittedChanges` to avoid the "nothing to commit" rejection
+ * (which `git commit` exits non-zero for).
+ *
+ * Returns `null` (rather than throwing) when the commit itself succeeded
+ * but `git rev-parse HEAD` failed transiently — by contract the diff is
+ * no longer in the working tree, so callers must NOT report it as such.
+ */
+export declare function tryCommitChanges(commitMessage: string, directory: string): string | null;
 export declare function getLatestCommitSha(directory?: string): string | null;

package/dist/src/utils/git-utils.js

@@ -4,9 +4,16 @@ exports.GitRepository = void 0;
 exports.cloneFromUpstream = cloneFromUpstream;
 exports.parseVcsRemoteUrl = parseVcsRemoteUrl;
 exports.getVcsRemoteInfo = getVcsRemoteInfo;
+exports.isGitRepository = isGitRepository;
+exports.hasUncommittedChanges = hasUncommittedChanges;
+exports.getUncommittedChangesSnapshot = getUncommittedChangesSnapshot;
 exports.commitChanges = commitChanges;
+exports.tryCommitChanges = tryCommitChanges;
 exports.getLatestCommitSha = getLatestCommitSha;
+const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
+const crypto = tslib_1.__importStar(require("crypto"));
+const fs = tslib_1.__importStar(require("fs"));
 const path_1 = require("path");
 const logger_1 = require("./logger");
 function execAsync(command, execOptions) {
@@ -253,6 +260,97 @@ function getVcsRemoteInfo(directory) {
         return null;
     }
 }
+function isGitRepository(directory) {
+    try {
+        (0, child_process_1.execSync)('git rev-parse --is-inside-work-tree', {
+            stdio: 'ignore',
+            cwd: directory,
+            windowsHide: true,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Sync companion to `GitRepository.hasUncommittedChanges` for callers that
+// can't drop into the async class (e.g. the migrate orchestrator, which
+// branches on this before spawning subprocesses synchronously).
+function hasUncommittedChanges(directory) {
+    try {
+        const out = (0, child_process_1.execSync)('git status --porcelain', {
+            encoding: 'utf8',
+            cwd: directory,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        });
+        return out.trim() !== '';
+    }
+    catch {
+        return false;
+    }
+}
+// Returns a content-sensitive sha1 snapshot of the working tree state for
+// before/after comparison. Hashes three probes:
+//   1. `git diff HEAD` with defensive flags — every byte of tracked-file
+//      changes. `--no-ext-diff` / `--no-textconv` neuter user/repo driver
+//      overrides so output is deterministic; `--binary` keeps binary
+//      edits from collapsing to "Binary files differ".
+//   2. `git status --porcelain=v1 -uall` — untracked paths the diff
+//      omits. `-uall` expands untracked directories per-file.
+//   3. Untracked file content bytes — so a same-path content edit on an
+//      already-untracked file does not collapse against the baseline.
+//
+// Each probe is wrapped independently with a failure sentinel so a
+// single-sided git error (e.g. `git diff HEAD` on an initial-commit-less
+// repo) cannot mask surviving signal from the others.
+function getUncommittedChangesSnapshot(directory) {
+    const hasher = crypto.createHash('sha1');
+    const cwd = directory ?? process.cwd();
+    const execOpts = {
+        encoding: 'utf8',
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        maxBuffer: 64 * 1024 * 1024,
+    };
+    let diffOutput;
+    try {
+        diffOutput = (0, child_process_1.execSync)('git diff HEAD --no-color --no-ext-diff --no-textconv --binary', execOpts);
+    }
+    catch {
+        diffOutput = '<diff-unavailable>';
+    }
+    hasher.update('diff:').update(diffOutput).update('\0');
+    let statusOutput;
+    try {
+        statusOutput = (0, child_process_1.execSync)('git status --porcelain=v1 -uall', execOpts);
+    }
+    catch {
+        statusOutput = '<status-unavailable>';
+    }
+    hasher.update('status:').update(statusOutput).update('\0');
+    let untrackedRaw;
+    try {
+        untrackedRaw = (0, child_process_1.execSync)('git ls-files --others --exclude-standard -z', execOpts);
+    }
+    catch {
+        untrackedRaw = '';
+    }
+    const untrackedPaths = untrackedRaw.split('\0').filter(Boolean).sort();
+    hasher.update('untracked:');
+    for (const p of untrackedPaths) {
+        hasher.update(p).update('\0');
+        try {
+            hasher.update(fs.readFileSync((0, path_1.join)(cwd, p)));
+        }
+        catch {
+            hasher.update('<file-unreadable>');
+        }
+        hasher.update('\0');
+    }
+    return hasher.digest('hex');
+}
 function commitChanges(commitMessage, directory) {
     try {
         (0, child_process_1.execSync)('git add -A', {
@@ -283,6 +381,46 @@ function commitChanges(commitMessage, directory) {
     }
     return getLatestCommitSha(directory);
 }
+/**
+ * Throws on git failure with the real stderr attached. Use this when the
+ * caller needs to distinguish hook rejection / GPG signing failures / LFS
+ * lock errors from a successful no-op. Callers should pre-check
+ * `hasUncommittedChanges` to avoid the "nothing to commit" rejection
+ * (which `git commit` exits non-zero for).
+ *
+ * Returns `null` (rather than throwing) when the commit itself succeeded
+ * but `git rev-parse HEAD` failed transiently — by contract the diff is
+ * no longer in the working tree, so callers must NOT report it as such.
+ */
+function tryCommitChanges(commitMessage, directory) {
+    try {
+        (0, child_process_1.execSync)('git add -A', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            cwd: directory,
+            windowsHide: true,
+        });
+        (0, child_process_1.execSync)('git commit --no-verify -F -', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            input: commitMessage,
+            cwd: directory,
+            windowsHide: true,
+        });
+    }
+    catch (err) {
+        const stderr = err?.stderr?.toString();
+        const stdout = err?.stdout?.toString();
+        const detail = [stderr, stdout]
+            .map((s) => s?.trim())
+            .filter(Boolean)
+            .join('\n');
+        // `{ cause }` preserves structured fields (.signal, .status, .code)
+        // for callers to inspect; otherwise only stderr/stdout text survives.
+        throw new Error(detail || (err instanceof Error ? err.message : String(err)), { cause: err });
+    }
+    return getLatestCommitSha(directory);
+}
 function getLatestCommitSha(directory) {
     try {
         return (0, child_process_1.execSync)('git rev-parse HEAD', {

package/dist/src/utils/handle-import.d.ts

@@ -3,7 +3,10 @@
  * Provides a single point of change for future ESM migration.
  *
  * Falls back to real import() for ESM-only packages that
- * throw ERR_REQUIRE_ESM.
+ * throw ERR_REQUIRE_ESM. When loading a workspace plugin's `.ts` entry
+ * under native TypeScript stripping, also falls back to swc/ts-node if
+ * the file uses constructs Node can't strip (enum, runtime namespace,
+ * legacy decorators, etc.).
  *
  * @param modulePath - The module specifier (relative, absolute, or package name)
  * @param relativeTo - The directory to resolve relative paths against.

package/dist/src/utils/handle-import.js

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleImport = handleImport;
 const path_1 = require("path");
+const STRIP_TYPES_DOCS_URL = 'https://nx.dev/docs/reference/environment-variables#nx-prefer-node-strip-types';
 /**
  * Dynamically imports a module using CJS require().
  * Provides a single point of change for future ESM migration.
  *
  * Falls back to real import() for ESM-only packages that
- * throw ERR_REQUIRE_ESM.
+ * throw ERR_REQUIRE_ESM. When loading a workspace plugin's `.ts` entry
+ * under native TypeScript stripping, also falls back to swc/ts-node if
+ * the file uses constructs Node can't strip (enum, runtime namespace,
+ * legacy decorators, etc.).
  *
  * @param modulePath - The module specifier (relative, absolute, or package name)
  * @param relativeTo - The directory to resolve relative paths against.
@@ -24,9 +28,59 @@ async function handleImport(modulePath, relativeTo) {
         return require(normalizedPath);
     }
     catch (e) {
-        if (e.code === 'ERR_REQUIRE_ESM') {
+        // ERR_REQUIRE_ESM (legacy) and ERR_REQUIRE_ASYNC_MODULE (Node 22.12+,
+        // ESM with top-level await) both indicate the module must be loaded via
+        // dynamic import(). Native strip handles `.ts` extension resolution on
+        // the import() path, so this recovers TLA plugin entry points without
+        // requiring swc-node or ts-node to be installed.
+        if (e.code === 'ERR_REQUIRE_ESM' || e.code === 'ERR_REQUIRE_ASYNC_MODULE') {
             return import(resolvedPath);
         }
+        // Mirror `loadTsFile`'s fallback set (register.ts). Plugin loads hit a
+        // wider failure surface than .ts config loads because plugin sources are
+        // often ESM and import type-only symbols from `@nx/devkit` as runtime
+        // named exports. Lazy-require the matchers to keep register/transpiler
+        // (and their daemon/logger deps) out of module-eval-time graphs.
+        const matchers = require('../plugins/js/utils/register');
+        if (e?.code === 'ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX' ||
+            e?.code === 'MODULE_NOT_FOUND' ||
+            e?.code === 'ERR_MODULE_NOT_FOUND' ||
+            matchers.isTsEsmSyntaxError(e, resolvedPath) ||
+            matchers.isTsEsmNamedExportLinkageError(e, resolvedPath) ||
+            matchers.isCjsSyntaxError(e, resolvedPath) ||
+            matchers.isRequireInEsmScopeError(e, resolvedPath)) {
+            // Lazy-require to avoid pulling register/transpiler (and their
+            // daemon/logger transitive deps) into module-eval-time graphs.
+            const { forceRegisterPluginTSTranspiler } = require('../project-graph/plugins/transpiler');
+            forceRegisterPluginTSTranspiler();
+            try {
+                delete require.cache[require.resolve(normalizedPath)];
+            }
+            catch {
+                // require.resolve may throw if the failed load never reached cache
+            }
+            try {
+                return require(normalizedPath);
+            }
+            catch (retryErr) {
+                // Mirror the initial-catch behavior: if the compiled output surfaces
+                // TLA or ESM-only-as-CJS, dispatch to dynamic import() instead of
+                // re-throwing. Without this, a plugin whose source needed the
+                // transpiler fallback AND emits top-level await fails here instead of
+                // loading.
+                if (retryErr?.code === 'ERR_REQUIRE_ESM' ||
+                    retryErr?.code === 'ERR_REQUIRE_ASYNC_MODULE') {
+                    return import(resolvedPath);
+                }
+                if (retryErr instanceof Error) {
+                    // Lazy-require NX_PREFIX so we don't pull logger -> daemon into
+                    // module-eval-time graphs.
+                    const { NX_PREFIX } = require('./logger');
+                    retryErr.message = `${retryErr.message}\n\n${NX_PREFIX} Failed to load ${normalizedPath} under Node's native TypeScript stripping. Set NX_PREFER_NODE_STRIP_TYPES=false to opt out and use swc/ts-node instead. See ${STRIP_TYPES_DOCS_URL}`;
+                }
+                throw retryErr;
+            }
+        }
         throw e;
     }
 }

package/dist/src/utils/has-nx-js-plugin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checks if `@nx/js` is installed by attempting to resolve its `package.json`.
+ *
+ * Lives in its own module so unit tests can `jest.doMock` it without having to
+ * intercept Node's resolver at the global level. The previous in-`package-json`
+ * definition was unreachable to mocks because callers in the same module
+ * referenced it via the local lexical binding rather than `module.exports`.
+ */
+export declare function hasNxJsPlugin(projectRoot: string, workspaceRoot: string): boolean;

package/dist/src/utils/has-nx-js-plugin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNxJsPlugin = hasNxJsPlugin;
+const installation_directory_1 = require("./installation-directory");
+/**
+ * Checks if `@nx/js` is installed by attempting to resolve its `package.json`.
+ *
+ * Lives in its own module so unit tests can `jest.doMock` it without having to
+ * intercept Node's resolver at the global level. The previous in-`package-json`
+ * definition was unreachable to mocks because callers in the same module
+ * referenced it via the local lexical binding rather than `module.exports`.
+ */
+function hasNxJsPlugin(projectRoot, workspaceRoot) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/js/package.json', {
+            paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/utils/installed-nx-version.d.ts

@@ -1,8 +1,18 @@
 /**
  * Resolve the workspace's installed `nx` version, or `null` if no installed
- * `nx` can be located. Routed through a cache-shielded, self-reference-free
- * `require.resolve` so the answer always reflects the workspace's
- * `node_modules`/PnP store rather than whichever `nx` package happens to be
- * loaded in the current process. See nrwl/nx#35444.
+ * `nx` can be located.
  */
 export declare function getInstalledNxVersion(): string | null;
+/**
+ * Return the package names declared in the installed `nx` package's
+ * `ng-update.packageGroup` (or `nx-migrations.packageGroup`), plus `'nx'`
+ * itself. Returns a set containing only `'nx'` when nx isn't installed or
+ * the metadata is missing.
+ */
+export declare function getInstalledNxPackageGroup(): Set<string>;
+/**
+ * Resolve the workspace's installed `@nrwl/workspace` version (legacy-era
+ * fallback for `nx migrate --mode=third-party` targeting `< 14.0.0-beta.0`),
+ * or `null` if it cannot be resolved from the workspace require paths.
+ */
+export declare function getInstalledLegacyNrwlWorkspaceVersion(): string | null;

package/dist/src/utils/installed-nx-version.js

@@ -1,25 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getInstalledNxVersion = getInstalledNxVersion;
+exports.getInstalledNxPackageGroup = getInstalledNxPackageGroup;
+exports.getInstalledLegacyNrwlWorkspaceVersion = getInstalledLegacyNrwlWorkspaceVersion;
 const tslib_1 = require("tslib");
 const node_module_1 = tslib_1.__importStar(require("node:module"));
 const fileutils_1 = require("./fileutils");
+const package_json_1 = require("./package-json");
 const workspace_root_1 = require("./workspace-root");
 const installation_directory_1 = require("./installation-directory");
+/**
+ * Read the installed `nx` package.json via the cache-shielded resolver. The
+ * resolver always reflects the workspace's `node_modules`/PnP store rather
+ * than whichever `nx` package happens to be loaded in the current process
+ * (e.g. the temp `nx@latest` install used by the migrate bootstrap). See
+ * nrwl/nx#35444 and `resolvePackageJsonWithoutCachePollution` below.
+ */
+function readInstalledNxPackageJson() {
+    const path = resolvePackageJsonWithoutCachePollution('nx', (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot));
+    if (!path) {
+        return null;
+    }
+    try {
+        return (0, fileutils_1.readJsonFile)(path);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Resolve the workspace's installed `nx` version, or `null` if no installed
- * `nx` can be located. Routed through a cache-shielded, self-reference-free
- * `require.resolve` so the answer always reflects the workspace's
- * `node_modules`/PnP store rather than whichever `nx` package happens to be
- * loaded in the current process. See nrwl/nx#35444.
+ * `nx` can be located.
  */
 function getInstalledNxVersion() {
-    const nxPackageJsonPath = resolvePackageJsonWithoutCachePollution('nx', (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot));
-    if (!nxPackageJsonPath) {
+    return readInstalledNxPackageJson()?.version ?? null;
+}
+/**
+ * Return the package names declared in the installed `nx` package's
+ * `ng-update.packageGroup` (or `nx-migrations.packageGroup`), plus `'nx'`
+ * itself. Returns a set containing only `'nx'` when nx isn't installed or
+ * the metadata is missing.
+ */
+function getInstalledNxPackageGroup() {
+    const set = new Set(['nx']);
+    const pkg = readInstalledNxPackageJson();
+    if (!pkg) {
+        return set;
+    }
+    const declared = pkg['ng-update']?.packageGroup ?? pkg['nx-migrations']?.packageGroup;
+    if (declared) {
+        for (const entry of (0, package_json_1.normalizePackageGroup)(declared)) {
+            set.add(entry.package);
+        }
+    }
+    return set;
+}
+/**
+ * Resolve the workspace's installed `@nrwl/workspace` version (legacy-era
+ * fallback for `nx migrate --mode=third-party` targeting `< 14.0.0-beta.0`),
+ * or `null` if it cannot be resolved from the workspace require paths.
+ */
+function getInstalledLegacyNrwlWorkspaceVersion() {
+    const path = resolvePackageJsonWithoutCachePollution('@nrwl/workspace', (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot));
+    if (!path) {
         return null;
     }
     try {
-        return (0, fileutils_1.readJsonFile)(nxPackageJsonPath).version ?? null;
+        return (0, fileutils_1.readJsonFile)(path).version ?? null;
     }
     catch {
         return null;

package/dist/src/utils/logger.d.ts

@@ -1,7 +1,17 @@
 export declare const NX_PREFIX: string;
 export declare const NX_ERROR: string;
+type LogDriver = Pick<Console, 'warn' | 'error' | 'info' | 'log' | 'debug'>;
+export declare function createLogger(driver: LogDriver): {
+    warn: (...v: any[]) => void;
+    error: (s: any) => void;
+    info: (s: any) => void;
+    log: (...s: any[]) => void;
+    debug: (...s: any[]) => void;
+    fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
+};
 export declare const logger: {
-    warn: (s: any) => void;
+    warn: (...v: any[]) => void;
     error: (s: any) => void;
     info: (s: any) => void;
     log: (...s: any[]) => void;
@@ -10,3 +20,4 @@ export declare const logger: {
     verbose: (...s: any[]) => void;
 };
 export declare function stripIndent(str: string): string;
+export {};