nx 24.0.0-beta.1 → 24.0.0-beta.2

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

@@ -967,7 +967,8 @@ function expandInputs(inputs, project, allWorkspaceFiles, depGraphClientResponse
         }
     });
     const workspaceRootsExpanded = getExpandedWorkspaceRoots(workspaceRootInputs, allWorkspaceFiles);
-    const filesExpanded = filesInputs.flatMap((globs) => (0, native_1.expandFilesInput)(workspace_root_1.workspaceRoot, globs));
+    const projectRoots = depGraphClientResponse.projects.map((p) => p.data.root);
+    const filesExpanded = filesInputs.flatMap((globs) => (0, native_1.expandFilesInput)(workspace_root_1.workspaceRoot, globs, projectRoots));
     const otherInputsExpanded = otherInputs.map((input) => {
         if (input === 'TsConfig') {
             return (0, node_path_1.relative)(workspace_root_1.workspaceRoot, (0, typescript_1.getRootTsConfigPath)());

package/dist/src/command-line/migrate/agentic/handoff-gitignore.d.ts

@@ -3,26 +3,23 @@
  * `.nx/migrate-runs/<run-id>/`: handoff and prompt files in both cases, plus
  * the durable run state and its plan snapshots for the orchestrator. The v23
  * migration `23-0-0-add-migrate-runs-to-git-ignore` adds `.nx/migrate-runs` to
- * `.gitignore`; in its declared slot (typically late) earlier per-migration
- * commits would absorb the scratch into the user-visible diff.
+ * `.gitignore`, but the scratch exists before that migration runs, so earlier
+ * commits would absorb it into the user-visible diff. Its two callers use this
+ * function to add the entry before that can happen:
  *
- * Two paths cover the leak, with no overlap:
+ *   1. Orchestrator init calls it with `applyWhenPlanned` and no standalone
+ *      commit, before it creates the run dir. Its checkpoint commit carries the
+ *      edit when commits are on and the checkpoint succeeds. A planned v23
+ *      migration then changes nothing in its own step.
  *
- *   1. HOIST: `sortMigrations`, which `executeMigrations` applies, sorts the
- *      v23 migration to position 0 when it is in the queue, so it runs first
- *      through the normal runner with its own log line and commit. A
- *      single-migration worker run needs no hoisting: the requested migration
- *      is the entire queue.
+ *   2. A single-migration worker run with an agent defers to the requested
+ *      migration when it is the v23 one. Otherwise, below v23, it applies the
+ *      entry and commits it as a standalone preflight commit (or leaves it in
+ *      the working tree under `--no-create-commits`).
  *
- *   2. INLINE FALLBACK, this function. When the migration is NOT in the queue
- *      AND the highest target version is < v23 (intra-pre-v23 `--agentic`
- *      run) it will never run, so apply its body inline against an `FsTree`
- *      and commit it as a standalone preflight commit (or leave it in the
- *      working tree under `--no-create-commits`).
- *
- * Not in the queue AND target >= v23 means the user is already past v23. They
- * had the entry historically; if it is gone, that is a conscious removal we
- * respect.
+ * When the v23 migration is not planned and nx is at v23 or later, the user is
+ * already past v23. They had the entry historically; if it is gone, that is a
+ * conscious removal we respect.
  */
 export declare function applyAgenticHandoffGitignoreFallback({ migrations, installedNxVersion, effectiveCreateCommits, commitPrefix, root, applyWhenPlanned, commitStandalone, }: {
     migrations: ReadonlyArray<{
@@ -41,12 +38,11 @@ export declare function applyAgenticHandoffGitignoreFallback({ migrations, insta
     commitPrefix: string;
     root: string;
     /**
-     * Apply the entry even when the hoisted migration is in the plan. The
-     * classic loop can defer to that migration because its run scratch appears
-     * only after migration 1 has run; the orchestrator creates its run dir at
-     * init, before any migration, so it needs the entry immediately. A planned
-     * migration also means the missing entry is not a conscious removal, so the
-     * v23 cutoff does not apply.
+     * Apply the entry even when the v23 migration is in the plan. The
+     * orchestrator creates its run dir at init, before any migration runs, so
+     * it can't defer to that migration. A planned migration also means the
+     * missing entry is not a conscious removal, so the v23 cutoff does not
+     * apply.
      */
     applyWhenPlanned?: boolean;
     /**

package/dist/src/command-line/migrate/agentic/handoff-gitignore.js

@@ -14,32 +14,29 @@ const types_1 = require("./types");
  * `.nx/migrate-runs/<run-id>/`: handoff and prompt files in both cases, plus
  * the durable run state and its plan snapshots for the orchestrator. The v23
  * migration `23-0-0-add-migrate-runs-to-git-ignore` adds `.nx/migrate-runs` to
- * `.gitignore`; in its declared slot (typically late) earlier per-migration
- * commits would absorb the scratch into the user-visible diff.
+ * `.gitignore`, but the scratch exists before that migration runs, so earlier
+ * commits would absorb it into the user-visible diff. Its two callers use this
+ * function to add the entry before that can happen:
  *
- * Two paths cover the leak, with no overlap:
+ *   1. Orchestrator init calls it with `applyWhenPlanned` and no standalone
+ *      commit, before it creates the run dir. Its checkpoint commit carries the
+ *      edit when commits are on and the checkpoint succeeds. A planned v23
+ *      migration then changes nothing in its own step.
  *
- *   1. HOIST: `sortMigrations`, which `executeMigrations` applies, sorts the
- *      v23 migration to position 0 when it is in the queue, so it runs first
- *      through the normal runner with its own log line and commit. A
- *      single-migration worker run needs no hoisting: the requested migration
- *      is the entire queue.
+ *   2. A single-migration worker run with an agent defers to the requested
+ *      migration when it is the v23 one. Otherwise, below v23, it applies the
+ *      entry and commits it as a standalone preflight commit (or leaves it in
+ *      the working tree under `--no-create-commits`).
  *
- *   2. INLINE FALLBACK, this function. When the migration is NOT in the queue
- *      AND the highest target version is < v23 (intra-pre-v23 `--agentic`
- *      run) it will never run, so apply its body inline against an `FsTree`
- *      and commit it as a standalone preflight commit (or leave it in the
- *      working tree under `--no-create-commits`).
- *
- * Not in the queue AND target >= v23 means the user is already past v23. They
- * had the entry historically; if it is gone, that is a conscious removal we
- * respect.
+ * When the v23 migration is not planned and nx is at v23 or later, the user is
+ * already past v23. They had the entry historically; if it is gone, that is a
+ * conscious removal we respect.
  */
 async function applyAgenticHandoffGitignoreFallback({ migrations, installedNxVersion, effectiveCreateCommits, commitPrefix, root, applyWhenPlanned = false, commitStandalone = true, }) {
     if (migrations.some(types_1.isHandoffGitignoreMigration)) {
         if (!applyWhenPlanned) {
-            // The queue runs it itself: hoisted to the front by the sort comparator
-            // in a full run, or as the single requested migration in a worker run.
+            // The single-migration worker run is that migration, and it adds the
+            // entry itself.
             return;
         }
     }

package/dist/src/command-line/migrate/agentic/master/run-master-session.js

@@ -21,20 +21,29 @@ async function runMasterSession(input) {
         createCommits: init.createCommits,
         skipInstall: init.skipInstall,
     };
-    const resume = (runId) => (0, run_1.runOrchestratorResume)({
-        root: init.root,
-        runId,
-        policy,
-        emitAgentInstructions: false,
-    });
+    // A resume refuses when it cannot restore the run's missing runbook; a
+    // start refuses when the default-branch commit confirmation is declined.
+    let refusal = 'declined_commits';
+    const resume = (runId) => {
+        refusal = 'runbook_missing';
+        return (0, run_1.runOrchestratorResume)({
+            root: init.root,
+            runId,
+            policy,
+            emitAgentInstructions: false,
+        });
+    };
     // With `replaceRunId`, starts fresh over that run only; the consent covers
     // the run the user saw, and any other active run is reported instead.
-    const start = (replaceRunId) => (0, run_1.runOrchestratorInit)({
-        ...init,
-        emitAgentInstructions: false,
-        onExistingRun: replaceRunId === undefined ? 'report' : 'start-fresh',
-        replaceRunId,
-    });
+    const start = (replaceRunId) => {
+        refusal = 'declined_commits';
+        return (0, run_1.runOrchestratorInit)({
+            ...init,
+            emitAgentInstructions: false,
+            onExistingRun: replaceRunId === undefined ? 'report' : 'start-fresh',
+            replaceRunId,
+        });
+    };
     let ready = requestedRunId !== undefined && !startFresh
         ? resume(requestedRunId)
         : await start(startFresh ? requestedRunId : undefined);
@@ -44,6 +53,7 @@ async function runMasterSession(input) {
             output_1.output.log({
                 title: `Leaving migrate run ${ready.runId} as it is. ${continueHint(init.root, agent.id, ready.runId, ready.facts.policy)}`,
             });
+            (0, migrate_analytics_1.reportMigrateRunStopped)('aborted');
             return;
         }
         if (decision === 'continue') {
@@ -56,9 +66,11 @@ async function runMasterSession(input) {
     }
     if (ready.kind === 'existing-run') {
         output_1.output.warn((0, run_1.renderExistingRunReport)(ready.facts, (0, run_1.renderExistingRunCommands)(init.root, ready.facts, init.migrationsPath, agent.id)));
+        (0, migrate_analytics_1.reportMigrateRunStopped)('existing_run');
         return 1;
     }
     if (ready.kind === 'refused') {
+        (0, migrate_analytics_1.reportMigrateRunStopped)(refusal);
         return;
     }
     const { runId, runRoot, runbookPath, reconcileCommand } = ready;
@@ -145,7 +157,7 @@ async function runMasterSession(input) {
     }
 }
 function continueHint(root, agentId, runId, policy) {
-    return `Run ${(0, run_1.renderContinueCommand)(root, runId, policy, agentId)}, with NX_MIGRATE_ORCHESTRATOR=true set in the environment, to continue it.`;
+    return `Run ${(0, run_1.renderContinueCommand)(root, runId, policy, agentId)} to continue it.`;
 }
 async function decideExistingRun(found, root) {
     output_1.output.log((0, run_1.renderExistingRunReport)(found.facts));

package/dist/src/command-line/migrate/agentic/master/spawn-master.js

@@ -22,16 +22,15 @@ const OPERATION_KILL_WAIT_MS = 2_000;
 // SIGINTs this close together are one Ctrl+C: `npx` and the package managers
 // pass on to nx the SIGINT the terminal already sent it.
 const SAME_PRESS_MS = 500;
-// The wrapper's local re-exec sets the first two for its own hop and the user
-// sets the third to reach this path; inherited, they would change install or
-// routing behavior for every `nx migrate` the agent runs. CI exports the last
-// two for its own `nx affected` runs; inherited, they would replace the base
-// the run names and drop uncommitted files from the pass's selection. The
-// workspace's env files can still set them: every nx command loads those.
+// The wrapper's local re-exec sets the first two for its own hop; inherited,
+// they would change install or routing behavior for every `nx migrate` the
+// agent runs. CI exports the last two for its own `nx affected` runs;
+// inherited, they would replace the base the run names and drop uncommitted
+// files from the pass's selection. The workspace's env files can still set
+// them: every nx command loads those.
 const STRIPPED_ENV_VARS = [
     'NX_MIGRATE_SKIP_INSTALL',
     'NX_MIGRATE_USE_LOCAL',
-    'NX_MIGRATE_ORCHESTRATOR',
     'NX_BASE',
     'NX_HEAD',
 ];

package/dist/src/command-line/migrate/agentic/select.js

@@ -97,7 +97,7 @@ function requireInteractiveOrAbort(isInteractive) {
     if (isInteractive)
         return;
     output_1.output.error({
-        title: 'The agentic flow is interactive-only in this release.',
+        title: 'The agentic flow needs an interactive terminal.',
         bodyLines: [
             'Re-run in an interactive terminal, or pass `--agentic=false` to skip the agentic flow.',
         ],
@@ -106,9 +106,9 @@ function requireInteractiveOrAbort(isInteractive) {
 }
 function warnAgenticInteractiveOnly() {
     output_1.output.warn({
-        title: 'Skipping the agentic flow: it is interactive-only in this release and this run is non-interactive.',
+        title: 'Skipping the agentic flow: the agent session needs an interactive terminal, and this run is non-interactive.',
         bodyLines: [
-            'Continuing the migration without the agentic flow. Re-run in an interactive terminal to use it.',
+            'Continuing without the agentic flow. Generators still run, prompt-based changes are left for you to apply, and no AI validation runs. Re-run in an interactive terminal to use the agentic flow.',
         ],
     });
 }

package/dist/src/command-line/migrate/agentic/types.js

@@ -28,9 +28,7 @@ exports.PROMPTS_DIR_NAME = 'prompts';
  * `.gitignore`. Hard-coded because the agentic preflight is a deliberate
  * one-off coupling: this exact migration owns the entry that keeps
  * `.nx/migrate-runs/<run-id>/...` scratch out of per-migration commits. If
- * the migration is ever renamed, this entry must move with it. It lives here
- * rather than in `handoff-gitignore.ts` so `sortMigrations`' hoist check
- * doesn't load that module's migration-execution machinery.
+ * the migration is ever renamed, this entry must move with it.
  */
 const HANDOFF_GITIGNORE_MIGRATION_PACKAGE = 'nx';
 const HANDOFF_GITIGNORE_MIGRATION_NAME = '23-0-0-add-migrate-runs-to-git-ignore';

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

@@ -59,10 +59,8 @@ function withMigrationOptions(yargs) {
         type: 'string',
     })
         .option('runId', {
-        // Hidden with the orchestrator itself.
-        describe: 'The orchestrated migrate run to record a single migration into, to continue with --run-migrations, or to reconcile when given alone.',
+        describe: "The id of a migrate run, as nx prints it. With --run-migrations: continue that run, or replace it with --start-fresh. The AI agent driving a run also passes it with --run-migration to record a migration into the run, and alone to record a step's outcome and get the next step.",
         type: 'string',
-        hidden: true,
     })
         .option('stepAction', {
         describe: 'How an orchestrated reconcile resolves its single failed or died step.',
@@ -71,9 +69,8 @@ function withMigrationOptions(yargs) {
         hidden: true,
     })
         .option('startFresh', {
-        describe: 'With --run-migrations and --run-id=<id> under the orchestrator: delete the record of the active migrate run the id names and start a new run over the whole plan. Migrations the deleted run applied stay applied.',
+        describe: 'With --run-migrations and --run-id=<id>: delete the record of the active migrate run the id names, then run the whole plan again, as a new run when orchestrated. Migrations the deleted run applied stay applied.',
         type: 'boolean',
-        hidden: true,
     })
         .option('ifExists', {
         describe: `Run migrations only if the migrations file exists, if not continues successfully.`,
@@ -123,17 +120,16 @@ function withMigrationOptions(yargs) {
         choices: exports.MULTI_MAJOR_MODES,
     })
         .option('agentic', {
-        describe: 'Enable the agentic flow for prompt-based migrations and AI-driven review. Pass `--agentic=<agent>` to pin a specific agent (claude-code, codex, or opencode). Pass `--agentic=false` or `--no-agentic` to disable.',
+        describe: 'Use an AI agent to apply prompt-based migrations and review the results. With --run-migrations, one agent session drives the whole run. Pass `--agentic=<agent>` to pin a specific agent (claude-code, codex, or opencode). Pass `--agentic=false` or `--no-agentic` to disable it, including when nx migrate runs inside an AI agent.',
         coerce: cli_args_1.coerceAgenticArg,
     })
         .option('validate', {
-        describe: 'When `--agentic` resolves to an enabled agent, run agent-driven validation after generator-only migrations that have no `prompt:` field. Defaults to on; pass `--no-validate` to opt out. Has no effect when `--agentic` is disabled, when running inside an outer agent, or when running non-interactively without an explicit agent.',
+        describe: 'Have the AI agent driving the run review the changes of generator-only migrations (those with no `prompt:` field). On by default; pass `--no-validate` to opt out. A continued run keeps the setting it started with. Has no effect when no agent drives the run, or with --run-migration inside an AI agent.',
         type: 'boolean',
     })
         .option('finalValidation', {
-        describe: 'With --run-migrations under the orchestrator: end the run with an agent validation pass over the whole workspace once every migration has run. On by default; pass --no-final-validation to opt out.',
+        describe: 'With --run-migrations, when an AI agent drives the run: once every migration has run, the agent checks that the projects the run touched still lint, build, and pass their unit tests. On by default; pass --no-final-validation to opt out. A continued run keeps the setting it started with.',
         type: 'boolean',
-        hidden: true,
     })
         .check(({ createCommits, commitPrefix, from, excludeAppliedMigrations, include, agentic, }) => {
         // Only an explicit `--no-create-commits` is decidable here, before the

package/dist/src/command-line/migrate/migrate-analytics.d.ts

@@ -18,6 +18,7 @@ export type MigratePromptChoices = {
 export type MigratePromptName = keyof MigratePromptChoices;
 export type MigrateGenerateErrorCode = 'resolve_version' | 'fetch_migrations' | 'package_updates';
 export type MigrateRunErrorCode = 'npm_install' | 'migration_exec' | 'agentic' | 'other';
+export type MigrateRunStopReason = 'existing_run' | 'declined_commits' | 'aborted' | 'runbook_missing';
 export declare function setMigrateInclude(include: MigrateInclude): void;
 export declare function setMigrateIncludeSource(source: MigrateIncludeSource): void;
 export declare function classifyMigrateFetchFallback(error: unknown): MigrateFetchFallbackReason;
@@ -60,6 +61,11 @@ export declare function reportMigrateRunComplete(opts: {
     migrationCount: number;
     appliedCount: number;
 }): void;
+/**
+ * Closes a `migrate_run_start` whose invocation stopped before running any
+ * migration.
+ */
+export declare function reportMigrateRunStopped(reason: MigrateRunStopReason): void;
 export declare function reportMigrateRunError(opts: {
     code: MigrateRunErrorCode;
     migrationPackage?: string;

package/dist/src/command-line/migrate/migrate-analytics.js

@@ -10,6 +10,7 @@ exports.reportMigrateGenerateError = reportMigrateGenerateError;
 exports.reportMigrateRunStart = reportMigrateRunStart;
 exports.hasMigrateRunStarted = hasMigrateRunStarted;
 exports.reportMigrateRunComplete = reportMigrateRunComplete;
+exports.reportMigrateRunStopped = reportMigrateRunStopped;
 exports.reportMigrateRunError = reportMigrateRunError;
 exports.reportMigrateOrchestratorInit = reportMigrateOrchestratorInit;
 exports.reportMigrateOrchestratorDispense = reportMigrateOrchestratorDispense;
@@ -165,6 +166,17 @@ function reportMigrateRunComplete(opts) {
         });
     });
 }
+/**
+ * Closes a `migrate_run_start` whose invocation stopped before running any
+ * migration.
+ */
+function reportMigrateRunStopped(reason) {
+    safeReport(() => {
+        if (!analytics_1.customDimensions)
+            return;
+        (0, analytics_1.reportEvent)(`migrate_run_stopped_${reason}`);
+    });
+}
 function reportMigrateRunError(opts) {
     safeReport(() => {
         if (!analytics_1.customDimensions || runErrorRecorded)

package/dist/src/command-line/migrate/migrate-config.d.ts

@@ -9,12 +9,12 @@ import { type MigrateArgs } from './command-object';
  * config value never trips the mutually-exclusive-flag guards in
  * `parseMigrationsOptions`: `include` and `multiMajorMode` in the generate
  * phase only; `createCommits` / `commitPrefix` and `agentic` / `validate` when
- * running the whole migrations file or a standalone single migration. A
- * `--run-id` reconcile or recorded worker takes none of them: a recorded run
- * takes its commit config from run.json and is driven by the outer agent. A
- * `--run-migrations --run-id` continue takes `agentic` only, to select the
- * agent of the new session. A `--start-fresh` starts a new run and takes all
- * four.
+ * running the whole migrations file or a standalone single migration, and
+ * `finalValidation` for the whole file only. A `--run-id` reconcile or
+ * recorded worker takes none of them: a recorded run takes its commit config
+ * from run.json and is driven by the outer agent. A `--run-migrations
+ * --run-id` continue takes `agentic` only, to select the agent of the new
+ * session. A `--start-fresh` starts a new run and takes all five.
  *
  * `include` is carried as `includeFromConfig` so it is never mistaken for an
  * explicit `--include`: `resolveInclude` applies it only when the resolved

package/dist/src/command-line/migrate/migrate-config.js

@@ -14,12 +14,12 @@ const MULTI_MAJOR_MODE_ENV = 'NX_MULTI_MAJOR_MODE';
  * config value never trips the mutually-exclusive-flag guards in
  * `parseMigrationsOptions`: `include` and `multiMajorMode` in the generate
  * phase only; `createCommits` / `commitPrefix` and `agentic` / `validate` when
- * running the whole migrations file or a standalone single migration. A
- * `--run-id` reconcile or recorded worker takes none of them: a recorded run
- * takes its commit config from run.json and is driven by the outer agent. A
- * `--run-migrations --run-id` continue takes `agentic` only, to select the
- * agent of the new session. A `--start-fresh` starts a new run and takes all
- * four.
+ * running the whole migrations file or a standalone single migration, and
+ * `finalValidation` for the whole file only. A `--run-id` reconcile or
+ * recorded worker takes none of them: a recorded run takes its commit config
+ * from run.json and is driven by the outer agent. A `--run-migrations
+ * --run-id` continue takes `agentic` only, to select the agent of the new
+ * session. A `--start-fresh` starts a new run and takes all five.
  *
  * `include` is carried as `includeFromConfig` so it is never mistaken for an
  * explicit `--include`: `resolveInclude` applies it only when the resolved
@@ -60,6 +60,12 @@ function applyNxJsonMigrateDefaults(args, migrateConfig, env = process.env) {
             assertType(migrateConfig.validate, 'boolean', 'validate');
             merged.validate = migrateConfig.validate;
         }
+        if (isRunMigrations &&
+            merged.finalValidation === undefined &&
+            migrateConfig.finalValidation !== undefined) {
+            assertType(migrateConfig.finalValidation, 'boolean', 'finalValidation');
+            merged.finalValidation = migrateConfig.finalValidation;
+        }
     }
     // A continue takes `agentic` too; the reconcile and the worker must not:
     // there it trips the `--agentic`/`--run-id` parse conflict.

package/dist/src/command-line/migrate/migrate.d.ts

@@ -196,7 +196,9 @@ export { filterDowngradedUpdates };
 export declare function generateMigrationsJsonAndUpdatePackageJson(root: string, opts: GenerateMigrations, fetch?: MigratorOptions['fetch']): Promise<void>;
 export { isPromptOnlyMigration, isHybridMigration };
 export declare function formatSkippedPromptsNextStep(skipped: PlannedMigration[]): string;
-export declare function executeMigrations(root: string, migrations: PlannedMigration[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, shouldSkipInstall?: boolean, agentic?: ResolvedAgentic, agenticHasDiffContext?: boolean, shouldRunValidation?: boolean): Promise<{
+export declare function executeMigrations(root: string, migrations: PlannedMigration[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, shouldSkipInstall?: boolean, agentic?: Exclude<ResolvedAgentic, {
+    kind: 'enabled';
+}>): Promise<{
     migrationsWithNoChanges: PlannedMigration[];
     skippedPromptsCount: number;
     notRunMigrationsCount: number;
@@ -213,33 +215,4 @@ export declare function migrate(root: string, args: {
 }, rawArgs: string[]): Promise<number>;
 export declare function readLocalNxVersion(root: string): string | undefined;
 export declare function runMigration(): Promise<number>;
-/**
- * Resolves a migration's collection once and derives everything the run loop
- * needs from that single read: the implementation context (`collection` +
- * `collectionPath`, handed to `runNxOrAngularMigration`) and, for agentic runs,
- * the workspace-relative documentation path handed to the agent.
- *
- * Read fresh per migration (not cached across the loop) so a prior migration's
- * reinstall is reflected, exactly as before. Error handling matches each field's
- * role:
- * - Migrations that run an implementation REQUIRE the collection; an unreadable
- *   collection throws and aborts that migration (caught by the run loop).
- * - Prompt-only migrations don't run an implementation, so the collection is
- *   read only to resolve documentation - a failure there is non-fatal: the
- *   prompt still runs and the supplementary doc is skipped with a warning.
- */
-export declare function resolveMigrationForRun(root: string, migration: {
-    package: string;
-    name: string;
-    documentation?: string;
-    implementation?: string;
-    factory?: string;
-    prompt?: string;
-}, resolveDocumentation: boolean): {
-    resolvedCollection?: {
-        collection: MigrationsJson;
-        collectionPath: string;
-    };
-    documentationPath?: string;
-};
 export declare function nxCliPath(nxWorkspaceRoot?: string): Promise<string>;