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

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

@@ -0,0 +1,69 @@
+###-begin-nx-completions-###
+#
+# nx command completion script
+#
+# Installation: nx completion zsh >> ~/.zshrc
+#    or: nx completion zsh > /usr/local/share/zsh/site-functions/_nx
+#
+if type compdef &>/dev/null; then
+  _nx_completions () {
+    local reply nx_cmd dir
+    local si=$IFS
+
+    # 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="${dir:h}"
+    done
+
+    # Hide stderr so stray warnings don't land in the buffer; NX_VERBOSE_LOGGING surfaces it.
+    if [[ -n "$NX_VERBOSE_LOGGING" ]]; then
+      IFS=$'\n' reply=($(NX_COMPLETE=zsh "$nx_cmd" "${words[@]}"))
+    else
+      IFS=$'\n' reply=($(NX_COMPLETE=zsh "$nx_cmd" "${words[@]}" 2>/dev/null))
+    fi
+    IFS=$si
+
+    # Split `value\tdescription` into parallel arrays for compadd -d. Don't
+    # use _describe: it splits on ':', mangling values like `my-app:build`.
+    local -a values displays
+    local r value nospace=0
+    for r in $reply; do
+      value="${r%%$'\t'*}"
+      values+=("$value")
+      if [[ "$r" == *$'\t'* ]]; then
+        displays+=("$value -- ${r#*$'\t'}")
+      else
+        displays+=("$value")
+      fi
+      [[ "$value" == *: ]] && nospace=1  # trailing ':' → nospace
+    done
+
+    if (( ${#values} == 0 )); then
+      # Nothing to suggest — fall back to filename completion (covers
+      # `nx g app --directory <TAB>` and similar unknown-flag values).
+      _files
+      return
+    fi
+    if (( nospace )); then
+      compadd -S '' -d displays -a values
+    else
+      compadd -d displays -a values
+    fi
+  }
+  compdef _nx_completions nx
+else
+  echo "nx: shell completion requires zsh's completion system to be loaded." >&2
+  echo "    Add the following line to your ~/.zshrc above this block:" >&2
+  echo "        autoload -U compinit && compinit" >&2
+fi
+###-end-nx-completions-###

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

@@ -0,0 +1,18 @@
+export type Shell = 'bash' | 'zsh' | 'fish' | 'powershell';
+export declare const SHELLS: readonly Shell[];
+/** Print the raw wrapper script to stdout — for scripting / custom rc paths. */
+export declare function printCompletionScript(shell: Shell): void;
+/**
+ * Write the wrapper to the shell's default rc location, replacing any prior
+ * nx-completion block (idempotent via the begin/end markers). Logs the
+ * resolved path and a one-line "open a new shell" hint.
+ */
+export declare function installCompletionScript(shell: Shell): void;
+/**
+ * Stderr advisory when `nx` is not on PATH — the wrappers walk up for a
+ * workspace-local nx, but the outside-workspace fallback needs `nx`
+ * reachable by name. Callers fire this ONCE per invocation even when
+ * installing for multiple shells.
+ */
+export declare function maybeWarnNxNotOnPath(): void;
+export declare function generateScript(shell: Shell): string;

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHELLS = void 0;
+exports.printCompletionScript = printCompletionScript;
+exports.installCompletionScript = installCompletionScript;
+exports.maybeWarnNxNotOnPath = maybeWarnNxNotOnPath;
+exports.generateScript = generateScript;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+exports.SHELLS = ['bash', 'zsh', 'fish', 'powershell'];
+/** Print the raw wrapper script to stdout — for scripting / custom rc paths. */
+function printCompletionScript(shell) {
+    process.stdout.write(generateScript(shell));
+}
+/**
+ * Write the wrapper to the shell's default rc location, replacing any prior
+ * nx-completion block (idempotent via the begin/end markers). Logs the
+ * resolved path and a one-line "open a new shell" hint.
+ */
+function installCompletionScript(shell) {
+    writeScriptToRcFile(shell);
+}
+/**
+ * Stderr advisory when `nx` is not on PATH — the wrappers walk up for a
+ * workspace-local nx, but the outside-workspace fallback needs `nx`
+ * reachable by name. Callers fire this ONCE per invocation even when
+ * installing for multiple shells.
+ */
+function maybeWarnNxNotOnPath() {
+    if (isNxOnPath())
+        return;
+    console.warn([
+        `nx: \`nx\` is not on your PATH.`,
+        `    The generated wrappers resolve a workspace-local nx when you`,
+        `    tab-complete inside a project, but outside any workspace they`,
+        `    fall back to a bare \`nx\`. Install nx globally so completion`,
+        `    works everywhere (e.g. \`pnpm add -g nx\` or \`npm i -g nx\`).`,
+        `    Continuing — pass --force to skip this notice.`,
+    ].join('\n'));
+}
+function writeScriptToRcFile(shell) {
+    const script = generateScript(shell);
+    const paths = installPathsFor(shell);
+    if (paths.length === 0) {
+        console.warn(`nx: automatic install isn't supported for ${shell} yet — run with --stdout and redirect manually.`);
+        return;
+    }
+    for (const path of paths) {
+        writeOneRcFile(shell, path, script);
+    }
+}
+function writeOneRcFile(shell, path, script) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(path), { recursive: true });
+    // Fish keeps each completion in its own file (a full overwrite is correct).
+    // bash/zsh/powershell append to a shared rc file: skip if an nx-completion
+    // block is already present so re-runs are no-ops, and never modify
+    // existing content — the user may have customized around the block.
+    if (shell === 'fish') {
+        (0, fs_1.writeFileSync)(path, script);
+    }
+    else {
+        const existing = (0, fs_1.existsSync)(path) ? (0, fs_1.readFileSync)(path, 'utf8') : '';
+        if (existing.includes('###-begin-nx-completions-###')) {
+            console.warn(`nx: ${shell} completion already present in ${path} — skipping.\n` +
+                `    Remove the existing block manually if you need to reinstall.`);
+            return;
+        }
+        const sep = existing && !existing.endsWith('\n') ? '\n' : '';
+        (0, fs_1.writeFileSync)(path, existing + sep + script);
+    }
+    console.warn(`nx: ${shell} completion installed at ${path}.\n` +
+        `    Open a new shell (or re-source the rc file) to activate.`);
+}
+function installPathsFor(shell) {
+    const home = (0, os_1.homedir)();
+    switch (shell) {
+        case 'bash':
+            return [(0, path_1.join)(home, '.bashrc')];
+        case 'zsh':
+            return [(0, path_1.join)(home, '.zshrc')];
+        case 'fish':
+            return [(0, path_1.join)(home, '.config', 'fish', 'completions', 'nx.fish')];
+        case 'powershell':
+            return resolvePowerShellProfiles();
+    }
+}
+/**
+ * Shell out to each available PowerShell to expand $PROFILE. The variable's
+ * resolution depends on the PS version (5.1 vs 7), $PSVersionTable, and
+ * Windows Documents-folder redirection (OneDrive etc.), so asking PS itself
+ * is the only reliable way. Returns every distinct profile path we find —
+ * PS 5.1 and PS 7 keep separate profile files, so a user with both
+ * installed needs the wrapper written to both.
+ */
+function resolvePowerShellProfiles() {
+    const candidates = process.platform === 'win32' ? ['pwsh.exe', 'powershell.exe'] : ['pwsh'];
+    const paths = [];
+    for (const exe of candidates) {
+        const result = (0, child_process_1.spawnSync)(exe, ['-NoProfile', '-Command', '$PROFILE'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        if (result.status !== 0 || !result.stdout)
+            continue;
+        const path = result.stdout.trim();
+        if (path && !paths.includes(path))
+            paths.push(path);
+    }
+    return paths;
+}
+function isNxOnPath() {
+    const pathEnv = process.env.PATH;
+    if (!pathEnv)
+        return false;
+    const names = process.platform === 'win32' ? ['nx.cmd', 'nx.exe', 'nx'] : ['nx'];
+    for (const dir of pathEnv.split(path_1.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            if ((0, fs_1.existsSync)((0, path_1.join)(dir, name)))
+                return true;
+        }
+    }
+    return false;
+}
+// Wrappers live as plain files in ./scripts/ for syntax highlighting and
+// shellcheck. Read at call time — each invocation needs each shell's
+// wrapper at most once.
+const WRAPPER_FILES = {
+    bash: 'bash.sh',
+    zsh: 'zsh.zsh',
+    fish: 'fish.fish',
+    powershell: 'powershell.ps1',
+};
+function generateScript(shell) {
+    return (0, fs_1.readFileSync)((0, path_1.join)(__dirname, 'scripts', WRAPPER_FILES[shell]), 'utf-8');
+}

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

@@ -0,0 +1,3 @@
+export type CompletionShell = 'bash' | 'zsh' | 'fish' | 'powershell';
+export declare function isCompletionRequest(): boolean;
+export declare function getCompletionShell(): CompletionShell | null;

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

@@ -0,0 +1,21 @@
+"use strict";
+// Shell detection via NX_COMPLETE env var (set by the wrappers).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompletionRequest = isCompletionRequest;
+exports.getCompletionShell = getCompletionShell;
+const KNOWN_SHELLS = new Set([
+    'bash',
+    'zsh',
+    'fish',
+    'powershell',
+]);
+function isCompletionRequest() {
+    return Boolean(process.env.NX_COMPLETE);
+}
+function getCompletionShell() {
+    const raw = process.env.NX_COMPLETE;
+    if (raw && KNOWN_SHELLS.has(raw)) {
+        return raw;
+    }
+    return null;
+}

package/dist/src/command-line/completion/value-completions.d.ts

@@ -0,0 +1,3 @@
+import './registrations';
+/** Returns true if handled — caller should not fall through. */
+export declare function tryValueCompletion(argv?: readonly string[]): boolean;

package/dist/src/command-line/completion/value-completions.js

@@ -0,0 +1,21 @@
+"use strict";
+// Fast-path completion: project/target/generator/flag values, served from
+// registered metadata without loading the yargs command surface.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryValueCompletion = tryValueCompletion;
+require("./registrations");
+const metadata_1 = require("./metadata");
+const argv_layout_1 = require("./argv-layout");
+/** Returns true if handled — caller should not fall through. */
+function tryValueCompletion(argv = process.argv) {
+    const parsed = (0, argv_layout_1.parseCompletionArgs)(argv);
+    if (parsed === null)
+        return false;
+    const completions = (0, metadata_1.resolveCompletion)(parsed.tokens, parsed.current, parsed.previousToken);
+    if (completions === null)
+        return false;
+    for (const line of completions) {
+        console.log(line);
+    }
+    return true;
+}

package/dist/src/command-line/examples.js

@@ -378,7 +378,7 @@ exports.examples = {
             description: 'Watch the "app" project and echo the project name and the files that changed',
         },
         {
-            command: 'watch --projects=app1,app2 --includeDependentProjects -- echo \\$NX_PROJECT_NAME',
+            command: 'watch --projects=app1,app2 --includeDependencies -- echo \\$NX_PROJECT_NAME',
             description: 'Watch "app1" and "app2" and echo the project name whenever a specified project or its dependencies change',
         },
         {

package/dist/src/command-line/format/format.js

@@ -34,10 +34,15 @@ async function format(command, args) {
         process.exit(1);
     }
     const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', { printWarnings: false }, (0, configuration_1.readNxJson)());
-    const patterns = (await getPatterns(prettier, { ...args, ...nxArgs })).map(
-    // prettier removes one of the \
-    // prettier-ignore
-    (p) => `"${p.replace(/\$/g, '\\\$')}"`);
+    const patterns = (await getPatterns(prettier, { ...args, ...nxArgs })).map((p) => {
+        // On non-Windows, escape $ to prevent shell variable interpolation
+        // (the shell consumes one \, so \\$ becomes \$ which the shell treats as literal $)
+        // On Windows (cmd.exe), $ is not a special character, so escaping it would
+        // cause prettier to look for a file with a literal \$ in the name
+        // prettier-ignore
+        const escaped = process.platform !== 'win32' ? p.replace(/\$/g, '\\\$') : p;
+        return `"${escaped}"`;
+    });
     // Chunkify the patterns array to prevent crashing the windows terminal
     const chunkList = (0, chunkify_1.chunkify)(patterns);
     switch (command) {
@@ -204,7 +209,12 @@ function getPrettierPath() {
         return prettierPath;
     }
     const { packageJson, path: packageJsonPath } = (0, package_json_1.readModulePackageJson)('prettier');
-    prettierPath = path.resolve(path.dirname(packageJsonPath), packageJson.bin);
+    const bin = packageJson.bin;
+    const binPath = typeof bin === 'string' ? bin : bin?.['prettier'];
+    if (!binPath) {
+        throw new Error(`Could not find prettier binary in ${packageJsonPath}`);
+    }
+    prettierPath = path.resolve(path.dirname(packageJsonPath), binPath);
     return prettierPath;
 }
 let useListDifferent;

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = require("../completion/metadata");
+const completion_providers_1 = require("../completion/completion-providers");
+const generateCompletion = {
+    positionals: [{ complete: completion_providers_1.completeGenerator }],
+};
+(0, metadata_1.registerCompletion)('generate', generateCompletion);
+(0, metadata_1.registerCompletion)('g', generateCompletion); // alias

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

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = require("../completion/metadata");
+const completion_providers_1 = require("../completion/completion-providers");
+(0, metadata_1.registerCompletion)('graph', {
+    flags: {
+        focus: completion_providers_1.getProjectNameCompletions,
+        exclude: completion_providers_1.getProjectNameCompletions,
+        targets: completion_providers_1.getTargetNameCompletions,
+        target: completion_providers_1.getTargetNameCompletions,
+        t: completion_providers_1.getTargetNameCompletions,
+    },
+});

package/dist/src/command-line/init/implementation/angular/standalone-workspace.js

@@ -54,29 +54,26 @@ function createNxJson(repoRoot, angularJson, cacheableOperations, { eslintProjec
                 : []),
         ].filter(Boolean),
     };
-    nxJson.targetDefaults ??= {};
+    const defaults = Array.isArray(nxJson.targetDefaults)
+        ? [...nxJson.targetDefaults]
+        : [];
     if (workspaceTargets.includes('build')) {
-        nxJson.targetDefaults.build = {
-            ...nxJson.targetDefaults.build,
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'build', {
             dependsOn: ['^build'],
             inputs: ['production', '^production'],
-        };
+        });
     }
     if (workspaceTargets.includes('server')) {
-        nxJson.targetDefaults.server = {
-            ...nxJson.targetDefaults.server,
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'server', {
             inputs: ['production', '^production'],
-        };
+        });
     }
     if (workspaceTargets.includes('test')) {
         const inputs = ['default', '^production'];
         if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, 'karma.conf.js'))) {
             inputs.push('{workspaceRoot}/karma.conf.js');
         }
-        nxJson.targetDefaults.test = {
-            ...nxJson.targetDefaults.test,
-            inputs,
-        };
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'test', { inputs });
     }
     if (workspaceTargets.includes('lint')) {
         const inputs = ['default'];
@@ -86,16 +83,15 @@ function createNxJson(repoRoot, angularJson, cacheableOperations, { eslintProjec
         if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, 'eslint.config.cjs'))) {
             inputs.push('{workspaceRoot}/eslint.config.cjs');
         }
-        nxJson.targetDefaults.lint = {
-            ...nxJson.targetDefaults.lint,
-            inputs,
-        };
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'lint', { inputs });
     }
     if (workspaceTargets.includes('e2e')) {
-        nxJson.targetDefaults.e2e = {
-            ...nxJson.targetDefaults.e2e,
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'e2e', {
             inputs: ['default', '^production'],
-        };
+        });
+    }
+    if (defaults.length > 0) {
+        nxJson.targetDefaults = defaults;
     }
     (0, fileutils_1.writeJsonFile)((0, node_path_1.join)(repoRoot, 'nx.json'), nxJson);
 }

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

@@ -102,6 +102,7 @@ function updateGitIgnore(host) {
         '.nx/cache',
         '.nx/workspace-data',
         '.nx/self-healing',
+        '.nx/migrate-runs',
     ].forEach((file) => {
         if (!contents.includes(file)) {
             contents = [contents, file].join('\n');

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

@@ -1,9 +1,15 @@
-import { NxJsonConfiguration } from '../../../config/nx-json';
+import { NxJsonConfiguration, TargetDefaultEntry } 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;
+/**
+ * Locate-by-target upsert against an in-memory `targetDefaults` array.
+ * Used by `nx init` code paths that operate on raw JSON before a Tree
+ * exists — generators should use `upsertTargetDefault` from devkit instead.
+ */
+export declare function upsertTargetDefaultEntry(entries: TargetDefaultEntry[], target: string, patch: Partial<TargetDefaultEntry>): 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;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNxJsonFile = createNxJsonFile;
+exports.upsertTargetDefaultEntry = upsertTargetDefaultEntry;
 exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
 exports.addDepsToPackageJson = addDepsToPackageJson;
 exports.updateGitIgnore = updateGitIgnore;
@@ -34,27 +35,37 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     }
     catch { }
     nxJson.$schema = './node_modules/nx/schemas/nx-schema.json';
-    nxJson.targetDefaults ??= {};
+    const entries = Array.isArray(nxJson.targetDefaults)
+        ? [...nxJson.targetDefaults]
+        : [];
     if (topologicalTargets.length > 0) {
         for (const scriptName of topologicalTargets) {
-            nxJson.targetDefaults[scriptName] ??= {};
-            nxJson.targetDefaults[scriptName] = { dependsOn: [`^${scriptName}`] };
+            upsertTargetDefaultEntry(entries, scriptName, {
+                dependsOn: [`^${scriptName}`],
+            });
         }
     }
     for (const [scriptName, output] of Object.entries(scriptOutputs)) {
         if (!output) {
             continue;
         }
-        nxJson.targetDefaults[scriptName] ??= {};
-        nxJson.targetDefaults[scriptName].outputs = [`{projectRoot}/${output}`];
+        upsertTargetDefaultEntry(entries, scriptName, {
+            outputs: [`{projectRoot}/${output}`],
+        });
     }
     for (const target of cacheableOperations) {
-        nxJson.targetDefaults[target] ??= {};
-        nxJson.targetDefaults[target].cache ??= true;
+        const existing = findUnfilteredTargetEntry(entries, target);
+        if (existing)
+            existing.cache ??= true;
+        else
+            entries.push({ target, cache: true });
     }
-    if (Object.keys(nxJson.targetDefaults).length === 0) {
+    if (entries.length === 0) {
         delete nxJson.targetDefaults;
     }
+    else {
+        nxJson.targetDefaults = entries;
+    }
     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') {
@@ -62,6 +73,21 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     }
     (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
 }
+/**
+ * Locate-by-target upsert against an in-memory `targetDefaults` array.
+ * Used by `nx init` code paths that operate on raw JSON before a Tree
+ * exists — generators should use `upsertTargetDefault` from devkit instead.
+ */
+function upsertTargetDefaultEntry(entries, target, patch) {
+    const existing = findUnfilteredTargetEntry(entries, target);
+    if (existing)
+        Object.assign(existing, patch, { target });
+    else
+        entries.push({ ...patch, target });
+}
+function findUnfilteredTargetEntry(entries, target) {
+    return entries.find((e) => e.target === target && e.projects === undefined && e.plugin === undefined);
+}
 function createNxJsonFromTurboJson(turboJson) {
     const nxJson = {
         $schema: './node_modules/nx/schemas/nx-schema.json',
@@ -88,20 +114,20 @@ function createNxJsonFromTurboJson(turboJson) {
     }
     // Handle task configurations
     if (turboJson.tasks) {
-        nxJson.targetDefaults = {};
+        const entries = [];
         for (const [taskName, taskConfig] of Object.entries(turboJson.tasks)) {
             // Skip project-specific tasks (containing #)
             if (taskName.includes('#'))
                 continue;
             const config = taskConfig;
-            nxJson.targetDefaults[taskName] = {};
+            const entry = { target: taskName };
             // Handle dependsOn
             if (config.dependsOn?.length > 0) {
-                nxJson.targetDefaults[taskName].dependsOn = config.dependsOn;
+                entry.dependsOn = config.dependsOn;
             }
             // Handle inputs
             if (config.inputs?.length > 0) {
-                nxJson.targetDefaults[taskName].inputs = config.inputs
+                entry.inputs = config.inputs
                     .map((input) => {
                     if (input === '$TURBO_DEFAULT$') {
                         return '{projectRoot}/**/*';
@@ -124,7 +150,7 @@ function createNxJsonFromTurboJson(turboJson) {
             }
             // Handle outputs
             if (config.outputs?.length > 0) {
-                nxJson.targetDefaults[taskName].outputs = config.outputs.map((output) => {
+                entry.outputs = config.outputs.map((output) => {
                     // Don't add projectRoot if it's already there
                     if (output.startsWith('{projectRoot}/'))
                         return output;
@@ -136,7 +162,11 @@ function createNxJsonFromTurboJson(turboJson) {
                 });
             }
             // Handle cache setting - true by default in Turbo
-            nxJson.targetDefaults[taskName].cache = config.cache !== false;
+            entry.cache = config.cache !== false;
+            entries.push(entry);
+        }
+        if (entries.length > 0) {
+            nxJson.targetDefaults = entries;
         }
     }
     /**
@@ -187,6 +217,13 @@ function updateGitIgnore(root) {
             }
             lines.push('.nx/workspace-data');
         }
+        if (!contents.includes('.nx/migrate-runs')) {
+            if (!sepIncluded) {
+                lines.push('\n');
+                sepIncluded = true;
+            }
+            lines.push('.nx/migrate-runs');
+        }
         (0, fs_1.writeFileSync)(ignorePath, lines.join('\n'), 'utf-8');
     }
     catch { }

package/dist/src/command-line/migrate/agentic/capture-generator-output.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Tees `console.{log,warn,error,info,debug}` into an internal buffer while
+ * preserving the original behavior. Does not intercept
+ * `process.{stdout,stderr}.write` — those bypass `console` and would also
+ * pick up unrelated framework output. Restoration is idempotent.
+ */
+export interface GeneratorOutputCapture {
+    flush(): string;
+    restore(): void;
+}
+export declare function installGeneratorOutputCapture(): GeneratorOutputCapture;
+/**
+ * Convenience wrapper that installs the capture, runs `fn`, restores on
+ * completion or throw, and returns the captured logs alongside `fn`'s value.
+ * Throws from `fn` propagate with the captured logs attached as
+ * `(err as any).capturedLogs` — the most useful diagnostic when a generator
+ * crashes mid-output.
+ */
+export declare function withGeneratorOutputCapture<T>(fn: () => Promise<T> | T): Promise<{
+    result: T;
+    logs: string;
+}>;