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

package/README.md

@@ -6,11 +6,11 @@ CLI for extracting, reviewing, generating, validating, and pushing Contentful Ex
 
 The package installs three equivalent binaries:
 
-| Binary                          | Notes                                                                |
-| ------------------------------- | -------------------------------------------------------------------- |
-| `experiences`                   | Preferred entry point — short and operator-facing                    |
-| `exo`                           | Shorthand for Experience Orchestration                               |
-| `experience-design-system-cli`  | Full name; used in CI / scripts where clarity matters                |
+| Binary                         | Notes                                                 |
+| ------------------------------ | ----------------------------------------------------- |
+| `experiences`                  | Preferred entry point — short and operator-facing     |
+| `exo`                          | Shorthand for Experience Orchestration                |
+| `experience-design-system-cli` | Full name; used in CI / scripts where clarity matters |
 
 The rest of this README uses `experiences`.
 
@@ -18,11 +18,13 @@ The rest of this README uses `experiences`.
 
 The CLI has two primary workflows:
 
-1. **`experiences import`** — the wizard. Drives the full pipeline (extract → AI select → scope-gate → internal generation → final-review → save/push) from a single command in a full-screen interactive TUI. **This is the recommended path for almost everyone.**
+1. **`experiences import`** — the wizard. Drives the full pipeline (extract → AI select → scope-gate → generation → final-review → save and push) from a single command in a full-screen interactive TUI. **This is the recommended path for almost everyone.**
 
-2. **`experiences apply`** — applies generated component and token definitions to Contentful.
+2. **`experiences apply <file>`** — applies a CDF file of component and token definitions to Contentful.
 
-The import wizard owns extraction, selection, generation, validation, and apply orchestration internally; those implementation stages are not exposed as standalone commands.
+`experiences setup` and `experiences doctor` configure and check your environment. `experiences importv2` launches the newer v2 TUI, and `experiences build` rebuilds a local checkout and re-links the binaries.
+
+The import wizard owns extraction, selection, generation, validation, and apply orchestration internally; those implementation stages are not exposed as public commands. Hidden internal commands (`__extract`, `__generate`, `map tokens`, `print`) are what the wizard runs in subprocesses.
 
 All intermediate data flows through a local SQLite session database (`~/.contentful/experience-design-system-cli/pipeline.db`). No JSON files are written between steps — each pipeline step reads its inputs from the session and writes its outputs back to it.
 
@@ -32,21 +34,14 @@ All intermediate data flows through a local SQLite session database (`~/.content
 
 A **composite component** is one that renders other components inside it — a `Card` that slots a `Button` and an `Icon`, a `Tabs` that slots `Tab` panels. When you import composite components, the CLI can populate each slot's `$allowedComponents` so the parent→child relationships survive into Contentful.
 
-### Atomic vs. composite
-
-Imports are **atomic by default** — flat components, no embedded hierarchy. This is the right choice when you just want each component registered on its own. Opt into hierarchy resolution with `--composite` (or any composition flag, which implies it).
-
-| Mode | Flag | Behavior |
-|---|---|---|
-| Atomic | default | Flat import; composition stripped before push |
-| Composite | `--composite` | Resolve and import the parent→child hierarchy |
+All imports use composite mode: embedded-component relationships are resolved and preserved in the generated CDF.
 
 ### How composition is resolved
 
-Under `--composite`, relationships are resolved from the highest-confidence source available, in this precedence order:
+Relationships are resolved from the highest-confidence source available, in this precedence order:
 
 1. **Typed slots (code)** — slots the source already declares, e.g. React `ReactElement<XProps>` / `children`, Svelte `Snippet<[XProps]>`, or an explicit `@allowedComponents` JSDoc tag. Fully deterministic; picked up automatically.
-2. **Agent** — direct edge emission for codebases that encode composition in *code patterns* rather than typed slots (common in real-world design systems). It is enabled automatically in composite mode and only runs when the deterministic sources above find nothing.
+2. **Agent** — direct edge emission for codebases that encode composition in _code patterns_ rather than typed slots (common in real-world design systems). It is enabled automatically in composite mode and only runs when the deterministic sources above find nothing.
 
 When more than one source speaks to the same relationship, the higher-precedence one wins (**code slots > agent**).
 
@@ -55,7 +50,7 @@ When more than one source speaks to the same relationship, the higher-precedence
 The composition agent emits one structured edge per relationship. The CLI validates component names and merges those edges with deterministic sources by provenance and precedence.
 
 - `--no-cache` — ignore caches and re-resolve composition from scratch, forcing the agent to run.
-- `--agent <name>` — which coding agent authors the parser (`claude`, `codex`, `opencode`, `cursor`, `copilot`).
+- `--agent <name>` — which coding agent runs composition, and the rest of the wizard's agent stages (`claude`, `codex`, `opencode`, `cursor`, `copilot`).
 - `--prompt composition=<file-or-text>` — override the composition stage's prompt.
 
 Because the agent path spawns a coding agent, it adds latency and cost and is best-effort.
@@ -72,13 +67,13 @@ If the resolved graph contains a circular slot dependency (A slots B, B slots A)
 
 The import wizard's generation steps require a coding agent CLI in your `$PATH`. Choose one:
 
-| Agent | Install | Auth |
-|---|---|---|
-| **Claude Code** (`claude`) | `npm install -g @anthropic-ai/claude-code` | `claude login` (browser OAuth) **or** set `ANTHROPIC_API_KEY` |
-| **OpenAI Codex** (`codex`) | `npm install -g @openai/codex` | Set `OPENAI_API_KEY` |
-| **OpenCode** (`opencode`) | `npm install -g opencode-ai` | Configure via `opencode auth` (supports multiple providers) |
-| **Cursor** (`cursor`) | Install [Cursor](https://cursor.com) | Sign in to Cursor; exposes `cursor-agent` binary |
-| **GitHub Copilot** (`copilot`) | `npm install -g @github/copilot` | Run `copilot` once to complete GitHub OAuth login. Free plan uses Auto model selection by default. Paid plans can pin a specific model via `EDS_AGENT_MODEL_COPILOT=<model-id>` (e.g. `claude-sonnet-4.6`) |
+| Agent                          | Install                                    | Auth                                                                                                                                                                                                       |
+| ------------------------------ | ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Claude Code** (`claude`)     | `npm install -g @anthropic-ai/claude-code` | `claude login` (browser OAuth) **or** set `ANTHROPIC_API_KEY`                                                                                                                                              |
+| **OpenAI Codex** (`codex`)     | `npm install -g @openai/codex`             | Set `OPENAI_API_KEY`                                                                                                                                                                                       |
+| **OpenCode** (`opencode`)      | `npm install -g opencode-ai`               | Configure via `opencode auth` (supports multiple providers)                                                                                                                                                |
+| **Cursor** (`cursor`)          | Install [Cursor](https://cursor.com)       | Sign in to Cursor; exposes `cursor-agent` binary                                                                                                                                                           |
+| **GitHub Copilot** (`copilot`) | `npm install -g @github/copilot`           | Run `copilot` once to complete GitHub OAuth login. Free plan uses Auto model selection by default. Paid plans can pin a specific model via `EDS_AGENT_MODEL_COPILOT=<model-id>` (e.g. `claude-sonnet-4.6`) |
 
 The CLI invokes the agent non-interactively in a subprocess. If the binary is not found in `$PATH`, the command exits 1 and prints manual fallback instructions.
 
@@ -86,7 +81,7 @@ The CLI invokes the agent non-interactively in a subprocess. If the binary is no
 
 ### Contentful credentials
 
-`apply` and `import` (when pushing) require access to a Contentful space. Set these environment variables or pass the equivalent flags:
+`apply` and `import` (when pushing) require access to a Contentful space. Configure these environment variables or run `experiences setup`:
 
 ```bash
 export CONTENTFUL_MANAGEMENT_TOKEN=<your-cma-token>   # required
@@ -96,7 +91,7 @@ export CONTENTFUL_ENVIRONMENT_ID=master                # required
 
 Or run `experiences setup` once and they get saved to `credentials.json` and pre-filled in the wizard.
 
-In the wizard's credentials step you can press `[s] Skip` to save-only without pushing — useful when you want a checked-in `components.json` without a live push.
+In the wizard's credentials step you can press `[s] Skip` to save-only without pushing — useful when you want a checked-in combined CDF file without a live push.
 
 ---
 
@@ -110,38 +105,40 @@ experiences import [flags]
 
 ### Wizard step machine
 
+The order below is the normal path. The first step depends on how the wizard is started: `--project` jumps straight to `token-input`, and `--tokens` jumps to `path-validation` (with `--project`) or `credentials` (without it).
+
 ```
-welcome
+welcome                — project path
   ↓
-extracting             — runs analyze extract (atomic by default; resolves composition
-                         under --composite, see below); spawns internal generation in parallel (prefetch)
+token-input            — optional raw token file; Enter on an empty field skips
+  ↓                       (token-generation and token-reuse-gate run here when a file is given)
+path-validation        — confirms the project path and how many files will be scanned
   ↓
-[auto-filter]          — analyze select-agent runs automatically
+credentials            — space ID, environment, CMA token and API host, prefilled from
+                         `experiences setup`; press [s] to skip and save files only
   ↓
-scope-gate             — single human review gate: confirm AI selection, toggle components
+extracting             — composite relationships enabled; the selection agent runs here
+                         once components are extracted
   ↓
-credentials            — operator reviews the prefilled space-id / env / token (internal generation is already running)
-                         press [s] Skip to save-only without pushing
+scope-gate             — single human review gate: confirm the AI selection, toggle components
   ↓
-final-review           — minimum-viable port of the JsonEditor; edit names, $description,
-                         $default, $allowedComponents per slot, $values, source/rationale panels
+generating             — component generation, then token mapping when a token file was given
   ↓
-preview                — diff vs. live Contentful
+final-review           — edit names, $description, $default, $allowedComponents per slot,
+                         $values, with source and rationale panels
   ↓
-push-decision-gate     — choose Save AND push (default) or one of the alternatives
+path-prompt            — where to save `components.json` (and `tokens.json`)
   ↓
-pushing → done         — push emits a Contentful webapp view URL for the imported components
+previewing → preview-gate — diff against live Contentful; confirm to push
+  ↓
+pushing → done         — the push emits a Contentful webapp view URL for the imported components
 ```
 
-There is now a single human review gate (`scope-gate`) before generation; the legacy two-step extract-review + select-review flow has been collapsed.
-
-### Configurable AI auto-filter
+There is a single human review gate (`scope-gate`) before generation. Choosing to skip credentials still saves the files; it bypasses the preview and refuses to push.
 
-The auto-filter (`analyze select-agent` invoked before scope-gate) is on by default; the value selected in setup is persisted to `credentials.json` so subsequent runs default to your saved preference.
+### Save and push
 
-### Save-and-push default
-
-The push-decision-gate defaults to **save AND push**: it writes `components.json` and `tokens.json` to disk *and* pushes to Contentful in one step.
+After final-review the wizard always saves one combined `components.json` CDF (components and design tokens) and then, unless credentials were skipped, previews the diff and pushes it to Contentful. The wizard records each saved run in `~/.config/experiences/runs.json`.
 
 ### Custom skill prompts
 
@@ -149,54 +146,41 @@ Custom `.md` skill prompt paths can be saved via `experiences setup`; the CLI em
 
 ### Flag reference — `experiences import`
 
-| Flag                              | Default                                | Description                                                                                                  |
-| --------------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
-| `--project <path>`                | `.`                                    | Project root to analyze                                                                                      |
-| `--agent <name>`                  | saved by setup / `claude`              | Agent for `analyze select-agent` and internal generation                                                     |
-| `--model <name>`                  | agent default                          | Model name                                                                                                   |
-| `--composite`                     | —                                      | Import the embedded-component hierarchy (any composition flag implies this)                                   |
-| `--composition-map <path>`        | —                                      | Consume a hand-authored parent→children interchange map (implies `--composite`)                              |
-| `--prompt <stage=value>`          | —                                      | Override a stage prompt (repeatable); value is a file path or literal text, e.g. `--prompt composition=./p.md` |
-| `--skip-map-tokens`               | —                                      | Skip the `map tokens` step between internal generation and apply                                             |
-| `--no-cache`                      | cache on                               | Bypass extract/select/internal-generation/map-tokens/composition caches and force re-run                    |
+| Flag                     | Default                   | Description                                                                                                                                                         |
+| ------------------------ | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--project <path>`       | `.`                       | Project root to analyze                                                                                                                                             |
+| `--tokens <path>`        | —                         | Raw token source file (SCSS, CSS variables, JS/TS, Style Dictionary, …) to classify and import alongside components; skips the interactive token prompt             |
+| `--agent <name>`         | saved by setup / `claude` | Coding agent, with an optional model as `agent:model` or `"agent model"`                                                                                            |
+| `--prompt <stage=value>` | —                         | Override a stage prompt (repeatable); value is a file path or literal text, e.g. `--prompt select=./p.md`. Stages used today: `composition`, `select`, `map-tokens` |
+| `--no-cache`             | cache on                  | Re-run all steps instead of reusing cached results                                                                                                                  |
 
-### `--model` and `--agent` overrides
+`--model`, `--composition-map`, `--skip-map-tokens` and `--raw-tokens` were removed from `import`. Unknown flags are rejected. Pass the model through `--agent` instead, and use `--tokens` for a token file.
 
-`--model <name>` overrides the stored model for this run. The resolution order is:
+### Choosing the agent and model
 
-1. `--model <name>` flag
-2. `model` field saved in `~/.config/experiences/credentials.json`
-3. Built-in default for the chosen agent
+`--agent` accepts `claude`, `codex`, `opencode`, `cursor` or `copilot`, optionally followed by a model: `--agent claude:sonnet` or `--agent "claude sonnet"`. The agent resolves in this order:
 
-`--agent <name>` works the same way and is a fully functional wizard override — earlier releases plumbed the flag but the commander default shadowed it; the flag now wins over the saved value as expected.
+1. `--agent <name>` flag
+2. `agent` field saved in `~/.config/experiences/credentials.json` by `experiences setup`
+3. Built-in default, `claude`
 
----
-
-### `print components` / `print tokens` / `print validate`
-
-Unchanged from prior releases.
-
-```bash
-experiences print components [--session <id>] [--out <path>]
-experiences print tokens     [--session <id>] [--out <path>]
-experiences print validate   [--components <path>] [--tokens <path>]
-```
-
-`print validate` exits `0` on success, `1` on validation errors.
+The model resolves the same way: the model part of `--agent`, then the `agentModel` field in `credentials.json`, then the agent's own lightweight default. You can also set a model per agent with `EDS_AGENT_MODEL_<AGENT>` (for example `EDS_AGENT_MODEL_CLAUDE`).
 
 ---
 
 ### `apply`
 
-This command is the non-wizard route to the same diff and push logic. Its flag surface is unchanged.
+This command is the non-wizard route to the same diff and push logic. It accepts one CDF file containing all component and design token definitions.
 
 `apply` emits a Contentful webapp view URL for the imported components in its JSON summary (`viewUrl`) so callers can deep-link into the management UI after a successful push.
 
+Design tokens are read from the same CDF file, so there is no separate token flag.
+
 ```bash
-experiences apply
+experiences apply <file>
 ```
 
-Shared flags: `--components`, `--tokens`. `apply` is interactive and loads credentials from `experiences setup` or environment variables. Remote ComponentTypes and DesignTokens missing from the pushed manifest are always skipped.
+`apply` is interactive and loads credentials from `experiences setup` or environment variables. Remote ComponentTypes and DesignTokens missing from the pushed manifest are always skipped.
 
 Design tokens are written first (component types may reference token kinds). Each entity write is recorded in the session database atomically — interrupted pushes resume from where they left off.
 
@@ -210,9 +194,7 @@ All pipeline state is stored in `~/.contentful/experience-design-system-cli/pipe
 
 ## Terminal Compatibility
 
-- Minimum 60 columns required for the wizard and the `analyze select` TUI
-- 80+ columns recommended for full sidebar + detail view
-- 120+ columns required to show the source code panel in `analyze select`
+- The scope-gate step shows two columns at 100 or more terminal columns and one column below that; a wider terminal is more comfortable for the final-review editor
 - `NO_COLOR=1` suppresses all ANSI color output
 - Interactive views require both stdin and stdout to be TTYs and stdin to support raw mode.
 - On Windows, use Windows Terminal with PowerShell. Older ConEmu and cmd.exe hosts may not provide the raw-mode support the interactive UI needs.
@@ -235,7 +217,7 @@ What may be included:
 
 You can turn this off two ways:
 
-- Persistently: run `experiences setup` and answer "yes" at the analytics prompt. This writes an opt-out to `~/.config/experiences/credentials.json` that persists across invocations until you change it again — it will not silently re-enable itself.
+- Persistently: run `experiences setup`, open **Usage analytics** and choose "Don't share usage data". This writes `analyticsDisabled: true` to `~/.config/experiences/credentials.json`, which persists across invocations until you change it again — it will not silently re-enable itself.
 - Per invocation:
 
   ```bash

package/dist/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",
@@ -40,6 +40,7 @@
   "dependencies": {
     "@contentful/experience-design-system-cli-v2": "workspace:*",
     "@contentful/experience-design-system-types": "workspace:*",
+    "@inkjs/ui": "^2.0.0",
     "@segment/analytics-node": "^3.0.0",
     "@vue/compiler-sfc": "^3.5.31",
     "commander": "^13.1.0",

package/dist/src/analyze/composition/interchange-schema.d.ts

@@ -1,17 +1,11 @@
 /**
  * The CLI-owned composition interchange format (spec T1).
  *
- * Two views of the same data:
- *  - `InterchangeMap` — the human-authored / on-disk `{ version, groups }`
- *    shape (parent → children), consumed by the composition-map option.
- *    `--composition-map` consumes and the resolver can emit.
- *  - `CompositionEdge[]` — the flat internal runtime view, one edge per
- *    parent→child relationship, carrying optional `slot` (T7), `confidence`,
- *    and `provenance`. Easier to merge/dedupe across sources (T2).
- *
- * This module owns both shapes and the converters between them.
+ * `CompositionEdge[]` is the flat internal runtime view, one edge per
+ * parent→child relationship, carrying optional `slot` (T7), `confidence`,
+ * and `provenance`. It is easier to merge and dedupe across sources (T2).
  */
-export type EdgeProvenance = 'user' | 'typed-slot' | 'structural' | 'manifest' | 'doc' | `adapter:${string}` | 'agent';
+export type EdgeProvenance = 'typed-slot' | 'structural' | 'manifest' | 'doc' | `adapter:${string}` | 'agent';
 export type CompositionEdge = {
     parent: string;
     child: string;
@@ -21,17 +15,3 @@ export type CompositionEdge = {
     confidence?: number;
     provenance: EdgeProvenance;
 };
-export type InterchangeMap = {
-    version: 1;
-    groups: Record<string, string[]>;
-};
-export type ValidateResult = {
-    valid: true;
-    map: InterchangeMap;
-} | {
-    valid: false;
-    errors: string[];
-};
-export declare function validateInterchangeMap(input: unknown): ValidateResult;
-export declare function groupsToEdges(map: InterchangeMap, provenance: EdgeProvenance): CompositionEdge[];
-export declare function edgesToGroups(edges: CompositionEdge[]): InterchangeMap;

package/dist/src/analyze/composition/resolve-mapping-cli.d.ts

@@ -1,18 +1,9 @@
-import { type InterchangeMap } from './interchange-schema.js';
 export type CompositionCliOptions = {
-    /** `--composition-map <path>` — hand-authored interchange file. */
-    compositionMap?: string;
     /** `--composition-refresh` — force edge emission to run even over resolved residue. */
     compositionRefresh?: boolean;
+    /** `--no-cache` — force the composition agent to rerun with the rest of the pipeline. */
+    noCache?: boolean;
 };
-export type LoadUserMapResult = {
-    ok: true;
-    map: InterchangeMap;
-} | {
-    ok: false;
-    error: string;
-};
-export declare function loadUserMap(path: string): Promise<LoadUserMapResult>;
 export type ResolvedCompositionSources = {
     forceAgent: boolean;
 };

package/dist/src/analyze/composition/resolve-mapping.d.ts

@@ -1,9 +1,8 @@
 import type { RawComponentDefinition } from '../../types.js';
-import { type CompositionEdge, type InterchangeMap } from './interchange-schema.js';
+import type { CompositionEdge } from './interchange-schema.js';
 import { type EdgeConflict } from './merge-edges.js';
 export type ResolveMappingResult = {
     components: RawComponentDefinition[];
-    userMap?: InterchangeMap;
     edges: CompositionEdge[];
     conflicts: EdgeConflict[];
     warnings: string[];
@@ -11,9 +10,9 @@ export type ResolveMappingResult = {
 /**
  * Orchestrate composition-edge acquisition and enrichment.
  *
- * Sources by rank: user map (1) > typed-slot / "code slots" (2) > structural
- * usage evidence (3) > manifest (4) > doc (5) > adapter-resolved / extraEdges
- * (6) > edge-emitting agent (7). Manifest/doc edges are computed deterministically outside
+ * Sources by rank: typed-slot / "code slots" (2) > structural usage evidence
+ * (3) > manifest (4) > doc (5) > adapter-resolved / extraEdges (6) >
+ * edge-emitting agent (7). Manifest/doc edges are computed deterministically outside
  * this function (see manifest-doc-evidence.ts) and joined via `extraEdges`.
  * ALL sources — including the code slots already on the incoming components —
  * are fed into one ranked merge and unioned; non-conflicting edges from every
@@ -28,7 +27,6 @@ export type ResolveMappingResult = {
  */
 export declare function resolveMapping(input: {
     components: RawComponentDefinition[];
-    userMap?: InterchangeMap;
     forceAgent?: boolean;
     files: Array<{
         path: string;
@@ -55,7 +53,7 @@ export declare function resolveMapping(input: {
     /**
      * Pre-resolved edges from an external source (e.g. manifest or documentation)
      * path). They join the ranked merge at their own provenance rank alongside
-     * code slots and the user map.
+     * code slots and other automatic mapping sources.
      */
     extraEdges?: CompositionEdge[];
 }): Promise<ResolveMappingResult>;

package/dist/src/analyze/extract-command.d.ts

@@ -1,3 +1,7 @@
 import type { Command } from 'commander';
+export declare function resolveExtractNoCache(opts: {
+    cache?: boolean;
+    noCache?: boolean;
+}): boolean;
 export declare function collectSourceFiles(directory: string, onProgress?: (scannedCount: number) => void): Promise<string[]>;
 export declare function registerInternalExtractCommand(program: Command): void;

package/dist/src/analyze/select/tui/components/FieldEditor.d.ts

@@ -17,6 +17,7 @@ export type FieldEditorProps = {
     value: string;
     width: number;
     height: number;
+    fixedHeight?: boolean;
     active?: boolean;
     onChange: (value: string) => void;
     onSave: () => void;
@@ -40,6 +41,7 @@ export type FieldEditorProps = {
         name: string;
     };
     showHiddenProps?: boolean;
+    showInlineRationales?: boolean;
 };
 export declare function simulateGraphWithCandidate(projectSlotGraph: ComponentSlotInfo[], selfName: string, currentSlots: {
     name: string;
@@ -58,5 +60,5 @@ export declare function computeAllowedComponentReplacementCandidates(projectSlot
     name: string;
     allowedComponents: string[];
 }[], targetSlotName: string, replaceIndex: number): string[];
-export declare function FieldEditor({ value, width, height, active, onChange, onSave, onDiscard, onExit, metadata, onTogglePropRationale, propRationaleKey, onToggleComponentRationale, componentRationaleKey, onToggleSourceExternal, onTextEntryActiveChange, projectSlotGraph, currentComponentName, onDirtyChange, discardTrigger, initialFocusTarget, showHiddenProps, }: FieldEditorProps): React.ReactElement;
+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, }: FieldEditorProps): React.ReactElement;
 export {};

package/dist/src/analyze/select/tui/components/FinalizeDialog.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
-/** Max removed-component lines shown at once; the rest scroll with j/k.
+/** Max removed-component lines shown at once; the rest scroll with arrow keys.
  *  Exported so the parent's scroll-offset clamping stays in sync. */
 export declare const FINALIZE_REMOVED_WINDOW = 6;
 type FinalizeDialogProps = {
@@ -15,7 +15,7 @@ type FinalizeDialogProps = {
     /** Status of the accepted-set preview fired when the dialog opened. While
      *  'running', the deletion section shows a spinner instead of a (stale) list. */
     previewStatus?: 'idle' | 'running' | 'done' | 'error';
-    /** Scroll offset into the removed list (owned by the parent; j/k adjust it). */
+    /** Scroll offset into the removed list (owned by the parent; arrow keys adjust it). */
     removedScrollOffset?: number;
 };
 export declare function FinalizeDialog({ accepted, rejected, needsReview, onConfirm, onCancel, removed, previewStatus, removedScrollOffset, }: FinalizeDialogProps): React.ReactElement;

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

@@ -17,6 +17,9 @@ export interface GroupedSidebarProps {
     expandedGroups: Set<string>;
     onToggleExpanded: (rootName: string) => void;
     width: number;
+    height?: number;
+    title?: string;
+    wrapLabels?: boolean;
     focused: boolean;
     renderStatusByKey?: Map<string, RenderStatus>;
     previewAnnotationByKey?: Map<string, PreviewAnnotation>;

package/dist/src/analyze/select/tui/components/HelpOverlay.d.ts

@@ -10,10 +10,12 @@ type HelpOverlayProps = {
     mode: 'analyze' | 'validate' | 'review';
     sections?: undefined;
     onClose: () => void;
+    handleInput?: boolean;
 } | {
     mode?: undefined;
     sections: HelpSection[];
     onClose: () => void;
+    handleInput?: boolean;
 };
 export declare function HelpOverlay(props: HelpOverlayProps): React.ReactElement;
 export {};

package/dist/src/analyze/select/tui/components/Sidebar.d.ts

@@ -7,8 +7,9 @@ export type PreviewBadgeValue = {
     bold?: boolean;
     dim?: boolean;
 };
-export declare function PreviewBadge({ badge }: {
+export declare function PreviewBadge({ badge, highlighted, }: {
     badge: PreviewBadgeValue | null;
+    highlighted?: boolean;
 }): React.ReactElement;
 type SidebarProps = {
     components: ReviewComponentSummary[];

package/dist/src/analyze/select/tui/hooks/scroll-offset.d.ts

@@ -8,15 +8,16 @@
  * binding (caller should NOT update state in that case).
  *
  * Supported bindings:
- * - j / downArrow      → +1 line
- * - k / upArrow        → -1 line
+ * - downArrow          → +1 line
+ * - upArrow            → -1 line
  * - Ctrl+d             → +half-page (floor(panelHeight / 2))
  * - Ctrl+u             → -half-page
  * - PageDown           → +panelHeight
  * - PageUp             → -panelHeight
  * - G                  → jump to maxOffset
  *
- * `g` (single-tap) and `gg` (double-tap → jump to 0) are handled separately
+ * `j`/`k` are intentionally not handled here because they are field-navigation
+ * keys in the editor. `g` (single-tap) and `gg` (double-tap → jump to 0) are handled separately
  * by the caller via a pending-flag ref, since they need transient state.
  */
 export type ScrollKeyState = {

package/dist/src/analyze/select/tui/hooks/useImmediateInput.d.ts

@@ -16,4 +16,4 @@ export type ImmediateInputKey = {
     meta: boolean;
 };
 export type ImmediateInputHandler = (input: string, key: ImmediateInputKey) => void;
-export declare function useImmediateInput(handler: ImmediateInputHandler): void;
+export declare function useImmediateInput(handler: ImmediateInputHandler, enabled?: boolean): void;

package/dist/src/credentials-store.d.ts

@@ -1,4 +1,3 @@
-import { type CompositionMode } from './lib/composition-mode.js';
 export type ExperiencesCredentials = {
     spaceId: string;
     environmentId: string;
@@ -8,31 +7,12 @@ export type ExperiencesCredentials = {
     agentModel?: string;
     /** Feature 8: persisted custom prompt path for `generate components`. */
     generatePromptPath?: string;
-    /** Feature: default debug-mode (writes JSONL trace of every decision) for all commands. */
+    /** Write JSONL trace of every command decision to ~/.contentful/experience-design-system-cli/debug/. */
     debug?: boolean;
-    /** Persisted opt-out for anonymous CLI usage analytics, set via `experiences setup`. */
+    /** Print plain text with no color; an exported NO_COLOR still wins. */
+    noColor?: boolean;
     analyticsDisabled?: boolean;
-    /**
-     * Feature (atomic mode): default composition mode. `atomic` (default) imports
-     * flat components with no embedded-component hierarchy; `composite` opts into
-     * the slot-graph machinery. Resolved `flag > env > this > default`.
-     */
-    compositionMode?: CompositionMode;
 };
-/**
- * Read persisted Contentful credentials.
- *
- * Precedence (INTEG-4410): what the operator saved on disk via
- * `experiences setup` or the wizard's credentials step wins over ambient
- * `CONTENTFUL_*` / `EDS_HOST` env vars. Env vars are still consulted as a
- * fallback when the field on disk is missing or empty — this preserves
- * back-compat for CI / scripts that only export env and never call setup.
- *
- * The pre-INTEG-4410 order (env-first) silently shadowed saved values, so
- * operators who saved a different space via setup kept seeing the env one
- * pre-filled in the wizard. The saved value now wins; the env fallback only
- * fires when the on-disk field is empty.
- */
 export declare function readExperiencesCredentials(): Promise<ExperiencesCredentials>;
 export declare function writeExperiencesCredentials(creds: ExperiencesCredentials): Promise<void>;
 export declare function experiencesCredentialsPath(): string;

package/dist/src/doctor/checks.d.ts

@@ -0,0 +1,5 @@
+export declare function reportNode(): Promise<boolean>;
+export declare function reportPnpm(pkgRoot: string): Promise<boolean>;
+export declare function reportDependencies(pkgRoot: string): Promise<boolean>;
+export declare function reportBuild(pkgRoot: string): Promise<boolean>;
+export declare function reportAgent(): Promise<boolean>;

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

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerDoctorCommand(program: Command): void;

package/dist/src/doctor/report.d.ts

@@ -0,0 +1,7 @@
+export declare function ok(msg: string): void;
+export declare function fail(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function info(msg: string): void;
+export declare function section(title: string): void;
+/** Echo the first `limit` lines of a failed command's stderr. */
+export declare function infoStderr(stderr: string, limit: number): void;

package/dist/src/import/agent-model-resolve.d.ts

@@ -1,11 +1,11 @@
 /**
- * Resolution chain for `--agent` and `--model` overrides on `experiences import`.
+ * Resolution chain for the combined `--agent` override on `experiences import`.
  *
  * The wizard path previously hard-defaulted `--agent` to `'claude'` at the
  * commander layer, which (a) shadowed the stored `credentials.json` value when
  * the user passed no flag, and (b) made it impossible to distinguish "user
- * explicitly passed --agent claude" from "user passed nothing". `--model` was
- * registered but never threaded into the wizard subprocesses at all.
+ * explicitly passed --agent claude" from "user passed nothing". The combined
+ * flag accepts either `agent:model` or `agent model`.
  *
  * These helpers produce the resolved values to feed into `WizardApp` /
  * the import wizard:
@@ -15,9 +15,13 @@
  *      `experiences setup`) is used.
  *   3. Otherwise, the built-in default (currently `'claude'`) is used for
  *      the agent. Model has no default — agents pick a small/fast model
- *      themselves when `--model` is omitted.
+ *      themselves when no model is included in `--agent`.
  */
 /** Built-in fallback agent when neither a flag nor a stored preference is set. */
 export declare const DEFAULT_AGENT = "claude";
+export declare function parseAgentModel(value: string | undefined): {
+    agent?: string;
+    model?: string;
+};
 export declare function resolveAgent(flagValue: string | undefined, storedValue: string | undefined): string;
 export declare function resolveModel(flagValue: string | undefined, storedValue: string | undefined): string | undefined;

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

@@ -1,9 +1,7 @@
 export type CompositionOptionInput = {
-    compositionMap?: string;
     prompt?: string[];
 };
 export type CompositionForwardingOptions = {
-    compositionMap?: string;
     promptOverrides?: string[];
 };
 export declare function buildCompositionForwardingOptions(options: CompositionOptionInput): CompositionForwardingOptions;