@contentful/experience-design-system-cli 2.35.0-alpha.0 → 2.35.0

package/dist/src/lib/agent-definitions.d.ts

@@ -0,0 +1,14 @@
+import type { AgentName } from '@contentful/experience-design-system-generation';
+export interface AgentDefinition {
+    name: string;
+    binary: AgentName;
+    /** The npm package that installs this agent, so callers never spell it out again. */
+    packageName: string;
+    installSuffix?: string;
+    /** Whether `experiences setup` offers to install it. Copilot is detect-only. */
+    installable: boolean;
+}
+export declare const AGENT_DEFS: readonly AgentDefinition[];
+export declare function installCommand(agent: AgentDefinition): string;
+export declare function installHint(agent: AgentDefinition): string;
+export declare const INSTALLABLE_AGENTS: AgentDefinition[];

package/dist/src/lib/agent-model-options.d.ts

@@ -4,12 +4,12 @@ export declare const MODEL_DESCRIPTION = "Model to use (defaults to a lightweigh
 export interface AgentModelOptionsConfig {
     agentDescription?: string;
     includeModel?: boolean;
+    includeBedrock?: boolean;
     modelDescription?: string;
 }
 /**
- * Register --agent, --bedrock, and optional --model flags with a Commander
- * command. Pass includeModel: false to omit --model only — --bedrock is
- * independent of model selection (it's a routing switch, not a model choice)
- * and is always registered alongside --agent.
+ * Register --agent plus optional --model and --bedrock flags with a Commander
+ * command. The optional flags can be omitted for commands with a narrower
+ * public surface.
  */
 export declare function addAgentModelOptions(cmd: Command, config?: AgentModelOptionsConfig): Command;

package/dist/src/lib/command-options.d.ts

@@ -1,4 +1,3 @@
 import type { Command } from 'commander';
 export declare function addArtifactInputOptions(cmd: Command): Command;
 export declare function addContentfulTargetOptions(cmd: Command): Command;
-export declare function addCompositionOptions(cmd: Command): Command;

package/dist/src/lib/debug-logger.d.ts

@@ -25,15 +25,7 @@ export declare function initDebugLogger(opts: InitDebugLoggerOptions): DebugLogg
 export declare function getDebugLogger(): DebugLogger;
 /** Test-only: reset the singleton. */
 export declare function __resetDebugLoggerForTest(): void;
-/**
- * Resolve effective debug-mode setting from three sources.
- *
- * Precedence (highest first):
- *   1. `--debug` / `--no-debug` CLI flag
- *   2. `EDSI_DEBUG` env var (truthy: 1, true, yes, on)
- *   3. Persisted `debug` field in credentials.json
- *   4. Default: OFF
- */
+/** Resolve debug mode from an explicit option, environment, or saved settings. */
 export declare function resolveDebugMode(opts: {
     debug?: boolean;
 }, configDebug?: boolean): boolean;

package/dist/src/lib/debug-preamble.d.ts

@@ -1,13 +1,6 @@
 import { type DebugLogger } from './debug-logger.js';
 /**
- * Preamble every top-level command action should call before doing work.
- *
- * Resolves the effective debug decision (flag > env > persisted config),
- * initializes the singleton, and prints the bright-green start banner.
- * Registers a process-exit handler that prints the end banner once.
- *
- * Returns the logger so the caller can emit events without a second import.
- * When debug is disabled, the returned logger is a no-op.
+ * Resolve and initialize the debug logger before a top-level command runs.
  */
 export declare function beginCommand(command: string, opts: {
     debug?: boolean;

package/dist/src/program.d.ts

@@ -16,9 +16,9 @@ export declare function runBuild(opts: {
     exitCode: number;
 }>;
 /**
- * Walks `actionCommand` and its ancestors for a truthy `--bedrock`. --bedrock
- * is registered per-subcommand (not at program scope, unlike --debug), so a
- * root-level or subcommand-level setting can each carry it.
+ * Walks `actionCommand` and its ancestors for a truthy `--bedrock`.
+ * --bedrock is registered per-subcommand, so a root-level or
+ * subcommand-level setting can each carry it.
  */
 export declare function resolveBedrockFromAncestors(actionCommand: Command): boolean;
 export declare function createProgram(): Command;

package/dist/src/runs/store.d.ts

@@ -1,4 +1,3 @@
-import type { CompositionMode } from '../lib/composition-mode.js';
 export declare const RUNS_FILE_VERSION: 3;
 /** Versions this CLI can read. v1 / v2 files are auto-migrated in memory;
  *  new writes always use the latest version. */
@@ -45,10 +44,6 @@ export type RunRecord = {
      *  satisfy `RunRecord`; `appendRun` always normalizes a missing value to
      *  null on the way to disk. */
     sourceFingerprint?: SourceFingerprint | null;
-    /** Composition mode the run was produced in, so replay resumes in the
-     *  same mode (`composite` vs `atomic`). Absent on records written before this
-     *  field existed; callers treat a missing value as `atomic` (the default). */
-    compositionMode?: CompositionMode;
     notes?: string;
 };
 export type RunsFile = {

package/dist/src/session/db.d.ts

@@ -22,6 +22,10 @@ export interface ApplyToolCallsResult {
     slots: number;
     warnings: string[];
 }
+export interface ApplyToolCallsOptions {
+    /** Component names that may appear in generated slot allowed-components lists. */
+    allowedComponentNames?: ReadonlySet<string>;
+}
 export interface ComponentReviewMetadata {
     sourcePath: string | null;
     componentSource: string | null;
@@ -51,7 +55,7 @@ export interface ComponentRationale {
     }>;
 }
 export declare function loadComponentRationale(db: DatabaseSync, sessionId: string, componentName: string): ComponentRationale | null;
-export declare function applyToolCalls(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, calls: ToolCall[], incomingWarnings: string[]): ApplyToolCallsResult;
+export declare function applyToolCalls(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, calls: ToolCall[], incomingWarnings: string[], options?: ApplyToolCallsOptions): ApplyToolCallsResult;
 export type MatchHints = SessionMatchHints;
 export type { SessionResolution };
 export declare function getOrCreateSession(db: DatabaseSync, sessionFlag: string | undefined, sessionName: string | undefined, hints: MatchHints): SessionResolution;
@@ -60,6 +64,7 @@ export declare function updateStep(db: DatabaseSync, stepId: number, status: 'co
 export declare function storeRawComponents(db: DatabaseSync, sessionId: string, components: RawComponentDefinition[], options?: {
     status?: string;
     preserveCDF?: boolean;
+    preserveStatus?: boolean;
 }): void;
 export type RawComponentWithId = RawComponentDefinition & {
     component_id: string;
@@ -121,6 +126,14 @@ export declare function computeMapTokensInputHash(db: DatabaseSync, sessionId: s
 export declare function lookupCache(db: DatabaseSync, inputHash: string, entityType: CacheEntityType, entityId: string, promptHash?: string): CacheEntry | null;
 export declare function lookupCacheByEntity(db: DatabaseSync, entityType: CacheEntityType, entityId: string): CacheEntry | null;
 export declare function storeCache(db: DatabaseSync, inputHash: string, entityType: CacheEntityType, entityId: string, sourceSessionId: string, humanEdited: boolean, promptHash?: string): void;
+export declare function storeCaches(db: DatabaseSync, entries: Array<{
+    inputHash: string;
+    entityType: CacheEntityType;
+    entityId: string;
+    sourceSessionId: string;
+    humanEdited: boolean;
+    promptHash?: string;
+}>): void;
 export declare function storeScannedFiles(db: DatabaseSync, sessionId: string, filePaths: string[]): void;
 export declare function loadScannedFiles(db: DatabaseSync, sessionId: string): string[];
 export declare function storeSlotCycles(db: DatabaseSync, sessionId: string, cycles: Array<SlotCycle & {
@@ -132,7 +145,24 @@ export interface StoredSlotCycle extends SlotCycle {
 export declare function loadSlotCycles(db: DatabaseSync, sessionId: string): StoredSlotCycle[];
 export declare function clearSlotCycles(db: DatabaseSync, sessionId: string): void;
 export declare function markCacheHumanEdited(db: DatabaseSync, entityType: 'component' | 'token_set', entityId: string): void;
-export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string): void;
+export interface UnknownSlotAllowedComponent {
+    componentId: string;
+    componentName: string;
+    slotName: string;
+    allowedComponent: string;
+}
+export declare function findUnknownSlotAllowedComponents(db: DatabaseSync, sessionId: string, allowedComponentNames: ReadonlySet<string>, componentId?: string): UnknownSlotAllowedComponent[];
+/** Remove slot references that cannot resolve in the current manifest or target space. */
+export declare function filterUnknownSlotAllowedComponents(db: DatabaseSync, sessionId: string, allowedComponentNames: ReadonlySet<string>): UnknownSlotAllowedComponent[];
+export interface CopyComponentFromCacheOptions {
+    allowedComponentNames?: ReadonlySet<string>;
+}
+export declare function copyComponentFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string, componentId: string, manageTransaction?: boolean, options?: CopyComponentFromCacheOptions): void;
+export declare function copyComponentsFromCache(db: DatabaseSync, entries: Array<{
+    sourceSessionId: string;
+    targetSessionId: string;
+    componentId: string;
+}>, options?: CopyComponentFromCacheOptions): void;
 export declare function copyTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): void;
 export declare function copyMapTokensFromCache(db: DatabaseSync, sourceSessionId: string, targetSessionId: string): number;
 export declare function getCliCacheVersion(): Promise<string>;

package/dist/src/setup/SetupScreen.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+export type SetupResultEntry = {
+    name: string;
+    status: 'completed' | 'skipped' | 'failed';
+    required: boolean;
+};
+export declare function formatSetupCompletionMessage(results: readonly SetupResultEntry[]): string;
+/** Prompts and output are UI-owned; the screen supplies the rest itself. */
+export type SetupSkipFlags = {
+    skipBuild?: boolean;
+    skipAgent?: boolean;
+    skipCredentials?: boolean;
+    skipOptional?: boolean;
+};
+export type SetupOutcome = {
+    results: SetupResultEntry[];
+    exitCode: number;
+};
+type SetupScreenProps = {
+    version: string;
+    repoRoot: string;
+    skip?: SetupSkipFlags;
+    /** Defaults to the live Ink stdout columns. */
+    columns?: number;
+    onComplete: (outcome: SetupOutcome) => void;
+};
+export declare function SetupScreen({ version, repoRoot, skip, columns: columnsOverride, onComplete, }: SetupScreenProps): React.ReactElement;
+export {};

package/dist/src/setup/SetupStepper.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type SetupStepperProps = {
+    activeStep: number;
+    columns?: number;
+};
+export declare function SetupStepper({ activeStep, columns }: SetupStepperProps): React.ReactElement;
+export {};

package/dist/src/setup/command.d.ts

@@ -1,9 +1,3 @@
 import type { Command } from 'commander';
-export declare function promptCodexModel(ask?: (q: string) => Promise<string>): Promise<string | undefined>;
-/**
- * Prompt the operator for a custom skill prompt path. Returns the resolved
- * trimmed value, or `undefined` to leave the current value unchanged, or `null`
- * to clear it. `ask` is injectable so tests can stub stdin.
- */
-export declare function promptCustomSkillPath(current: string | undefined, ask?: (q: string) => Promise<string>): Promise<string | undefined | null>;
+export declare const SETUP_REQUIRES_TTY_MESSAGE = "Error: experiences setup requires an interactive terminal.";
 export declare function registerSetupCommand(program: Command): void;

package/dist/src/setup/lib/checks.d.ts

@@ -0,0 +1,57 @@
+import { binaryExists, pathExists, runSpawn, type ShellCommandResult } from './shell.js';
+/**
+ * The decision half of each prerequisite check, shared by `experiences doctor`
+ * and the setup wizard's Prerequisites step. Neither writes output from here:
+ * doctor streams ANSI, setup emits events for Ink, and both need the same
+ * verdict. Anything a caller needs for its own wording is returned rather than
+ * printed.
+ */
+export interface NodeVersionCheck {
+    passed: boolean;
+    version: string;
+    major: number;
+    required: number;
+}
+export declare function checkNodeVersion(nodeVersion?: string): NodeVersionCheck;
+/** Which Node version manager is available, so callers can offer the right fix. */
+export interface NodeVersionManagers {
+    nvm: boolean;
+    fnm: boolean;
+    nvmScript: string;
+}
+export declare function detectNodeVersionManagers(homeDir: string, deps?: {
+    binaryExists: typeof binaryExists;
+    pathExists: typeof pathExists;
+}): Promise<NodeVersionManagers>;
+export type PnpmCheck = {
+    status: 'missing';
+} | {
+    status: 'broken';
+} | {
+    status: 'unusable-in-repo';
+    version: string;
+} | {
+    status: 'ok';
+    version: string;
+};
+type PnpmDeps = {
+    binaryExists: typeof binaryExists;
+    run: typeof runSpawn;
+};
+/**
+ * `detectPnpm` plus proof that pnpm can execute inside the repo. A store built
+ * against a different Node version still passes `--version` but fails there,
+ * which is the failure operators actually hit — so both doctor and setup check it.
+ */
+export declare function checkPnpm(pkgRoot: string, deps?: PnpmDeps): Promise<PnpmCheck>;
+export interface CommandCheck {
+    passed: boolean;
+    result: ShellCommandResult;
+}
+export declare function installDependencies(repoRoot: string, deps?: {
+    run: typeof runSpawn;
+}): Promise<CommandCheck>;
+export declare function buildCli(repoRoot: string, deps?: {
+    run: typeof runSpawn;
+}): Promise<CommandCheck>;
+export {};

package/dist/src/setup/lib/shell.d.ts

@@ -0,0 +1,12 @@
+export declare const REQUIRED_NODE_MAJOR = 24;
+export interface ShellCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function binaryExists(name: string): Promise<boolean>;
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function runSpawn(cmd: string, args: string[], opts?: {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<ShellCommandResult>;

package/dist/src/setup/steps/CodingAgentScreen.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { AgentName } from '@contentful/experience-design-system-generation';
+import { type AgentDefinition } from '../../lib/agent-definitions.js';
+import { binaryExists, runSpawn } from '../lib/shell.js';
+import { type StepDone } from './StepLayout.js';
+export declare function detectAgents(exists?: (binary: string) => Promise<boolean>): Promise<AgentDefinition[]>;
+/** Codex needs a model only when it authenticates through a ChatGPT account. */
+export declare function needsCodexModel(agent: AgentName, env: NodeJS.ProcessEnv): boolean;
+export type CodingAgentDeps = {
+    binaryExists: typeof binaryExists;
+    run: typeof runSpawn;
+    env: NodeJS.ProcessEnv;
+};
+type CodingAgentScreenProps = {
+    onDone: StepDone;
+    /** Injected so tests can drive detection and install without spawning. */
+    deps?: CodingAgentDeps;
+};
+export declare function CodingAgentScreen({ onDone, deps }: CodingAgentScreenProps): React.ReactElement;
+export {};

package/dist/src/setup/steps/ContentfulCredentialsScreen.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type StepDone } from './StepLayout.js';
+/**
+ * Env vars still act as a fallback when a field on disk is empty, so an operator
+ * who skips this step should know an ambient value would take effect.
+ */
+export declare function envShadowingWarning(env: NodeJS.ProcessEnv): string | null;
+export declare function maskToken(token: string): string;
+export declare function ContentfulCredentialsScreen({ onDone }: {
+    onDone: StepDone;
+}): React.ReactElement;

package/dist/src/setup/steps/StepLayout.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+export type StepStatus = 'completed' | 'skipped' | 'failed';
+export type StepDone = (status: StepStatus) => void;
+type StepLayoutProps = {
+    helpText?: string;
+    children?: React.ReactNode;
+    prompt?: React.ReactNode;
+};
+export declare function StepLayout({ helpText, children, prompt }: StepLayoutProps): React.ReactElement;
+export declare function StepSuccess({ children }: {
+    children: React.ReactNode;
+}): React.ReactElement;
+export declare function StepWarning({ children }: {
+    children: React.ReactNode;
+}): React.ReactElement;
+export declare function StepValue({ label, value }: {
+    label: string;
+    value: string | undefined;
+}): React.ReactElement;
+export {};

package/dist/src/setup/steps/preferences/AnalyticsScreen.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { StepDone } from '../StepLayout.js';
+export declare function AnalyticsScreen({ onDone }: {
+    onDone: StepDone;
+}): React.ReactElement;

package/dist/src/setup/steps/preferences/BooleanInput.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { type ExperiencesCredentials } from '../../../credentials-store.js';
+import { type StepDone } from '../StepLayout.js';
+type BooleanPreferenceProps = {
+    helpText: string;
+    question: string;
+    /** What choosing each option means, named after the outcome rather than yes/no. */
+    labels: {
+        on: string;
+        off: string;
+    };
+    /** Reads the stored value; `undefined` means the operator has never set it. */
+    read: (credentials: ExperiencesCredentials) => boolean | undefined;
+    /** Applied to the stored credentials when the answer differs from the default. */
+    write: (credentials: ExperiencesCredentials, value: boolean) => ExperiencesCredentials;
+    /** What the setting means when it has never been set. */
+    fallback: boolean;
+    onDone: StepDone;
+};
+export declare function BooleanInput({ helpText, question, labels, read, write, fallback, onDone, }: BooleanPreferenceProps): React.ReactElement;
+export {};

package/dist/src/setup/steps/preferences/ColorPreferenceScreen.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { StepDone } from '../StepLayout.js';
+export declare function ColorPreferenceScreen({ onDone }: {
+    onDone: StepDone;
+}): React.ReactElement;

package/dist/src/setup/steps/preferences/CustomPromptScreen.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type ExperiencesCredentials } from '../../../credentials-store.js';
+import { type StepDone } from '../StepLayout.js';
+/**
+ * Interpret an answer to a custom prompt path question: empty keeps whatever is
+ * stored, `-` clears it, anything else is the new path.
+ */
+export declare function parseCustomSkillPath(answer: string): string | undefined | null;
+export declare function customSkillPathQuestion(current: string | undefined): string;
+/** Apply a parsed answer to the credentials, clearing the field on `null`. */
+export declare function applyCustomSkillPath(credentials: ExperiencesCredentials, parsed: string | undefined | null): ExperiencesCredentials;
+export declare function CustomPromptsScreen({ onDone }: {
+    onDone: StepDone;
+}): React.ReactElement;

package/dist/src/setup/steps/preferences/DebugLogsScreen.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { StepDone } from '../StepLayout.js';
+export declare function DebugLogsScreen({ onDone }: {
+    onDone: StepDone;
+}): React.ReactElement;

package/dist/src/setup/steps/preferences/PreferencesMenu.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { type StepDone } from '../StepLayout.js';
+type PreferenceScreenProps = {
+    onDone: StepDone;
+};
+export declare const PREFERENCE_OPTIONS: readonly [{
+    readonly key: "customPrompts";
+    readonly label: "Custom prompts";
+    readonly Screen: ({ onDone }: PreferenceScreenProps) => import("react/jsx-runtime").JSX.Element;
+}, {
+    readonly key: "debug";
+    readonly label: "Debug logging";
+    readonly Screen: ({ onDone }: PreferenceScreenProps) => import("react/jsx-runtime").JSX.Element;
+}, {
+    readonly key: "analytics";
+    readonly label: "Usage analytics";
+    readonly Screen: ({ onDone }: PreferenceScreenProps) => import("react/jsx-runtime").JSX.Element;
+}, {
+    readonly key: "noColor";
+    readonly label: "Terminal colors";
+    readonly Screen: ({ onDone }: PreferenceScreenProps) => import("react/jsx-runtime").JSX.Element;
+}];
+export declare function PreferencesMenu({ onDone }: {
+    onDone: StepDone;
+}): React.ReactElement;
+export {};

package/dist/src/setup/steps/prerequisites/PrerequisitesScreen.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { PrerequisiteDeps, PrerequisitesOutcome } from './deps.js';
+export type PrerequisitesScreenProps = {
+    repoRoot: string;
+    skipBuild?: boolean;
+    onDone: (outcome: PrerequisitesOutcome) => void;
+    /** Injected so tests can drive the checks without spawning processes. */
+    deps?: Pick<PrerequisiteDeps, 'nodeVersion' | 'homeDir' | 'binaryExists' | 'pathExists' | 'run'>;
+};
+/**
+ * Prerequisites runs as soon as the wizard opens and reports each check as it
+ * finishes. It keeps a driver rather than a per-question screen because the flow
+ * is sequential — a failed check may offer an install, and the next check depends
+ * on that answer.
+ */
+export declare function PrerequisitesScreen({ repoRoot, skipBuild, onDone, deps, }: PrerequisitesScreenProps): React.ReactElement;

package/dist/src/setup/steps/prerequisites/build.d.ts

@@ -0,0 +1,2 @@
+import { type PrerequisiteDeps, type PrerequisiteResult } from './deps.js';
+export declare function runBuildSetup(dependencies: PrerequisiteDeps, repoRoot: string): Promise<PrerequisiteResult>;

package/dist/src/setup/steps/prerequisites/deps.d.ts

@@ -0,0 +1,33 @@
+import type { binaryExists, pathExists, runSpawn } from '../../lib/shell.js';
+export type PrerequisiteEventKind = 'success' | 'failure' | 'warning' | 'info';
+export interface PrerequisiteEvent {
+    kind: PrerequisiteEventKind;
+    message: string;
+}
+/**
+ * What the prerequisite checks need from the outside world.
+ *
+ * Unlike the other steps, this one is a sequential process rather than a form —
+ * it checks Node, may offer to install a version manager, checks pnpm, may offer
+ * corepack or npm, then installs and builds. Those mid-flow confirmations mean it
+ * keeps an imperative shape, so it takes `confirm` and `emit` rather than
+ * rendering each question itself.
+ */
+export interface PrerequisiteDeps {
+    nodeVersion: string;
+    homeDir: string;
+    binaryExists: typeof binaryExists;
+    pathExists: typeof pathExists;
+    run: typeof runSpawn;
+    confirm(question: string, defaultYes?: boolean): Promise<boolean>;
+    emit(event: PrerequisiteEvent): void;
+}
+export interface PrerequisiteResult {
+    passed: boolean;
+}
+export interface PrerequisitesOutcome {
+    node: PrerequisiteResult;
+    pnpm?: PrerequisiteResult;
+    build?: PrerequisiteResult;
+}
+export declare function emit(deps: PrerequisiteDeps, kind: PrerequisiteEventKind, message: string): void;

package/dist/src/setup/steps/prerequisites/index.d.ts

@@ -0,0 +1,4 @@
+import type { PrerequisiteDeps, PrerequisitesOutcome } from './deps.js';
+export declare function runPrerequisitesSetup(dependencies: PrerequisiteDeps, repoRoot: string, options?: {
+    skipBuild?: boolean;
+}): Promise<PrerequisitesOutcome>;

package/dist/src/setup/steps/prerequisites/node.d.ts

@@ -0,0 +1,2 @@
+import { type PrerequisiteDeps, type PrerequisiteResult } from './deps.js';
+export declare function runNodeSetup(dependencies: PrerequisiteDeps): Promise<PrerequisiteResult>;

package/dist/src/setup/steps/prerequisites/pnpm.d.ts

@@ -0,0 +1,2 @@
+import { type PrerequisiteDeps, type PrerequisiteResult } from './deps.js';
+export declare function runPnpmSetup(dependencies: PrerequisiteDeps, repoRoot: string): Promise<PrerequisiteResult>;

package/dist/src/tui/render-with-goodbye.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type Instance, type RenderOptions } from 'ink';
+export declare function useScreenTransitionClear(): () => void;
+export declare function GoodbyeBoundary({ children }: {
+    children: React.ReactNode;
+}): React.ReactElement;
+export declare function renderWithGoodbye(element: React.ReactElement, options?: RenderOptions): Instance;

package/dist/src/tui/use-terminal-size.d.ts

@@ -0,0 +1,6 @@
+export type TerminalSize = {
+    columns: number;
+    rows: number;
+};
+/** Keep layout consumers synchronized with terminal resize events. */
+export declare function useTerminalSize(): TerminalSize;

package/dist/src/tui/windowed-panel.d.ts

@@ -0,0 +1,37 @@
+import { type BoxProps } from 'ink';
+import type { ReactElement, ReactNode } from 'react';
+export type WindowDirection = 'up' | 'down';
+/** Size a standalone panel to the terminal while reserving a small safety margin. */
+export declare function terminalPanelHeight(rows: number, reservedRows?: number): number;
+export interface WindowedPanelProps {
+    width: number;
+    height?: number;
+    title?: string;
+    focused: boolean;
+    children: ReactNode;
+}
+export interface FixedPanelProps {
+    width: number;
+    height?: number;
+    minHeight?: BoxProps['minHeight'];
+    focused?: boolean;
+    borderStyle?: BoxProps['borderStyle'];
+    borderColor?: BoxProps['borderColor'];
+    paddingLeft?: BoxProps['paddingLeft'];
+    clipOverflow?: boolean;
+    children: ReactNode;
+}
+/** Shared panel frame that clips content instead of resizing its layout slot. */
+export declare function FixedPanel({ width, height, minHeight, focused, borderStyle, borderColor, paddingLeft, clipOverflow, children, }: FixedPanelProps): ReactElement;
+/** Shared frame for panels whose viewport must not change with their contents. */
+export declare function WindowedPanel({ width, height, title, focused, children }: WindowedPanelProps): ReactElement;
+export declare function WindowedPanelHeader({ title, width, focused, }: {
+    title: string;
+    width: number;
+    focused: boolean;
+}): ReactElement;
+export declare function formatWindowIndicator(direction: WindowDirection, count: number): string;
+export declare function WindowIndicator({ direction, count }: {
+    direction: WindowDirection;
+    count: number;
+}): ReactElement;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.35.0-alpha.0",
+  "version": "2.35.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -29,6 +29,7 @@
     "skills/"
   ],
   "dependencies": {
+    "@inkjs/ui": "^2.0.0",
     "@segment/analytics-node": "^3.0.0",
     "@vue/compiler-sfc": "^3.5.31",
     "commander": "^13.1.0",
@@ -40,8 +41,8 @@
     "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.35.0-alpha.0",
-    "@contentful/experience-design-system-cli-v2": "2.35.0-alpha.0"
+    "@contentful/experience-design-system-cli-v2": "2.35.0",
+    "@contentful/experience-design-system-types": "2.35.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",
@@ -53,9 +54,9 @@
     "ink-testing-library": "^4.0.0",
     "typescript-eslint": "^8.67.0",
     "vitest": "^4.0.16",
-    "@contentful/experience-design-system-extraction": "2.35.0-alpha.0",
-    "@contentful/experience-design-system-client": "2.35.0-alpha.0",
-    "@contentful/experience-design-system-generation": "2.35.0-alpha.0"
+    "@contentful/experience-design-system-client": "2.35.0",
+    "@contentful/experience-design-system-generation": "2.35.0",
+    "@contentful/experience-design-system-extraction": "2.35.0"
   },
   "repository": {
     "type": "git",