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

package/dist/src/command-line/completion/command-object.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsCompletionCommand = void 0;
+const enquirer_1 = require("enquirer");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const handle_import_1 = require("../../utils/handle-import");
+const SHELL_CHOICES = ['bash', 'zsh', 'fish', 'powershell'];
+exports.yargsCompletionCommand = {
+    command: 'completion [shell]',
+    describe: 'Install shell completion for bash, zsh, fish, or powershell. Omit the shell to pick interactively.',
+    builder: (yargs) => yargs
+        .positional('shell', {
+        type: 'string',
+        choices: SHELL_CHOICES,
+        describe: 'Shell to install completion for.',
+    })
+        .option('force', {
+        type: 'boolean',
+        default: false,
+        describe: 'Install the completion script even if `nx` is not found on PATH.',
+    })
+        .option('stdout', {
+        type: 'boolean',
+        default: false,
+        describe: 'Print the completion script to stdout instead of writing to the shell rc file.',
+    })
+        .example('$0 completion bash', 'Install bash completion to ~/.bashrc')
+        .example('$0 completion', 'Pick shells interactively and install completion for each')
+        .example('$0 completion bash --stdout >> ~/.bash_profile', 'Print to stdout for a custom rc location'),
+    handler: async (args) => {
+        const scripts = await (0, handle_import_1.handleImport)('./scripts.js', __dirname);
+        const shells = args.shell ? [args.shell] : await pickShellsInteractively();
+        if (shells.length === 0) {
+            console.warn('nx: no shells selected — nothing installed.');
+            process.exit(0);
+        }
+        if (args.stdout && shells.length > 1) {
+            console.warn('nx: --stdout only makes sense with one shell — concatenating two wrapper scripts to stdout is never useful.');
+            process.exit(1);
+        }
+        const emit = args.stdout
+            ? scripts.printCompletionScript
+            : scripts.installCompletionScript;
+        // Fire the PATH-advisory once, before any per-shell emit.
+        if (!args.force)
+            scripts.maybeWarnNxNotOnPath();
+        for (const shell of shells)
+            emit(shell);
+        process.exit(0);
+    },
+};
+async function pickShellsInteractively() {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        console.warn('nx: please specify a shell — `nx completion <bash|zsh|fish|powershell>`.');
+        process.exit(1);
+    }
+    const detected = detectAvailableShells();
+    const answer = (await (0, enquirer_1.prompt)({
+        type: 'multiselect',
+        name: 'shells',
+        message: 'Install nx completion for which shell(s)?',
+        choices: SHELL_CHOICES.map((name) => ({
+            name,
+            value: name,
+            // Pre-check shells we can detect on this machine.
+            enabled: detected.has(name),
+        })),
+    }));
+    return answer.shells ?? [];
+}
+/** Best-effort detect-which-shells-the-user-has. Pre-checks the multiselect.
+ *  Signals: $SHELL basename, presence of conventional rc files, $PSModulePath
+ *  for PowerShell. False positives are fine — the user can uncheck. */
+function detectAvailableShells() {
+    const found = new Set();
+    const home = (0, os_1.homedir)();
+    const shellEnv = (process.env.SHELL ?? '').replace(/\\/g, '/');
+    const shellName = shellEnv.split('/').pop() ?? '';
+    if (shellName === 'bash' || (0, fs_1.existsSync)((0, path_1.join)(home, '.bashrc'))) {
+        found.add('bash');
+    }
+    if (shellName === 'zsh' || (0, fs_1.existsSync)((0, path_1.join)(home, '.zshrc'))) {
+        found.add('zsh');
+    }
+    if (shellName === 'fish' ||
+        (0, fs_1.existsSync)((0, path_1.join)(home, '.config', 'fish', 'config.fish'))) {
+        found.add('fish');
+    }
+    if (process.env.PSModulePath || process.platform === 'win32') {
+        found.add('powershell');
+    }
+    return found;
+}

package/dist/src/command-line/completion/completion-providers.d.ts

@@ -0,0 +1,21 @@
+/** Project names matching `current`. */
+export declare function getProjectNameCompletions(current: string): string[];
+/** Projects that declare `targetName`, matching `current`. */
+export declare function getProjectNamesWithTarget(current: string, targetName: string): string[];
+/** Two-stage `project[:target]` — stage 1 emits `project:` (nospace), stage 2 emits `project:target`. */
+export declare function completeProjectTarget(current: string): string[];
+/** Generator completion. Stage 1 (`nx g <TAB>`) emits plugin names (with `:`)
+ *  and bare generator names (for `nx g application`); stage 2 emits
+ *  `plugin:generator`. */
+export declare function completeGenerator(current: string): string[];
+/** Plugin names matching `current` — installed npm plugins + workspace-local
+ *  plugin projects, only those declaring a generator collection. */
+export declare function getGeneratorPluginCompletions(current: string): string[];
+/** Generator names in a single plugin, matching `current`. */
+export declare function getGeneratorsForPlugin(pluginName: string, current: string): string[];
+/** Unique target names across the workspace, matching `current`. */
+export declare function getTargetNameCompletions(current: string): string[];
+/** Target names for a single project, matching `current`. Falls back to
+ *  workspace-wide if the project isn't in the graph — covers the
+ *  `project:t<TAB>` case where the user is still typing the project name. */
+export declare function getTargetNamesForProject(current: string, projectName: string): string[];

package/dist/src/command-line/completion/completion-providers.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectNameCompletions = getProjectNameCompletions;
+exports.getProjectNamesWithTarget = getProjectNamesWithTarget;
+exports.completeProjectTarget = completeProjectTarget;
+exports.completeGenerator = completeGenerator;
+exports.getGeneratorPluginCompletions = getGeneratorPluginCompletions;
+exports.getGeneratorsForPlugin = getGeneratorsForPlugin;
+exports.getTargetNameCompletions = getTargetNameCompletions;
+exports.getTargetNamesForProject = getTargetNamesForProject;
+const path_1 = require("path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const project_graph_1 = require("../../project-graph/project-graph");
+const fileutils_1 = require("../../utils/fileutils");
+const local_plugins_1 = require("../../utils/plugins/local-plugins");
+/** Stale graphs are intentionally tolerated — do not "fix" by triggering
+ *  a recompute. readCachedProjectGraph throws if no cache exists; we
+ *  swallow because completion must always degrade silently. */
+function getCachedProjectGraph() {
+    try {
+        return (0, project_graph_1.readCachedProjectGraph)();
+    }
+    catch {
+        return null;
+    }
+}
+/** Project names matching `current`. */
+function getProjectNameCompletions(current) {
+    const graph = getCachedProjectGraph();
+    if (!graph?.nodes) {
+        return [];
+    }
+    const names = Object.keys(graph.nodes);
+    if (!current) {
+        return names;
+    }
+    return names.filter((name) => name.startsWith(current));
+}
+/** Projects that declare `targetName`, matching `current`. */
+function getProjectNamesWithTarget(current, targetName) {
+    const graph = getCachedProjectGraph();
+    if (!graph?.nodes) {
+        return [];
+    }
+    const matches = [];
+    for (const [name, node] of Object.entries(graph.nodes)) {
+        if (node?.data?.targets?.[targetName]) {
+            if (!current || name.startsWith(current)) {
+                matches.push(name);
+            }
+        }
+    }
+    return matches;
+}
+/** Two-stage `project[:target]` — stage 1 emits `project:` (nospace), stage 2 emits `project:target`. */
+function completeProjectTarget(current) {
+    const colonIdx = current.indexOf(':');
+    if (colonIdx === -1) {
+        return getProjectNameCompletions(current).map((p) => `${p}:`);
+    }
+    const projectName = current.slice(0, colonIdx);
+    const targetPrefix = current.slice(colonIdx + 1);
+    return getTargetNamesForProject(targetPrefix, projectName).map((t) => `${projectName}:${t}`);
+}
+/** Generator completion. Stage 1 (`nx g <TAB>`) emits plugin names (with `:`)
+ *  and bare generator names (for `nx g application`); stage 2 emits
+ *  `plugin:generator`. */
+function completeGenerator(current) {
+    const colonIdx = current.indexOf(':');
+    if (colonIdx !== -1) {
+        const pluginName = current.slice(0, colonIdx);
+        const generatorPrefix = current.slice(colonIdx + 1);
+        return getGeneratorsForPlugin(pluginName, generatorPrefix).map((g) => `${pluginName}:${g}`);
+    }
+    // No prefix on the plugin map — we need every plugin to enumerate bare
+    // generator names; dedup bare names across plugins.
+    const all = collectPluginDirs();
+    const result = [];
+    const bare = new Set();
+    for (const [name, entry] of all) {
+        if (!current || name.startsWith(current)) {
+            result.push(`${name}:`);
+        }
+        for (const gen of readGeneratorNames(entry.dir, entry.field)) {
+            if (!current || gen.startsWith(current)) {
+                bare.add(gen);
+            }
+        }
+    }
+    for (const gen of bare) {
+        result.push(gen);
+    }
+    return result;
+}
+/** Plugin names matching `current` — installed npm plugins + workspace-local
+ *  plugin projects, only those declaring a generator collection. */
+function getGeneratorPluginCompletions(current) {
+    return [...collectPluginDirs(current).keys()];
+}
+/** Generator names in a single plugin, matching `current`. */
+function getGeneratorsForPlugin(pluginName, current) {
+    const entry = collectPluginDirs(pluginName).get(pluginName);
+    if (!entry) {
+        return [];
+    }
+    const generators = readGeneratorNames(entry.dir, entry.field);
+    if (!current) {
+        return generators;
+    }
+    return generators.filter((g) => g.startsWith(current));
+}
+/** plugin name → { dir, generators-collection path }. Workspace-local
+ *  plugins win over same-named installed ones. `prefix` skips non-matching
+ *  installed deps before reading their package.json. */
+function collectPluginDirs(prefix = '') {
+    const dirs = new Map();
+    // Installed plugins: root package.json deps, resolved under node_modules.
+    const rootPkg = readJsonSafe((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'));
+    if (rootPkg) {
+        const deps = {
+            ...(rootPkg.dependencies ?? {}),
+            ...(rootPkg.devDependencies ?? {}),
+        };
+        for (const dep of Object.keys(deps)) {
+            if (prefix && !dep.startsWith(prefix))
+                continue;
+            const dir = (0, path_1.join)(workspace_root_1.workspaceRoot, 'node_modules', dep);
+            const pkg = readJsonSafe((0, path_1.join)(dir, 'package.json'));
+            const field = pkg?.generators ?? pkg?.schematics;
+            if (typeof field === 'string')
+                dirs.set(dep, { dir, field });
+        }
+    }
+    // Workspace-local plugin projects — shared helper with utils/plugins.
+    // Local entries overwrite same-named installed ones (the local one is what
+    // the user is developing).
+    const graph = getCachedProjectGraph();
+    const projectRoots = Object.values(graph?.nodes ?? {})
+        .map((n) => n?.data?.root)
+        .filter((r) => typeof r === 'string' && r.length > 0);
+    for (const [name, entry] of (0, local_plugins_1.findLocalPluginsWithGenerators)(projectRoots)) {
+        if (prefix && !name.startsWith(prefix))
+            continue;
+        dirs.set(name, entry);
+    }
+    return dirs;
+}
+/**
+ * Reads the non-hidden generator names from the `generators`/`schematics`
+ * JSON at `field`, relative to the plugin's `pluginDir`.
+ */
+function readGeneratorNames(pluginDir, field) {
+    const generatorsJson = readJsonSafe((0, path_1.join)(pluginDir, field));
+    if (!generatorsJson) {
+        return [];
+    }
+    const collection = generatorsJson.generators ?? generatorsJson.schematics ?? {};
+    return Object.keys(collection).filter((k) => !collection[k]?.hidden);
+}
+function readJsonSafe(path) {
+    try {
+        return (0, fileutils_1.readJsonFile)(path);
+    }
+    catch {
+        return null;
+    }
+}
+/** Unique target names across the workspace, matching `current`. */
+function getTargetNameCompletions(current) {
+    const graph = getCachedProjectGraph();
+    if (!graph?.nodes)
+        return [];
+    const targetSet = new Set();
+    for (const node of Object.values(graph.nodes)) {
+        for (const target of Object.keys(node?.data?.targets ?? {})) {
+            targetSet.add(target);
+        }
+    }
+    const targets = [...targetSet];
+    return current ? targets.filter((t) => t.startsWith(current)) : targets;
+}
+/** Target names for a single project, matching `current`. Falls back to
+ *  workspace-wide if the project isn't in the graph — covers the
+ *  `project:t<TAB>` case where the user is still typing the project name. */
+function getTargetNamesForProject(current, projectName) {
+    const graph = getCachedProjectGraph();
+    if (!graph?.nodes)
+        return [];
+    const node = graph.nodes[projectName];
+    if (!node)
+        return getTargetNameCompletions(current);
+    const targets = Object.keys(node?.data?.targets ?? {});
+    return current ? targets.filter((t) => t.startsWith(current)) : targets;
+}

package/dist/src/command-line/completion/infix-targets.d.ts

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

package/dist/src/command-line/completion/infix-targets.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = require("./metadata");
+const completion_providers_1 = require("./completion-providers");
+const project_graph_1 = require("../../project-graph/project-graph");
+// `nx <target> <project>` infix completion. Every unique target name in
+// the cached graph gets its own path; union with a conventional set so
+// cold workspaces still get the everyday names.
+//
+// This file is imported LAST in registrations.ts so we can skip target
+// names that collide with real Nx commands ('run', 'add', 'generate',
+// ...). Otherwise a workspace that happens to have e.g. a `run` target
+// would silently shadow the command-specific completer.
+const CONVENTIONAL_TARGETS = [
+    'build',
+    'serve',
+    'test',
+    'lint',
+    'e2e',
+    'dev',
+    'start',
+    'preview',
+    'typecheck',
+];
+const targetNames = new Set(CONVENTIONAL_TARGETS);
+try {
+    const graph = (0, project_graph_1.readCachedProjectGraph)();
+    for (const node of Object.values(graph?.nodes ?? {})) {
+        for (const t of Object.keys(node?.data?.targets ?? {})) {
+            targetNames.add(t);
+        }
+    }
+}
+catch {
+    // No cached graph — conventional set only.
+}
+const reserved = new Set((0, metadata_1.getRegisteredTopLevelPaths)());
+for (const targetName of targetNames) {
+    if (reserved.has(targetName))
+        continue;
+    (0, metadata_1.registerCompletion)(targetName, {
+        positionals: [
+            {
+                complete: (current) => (0, completion_providers_1.getProjectNamesWithTarget)(current, targetName),
+            },
+        ],
+    });
+}

package/dist/src/command-line/completion/metadata.d.ts

@@ -0,0 +1,22 @@
+export type CompletionFn = (current: string, args: string[]) => string[];
+export interface PositionalCompletion {
+    choices?: string[];
+    complete?: CompletionFn;
+}
+export interface CommandCompletionMetadata {
+    positionals?: PositionalCompletion[];
+    /** Flag value handlers, keyed without leading `--`. Aliases get their own
+     *  entry pointing at the same function. */
+    flags?: Record<string, CompletionFn>;
+}
+export declare function registerCompletion(path: string, metadata: CommandCompletionMetadata): void;
+/** Single-token registered paths (infix targets etc.). */
+export declare function getRegisteredTopLevelPaths(): string[];
+/** Longest-prefix match against the leading non-flag args. */
+export declare function findCompletionMetadata(args: string[]): {
+    metadata: CommandCompletionMetadata;
+    positionalIndex: number;
+} | null;
+export declare function findFlagCompletion(metadata: CommandCompletionMetadata | null, flag: string): CompletionFn | null;
+/** Positional/flag-value dispatch. Returns null when no handler applies. */
+export declare function resolveCompletion(args: string[], current: string, previousToken: string): string[] | null;

package/dist/src/command-line/completion/metadata.js

@@ -0,0 +1,71 @@
+"use strict";
+// Per-command completion metadata. Path-keyed because yargs doesn't
+// preserve command-object references through its parse.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCompletion = registerCompletion;
+exports.getRegisteredTopLevelPaths = getRegisteredTopLevelPaths;
+exports.findCompletionMetadata = findCompletionMetadata;
+exports.findFlagCompletion = findFlagCompletion;
+exports.resolveCompletion = resolveCompletion;
+const REGISTRY = new Map();
+function registerCompletion(path, metadata) {
+    REGISTRY.set(path, metadata);
+}
+/** Single-token registered paths (infix targets etc.). */
+function getRegisteredTopLevelPaths() {
+    const paths = [];
+    for (const path of REGISTRY.keys()) {
+        if (!path.includes(' '))
+            paths.push(path);
+    }
+    return paths;
+}
+/** Longest-prefix match against the leading non-flag args. */
+function findCompletionMetadata(args) {
+    const nonFlag = [];
+    for (const arg of args) {
+        if (arg.startsWith('-'))
+            break;
+        nonFlag.push(arg);
+    }
+    for (let i = nonFlag.length; i > 0; i--) {
+        const path = nonFlag.slice(0, i).join(' ');
+        const metadata = REGISTRY.get(path);
+        if (metadata) {
+            const positionalIndex = Math.max(0, nonFlag.length - i - 1);
+            return { metadata, positionalIndex };
+        }
+    }
+    return null;
+}
+function findFlagCompletion(metadata, flag) {
+    return metadata?.flags?.[flag] ?? null;
+}
+/** Positional/flag-value dispatch. Returns null when no handler applies. */
+function resolveCompletion(args, current, previousToken) {
+    if (args.length === 0)
+        return null;
+    const match = findCompletionMetadata(args);
+    const meta = match?.metadata ?? null;
+    if (previousToken && previousToken.startsWith('-')) {
+        const handler = findFlagCompletion(meta, previousToken.replace(/^-+/, ''));
+        if (handler)
+            return handler(current, args);
+        // The user is typing a flag's value but we don't have a handler for
+        // this flag. Emit no candidates so the shell wrapper falls back to its
+        // native default (filename/dirname completion in bash via `-o default`).
+        // Crucially, do NOT fall through to positional dispatch — that would
+        // offer wrong candidates (e.g. project names for `nx g app --directory <TAB>`).
+        return [];
+    }
+    if (match) {
+        const positional = match.metadata.positionals?.[match.positionalIndex];
+        if (positional?.complete)
+            return positional.complete(current, args);
+        if (positional?.choices) {
+            return positional.choices.filter((c) => c.startsWith(current));
+        }
+        return null;
+    }
+    return null;
+}

package/dist/src/command-line/completion/registrations.d.ts

@@ -0,0 +1,9 @@
+import '../run/completion';
+import '../run-many/completion';
+import '../affected/completion';
+import '../show/completion';
+import '../generate/completion';
+import '../graph/completion';
+import '../watch/completion';
+import '../add/completion';
+import './infix-targets';

package/dist/src/command-line/completion/registrations.js

@@ -0,0 +1,16 @@
+"use strict";
+// Side-effect imports populating the completion registry. Each
+// command's completion.ts pulls only metadata helpers + providers, not
+// the heavy command-object surface.
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../run/completion");
+require("../run-many/completion");
+require("../affected/completion");
+require("../show/completion");
+require("../generate/completion");
+require("../graph/completion");
+require("../watch/completion");
+require("../add/completion");
+// Must be last — infix-targets skips any name already registered above
+// so a real Nx command (`run`, `add`, ...) wins over a same-named target.
+require("./infix-targets");

package/dist/src/command-line/completion/scripts/bash.sh

@@ -0,0 +1,51 @@
+###-begin-nx-completions-###
+#
+# nx command completion script
+#
+# Installation: nx completion bash >> ~/.bashrc
+#    or: nx completion bash >> ~/.bash_profile
+#
+_nx_completions()
+{
+    local cur_word args type_list nx_cmd dir
+
+    cur_word="${COMP_WORDS[COMP_CWORD]}"
+    args=("${COMP_WORDS[@]}")
+
+    # Walk up for a workspace-local nx; fall back to PATH outside a workspace.
+    nx_cmd="nx"
+    dir="$PWD"
+    while [ "$dir" != "/" ]; do
+      if [ -x "$dir/node_modules/.bin/nx" ]; then
+        nx_cmd="$dir/node_modules/.bin/nx"
+        break
+      fi
+      if [ -x "$dir/.nx/installation/node_modules/.bin/nx" ]; then
+        nx_cmd="$dir/.nx/installation/node_modules/.bin/nx"
+        break
+      fi
+      dir="$(dirname "$dir")"
+    done
+
+    # Hide stderr so stray warnings don't land in the buffer; NX_VERBOSE_LOGGING surfaces it.
+    if [ -n "$NX_VERBOSE_LOGGING" ]; then
+      type_list=$(NX_COMPLETE=bash "$nx_cmd" "${args[@]}")
+    else
+      type_list=$(NX_COMPLETE=bash "$nx_cmd" "${args[@]}" 2>/dev/null)
+    fi
+
+    COMPREPLY=( $(compgen -W "${type_list}" -- ${cur_word}) )
+
+    # Trailing ':' (project:target stage 1) — nospace so the user can TAB again.
+    if [ ${#COMPREPLY[@]} -eq 1 ] && [[ "${COMPREPLY[0]}" == *: ]]; then
+      compopt -o nospace 2>/dev/null
+    fi
+
+    if [ ${#COMPREPLY[@]} -eq 0 ]; then
+      COMPREPLY=()
+    fi
+
+    return 0
+}
+complete -o default -F _nx_completions nx
+###-end-nx-completions-###

package/dist/src/command-line/completion/scripts/fish.fish

@@ -0,0 +1,47 @@
+###-begin-nx-completions-###
+#
+# nx command completion script for fish
+#
+# Installation:
+#   mkdir -p ~/.config/fish/completions
+#   nx completion fish > ~/.config/fish/completions/nx.fish
+#
+complete -e -c nx
+
+function __nx_completions
+  set -l tokens (commandline -cop)
+  set -l current (commandline -ct)
+  # Walk up for a workspace-local nx; fall back to PATH outside a workspace.
+  set -l nx_cmd nx
+  set -l dir $PWD
+  while test "$dir" != "/"
+    if test -x "$dir/node_modules/.bin/nx"
+      set nx_cmd "$dir/node_modules/.bin/nx"
+      break
+    end
+    if test -x "$dir/.nx/installation/node_modules/.bin/nx"
+      set nx_cmd "$dir/.nx/installation/node_modules/.bin/nx"
+      break
+    end
+    set dir (dirname "$dir")
+  end
+  # Hide stderr so stray warnings don't land in the buffer; NX_VERBOSE_LOGGING surfaces it.
+  set -l output
+  if test -n "$NX_VERBOSE_LOGGING"
+    set output (NX_COMPLETE=fish $nx_cmd $tokens "$current")
+  else
+    set output (NX_COMPLETE=fish $nx_cmd $tokens "$current" 2>/dev/null)
+  end
+  if test (count $output) -gt 0
+    printf '%s\n' $output
+    return
+  end
+  # No nx completion — fall back to filename completion. `-f` on the
+  # `complete` declaration blocks fish's BUILT-IN file offering, but
+  # fish exposes __fish_complete_path for callers that want the same
+  # behaviour (trailing '/' on dirs, ~ expansion, hidden-file handling,
+  # fish_complete_path config) from inside a function.
+  __fish_complete_path $current
+end
+complete -c nx -f -a '(__nx_completions)'
+###-end-nx-completions-###

package/dist/src/command-line/completion/scripts/powershell.ps1

@@ -0,0 +1,52 @@
+###-begin-nx-completions-###
+#
+# nx command completion script for PowerShell
+#
+# Installation: nx completion powershell | Out-File -Append $PROFILE
+#
+Register-ArgumentCompleter -Native -CommandName nx -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $tokens = @($commandAst.CommandElements | ForEach-Object { $_.Extent.Text })
+    # Match POSIX wrappers' '[...tokens, currentPartial]' layout.
+    if ($cursorPosition -gt $commandAst.Extent.EndOffset) {
+        $tokens += ''
+    }
+
+    # Walk up for a workspace-local nx.cmd; fall back to PATH outside a workspace.
+    $nxCmd = 'nx'
+    $dir = $PWD.Path
+    while ($dir) {
+        $standard = Join-Path $dir 'node_modules\.bin\nx.cmd'
+        $nxStyle = Join-Path $dir '.nx\installation\node_modules\.bin\nx.cmd'
+        if (Test-Path -LiteralPath $standard) { $nxCmd = $standard; break }
+        if (Test-Path -LiteralPath $nxStyle) { $nxCmd = $nxStyle; break }
+        $parent = Split-Path -Parent $dir
+        if ($parent -eq $dir) { break }
+        $dir = $parent
+    }
+
+    $env:NX_COMPLETE = 'powershell'
+    # Windows PowerShell 5.1 turns native-command stderr into terminating
+    # ErrorRecords when the caller's $ErrorActionPreference is 'Stop', so
+    # `2>$null` raises before it can suppress. Force 'Continue' locally —
+    # the param has function scope and resets on return.
+    $ErrorActionPreference = 'Continue'
+    try {
+        # Hide stderr so stray warnings don't land in the buffer; NX_VERBOSE_LOGGING surfaces it.
+        if ($env:NX_VERBOSE_LOGGING) {
+            $lines = & $nxCmd @tokens
+        } else {
+            $lines = & $nxCmd @tokens 2>$null
+        }
+        # PowerShell appends a space after each completion — no per-result nospace API.
+        # Skip blank lines: PS 5.1's CompletionResult ctor throws on empty completionText.
+        foreach ($line in $lines) {
+            if ([string]::IsNullOrEmpty($line)) { continue }
+            [System.Management.Automation.CompletionResult]::new($line)
+        }
+    } finally {
+        Remove-Item Env:NX_COMPLETE -ErrorAction SilentlyContinue
+    }
+}
+###-end-nx-completions-###