@contentful/experience-design-system-cli 2.41.1-dev-build-699ca2d9.0 → 2.41.1-dev-build-06624ee7.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.41.1-dev-build-699ca2d9.0",
+  "version": "2.41.1-dev-build-06624ee7.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/tui/debug-store.d.ts

@@ -24,6 +24,8 @@ export declare function startDebugRun({ flow, step, menuOption, inputs, }: {
     menuOption: string;
     inputs: Record<string, unknown>;
 }): void;
+/** Keeps what the open run has so far, in memory. It is only written if the run is cut short. */
+export declare function setDebugRunProgress(outputs: Record<string, unknown>): void;
 export declare function finishDebugRun({ outputs, status, exitMethod, }: {
     outputs: Record<string, unknown>;
     status: Status;

package/dist/src/tui/import/steps/04-credentials/logic.d.ts

@@ -7,6 +7,28 @@ export type CredentialValues = Record<CredentialField, string>;
  */
 export declare function credentialsPurpose(tokensOnly: boolean): string;
 export declare function normalize(values: CredentialValues): CredentialValues;
-export declare function missingField(values: CredentialValues): boolean;
+/** The required fields that are still empty, by name. */
+export declare function missingFields(values: CredentialValues): CredentialField[];
 export declare function isUnchanged(current: CredentialValues, initial: CredentialValues): boolean;
+export type CredentialAttempt = {
+    host: string;
+    reason: string;
+};
+/**
+ * One rejected attempt as the log records it. The reason is scrubbed of the token first: an API error can echo what it
+ * was sent, so the message the user saw may contain it.
+ */
+export declare function rejectedAttempt(reason: string, credentials: CredentialValues): CredentialAttempt;
+/**
+ * The credentials as the log shows them. `cma_token` is the only key the token may be under: the logger reduces it to
+ * "present, N chars", which is enough to spot a truncated paste without writing the secret.
+ */
+export declare function credentialsLog(credentials: CredentialValues): Record<string, unknown>;
+/** The log's outputs: where the user ended up, the credentials, which fields they changed (names only), and the rejections. */
+export declare function credentialsOutputs({ outcome, credentials, initial, attempts, }: {
+    outcome: 'validated' | 'back';
+    credentials: CredentialValues;
+    initial: CredentialValues;
+    attempts: readonly CredentialAttempt[];
+}): Record<string, unknown>;
 export {};

package/dist/src/tui/import/steps/04-credentials/screen.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { ImportTarget } from '../00-preflight/logic.js';
 import { type CredentialValues } from './logic.js';
 import { type ValidationResult } from './validate.js';
 export type CredentialsResult = {
@@ -8,6 +9,8 @@ export type CredentialsResult = {
     skipped: true;
 };
 interface CredentialsScreenProps {
+    /** What the user chose to import at Preflight; it decides which steps run, so every log notes it. */
+    mode: ImportTarget;
     onDone: (result: CredentialsResult) => void;
     onBack: () => void;
     initial?: Partial<CredentialValues>;
@@ -15,5 +18,5 @@ interface CredentialsScreenProps {
     /** The import only generates tokens, so there are no components to look up in the space. */
     tokensOnly?: boolean;
 }
-export declare function CredentialsScreen({ onDone, onBack, initial, validate, tokensOnly, }: CredentialsScreenProps): React.ReactElement;
+export declare function CredentialsScreen({ mode, onDone, onBack, initial, validate, tokensOnly, }: CredentialsScreenProps): React.ReactElement;
 export {};

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

@@ -1,7 +1,20 @@
 import type { ExtractAndComposeProgress } from '@contentful/experience-design-system-backend-pipeline';
-import type { ExtractionProgress } from './types.js';
+import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
 /** Structured progress events emitted by the orchestrator (extraction + composition). */
 export type ProgressEvent = ExtractAndComposeProgress;
+/**
+ * What the debug log says the stage started with. The credentials come with the input, so the CMA token is only ever put
+ * under `cma_token`, which the logger reduces to "present, N chars" (or "not set" when the credentials were skipped).
+ */
+export declare function extractionLogInputs(input: ExtractionInput): Record<string, unknown>;
+/**
+ * How the stage ended. A failure names the step that failed and its message, scrubbed of the CMA token; the last progress
+ * says which of the parallel jobs had finished, failed or was still running.
+ */
+export declare function extractionLogOutputs(result: ExtractionResult, progress: ExtractionProgress | undefined, cmaToken: string): {
+    outputs: Record<string, unknown>;
+    status: 'success' | 'error';
+};
 /**
  * Every job the stage will run starts on the first frame, so no row appears later as a surprise. A job that does not
  * apply stays 'idle' and has no row: existing entities need credentials, and token definitions need a raw tokens file.

package/dist/src/tui/import/steps/07-scope-gate/log.d.ts

@@ -0,0 +1,8 @@
+import type { ScopeComponent, ScopeDecisions } from './types.js';
+/** What the gate starts with: how many components, and what the AI suggested for them. */
+export declare function scopeGateLogInputs(components: ScopeComponent[], tokenCount: number): Record<string, unknown>;
+/**
+ * What the user decided. Everything not accepted counts as rejected, so a component the AI accepted and the user never
+ * touched shows as left out. Components with the same name share one decision, so names are counted once.
+ */
+export declare function scopeGateLogOutputs(components: ScopeComponent[], decisions: ScopeDecisions): Record<string, unknown>;

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

@@ -1,4 +1,11 @@
-import type { GenerationProgress } from './types.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>;
+/** How the stage ended. A failure names the step that failed (save decisions, generate components, map tokens). */
+export declare function generationLogOutputs(result: GenerationResult, progress: GenerationProgress | undefined): {
+    outputs: Record<string, unknown>;
+    status: 'success' | 'error';
+};
 export declare function initialProgress(): GenerationProgress;
 export declare function shouldRunMapTokens(counts: {
     mappablePropCount: number;

package/dist/src/tui/import/steps/09-review/review-log.d.ts

@@ -0,0 +1,31 @@
+import type { CdfReviewEntry, ReviewComponentStatus } from './types.js';
+export declare const REVIEW_RUN: {
+    readonly flow: "import/review";
+    readonly step: "09-review";
+    readonly menuOption: "Review";
+};
+export type ReviewTrail = {
+    startedAt: number;
+    /** How each component arrived, by key. */
+    start: Map<string, ReviewComponentStatus>;
+    /** The edits in order, as the history labels them (for example `edit-save` or `token-review:size`). */
+    actions: string[];
+    /** The same edits counted by kind, so a long session still reads at a glance. */
+    kinds: Record<string, number>;
+};
+/** What the review starts with: how many components, and how the AI and the checks left them. */
+export declare function reviewInputs(components: CdfReviewEntry[]): Record<string, unknown>;
+export declare function openReviewTrail(components: CdfReviewEntry[], now: number): ReviewTrail;
+export declare function recordReviewAction(trail: ReviewTrail, label: string): void;
+/** What a crash or Ctrl+C writes if it cuts the review short. */
+export declare function reviewProgress(trail: ReviewTrail, components: CdfReviewEntry[], now: number): Record<string, unknown>;
+/** How the review ended. `final` is the count the user confirmed, or undefined when the review was left without finishing. */
+export declare function reviewFinish(trail: ReviewTrail, components: CdfReviewEntry[], now: number, final: {
+    accepted: number;
+    rejected: number;
+    unresolved: number;
+} | undefined): {
+    outputs: Record<string, unknown>;
+    status: 'success';
+    exitMethod: 'saved' | 'discarded';
+};

package/dist/src/tui/import/steps/09-review/use-review-log.d.ts

@@ -0,0 +1,20 @@
+import type { CdfReviewEntry } from './types.js';
+type Counts = {
+    accepted: number;
+    rejected: number;
+    unresolved: number;
+};
+/**
+ * Writes one debug log for a visit to the Review. It starts once the components are loaded, grows in memory as the user
+ * edits, and is written when they finalize or leave. The trail is also handed to the logger as it grows, so a crash or
+ * Ctrl+C writes what happened so far. Going back to the review later is a new visit and a new log.
+ */
+export declare function useReviewLog({ loading, loadError, components, }: {
+    loading: boolean;
+    loadError: string | null | undefined;
+    components: CdfReviewEntry[];
+}): {
+    record: (label: string) => void;
+    finish: (counts: Counts) => void;
+};
+export {};

package/dist/src/tui/import/steps/09-review/use-review-session.d.ts

@@ -31,8 +31,10 @@ type UseReviewHistoryOptions = {
     components: CdfReviewEntry[];
     createSnapshot: (components: CdfReviewEntry[]) => HistorySnapshot;
     applySnapshot: (snapshot: HistorySnapshot) => void;
+    /** Told what each edit was called, and about each undo and redo, so the debug log can follow the session. */
+    onAction?: (label: string) => void;
 };
-export declare function useReviewHistory({ loading, components, createSnapshot, applySnapshot }: UseReviewHistoryOptions): {
+export declare function useReviewHistory({ loading, components, createSnapshot, applySnapshot, onAction, }: UseReviewHistoryOptions): {
     historySeededRef: {
         current: boolean;
     };

package/dist/src/tui/import/steps/10-flow/flow/flow-log.d.ts

@@ -0,0 +1,46 @@
+import type { FlowState } from './types.js';
+type FlowStep = FlowState['step'];
+/** Where the log goes: one folder for the whole step, numbered so it sorts after the earlier steps. */
+export declare const FLOW_RUN: {
+    readonly flow: "import/publish";
+    readonly step: "10-publish";
+    readonly menuOption: "Publish";
+};
+export type FlowTrail = {
+    startedAt: number;
+    stageStartedAt: number;
+    /** The step the flow is in now. */
+    at: FlowStep;
+    stages: string[];
+    preview?: Record<string, unknown>;
+    push?: Record<string, unknown>;
+    pushFailed?: boolean;
+    saved?: {
+        path: string;
+        run_id: string | null;
+    };
+    failure?: {
+        step: string;
+        message: string;
+    };
+    validation?: Record<string, unknown>;
+};
+/** What the run starts with, stated once. The token is only ever under `cma_token`, which the logger reduces to "present, N chars". */
+export declare function flowContext(state: FlowState): Record<string, unknown>;
+/** Starts the trail at the state the run began in. */
+export declare function openTrail(state: FlowState, now: number): FlowTrail;
+/** Adds what happened when the flow moved from one step to the next. */
+export declare function advance(trail: FlowTrail, from: FlowState, to: FlowState, now: number): FlowTrail;
+export declare const isFlowFinished: (step: FlowStep) => boolean;
+/** What a crash or Ctrl+C writes if it cuts the run short. */
+export declare function flowProgress(trail: FlowTrail, now: number): Record<string, unknown>;
+/**
+ * How the run ended. `final` is the state it ended in, or undefined when the import was left while the run was open. The
+ * outcome names the cause, so a failed push or preview says why in the first line of its own log.
+ */
+export declare function flowFinish(trail: FlowTrail, final: FlowState | undefined, now: number): {
+    outputs: Record<string, unknown>;
+    status: 'success' | 'error';
+    exitMethod: 'saved' | 'discarded';
+};
+export {};

package/dist/src/tui/import/steps/10-flow/flow/use-flow-log.d.ts

@@ -0,0 +1,7 @@
+import type { FlowState } from './types.js';
+/**
+ * Writes one debug log for the flow after the review. The trail grows in memory as the step changes; the log is written
+ * when the flow reaches done or an error, goes back to the review, or when the import is left. The trail is also handed to
+ * the logger as it grows, so a crash or Ctrl+C writes what happened so far. The review is its own step with its own log.
+ */
+export declare function useFlowLog(state: FlowState): void;

package/dist/src/tui/settings/configuration/agents/agent-debug.d.ts

@@ -1,5 +1,5 @@
 import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
-import type { Snapshot } from '../../shared/debug-trail.js';
+import type { Snapshot } from '@tui/shared/debug-trail.js';
 import type { AgentConfig } from './agent-store.js';
 /**
  * The agent settings as flat text, for `diffSnapshots`: `default_agent`, then `<agent>.model` and `<agent>.binary` for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.41.1-dev-build-699ca2d9.0",
+  "version": "2.41.1-dev-build-06624ee7.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.41.1-dev-build-699ca2d9.0"
+    "@contentful/experience-design-system-types": "2.41.1-dev-build-06624ee7.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.41.1-dev-build-699ca2d9.0"
+    "@contentful/experience-design-system-backend-pipeline": "2.41.1-dev-build-06624ee7.0"
   },
   "repository": {
     "type": "git",