@contentful/experience-design-system-cli 2.34.5-dev-build-5e798cb1.0 → 2.34.5-dev-build-ea694b2.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/debug-logger.d.ts

@@ -29,9 +29,8 @@ 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
+ *   1. `EDSI_DEBUG` env var (truthy: 1, true, yes, on)
+ *   2. Persisted `debug` field in credentials.json
  *   4. Default: OFF
  */
 export declare function resolveDebugMode(opts: {

package/dist/src/program.d.ts

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.34.5-dev-build-5e798cb1.0",
+  "version": "2.34.5-dev-build-ea694b2.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-cli-v2": "2.34.5-dev-build-5e798cb1.0",
-    "@contentful/experience-design-system-types": "2.34.5-dev-build-5e798cb1.0"
+    "@contentful/experience-design-system-cli-v2": "2.34.5-dev-build-ea694b2.0",
+    "@contentful/experience-design-system-types": "2.34.5-dev-build-ea694b2.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-client": "2.34.5-dev-build-5e798cb1.0",
-    "@contentful/experience-design-system-extraction": "2.34.5-dev-build-5e798cb1.0",
-    "@contentful/experience-design-system-generation": "2.34.5-dev-build-5e798cb1.0"
+    "@contentful/experience-design-system-extraction": "2.34.5-dev-build-ea694b2.0",
+    "@contentful/experience-design-system-generation": "2.34.5-dev-build-ea694b2.0",
+    "@contentful/experience-design-system-client": "2.34.5-dev-build-ea694b2.0"
   },
   "repository": {
     "type": "git",

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/debug-mode-prompt.d.ts

@@ -1,11 +0,0 @@
-/**
- * Ask the operator whether to enable debug logging by default.
- *
- * When ON, every command writes a JSONL trace of its decisions to
- * ~/.contentful/experience-design-system-cli/debug/. Off by default because
- * the trace file grows quickly and contains verbose per-tool-call detail
- * intended for developers debugging the CLI.
- *
- * Injectable `ask` so tests can drive without a TTY.
- */
-export declare function promptDebugModePreference(ask: (q: string) => Promise<string>, current?: boolean): Promise<boolean>;

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

@@ -1 +0,0 @@
-export declare function promptBooleanPreference(ask: (question: string) => Promise<string>, current: boolean | undefined, defaultValue: boolean, question: string): Promise<boolean>;