@contentful/experience-design-system-cli 2.38.1-dev-build-f59ff6e8.0 → 2.38.1-dev-build-1adffe40.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.38.1-dev-build-f59ff6e8.0",
+  "version": "2.38.1-dev-build-1adffe40.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -25,7 +25,8 @@
   "files": [
     "bin/",
     "dist/",
-    "legacy/"
+    "legacy/",
+    "skills/"
   ],
   "scripts": {
     "build": "nx build experience-design-system-cli",
@@ -37,10 +38,12 @@
     "dev": "node scripts/dev.mjs"
   },
   "dependencies": {
+    "@contentful/experience-design-system-backend-pipeline": "workspace:*",
     "@contentful/experience-design-system-types": "workspace:*",
     "@inkjs/ui": "^2.0.0",
     "@segment/analytics-node": "^3.0.0",
     "@vue/compiler-sfc": "^3.5.31",
+    "ajv": "^8.18.0",
     "commander": "^13.1.0",
     "contentful-management": "^12.17.0",
     "figures": "6.1.0",
@@ -51,7 +54,8 @@
     "semver": "^7.7.2",
     "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "zod": "^4.6.5"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",
@@ -62,6 +66,7 @@
     "eslint": "^9.39.5",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.6",
+    "ink-testing-library": "^4.0.0",
     "typescript-eslint": "^8.67.0",
     "vitest": "^4.0.16"
   },

package/dist/src/commands/import-options.d.ts

@@ -0,0 +1,10 @@
+export interface ImportOptions {
+    agent?: string;
+    prompt: string[];
+}
+interface RawImportOptions {
+    agent?: string;
+    prompt?: string[];
+}
+export declare function toImportOptions(raw: RawImportOptions): ImportOptions;
+export {};

package/dist/src/commands/import.d.ts

@@ -1,2 +1,3 @@
 import type { Command } from 'commander';
-export declare function registerImportCommand(program: Command, openTui: () => Promise<void>): void;
+import { type ImportOptions } from './import-options.js';
+export declare function registerImportCommand(program: Command, openTui: (options: ImportOptions) => Promise<void>): void;

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

@@ -0,0 +1,12 @@
+export type PruneResult = {
+    logs: number;
+    folders: number;
+};
+/**
+ * Deletes the debug logs under `<base>/.contentful` that are older than `retentionDays`. It only looks at `.md` files
+ * inside the `debug` folder of a session folder, so nothing the import produced or the user put there is touched. A file
+ * that cannot be read or deleted is skipped: this runs at startup and must never get in the user's way. A folder the
+ * deletion left empty is removed too, up to the session folder; one that still holds anything stays. Returns how many
+ * logs and folders it deleted.
+ */
+export declare function pruneExpiredLogs(base: string, retentionDays: number, now?: number): Promise<PruneResult>;

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

@@ -1,6 +1,23 @@
 type Status = 'success' | 'error';
 type ExitMethod = 'saved' | 'discarded' | 'crashed';
-export declare function currentDebugSessionDir(): string;
+export declare function currentDebugSessionDir(): string | undefined;
+/** This terminal session's folder, `<base>/.contentful/<session>/`, or undefined until it is known. */
+export declare function currentSessionDir(): string | undefined;
+/**
+ * Starts this terminal session's folder in `base`. The base directory setting being saved passes `replace` so the new
+ * location wins; the import passes nothing and only starts a session when none exists yet. Fail-open like the rest of
+ * the logger.
+ */
+export declare function startDebugSessionIn(base: string, { replace }?: {
+    replace?: boolean | undefined;
+}): Promise<void>;
+/**
+ * Where this import run writes everything it produces (tokens.json, .existing-entities.json, components.json): a new
+ * `dsi-import-N` folder in this session's folder, next to the debug logs. The session is started here, and waited for,
+ * so the answer does not depend on how quickly the boot-time start finished. Without a session (Debug Mode off, or a
+ * folder that cannot be created) the files stay in `<project>/.contentful`, as before.
+ */
+export declare function startImportRun(projectPath: string): Promise<string>;
 export declare function startDebugRun({ flow, step, menuOption, inputs, }: {
     flow: string;
     step: string;

package/dist/src/tui/help/file-locations.d.ts

@@ -0,0 +1,23 @@
+export interface FileLocationInput {
+    /** The Root Project Directory from Settings > Configuration > Project. Empty when not set. */
+    contentfulBaseDir: string;
+    /** Whether Debug Mode is on. Debug logs and the per-run folders only exist while it is. */
+    debugModeEnabled: boolean;
+    /** This terminal session's folder, once it has started. */
+    currentSessionDir: string | undefined;
+}
+export interface FileLocations {
+    debugLogs: string;
+    importFiles: string;
+}
+/**
+ * Where the CLI writes the files a user goes looking for, from the settings that decide it (see `startImportRun`).
+ *
+ * With Debug Mode on, everything goes in this terminal session's folder, `<base>/.contentful/<date>-session-N/`:
+ * the debug logs in `debug/` and, for each import, a `dsi-import-N/` folder with `tokens.json` and `components.json`.
+ * `<base>` is the Root Project Directory, or the project being imported when none is set. With Debug Mode off there is
+ * no session folder and no logs, and the files go to `<project>/.contentful/`.
+ *
+ * Names that are only known when a session or an import starts are shown as patterns, never guessed.
+ */
+export declare function describeFileLocations({ contentfulBaseDir, debugModeEnabled, currentSessionDir, }: FileLocationInput): FileLocations;

package/dist/src/tui/home/home.theme.d.ts

@@ -1,12 +1,3 @@
-export declare const PALETTE: {
-    readonly accent: "#1773EB";
-    readonly heading: "#FFFFFF";
-    readonly success: "#00C459";
-    readonly error: "#E44F20";
-    readonly warning: "#FFDA00";
-    readonly muted: "#A6B5C7";
-    readonly border: "#C4D1DE";
-};
 export declare function brandBar(width: number, ramp?: readonly string[]): {
     text: string;
     color: string;

package/dist/src/tui/import/resolve-user-path.d.ts

@@ -0,0 +1 @@
+export declare function resolveUserPath(raw: string): string;

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

@@ -0,0 +1,7 @@
+interface ErrorHandlers {
+    onExit: () => void;
+    onRetry?: () => void;
+    onAcknowledge?: () => void;
+}
+export declare function useErrorControls(handlers: ErrorHandlers): void;
+export {};

package/{legacy/dist/src/import/tui/steps/ErrorStep.d.ts → dist/src/tui/import/shared/error-step/error-step.d.ts}

@@ -1,10 +1,10 @@
 import React from 'react';
-type ErrorStepProps = {
+interface ErrorStepProps {
     stepName: string;
     message: string;
     onExit: () => void;
     onRetryCredentials?: () => void;
     onAcknowledgeBreakingChanges?: () => void;
-};
+}
 export declare function ErrorStep({ stepName, message, onExit, onRetryCredentials, onAcknowledgeBreakingChanges, }: ErrorStepProps): React.ReactElement;
 export {};

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

@@ -0,0 +1,15 @@
+interface Key {
+    return: boolean;
+    escape: boolean;
+}
+export type ErrorAction = 'exit' | 'retry' | 'acknowledge' | null;
+interface Available {
+    canRetry: boolean;
+    canAcknowledge: boolean;
+}
+export declare function errorAction(input: string, key: Key, available: Available): ErrorAction;
+export declare function errorControls(available: Available): {
+    keys: string;
+    label: string;
+}[];
+export {};

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

@@ -0,0 +1,8 @@
+interface GateHandlers {
+    canSkip: boolean;
+    onContinue: () => void;
+    onSkip: () => void;
+    onQuit: () => void;
+}
+export declare function useGateControls(handlers: GateHandlers): void;
+export {};

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import { type StepHeaderProps } from '@tui/shared/components/StepHeader.js';
+interface GateStepProps {
+    message: string;
+    onContinue: () => void;
+    onQuit: () => void;
+    summary?: string;
+    context?: string;
+    continueLabel?: string;
+    skipLabel?: string;
+    onSkip?: () => void;
+    intent?: 'success' | 'error';
+    step?: StepHeaderProps['step'];
+}
+export declare function GateStep({ message, onContinue, onQuit, summary, context, continueLabel, skipLabel, onSkip, intent, step, }: GateStepProps): React.ReactElement;
+export {};

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

@@ -0,0 +1,11 @@
+interface Key {
+    return: boolean;
+    escape: boolean;
+}
+export type GateAction = 'continue' | 'skip' | 'quit' | null;
+export declare function gateAction(input: string, key: Key, canSkip: boolean): GateAction;
+export declare function gateControls(continueLabel: string, skipLabel: string, canSkip: boolean): {
+    keys: string;
+    label: string;
+}[];
+export {};

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

@@ -0,0 +1,4 @@
+export { ErrorStep } from './error-step/error-step.js';
+export { GateStep } from './gate-step/gate-step.js';
+export { OverviewBox, type OverviewStep } from './overview-box/overview-box.js';
+export { RunningStep } from './running-step/running-step.js';

package/dist/src/tui/import/shared/overview-box/overview-box.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface OverviewStep {
+    description: string;
+    /** Whether the step uses the user's local AI agent. */
+    ai: boolean;
+}
+/** The framed list of the steps an import goes through, with the AI disclosure under it. Shown by the intro screens. */
+export declare function OverviewBox({ steps }: {
+    steps: readonly OverviewStep[];
+}): React.ReactElement;

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

@@ -0,0 +1,11 @@
+export interface Progress {
+    done: number;
+    total: number;
+}
+export interface RunningLine {
+    text: string;
+    complete?: boolean;
+    progress?: Progress;
+}
+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

@@ -0,0 +1,10 @@
+import React from 'react';
+import { type RunningLine } from './logic.js';
+import type { ImportStepId } from '@tui/shared/components/StepHeader.js';
+interface RunningStepProps {
+    step: ImportStepId;
+    description: string;
+    lines?: readonly RunningLine[];
+}
+export declare function RunningStep({ step, description, lines, }: RunningStepProps): React.ReactElement;
+export {};

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

@@ -0,0 +1,3 @@
+export declare const PROGRESS_THEME: {
+    components: Record<string, import("@inkjs/ui").ComponentTheme>;
+};

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

@@ -0,0 +1 @@
+export declare function useElapsed(): string;

package/dist/src/tui/import/steps/00-preflight/controls.d.ts

@@ -0,0 +1,17 @@
+import { type ImportTarget } from './logic.js';
+export declare const PREFLIGHT_CONTROLS: readonly [{
+    readonly keys: "↑/↓";
+    readonly label: "Choose";
+}, {
+    readonly keys: "Enter";
+    readonly label: "Continue";
+}, {
+    readonly keys: "Esc";
+    readonly label: "Back to menu";
+}];
+export declare function usePreflightControls(handlers: {
+    focus: number;
+    onFocus: (focus: number) => void;
+    onChoose: (target: ImportTarget) => void;
+    onQuit: () => void;
+}): void;

package/dist/src/tui/import/steps/00-preflight/logic.d.ts

@@ -0,0 +1,45 @@
+import type { OverviewStep } from '../../shared/index.js';
+export type ImportTarget = 'both' | 'tokens' | 'components';
+export declare const IMPORT_TARGET_OPTIONS: ReadonlyArray<{
+    target: ImportTarget;
+    label: string;
+}>;
+export declare function overviewFor(target: ImportTarget): readonly OverviewStep[];
+export type ImportStepId = 'project' | 'token-file' | 'path-validation' | 'credentials' | 'component-extraction' | 'token-generation' | 'scope-gate' | 'generation' | 'review' | 'save-push';
+export declare function stepsFor(target: ImportTarget): readonly ImportStepId[];
+export interface InputAnswers {
+    projectPath?: string;
+    tokensPath?: string;
+    scannedFiles?: string[];
+}
+/**
+ * The input screen to show: the first step of this mode whose answer is still missing, or 'credentials' once every
+ * earlier one is answered. A mode never shows a screen it does not list, so skipping one needs no special case.
+ */
+export declare function currentInputStep(target: ImportTarget, answers: InputAnswers): Extract<ImportStepId, 'project' | 'token-file' | 'path-validation' | 'credentials'>;
+/**
+ * What Back from `current` does: leave for the preflight when it is the first screen of the mode, otherwise clear the
+ * previous step's answer so that screen shows again.
+ */
+export declare function goBack(target: ImportTarget, current: ImportStepId, answers: InputAnswers): {
+    to: 'preflight';
+} | {
+    to: 'step';
+    answers: InputAnswers;
+};
+/**
+ * Where a run writes its files when it has no project to put them in: the Root Project Directory setting if there is
+ * one, otherwise the folder the token file is in. Components runs always have a project and use it.
+ */
+export declare function runBaseDir(input: {
+    projectPath?: string;
+    tokensPath?: string;
+    configuredBaseDir?: string;
+}): string;
+interface FocusKey {
+    upArrow: boolean;
+    downArrow: boolean;
+}
+/** The option focused after a key: arrows move through the list and wrap around. */
+export declare function moveFocus(focus: number, key: FocusKey, count: number): number;
+export {};

package/dist/src/tui/import/steps/00-preflight/screen.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { type ImportTarget } from './logic.js';
+interface PreflightScreenProps {
+    onChoose: (target: ImportTarget) => void;
+    onQuit: () => void;
+}
+export declare function PreflightScreen({ onChoose, onQuit }: PreflightScreenProps): React.ReactElement;
+export {};

package/dist/src/tui/import/steps/01-welcome/controls.d.ts

@@ -1,8 +1,11 @@
 export declare const WELCOME_CONTROLS: readonly [{
     readonly keys: "Enter";
     readonly label: "Continue";
+}, {
+    readonly keys: "Ctrl+D";
+    readonly label: "Clear";
 }, {
     readonly keys: "Esc";
-    readonly label: "Back to menu";
+    readonly label: "Back";
 }];
 export declare function useWelcomeControls(onQuit: () => void): void;

package/dist/src/tui/import/steps/02-token-input/controls.d.ts

@@ -1,6 +1,9 @@
 export declare const TOKEN_INPUT_CONTROLS: readonly [{
     readonly keys: "Enter";
     readonly label: "Continue";
+}, {
+    readonly keys: "Ctrl+D";
+    readonly label: "Clear";
 }, {
     readonly keys: "Esc";
     readonly label: "Back";

package/dist/src/tui/import/steps/03-path-validation/controls.d.ts

@@ -0,0 +1,13 @@
+import { type PathPhase } from './logic.js';
+interface Control {
+    keys: string;
+    label: string;
+}
+interface PathValidationHandlers {
+    onConfirm: () => void;
+    onChangePath: () => void;
+    onBack: () => void;
+}
+export declare function controlsFor(phase: PathPhase): readonly Control[];
+export declare function usePathValidationControls(phase: PathPhase, handlers: PathValidationHandlers): void;
+export {};

package/dist/src/tui/import/steps/03-path-validation/helpers/scan-files.d.ts

@@ -0,0 +1,2 @@
+import type { ScanResult } from '../logic.js';
+export declare function scanFiles(directory: string): ScanResult;

package/dist/src/tui/import/steps/03-path-validation/logic.d.ts

@@ -0,0 +1,45 @@
+type FileCategory = 'tsx' | 'ts' | 'vue' | 'astro' | 'jsx' | 'js' | 'json' | 'other';
+export type FileCounts = Record<FileCategory, number> & {
+    total: number;
+};
+export type ScanFailureCode = 'not-found' | 'permission-denied' | 'is-file' | 'not-directory' | 'unreadable';
+export type ScanResult = {
+    ok: true;
+    counts: FileCounts;
+    filePaths: string[];
+    warnings: string[];
+} | {
+    ok: false;
+    failure: ScanFailureCode;
+};
+export type PathPhase = 'scanning' | 'ready' | 'failed';
+export type KeyAction = 'confirm' | 'change-path' | 'back';
+export interface SummaryRow {
+    label: string;
+    count: number;
+    tone: 'default' | 'accent' | 'muted';
+}
+export interface Summary {
+    total: number;
+    rows: SummaryRow[];
+    warning?: string;
+}
+export interface FailureMessage {
+    headline: string;
+    hints: string[];
+}
+interface Key {
+    escape: boolean;
+    return: boolean;
+}
+export declare function describeFailure(failure: ScanFailureCode, path: string): FailureMessage;
+/**
+ * The scan result as rows and a warning. When the import does not generate tokens (components only), `.json` files are
+ * not design tokens here, so the row says they are ignored and the warnings do not mention tokens.
+ */
+export declare function summarize(counts: FileCounts, { hasTokens }?: {
+    hasTokens?: boolean;
+}): Summary;
+export declare function phaseOf(scan: ScanResult | undefined): PathPhase;
+export declare function keyAction(phase: PathPhase, input: string, key: Key): KeyAction | undefined;
+export {};

package/dist/src/tui/import/steps/03-path-validation/screen.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+interface PathValidationScreenProps {
+    projectPath: string;
+    onConfirm: (result: {
+        projectPath: string;
+        filePaths: string[];
+    }) => void;
+    onChangePath: () => void;
+    onBack: () => void;
+    /** False when the import does not generate tokens, so `.json` files are not described as design tokens. */
+    hasTokens?: boolean;
+}
+export declare function PathValidationScreen({ projectPath, onConfirm, onChangePath, onBack, hasTokens, }: PathValidationScreenProps): React.ReactElement;
+export {};

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

@@ -0,0 +1,12 @@
+declare const FIELDS: readonly ["spaceId", "environmentId", "cmaToken", "host"];
+export type CredentialField = (typeof FIELDS)[number];
+export type CredentialValues = Record<CredentialField, string>;
+/**
+ * Why the space is asked for. Components are looked up in it before they are generated, so that is part of the reason
+ * unless the import only generates tokens, which has nothing to look up.
+ */
+export declare function credentialsPurpose(tokensOnly: boolean): string;
+export declare function normalize(values: CredentialValues): CredentialValues;
+export declare function missingField(values: CredentialValues): boolean;
+export declare function isUnchanged(current: CredentialValues, initial: CredentialValues): boolean;
+export {};

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

@@ -0,0 +1,19 @@
+import React from 'react';
+import { type CredentialValues } from './logic.js';
+import { type ValidationResult } from './validate.js';
+export type CredentialsResult = {
+    skipped: false;
+    credentials: CredentialValues;
+} | {
+    skipped: true;
+};
+interface CredentialsScreenProps {
+    onDone: (result: CredentialsResult) => void;
+    onBack: () => void;
+    initial?: Partial<CredentialValues>;
+    validate?: (values: CredentialValues) => Promise<ValidationResult>;
+    /** 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 {};

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

@@ -0,0 +1,8 @@
+import type { CredentialValues } from './logic.js';
+export type ValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function validateCredentials(values: CredentialValues): Promise<ValidationResult>;

package/dist/src/tui/import/steps/06-extraction/find-skill-path.d.ts

@@ -0,0 +1 @@
+export declare function findSkillPath(fileName: string): string;

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

@@ -0,0 +1,33 @@
+import type { ExtractAndComposeProgress } from '@contentful/experience-design-system-backend-pipeline';
+import type { ExtractionProgress } from './types.js';
+/** Structured progress events emitted by the orchestrator (extraction + composition). */
+export type ProgressEvent = ExtractAndComposeProgress;
+/**
+ * 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.
+ */
+export declare function initialProgress(input: {
+    hasCredentials: boolean;
+    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;
+}>;
+/** 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;
+export declare function agentAuthMessage(agent: string, status: 'not-found' | 'unauthenticated'): string;
+/**
+ * The agent and model the import runs with: what was typed after `--agent` (either `agent` or `agent:model`), else
+ * what `experiences setup` saved, else Claude with no model. Same chain the legacy import command uses.
+ */
+export declare function resolveAgentChoice(flag: string | undefined, stored: {
+    agent?: unknown;
+    agentModel?: unknown;
+}): {
+    agent: string;
+    agentModel?: string;
+};

package/dist/src/tui/import/steps/06-extraction/run-tokens-only.d.ts

@@ -0,0 +1,31 @@
+import { checkAgentAuth, runGenerateTokensSession } from '@contentful/experience-design-system-backend-pipeline';
+export interface TokensOnlyInput {
+    rawTokensPath: string;
+    /** Where tokens.json is written: this import run's folder. */
+    outDir: string;
+    agent: string;
+    agentModel?: string;
+    promptOverrides: string[];
+    noCache: boolean;
+}
+export type TokensOnlyResult = {
+    ok: true;
+    tokensPath: string;
+    tokenSessionId: string | null;
+    tokenCount: number;
+} | {
+    ok: false;
+    step: 'generate tokens' | `${string} auth check`;
+    message: string;
+};
+/** The outside world the stage talks to, so it can be tested without an agent. */
+export interface TokensOnlyDeps {
+    checkAgentAuth: typeof checkAgentAuth;
+    runGenerateTokensSession: typeof runGenerateTokensSession;
+}
+/**
+ * The extraction stage for an import that only generates tokens: the same auth check and token generation the full stage
+ * runs, without scanning components, composing them or selecting. The full stage fails when it finds no components, so it
+ * cannot be used for this.
+ */
+export declare function runTokensOnly(input: TokensOnlyInput, deps?: TokensOnlyDeps): Promise<TokensOnlyResult>;

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

@@ -0,0 +1,26 @@
+import { checkAgentAuth, runExtractAndComposeSession, runGenerateTokensSession } from '@contentful/experience-design-system-backend-pipeline';
+import { runSelection } from './selection.js';
+import type { ExtractionInput, ExtractionProgress, ExtractionResult } from './types.js';
+/** The outside world the stage talks to, so the order of events can be tested without a network, an agent or a CLI. */
+export interface ExtractionDeps {
+    checkAgentAuth: typeof checkAgentAuth;
+    fetchEntities: (credentials: NonNullable<ExtractionInput['credentials']>, outDir: string) => Promise<string | null>;
+    runExtractAndComposeSession: typeof runExtractAndComposeSession;
+    runGenerateTokensSession: typeof runGenerateTokensSession;
+    runSelection: typeof runSelection;
+}
+/**
+ * Runs the stage. The jobs overlap exactly as they did when extract was a
+ * subprocess:
+ *
+ *   entities fetch ───────────────────┐
+ *   extract + compose (in-process)    │
+ *     └─ onSessionCreated(id) ────────┴─ selection agent (waits for fetch) ──┐
+ *     └──────────────────────── returns (composition done) ─────────────────┴─ result
+ *   token generation            (only when the tokens are not being reused)
+ *
+ * Selection starts the moment the orchestrator mints the sessionId, so it
+ * overlaps with composition. When more than one job fails, the error reported
+ * is the first of: extract, no components, selection, token generation.
+ */
+export declare function runExtraction(input: ExtractionInput, onProgress: (progress: ExtractionProgress) => void, deps?: ExtractionDeps): Promise<ExtractionResult>;

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

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ExtractionProgress } from './types.js';
+interface ExtractionScreenProps {
+    progress: ExtractionProgress;
+    agent: string;
+}
+export declare function ExtractionScreen({ progress, agent }: ExtractionScreenProps): React.ReactElement;
+export {};

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

@@ -0,0 +1,18 @@
+import { type AgentName } from '@contentful/experience-design-system-backend-pipeline';
+export interface SelectionOptions {
+    sessionId: string;
+    agent: AgentName;
+    model?: string;
+    promptText?: string;
+    promptPath?: string;
+    noCache: boolean;
+}
+/**
+ * The selection agent run, as the legacy wizard ran it.
+ *
+ * Reads the extracted components from the session database and skips the ones already decided (cache keyed by
+ * component hash, prompt hash and CLI version). It asks the agent about the rest, then writes accepted or rejected to
+ * raw_components and stores the new decisions in the cache in one transaction. Throws on a timeout, a non-zero exit,
+ * or a database error.
+ */
+export declare function runSelection(options: SelectionOptions): Promise<void>;