@contentful/experience-design-system-cli 2.42.1-dev-build-35573a04.0 → 2.42.1-dev-build-62049584.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.42.1-dev-build-35573a04.0",
+  "version": "2.42.1-dev-build-62049584.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/tui/import/shared/running-step/activity-panel.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type ActivityItem } from './activity.js';
+/** A rolling log of what a long step has done, beside it on a wide terminal and under it on a narrow one. */
+export declare function ActivityPanel({ title, items }: {
+    title: string;
+    items: readonly ActivityItem[];
+}): React.ReactElement;
+/**
+ * Lays out a step with its panel: the panel goes beside the step on a wide terminal and under it on a narrow one. A step
+ * with no panel is returned exactly as it is.
+ */
+export declare function AsideLayout({ aside, children, }: {
+    aside?: React.ReactNode;
+    children: React.ReactNode;
+}): React.ReactElement;

package/dist/src/tui/import/shared/running-step/activity.d.ts

@@ -0,0 +1,26 @@
+type ActivityState = 'running' | 'done' | 'failed';
+export interface ActivityItem {
+    name: string;
+    state: ActivityState;
+    /** A short note after the name, for example "cached" or "create component". */
+    detail?: string;
+    /** How long it took, once it has finished. */
+    ms?: number;
+    /** Why it failed. */
+    error?: string;
+    /** When it started, so its time can be worked out when it finishes. */
+    startedAt?: number;
+}
+export declare const PANEL_COLUMNS = 46;
+export declare function panelLayout(columns: number): 'beside' | 'below';
+/**
+ * The entries that fit. A long run has far more entries than lines, and what a person needs is the failures and what is
+ * running now, so those are kept first and the newest finished entries fill what is left. The entries stay in the order
+ * they happened. `hidden` is how many were left out.
+ */
+export declare function visibleActivity(items: readonly ActivityItem[], max: number): {
+    shown: ActivityItem[];
+    hidden: number;
+};
+export declare function truncate(text: string, max: number): string;
+export {};

package/dist/src/tui/import/shared/running-step/logic.d.ts

@@ -5,7 +5,23 @@ export interface Progress {
 export interface RunningLine {
     text: string;
     complete?: boolean;
+    /** Set for a row that ended badly. A warning carries on without it; a failure does not. Otherwise `complete` decides. */
+    state?: 'warning' | 'failed';
     progress?: Progress;
+    /** How long the row took, once it has finished. */
+    ms?: number;
 }
+export type LineState = 'running' | 'done' | 'warning' | 'failed';
+/** What a row looks like. A row that ended badly is never shown as running or as done. */
+export declare function lineState(line: RunningLine): LineState;
+export declare function formatDuration(ms: number): string;
+/**
+ * How long each row took, by position, for the rows that have finished. A row's time is how long the run had been going
+ * when it was first seen finished, and it does not change after that. Rows keep their position for the whole run, so a row
+ * that appears later is added at the end.
+ */
+export declare function trackFinished(previous: ReadonlyArray<number | undefined>, rows: readonly RunningLine[], elapsedMs: number): Array<number | undefined>;
+/** The rows with the time each finished row took, by position. */
+export declare function withTimes(rows: RunningLine[], rowMs: ReadonlyArray<number | undefined>): RunningLine[];
 export declare function progressPercent(progress: Progress): number;
 export declare function formatElapsed(totalSeconds: number): string;

package/dist/src/tui/import/shared/running-step/running-step.d.ts

@@ -5,6 +5,8 @@ interface RunningStepProps {
     step: ImportStepId;
     description: string;
     lines?: readonly RunningLine[];
+    /** A panel shown beside the step, or under it on a narrow terminal. */
+    aside?: React.ReactNode;
 }
-export declare function RunningStep({ step, description, lines, }: RunningStepProps): React.ReactElement;
+export declare function RunningStep({ step, description, lines, aside, }: RunningStepProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/06-extraction/logic.d.ts

@@ -1,4 +1,5 @@
 import type { ExtractAndComposeProgress } from '@contentful/experience-design-system-backend-pipeline';
+import { type RunningLine } from '../../shared/running-step/logic.js';
 import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
 /** Structured progress events emitted by the orchestrator (extraction + composition). */
 export type ProgressEvent = ExtractAndComposeProgress;
@@ -24,11 +25,11 @@ export declare function initialProgress(input: {
     hasRawTokens: boolean;
 }): ExtractionProgress;
 export declare function applyProgressEvent(progress: ExtractionProgress, event: ProgressEvent): ExtractionProgress;
-/** The rows the screen shows, in the order the wizard showed them. Rows that do not apply are left out. */
-export declare function progressRows(progress: ExtractionProgress, agent: string): Array<{
-    text: string;
-    complete: boolean;
-}>;
+/**
+ * The rows the screen shows, in the order the wizard showed them. Rows that do not apply are left out. `rowMs` is how long
+ * each finished row took, by position (see `trackFinished`).
+ */
+export declare function progressRows(progress: ExtractionProgress, agent: string, rowMs?: ReadonlyArray<number | undefined>): RunningLine[];
 /** True when every job is already done, so the screen would only flash. The wizard shows nothing in this case. */
 export declare function isFullCacheHit(progress: ExtractionProgress): boolean;
 export declare function noComponentsMessage(projectPath: string): string;

package/dist/src/tui/import/steps/06-extraction/screen.d.ts

@@ -3,6 +3,8 @@ import type { ExtractionProgress } from './types.js';
 interface ExtractionScreenProps {
     progress: ExtractionProgress;
     agent: string;
+    /** How long each finished row took, by position. */
+    rowMs?: ReadonlyArray<number | undefined>;
 }
-export declare function ExtractionScreen({ progress, agent }: ExtractionScreenProps): React.ReactElement;
+export declare function ExtractionScreen({ progress, agent, rowMs }: ExtractionScreenProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/06-extraction/use-extraction.d.ts

@@ -2,6 +2,7 @@ import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './ty
 export type ExtractionState = {
     status: 'running';
     progress: ExtractionProgress;
+    rowMs: Array<number | undefined>;
 } | {
     status: 'done';
     result: ExtractionResult;

package/dist/src/tui/import/steps/08-generation/logic.d.ts

@@ -1,3 +1,6 @@
+import type { GenerateComponentsProgress } from '@contentful/experience-design-system-backend-pipeline';
+import { type ActivityItem } from '../../shared/running-step/activity.js';
+import { type RunningLine } from '../../shared/running-step/logic.js';
 import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
 /** What the debug log says the stage started with. The counts are logged, not the lists of names. */
 export declare function generationLogInputs(input: GenerationInput): Record<string, unknown>;
@@ -7,6 +10,11 @@ export declare function generationLogOutputs(result: GenerationResult, progress:
     status: 'success' | 'error';
 };
 export declare function initialProgress(): GenerationProgress;
+/**
+ * The panel's entries after one more event. Each component has one entry, in the order they began: it is running from
+ * when it starts, then done, cached or failed. A component the pipeline starts again for a retry keeps its entry.
+ */
+export declare function applyActivityEvent(event: GenerateComponentsProgress, previous: readonly ActivityItem[], now: number): ActivityItem[];
 export declare function shouldRunMapTokens(counts: {
     mappablePropCount: number;
     rawTokenCount: number;
@@ -20,11 +28,5 @@ export declare function describeGeneration(input: {
     agent: string;
     hasTokens: boolean;
 }): string;
-export declare function progressRows(progress: GenerationProgress, agent: string): Array<{
-    text: string;
-    complete: boolean;
-    progress?: {
-        done: number;
-        total: number;
-    };
-}>;
+/** `rowMs` is how long each finished row took, by position (see `trackFinished`). */
+export declare function progressRows(progress: GenerationProgress, agent: string, rowMs?: ReadonlyArray<number | undefined>): RunningLine[];

package/dist/src/tui/import/steps/08-generation/screen.d.ts

@@ -5,6 +5,8 @@ interface GenerationScreenProps {
     agent: string;
     acceptedCount: number;
     hasTokens: boolean;
+    /** How long each finished row took, by position. */
+    rowMs?: ReadonlyArray<number | undefined>;
 }
-export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, }: GenerationScreenProps): React.ReactElement;
+export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, rowMs, }: GenerationScreenProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/08-generation/types.d.ts

@@ -1,4 +1,5 @@
 import type { GenerationHandoff } from '@contentful/experience-design-system-types/handoff';
+import type { ActivityItem } from '../../shared/running-step/activity.js';
 export interface GenerationInput {
     /** The extraction session the scope was decided on. */
     sessionId: string;
@@ -26,12 +27,18 @@ export interface GenerationInput {
 }
 /** One line per thing the screen shows, in the order it shows them. */
 export interface GenerationProgress {
-    /** Components finished, out of the total, and the one being worked on. Null until the first progress line. */
+    /**
+     * Components finished, out of the total, and the one being worked on. `failed` counts the finished ones that failed: the
+     * run carries on through the rest and only fails at the end. Null until the first progress line.
+     */
     components: {
         done: number;
         total: number;
         current: string;
+        failed: number;
     } | null;
+    /** One entry for each component the run has started, in the order they began. Feeds the activity panel. */
+    activity: ActivityItem[];
     mapTokens: 'idle' | 'running' | 'complete';
     /** Whether token mapping will run at all; unknown until the generated components have been looked at. */
     mapTokensEligible: boolean | null;

package/dist/src/tui/import/steps/08-generation/use-generation.d.ts

@@ -2,6 +2,7 @@ import type { GenerationInput, GenerationProgress, GenerationResult } from './ty
 export type GenerationState = {
     status: 'running';
     progress: GenerationProgress;
+    rowMs: Array<number | undefined>;
 } | {
     status: 'done';
     result: GenerationResult;

package/dist/src/tui/import/steps/10-flow/support/push-progress.d.ts

@@ -1,3 +1,4 @@
+import type { ActivityItem } from '../../../shared/running-step/activity.js';
 export type PushProgress = {
     kind: 'queued';
     operationId: string;
@@ -5,5 +6,24 @@ export type PushProgress = {
     kind: 'progress';
     processed: number;
     total: number;
+    failed: number;
     current: string | null;
+    items: ActivityItem[];
 } | null;
+/** What the API reports for one entity in the push. */
+interface OperationItem {
+    entityType: string;
+    action: string;
+    id: string;
+    status: string;
+    /** The API gives the reason as an object with a message, or as plain text. */
+    error?: string | {
+        message: string;
+    };
+}
+/**
+ * The panel's entries for the entities the push has processed so far. An entity still waiting in the queue is left out,
+ * so the panel shows what has happened and not a list of everything that is yet to.
+ */
+export declare function activityFromItems(items: readonly OperationItem[]): ActivityItem[];
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.42.1-dev-build-35573a04.0",
+  "version": "2.42.1-dev-build-62049584.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -45,7 +45,7 @@
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
     "zod": "^4.6.5",
-    "@contentful/experience-design-system-types": "2.42.1-dev-build-35573a04.0"
+    "@contentful/experience-design-system-types": "2.42.1-dev-build-62049584.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",
@@ -59,7 +59,7 @@
     "ink-testing-library": "^4.0.0",
     "typescript-eslint": "^8.67.0",
     "vitest": "^4.0.16",
-    "@contentful/experience-design-system-backend-pipeline": "2.42.1-dev-build-35573a04.0"
+    "@contentful/experience-design-system-backend-pipeline": "2.42.1-dev-build-62049584.0"
   },
   "repository": {
     "type": "git",