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

package/dist/src/utils/logger.js

@@ -1,47 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logger = exports.NX_ERROR = exports.NX_PREFIX = void 0;
+exports.createLogger = createLogger;
 exports.stripIndent = stripIndent;
 const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const logger_1 = require("../daemon/logger");
 exports.NX_PREFIX = pc.inverse(pc.bold(pc.cyan(' NX ')));
 exports.NX_ERROR = pc.inverse(pc.bold(pc.red(' ERROR ')));
-exports.logger = {
-    warn: (s) => console.warn(pc.bold(pc.yellow(s))),
-    error: (s) => {
-        if (typeof s === 'string' && s.startsWith('NX ')) {
-            console.error(`\n${exports.NX_ERROR} ${pc.bold(pc.red(s.slice(3)))}\n`);
-        }
-        else if (s instanceof Error && s.stack) {
-            console.error(pc.bold(pc.red(s.stack)));
-        }
-        else {
-            console.error(pc.bold(pc.red(s)));
-        }
-    },
-    info: (s) => {
-        if (typeof s === 'string' && s.startsWith('NX ')) {
-            console.info(`\n${exports.NX_PREFIX} ${pc.bold(s.slice(3))}\n`);
-        }
-        else {
-            console.info(s);
-        }
-    },
-    log: (...s) => {
-        console.log(...s);
-    },
-    debug: (...s) => {
-        console.debug(...s);
-    },
-    fatal: (...s) => {
-        console.error(...s);
-    },
-    verbose: (...s) => {
-        if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            console.log(...s);
-        }
-    },
-};
+function createLogger(driver) {
+    return {
+        warn: (...v) => driver.warn(...v.map((s) => pc.bold(pc.yellow(s)))),
+        error: (s) => {
+            if (typeof s === 'string' && s.startsWith('NX ')) {
+                driver.error(`\n${exports.NX_ERROR} ${pc.bold(pc.red(s.slice(3)))}\n`);
+            }
+            else if (s instanceof Error && s.stack) {
+                driver.error(pc.bold(pc.red(s.stack)));
+            }
+            else {
+                driver.error(pc.bold(pc.red(s)));
+            }
+        },
+        info: (s) => {
+            if (typeof s === 'string' && s.startsWith('NX ')) {
+                driver.info(`\n${exports.NX_PREFIX} ${pc.bold(s.slice(3))}\n`);
+            }
+            else {
+                driver.info(s);
+            }
+        },
+        log: (...s) => {
+            driver.log(...s);
+        },
+        debug: (...s) => {
+            driver.debug(...s);
+        },
+        fatal: (...s) => {
+            driver.error(...s);
+        },
+        verbose: (...s) => {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                // verbose logs go to stderr to prevent things like `nx show projects | grep`
+                // breaking when you enable verbose logging. The only potential breakage from
+                // this would be if a tool counts any output on stderr as being an issue, but
+                // there are likely other places that would trigger those same issues.
+                driver.warn(...s);
+            }
+        },
+    };
+}
+exports.logger = createLogger((0, is_on_daemon_1.isOnDaemon)()
+    ? (() => {
+        const log = logger_1.serverLogger.log.bind(logger_1.serverLogger);
+        return {
+            warn: log,
+            error: log,
+            debug: log,
+            info: log,
+            log: log,
+        };
+    })()
+    : console);
 function stripIndent(str) {
     const match = str.match(/^[ \t]*(?=\S)/gm);
     if (!match) {

package/dist/src/utils/nx-key.d.ts

@@ -1,6 +1,5 @@
 import type { NxKey } from '@nx/key';
 export declare function createNxKeyLicenseeInformation(nxKey: NxKey): string;
-export declare function printNxKey(): Promise<void>;
 export declare function getNxKeyInformation(): Promise<NxKey | null>;
 export declare class NxKeyNotInstalledError extends Error {
     constructor(e: Error);

package/dist/src/utils/nx-key.js

@@ -2,12 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NxKeyNotInstalledError = void 0;
 exports.createNxKeyLicenseeInformation = createNxKeyLicenseeInformation;
-exports.printNxKey = printNxKey;
 exports.getNxKeyInformation = getNxKeyInformation;
-const logger_1 = require("./logger");
+const installation_directory_1 = require("./installation-directory");
 const package_manager_1 = require("./package-manager");
 const workspace_root_1 = require("./workspace-root");
-const handle_import_1 = require("./handle-import");
 function createNxKeyLicenseeInformation(nxKey) {
     if ('isPowerpack' in nxKey && nxKey.isPowerpack) {
         return `Licensed to ${nxKey.organizationName} for ${nxKey.seatCount} user${nxKey.seatCount > 1 ? 's' : ''} in ${nxKey.workspaceCount === 9999
@@ -18,32 +16,31 @@ function createNxKeyLicenseeInformation(nxKey) {
         return `Licensed to ${nxKey.organizationName}.`;
     }
 }
-async function printNxKey() {
+// `await handleImport` walks node_modules and pays ~25ms per miss; `resolve`
+// is just the filesystem lookup and is microseconds when the package is absent.
+// Only treat MODULE_NOT_FOUND as "not installed" so unrelated errors (permission,
+// corrupt package.json, etc.) still surface instead of being silently hidden.
+function packageInstalled(name) {
     try {
-        const key = await getNxKeyInformation();
-        if (key) {
-            logger_1.logger.log(createNxKeyLicenseeInformation(key));
-        }
+        require.resolve(name, { paths: (0, installation_directory_1.getNxRequirePaths)() });
+        return true;
+    }
+    catch (e) {
+        if (e?.code === 'MODULE_NOT_FOUND')
+            return false;
+        throw e;
     }
-    catch { }
 }
 async function getNxKeyInformation() {
-    try {
-        const { getPowerpackLicenseInformation, getPowerpackLicenseInformationAsync, } = (await (0, handle_import_1.handleImport)('@nx/powerpack-license'));
-        return (getPowerpackLicenseInformationAsync ?? getPowerpackLicenseInformation)(workspace_root_1.workspaceRoot);
+    if (packageInstalled('@nx/key')) {
+        const { getNxKeyInformationAsync } = await import('@nx/key');
+        return getNxKeyInformationAsync(workspace_root_1.workspaceRoot);
     }
-    catch (e) {
-        try {
-            const { getNxKeyInformationAsync } = (await (0, handle_import_1.handleImport)('@nx/key'));
-            return getNxKeyInformationAsync(workspace_root_1.workspaceRoot);
-        }
-        catch (e) {
-            if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
-                throw new NxKeyNotInstalledError(e);
-            }
-            throw e;
-        }
+    if (packageInstalled('@nx/powerpack-license')) {
+        const { getPowerpackLicenseInformation, getPowerpackLicenseInformationAsync, } = await import('@nx/powerpack-license');
+        return (getPowerpackLicenseInformationAsync ?? getPowerpackLicenseInformation)(workspace_root_1.workspaceRoot);
     }
+    throw new NxKeyNotInstalledError(new Error('MODULE_NOT_FOUND'));
 }
 class NxKeyNotInstalledError extends Error {
     constructor(e) {

package/dist/src/utils/nx-package-group.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The first-party Nx package set declared in nx's own
+ * `nx-migrations.packageGroup`. Used by `nx report` (to know which
+ * package versions to print) and by `nx add` shell completion (to
+ * suggest first-party plugins). Auto-updates as new plugins land in
+ * the package group — no hand-maintained list.
+ */
+export declare function readNxPackageGroup(): string[];

package/dist/src/utils/nx-package-group.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxPackageGroup = readNxPackageGroup;
+const fileutils_1 = require("./fileutils");
+/**
+ * The first-party Nx package set declared in nx's own
+ * `nx-migrations.packageGroup`. Used by `nx report` (to know which
+ * package versions to print) and by `nx add` shell completion (to
+ * suggest first-party plugins). Auto-updates as new plugins land in
+ * the package group — no hand-maintained list.
+ */
+function readNxPackageGroup() {
+    const nxPkg = (0, fileutils_1.readJsonFile)(require.resolve('nx/package.json'));
+    return (nxPkg['nx-migrations']?.packageGroup ?? []).map((e) => typeof e === 'string' ? e : e.package);
+}

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

@@ -1,3 +1,4 @@
+import { WriteStream } from 'tty';
 import type { TaskStatus } from '../tasks-runner/tasks-runner';
 export interface CLIErrorMessageConfig {
     title: string;
@@ -47,12 +48,12 @@ declare class CLIOutput {
     bold: import("picocolors/types").Formatter;
     underline: import("picocolors/types").Formatter;
     dim: import("picocolors/types").Formatter;
-    private writeToStdOut;
+    private writeToStream;
     overwriteLine(lineText?: string): void;
     private writeOutputTitle;
     private writeOptionalOutputBody;
     applyNxPrefix(color: string, text: string): string;
-    addNewline(): void;
+    addNewline(stream?: WriteStream): void;
     addVerticalSeparator(color?: string): void;
     addVerticalSeparatorWithoutNewLines(color?: string): void;
     getVerticalSeparatorLines(color?: string): string[];

package/dist/src/utils/output.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.output = void 0;
 exports.orange = orange;
 const tslib_1 = require("tslib");
-const pc = tslib_1.__importStar(require("picocolors"));
 const os_1 = require("os");
+const pc = tslib_1.__importStar(require("picocolors"));
 const readline = tslib_1.__importStar(require("readline"));
 const GH_GROUP_PREFIX = '::group::';
 const GH_GROUP_SUFFIX = '::endgroup::';
@@ -62,8 +62,8 @@ class CLIOutput {
         }
         return divider;
     }
-    writeToStdOut(str) {
-        process.stdout.write(str);
+    writeToStream(str, stream = process.stdout) {
+        stream.write(str);
     }
     overwriteLine(lineText = '') {
         // Ensure we always start writing from column 0.
@@ -78,23 +78,23 @@ class CLIOutput {
         process.stdout.write('\n');
         readline.cursorTo(process.stdout, 0);
     }
-    writeOutputTitle({ color, title, }) {
-        this.writeToStdOut(`${this.applyNxPrefix(color, title)}${os_1.EOL}`);
+    writeOutputTitle({ color, title, }, stream = process.stdout) {
+        this.writeToStream(`${this.applyNxPrefix(color, title)}${os_1.EOL}`, stream);
     }
-    writeOptionalOutputBody(bodyLines) {
+    writeOptionalOutputBody(bodyLines, stream = process.stdout) {
         if (!bodyLines) {
             return;
         }
-        this.addNewline();
-        bodyLines.forEach((bodyLine) => this.writeToStdOut(`${bodyLine}${os_1.EOL}`));
+        this.addNewline(stream);
+        bodyLines.forEach((bodyLine) => this.writeToStream(`${bodyLine}${os_1.EOL}`, stream));
     }
     applyNxPrefix(color = 'cyan', text) {
         const colorFn = pcColors[color] || ((t) => t);
         const nxPrefix = pc.inverse(pc.bold(colorFn(` ${this.cliName} `)));
         return `${nxPrefix}  ${text}`;
     }
-    addNewline() {
-        this.writeToStdOut(os_1.EOL);
+    addNewline(stream = process.stdout) {
+        this.writeToStream(os_1.EOL, stream);
     }
     addVerticalSeparator(color = 'gray') {
         this.addNewline();
@@ -102,7 +102,7 @@ class CLIOutput {
         this.addNewline();
     }
     addVerticalSeparatorWithoutNewLines(color = 'gray') {
-        this.writeToStdOut(`${this.getVerticalSeparator(color)}${os_1.EOL}`);
+        this.writeToStream(`${this.getVerticalSeparator(color)}${os_1.EOL}`);
     }
     getVerticalSeparatorLines(color = 'gray') {
         return ['', this.getVerticalSeparator(color), ''];
@@ -112,36 +112,37 @@ class CLIOutput {
         return pc.dim(colorFn(this.VERTICAL_SEPARATOR));
     }
     error({ title, slug, bodyLines }) {
-        this.addNewline();
+        const stream = process.stderr;
+        this.addNewline(stream);
         this.writeOutputTitle({
             color: 'red',
             title: pc.red(title),
-        });
-        this.writeOptionalOutputBody(bodyLines);
+        }, stream);
+        this.writeOptionalOutputBody(bodyLines, stream);
         /**
          * Optional slug to be used in an Nx error message redirect URL
          */
         if (slug && typeof slug === 'string') {
-            this.addNewline();
-            this.writeToStdOut(`${pc.gray('  Learn more about this error: ')}https://errors.nx.dev/${slug}${os_1.EOL}`);
+            this.addNewline(stream);
+            this.writeToStream(`${pc.gray('  Learn more about this error: ')}https://errors.nx.dev/${slug}${os_1.EOL}`, stream);
         }
-        this.addNewline();
+        this.addNewline(stream);
     }
     warn({ title, slug, bodyLines }) {
-        this.addNewline();
+        this.addNewline(process.stderr);
         this.writeOutputTitle({
             color: 'yellow',
             title: pc.yellow(title),
-        });
-        this.writeOptionalOutputBody(bodyLines);
+        }, process.stderr);
+        this.writeOptionalOutputBody(bodyLines, process.stderr);
         /**
          * Optional slug to be used in an Nx warning message redirect URL
          */
         if (slug && typeof slug === 'string') {
-            this.addNewline();
-            this.writeToStdOut(`${pc.gray('  Learn more about this warning: ')}https://errors.nx.dev/${slug}${os_1.EOL}`);
+            this.addNewline(process.stderr);
+            this.writeToStream(`${pc.gray('  Learn more about this warning: ')}https://errors.nx.dev/${slug}${os_1.EOL}`, process.stderr);
         }
-        this.addNewline();
+        this.addNewline(process.stderr);
     }
     note({ title, bodyLines }) {
         this.addNewline();
@@ -170,12 +171,12 @@ class CLIOutput {
         this.addNewline();
     }
     logRawLine(message) {
-        this.writeToStdOut(`${message}${os_1.EOL}`);
+        this.writeToStream(`${message}${os_1.EOL}`);
         this.addNewline();
     }
     logCommand(message, taskStatus) {
         this.addNewline();
-        this.writeToStdOut(this.getCommandWithStatus(message, taskStatus));
+        this.writeToStream(this.getCommandWithStatus(message, taskStatus));
         this.addNewline();
         this.addNewline();
     }
@@ -187,13 +188,13 @@ class CLIOutput {
             commandOutputWithStatus = `${GH_GROUP_PREFIX}${icon} ${commandOutputWithStatus}`;
         }
         this.addNewline();
-        this.writeToStdOut(commandOutputWithStatus);
+        this.writeToStream(commandOutputWithStatus);
         this.addNewline();
         this.addNewline();
-        this.writeToStdOut(output);
+        this.writeToStream(output);
         if (process.env.NX_SKIP_LOG_GROUPING !== 'true' &&
             process.env.GITHUB_ACTIONS) {
-            this.writeToStdOut(GH_GROUP_SUFFIX);
+            this.writeToStream(GH_GROUP_SUFFIX);
         }
     }
     getCommandWithStatus(message, taskStatus) {

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

@@ -92,9 +92,22 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
     packageGroup?: ArrayPackageGroup;
 };
 export declare function buildTargetFromScript(script: string, scripts: Record<string, string>, packageManagerCommand: PackageManagerCommands): TargetConfiguration;
+export type PackageJsonProjectMetadata = {
+    targetGroups: {
+        'NPM Scripts'?: Array<string>;
+    };
+    description: string;
+    js: {
+        packageName: PackageJson['name'];
+        packageVersion: PackageJson['version'];
+        packageExports: PackageJson['exports'];
+        packageMain: PackageJson['main'];
+        isInPackageManagerWorkspaces: boolean;
+    };
+};
 export declare function getMetadataFromPackageJson(packageJson: PackageJson, isInPackageManagerWorkspaces: boolean): ProjectMetadata;
 export declare function getTagsFromPackageJson(packageJson: PackageJson): string[];
-export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration, projectRoot: string, workspaceRoot: string): Record<string, TargetConfiguration<any>>;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration, projectRoot: string, workspaceRoot: string, packageManagerCommand: PackageManagerCommands): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

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

@@ -18,9 +18,11 @@ const path_1 = require("path");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 const tmp_1 = require("tmp");
 const json_1 = require("../generators/utils/json");
+const project_configuration_utils_1 = require("../project-graph/utils/project-configuration-utils");
 const target_merging_1 = require("../project-graph/utils/project-configuration/target-merging");
 const catalog_1 = require("./catalog");
 const fileutils_1 = require("./fileutils");
+const has_nx_js_plugin_1 = require("./has-nx-js-plugin");
 const installation_directory_1 = require("./installation-directory");
 const package_manager_1 = require("./package-manager");
 const workspace_root_1 = require("./workspace-root");
@@ -66,14 +68,15 @@ function buildTargetFromScript(script, scripts = {}, packageManagerCommand) {
         },
     };
 }
-let packageManagerCommand;
 function getMetadataFromPackageJson(packageJson, isInPackageManagerWorkspaces) {
     const { scripts, nx, description, name, exports, main, version } = packageJson;
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
-    return {
-        targetGroups: {
-            ...(includedScripts.length ? { 'NPM Scripts': includedScripts } : {}),
-        },
+    const metadata = {
+        targetGroups: includedScripts.length
+            ? {
+                'NPM Scripts': includedScripts,
+            }
+            : {},
         description,
         js: {
             packageName: name,
@@ -83,6 +86,7 @@ function getMetadataFromPackageJson(packageJson, isInPackageManagerWorkspaces) {
             isInPackageManagerWorkspaces,
         },
     };
+    return metadata;
 }
 function getTagsFromPackageJson(packageJson) {
     const tags = packageJson.private ? ['npm:private'] : ['npm:public'];
@@ -94,12 +98,11 @@ function getTagsFromPackageJson(packageJson) {
     }
     return tags;
 }
-function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot) {
+function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot, packageManagerCommand) {
     const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
     for (const script of includedScripts) {
-        packageManagerCommand ??= (0, package_manager_1.getPackageManagerCommand)();
         res[script] = buildTargetFromScript(script, scripts, packageManagerCommand);
     }
     for (const targetName in nx?.targets) {
@@ -124,8 +127,8 @@ function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceR
      */
     if (!isPrivate &&
         !res['nx-release-publish'] &&
-        hasNxJsPlugin(projectRoot, workspaceRoot)) {
-        const nxReleasePublishTargetDefaults = nxJson?.targetDefaults?.['nx-release-publish'] ?? {};
+        (0, has_nx_js_plugin_1.hasNxJsPlugin)(projectRoot, workspaceRoot)) {
+        const nxReleasePublishTargetDefaults = readCompatibleTargetDefaultsForTarget('nx-release-publish', nxJson?.targetDefaults, '@nx/js:release-publish') ?? {};
         res['nx-release-publish'] = {
             executor: '@nx/js:release-publish',
             ...nxReleasePublishTargetDefaults,
@@ -141,17 +144,13 @@ function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceR
     }
     return res;
 }
-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;
+function readCompatibleTargetDefaultsForTarget(targetName, targetDefaults, executor) {
+    if (targetDefaults &&
+        !Array.isArray(targetDefaults) &&
+        Object.prototype.hasOwnProperty.call(targetDefaults, targetName)) {
+        return targetDefaults[targetName] ?? null;
     }
+    return (0, project_configuration_utils_1.readTargetDefaultsForTarget)(targetName, targetDefaults, executor);
 }
 /**
  * Uses `require.resolve` to read the package.json for a module.
@@ -221,11 +220,11 @@ function preparePackageInstallation(pkg, requiredVersion) {
         cleanup: () => { },
     };
     console.log(`Fetching ${pkg}...`);
-    const packageManager = (0, package_manager_1.detectPackageManager)();
+    const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
     const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
     generatePackageManagerFiles(tempDir, packageManager);
-    const preInstallCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager).preInstall;
     const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+    const preInstallCommand = pmCommands.preInstall;
     let addCommand = pmCommands.addDev;
     if (packageManager === 'pnpm') {
         addCommand = 'pnpm add -D'; // we need to ensure that we are not using workspace command

package/dist/src/utils/perf-logging.js

@@ -7,6 +7,7 @@ function isTrackedDetail(detail) {
         detail.track === true);
 }
 new perf_hooks_1.PerformanceObserver((list) => {
+    // observer is configured for 'measure' entries only (see .observe call below)
     const entries = list.getEntries();
     const logEnabled = process.env.NX_PERF_LOGGING === 'true';
     const tracked = entries.filter((e) => isTrackedDetail(e.detail));
@@ -17,9 +18,10 @@ new perf_hooks_1.PerformanceObserver((list) => {
     if (logEnabled) {
         const { isOnDaemon } = require('../daemon/is-on-daemon');
         const { serverLogger } = require('../daemon/logger');
+        const { logger } = require('./logger');
         const log = isOnDaemon()
             ? (msg) => serverLogger.log(msg)
-            : console.log;
+            : (msg) => logger.warn(msg);
         for (const entry of entries) {
             log(`Time taken for '${entry.name}' ${entry.duration}ms`);
         }

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

@@ -21,8 +21,17 @@ interface PluginCacheData<T> {
 export declare class PluginCache<T> {
     private entries;
     private accessOrder;
-    constructor(cachePath: string);
-    constructor(entries?: Record<string, T>, accessOrder?: string[] | Set<string>);
+    private cachePath;
+    /**
+     * Constructs a `PluginCache`. The `cachePath` is the single source of truth
+     * for both reading and writing — `writeToDisk()` writes to it.
+     *
+     * If `entries` is omitted, the cache is loaded from `cachePath` on disk.
+     * If `entries` is provided, those entries are used as the in-memory state
+     * and the on-disk file is not read (useful for tests or for seeding the
+     * cache with known state).
+     */
+    constructor(cachePath: string, entries?: Record<string, T>, accessOrder?: string[] | Set<string>);
     private touch;
     /**
      * Returns the value for `key`, or `undefined` if not present.
@@ -44,7 +53,7 @@ export declare class PluginCache<T> {
      */
     toSerializable(): PluginCacheData<T>;
     /**
-     * Safely writes this cache to disk.
+     * Safely writes this cache to the path it was constructed with.
      *
      * Strategy:
      * 1. Serialize to JSON
@@ -55,7 +64,7 @@ export declare class PluginCache<T> {
      * 3. On total serialization failure (even after eviction),
      *    write an empty cache so the file is valid
      */
-    writeToDisk(cachePath: string): void;
+    writeToDisk(): void;
     /**
      * Evicts the oldest 50% of entries (front of the access-order queue)
      * and returns the remaining entries + accessOrder as a plain object.

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

@@ -20,17 +20,27 @@ const logger_1 = require("./logger");
  * least recently used keys.
  */
 class PluginCache {
-    constructor(cachePathOrEntries, accessOrder) {
-        if (typeof cachePathOrEntries === 'string') {
-            const loaded = loadFromDisk(cachePathOrEntries);
-            this.entries = loaded.entries;
-            this.accessOrder = loaded.accessOrder;
-        }
-        else {
-            this.entries = cachePathOrEntries ?? {};
+    /**
+     * Constructs a `PluginCache`. The `cachePath` is the single source of truth
+     * for both reading and writing — `writeToDisk()` writes to it.
+     *
+     * If `entries` is omitted, the cache is loaded from `cachePath` on disk.
+     * If `entries` is provided, those entries are used as the in-memory state
+     * and the on-disk file is not read (useful for tests or for seeding the
+     * cache with known state).
+     */
+    constructor(cachePath, entries, accessOrder) {
+        this.cachePath = cachePath;
+        if (entries !== undefined) {
+            this.entries = entries;
             this.accessOrder =
                 accessOrder instanceof Set ? accessOrder : new Set(accessOrder ?? []);
         }
+        else {
+            const loaded = loadFromDisk(cachePath);
+            this.entries = loaded.entries;
+            this.accessOrder = loaded.accessOrder;
+        }
     }
     touch(key) {
         // Sets are guaranteed to maintain insertion order, so we can delete and re-add to move it to the end.
@@ -73,7 +83,7 @@ class PluginCache {
         };
     }
     /**
-     * Safely writes this cache to disk.
+     * Safely writes this cache to the path it was constructed with.
      *
      * Strategy:
      * 1. Serialize to JSON
@@ -84,8 +94,8 @@ class PluginCache {
      * 3. On total serialization failure (even after eviction),
      *    write an empty cache so the file is valid
      */
-    writeToDisk(cachePath) {
-        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(cachePath), { recursive: true });
+    writeToDisk() {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(this.cachePath), { recursive: true });
         let content;
         try {
             content = JSON.stringify({
@@ -115,11 +125,11 @@ class PluginCache {
         }
         // Attempt to write the serialized content to disk
         try {
-            (0, node_fs_1.writeFileSync)(cachePath, content);
+            (0, node_fs_1.writeFileSync)(this.cachePath, content);
         }
         catch {
             // Filesystem error — wipe cache so a corrupted file doesn't persist
-            tryRemoveFile(cachePath);
+            tryRemoveFile(this.cachePath);
         }
     }
     /**

package/dist/src/utils/plugins/local-plugins.d.ts

@@ -1,4 +1,22 @@
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectsConfigurations } from '../../config/workspace-json-project-json';
 import { PluginCapabilities } from './plugin-capabilities';
+/** A workspace-local plugin discovered cheaply (no JS load). */
+export interface LocalPluginWithGenerators {
+    /** Absolute path to the project root that hosts the plugin. */
+    dir: string;
+    /** The `generators` or `schematics` field value from the plugin's
+     *  package.json (a relative path to the collection JSON). */
+    field: string;
+}
+/**
+ * Sync, lightweight scan: for each given project root, read its package.json
+ * and yield it as a plugin if it declares a `generators`/`schematics`
+ * collection. Used by tab completion which cannot afford the heavier
+ * {@link getLocalWorkspacePlugins} (that one loads each plugin's JS to
+ * walk its capabilities).
+ *
+ * `projectRoots` are paths relative to `workspaceRoot`.
+ */
+export declare function findLocalPluginsWithGenerators(projectRoots: Iterable<string>): Map<string, LocalPluginWithGenerators>;
 export declare function getLocalWorkspacePlugins(projectsConfiguration: ProjectsConfigurations, nxJson: NxJsonConfiguration): Promise<Map<string, PluginCapabilities>>;