@contentful/experience-design-system-cli 2.18.1-dev-build-b4ecc99.0 → 2.18.1-dev-build-180092e.0

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

@@ -1,427 +0,0 @@
-import { spawn } from 'node:child_process';
-import { getDebugLogger } from '../lib/debug-logger.js';
-export { AGENT_NAMES, isAgentName } from '../lib/agent-names.js';
-const VALID_SELECT_TOOL_NAMES = new Set(['select_component', 'reject_component']);
-export function parseSelectToolCallLines(stdout) {
-    const calls = [];
-    const warnings = [];
-    for (const raw of stdout.split('\n')) {
-        const line = raw.trim();
-        if (!line.startsWith('{'))
-            continue;
-        let obj;
-        try {
-            obj = JSON.parse(line);
-        }
-        catch {
-            warnings.push(`unparseable line: ${line.slice(0, 120)}`);
-            continue;
-        }
-        if (typeof obj !== 'object' || obj === null || !('tool' in obj))
-            continue;
-        const rec = obj;
-        if (!VALID_SELECT_TOOL_NAMES.has(rec.tool))
-            continue;
-        if (typeof rec.name !== 'string' || !rec.name) {
-            warnings.push(`${String(rec.tool)} missing name — skipped`);
-            continue;
-        }
-        const call = {
-            tool: rec.tool,
-            name: rec.name,
-        };
-        if (typeof rec.reason === 'string')
-            call.reason = rec.reason;
-        if (typeof rec.confidence === 'number' && rec.confidence >= 1 && rec.confidence <= 5) {
-            if (call.tool === 'select_component') {
-                call.confidence = rec.confidence;
-            }
-            else {
-                call.confidence = rec.confidence;
-            }
-        }
-        calls.push(call);
-    }
-    return { calls, warnings };
-}
-const VALID_TOOL_NAMES = new Set(['classify_prop', 'exclude_prop', 'classify_component', 'classify_slot']);
-const VALID_TOKEN_TOOL_NAMES = new Set(['set_token', 'set_group']);
-const VALID_CDF_TYPES = new Set(['string', 'richtext', 'media', 'enum', 'token', 'boolean']);
-const VALID_CATEGORIES = new Set(['content', 'design', 'state']);
-export function parseToolCallLines(stdout) {
-    const calls = [];
-    const warnings = [];
-    for (const raw of stdout.split('\n')) {
-        const line = raw.trim();
-        if (!line.startsWith('{'))
-            continue;
-        let obj;
-        try {
-            obj = JSON.parse(line);
-        }
-        catch {
-            warnings.push(`unparseable line: ${line.slice(0, 120)}`);
-            continue;
-        }
-        if (typeof obj !== 'object' || obj === null || !('tool' in obj))
-            continue;
-        const rec = obj;
-        if (!VALID_TOOL_NAMES.has(rec.tool)) {
-            warnings.push(`unknown tool: ${String(rec.tool)}`);
-            continue;
-        }
-        const tool = rec.tool;
-        if (tool === 'classify_prop') {
-            if (typeof rec.prop !== 'string' || !rec.prop) {
-                warnings.push('classify_prop missing prop name — skipped');
-                continue;
-            }
-            if (typeof rec.cdf_type !== 'string' || !VALID_CDF_TYPES.has(rec.cdf_type)) {
-                warnings.push(`classify_prop '${rec.prop}': invalid cdf_type '${String(rec.cdf_type)}' — skipped`);
-                continue;
-            }
-            if (typeof rec.cdf_category !== 'string' || !VALID_CATEGORIES.has(rec.cdf_category)) {
-                warnings.push(`classify_prop '${rec.prop}': invalid cdf_category '${String(rec.cdf_category)}' — skipped`);
-                continue;
-            }
-            const call = {
-                tool: 'classify_prop',
-                prop: rec.prop,
-                cdf_type: rec.cdf_type,
-                cdf_category: rec.cdf_category,
-            };
-            if (Array.isArray(rec.values) && rec.values.every((v) => typeof v === 'string')) {
-                call.values = rec.values;
-            }
-            if (typeof rec.token_kind === 'string')
-                call.token_kind = rec.token_kind;
-            if (typeof rec.required === 'boolean')
-                call.required = rec.required;
-            if (typeof rec.description === 'string')
-                call.description = rec.description;
-            if (typeof rec.default === 'string' || typeof rec.default === 'boolean')
-                call.default = rec.default;
-            if (typeof rec.reason === 'string')
-                call.reason = rec.reason;
-            calls.push(call);
-        }
-        else if (tool === 'exclude_prop') {
-            if (typeof rec.prop !== 'string' || !rec.prop) {
-                warnings.push('exclude_prop missing prop name — skipped');
-                continue;
-            }
-            calls.push({
-                tool: 'exclude_prop',
-                prop: rec.prop,
-                reason: typeof rec.reason === 'string' ? rec.reason : '',
-            });
-        }
-        else if (tool === 'classify_component') {
-            const call = { tool: 'classify_component' };
-            if (typeof rec.description === 'string')
-                call.description = rec.description;
-            if (typeof rec.rationale === 'object' && rec.rationale !== null) {
-                const r = rec.rationale;
-                const rationale = {};
-                if (typeof r.description === 'string')
-                    rationale.description = r.description;
-                if (typeof r.props === 'string')
-                    rationale.props = r.props;
-                if (typeof r.slots === 'string')
-                    rationale.slots = r.slots;
-                if (Object.keys(rationale).length > 0)
-                    call.rationale = rationale;
-            }
-            calls.push(call);
-        }
-        else if (tool === 'classify_slot') {
-            if (typeof rec.slot !== 'string' || !rec.slot) {
-                warnings.push('classify_slot missing slot name — skipped');
-                continue;
-            }
-            const call = { tool: 'classify_slot', slot: rec.slot };
-            if (typeof rec.required === 'boolean')
-                call.required = rec.required;
-            if (Array.isArray(rec.allowed_components) && rec.allowed_components.every((v) => typeof v === 'string')) {
-                call.allowed_components = rec.allowed_components;
-            }
-            if (typeof rec.description === 'string')
-                call.description = rec.description;
-            if (typeof rec.rationale === 'string')
-                call.rationale = rec.rationale;
-            calls.push(call);
-        }
-    }
-    return { calls, warnings };
-}
-export function parseTokenToolCallLines(stdout) {
-    const calls = [];
-    const warnings = [];
-    for (const raw of stdout.split('\n')) {
-        const line = raw.trim();
-        if (!line.startsWith('{'))
-            continue;
-        let obj;
-        try {
-            obj = JSON.parse(line);
-        }
-        catch {
-            warnings.push(`unparseable line: ${line.slice(0, 120)}`);
-            continue;
-        }
-        if (typeof obj !== 'object' || obj === null || !('tool' in obj))
-            continue;
-        const rec = obj;
-        if (!VALID_TOKEN_TOOL_NAMES.has(rec.tool))
-            continue; // not a token call — skip silently
-        if (rec.tool === 'set_token') {
-            if (typeof rec.path !== 'string' || !rec.path) {
-                warnings.push('set_token missing path — skipped');
-                continue;
-            }
-            if (typeof rec.type !== 'string' || !rec.type) {
-                warnings.push(`set_token '${rec.path}': missing type — skipped`);
-                continue;
-            }
-            if (!('value' in rec)) {
-                warnings.push(`set_token '${rec.path}': missing value — skipped`);
-                continue;
-            }
-            const call = { tool: 'set_token', path: rec.path, type: rec.type, value: rec.value };
-            if (typeof rec.description === 'string')
-                call.description = rec.description;
-            calls.push(call);
-        }
-        else if (rec.tool === 'set_group') {
-            if (typeof rec.path !== 'string' || !rec.path) {
-                warnings.push('set_group missing path — skipped');
-                continue;
-            }
-            const call = { tool: 'set_group', path: rec.path };
-            if (typeof rec.description === 'string')
-                call.description = rec.description;
-            calls.push(call);
-        }
-    }
-    return { calls, warnings };
-}
-// --- Agent invocation ---
-const AGENT_BINARIES = {
-    claude: 'claude',
-    codex: 'codex',
-    opencode: 'opencode',
-    cursor: 'cursor-agent',
-};
-export function resolveBinary(agent) {
-    const envKey = `EDS_AGENT_BINARY_${agent.toUpperCase()}`;
-    const override = process.env[envKey];
-    if (override && override.trim())
-        return override.trim();
-    return AGENT_BINARIES[agent];
-}
-/**
- * Default models per agent — lightweight/fast picks to control cost when no
- * explicit model is configured. cursor uses `gpt-mini` (verified alias from
- * GetUsableModels; haiku is not available in cursor's model catalog).
- */
-const DEFAULT_MODELS = {
-    claude: 'haiku',
-    codex: 'gpt-5.4-mini', // requires OPENAI_API_KEY; ChatGPT account users must pass --model
-    opencode: 'claude-haiku-4-5',
-    cursor: 'gpt-mini', // cursor alias for gpt-5.4-mini-medium; haiku not in cursor's catalog
-};
-/**
- * Resolve the model for an agent. Explicit flag/creds value wins, then a
- * per-agent `EDS_AGENT_MODEL_<AGENT>` env override (mirrors the
- * `EDS_AGENT_BINARY_<AGENT>` pattern), otherwise the lightweight default for
- * that agent.
- */
-export function resolveAgentModel(agent, explicit) {
-    if (explicit && explicit.trim())
-        return explicit.trim();
-    const override = process.env[`EDS_AGENT_MODEL_${agent.toUpperCase()}`];
-    if (override && override.trim())
-        return override.trim();
-    return DEFAULT_MODELS[agent];
-}
-export function buildArgs(agent, prompt, model, promptViaStdin = false) {
-    const modelArg = ['--model', resolveAgentModel(agent, model)];
-    // When the prompt is delivered on stdin, omit it from argv — a large prompt
-    // as a command-line argument overflows ARG_MAX (spawn E2BIG). All four CLIs
-    // read the prompt from stdin when it isn't passed positionally.
-    const promptArg = promptViaStdin ? [] : [prompt];
-    switch (agent) {
-        case 'claude':
-            return ['--print', ...modelArg, ...promptArg];
-        case 'codex':
-            // --dangerously-bypass-approvals-and-sandbox required for non-interactive use
-            return ['exec', ...modelArg, '--dangerously-bypass-approvals-and-sandbox', ...promptArg];
-        case 'opencode':
-            return ['run', ...modelArg, ...promptArg];
-        case 'cursor':
-            // cursor-agent uses --print for non-interactive stdout output
-            return ['--print', ...modelArg, ...promptArg];
-    }
-}
-export async function runAgent(options) {
-    const { agent, prompt, interactive, timeoutMs, model, onOutput, promptViaStdin } = options;
-    const binary = resolveBinary(agent);
-    const useStdin = !!promptViaStdin && !interactive;
-    const args = buildArgs(agent, prompt, model, useStdin);
-    const debug = getDebugLogger();
-    const startedAt = Date.now();
-    debug.event('agent', 'run.start', {
-        agent,
-        binary,
-        model,
-        interactive,
-        timeoutMs,
-        promptLen: prompt.length,
-        promptHead: prompt.slice(0, 500),
-    });
-    return new Promise((resolve) => {
-        const child = spawn(binary, args, {
-            stdio: interactive ? 'inherit' : ['pipe', 'pipe', 'pipe'],
-        });
-        if (!interactive) {
-            if (useStdin && child.stdin) {
-                // Guard against EPIPE: the child may close stdin before we finish
-                // writing (fast exit, or it stops reading). Swallow the write error —
-                // the child's own exit code/stderr is the source of truth.
-                child.stdin.on('error', () => { });
-                child.stdin.write(prompt, () => {
-                    child.stdin?.end();
-                });
-            }
-            else {
-                child.stdin?.end();
-            }
-        }
-        let stdout = '';
-        let stderr = '';
-        let timedOut = false;
-        const timer = setTimeout(() => {
-            timedOut = true;
-            child.kill('SIGTERM');
-        }, timeoutMs);
-        if (!interactive) {
-            child.stdout?.on('data', (chunk) => {
-                const text = chunk.toString();
-                stdout += text;
-                onOutput?.(text);
-            });
-            child.stderr?.on('data', (chunk) => {
-                stderr += chunk.toString();
-            });
-        }
-        child.on('close', (code, signal) => {
-            clearTimeout(timer);
-            const result = {
-                exitCode: signal ? 1 : (code ?? 1),
-                stdout,
-                stderr,
-                timedOut,
-            };
-            debug.event('agent', 'run.end', {
-                agent,
-                model,
-                durationMs: Date.now() - startedAt,
-                exitCode: result.exitCode,
-                signal,
-                timedOut,
-                stdoutLen: stdout.length,
-                stderrLen: stderr.length,
-                stderrTail: stderr.slice(-1000),
-            });
-            resolve(result);
-        });
-    });
-}
-export async function checkAgentAuth(agent) {
-    const binary = resolveBinary(agent);
-    // Verify the selected agent's binary exists first — for EVERY agent, not
-    // just claude. When `binary` is an absolute path (e.g. set via
-    // EDS_AGENT_BINARY_<AGENT>=/opt/custom/bin), `which` on some shells doesn't
-    // resolve it — check the filesystem directly for absolute paths, and fall
-    // back to `which` for bare names on $PATH.
-    const binaryExists = await new Promise((resolve) => {
-        if (binary.startsWith('/')) {
-            import('node:fs/promises').then((fs) => fs.access(binary).then(() => resolve(true), () => resolve(false)));
-            return;
-        }
-        const child = spawn('which', [binary], { stdio: 'ignore' });
-        child.on('close', (code) => resolve(code === 0));
-    });
-    if (!binaryExists)
-        return 'not-found';
-    // Only Claude exposes `auth status --json`. Non-Claude agents are considered
-    // authenticated once their binary is present — never gate them on claude
-    // (e.g. Codex-via-Bedrock users would otherwise be blocked by a claude check).
-    if (agent !== 'claude')
-        return 'ok';
-    // Use `claude auth status` — fast, no API call, works regardless of which
-    // auth provider (direct, Bedrock, Vertex) or whether AWS_PROFILE is set.
-    return new Promise((resolve) => {
-        const child = spawn(binary, ['auth', 'status', '--json'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        let done = false;
-        const timer = setTimeout(() => {
-            if (!done) {
-                done = true;
-                child.kill('SIGTERM');
-                resolve('unauthenticated');
-            }
-        }, 5000);
-        child.stdout?.on('data', (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.on('close', (code) => {
-            if (done)
-                return;
-            done = true;
-            clearTimeout(timer);
-            if (code !== 0) {
-                resolve('unauthenticated');
-                return;
-            }
-            try {
-                const status = JSON.parse(stdout);
-                resolve(status.loggedIn ? 'ok' : 'unauthenticated');
-            }
-            catch {
-                resolve('unauthenticated');
-            }
-        });
-    });
-}
-/**
- * Build a diagnostic string from a failed agent run, surfacing the agent's own
- * stderr (or stdout, when stderr is empty) so callers never emit a context-free
- * "agent failed". Callers only invoke this on a failed run: either a non-zero
- * exit, or a zero exit that produced no tool calls. A non-zero exit is reported
- * as such; a zero exit is therefore the "produced no tool calls" case.
- */
-export function describeAgentFailure(result, maxDetail = 800) {
-    const base = result.exitCode !== 0 ? `agent exited with code ${result.exitCode}` : 'agent produced no tool calls';
-    const detail = (result.stderr.trim() || result.stdout.trim()).slice(-maxDetail).trim();
-    return detail ? `${base} — ${detail}` : base;
-}
-export function extractSentinelOutput(stdout) {
-    const START = '<<<EDS_OUTPUT_START>>>';
-    const END = '<<<EDS_OUTPUT_END>>>';
-    const startIdx = stdout.indexOf(START);
-    const endIdx = stdout.indexOf(END);
-    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
-        return null;
-    // Check for multiple blocks
-    const secondStart = stdout.indexOf(START, startIdx + START.length);
-    if (secondStart !== -1 && secondStart < endIdx)
-        return 'multiple';
-    const afterStart = stdout.indexOf(END, startIdx);
-    const secondEnd = stdout.indexOf(END, afterStart + END.length);
-    if (secondEnd !== -1)
-        return 'multiple';
-    return stdout.slice(startIdx + START.length, endIdx).trim();
-}

package/dist/src/generate/progress.d.ts

@@ -1,9 +0,0 @@
-/**
- * Formats a structured generation-progress line for the wizard parser.
- *
- * Emitted at terminal completion of each component (success, cache hit,
- * pinned hit, or final failure). `done` represents the count of completed
- * components, which is monotonically non-decreasing — unlike the legacy
- * `[index+1/total]` line, which reports input position.
- */
-export declare function formatGenerateProgressLine(done: number, total: number, name: string): string;

package/dist/src/generate/progress.js

@@ -1,11 +0,0 @@
-/**
- * Formats a structured generation-progress line for the wizard parser.
- *
- * Emitted at terminal completion of each component (success, cache hit,
- * pinned hit, or final failure). `done` represents the count of completed
- * components, which is monotonically non-decreasing — unlike the legacy
- * `[index+1/total]` line, which reports input position.
- */
-export function formatGenerateProgressLine(done, total, name) {
-    return `progress=generate:${done}/${total}:${name}`;
-}

package/dist/src/generate/prompt-builder.d.ts

@@ -1,26 +0,0 @@
-/** `components` — classify component props; `tokens` — classify design tokens; `select` — decide whether a component belongs in Contentful Experience Orchestration */
-export type Skill = 'components' | 'tokens' | 'select';
-export type Mode = 'autonomous' | 'interactive';
-export interface PromptOptions {
-    skill: Skill;
-    mode: Mode;
-    rawComponentsInline?: string;
-    rawTokensInline?: string;
-    /** Original filename for raw tokens — used to set the correct code fence language. */
-    rawTokensFilename?: string;
-    tokensInline?: string;
-    tokenMapInline?: string;
-    outDir: string;
-    /** For components skill only: the single component's name (used in error messages). */
-    componentName?: string;
-    /**
-     * Feature 8: custom prompt path override. When set, this absolute or relative
-     * `.md` path is read in place of the bundled skill file. The bundled-prompt
-     * invariants (utility-wrapper rejection, description content rules, etc.) do
-     * NOT apply under an override — callers are responsible for showing the
-     * appropriate warning banner.
-     */
-    skillPathOverride?: string;
-}
-export declare function buildPrompt(options: PromptOptions): Promise<string>;
-export declare function resolveSkillPath(skill: Skill): string;