nx 23.2.0-beta.4 → 23.2.0-beta.6

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

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetSgrAfterAgent = resetSgrAfterAgent;
 exports.logMigrationBoundary = logMigrationBoundary;
 exports.logAgenticSuccessOutcome = logAgenticSuccessOutcome;
+exports.logWaivedAgenticStep = logWaivedAgenticStep;
 exports.countLandedCommits = countLandedCommits;
+exports.countWaivedAgenticSteps = countWaivedAgenticSteps;
+exports.formatWaivedAgenticSteps = formatWaivedAgenticSteps;
 exports.retainedMigrations = retainedMigrations;
 exports.logFailureRecap = logFailureRecap;
 exports.buildTallyBodyLine = buildTallyBodyLine;
@@ -14,13 +17,12 @@ const pc = tslib_1.__importStar(require("picocolors"));
 const logger_1 = require("../../utils/logger");
 const migration_shape_1 = require("./migration-shape");
 /**
- * Presentation layer for `nx migrate --run-migrations`. Pure helpers — every
- * function maps (state) → (terminal output or string lines). Shared visual
- * vocabulary across the migrate run:
- *   `→` start  ·  `✓` success  ·  `✗` failure  ·  `↷` skipped  ·  `ℹ` info  ·  `─` boundary
+ * Pure presentation helpers for the migrate run phase (`--run-migrations` and
+ * the single-migration worker). Shared glyph vocabulary:
+ *   `→` start, `✓` success, `✗` failure, `↷` skipped, `ℹ` info, `─` boundary
  *
  * Inputs are typed structurally (e.g. `{ name: string }[]`) so this module
- * stays decoupled from `ExecutableMigration` and the executor in migrate.ts.
+ * stays decoupled from the migration executor in migrate.ts.
  */
 /**
  * Some agent TUIs (codex, opencode) don't fully reset their cursor / SGR state
@@ -49,6 +51,23 @@ function logAgenticSuccessOutcome(label, sha, summary) {
     const shaPart = sha ? ` (${sha})` : '';
     logger_1.logger.info(`${pc.green('✓')} ${label}${shaPart}: ${summary}`);
 }
+/**
+ * Logs the skip line for a migration that waived its AI step through
+ * `skipAgentic`, plus a verbose note for any `agentContext` the waiver
+ * dropped. A hybrid waives its paired prompt; a generator-only migration
+ * waives the validation pass, so callers must reach here only once they know
+ * one was on the table. Under `inside-agent` only a hybrid can, so the
+ * hand-off dropped alongside is always a prompt's; a waived generator-only
+ * migration keeps its own. The note is author-facing, hence `--verbose`.
+ */
+function logWaivedAgenticStep(migration, agentContext) {
+    logger_1.logger.info(pc.dim((0, migration_shape_1.isHybridMigration)(migration)
+        ? '↷ Prompt phase skipped. The migration reported nothing left for the AI step to do.'
+        : '↷ Validation skipped. The migration reported its changes need no AI review.'));
+    if (agentContext.length === 0)
+        return;
+    logger_1.logger.verbose(`${migration.package}: ${migration.name} returned skipAgentic: true alongside agentContext, which was dropped. agentContext exists to feed the AI step this migration waived.`);
+}
 /**
  * Counts the migrations whose own commit actually landed — including the
  * HEAD-resolve-race case (`commit: { kind: 'landed', sha: null }`). Used by
@@ -60,6 +79,22 @@ function logAgenticSuccessOutcome(label, sha, summary) {
 function countLandedCommits(outcomes) {
     return outcomes.filter((o) => o.commit.kind === 'landed').length;
 }
+/**
+ * Counts the migrations that waived the AI step they would otherwise have
+ * run. Shared by the success tally and the failure recap so the two can't
+ * report different numbers.
+ */
+function countWaivedAgenticSteps(outcomes) {
+    return outcomes.filter((o) => o.status === 'completed' && o.waivedAgenticStep === true).length;
+}
+/**
+ * The recap phrase for waived AI steps. "not needed" rather than
+ * "skipped"/"deferred", which both recaps reserve for work the user still
+ * owes.
+ */
+function formatWaivedAgenticSteps(count) {
+    return `${count} AI step${count === 1 ? '' : 's'} not needed`;
+}
 /**
  * Migrations whose own commit attempt failed and whose diff was never
  * absorbed by a later commit. Surfaces what the user has to commit or
@@ -90,6 +125,7 @@ function logFailureRecap(opts) {
     const appliedCount = outcomes.filter((o) => o.status === 'completed' &&
         (o.kind === 'applied' || o.kind === 'no-changes')).length;
     const deferredCount = outcomes.filter((o) => o.status === 'completed' && o.kind === 'deferred').length;
+    const waivedAgenticCount = countWaivedAgenticSteps(outcomes);
     const notAttempted = totalMigrations - migrationIndex;
     // Walk back to the most recent completed record whose work is anchored to
     // a sha — either its own commit (`landed`), or a later commit that
@@ -146,6 +182,9 @@ function logFailureRecap(opts) {
         if (deferredCount > 0) {
             parts.push(`${deferredCount} deferred`);
         }
+        if (waivedAgenticCount > 0) {
+            parts.push(formatWaivedAgenticSteps(waivedAgenticCount));
+        }
         logger_1.logger.info(`${parts.join(', ')}. ${notAttempted} not attempted.`);
         logger_1.logger.info(`See the per-migration log above for full details.`);
     }
@@ -181,15 +220,17 @@ function logFailureRecap(opts) {
  * emitting a misleading `0 prompt migrations skipped.` line.
  *
  * Rule (kept coherent across every scenario):
- * - When at least one migration was applied: `<N> migrations applied, <K> commits created[, <D> prompt migrations <skipped|deferred>]`.
+ * - When at least one migration was applied: `<N> migrations applied, <K> commits created[, <D> prompt migrations <skipped|deferred>][, <W> AI steps not needed]`.
  *   The `<K> commits created` part stays even at 0 — it tells the reader work
  *   was applied but not committed (the J4/J8 information made explicit).
  * - When zero migrations were applied but some prompt halves were
- *   skipped/deferred: `<D> prompt migrations <skipped|deferred>` only.
+ *   skipped/deferred: `<D> prompt migrations <skipped|deferred>` only. Waiving
+ *   never adds to `skippedPromptsCount`, so `appliedCount` is non-zero whenever
+ *   `waivedAgenticStepsCount` is, and this branch can't be reached with one.
  * - When zero of either: no body line.
  */
 function buildTallyBodyLine(opts) {
-    const { appliedCount, committedShasCount, skippedPromptsCount, insideAgent } = opts;
+    const { appliedCount, committedShasCount, skippedPromptsCount, waivedAgenticStepsCount, insideAgent, } = opts;
     const skipVerb = insideAgent ? 'deferred' : 'skipped';
     if (appliedCount === 0) {
         if (skippedPromptsCount === 0)
@@ -203,6 +244,9 @@ function buildTallyBodyLine(opts) {
     if (skippedPromptsCount > 0) {
         parts.push(`${skippedPromptsCount} prompt migration${skippedPromptsCount === 1 ? '' : 's'} ${skipVerb}`);
     }
+    if (waivedAgenticStepsCount > 0) {
+        parts.push(formatWaivedAgenticSteps(waivedAgenticStepsCount));
+    }
     return `${parts.join(', ')}.`;
 }
 /**

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

@@ -19,6 +19,7 @@ export type SuccessfulMigration = {
     ref: string;
     nextSteps?: string[];
     acknowledgedPrompt?: boolean;
+    skipAgentic?: boolean;
 };
 export type FailedMigration = {
     type: 'failed';
@@ -41,7 +42,7 @@ export declare function runSingleMigration(workspacePath: string, migration: Mig
 }): Promise<void>;
 export declare function getImplementationPath(workspacePath: string, migration: MigrationDetailsWithId): Promise<string>;
 export declare function modifyMigrationsJsonMetadata(workspacePath: string, modify: (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata): void;
-export declare function addSuccessfulMigration(id: string, fileChanges: Omit<FileChange, 'content'>[], ref: string, nextSteps: string[]): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
+export declare function addSuccessfulMigration(id: string, fileChanges: Omit<FileChange, 'content'>[], ref: string, nextSteps: string[], skipAgentic?: boolean): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
 export declare function updateRefForSuccessfulMigration(id: string, ref: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
 export declare function addFailedMigration(id: string, error: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => {
     completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration | StoppedMigration>;

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

@@ -148,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', {
@@ -225,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]: {
@@ -245,6 +253,7 @@ function addSuccessfulMigration(id, fileChanges, ref, nextSteps) {
                 ref,
                 nextSteps,
                 ...(acknowledgedPrompt && { acknowledgedPrompt: true }),
+                ...(skipAgentic && { skipAgentic: true }),
             },
         };
         return copied;

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

@@ -5,8 +5,9 @@ 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';
 export * from './execute-migration';
@@ -166,88 +167,37 @@ 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;
+    agentic: AgenticArg;
+    validate?: boolean;
+    interactive?: boolean;
+};
+export declare function parseMigrationsOptions(options: MigrateArgs, fetch?: MigratorOptions['fetch']): Promise<GenerateMigrations | RunMigrations | RunSingleMigration>;
 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>;
-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 function isSingleMigrationInvocation(args: Pick<MigrateArgs, 'runMigration'>): 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>;
 /**
  * Resolves a migration's collection once and derives everything the run loop
@@ -278,5 +228,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>;