@contentful/experience-design-system-cli 2.7.4 → 2.11.0

package/dist/src/import/orchestrator.js

@@ -3,6 +3,7 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFile } from 'node:child_process';
 import { openPipelineDb, getOrCreateSession, createStep, updateStep, findLatestSessionForCommand, } from '../session/db.js';
+import { PREVIEW_ERROR_PREFIX, VALIDATION_FAILED_CODE, parsePreviewValidationErrors } from '../apply/api-client.js';
 function findCliPath() {
     return join(fileURLToPath(import.meta.url), '..', '..', '..', '..', 'bin', 'cli.js');
 }
@@ -27,6 +28,49 @@ async function runStep(args, cliPath, env = {}, streamStderr = false) {
         });
     });
 }
+const MAX_VALIDATION_RETRIES = Number(process.env['EDS_MAX_VALIDATION_RETRIES'] ?? 2);
+export function isPreviewValidationError(result) {
+    return (result.exitCode !== 0 &&
+        result.stderr.includes(`${PREVIEW_ERROR_PREFIX} 422`) &&
+        result.stderr.includes(VALIDATION_FAILED_CODE));
+}
+export function parseOffendingComponentNames(output) {
+    // The 422 body is appended to the ApiError message by the constructor and
+    // written to stderr by die(). Extract the JSON portion by finding the first '{'.
+    const jsonStart = output.indexOf('{');
+    if (jsonStart === -1)
+        return [];
+    const errors = parsePreviewValidationErrors(output.slice(jsonStart));
+    return [...new Set(errors.map((e) => e.componentName))];
+}
+/**
+ * Build the apply-push StepResult record. Centralizes the success/failure
+ * shape so excludedByValidationRetry is recorded consistently in both
+ * branches — previously the total-failure branch dropped it, leaving users
+ * with a failed pipeline and no audit trail of what was auto-excluded
+ * before the retry loop gave up.
+ */
+export function buildPushStepResult(args) {
+    const { created, updated, failed, durationMs, stderr, excludedByRetry, totalFailure } = args;
+    const excludedDetail = excludedByRetry.length > 0 ? { excludedByValidationRetry: excludedByRetry } : {};
+    if (totalFailure) {
+        const detail = excludedByRetry.length > 0 ? { ...excludedDetail } : undefined;
+        return {
+            step: 'apply push',
+            status: 'failed',
+            durationMs,
+            error: stderr,
+            ...(detail ? { detail } : {}),
+        };
+    }
+    const status = failed > 0 ? 'failed' : 'complete';
+    return {
+        step: 'apply push',
+        status,
+        durationMs,
+        detail: { created, updated, failed, ...excludedDetail },
+    };
+}
 export async function runPipeline(opts, progressWriter, cliPathOverride) {
     const projectRoot = resolve(opts.project);
     const outDir = resolve(opts.out);
@@ -128,6 +172,8 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
             editArgs = ['analyze', 'select-agent', '--session', extractSessionId, '--agent', opts.agent];
             if (opts.model)
                 editArgs.push('--model', opts.model);
+            if (opts.excludeInvalid)
+                editArgs.push('--exclude-invalid');
         }
         else {
             editArgs = ['analyze', 'select', '--session', extractSessionId];
@@ -320,7 +366,37 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
             components: componentsPath,
         });
         const t0 = Date.now();
-        const r = await runStep(pushArgs, cliPath, { FORCE_COLOR: '1' }, true);
+        let r = await runStep(pushArgs, cliPath, { FORCE_COLOR: '1' }, true);
+        // Bounded retry loop: on a preview-phase 422 with a parseable ValidationFailed
+        // body, exclude the offending components and re-run apply push.
+        const excludedByRetry = [];
+        let validationRetryCount = 0;
+        while (validationRetryCount < MAX_VALIDATION_RETRIES && isPreviewValidationError(r) && extractSessionId) {
+            const offenders = parseOffendingComponentNames(r.stderr + r.stdout);
+            if (offenders.length === 0)
+                break; // unparseable body — give up and surface original error
+            process.stderr.write(`[retry ${validationRetryCount + 1}/${MAX_VALIDATION_RETRIES}] Preview validation failed — excluding ${offenders.join(', ')} and retrying\n`);
+            excludedByRetry.push(...offenders);
+            // No --select-all here: that would route through runNonInteractive's
+            // rebuild path, which DELETEs all rows and re-inserts with default
+            // status='extracted' — wiping the post-`generate components` state
+            // (status='generated' + raw_props.cdf_type) the next apply push reads.
+            // The bare --exclude-components form takes the rejectComponentsByName
+            // early-return: pure UPDATE, no rebuild.
+            const rejectArgs = [
+                'analyze',
+                'select',
+                '--session',
+                extractSessionId,
+                '--exclude-components',
+                offenders.join(','),
+            ];
+            const rejectResult = await runStep(rejectArgs, cliPath);
+            if (rejectResult.exitCode !== 0)
+                break; // selection step failed — give up
+            r = await runStep(pushArgs, cliPath, { FORCE_COLOR: '1' }, true);
+            validationRetryCount++;
+        }
         const durationMs = Date.now() - t0;
         let pushResult = null;
         try {
@@ -343,25 +419,32 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
             // Total failure — nothing was pushed
             updateStep(db, pushStepId, 'failed', {}, r.stderr);
             progressWriter(`${pushLabel}✗  failed (${(durationMs / 1000).toFixed(1)}s)`);
-            steps.push({
-                step: 'apply push',
-                status: 'failed',
+            steps.push(buildPushStepResult({
+                created,
+                updated,
+                failed,
                 durationMs,
-                error: r.stderr,
-            });
+                stderr: r.stderr,
+                excludedByRetry,
+                totalFailure: true,
+            }));
             db.close();
             return { session: sessionId, project: projectRoot, steps };
         }
-        const stepStatus = failed > 0 ? 'failed' : 'complete';
-        updateStep(db, pushStepId, stepStatus === 'complete' ? 'complete' : 'failed', { components: componentsPath });
-        const statusIcon = failed > 0 ? '⚠' : '✓';
-        progressWriter(`${pushLabel}${statusIcon}  ${created} created, ${updated} updated, ${failed} failed  (${(durationMs / 1000).toFixed(1)}s)`);
-        steps.push({
-            step: 'apply push',
-            status: stepStatus,
+        const stepResult = buildPushStepResult({
+            created,
+            updated,
+            failed,
             durationMs,
-            detail: { created, updated, failed },
+            stderr: r.stderr,
+            excludedByRetry,
         });
+        updateStep(db, pushStepId, stepResult.status === 'complete' ? 'complete' : 'failed', {
+            components: componentsPath,
+        });
+        const statusIcon = failed > 0 ? '⚠' : '✓';
+        progressWriter(`${pushLabel}${statusIcon}  ${created} created, ${updated} updated, ${failed} failed  (${(durationMs / 1000).toFixed(1)}s)`);
+        steps.push(stepResult);
     }
     progressWriter('');
     progressWriter(`Pipeline complete. Session: ${sessionId}`);

package/dist/src/import/tui/WizardApp.d.ts

@@ -1,4 +1,17 @@
 import React from 'react';
+export declare function buildAnalyzeSelectArgs(opts: {
+    sessionId: string;
+    acceptAll: boolean;
+}): string[];
+export declare function formatAcceptanceSummary(opts: {
+    accepted: number;
+    autoRejected: number;
+}): string;
+export declare function formatGeneratedSummary(opts: {
+    generated: number;
+    renamedSlots: number;
+    autoRejected: number;
+}): string;
 export type WizardAppProps = {
     initialSpaceId?: string;
     initialEnvironmentId?: string;

package/dist/src/import/tui/WizardApp.js

@@ -18,7 +18,9 @@ import { DoneStep } from './steps/DoneStep.js';
 import { ErrorStep } from './steps/ErrorStep.js';
 import { TokenInputStep } from './steps/TokenInputStep.js';
 import { GenerateReviewStep } from './steps/GenerateReviewStep.js';
+import { PreviewValidationErrorStep } from './steps/PreviewValidationErrorStep.js';
 import { ImportApiClient, ApiError } from '../../apply/api-client.js';
+import { handlePreview422, applySkipValidationErrors, clearedValidationErrorState } from './wizard-422-helpers.js';
 import { readTokensFromPath, hasBreakingChangesWithImpact } from '../../apply/manifest.js';
 import { buildManifest } from '@contentful/experience-design-system-types';
 import { openPipelineDb, loadCDFComponents, seedCDFFromPreviewResponse, seedDefaultsFromChangedItems, backfillUnclassifiedProps, } from '../../session/db.js';
@@ -29,6 +31,34 @@ import { writeExperiencesCredentials } from '../../credentials-store.js';
 function findCliPath() {
     return join(fileURLToPath(import.meta.url), '..', '..', '..', '..', '..', 'bin', 'cli.js');
 }
+export function buildAnalyzeSelectArgs(opts) {
+    const args = ['analyze', 'select', '--session', opts.sessionId];
+    if (opts.acceptAll) {
+        // The wizard pre-shows validation errors in the analyze-extract TUI before
+        // reaching this gate, so the user has already seen what will be excluded.
+        // Pass --exclude-invalid to bypass the headless fail-loud gate (which is
+        // for CI / scripted callers that need to fail loud) — the wizard surfaces
+        // the auto-rejection via formatAcceptanceSummary on the next screen.
+        args.push('--select-all', '--exclude-invalid');
+    }
+    return args;
+}
+export function formatAcceptanceSummary(opts) {
+    const acceptedClause = `${opts.accepted} component${opts.accepted === 1 ? '' : 's'} accepted`;
+    if (opts.autoRejected === 0)
+        return `${acceptedClause}.`;
+    return `${acceptedClause}, ${opts.autoRejected} excluded due to validation errors.`;
+}
+export function formatGeneratedSummary(opts) {
+    const generatedClause = `Generated definitions for ${opts.generated} component${opts.generated === 1 ? '' : 's'}.`;
+    const renamedClause = opts.renamedSlots > 0
+        ? ` ${opts.renamedSlots} unnamed slot${opts.renamedSlots === 1 ? '' : 's'} renamed (children / slot_<n>) so the LLM could classify them.`
+        : '';
+    const exclusionClause = opts.autoRejected > 0
+        ? ` ${opts.autoRejected} component${opts.autoRejected === 1 ? '' : 's'} excluded earlier due to validation errors.`
+        : '';
+    return `${generatedClause}${renamedClause}${exclusionClause}`;
+}
 function runCli(args) {
     return new Promise((res) => {
         execFile('node', [findCliPath(), ...args], (error, stdout, stderr) => {
@@ -70,8 +100,10 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         generateSessionId: null,
         extractedCount: 0,
         acceptedCount: 0,
+        autoRejectedCount: 0,
         generatedCount: 0,
         generatedAcceptedCount: 0,
+        renamedSlotsCount: 0,
         generateProgress: null,
         extractProgress: null,
         componentsPath: '',
@@ -91,6 +123,8 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         errorMessage: '',
         errorAllowCredentialRetry: false,
         authCheckStepNumber: 1,
+        previewValidationErrors: [],
+        previewValidationMissingNames: [],
     });
     useEffect(() => {
         sessionRef.current = {
@@ -195,7 +229,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
             child.on('exit', (code) => res({ exitCode: code ?? 0, stdout, stderr }));
         });
         if (result.exitCode !== 0) {
-            update({ step: 'error', errorStep: 'generate tokens', errorMessage: result.stderr.trim() || 'Unknown error' });
+            update({
+                step: 'error',
+                errorStep: 'generate tokens',
+                errorMessage: result.stderr.trim() || 'Unknown error',
+            });
             return;
         }
         const sessionMatch = /^session:\s*(.+)$/m.exec(result.stdout);
@@ -206,7 +244,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
             printArgs.push('--session', tokenSessionId);
         const r = await runCli(printArgs);
         if (r.exitCode !== 0) {
-            update({ step: 'error', errorStep: 'print tokens', errorMessage: r.stderr.trim() || 'Unknown error' });
+            update({
+                step: 'error',
+                errorStep: 'print tokens',
+                errorMessage: r.stderr.trim() || 'Unknown error',
+            });
             return;
         }
         update({ step: 'path-validation', tokensPath, tokenSessionId });
@@ -259,7 +301,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
             child.on('exit', (code) => res({ exitCode: code ?? 0, stdout, stderr }));
         });
         if (r.exitCode !== 0) {
-            update({ step: 'error', errorStep: 'analyze extract', errorMessage: r.stderr.trim() || 'Unknown error' });
+            update({
+                step: 'error',
+                errorStep: 'analyze extract',
+                errorMessage: r.stderr.trim() || 'Unknown error',
+            });
             return;
         }
         const sessionMatch = /^session=(.+)$/m.exec(r.stdout);
@@ -274,41 +320,57 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
             });
             return;
         }
-        update({ step: 'review-extraction-gate', extractSessionId, extractedCount });
+        update({
+            step: 'review-extraction-gate',
+            extractSessionId,
+            extractedCount,
+        });
     };
     const runAnalyzeSelect = async (sessionId, extractedCount, tokensPath, acceptAll) => {
-        logStep({ fn: 'runAnalyzeSelect:enter', sessionId, extractedCount, acceptAll });
+        logStep({
+            fn: 'runAnalyzeSelect:enter',
+            sessionId,
+            extractedCount,
+            acceptAll,
+        });
         let acceptedCount;
-        if (acceptAll) {
-            logStep({ fn: 'runAnalyzeSelect:acceptAll-skip-spawn' });
-            acceptedCount = extractedCount;
+        if (!acceptAll && state.serverPreview && !process.env['EDS_PREVIEW_ANNOTATIONS']) {
+            process.env['EDS_PREVIEW_ANNOTATIONS'] = JSON.stringify(buildPreviewAnnotations(state.serverPreview));
         }
-        else {
-            if (state.serverPreview && !process.env['EDS_PREVIEW_ANNOTATIONS']) {
-                process.env['EDS_PREVIEW_ANNOTATIONS'] = JSON.stringify(buildPreviewAnnotations(state.serverPreview));
-            }
+        if (!acceptAll) {
             update({ step: 'analyze-select' });
-            const r = await runCliInteractive(['analyze', 'select', '--session', sessionId]);
-            logStep({ fn: 'runAnalyzeSelect:post-spawn', exitCode: r.exitCode });
+        }
+        const args = buildAnalyzeSelectArgs({ sessionId, acceptAll });
+        const r = acceptAll ? await runCli(args) : await runCliInteractive(args);
+        logStep({ fn: 'runAnalyzeSelect:post-spawn', exitCode: r.exitCode, args });
+        if (!acceptAll)
             clearPreviewEnvVars();
-            if (r.exitCode !== 0) {
-                update({ step: 'error', errorStep: 'analyze select', errorMessage: r.stderr.trim() || 'Unknown error' });
-                return;
-            }
-            // Read accepted count from the review state file (since TUI subprocess inherits stdio)
-            const artifactsRoot = process.env['EDS_REVIEW_ARTIFACTS_DIR']
-                ? resolve(process.env['EDS_REVIEW_ARTIFACTS_DIR'])
-                : resolve(homedir(), '.contentful', 'experience-design-system-cli', 'reviews');
-            const reviewStatePath = resolve(artifactsRoot, sessionId, 'current-review-state.json');
-            try {
-                const reviewState = JSON.parse(await readFile(reviewStatePath, 'utf8'));
-                acceptedCount = reviewState.components.filter((c) => c.status === 'accepted').length;
-            }
-            catch {
-                acceptedCount = extractedCount;
-            }
+        if (r.exitCode !== 0) {
+            update({
+                step: 'error',
+                errorStep: 'analyze select',
+                errorMessage: r.stderr.trim() || 'Unknown error',
+            });
+            return;
         }
-        update({ acceptedCount });
+        // Read accepted count from the review state file (since TUI subprocess inherits stdio
+        // in the manual review path; in the bulk path we also persist to the same file).
+        // Also extract auto-rejected count (components with error-severity validation issues
+        // dropped by the gate) so the user sees what was excluded on the next step.
+        const artifactsRoot = process.env['EDS_REVIEW_ARTIFACTS_DIR']
+            ? resolve(process.env['EDS_REVIEW_ARTIFACTS_DIR'])
+            : resolve(homedir(), '.contentful', 'experience-design-system-cli', 'reviews');
+        const reviewStatePath = resolve(artifactsRoot, sessionId, 'current-review-state.json');
+        let autoRejectedCount = 0;
+        try {
+            const reviewState = JSON.parse(await readFile(reviewStatePath, 'utf8'));
+            acceptedCount = reviewState.components.filter((c) => c.status === 'accepted').length;
+            autoRejectedCount = reviewState.components.filter((c) => c.status === 'rejected' && (c.originalProposal.validationIssues ?? []).some((i) => i.severity === 'error')).length;
+        }
+        catch {
+            acceptedCount = extractedCount;
+        }
+        update({ acceptedCount, autoRejectedCount });
         if (acceptedCount > 0) {
             if (await runAgentAuthCheck('generating')) {
                 void runGenerate(sessionId, tokensPath, acceptedCount);
@@ -335,7 +397,13 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                 for (const line of chunk.split('\n')) {
                     const m = /\[(\d+)\/(\d+)\]\s+(.+)/.exec(line);
                     if (m)
-                        update({ generateProgress: { done: Number(m[1]), total: Number(m[2]), current: m[3].trim() } });
+                        update({
+                            generateProgress: {
+                                done: Number(m[1]),
+                                total: Number(m[2]),
+                                current: m[3].trim(),
+                            },
+                        });
                 }
             });
             child.on('exit', (code) => res({ exitCode: code ?? 0, stdout, stderr }));
@@ -352,7 +420,15 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         const generateSessionId = sessionMatch ? sessionMatch[1].trim() : null;
         const countMatch = /(\d+) components?/.exec(result.stderr);
         const generatedCount = countMatch ? Number(countMatch[1]) : acceptedCount;
-        update({ step: 'review-generated-gate', generateSessionId, generatedCount, generateProgress: null });
+        const renamedMatch = /^renamed-slots:\s*(\d+)$/m.exec(result.stdout);
+        const renamedSlotsCount = renamedMatch ? Number(renamedMatch[1]) : 0;
+        update({
+            step: 'review-generated-gate',
+            generateSessionId,
+            generatedCount,
+            renamedSlotsCount,
+            generateProgress: null,
+        });
     };
     const advanceToPushFlow = (generatedAcceptedCount) => {
         update({ generatedAcceptedCount, step: 'credentials' });
@@ -367,7 +443,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
             if (sessionId) {
                 const r = await runCliInteractive(['generate', 'components', 'edit', '--session', sessionId]);
                 if (r.exitCode !== 0) {
-                    update({ step: 'error', errorStep: 'generate edit', errorMessage: r.stderr.trim() || 'Unknown error' });
+                    update({
+                        step: 'error',
+                        errorStep: 'generate edit',
+                        errorMessage: r.stderr.trim() || 'Unknown error',
+                    });
                     return;
                 }
                 const acceptedMatch = /Accepted: (\d+)/.exec(r.stderr);
@@ -409,7 +489,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
     const runEditFromPreview = async (preview) => {
         const sessionId = state.extractSessionId;
         if (!sessionId) {
-            update({ step: 'error', errorStep: 'edit definitions', errorMessage: 'No session available for editing' });
+            update({
+                step: 'error',
+                errorStep: 'edit definitions',
+                errorMessage: 'No session available for editing',
+            });
             return;
         }
         process.env['EDS_PREVIEW_ANNOTATIONS'] = JSON.stringify(buildPreviewAnnotations(preview));
@@ -430,13 +514,22 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         const r = await runCliInteractive(['analyze', 'select', '--session', sessionId]);
         clearPreviewEnvVars();
         if (r.exitCode !== 0) {
-            update({ step: 'error', errorStep: 'edit definitions', errorMessage: 'Editor exited with an error' });
+            update({
+                step: 'error',
+                errorStep: 'edit definitions',
+                errorMessage: 'Editor exited with an error',
+            });
             return;
         }
         // Re-preview with updated definitions
         const { extractSessionId: sid, tokensPath: tp } = sessionRef.current;
         void runPreview(sid, tp, state.spaceId, state.environmentId, state.cmaToken, state.host);
     };
+    const runSkipValidationErrorsAndRetry = async (errors) => {
+        await applySkipValidationErrors(state.extractSessionId, errors);
+        const { extractSessionId: sid, tokensPath: tp } = sessionRef.current;
+        void runPreview(sid, tp, state.spaceId, state.environmentId, state.cmaToken, state.host);
+    };
     const advanceWithCredentials = (spaceId, environmentId, cmaToken, host) => {
         const resolvedHost = resolveWizardHost(host);
         credentialsRef.current = { spaceId, environmentId, cmaToken };
@@ -452,7 +545,12 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
     const confirmCredentials = async (spaceId, environmentId, cmaToken, host) => {
         const resolvedHost = resolveWizardHost(host);
         try {
-            await writeExperiencesCredentials({ spaceId, environmentId, cmaToken, host: resolvedHost });
+            await writeExperiencesCredentials({
+                spaceId,
+                environmentId,
+                cmaToken,
+                host: resolvedHost,
+            });
             advanceWithCredentials(spaceId, environmentId, cmaToken, resolvedHost);
         }
         catch (e) {
@@ -471,7 +569,12 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         update({ step: 'validating-credentials' });
         try {
             const resolvedHost = resolveWizardHost(host);
-            const client = new ImportApiClient({ cmaToken, spaceId, environmentId, host: resolvedHost });
+            const client = new ImportApiClient({
+                cmaToken,
+                spaceId,
+                environmentId,
+                host: resolvedHost,
+            });
             await client.validateToken();
             const { extractSessionId, tokensPath } = sessionRef.current;
             void runPreview(extractSessionId, tokensPath, spaceId, environmentId, cmaToken, resolvedHost);
@@ -494,7 +597,12 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         update({ step: 'previewing' });
         const resolvedHost = resolveWizardHost(host);
         try {
-            const client = new ImportApiClient({ cmaToken, spaceId, environmentId, host: resolvedHost });
+            const client = new ImportApiClient({
+                cmaToken,
+                spaceId,
+                environmentId,
+                host: resolvedHost,
+            });
             let components = [];
             if (extractSessionId) {
                 const db = openPipelineDb();
@@ -543,7 +651,7 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                     db.close();
                 }
             }
-            update({ step: 'preview-gate', serverPreview: preview, manifest });
+            update({ step: 'preview-gate', serverPreview: preview, manifest, ...clearedValidationErrorState() });
         }
         catch (e) {
             if (e instanceof ApiError) {
@@ -585,11 +693,31 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                     });
                     return;
                 }
-                update({ step: 'error', errorStep: 'apply preview', errorMessage: e.message, errorAllowCredentialRetry: true });
+                const outcome = await handlePreview422(e, extractSessionId);
+                if (outcome.kind === 'validation-error') {
+                    update({
+                        step: 'preview-validation-error',
+                        previewValidationErrors: outcome.errors,
+                        previewValidationMissingNames: outcome.missingNames,
+                    });
+                    return;
+                }
+                // 'unparseable' and 'not-422' both fall through to the generic error branch below.
+                update({
+                    step: 'error',
+                    errorStep: 'apply preview',
+                    errorMessage: e.message,
+                    errorAllowCredentialRetry: true,
+                });
                 return;
             }
             const msg = e instanceof Error ? e.message : 'Preview failed';
-            update({ step: 'error', errorStep: 'apply preview', errorMessage: msg, errorAllowCredentialRetry: true });
+            update({
+                step: 'error',
+                errorStep: 'apply preview',
+                errorMessage: msg,
+                errorAllowCredentialRetry: true,
+            });
         }
     };
     const runPush = async (manifest, spaceId, environmentId, cmaToken, host, acknowledgeBreakingChanges, preview) => {
@@ -612,17 +740,28 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         update({ step: 'pushing' });
         try {
             const resolvedHost = resolveWizardHost(host);
-            const client = new ImportApiClient({ cmaToken, spaceId, environmentId, host: resolvedHost });
+            const client = new ImportApiClient({
+                cmaToken,
+                spaceId,
+                environmentId,
+                host: resolvedHost,
+            });
             let operation = await client.applyImport(manifest, acknowledgeBreakingChanges);
             try {
                 logStep({
-                    applyResponse: { status: operation?.sys?.status, id: operation?.sys?.id, keys: Object.keys(operation ?? {}) },
+                    applyResponse: {
+                        status: operation?.sys?.status,
+                        id: operation?.sys?.id,
+                        keys: Object.keys(operation ?? {}),
+                    },
                 });
             }
             catch (err) {
                 process.stderr.write(`[eds] log write failed: ${err instanceof Error ? err.message : String(err)}\n`);
             }
-            update({ pushProgress: `Queued (operation ${operation.sys.id.slice(0, 8)}...)` });
+            update({
+                pushProgress: `Queued (operation ${operation.sys.id.slice(0, 8)}...)`,
+            });
             let pollCount = 0;
             operation = await client.pollOperation(operation.sys.id, {
                 onProgress: (op) => {
@@ -633,7 +772,13 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                         update({ pushProgress: `${done}/${s.total} entities processed` });
                     }
                     try {
-                        logStep({ pollTick: { attempt: pollCount, status: op.sys.status, summary: op.summary } });
+                        logStep({
+                            pollTick: {
+                                attempt: pollCount,
+                                status: op.sys.status,
+                                summary: op.summary,
+                            },
+                        });
                     }
                     catch (err) {
                         process.stderr.write(`[eds] log write failed: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -691,7 +836,12 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
         }
         catch (e) {
             const msg = e instanceof ApiError ? e.message : e instanceof Error ? e.message : 'Push failed';
-            update({ step: 'error', errorStep: 'apply push', errorMessage: msg, errorAllowCredentialRetry: true });
+            update({
+                step: 'error',
+                errorStep: 'apply push',
+                errorMessage: msg,
+                errorAllowCredentialRetry: true,
+            });
         }
     };
     const runPrintFiles = async (extractSessionId, outDir) => {
@@ -702,7 +852,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
             printArgs.push('--session', extractSessionId);
         const r = await runCli(printArgs);
         if (r.exitCode !== 0) {
-            update({ step: 'error', errorStep: 'print components', errorMessage: r.stderr.trim() || 'Unknown error' });
+            update({
+                step: 'error',
+                errorStep: 'print components',
+                errorMessage: r.stderr.trim() || 'Unknown error',
+            });
             return;
         }
         // tokensPath is already on disk from generate-tokens step; just record it
@@ -724,7 +878,11 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                         stat(state.rawTokensPath).catch(() => null),
                     ]);
                     const sourceChanged = sourceStat ? sourceStat.mtimeMs > tokensStat.mtimeMs : false;
-                    update({ step: 'token-reuse-gate', tokensPath: existingTokensPath, tokenSourceChanged: sourceChanged });
+                    update({
+                        step: 'token-reuse-gate',
+                        tokensPath: existingTokensPath,
+                        tokenSourceChanged: sourceChanged,
+                    });
                 }
                 catch {
                     // No existing tokens — need LLM to generate
@@ -828,11 +986,15 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                 const progressDetail = p
                     ? `[${p.done}/${p.total}] ${p.current} — this can take 10–30 minutes for large libraries`
                     : `Starting up ${state.agent}... (this can take 10–30 minutes for large libraries — grab a coffee)`;
-                return (_jsx(RunningStep, { stepNumber: stepNum, totalSteps: totalSteps, title: "Generating definitions", description: `${state.acceptedCount} component${state.acceptedCount === 1 ? '' : 's'} accepted. ${state.agent} is mapping your TypeScript types to Contentful's CDF format.${hasTokens ? ' Using your design tokens for prop resolution.' : ''}`, detail: progressDetail }));
+                return (_jsx(RunningStep, { stepNumber: stepNum, totalSteps: totalSteps, title: "Generating definitions", description: `${formatAcceptanceSummary({ accepted: state.acceptedCount, autoRejected: state.autoRejectedCount })} ${state.agent} is mapping your TypeScript types to Contentful's CDF format.${hasTokens ? ' Using your design tokens for prop resolution.' : ''}`, detail: progressDetail }));
             }
             case 'review-generated-gate': {
                 const stepNum = hasTokens ? 4 : 3;
-                return (_jsx(GateStep, { successMessage: `Step ${stepNum} complete — definitions generated`, summary: `Generated definitions for ${state.generatedCount} component${state.generatedCount === 1 ? '' : 's'}.`, context: "Take a final look before pushing to Contentful. You can accept, reject, or inspect each component's generated definition.", continueLabel: "Review definitions", skipLabel: "Approve all and skip", onContinue: () => {
+                return (_jsx(GateStep, { successMessage: `Step ${stepNum} complete — definitions generated`, summary: formatGeneratedSummary({
+                        generated: state.generatedCount,
+                        renamedSlots: state.renamedSlotsCount,
+                        autoRejected: state.autoRejectedCount,
+                    }), context: "Take a final look before pushing to Contentful. You can accept, reject, or inspect each component's generated definition.", continueLabel: "Review definitions", skipLabel: "Approve all and skip", onContinue: () => {
                         update({ step: 'generate-review' });
                     }, onSkip: () => {
                         void runGenerateEdit(state.generateSessionId, state.generatedCount, true);
@@ -843,7 +1005,10 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                     return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: "red", children: "Error: no session ID \u2014 cannot load generated definitions." }) }));
                 }
                 return (_jsx(GenerateReviewStep, { extractSessionId: state.extractSessionId, onFinalize: (accepted, rejected) => {
-                        update({ generatedAcceptedCount: accepted, step: 'push-decision-gate' });
+                        update({
+                            generatedAcceptedCount: accepted,
+                            step: 'push-decision-gate',
+                        });
                         void Promise.resolve();
                         // log so orchestrator can read it
                         process.stderr.write(`Accepted: ${accepted}  Rejected: ${rejected}\n`);
@@ -905,6 +1070,13 @@ export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master'
                 const totalFailed = state.pushResult.componentTypes.failed + state.pushResult.designTokens.failed;
                 return (_jsx(DoneStep, { componentTypes: state.pushResult.componentTypes, designTokens: state.pushResult.designTokens, summary: state.pushResult.summary, spaceId: state.spaceId, environmentId: state.environmentId, onExit: () => process.exit(totalFailed > 0 ? 1 : 0) }));
             }
+            case 'preview-validation-error': {
+                return (_jsx(PreviewValidationErrorStep, { errors: state.previewValidationErrors, missingNames: state.previewValidationMissingNames, onEdit: () => {
+                        void runEditFromPreview(null);
+                    }, onSkip: () => {
+                        void runSkipValidationErrorsAndRetry(state.previewValidationErrors);
+                    }, onQuit: () => process.exit(0) }));
+            }
             case 'error':
                 return (_jsx(ErrorStep, { stepName: state.errorStep, message: state.errorMessage, onExit: () => process.exit(1), onRetryCredentials: state.errorAllowCredentialRetry ? () => update({ step: 'credentials', credentialsError: '' }) : undefined }));
         }

package/dist/src/import/tui/steps/GateStep.d.ts

@@ -9,6 +9,7 @@ type GateStepProps = {
     onSkip?: () => void;
     onQuit: () => void;
     showSkip?: boolean;
+    intent?: 'success' | 'error';
 };
-export declare function GateStep({ successMessage, summary, context, continueLabel, skipLabel, onContinue, onSkip, onQuit, showSkip, }: GateStepProps): React.ReactElement;
+export declare function GateStep({ successMessage, summary, context, continueLabel, skipLabel, onContinue, onSkip, onQuit, showSkip, intent, }: GateStepProps): React.ReactElement;
 export {};