nx 23.2.0-beta.0 → 23.2.0-beta.10

package/dist/src/command-line/migrate/migrate-ui-api.js

@@ -19,6 +19,7 @@ exports.stopMigration = stopMigration;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
+const git_revision_1 = require("../../utils/git-revision");
 const migrate_1 = require("./migrate");
 Object.defineProperty(exports, "isHybridMigration", { enumerable: true, get: function () { return migrate_1.isHybridMigration; } });
 Object.defineProperty(exports, "isPromptOnlyMigration", { enumerable: true, get: function () { return migrate_1.isPromptOnlyMigration; } });
@@ -51,6 +52,9 @@ function finishMigrationProcess(workspacePath, squashCommits, commitMessage) {
     const migrationsJsonPath = (0, path_1.join)(workspacePath, 'migrations.json');
     const parsedMigrationsJson = JSON.parse((0, fs_1.readFileSync)(migrationsJsonPath, 'utf-8'));
     const initialGitRef = parsedMigrationsJson['nx-console'].initialGitRef;
+    if (squashCommits && initialGitRef) {
+        (0, git_revision_1.assertValidGitSha)(initialGitRef.ref);
+    }
     if ((0, fs_1.existsSync)(migrationsJsonPath)) {
         (0, fs_1.rmSync)(migrationsJsonPath);
     }
@@ -59,24 +63,24 @@ function finishMigrationProcess(workspacePath, squashCommits, commitMessage) {
         encoding: 'utf-8',
         windowsHide: true,
     });
-    (0, child_process_1.execSync)(`git commit -m "${commitMessage}" --no-verify`, {
-        cwd: workspacePath,
-        encoding: 'utf-8',
-        windowsHide: true,
-    });
+    commit(workspacePath, commitMessage);
     if (squashCommits && initialGitRef) {
-        (0, child_process_1.execSync)(`git reset --soft ${initialGitRef.ref}`, {
-            cwd: workspacePath,
-            encoding: 'utf-8',
-            windowsHide: true,
-        });
-        (0, child_process_1.execSync)(`git commit -m "${commitMessage}" --no-verify`, {
+        (0, child_process_1.execFileSync)('git', ['reset', '--soft', initialGitRef.ref], {
             cwd: workspacePath,
             encoding: 'utf-8',
             windowsHide: true,
         });
+        commit(workspacePath, commitMessage);
     }
 }
+function commit(workspacePath, commitMessage) {
+    (0, child_process_1.execSync)('git commit --no-verify -F -', {
+        cwd: workspacePath,
+        encoding: 'utf-8',
+        windowsHide: true,
+        input: commitMessage,
+    });
+}
 async function runSingleMigration(workspacePath, migration, configuration) {
     try {
         // Set current migration tracking
@@ -144,11 +148,15 @@ async function runSingleMigration(workspacePath, migration, configuration) {
         if (result.type === 'error') {
             throw new Error(result.message);
         }
-        const { fileChanges, gitRefAfter, nextSteps } = result;
+        const { fileChanges, gitRefAfter, nextSteps, skipAgentic } = result;
         modifyMigrationsJsonMetadata(workspacePath, addSuccessfulMigration(migration.id, fileChanges.map((change) => ({
             path: change.path,
             type: change.type,
-        })), gitRefAfter, nextSteps));
+        })), gitRefAfter, nextSteps, 
+        // Only a hybrid has a prompt phase to waive. A generator-only
+        // migration has no prompt affordance in the UI, so recording it there
+        // would mark a state the UI never shows.
+        skipAgentic === true && (0, migrate_1.isHybridMigration)(migration)));
         if (gitRefBefore !== gitRefAfter) {
             try {
                 (0, child_process_1.execSync)('git add migrations.json', {
@@ -221,17 +229,21 @@ function modifyMigrationsJsonMetadata(workspacePath, modify) {
     migrationsJson['nx-console'] = modify(migrationsJson['nx-console']);
     (0, fs_1.writeFileSync)(migrationsJsonPath, JSON.stringify(migrationsJson, null, 2));
 }
-function addSuccessfulMigration(id, fileChanges, ref, nextSteps) {
+function addSuccessfulMigration(id, fileChanges, ref, nextSteps, skipAgentic = false) {
     return (migrationsJsonMetadata) => {
         const copied = { ...migrationsJsonMetadata };
         if (!copied.completedMigrations) {
             copied.completedMigrations = {};
         }
-        // Carry forward a previously-set acknowledgedPrompt so any caller that
-        // re-records a successful entry for the same id (no current trigger; this
-        // is defensive against future paths) cannot silently drop the user's ack.
+        // A rerun re-records the same id. Carry an ack forward only off a record
+        // that carries no waiver: once a waiving run writes one it is
+        // byte-identical to a user's, so a rerun that owes the prompt again re-asks
+        // rather than trust it. Waiving sets the ack because nothing is owed.
         const existing = copied.completedMigrations[id];
-        const acknowledgedPrompt = existing?.type === 'successful' && existing.acknowledgedPrompt;
+        const acknowledgedPrompt = skipAgentic ||
+            (existing?.type === 'successful' &&
+                existing.acknowledgedPrompt &&
+                !existing.skipAgentic);
         copied.completedMigrations = {
             ...copied.completedMigrations,
             [id]: {
@@ -241,6 +253,7 @@ function addSuccessfulMigration(id, fileChanges, ref, nextSteps) {
                 ref,
                 nextSteps,
                 ...(acknowledgedPrompt && { acknowledgedPrompt: true }),
+                ...(skipAgentic && { skipAgentic: true }),
             },
         };
         return copied;
@@ -342,7 +355,8 @@ function undoMigration(workspacePath, id) {
         // `existing.ref` is the unmodified HEAD at run time, so `ref^` would
         // reset past unrelated history. Only flip the metadata to skipped.
         if (existing.changedFiles.length > 0) {
-            (0, child_process_1.execSync)(`git reset --hard ${existing.ref}^`, {
+            (0, git_revision_1.assertValidGitSha)(existing.ref);
+            (0, child_process_1.execFileSync)('git', ['reset', '--hard', `${existing.ref}^`], {
                 cwd: workspacePath,
                 encoding: 'utf-8',
                 windowsHide: true,

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

@@ -1,15 +1,17 @@
 import { MigrationsJson, PackageJsonUpdateForPackage as PackageUpdate } from '../../config/misc-interfaces';
 import { NxJsonConfiguration } from '../../config/nx-json';
-import { FileChange } from '../../generators/tree';
 import { ArrayPackageGroup, PackageJson } from '../../utils/package-json';
 import { PackageManagerCommands } from '../../utils/package-manager';
 import { type MigrateFetchStats, type MigrateMultiMajorChoice } from './migrate-analytics';
 import { type MultiMajorMode } from './multi-major';
 import type { AgenticArg } from './agentic/select';
+import { MigrateArgs } from './command-object';
 import type { ResolvedAgentic } from './agentic/types';
-import { isHybridMigration, isPromptOnlyMigration } from './migration-shape';
+import { isHybridMigration, isPromptOnlyMigration, type PlannedMigration } from './migration-shape';
 import { filterDowngradedUpdates } from './update-filters';
 import { normalizeVersion } from './version-utils';
+import { type StepAction } from './step-actions';
+export * from './execute-migration';
 export { normalizeVersion };
 export interface ResolvedMigrationConfiguration extends MigrationsJson {
     packageGroup?: ArrayPackageGroup;
@@ -63,6 +65,8 @@ export declare class Migrator {
     private readonly packageUpdates;
     private readonly collectedVersions;
     private readonly promptAnswers;
+    private readonly pendingPackageJsonUpdates;
+    private readonly appliedPackageJsonUpdates;
     private readonly nxInstallation;
     private minVersionWithSkippedUpdates;
     constructor(opts: MigratorOptions);
@@ -85,6 +89,8 @@ export declare class Migrator {
     }>;
     private createMigrateJson;
     private buildPackageJsonUpdates;
+    private applyPackageJsonUpdate;
+    private applyPendingPackageJsonUpdates;
     private resolveVersionForCascade;
     private populatePackageJsonUpdatesAndGetPackagesToCheck;
     private getPackageJsonUpdatesFromMigrationConfig;
@@ -166,133 +172,44 @@ type RunMigrations = {
     validate?: boolean;
     interactive?: boolean;
 };
-export declare function parseMigrationsOptions(options: {
-    [k: string]: any;
-}, fetch?: MigratorOptions['fetch']): Promise<GenerateMigrations | RunMigrations>;
+type RunSingleMigration = {
+    type: 'runSingleMigration';
+    runMigration: string;
+    runId?: string;
+    agentic: AgenticArg;
+    validate?: boolean;
+    interactive?: boolean;
+};
+type OrchestratorReconcile = {
+    type: 'orchestratorReconcile';
+    runId: string;
+    stepAction?: StepAction;
+};
+export declare function parseMigrationsOptions(options: MigrateArgs, fetch?: MigratorOptions['fetch']): Promise<GenerateMigrations | RunMigrations | RunSingleMigration | OrchestratorReconcile>;
 export declare function createFetcher(pmc: PackageManagerCommands): ((pkg: string, version: string) => Promise<ResolvedMigrationConfiguration>) & {
     stats?: MigrateFetchStats;
 };
 export { filterDowngradedUpdates };
 export declare function generateMigrationsJsonAndUpdatePackageJson(root: string, opts: GenerateMigrations, fetch?: MigratorOptions['fetch']): Promise<void>;
-/**
- * Detects npm peer-dependency resolution failures. Keyed on the `ERESOLVE`
- * error code, which npm consistently emits for this class of failure across
- * v7+ (`npm ERR! code ERESOLVE` / `npm error code ERESOLVE`). Falls back to a
- * small set of stable phrases in case the code line is missing from the
- * captured output.
- */
-export declare function isNpmPeerDepsError(stderr: string): boolean;
-type ExecutableMigration = {
-    package: string;
-    name: string;
-    description?: string;
-    version: string;
-    implementation?: string;
-    factory?: string;
-    prompt?: string;
-    documentation?: string;
-};
 export { isPromptOnlyMigration, isHybridMigration };
-export declare function resolveAgenticRunId(migrations: ExecutableMigration[]): string;
-export declare function formatSkippedPromptsNextStep(skipped: ExecutableMigration[]): string;
-/**
- * Resolves the effective `--create-commits` state once the agentic flow has
- * been resolved. The agent's outer prompt only embeds the impl-phase file list
- * when per-migration commits isolate each migration's diff, so the diff-context
- * flag returned here gates that section.
- */
-export declare function resolveCreateCommits(args: {
-    createCommits: boolean | undefined;
-    agenticKind: ResolvedAgentic['kind'];
-    isGitRepo: boolean;
-    /**
-     * Whether `--commit-prefix` was given a non-default value. When commits
-     * end up disabled, the prefix has no effect — the warning copy below
-     * surfaces that so the user isn't silently misled.
-     */
-    commitPrefixIsCustom?: boolean;
-}): {
-    effective: boolean;
-    agenticHasDiffContext: boolean;
-    warning?: string;
-    error?: string;
-};
-/**
- * Confirms before creating per-migration commits while the user sits on the
- * repository's default branch, so migrations don't silently commit there (most
- * relevant since `--agentic` enables commits by default). Only the default
- * branch triggers a prompt; a detached HEAD, a different branch, or an
- * unresolved default branch all proceed untouched. Callers gate this on
- * commits being effective and prompting being possible, so non-interactive
- * runs (CI, `--no-interactive`) never reach here.
- */
-export declare function confirmCommitsOnDefaultBranch(args: {
-    currentBranch: string | null;
-    defaultBranch: string | null;
-}): Promise<boolean>;
-/**
- * Resolves whether the framework-owned generic-validation agent step should run
- * after generator-only migrations.
- *
- * Default-on when the agentic flow resolved to `enabled`; silently ignored
- * otherwise (no warning emitted) — `--validate` requires an active agent
- * session by definition. An explicit `--no-validate` (`validate === false`)
- * opts out even when agentic is enabled.
- */
-export declare function resolveShouldRunValidation(args: {
-    validate: boolean | undefined;
-    agenticKind: ResolvedAgentic['kind'];
-}): boolean;
-export declare function executeMigrations(root: string, migrations: ExecutableMigration[], isVerbose: boolean, shouldCreateCommits: boolean, commitPrefix: string, shouldSkipInstall?: boolean, agentic?: ResolvedAgentic, agenticHasDiffContext?: boolean, shouldRunValidation?: boolean): Promise<{
-    migrationsWithNoChanges: ExecutableMigration[];
+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<{
+    migrationsWithNoChanges: PlannedMigration[];
     skippedPromptsCount: number;
     notRunMigrationsCount: number;
     nextSteps: string[];
-    skippedPrompts: ExecutableMigration[];
+    skippedPrompts: PlannedMigration[];
     migrationEmittedNextSteps: string[];
     committedShasCount: number;
+    waivedAgenticStepsCount: number;
     retainedAtSuccess: string[];
 }>;
-export declare class ChangedDepInstaller {
-    private readonly root;
-    private readonly shouldSkipInstall;
-    private initialDeps;
-    private _skippedInstall;
-    constructor(root: string, shouldSkipInstall?: boolean);
-    get skippedInstall(): boolean;
-    installDepsIfChanged(): Promise<void>;
-}
-export declare function runNxOrAngularMigration(root: string, migration: {
-    package: string;
-    name: string;
-    description?: string;
-    version: string;
-}, isVerbose: boolean, captureGeneratorOutput?: boolean, resolvedCollection?: {
-    collection: MigrationsJson;
-    collectionPath: string;
-}): Promise<{
-    changes: FileChange[];
-    nextSteps: string[];
-    agentContext: string[];
-    logs: string;
-    madeChanges: boolean;
-}>;
-export declare function parseMigrationReturn(value: unknown): {
-    nextSteps: string[];
-    agentContext: string[];
-};
+export declare function isRunPhaseInvocation(args: Pick<MigrateArgs, 'runMigration' | 'runId' | 'stepAction'>): boolean;
 export declare function migrate(root: string, args: {
     [k: string]: any;
 }, rawArgs: string[]): Promise<number>;
+export declare function readLocalNxVersion(root: string): string | undefined;
 export declare function runMigration(): Promise<number>;
-export declare function readMigrationCollection(packageName: string, root: string): {
-    collection: MigrationsJson;
-    collectionPath: string;
-};
-export declare function getImplementationPath(collection: MigrationsJson, collectionPath: string, name: string, migrationVersion?: string): {
-    path: string;
-    fnSymbol: string;
-};
 /**
  * Resolves a migration's collection once and derives everything the run loop
  * needs from that single read: the implementation context (`collection` +
@@ -322,5 +239,4 @@ export declare function resolveMigrationForRun(root: string, migration: {
     };
     documentationPath?: string;
 };
-export declare function resolveDocumentationFileToWorkspacePath(root: string, migrationsDir: string, documentation: string): string | undefined;
 export declare function nxCliPath(nxWorkspaceRoot?: string): Promise<string>;