@contentful/experience-design-system-cli 2.38.1-dev-build-6d903339.0 → 2.38.1-dev-build-962dbe22.0

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

@@ -1,22 +1,18 @@
 import type { GenerationProgress } from './types.js';
 export declare function initialProgress(): GenerationProgress;
-/** Token mapping runs only when there is something to map and tokens to map it from. */
 export declare function shouldRunMapTokens(counts: {
     mappablePropCount: number;
     rawTokenCount: number;
 }): boolean;
-/** "5 components accepted." or, with some left out, "5 components accepted, 2 excluded due to validation errors." */
 export declare function formatAcceptanceSummary(counts: {
     accepted: number;
     autoRejected: number;
 }): string;
-/** The screen's description: what was accepted, what is happening to it, and whether the tokens are used. */
 export declare function describeGeneration(input: {
     acceptedCount: number;
     agent: string;
     hasTokens: boolean;
 }): string;
-/** The rows the generating screen shows for this progress. */
 export declare function progressRows(progress: GenerationProgress, agent: string): Array<{
     text: string;
     complete: boolean;

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

@@ -9,14 +9,4 @@ export interface GenerationDeps {
     runMapTokens: typeof runMapTokens;
     prepareMapTokens: typeof prepareMapTokens;
 }
-/**
- * The whole stage, in the order the wizard ran it:
- *  1. Wait for the cache check that ran while the scope gate was open, then save the decisions. Both write to the
- *     pipeline database and the cache has to be restored first. With nothing accepted the stage ends here.
- *  2. Generate the accepted components in-process. The orchestrator handles per-component cache lookup, so the names
- *     from the cache check are forwarded as `precomputedCachedNames` to skip a redundant lookup.
- *  3. Map tokens onto the generated session. Skipped when there is nothing to map.
- * A failed token mapping after a successful generation is an error to show. It neither retries nor throws away what was
- * generated.
- */
 export declare function runGeneration(input: GenerationInput, onProgress: (progress: GenerationProgress) => void, deps?: GenerationDeps): Promise<GenerationResult>;

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

@@ -5,8 +5,6 @@ interface GenerationScreenProps {
     agent: string;
     acceptedCount: number;
     hasTokens: boolean;
-    stepNumber: number;
-    totalSteps: number;
 }
-export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, stepNumber, totalSteps, }: GenerationScreenProps): React.ReactElement;
+export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, }: GenerationScreenProps): React.ReactElement;
 export {};

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

@@ -1,5 +1,5 @@
 import React from 'react';
-import { findSlotCycles, type ComponentSlotInfo } from '../../07-scope-gate/graph/cycle-detection.js';
+import { type ComponentSlotInfo } from '../../07-scope-gate/graph/cycle-detection.js';
 type PropMetadata = {
     rationale?: string | null;
     sourceStartLine?: number | null;
@@ -46,22 +46,5 @@ export type FieldEditorProps = {
     header?: React.ReactNode;
     headerHeight?: number;
 };
-export declare function simulateGraphWithCandidate(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, candidate: string): ComponentSlotInfo[];
-export declare function introducesNewCycle(before: ReturnType<typeof findSlotCycles>, next: ReturnType<typeof findSlotCycles>): boolean;
-export declare function computeAllowedComponentCandidates(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string): string[];
-export declare function simulateGraphWithReplacement(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, replaceIndex: number, candidate: string): ComponentSlotInfo[];
-export declare function computeAllowedComponentReplacementCandidates(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
-    name: string;
-    allowedComponents: string[];
-}[], targetSlotName: string, replaceIndex: number): string[];
 export declare function FieldEditor({ value, width, height, fixedHeight, active, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, propRationaleKey, onToggleComponentRationale, componentRationaleKey, onToggleSourceExternal, onTextEntryActiveChange, projectSlotGraph, currentComponentName, onDirtyChange, discardTrigger, initialFocusTarget, showHiddenProps, showInlineRationales, header, headerHeight, }: FieldEditorProps): React.ReactElement;
 export {};

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

@@ -1,21 +1,7 @@
 import React from 'react';
-import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
 import type { UseFinalizePreviewReturn } from '../use-finalize-preview.js';
 import type { UseReviewSurfaceStateResult } from '../use-review-surface-state.js';
 import { type ReviewStatusEntry } from './ReviewStatus.js';
-export type ReviewFinalizeDialogsProps = {
-    showFinalize: boolean;
-    showQuit: boolean;
-    components: ReadonlyArray<ReviewStatusEntry>;
-    removed?: ComponentTypeSummary[];
-    previewStatus?: 'idle' | 'running' | 'done' | 'error';
-    removedScrollOffset?: number;
-    onFinalizeConfirm: () => void;
-    onFinalizeCancel: () => void;
-    onQuitConfirm: () => void;
-    onQuitCancel: () => void;
-};
-export declare function ReviewFinalizeDialogs({ showFinalize, showQuit, components, removed, previewStatus, removedScrollOffset, onFinalizeConfirm, onFinalizeCancel, onQuitConfirm, onQuitCancel, }: ReviewFinalizeDialogsProps): React.ReactElement;
 export declare function ReviewStepDialogs({ surfaceState, components, finalizePreview, onFinalize, onQuit, }: {
     surfaceState: UseReviewSurfaceStateResult;
     components: ReadonlyArray<ReviewStatusEntry>;

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

@@ -1,21 +1,15 @@
 import React from 'react';
-import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
 export type TokenPropSuggestion = {
     propName: string;
     paths: string[];
     suggested: string[];
     allowed: string[];
 };
-export type TokenReviewToken = {
-    path: string;
-    kind: string;
-};
 /**
  * Design-token props on `entry` with a declared token kind. `paths` is the
  * full compatible token universe when a token catalog is available; `allowed`
  * remains the current subset.
  */
-export declare function collectTokenSuggestions(entry: CDFComponentEntry, availableTokens?: TokenReviewToken[]): TokenPropSuggestion[];
 export type TokenReviewPanelProps = {
     componentName: string;
     suggestions: TokenPropSuggestion[];

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

@@ -1,5 +1,4 @@
 import React from 'react';
-import type { BreakingChange, CDFComponentEntry, ComponentTypeSummary, DownstreamImpact, ServerPreviewResponse } from '@contentful/experience-design-system-types';
 type GenerateReviewStepProps = {
     extractSessionId: string | null;
     tokenSessionId?: string | null;
@@ -13,25 +12,5 @@ type GenerateReviewStepProps = {
     tokensPath?: string;
     initialFinalizeError?: string | null;
 };
-export declare function sortComponentsForSidebar<T extends {
-    key: string;
-    entry: CDFComponentEntry;
-}>(components: T[], cycleParticipants?: Set<string>): T[];
-export { computeCycleAutoRejectTargets } from './graph/cycle-auto-reject.js';
-export interface BreakingComponent {
-    componentName: string;
-    changes: BreakingChange[];
-    impact?: DownstreamImpact;
-    current?: ComponentTypeSummary;
-}
-export interface BreakingRow {
-    label: string;
-    componentName: string;
-    focusTarget?: {
-        kind: 'prop' | 'slot';
-        name: string;
-    };
-}
-export declare function buildBreakingRows(breakingChanges: BreakingComponent[]): BreakingRow[];
-export declare function deriveBreakingChanges(response: ServerPreviewResponse): BreakingComponent[];
 export declare function GenerateReviewStep(props: GenerateReviewStepProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/09-review/helpers/cycle-panel-scroll.d.ts

@@ -1,8 +1,4 @@
-export declare const CYCLE_PANEL_PREAMBLE_LINES = 4;
 export interface CyclePanelLineCountable {
     suggestedBreak?: unknown;
 }
-export declare function cycleLineCount(cycle: CyclePanelLineCountable): number;
-export declare function cycleLineOffsets(cycles: readonly CyclePanelLineCountable[], preamble?: number): number[];
-export declare function totalCyclePanelLines(cycles: readonly CyclePanelLineCountable[], preamble?: number): number;
 export declare function followCycleScroll(currentScroll: number, cursorIdx: number, cycles: readonly CyclePanelLineCountable[], panelHeight: number, preamble?: number): number;

package/dist/src/tui/import/steps/09-review/run-live-preview.d.ts

@@ -1,7 +1,4 @@
 import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
-export declare class TimeoutError extends Error {
-    constructor(message?: string);
-}
 export type LivePreviewResult = {
     generation: number;
     response: ServerPreviewResponse | null;

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

@@ -1,6 +1,6 @@
 import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
 type FinalizePreviewStatus = 'idle' | 'running' | 'done' | 'error';
-export type UseFinalizePreviewOptions = {
+type UseFinalizePreviewOptions = {
     /** True while the Finalize dialog is open. Toggling true (re)fires the preview. */
     open: boolean;
     extractSessionId: string | null;
@@ -26,14 +26,4 @@ export type UseReviewFinalizePreviewOptions = Omit<UseFinalizePreviewOptions, 'a
     }>;
 };
 export declare function useReviewFinalizePreview({ components, ...options }: UseReviewFinalizePreviewOptions): UseFinalizePreviewReturn;
-/**
- * Shared Finalize-dialog preview, used by both the composite and atomic
- * generate-review steps.
- *
- * When the dialog opens it fires a preview scoped to the ACCEPTED set (so the
- * result reflects exactly what the push does, independent of the session's
- * not-yet-reclassified generated rows), tracks loading/error, and owns the
- * scroll offset for the preview list.
- */
-export declare function useFinalizePreview(opts: UseFinalizePreviewOptions): UseFinalizePreviewReturn;
 export {};

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

@@ -17,5 +17,6 @@ export declare function buildFlowStart(input: {
     handoff: ImportHandoff;
     saved?: SavedCredentials;
     generatePromptPath?: string;
+    tokensOnly?: FlowStart['tokensOnly'];
 }): FlowStart;
 export {};

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

@@ -1,9 +1,8 @@
-import { type PreviewValidationError } from '@contentful/experience-design-system-backend-pipeline';
 import type { ImportHandoff } from '@contentful/experience-design-system-types/handoff';
 import { type PreviewDeps } from './preview.js';
 import { type PushDeps } from './push.js';
 import { type SaveDeps } from './save.js';
-import { type FlowPatch, type FlowState } from './types.js';
+import { type FlowState } from './types.js';
 /** What the flow starts from: what the earlier stages produced, and the user's saved settings. */
 export interface FlowStart {
     handoff: ImportHandoff;
@@ -18,6 +17,13 @@ export interface FlowStart {
         cmaToken: string;
         host: string;
     };
+    /** Set when the import only generates tokens: there is no extraction or generation, so the flow starts at saving. */
+    tokensOnly?: {
+        tokensPath: string;
+        tokenSessionId: string | null;
+        tokenCount: number;
+        outDir: string;
+    };
     /** A custom prompt for `generate components`, shown as a warning above every step. */
     generatePromptPath?: string;
 }
@@ -38,15 +44,15 @@ export interface FlowDeps {
     /** Writes one line of the wizard's step log. */
     log: (entry: Record<string, unknown>) => void;
     stderr: (text: string) => void;
+    /**
+     * Called when the step is about to change, before anything is told about the new one. The host clears the terminal
+     * here so the next screen is drawn on a clean one. It has to be before: Ink paints as soon as it is told, and a clear
+     * after the paint wipes a static screen like the done step, which nothing draws again.
+     */
+    beforeStepChange?: () => void;
 }
 export declare function startWizardLog(): void;
 export declare function realFlowDeps(): FlowDeps;
-/** The state the flow begins in, from what the earlier stages handed over. */
-export declare function initialFlowState(start: FlowStart): FlowState;
-/** What the log gets: the state change without the token, the document, or the whole of a large server response. */
-export declare function sanitizeForLog(partial: FlowPatch): Record<string, unknown>;
-/** The names of the components the errors are about, once each. */
-export declare function namesToSkip(errors: readonly PreviewValidationError[]): string[];
 export interface FlowController {
     getState(): FlowState;
     subscribe(listener: () => void): () => void;

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

@@ -1,9 +1,11 @@
 import type { DatabaseSync } from 'node:sqlite';
-import { ApiError, patchReviewStateWithValidationErrors, type PreviewValidationError } from '@contentful/experience-design-system-backend-pipeline';
+import { patchReviewStateWithValidationErrors } from '@contentful/experience-design-system-backend-pipeline';
 import { type CDFDocument, type DTCGTokenEntry, type ServerPreviewResponse } from '@contentful/experience-design-system-types';
 import type { FlowPatch, FlowState } from './types.js';
 type PreviewClient = {
     previewImport(cdf: CDFDocument): Promise<ServerPreviewResponse>;
+    /** Request id of the most recent response, used by `recordContentfulContext` for analytics correlation. */
+    getLastRequestId(): string | undefined;
 };
 /** The outside world `runPreview` talks to, so each branch can be tested without a database or a network. */
 export interface PreviewDeps {
@@ -30,20 +32,6 @@ export interface RunPreviewInput {
     /** Set when nothing was accepted, so the document is present but empty and the server shows what would be deleted. */
     deleteAll: boolean;
 }
-/** What to do with a 422 from the preview: show the components that failed, or fall through to the generic error. */
-type Preview422Outcome = {
-    kind: 'validation-error';
-    errors: PreviewValidationError[];
-    missingNames: string[];
-} | {
-    kind: 'unparseable';
-    message: string;
-} | {
-    kind: 'not-422';
-};
-export declare function handlePreview422(err: ApiError, extractSessionId: string | null, patchFn: PreviewDeps['patchReviewState']): Promise<Preview422Outcome>;
-/** The patch to spread into any update that leaves the validation error step, so stale errors do not linger. */
-export declare function clearedValidationErrorState(): Pick<FlowState, 'previewValidationErrors' | 'previewValidationMissingNames'>;
 /**
  * Loads what would be pushed and asks the server what that would change. Returns the patch the wizard applied: the
  * preview gate, a terminal "done" when nothing would change, the validation error step for a 422, or an error.

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

@@ -8,6 +8,8 @@ type PushClient = {
     pollOperation(operationId: string, options: {
         onProgress?: (operation: ApplyOperationResponse) => void;
     }): Promise<ApplyOperationResponse>;
+    /** Request id of the most recent response, used by `recordApplyOutcome` for analytics correlation. */
+    getLastRequestId(): string | undefined;
 };
 /** The outside world `runPush` talks to, so each branch can be tested without a network or a run history. */
 export interface PushDeps {

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

@@ -1,16 +1,7 @@
 import type { DatabaseSync } from 'node:sqlite';
 import { appendRun, buildSourceFingerprint } from '@contentful/experience-design-system-backend-pipeline';
-import { type CDFComponentEntry, type CDFDocument, type DTCGTokenEntry } from '@contentful/experience-design-system-types';
+import { type DTCGTokenEntry } from '@contentful/experience-design-system-types';
 import type { FlowPatch, FlowState } from './types.js';
-/** How long the confirmation of a written file stays up before the flow moves on to the preview. */
-export declare const SAVE_CONFIRMATION_DELAY_MS = 1000;
-/** The document written to `components.json`: the components and tokens as one schema-valid CDF. */
-export declare function buildSavedCDF(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>, tokens: DTCGTokenEntry[], opts?: {
-    deleteAll?: boolean;
-}): CDFDocument;
 /** The outside world saving talks to, so each branch can be tested without a disk, a database or a clock. */
 export interface SaveDeps {
     openDb: () => DatabaseSync;

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

@@ -9,9 +9,5 @@ interface FlowScreenProps {
     /** Leaves the import with the exit code the wizard would have exited with. */
     onExit: (exitCode: number) => void;
 }
-/** How many steps the import has, as the wizard counted them. */
-export declare function totalStepsFor(state: Pick<FlowState, 'tokensPath' | 'rawTokensPath' | 'mapTokensEligible'>): number;
-/** Whether the preview gate offers "[e] Edit definitions": only when the document has components to edit. */
-export declare function canEditFromPreview(cdf: FlowState['cdf']): boolean;
 export declare function FlowScreen({ state, controller, livePreview, generatePromptPath, onExit, }: FlowScreenProps): React.ReactElement;
 export {};

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

@@ -3,7 +3,10 @@ import { type FlowController, type FlowDeps, type FlowStart } from './controller
  * The flow for a start, once. `start` is undefined until the generation stage has finished, so the hook can be called
  * unconditionally; the step log is started with the controller, as the wizard started it with its first render.
  */
-export declare function useFlow(start: FlowStart | undefined, deps?: () => FlowDeps): {
+export declare function useFlow(start: FlowStart | undefined, options?: {
+    beforeStepChange?: () => void;
+    deps?: () => FlowDeps;
+}): {
     controller: FlowController;
     state: ReturnType<FlowController['getState']>;
 } | undefined;

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

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { Produced } from '../support/produced.js';
 type EntityResult = {
     created: number;
     updated: number;
@@ -16,6 +17,10 @@ type DoneStepProps = {
     spaceId: string;
     environmentId: string;
     host?: string;
+    /** What the import produced, so only the links to those things are offered. */
+    produced: Produced;
+    /** The user skipped the credentials, so nothing could be pushed: the files were only saved. */
+    credentialsSkipped?: boolean;
     runTeaser?: string;
     failures?: Array<{
         entityType: string;
@@ -24,5 +29,5 @@ type DoneStepProps = {
     }>;
     onExit: () => void;
 };
-export declare function DoneStep({ componentTypes, designTokens, summary, spaceId, environmentId, host, failures, onExit, }: DoneStepProps): React.ReactElement;
+export declare function DoneStep({ componentTypes, designTokens, summary, spaceId, environmentId, host, produced, credentialsSkipped, failures, onExit, }: DoneStepProps): React.ReactElement;
 export {};

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

@@ -1,9 +1,9 @@
 import React from 'react';
 import type { PushProgress } from '../support/push-progress.js';
+import { type Produced } from '../support/produced.js';
 type PushingStepProps = {
-    stepNumber: number;
-    totalSteps: number;
     progress: PushProgress;
+    produced: Produced;
 };
-export declare function PushingStep({ stepNumber, totalSteps, progress }: PushingStepProps): React.ReactElement;
+export declare function PushingStep({ progress, produced }: PushingStepProps): React.ReactElement;
 export {};

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

@@ -1,20 +1,12 @@
 import React from 'react';
 import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
-export interface PreviewDiffLine {
-    key: string;
-    color: string;
-    text: string;
-}
-export declare function buildPreviewSummaryLines(preview: ServerPreviewResponse): PreviewDiffLine[];
 type WizardPreviewStepProps = {
     preview: ServerPreviewResponse;
     spaceId: string;
     environmentId: string;
-    stepNumber: number;
-    totalSteps: number;
     onConfirm: (acknowledge: boolean) => void;
     onEdit?: () => void;
     onQuit: () => void;
 };
-export declare function WizardPreviewStep({ preview, spaceId, environmentId, stepNumber, totalSteps, onConfirm, onEdit, onQuit, }: WizardPreviewStepProps): React.ReactElement;
+export declare function WizardPreviewStep({ preview, spaceId, environmentId, onConfirm, onEdit, onQuit, }: WizardPreviewStepProps): React.ReactElement;
 export {};

package/dist/src/tui/import/steps/10-flow/support/path-utils.d.ts

@@ -1,8 +1,3 @@
-/**
- * Expands a leading `~` to the user's home directory.
- * Exported separately so it can be unit-tested and reused.
- */
-export declare function expandTilde(input: string): string;
 /**
  * Normalizes a user-entered path to an absolute path, handling all common
  * terminal path styles:

package/dist/src/tui/import/steps/10-flow/support/preview-diff.d.ts

@@ -1,10 +1,7 @@
-import type { ChangeClassification, ComponentTypeSummary, PropertySummary } from '@contentful/experience-design-system-types';
+import type { ChangeClassification, ComponentTypeSummary } from '@contentful/experience-design-system-types';
 export interface PropertyDiffLine {
     key: string;
-    color: 'green' | 'red' | 'yellow';
+    color: string;
     text: string;
 }
 export declare function computeComponentDiffLines(current: ComponentTypeSummary, proposed: Record<string, unknown>, changeClassification?: ChangeClassification): PropertyDiffLine[];
-export declare function diffProperty(name: string, old: PropertySummary, newDef: Record<string, unknown>): PropertyDiffLine[];
-export declare function formatOldProp(prop: PropertySummary): string;
-export declare function formatPropDef(def: Record<string, unknown>): string;

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

@@ -0,0 +1,15 @@
+import type { FlowState } from '../flow/types.js';
+/** What an import produced, so the screens after the work can describe what happened and not a fixed pair. */
+export interface Produced {
+    components: boolean;
+    tokens: boolean;
+}
+/** Components exist when extraction ran; tokens exist when the token stage left a catalog or a session behind. */
+export declare function producedOf(state: Pick<FlowState, 'extractSessionId' | 'tokensPath' | 'tokenSessionId'>): Produced;
+/**
+ * How the saved file is described: the file is always named `components.json`, but when only tokens were generated it
+ * holds just the tokens, and calling it a components file would mislead.
+ */
+export declare function fileSummaryLabel({ components }: Produced): string;
+/** "component types and design tokens", "design tokens", or "component types": the things this run writes. */
+export declare function writtenThings({ components, tokens }: Produced): string;

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

@@ -1,6 +1,6 @@
+export { PreflightScreen } from './00-preflight/screen.js';
 export { WelcomeScreen } from './01-welcome/screen.js';
 export { TokenInputScreen } from './02-token-input/screen.js';
 export { PathValidationScreen } from './03-path-validation/screen.js';
 export { CredentialsScreen } from './04-credentials/screen.js';
-export { TokenReuseScreen } from './05-token-reuse/screen.js';
 export { ExtractionScreen } from './06-extraction/screen.js';

package/dist/src/tui/import/steps/preview-validation-error/logic.d.ts

@@ -3,10 +3,7 @@ export interface PreviewValidationError {
     path: string;
     message: string;
 }
-export declare function failedComponentNames(errors: readonly PreviewValidationError[]): string[];
 export declare function matchedComponentNames(errors: readonly PreviewValidationError[], missingNames: readonly string[]): string[];
-export declare function formatErrorLine(error: PreviewValidationError): string;
 export declare function formatErrorLines(errors: readonly PreviewValidationError[]): string;
-export declare function missingNote(missingNames: readonly string[]): string;
 export declare function contextText(errors: readonly PreviewValidationError[], missingNames: readonly string[]): string;
 export declare function skipLabel(matchedNames: readonly string[]): string;

package/dist/src/tui/settings/{contentful-configuration/ContentfulConfigScreen.d.ts → configuration/ConfigurationScreen.d.ts}

@@ -1,4 +1,5 @@
 import React from 'react';
+/** Settings > Configuration: a short menu that opens the Project settings or the Agent settings. */
 export declare function ConfigurationScreen({ onDone }: {
     onDone: () => void;
 }): React.ReactElement;

package/dist/src/tui/settings/configuration/agents/AgentDetail.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
+import { type AgentConfig } from './agent-store.js';
+/**
+ * One agent's screen: what was found for it, its two settings, and the test. Saving writes the whole agent config, so the
+ * default agent and the other agents are kept. The test uses the values on screen, saved or not.
+ */
+export declare function AgentDetail({ name, config, setConfig, onBack, record, }: {
+    name: AgentName;
+    config: AgentConfig;
+    setConfig: (config: AgentConfig) => void;
+    onBack: () => void;
+    /** Adds a line to the debug log of this visit. The Agents list owns the log, since it is the screen that is open. */
+    record: (action: string, error?: unknown) => void;
+}): React.ReactElement;

package/dist/src/tui/settings/configuration/agents/AgentStatusBadge.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { AgentName } from '@contentful/experience-design-system-backend-pipeline';
+import { type AgentCheck, type StatusRow } from './agent-status.js';
+export declare const TONE_COLOR: Record<StatusRow['tone'], string>;
+/** The symbol and one-word state for an agent, shown on its row in the list. `binary` is the saved path, empty when none is saved. */
+export declare function AgentStatusBadge({ name, checks, binary, }: {
+    name: AgentName;
+    checks: AgentCheck[] | undefined;
+    binary: string;
+}): React.ReactElement;

package/dist/src/tui/settings/configuration/agents/AgentsScreen.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+/**
+ * Settings > Configuration > Agents. The list holds only what is needed to pick an agent: the name, a star on the default,
+ * and a one-word status. Below it, a panel shows the full detail for the focused agent and follows the cursor, so nothing
+ * has to be opened to read it. The "Default agent" line at the top is read-only: ↑/↓ move through the agents, Enter makes
+ * the focused one the default (saved at once), and → opens its own screen, where its path and model are edited and the
+ * test is run.
+ */
+export declare function AgentsScreen({ onDone }: {
+    onDone: () => void;
+}): React.ReactElement;

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

@@ -0,0 +1,25 @@
+import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
+import type { Snapshot } from '../../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
+ * every agent. Taken on entry and on exit, so the log shows what a visit changed.
+ */
+export declare function agentSnapshot(config: AgentConfig): Snapshot;
+export type AgentEnvironment = {
+    /** Whether the command was found, and the path it resolved to. */
+    found: boolean;
+    resolved_path: string;
+    version: string;
+    /**
+     * The `EDS_AGENT_BINARY_<AGENT>` variable when it points somewhere other than the saved path. Settings copies a saved
+     * path into that variable at startup, so a value equal to the saved path is not an override and is left out.
+     */
+    env_override: string;
+};
+/**
+ * What is true about each agent on this machine, so "my agent does not work" can be read from the log: found or not,
+ * where, its version, and whether a shell variable is overriding the saved path. Uses the quick checks only, so it never
+ * spends a prompt.
+ */
+export declare function describeAgents(config: AgentConfig): Promise<Record<AgentName, AgentEnvironment>>;

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

@@ -0,0 +1,63 @@
+import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
+type AgentCheckStep = 'path' | 'version' | 'login' | 'prompt';
+export type AgentCheck = {
+    step: AgentCheckStep;
+    ok: boolean;
+    /** One line for the user: the version string, the reason it failed, or what to run next. */
+    detail: string;
+    /** Only on the prompt step: the agent did not answer in time. That is not the same as a failure or a missing login. */
+    timedOut?: boolean;
+};
+/**
+ * The one-word state shown on an agent's row. `not-configured` means no path is saved and the command is not on the
+ * PATH; `not-found` means a saved path does not work. `unknown` means it runs but its login cannot be checked.
+ */
+export type AgentStatus = 'checking' | 'ready' | 'not-configured' | 'not-found' | 'not-logged-in' | 'test-failed' | 'timed-out' | 'unknown';
+/** The model the agent runs with when none is saved ("haiku", "gpt-mini", or the agent's own pick), for the model row. */
+export declare function defaultModelLabel(name: AgentName): string;
+/**
+ * Steps 1 to 3 against `binary`. Never throws and never spends tokens, so it is safe to run for every row on open.
+ * Checks the path the user typed, not what is saved, so the form can test a value before it is written.
+ */
+export declare function inspectAgent(name: AgentName, binary: string): Promise<AgentCheck[]>;
+/** Steps 1 to 4. The prompt step is the only way to verify login and model name for agents other than claude. */
+export declare function testAgent(name: AgentName, binary: string, model: string): Promise<AgentCheck[]>;
+/** Collapses a list of checks into the status shown on the row. */
+export declare function statusFromChecks(name: AgentName, checks: readonly AgentCheck[], savedBinary: string): AgentStatus;
+export type StatusRow = {
+    label: string;
+    value: string;
+    tone: 'ok' | 'bad' | 'muted';
+};
+/**
+ * How a full test went, in one line for a banner on the agent's screen. Undefined when no test has run (the quick checks
+ * alone are not a test), so the banner only appears after the user asked for one.
+ */
+export declare function testOutcome(checks: readonly AgentCheck[] | undefined): {
+    ok: boolean;
+    text: string;
+} | undefined;
+/**
+ * The short form of a status for the list, where every row has to be scannable at a glance. The wording is plainer than
+ * the detail panel's: "not installed" covers both "nothing saved" and "saved path broken", which the panel tells apart.
+ */
+export declare const LIST_STATUS: Record<AgentStatus, {
+    symbol: string;
+    text: string;
+    tone: StatusRow['tone'];
+}>;
+/**
+ * The rows of the detail panel under the list, for the focused agent. Everything here is read-only and comes from
+ * checks already collected, so moving the cursor never runs anything.
+ */
+export declare function panelRows(name: AgentName, checks: readonly AgentCheck[] | undefined, settings: {
+    binary: string;
+    model: string;
+}): StatusRow[];
+/**
+ * What the Status section of an agent's screen shows: the shared rows, then the login and the test, which only this
+ * view has. The login row is always there once the command is found, because for most agents it has to say that login
+ * cannot be checked without a test.
+ */
+export declare function statusRows(name: AgentName, checks: readonly AgentCheck[] | undefined, savedBinary: string): StatusRow[];
+export {};

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

@@ -0,0 +1,21 @@
+import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
+export type AgentSettings = {
+    /** Passed as --model. Empty: the agent's built-in default (see defaultModelLabel). */
+    model: string;
+    /** Path to the agent's command. Empty: the command name is looked up on the PATH. */
+    binary: string;
+};
+export type AgentConfig = {
+    /** The agent the CLI uses when `--agent` is not given. Claude when nothing was chosen. */
+    defaultAgent: AgentName;
+    /**
+     * Whether the user chose the default agent. Only then is `agent` written to config.json, so someone who never chose
+     * keeps the import's built-in default, including if that default changes in a later version.
+     */
+    defaultChosen?: boolean;
+    agents: Record<AgentName, AgentSettings>;
+};
+export declare const AGENT_LABELS: Record<AgentName, string>;
+export declare function emptyAgents(): Record<AgentName, AgentSettings>;
+export declare function readAgentConfig(): Promise<AgentConfig>;
+export declare function writeAgentConfig(config: AgentConfig): Promise<void>;