@contentful/experience-design-system-cli 2.35.0-alpha.0 → 2.35.1-dev-build-041b6e0a.0

package/README.md

@@ -1,263 +0,0 @@
-# @contentful/experience-design-system-cli
-
-CLI for extracting, reviewing, generating, validating, and pushing Contentful Experience Design System component definitions into Experiences.
-
-## Binaries
-
-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                |
-
-The rest of this README uses `experiences`.
-
-## CLI Overview
-
-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.**
-
-2. **`experiences apply`** — applies generated 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.
-
-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.
-
----
-
-## Composite components & composition
-
-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 |
-
-### How composition is resolved
-
-Under `--composite`, 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.
-
-When more than one source speaks to the same relationship, the higher-precedence one wins (**code slots > agent**).
-
-### The composition agent
-
-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`).
-- `--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.
-
-### Slot cycles
-
-If the resolved graph contains a circular slot dependency (A slots B, B slots A), it is detected before push. `apply` and the wizard's push path **refuse to send a manifest with cycles**; the cycle path is reported so you can break it.
-
----
-
-## Prerequisites
-
-### Coding agent
-
-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`) |
-
-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.
-
-`experiences setup` persists your chosen agent (and optional model + custom prompt paths) to `~/.config/experiences/credentials.json`; later commands pick them up automatically.
-
-### Contentful credentials
-
-`apply` and `import` (when pushing) require access to a Contentful space. Set these environment variables or pass the equivalent flags:
-
-```bash
-export CONTENTFUL_MANAGEMENT_TOKEN=<your-cma-token>   # required
-export CONTENTFUL_SPACE_ID=<your-space-id>             # required
-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.
-
----
-
-## The `import` wizard
-
-```bash
-experiences import [flags]
-```
-
-`experiences import` is the primary entry point and launches a full-screen wizard in a supported interactive terminal.
-
-### Wizard step machine
-
-```
-welcome
-  ↓
-extracting             — runs analyze extract (atomic by default; resolves composition
-                         under --composite, see below); spawns internal generation in parallel (prefetch)
-  ↓
-[auto-filter]          — analyze select-agent runs automatically
-  ↓
-scope-gate             — single human review gate: confirm AI selection, toggle components
-  ↓
-credentials            — operator reviews the prefilled space-id / env / token (internal generation is already running)
-                         press [s] Skip to save-only without pushing
-  ↓
-final-review           — minimum-viable port of the JsonEditor; edit names, $description,
-                         $default, $allowedComponents per slot, $values, source/rationale panels
-  ↓
-preview                — diff vs. live Contentful
-  ↓
-push-decision-gate     — choose Save AND push (default) or one of the alternatives
-  ↓
-pushing → done         — 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
-
-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 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.
-
-### Custom skill prompts
-
-Custom `.md` skill prompt paths can be saved via `experiences setup`; the CLI emits a banner at agent invocation when an override is active.
-
-### 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                    |
-
-### `--model` and `--agent` overrides
-
-`--model <name>` overrides the stored model for this run. The resolution order is:
-
-1. `--model <name>` flag
-2. `model` field saved in `~/.config/experiences/credentials.json`
-3. Built-in default for the chosen agent
-
-`--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.
-
----
-
-### `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.
-
----
-
-### `apply`
-
-This command is the non-wizard route to the same diff and push logic. Its flag surface is unchanged.
-
-`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.
-
-```bash
-experiences apply
-```
-
-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.
-
-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.
-
----
-
-## Session Database
-
-All pipeline state is stored in `~/.contentful/experience-design-system-cli/pipeline.db` (SQLite). The path can be overridden with the `EDS_PIPELINE_DB_PATH` environment variable. The push-resumption database is at `~/.contentful/experience-design-system-cli/import.db` (override with `EDS_IMPORT_DB_PATH`).
-
----
-
-## 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`
-- `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.
-- `experiences import` does not provide a non-interactive execution mode.
-
----
-
-## Usage data
-
-The CLI collects **anonymous usage data** to help us understand which commands are used and where the import workflow succeeds or fails. This data does **not** include your source code, file paths, credentials, prompts, or any content you author.
-
-What may be included:
-
-- Command name and duration
-- CLI, Node.js, and operating-system version
-- Anonymous session identifiers that link steps within a single import run
-- Structural counts (for example, how many components were extracted or accepted)
-- Space and environment IDs you pass on the command line
-- Contentful request IDs from API responses (to correlate failures with server logs)
-
-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.
-- Per invocation:
-
-  ```bash
-  DISABLE_ANALYTICS=1 experiences import --project ./my-app
-  ```
-
-  Setting `DISABLE_ANALYTICS` to any value disables collection for that invocation. This is additive with the persisted opt-out — it can only disable, never re-enable, collection that setup has turned off.
-
----
-
-## Development
-
-```bash
-# Install dependencies from repo root
-pnpm install
-
-# Build
-pnpm -F @contentful/experience-design-system-cli build
-
-# Run tests
-pnpm -F @contentful/experience-design-system-cli test
-
-# Typecheck
-pnpm -F @contentful/experience-design-system-cli typecheck
-```

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

@@ -1,37 +0,0 @@
-/**
- * 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.
- */
-export type EdgeProvenance = 'user' | 'typed-slot' | 'structural' | 'manifest' | 'doc' | `adapter:${string}` | 'agent';
-export type CompositionEdge = {
-    parent: string;
-    child: string;
-    /** Optional named slot (T7). Default slot when omitted. */
-    slot?: string;
-    /** 1–5 scale, same as select/reject agent tools. */
-    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,19 +0,0 @@
-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;
-};
-export type LoadUserMapResult = {
-    ok: true;
-    map: InterchangeMap;
-} | {
-    ok: false;
-    error: string;
-};
-export declare function loadUserMap(path: string): Promise<LoadUserMapResult>;
-export type ResolvedCompositionSources = {
-    forceAgent: boolean;
-};
-export declare function resolveCompositionSources(opts: CompositionCliOptions): ResolvedCompositionSources;

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

@@ -1,14 +0,0 @@
-import React from 'react';
-import type { LineageEntry, LineageJumpable } from '../../../../import/tui/hooks/useLineage.js';
-export interface LineagePanelProps {
-    focusedComponentKey: string;
-    entries: LineageEntry[];
-    /** Index into the jumpables list — NOT into entries. */
-    cursor: number;
-    jumpables: LineageJumpable[];
-    /** Max entry rows rendered at once. Larger lineages window around the cursor. */
-    maxRows?: number;
-    /** Constrain the panel box to a fixed column width (e.g. the sidebar slot). */
-    width?: number;
-}
-export declare function LineagePanel({ focusedComponentKey, entries, cursor, jumpables, maxRows, width, }: LineagePanelProps): React.ReactElement;

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

@@ -1,38 +0,0 @@
-import { type CompositionMode } from './lib/composition-mode.js';
-export type ExperiencesCredentials = {
-    spaceId: string;
-    environmentId: string;
-    cmaToken: string;
-    host?: string;
-    agent?: string;
-    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. */
-    debug?: boolean;
-    /** Persisted opt-out for anonymous CLI usage analytics, set via `experiences setup`. */
-    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/import/strip-allowed-components.d.ts

@@ -1,18 +0,0 @@
-import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
-/**
- * Atomic-mode normalization (spec T8, option a): keep every slot's structure
- * but drop its `$allowedComponents` composition constraint. Applied over the
- * loaded component array regardless of source (`--session` or `--components`),
- * so the atomic bypass cannot leak a live composition link into the pushed
- * CDF document. Starving `$allowedComponents` at this single point also makes
- * slot-cycle detection structurally return zero (see T12).
- *
- * Returns a new array with cloned entries; inputs are not mutated.
- */
-export declare function stripAllowedComponents(components: Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>): Array<{
-    key: string;
-    entry: CDFComponentEntry;
-}>;

package/dist/src/import/tui/final-review-host.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-import type { CompositionMode } from '../../lib/composition-mode.js';
-import type { ReviewStepProps } from './review-step-props.js';
-export type FinalReviewHostProps = Omit<ReviewStepProps, 'extractSessionId'> & {
-    extractSessionId: string | null;
-    compositionMode?: CompositionMode;
-};
-export declare function FinalReviewHost({ extractSessionId, tokenSessionId, compositionMode, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }: FinalReviewHostProps): React.ReactElement;

package/dist/src/import/tui/hooks/useLineage.d.ts

@@ -1,32 +0,0 @@
-import { type ComponentGraphNode } from '../../../analyze/composite-closure.js';
-export type LineageEntry = {
-    kind: 'section';
-    label: string;
-} | {
-    kind: 'ancestor';
-    label: string;
-    jumpTarget: string;
-} | {
-    kind: 'descendant';
-    label: string;
-    jumpTarget: string;
-} | {
-    kind: 'empty';
-    label: string;
-};
-export interface LineageJumpable {
-    /** Original index into the `entries` array — callers highlight the source row. */
-    i: number;
-    entry: LineageEntry;
-}
-export interface UseLineageResult {
-    entries: LineageEntry[];
-    /**
-     * Jumpable entries — those the operator can Tab/Enter to. Excludes
-     * `section` / `empty` rows. Order matches `entries` minus the non-jumpable
-     * rows; each item carries the original `entries` index so callers can
-     * highlight the source row.
-     */
-    jumpables: LineageJumpable[];
-}
-export declare function useLineage(focusedKey: string | null, graph: ComponentGraphNode[]): UseLineageResult;

package/dist/src/import/tui/lineage-input.d.ts

@@ -1,18 +0,0 @@
-import type { LineageJumpable } from './hooks/useLineage.js';
-type LineageInputKey = {
-    upArrow: boolean;
-    downArrow: boolean;
-    tab: boolean;
-    return: boolean;
-};
-export declare function handleLineageNavigation({ input, key, cursor, jumpables, onCursorChange, onJump, onClose, allowTab, }: {
-    input: string;
-    key: LineageInputKey;
-    cursor: number;
-    jumpables: LineageJumpable[];
-    onCursorChange: (update: number | ((current: number) => number)) => void;
-    onJump: (name: string) => void;
-    onClose: () => void;
-    allowTab: boolean;
-}): boolean;
-export {};

package/dist/src/import/tui/push-decision-gate-helpers.d.ts

@@ -1,8 +0,0 @@
-import type { PushDecisionChoice } from './steps/PushDecisionGateStep.js';
-export type GateAction = 'save-and-push' | 'push-only' | 'save-only';
-/**
- * Maps a `PushDecisionGateStep` choice to the wizard action it triggers.
- * Centralizing this keeps the gate component free of wizard-side semantics
- * and gives us a unit-testable seam between UI choice and side-effect.
- */
-export declare function chooseGateAction(choice: PushDecisionChoice): GateAction;

package/dist/src/import/tui/review-step-props.d.ts

@@ -1,13 +0,0 @@
-export type ReviewStepProps = {
-    extractSessionId: string;
-    tokenSessionId?: string | null;
-    onFinalize: (accepted: number, rejected: number, unresolved: number) => void;
-    onQuit: () => void;
-    livePreview?: boolean;
-    spaceId?: string;
-    environmentId?: string;
-    cmaToken?: string;
-    host?: string;
-    tokensPath?: string;
-    initialFinalizeError?: string | null;
-};

package/dist/src/import/tui/scope-gate-host.d.ts

@@ -1,21 +0,0 @@
-import React from 'react';
-import type { ScopeComponent } from './steps/ScopeGateStep.js';
-import type { CompositionMode } from '../../lib/composition-mode.js';
-export type { ScopeComponent };
-export type ScopeGateHostProps = {
-    components: ReadonlyArray<ScopeComponent>;
-    compositionMode?: CompositionMode;
-    onConfirm: (decisions: {
-        accepted: string[];
-        rejected: string[];
-    }) => void;
-    onQuit: () => void;
-    /** Retained for fixture compatibility; filtering is no longer performed here. */
-    aiFilterStatus?: string;
-    aiFilterProgress?: {
-        done: number;
-        total: number;
-    } | null;
-    aiFilterError?: string | null;
-};
-export declare function ScopeGateHost({ components, compositionMode, onConfirm, onQuit, }: ScopeGateHostProps): React.ReactElement;

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

@@ -1,28 +0,0 @@
-import React from 'react';
-type GenerateReviewStepProps = {
-    extractSessionId: string;
-    tokenSessionId?: string | null;
-    onFinalize: (accepted: number, rejected: number, unresolved: number) => void;
-    onQuit: () => void;
-    /**
-     * Feature 2 (live preview after every save). When `true` (default), the
-     * wizard re-runs `previewImport` after each successful FieldEditor Ctrl+S
-     * (debounced 500ms) and refreshes the sidebar's previewAnnotation badges.
-     * Live preview is enabled for the wizard flow.
-     */
-    livePreview?: boolean;
-    spaceId?: string;
-    environmentId?: string;
-    cmaToken?: string;
-    host?: string;
-    tokensPath?: string;
-    /**
-     * INTEG-4411 refined: initial value for the inline `finalizeError` banner.
-     * The wizard sets this when it routes back to `final-review` after the
-     * preview API returned an empty diff (pure no-op push). Cleared on the
-     * next `a` / `A` keystroke.
-     */
-    initialFinalizeError?: string | null;
-};
-export declare function AtomicGenerateReviewStep({ extractSessionId, tokenSessionId, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }: GenerateReviewStepProps): React.ReactElement;
-export {};

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

@@ -1,3 +0,0 @@
-import React from 'react';
-import type { ScopeGateStepProps } from './ScopeGateStep.js';
-export declare function AtomicScopeGateStep({ components, onConfirm, onQuit }: ScopeGateStepProps): React.ReactElement;

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

@@ -1,12 +0,0 @@
-import React from 'react';
-export type PushDecisionChoice = 'both' | 'push-only' | 'save-only';
-type PushDecisionGateStepProps = {
-    summary: string;
-    context: string;
-    fileList: string;
-    onChoice: (choice: PushDecisionChoice) => void;
-    onQuit: () => void;
-    pushDisabled?: boolean;
-};
-export declare function PushDecisionGateStep({ summary, context, onChoice, onQuit, pushDisabled, }: PushDecisionGateStepProps): React.ReactElement;
-export {};

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

@@ -1,13 +0,0 @@
-import React from 'react';
-type RunningStepProps = {
-    stepNumber: number;
-    totalSteps: number;
-    title: string;
-    description: string;
-    detail?: string;
-    /** Optional second progress line (own spinner) — e.g. composition resolution
-     *  running after the file scan on the extracting screen. */
-    secondaryDetail?: string;
-};
-export declare function RunningStep({ stepNumber, totalSteps, title, description, detail, secondaryDetail, }: RunningStepProps): React.ReactElement;
-export {};

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

@@ -1 +0,0 @@
-export declare function useTerminalColumns(): number;

package/dist/src/lib/composition-mode.d.ts

@@ -1,21 +0,0 @@
-export declare const COMPOSITION_MODES: readonly ["composite", "atomic"];
-export type CompositionMode = (typeof COMPOSITION_MODES)[number];
-export declare function isCompositionMode(value: string): value is CompositionMode;
-/**
- * Options that, when present, IMPLY composite mode — passing any of them is a
- * clear opt-in, so requiring an explicit `--composite` alongside is redundant.
- */
-export type CompositionSourceOptions = {
-    compositionRefresh?: boolean;
-    compositionMap?: string;
-};
-/**
- * Resolve the effective composition mode with precedence
- * `explicit flag > implied source > env > persisted config > default`.
- * Default is `atomic` (composition OFF); opting into composite mode enables
- * the hierarchy machinery. Passing a composition source implies composite.
- */
-export declare function resolveCompositionMode(opts: {
-    composite?: boolean;
-    atomic?: boolean;
-} & CompositionSourceOptions, configMode?: CompositionMode): CompositionMode;

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

@@ -1,14 +0,0 @@
-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.
- */
-export declare function beginCommand(command: string, opts: {
-    debug?: boolean;
-}): Promise<DebugLogger>;

package/dist/src/runs/save-conflict.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-export type SaveConflictGateProps = {
-    path: string;
-    onOverwrite: () => void;
-    onNew: () => void;
-    onCancel: () => void;
-};
-export declare function SaveConflictGate({ path, onOverwrite, onNew, onCancel }: SaveConflictGateProps): React.ReactElement;

package/dist/src/setup/analytics-prompt.d.ts

@@ -1,13 +0,0 @@
-/**
- * Ask the operator whether to persist an opt-out of anonymous usage analytics.
- *
- * The helper is injectable so it can be unit-tested without a TTY. The caller
- * provides an `ask` function that yields one line of input per call.
- *
- * Behavior:
- *   - Empty input returns `current` if defined, else `false` (default: enabled).
- *   - Input starting with 'y' or 'Y' returns `true` (disabled).
- *   - Input starting with 'n' or 'N' returns `false` (enabled).
- *   - Any other input falls back to the same rule as empty input.
- */
-export declare function promptAnalyticsPreference(ask: (q: string) => Promise<string>, current?: boolean): Promise<boolean>;

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

@@ -1,9 +0,0 @@
-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 function registerSetupCommand(program: Command): void;