@contentful/experience-design-system-cli 2.11.0 → 2.11.1-dev-build-96af281.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.11.0",
+  "version": "2.11.1-dev-build-96af281.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/analyze/select-agent/command.js

@@ -3,6 +3,7 @@ import { appendReviewEvent, getRefineArtifactsRoot, ensureRefineSession, getRefi
 import { loadReviewInput } from '../select/parser.js';
 import { buildPrompt } from '../../generate/prompt-builder.js';
 import { parseSelectToolCallLines, runAgent } from '../../generate/agent-runner.js';
+import { readExperiencesCredentials } from '../../credentials-store.js';
 import { OutputFormatter, c } from '../../output/format.js';
 import { buildRepoContextIndex, buildSelectionContext } from './context-builder.js';
 import { isAbsolute, resolve } from 'node:path';
@@ -174,18 +175,21 @@ export function registerAnalyzeSelectAgentCommand(program) {
         .description('Use an AI agent to select components for Contentful Experience Orchestration')
         .option('--session <id>', 'Session ID from analyze extract (defaults to most recent)')
         .option('--project-root <path>', 'Project root for resolving component source files')
-        .requiredOption('--agent <name>', 'Agent to use: claude, codex, opencode, cursor')
+        .option('--agent <name>', 'Agent to use: claude, codex, opencode, cursor (defaults to value saved by experiences setup)')
         .option('--model <name>', 'Model to use (defaults to a small/fast model per agent)')
         .option('--verbose', 'Show full agent output including reasoning text')
         .option('--dry-run', 'Print the prompt for the first component without invoking the agent')
         .option('--exclude-invalid', 'Auto-reject components with validation errors instead of failing loud (LLM cannot fix structural issues)')
         .action(async (opts) => {
-        if (!VALID_AGENTS.has(opts.agent)) {
-            process.stderr.write(`Error: unknown agent '${opts.agent}'. Accepted values: claude, codex, opencode, cursor\n`);
+        const savedCreds = await readExperiencesCredentials();
+        const agentName = opts.agent ?? savedCreds.agent;
+        const model = opts.model ?? savedCreds.agentModel;
+        if (!agentName || !VALID_AGENTS.has(agentName)) {
+            process.stderr.write(`Error: no agent configured. Pass --agent <name> or run experiences setup. Accepted values: claude, codex, opencode, cursor\n`);
             process.exit(1);
             return;
         }
-        const agent = opts.agent;
+        const agent = agentName;
         const sessionId = resolveSessionId(opts.session);
         const selectionRoot = resolveProjectRoot(sessionId, opts.projectRoot);
         const db = openPipelineDb();
@@ -266,7 +270,7 @@ export function registerAnalyzeSelectAgentCommand(program) {
             process.exit(0);
             return;
         }
-        const selectResults = await selectAllComponents(agent, opts.model, selectionCandidates, opts.verbose ?? false);
+        const selectResults = await selectAllComponents(agent, model, selectionCandidates, opts.verbose ?? false);
         // Build decision map from results. Seed auto-rejections from validation exclusions first.
         const decisions = new Map();
         for (const comp of invalidComponents) {

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

@@ -3,6 +3,8 @@ export type ExperiencesCredentials = {
     environmentId: string;
     cmaToken: string;
     host?: string;
+    agent?: string;
+    agentModel?: string;
 };
 export declare function readExperiencesCredentials(): Promise<ExperiencesCredentials>;
 export declare function writeExperiencesCredentials(creds: ExperiencesCredentials): Promise<void>;

package/dist/src/credentials-store.js

@@ -14,6 +14,8 @@ export async function readExperiencesCredentials() {
             environmentId: process.env['CONTENTFUL_ENVIRONMENT_ID'] ?? parsed.environmentId ?? '',
             cmaToken: process.env['CONTENTFUL_MANAGEMENT_TOKEN'] ?? parsed.cmaToken ?? '',
             ...(host ? { host } : {}),
+            ...(parsed.agent ? { agent: parsed.agent } : {}),
+            ...(parsed.agentModel ? { agentModel: parsed.agentModel } : {}),
         };
     }
     catch {
@@ -27,12 +29,14 @@ export async function readExperiencesCredentials() {
     }
 }
 export async function writeExperiencesCredentials(creds) {
-    const { host: _host, ...rest } = creds;
+    const { host: _host, agent, agentModel, ...rest } = creds;
     const host = toConfiguredHost(creds.host);
     await mkdir(CREDENTIALS_DIR, { recursive: true });
     await writeFile(CREDENTIALS_PATH, JSON.stringify({
         ...rest,
         ...(host ? { host } : {}),
+        ...(agent ? { agent } : {}),
+        ...(agentModel ? { agentModel } : {}),
     }, null, 2) + '\n', { mode: 0o600 });
 }
 export function experiencesCredentialsPath() {

package/dist/src/generate/agent-runner.js

@@ -197,7 +197,7 @@ const AGENT_BINARIES = {
 // Default to small/fast models for single-component classification — cheap and accurate enough.
 const DEFAULT_MODELS = {
     claude: 'haiku',
-    codex: 'gpt-4.1-nano', // requires OPENAI_API_KEY; ChatGPT account users must pass --model
+    codex: 'gpt-5.4-mini', // requires OPENAI_API_KEY; ChatGPT account users must pass --model
     opencode: 'claude-haiku-4-5',
     cursor: 'claude-3-5-haiku-20241022',
 };
@@ -225,8 +225,11 @@ export async function runAgent(options) {
     const args = buildArgs(agent, prompt, model);
     return new Promise((resolve) => {
         const child = spawn(binary, args, {
-            stdio: interactive ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+            stdio: interactive ? 'inherit' : ['pipe', 'pipe', 'pipe'],
         });
+        if (!interactive) {
+            child.stdin?.end();
+        }
         let stdout = '';
         let stderr = '';
         let timedOut = false;

package/dist/src/generate/command.js

@@ -11,6 +11,7 @@ import { GenerateView } from './tui/GenerateView.js';
 import { registerGenerateEditCommand } from './edit/command.js';
 import { openPipelineDb, loadRawComponents, applyToolCalls, applyTokenToolCalls, computeComponentInputHash, computeTokenInputHash, lookupCache, lookupCacheByEntity, storeCache, copyComponentFromCache, copyTokensFromCache, renameEmptySlots, } from '../session/db.js';
 import { getRefineArtifactsRoot, getRefineSessionPaths } from '../analyze/select/persistence.js';
+import { readExperiencesCredentials } from '../credentials-store.js';
 const execFileAsync = promisify(execFile);
 const VALID_AGENTS = new Set(['claude', 'codex', 'opencode', 'cursor']);
 const DEFAULT_TIMEOUT_MS = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 3 * 60 * 1000);
@@ -292,10 +293,13 @@ async function loadAcceptedNames(sessionId) {
     }
 }
 async function runGenerateSkill(skill, opts, verbose = false) {
-    if (!VALID_AGENTS.has(opts.agent)) {
-        die(`Error: unknown agent '${opts.agent}'. Accepted values: claude, codex, opencode, cursor`);
+    const savedCreds = await readExperiencesCredentials();
+    const agentName = opts.agent ?? savedCreds.agent;
+    const model = opts.model ?? savedCreds.agentModel;
+    if (!agentName || !VALID_AGENTS.has(agentName)) {
+        die(`Error: no agent configured. Pass --agent <name> or run experiences setup. Accepted values: claude, codex, opencode, cursor`);
     }
-    const agent = opts.agent;
+    const agent = agentName;
     if (skill === 'tokens' && !opts.rawTokens) {
         die('Error: --raw-tokens is required when using generate tokens');
     }
@@ -386,7 +390,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
         const db = openPipelineDb();
         let componentResults;
         try {
-            componentResults = await runAllComponents(agent, opts.model, db, sessionId, allComponents, tokensInline, tokenMapInline, verbose, opts.cache === false || process.env.EDS_NO_CACHE === '1');
+            componentResults = await runAllComponents(agent, model, db, sessionId, allComponents, tokensInline, tokenMapInline, verbose, opts.cache === false || process.env.EDS_NO_CACHE === '1');
         }
         finally {
             db.close();
@@ -478,7 +482,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
             });
             const result = await runAgent({
                 agent,
-                model: opts.model,
+                model,
                 prompt,
                 interactive: false,
                 timeoutMs: DEFAULT_TIMEOUT_MS * 5,
@@ -533,7 +537,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
 }
 function addAgentFlags(cmd) {
     return cmd
-        .requiredOption('--agent <name>', 'Agent to use: claude, codex, opencode, cursor')
+        .option('--agent <name>', 'Agent to use: claude, codex, opencode, cursor (defaults to value saved by experiences setup)')
         .option('--model <name>', 'Model to use (defaults to a small/fast model per agent)')
         .option('--verbose', 'Show full agent output including reasoning text')
         .option('--dry-run', 'Print the prompt without invoking the agent')

package/dist/src/setup/command.js

@@ -329,28 +329,80 @@ async function setupBuild(repoRoot) {
     return true;
 }
 // ── Step 4: agent CLI ─────────────────────────────────────────────────────────
+const AGENT_DEFS = [
+    { name: 'Claude Code', binary: 'claude', installHint: 'npm install -g @anthropic-ai/claude-code && claude login' },
+    { name: 'OpenAI Codex', binary: 'codex', installHint: 'npm install -g @openai/codex  (requires OPENAI_API_KEY)' },
+    { name: 'OpenCode', binary: 'opencode', installHint: 'npm install -g opencode-ai && opencode auth' },
+];
+function pick(items, defaultIdx = 0) {
+    items.forEach((item, i) => {
+        const num = `\x1b[1m[${i + 1}]\x1b[0m`;
+        const desc = item.description ? `  \x1b[2m${item.description}\x1b[0m` : '';
+        const def = i === defaultIdx ? `  \x1b[2m(default)\x1b[0m` : '';
+        process.stdout.write(`     ${num} ${item.label}${desc}${def}\n`);
+    });
+    process.stdout.write(`     \x1b[2m[s] Skip\x1b[0m\n`);
+}
+async function promptCodexModel() {
+    if (process.env['OPENAI_API_KEY'])
+        return undefined; // API key users get the default (gpt-4.1-nano)
+    info('');
+    process.stdout.write(`     \x1b[33m⚠\x1b[0m  No OPENAI_API_KEY — using ChatGPT account authentication.\n`);
+    info('  Tip: run \x1b[1mcodex\x1b[0m then type \x1b[1m/model\x1b[0m to browse all available models.');
+    info('');
+    info('  Choose a model:');
+    info('');
+    pick([
+        { label: 'gpt-5.4-mini', description: 'fast, lower cost' },
+        { label: 'gpt-5.5', description: 'most capable' },
+        { label: 'gpt-5.4' },
+    ]);
+    info('');
+    const choice = await prompt('  \x1b[2m›\x1b[0m Your choice [1]: ');
+    if (choice === '1' || choice === '')
+        return 'gpt-5.4-mini';
+    if (choice === '2')
+        return 'gpt-5.5';
+    if (choice === '3')
+        return 'gpt-5.4';
+    return undefined;
+}
 async function setupAgent() {
-    section('Step 4: Coding agent (claude, codex, opencode, or cursor)', '[required]');
+    section('Step 4: Coding agent (claude, codex, or opencode)', '[required]');
     info('experiences import uses a coding agent to generate component definitions.');
     info('');
-    const agents = [
-        { name: 'Claude Code', binary: 'claude', installHint: 'npm install -g @anthropic-ai/claude-code && claude login' },
-        { name: 'OpenAI Codex', binary: 'codex', installHint: 'npm install -g @openai/codex  (requires OPENAI_API_KEY)' },
-        { name: 'OpenCode', binary: 'opencode', installHint: 'npm install -g opencode-ai && opencode auth' },
-    ];
-    for (const agent of agents) {
-        if (await binaryExists(agent.binary)) {
-            ok(`${agent.name} (${agent.binary}) found`);
-            return true;
-        }
+    const found = (await Promise.all(AGENT_DEFS.map(async (a) => ((await binaryExists(a.binary)) ? a : null)))).filter((a) => a !== null);
+    if (found.length === 1) {
+        ok(`${found[0].name} (${found[0].binary}) found`);
+        const agentModel = found[0].binary === 'codex' ? await promptCodexModel() : undefined;
+        return { agent: found[0].binary, agentModel };
+    }
+    if (found.length > 1) {
+        info('Multiple coding agents found. Choose one to use as the default:');
+        info('');
+        pick(found.map((a) => ({ label: `${a.name}`, description: a.binary })));
+        info('');
+        const choice = await prompt('  \x1b[2m›\x1b[0m Your choice [1]: ');
+        if (choice.toLowerCase() === 's') {
+            warn('Skipped. Install a coding agent before running experiences import.');
+            return { agent: undefined, agentModel: undefined };
+        }
+        const parsed = choice === '' ? 1 : parseInt(choice, 10);
+        const idx = Number.isNaN(parsed) || parsed < 1 || parsed > found.length ? 0 : parsed - 1;
+        const selected = found[idx];
+        ok(`${selected.name} \x1b[2m(${selected.binary})\x1b[0m selected`);
+        const agentModel = selected.binary === 'codex' ? await promptCodexModel() : undefined;
+        return { agent: selected.binary, agentModel };
     }
     warn('No coding agent found on PATH');
     info('');
     info('Choose one to install:');
-    info('  [1] Claude Code (recommended) — npm install -g @anthropic-ai/claude-code');
-    info('  [2] OpenAI Codex             — npm install -g @openai/codex');
-    info('  [3] OpenCode                 — npm install -g opencode-ai');
-    info('  [s] Skip for now');
+    info('');
+    pick([
+        { label: 'Claude Code', description: 'npm install -g @anthropic-ai/claude-code' },
+        { label: 'OpenAI Codex', description: 'npm install -g @openai/codex' },
+        { label: 'OpenCode', description: 'npm install -g opencode-ai' },
+    ]);
     info('');
     const choice = await prompt('  Your choice: ');
     if (choice === '1' || choice === '') {
@@ -358,48 +410,48 @@ async function setupAgent() {
         if (r.exitCode !== 0) {
             fail('Install failed');
             info(r.stderr.trim().split('\n').slice(0, 5).join('\n'));
-            return false;
+            return { agent: undefined, agentModel: undefined };
         }
         if (!(await binaryExists('claude'))) {
             fail('claude binary not found on PATH after install — check your npm global bin directory');
-            return false;
+            return { agent: undefined, agentModel: undefined };
         }
         ok('Claude Code installed');
         info('');
         info('Next: run `claude login` to authenticate (browser OAuth).');
         info('Or set ANTHROPIC_API_KEY in your shell profile.');
-        return true;
+        return { agent: 'claude', agentModel: undefined };
     }
     if (choice === '2') {
         const r = await runSpawn('npm', ['install', '-g', '@openai/codex']);
         if (r.exitCode !== 0) {
             fail('Install failed');
-            return false;
+            return { agent: undefined, agentModel: undefined };
         }
         if (!(await binaryExists('codex'))) {
             fail('codex binary not found on PATH after install — check your npm global bin directory');
-            return false;
+            return { agent: undefined, agentModel: undefined };
         }
         ok('OpenAI Codex installed');
-        info('Set OPENAI_API_KEY in your shell profile to authenticate.');
-        return true;
+        const agentModel = await promptCodexModel();
+        return { agent: 'codex', agentModel };
     }
     if (choice === '3') {
         const r = await runSpawn('npm', ['install', '-g', 'opencode-ai']);
         if (r.exitCode !== 0) {
             fail('Install failed');
-            return false;
+            return { agent: undefined, agentModel: undefined };
         }
         if (!(await binaryExists('opencode'))) {
             fail('opencode binary not found on PATH after install — check your npm global bin directory');
-            return false;
+            return { agent: undefined, agentModel: undefined };
         }
         ok('OpenCode installed');
         info('Run `opencode auth` to configure your provider.');
-        return true;
+        return { agent: 'opencode', agentModel: undefined };
     }
     warn('Skipped. Install a coding agent before running experiences import.');
-    return false;
+    return { agent: undefined, agentModel: undefined };
 }
 // ── Step 5: Contentful credentials ───────────────────────────────────────────
 async function setupContentfulCredentials() {
@@ -462,7 +514,8 @@ async function setupContentfulCredentials() {
     }
     const hostInput = await prompt(`  API host [${currentHost}]: `);
     const host = toConfiguredHost(hostInput) ?? storedHost;
-    await writeExperiencesCredentials({ spaceId, environmentId, cmaToken, ...(host ? { host } : {}) });
+    const existing = await readExperiencesCredentials();
+    await writeExperiencesCredentials({ ...existing, spaceId, environmentId, cmaToken, ...(host ? { host } : {}) });
     ok(`Credentials saved to ${experiencesCredentialsPath()}`);
     ok(`API host set to ${host ?? DEFAULT_CONFIGURED_HOST}`);
     info('Run experiences import — credentials will be pre-filled automatically.');
@@ -612,14 +665,27 @@ async function checkBuild(pkgRoot) {
 }
 async function checkAgent() {
     section('Checking coding agent');
-    const agents = [
-        { name: 'Claude Code', binary: 'claude' },
-        { name: 'OpenAI Codex', binary: 'codex' },
-        { name: 'OpenCode', binary: 'opencode' },
-    ];
+    const agents = AGENT_DEFS;
+    const creds = await readExperiencesCredentials();
+    const savedAgent = creds.agent;
+    const savedModel = creds.agentModel;
+    if (savedAgent) {
+        const found = await binaryExists(savedAgent);
+        if (found) {
+            const modelStr = savedModel ? ` — model: ${savedModel}` : '';
+            ok(`${savedAgent}${modelStr} (saved preference)`);
+            return true;
+        }
+        else {
+            warn(`Saved agent '${savedAgent}' not found on PATH`);
+            info(`Re-run experiences setup to reconfigure.`);
+            return false;
+        }
+    }
     for (const agent of agents) {
         if (await binaryExists(agent.binary)) {
             ok(`${agent.name} (${agent.binary}) found`);
+            info('Tip: run experiences setup to save a default agent and model.');
             return true;
         }
     }
@@ -704,7 +770,6 @@ export function registerSetupCommand(program) {
         .action(async (opts) => {
         process.stdout.write('\n\x1b[1mexperiences setup\x1b[0m — interactive setup wizard\n');
         process.stdout.write('Sets up everything you need to run \x1b[1mexperiences import\x1b[0m.\n');
-        process.stdout.write('Required steps are marked \x1b[31m[required]\x1b[0m, optional ones \x1b[2m[optional]\x1b[0m.\n');
         const pkgRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
         const repoRoot = join(pkgRoot, '..', '..');
         const profilePath = await detectShellProfile();
@@ -729,8 +794,13 @@ export function registerSetupCommand(program) {
         }
         // Step 4: agent
         if (!opts.skipAgent) {
-            const agentOk = await setupAgent();
-            results.push({ name: 'coding agent', passed: agentOk, required: true });
+            const { agent, agentModel } = await setupAgent();
+            if (agent) {
+                const stored = await readExperiencesCredentials();
+                const { agentModel: _staleModel, ...storedWithoutModel } = stored;
+                await writeExperiencesCredentials({ ...storedWithoutModel, agent, ...(agentModel ? { agentModel } : {}) });
+            }
+            results.push({ name: 'coding agent', passed: !!agent, required: true });
         }
         else {
             info('\nSkipping agent check (--skip-agent)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.11.0",
+  "version": "2.11.1-dev-build-96af281.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
     "react-dom": "^18.3.1",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.11.0"
+    "@contentful/experience-design-system-types": "2.11.1-dev-build-96af281.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",