@contentful/experience-design-system-cli 2.37.1-dev-build-444a2d6a.0 → 2.37.1-dev-build-04545499.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.37.1-dev-build-444a2d6a.0",
+  "version": "2.37.1-dev-build-04545499.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/tui/import/steps/07-scope-gate/sidebar/components/GroupedSidebar.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
 import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
 import { type ComponentGraphNode, type NodeStatus } from '../../graph/composite-closure.js';
-import type { ParentChildEdge } from '../../types.js';
 import type { PreviewAnnotation, RenderStatus } from '../types.js';
 export interface GroupedSidebarItem {
     key: string;
@@ -28,8 +27,6 @@ export interface GroupedSidebarProps {
     alwaysExpanded?: boolean;
     showFlatTier?: boolean;
     selectionStateByKey?: Map<string, 'accepted' | 'rejected' | 'undecided'>;
-    /** Slot edges the user removed; their nested rows render unchecked. */
-    excludedSlotEdges?: ParentChildEdge[];
     aiFlaggedByKey?: Map<string, boolean>;
     dimPredicate?: (componentKey: string) => boolean;
     viewMode?: 'grouped' | 'flat';
@@ -48,8 +45,6 @@ export interface VisibleRow {
     cycleChild?: boolean;
     itemIdx: number;
     rootName?: string;
-    /** The parent whose slot the nested row sits in. */
-    parentName?: string;
 }
 export declare function buildVisibleRows(props: {
     items: GroupedSidebarItem[];

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

@@ -1,5 +1,5 @@
 import { type ScopeGraph } from './graph/index.js';
-import type { Decision, ParentChildEdge, ScopeComponent, ScopeDecisions } from './types.js';
+import type { Decision, ScopeComponent, ScopeDecisions } from './types.js';
 export type DecisionState = Map<string, Decision>;
 export type DecisionAction = {
     type: 'accept';
@@ -15,6 +15,5 @@ export type DecisionAction = {
 export declare function reduceDecisions(state: DecisionState, action: DecisionAction, components: ScopeComponent[], graph: ScopeGraph): DecisionState;
 /** Whether rejecting `name` touches 2 or more other components, so the screen has to ask first. */
 export declare function rejectNeedsConfirmation(graph: ScopeGraph, name: string, state: DecisionState): boolean;
-export declare function withEdgeExcluded(edges: ParentChildEdge[], edge: ParentChildEdge, excluded: boolean): ParentChildEdge[];
 /** Everything not accepted counts as rejected, as legacy's `partition` did. */
-export declare function partitionDecisions(components: ScopeComponent[], state: DecisionState, excludedEdges: ParentChildEdge[]): ScopeDecisions;
+export declare function partitionDecisions(components: ScopeComponent[], state: DecisionState): ScopeDecisions;

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

@@ -10,17 +10,10 @@ export type ScopeComponent = Omit<ScopeComponentRow, 'aiDecision' | 'aiReason' |
     slots?: ScopeComponentRow['slots'];
 };
 export type Decision = 'accepted' | 'rejected' | 'undecided';
-/** One slot edge: `parent` allows `child` in a slot. */
-export interface ParentChildEdge {
-    parent: string;
-    child: string;
-}
 /** What the user confirmed. Becomes `ImportHandoff.scope`; the legacy wizard saves it and starts generation. */
 export interface ScopeDecisions {
     accepted: string[];
     rejected: string[];
-    /** Slot edges removed at the gate. The child keeps its own decision. */
-    excludedSlotEdges: ParentChildEdge[];
 }
 export type ScopeGateLoad = {
     ok: true;

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

@@ -1,4 +1,3 @@
-import type { ScopeHandoff } from '@contentful/experience-design-system-types/handoff';
 import { type CacheCheckInput } from './cache-check.js';
 import { loadScopeGate } from './load.js';
 import type { ScopeDecisions, ScopeGateLoad } from './types.js';
@@ -11,13 +10,10 @@ export type ScopeGateFlow = {
         ok: true;
     }>;
     confirm: (decisions: ScopeDecisions) => void;
-}
-/** Confirmed before the cache check finished. */
- | {
-    status: 'preparing';
 } | {
     status: 'confirmed';
-    scope: ScopeHandoff;
+    decisions: ScopeDecisions;
+    cachedNames: Promise<string[]>;
 };
 interface Deps {
     load: typeof loadScopeGate;

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

@@ -1,4 +1,4 @@
-import type { ParentChildEdge, ScopeComponent, ScopeDecisions } from './types.js';
+import type { ScopeComponent, ScopeDecisions } from './types.js';
 interface UseScopeGateOptions {
     components: ScopeComponent[];
     onConfirm: (decisions: ScopeDecisions) => void;
@@ -20,7 +20,6 @@ export declare function useScopeGate({ components, onConfirm, onQuit }: UseScope
     panelLayout: import("./columns.js").ScopeGatePanelLayout;
     visibleCount: number;
     panelMaxRows: number;
-    excludedEdges: ParentChildEdge[];
     groupedItems: import("./graph/index.js").SidebarItem[];
     graph: import("./graph/index.js").ScopeGraph;
     hasGroupRoots: boolean;

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

@@ -0,0 +1,44 @@
+import type { GenerationProgress } from './types.js';
+export declare function initialProgress(): GenerationProgress;
+/**
+ * Folds a chunk of `__generate components` stderr into the progress. Two line shapes carry it:
+ *  1. `progress=generate:<done>/<total>:<name>`, emitted when a component finishes. `done` is the count of finished
+ *     components and never goes down.
+ *  2. `[<index>/<total>] <name>`, emitted when a component starts (and again on a retry). With more than one worker its
+ *     index is the worker's starting position, not a count of completions, so it must only change `current`.
+ */
+export declare function applyGenerateStderr(chunk: string, previous: GenerationProgress['components']): GenerationProgress['components'];
+/** The session, the component count and the renamed-slot count from the command's output. */
+export declare function parseGenerateResult(output: {
+    stdout: string;
+    stderr: string;
+}, fallbackCount: number): {
+    generateSessionId: string | null;
+    generatedCount: number;
+    renamedSlotsCount: number;
+};
+/** 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;
+    progress?: {
+        done: number;
+        total: number;
+    };
+}>;

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

@@ -0,0 +1,14 @@
+import type { GenerationInput } from './types.js';
+export interface MapTokensPlan {
+    /** False when there is nothing to map, in which case the command is not run. */
+    eligible: boolean;
+    mappablePropCount: number;
+    rawTokenCount: number;
+}
+/**
+ * Prepares the generated session for token mapping and says whether it is worth running. The map tokens command works
+ * on one session, so the token universe is copied into the generated one: from the token session when extraction made
+ * one, or restored from the saved tokens.json when an existing catalog was reused (there is no token session then).
+ * Then it counts the design props that are tokens and the raw tokens. Reads and writes the pipeline database.
+ */
+export declare function prepareMapTokens(input: Pick<GenerationInput, 'tokenSessionId' | 'tokensPath'>, generatedSessionId: string): Promise<MapTokensPlan>;

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

@@ -0,0 +1,42 @@
+export interface GenerateCommand {
+    sessionId: string;
+    tokensPath: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    generatePromptPath?: string;
+    noCache: boolean;
+    existingEntitiesPath: string | null;
+    /** Accepted components the cache already holds, so the command skips them. */
+    cachedComponents: string[];
+}
+export interface MapTokensCommand {
+    sessionId: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    noCache: boolean;
+    existingEntitiesPath: string | null;
+}
+export interface SpawnedResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * `__generate components …`, in the order the wizard builds the arguments. The cache was already restored by the check
+ * that ran while the scope gate was open, so `--restore-cache` is not passed here; what the cache holds goes in
+ * `--cached-components` instead.
+ */
+export declare function buildGenerateArgs(cliPath: string, command: GenerateCommand): string[];
+/** `map tokens …`, in the order the wizard builds the arguments. */
+export declare function buildMapTokensArgs(command: MapTokensCommand): string[];
+/**
+ * Runs `__generate components`, delivering stderr as it arrives. Resolves on close, not exit, so the child's stdio and
+ * any file handles it inherited (the pipeline database's WAL and SHM files) are released before anything else touches
+ * the database.
+ */
+export declare function spawnGenerate(command: GenerateCommand, handlers: {
+    onStderr: (chunk: string) => void;
+}): Promise<SpawnedResult>;
+export declare function runMapTokens(command: MapTokensCommand): Promise<SpawnedResult>;

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

@@ -0,0 +1,26 @@
+import { checkAgentAuth } from '@contentful/experience-design-system-generation';
+import { type CacheCheckInput } from '../07-scope-gate/cache-check.js';
+import { prepareMapTokens } from './map-tokens.js';
+import { runMapTokens, spawnGenerate } from './processes.js';
+import { saveDecisions } from './save-decisions.js';
+import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
+/** The outside world the stage talks to, so the order of events can be tested without a database, an agent or a CLI. */
+export interface GenerationDeps {
+    checkAgentAuth: typeof checkAgentAuth;
+    saveDecisions: typeof saveDecisions;
+    checkCache: (input: CacheCheckInput) => Promise<string[]>;
+    spawnGenerate: typeof spawnGenerate;
+    prepareMapTokens: typeof prepareMapTokens;
+    runMapTokens: typeof runMapTokens;
+}
+/**
+ * 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, as the wizard's did.
+ *  2. If every accepted component is in the cache, take them all from it. Otherwise look at the cache again, because the
+ *     earlier answer was read before the decisions were saved, and generate only what is still missing.
+ *  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/save-decisions.d.ts

@@ -0,0 +1,8 @@
+import type { GenerationInput } from './types.js';
+/**
+ * Applies the scope decisions to the session and writes the review snapshot that `generate components` reads to leave
+ * out rejected components. Without the snapshot the generator would process rejected components anyway.
+ * Uses `applyScopeDecisions` and `writeScopeDecisionsSnapshot` from backend-pipeline, which are identical to legacy's.
+ * Both write to the pipeline database, so this runs only after the cache check has finished restoring into it.
+ */
+export declare function saveDecisions(input: Pick<GenerationInput, 'sessionId' | 'decisions'>): Promise<void>;

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

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { GenerationProgress } from './types.js';
+interface GenerationScreenProps {
+    progress: GenerationProgress;
+    agent: string;
+    acceptedCount: number;
+    hasTokens: boolean;
+    stepNumber: number;
+    totalSteps: number;
+}
+export declare function GenerationScreen({ progress, agent, acceptedCount, hasTokens, stepNumber, totalSteps, }: GenerationScreenProps): React.ReactElement;
+export {};

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

@@ -0,0 +1,47 @@
+import type { GenerationHandoff } from '@contentful/experience-design-system-types/handoff';
+export interface GenerationInput {
+    /** The extraction session the scope was decided on. */
+    sessionId: string;
+    decisions: {
+        accepted: string[];
+        rejected: string[];
+    };
+    /**
+     * The cache check that ran while the scope gate was open, which restores cached definitions into the pipeline
+     * database. The stage waits for it before saving the decisions, since both write to that database.
+     */
+    cachedNames: Promise<string[]>;
+    tokensPath: string;
+    /** The token session extraction recorded, or null when an existing tokens.json was reused. */
+    tokenSessionId: string | null;
+    existingEntitiesPath: string | null;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    /** A custom prompt for `generate components`, saved in the config. Passed to the command as it is. */
+    generatePromptPath?: string;
+    noCache: boolean;
+    /** Whether a token catalog is in use. It changes the wording of the screen, not what runs. */
+    hasTokens: boolean;
+}
+/** 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: {
+        done: number;
+        total: number;
+        current: string;
+    } | null;
+    mapTokens: 'idle' | 'running' | 'complete';
+    /** Whether token mapping will run at all; unknown until the generated components have been looked at. */
+    mapTokensEligible: boolean | null;
+}
+export type GenerationStepName = 'save decisions' | 'generate components' | 'map tokens' | `${string} auth check`;
+export type GenerationResult = {
+    ok: true;
+    generation: GenerationHandoff;
+} | {
+    ok: false;
+    step: GenerationStepName;
+    message: string;
+};

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

@@ -0,0 +1,14 @@
+import type { GenerationInput, GenerationProgress, GenerationResult } from './types.js';
+export type GenerationState = {
+    status: 'running';
+    progress: GenerationProgress;
+} | {
+    status: 'done';
+    result: GenerationResult;
+};
+/**
+ * Runs the generation stage once for the given input and reports its progress. Passing a different input starts a new
+ * run; passing nothing leaves the stage idle. A run that finishes after the input changed or the screen went away is
+ * ignored.
+ */
+export declare function useGeneration(input: GenerationInput | undefined): GenerationState | undefined;

package/legacy/dist/src/analyze/select/tui/components/GroupedSidebar.d.ts

@@ -46,8 +46,6 @@ export interface VisibleRow {
     cycleChild?: boolean;
     itemIdx: number;
     rootName?: string;
-    /** The parent whose slot the nested row sits in. */
-    parentName?: string;
 }
 export declare function buildVisibleRows(props: {
     items: GroupedSidebarItem[];

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

@@ -1,42 +1,11 @@
 import React from 'react';
 import type { CDFDocument, CDFComponentEntry, DTCGTokenEntry } from '@contentful/experience-design-system-types';
-import { type AgentAuthStatus } from '@contentful/experience-design-system-generation';
-export declare function buildGenerateComponentsArgs(opts: {
-    sessionId: string;
-    tokensPath?: string;
-    agent: string;
-    model?: string;
-    bedrock?: boolean;
-    noCache?: boolean;
-    generatePromptPath?: string;
-    promptOverrides?: string[];
-    existingEntitiesPath?: string;
-    restoreCache?: boolean;
-    cachedComponents?: string[];
-}): string[];
-export declare function buildMapTokensArgs(opts: {
-    sessionId: string;
-    agent: string;
-    model?: string;
-    noCache?: boolean;
-    skipAgent?: boolean;
-    promptOverrides?: string[];
-    existingEntitiesPath?: string;
-}): string[];
-export declare function shouldRunMapTokens(opts: {
-    mappablePropCount: number;
-    rawTokenCount: number;
-}): boolean;
 export declare function buildSavedCDF(components: Array<{
     key: string;
     entry: CDFComponentEntry;
 }>, tokens: DTCGTokenEntry[], opts?: {
     deleteAll?: boolean;
 }): CDFDocument;
-export declare function formatAcceptanceSummary(opts: {
-    accepted: number;
-    autoRejected: number;
-}): string;
 export declare function parsePrintTokensCount(stdout: string): number;
 export type WizardAppProps = {
     initialSpaceId?: string;
@@ -48,12 +17,8 @@ export type WizardAppProps = {
     bedrock?: boolean;
     initialProjectPath?: string;
     host?: string;
-    promptOverrides?: string[];
-    noCache?: boolean;
     livePreview?: boolean;
     generatePromptPath?: string;
-    skipMapTokens?: boolean;
     initialRawTokensPath?: string;
-    initialAgentAuth?: Promise<AgentAuthStatus>;
 };
-export declare function WizardApp({ initialSpaceId, initialEnvironmentId, initialCmaToken, initialHost, initialAgent, initialModel, bedrock, initialProjectPath, host, promptOverrides, noCache, livePreview, generatePromptPath, skipMapTokens, initialRawTokensPath, initialAgentAuth, }?: WizardAppProps): React.ReactElement;
+export declare function WizardApp({ initialSpaceId, initialEnvironmentId, initialCmaToken, initialHost, initialAgent, initialModel, bedrock, initialProjectPath, host, livePreview, generatePromptPath, initialRawTokensPath, }?: WizardAppProps): React.ReactElement;

package/legacy/dist/src/import/tui/handoff.d.ts

@@ -1,5 +1,4 @@
 import { type ImportHandoff } from '@contentful/experience-design-system-types/handoff';
-import type { ParentChildEdge } from '../../session/db.js';
 /** The wizard state the early stages produce. Every field is one the stage used to write. */
 export interface HandoffState {
     credentialsSkipped: boolean;
@@ -13,24 +12,22 @@ export interface HandoffState {
     selectionAgentStatus?: 'complete';
     existingEntitiesStatus?: 'idle' | 'complete' | 'failed';
     existingEntitiesPath?: string | null;
+    acceptedCount?: number;
+    autoRejectedCount?: number;
+    generateSessionId?: string;
+    generatedCount?: number;
+    mapTokensEligible?: boolean;
+    mapTokensStatus?: 'complete';
 }
-/** What the user confirmed at the scope gate, which the CLI now shows. The wizard saves it, then generates. */
-export interface HandoffScope {
-    decisions: {
-        accepted: string[];
-        rejected: string[];
-        excludedSlotEdges: ParentChildEdge[];
-    };
-    /** Components the cache check (finished and restored before the wizard started) found already generated. */
-    cachedNames: string[];
-}
-export declare function scopeFromHandoff(handoff: ImportHandoff): HandoffScope | null;
+/** Where the wizard goes first: the review screen with the generated definitions, or straight to saving and pushing. */
+export type StartRoute = 'review' | 'push';
+export declare function routeFromHandoff(handoff: ImportHandoff): StartRoute | null;
 export declare function stateFromHandoff(handoff: ImportHandoff): HandoffState;
 export type StartFromHandoff = {
     ok: true;
     handoff: ImportHandoff;
     state: HandoffState;
-    scope: HandoffScope | null;
+    route: StartRoute | null;
 } | {
     ok: false;
     error: string;

package/legacy/dist/src/import/tui/runLivePreview.d.ts

@@ -29,9 +29,8 @@ export type RunLivePreviewOptions = {
 };
 /**
  * Pure async helper used by `useLivePreview` to re-fire `previewImport` after a
- * FieldEditor save in the wizard's final-review step. Mirrors the round-1
- * `runScopeGate` shape: a side-effect-bearing pure orchestrator that owns no
- * React state.
+ * FieldEditor save in the wizard's final-review step. A side-effect-bearing
+ * pure orchestrator that owns no React state.
  *
  * Skips silently (returns `{ response: null }`) when any of `spaceId`,
  * `environmentId`, or `cmaToken` is missing — live preview is an enhancement