@contentful/experience-design-system-cli 2.2.1

package/dist/src/apply/manifest.d.ts

@@ -0,0 +1 @@
+export { readTokensFromPath, hasBreakingChangesWithImpact } from './command.js';

package/dist/src/apply/manifest.js

@@ -0,0 +1 @@
+export { readTokensFromPath, hasBreakingChangesWithImpact } from './command.js';

package/dist/src/apply/tui/SelectView.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export interface SelectableEntity {
+    id: string;
+    kind: 'token' | 'component';
+    status: 'new' | 'changed';
+    isBreaking?: boolean;
+}
+export declare function makeSelectKey(kind: 'token' | 'component', id: string): string;
+interface SelectViewProps {
+    entities: SelectableEntity[];
+    spaceId: string;
+    environmentId: string;
+    selectedIndex: number;
+    selected: Set<string>;
+    importing: boolean;
+}
+export declare function SelectView({ entities, spaceId, environmentId, selectedIndex, selected, importing, }: SelectViewProps): React.ReactElement;
+export {};

package/dist/src/apply/tui/SelectView.js

@@ -0,0 +1,34 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function makeSelectKey(kind, id) {
+    return `${kind}:${id}`;
+}
+const STATUS_ICON = {
+    new: '✦',
+    changed: '~',
+};
+const STATUS_COLOR = {
+    new: 'green',
+    changed: 'yellow',
+};
+export function SelectView({ entities, spaceId, environmentId, selectedIndex, selected, importing, }) {
+    const tokens = entities.filter((e) => e.kind === 'token');
+    const components = entities.filter((e) => e.kind === 'component');
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, width: "100%", children: [_jsxs(Text, { bold: true, children: ["Select \u2014 ", environmentId, " @ ", spaceId] }), _jsx(Text, { children: " " }), tokens.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " Design Tokens" }), tokens.map((entity, i) => {
+                        const key = makeSelectKey('token', entity.id);
+                        return renderRow(entity, i, selectedIndex, selected.has(key), importing);
+                    }), _jsx(Text, { children: " " })] })), components.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: " Component Types" }), components.map((entity, i) => {
+                        const globalIdx = tokens.length + i;
+                        const key = makeSelectKey('component', entity.id);
+                        return renderRow(entity, globalIdx, selectedIndex, selected.has(key), importing);
+                    }), _jsx(Text, { children: " " })] })), entities.length === 0 && _jsx(Text, { dimColor: true, children: " No entities to display." }), importing ? (_jsx(Text, { dimColor: true, children: " Applying selected entities..." })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [" ", selected.size, " selected"] }), _jsx(Text, { dimColor: true, children: " \u2191\u2193 navigate Space toggle A all N none I apply selected Q quit" })] }))] }));
+}
+function renderRow(entity, globalIdx, selectedIndex, checked, importing) {
+    const isCursor = globalIdx === selectedIndex;
+    const icon = STATUS_ICON[entity.status] ?? '?';
+    const color = STATUS_COLOR[entity.status] ?? 'white';
+    const checkbox = checked ? '[✓]' : '[ ]';
+    const cursor = isCursor ? '>' : ' ';
+    const breakingNote = entity.isBreaking ? ' ⚠ breaking' : '';
+    return (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: isCursor ? 'cyan' : undefined, children: [cursor, " "] }), _jsxs(Text, { color: checked ? 'cyan' : 'gray', children: [checkbox, " "] }), _jsxs(Text, { color: color, children: [icon, " "] }), _jsx(Box, { flexGrow: 1, marginRight: 1, children: _jsx(Text, { color: isCursor ? 'cyan' : undefined, wrap: "wrap", children: entity.id }) }), _jsxs(Text, { color: color, children: [entity.status, breakingNote] }), importing && checked && isCursor && _jsx(Text, { dimColor: true, children: " (writing...)" })] }, entity.id));
+}

package/dist/src/apply/tui/ServerApplyView.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { ServerPreviewResponse, ApplyOperationResponse } from '@contentful/experience-design-system-types';
+interface ServerPreviewConfirmProps {
+    preview: ServerPreviewResponse;
+    spaceId: string;
+    environmentId: string;
+    breakingWithImpact: boolean;
+    onConfirm: (acknowledge: boolean) => void;
+    onCancel: () => void;
+}
+export declare function ServerPreviewConfirm({ preview, spaceId, environmentId, breakingWithImpact, onConfirm, onCancel, }: ServerPreviewConfirmProps): React.ReactElement;
+interface ServerPreviewAppProps {
+    preview: ServerPreviewResponse;
+    spaceId: string;
+    environmentId: string;
+}
+export declare function ServerPreviewApp({ preview, spaceId, environmentId }: ServerPreviewAppProps): React.ReactElement;
+interface ServerApplyProgressProps {
+    spaceId: string;
+    environmentId: string;
+    status: 'applying' | 'polling' | 'error';
+    operationId?: string;
+    error?: string;
+}
+export declare function ServerApplyProgress({ spaceId, environmentId, status, operationId, error, }: ServerApplyProgressProps): React.ReactElement;
+interface ServerApplyDoneProps {
+    operation: ApplyOperationResponse;
+    spaceId: string;
+    environmentId: string;
+}
+export declare function ServerApplyDone({ operation, spaceId, environmentId }: ServerApplyDoneProps): React.ReactElement;
+export {};

package/dist/src/apply/tui/ServerApplyView.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from 'ink';
+import { ServerPreviewView } from './ServerPreviewView.js';
+export function ServerPreviewConfirm({ preview, spaceId, environmentId, breakingWithImpact, onConfirm, onCancel, }) {
+    useInput((input, key) => {
+        if (key.return)
+            onConfirm(breakingWithImpact);
+        if (key.escape || input === 'q')
+            onCancel();
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ServerPreviewView, { preview: preview, spaceId: spaceId, environmentId: environmentId }), _jsxs(Box, { paddingX: 2, flexDirection: "column", children: [breakingWithImpact && (_jsxs(Text, { color: "red", bold: true, children: [' ', "\u26A0 Breaking changes will affect downstream entities. Press Enter to acknowledge and apply."] })), _jsxs(Text, { children: [' ', "Press ", _jsx(Text, { bold: true, children: "Enter" }), " to apply, ", _jsx(Text, { bold: true, children: "Esc" }), " to cancel"] })] })] }));
+}
+export function ServerPreviewApp({ preview, spaceId, environmentId }) {
+    useInput((input, key) => {
+        if (key.escape || input === 'q')
+            process.exit(0);
+    });
+    return _jsx(ServerPreviewView, { preview: preview, spaceId: spaceId, environmentId: environmentId });
+}
+export function ServerApplyProgress({ spaceId, environmentId, status, operationId, error, }) {
+    useInput((_input, key) => {
+        if (status === 'error' && (key.escape || _input === 'q'))
+            process.exit(1);
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { bold: true, children: ["Import \u2014 ", environmentId, " @ ", spaceId] }), _jsx(Text, { children: " " }), status === 'applying' && _jsx(Text, { children: " Submitting apply request..." }), status === 'polling' && _jsxs(Text, { children: [" Operation ", operationId, " in progress..."] }), status === 'error' && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: [" \u2717 Error: ", error] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: " Press Q to exit." })] }))] }));
+}
+export function ServerApplyDone({ operation, spaceId, environmentId }) {
+    useInput((input, key) => {
+        if (key.escape || input === 'q') {
+            process.exit(operation.sys.status === 'succeeded' ? 0 : 1);
+        }
+    });
+    const failures = (operation.items ?? []).filter((item) => item.status === 'failed');
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { bold: true, children: ["Import complete \u2014 ", environmentId, " @ ", spaceId] }), _jsx(Text, { children: " " }), _jsxs(Text, { color: "green", children: [" \u2713 ", operation.summary.succeeded, " succeeded"] }), operation.summary.failed > 0 && _jsxs(Text, { color: "red", children: [" \u2717 ", operation.summary.failed, " failed"] }), operation.summary.failed === 0 && _jsx(Text, { dimColor: true, children: " All entities imported successfully." }), failures.length > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: " Failures:" }), failures.map((item, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: [' ', "\u2717 ", item.entityType, ": ", item.id] }), item.error && _jsxs(Text, { dimColor: true, children: [" ", formatItemError(item.error)] })] }, i)))] })), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: " Press Q to exit." })] }));
+}
+function formatItemError(error) {
+    if (!error)
+        return '';
+    if (typeof error === 'string')
+        return error;
+    return `${error.code}: ${error.message}`;
+}

package/dist/src/apply/tui/ServerPreviewView.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+interface ServerPreviewViewProps {
+    preview: ServerPreviewResponse;
+    spaceId: string;
+    environmentId: string;
+}
+export declare function ServerPreviewView({ preview, spaceId, environmentId }: ServerPreviewViewProps): React.ReactElement;
+export {};

package/dist/src/apply/tui/ServerPreviewView.js

@@ -0,0 +1,21 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function BreakingBadge({ item }) {
+    if (!item.changeClassification || item.changeClassification.classification !== 'breaking')
+        return null;
+    const reasons = item.changeClassification.breakingChanges.map((bc) => `${bc.propertyId}: ${bc.reason}`).join(', ');
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: "red", children: [" \u26A0 BREAKING: ", reasons] }), item.impact && (item.impact.affectedFragments > 0 || item.impact.affectedExperiences > 0) && (_jsxs(Text, { color: "red", children: [' ', "\u2192 affects ", item.impact.affectedFragments, " Fragments, ", item.impact.affectedExperiences, " Experiences"] }))] }));
+}
+function DraftWarning({ hasDraft }) {
+    if (!hasDraft)
+        return null;
+    return _jsx(Text, { color: "yellow", children: " \u26A1 has pending draft changes" });
+}
+export function ServerPreviewView({ preview, spaceId, environmentId }) {
+    const { components, tokens } = preview;
+    const totalComponents = components.new.length + components.changed.length + components.unchanged.length + components.removed.length;
+    const totalTokens = tokens.new.length + tokens.changed.length + tokens.unchanged.length + tokens.removed.length;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { bold: true, children: ["Preview \u2014 ", environmentId, " @ ", spaceId] }), _jsx(Text, { children: " " }), totalComponents > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [" Component Types (", totalComponents, " total)"] }), _jsxs(Text, { color: "green", children: [" \u2726 ", components.new.length, " to create"] }), _jsxs(Text, { color: "yellow", children: [" ~ ", components.changed.length, " to update"] }), _jsxs(Text, { color: "red", children: [" \u2717 ", components.removed.length, " to remove"] }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", components.unchanged.length, " unchanged"] }), components.changed.map((item, i) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: "yellow", children: [" ~ ", item.current.name] }), _jsx(DraftWarning, { hasDraft: item.hasPendingDraftChanges })] }), _jsx(BreakingBadge, { item: item })] }, i))), _jsx(Text, { children: " " })] })), totalTokens > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { bold: true, children: [" Design Tokens (", totalTokens, " total)"] }), _jsxs(Text, { color: "green", children: [" \u2726 ", tokens.new.length, " to create"] }), _jsxs(Text, { color: "yellow", children: [" ~ ", tokens.changed.length, " to update"] }), _jsxs(Text, { color: "red", children: [" \u2717 ", tokens.removed.length, " to remove"] }), _jsxs(Text, { dimColor: true, children: [" \u00B7 ", tokens.unchanged.length, " unchanged"] }), tokens.changed
+                        .filter((t) => t.hasPendingDraftChanges)
+                        .map((item, i) => (_jsxs(Box, { flexDirection: "row", children: [_jsxs(Text, { color: "yellow", children: [" ~ ", item.current.name] }), _jsx(DraftWarning, { hasDraft: true })] }, i))), _jsx(Text, { children: " " })] })), _jsx(Text, { dimColor: true, children: " Press Q to exit." })] }));
+}

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

@@ -0,0 +1,8 @@
+export type ExoCredentials = {
+    spaceId: string;
+    environmentId: string;
+    cmaToken: string;
+};
+export declare function readExoCredentials(): Promise<ExoCredentials>;
+export declare function writeExoCredentials(creds: ExoCredentials): Promise<void>;
+export declare function exoCredentialsPath(): string;

package/dist/src/credentials-store.js

@@ -0,0 +1,30 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CREDENTIALS_DIR = join(homedir(), '.config', 'exo');
+const CREDENTIALS_PATH = join(CREDENTIALS_DIR, 'credentials.json');
+export async function readExoCredentials() {
+    try {
+        const raw = await readFile(CREDENTIALS_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            spaceId: process.env['CONTENTFUL_SPACE_ID'] ?? parsed.spaceId ?? '',
+            environmentId: process.env['CONTENTFUL_ENVIRONMENT_ID'] ?? parsed.environmentId ?? '',
+            cmaToken: process.env['CONTENTFUL_MANAGEMENT_TOKEN'] ?? parsed.cmaToken ?? '',
+        };
+    }
+    catch {
+        return {
+            spaceId: process.env['CONTENTFUL_SPACE_ID'] ?? '',
+            environmentId: process.env['CONTENTFUL_ENVIRONMENT_ID'] ?? '',
+            cmaToken: process.env['CONTENTFUL_MANAGEMENT_TOKEN'] ?? '',
+        };
+    }
+}
+export async function writeExoCredentials(creds) {
+    await mkdir(CREDENTIALS_DIR, { recursive: true });
+    await writeFile(CREDENTIALS_PATH, JSON.stringify(creds, null, 2) + '\n', { mode: 0o600 });
+}
+export function exoCredentialsPath() {
+    return CREDENTIALS_PATH;
+}

package/dist/src/generate/agent-runner.d.ts

@@ -0,0 +1,86 @@
+export type AgentName = 'claude' | 'codex' | 'opencode' | 'cursor';
+export interface AgentRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+}
+export interface ClassifyPropCall {
+    tool: 'classify_prop';
+    prop: string;
+    cdf_type: string;
+    cdf_category: 'content' | 'design' | 'state';
+    values?: string[];
+    token_kind?: string;
+    required?: boolean;
+    description?: string;
+    default?: string | boolean;
+}
+export interface ExcludePropCall {
+    tool: 'exclude_prop';
+    prop: string;
+    reason: string;
+}
+export interface ClassifyComponentCall {
+    tool: 'classify_component';
+    description?: string;
+}
+export interface ClassifySlotCall {
+    tool: 'classify_slot';
+    slot: string;
+    required?: boolean;
+    allowed_components?: string[];
+    description?: string;
+}
+export type ToolCall = ClassifyPropCall | ExcludePropCall | ClassifyComponentCall | ClassifySlotCall;
+export interface SelectComponentCall {
+    tool: 'select_component';
+    name: string;
+    reason?: string;
+}
+export interface RejectComponentCall {
+    tool: 'reject_component';
+    name: string;
+    reason?: string;
+}
+export type SelectToolCall = SelectComponentCall | RejectComponentCall;
+export interface ParsedSelectToolCalls {
+    calls: SelectToolCall[];
+    warnings: string[];
+}
+export declare function parseSelectToolCallLines(stdout: string): ParsedSelectToolCalls;
+export interface SetTokenCall {
+    tool: 'set_token';
+    path: string;
+    type: string;
+    value: unknown;
+    description?: string;
+}
+export interface SetGroupCall {
+    tool: 'set_group';
+    path: string;
+    description?: string;
+}
+export type TokenToolCall = SetTokenCall | SetGroupCall;
+export interface ParsedTokenToolCalls {
+    calls: TokenToolCall[];
+    warnings: string[];
+}
+export interface ParsedToolCalls {
+    calls: ToolCall[];
+    warnings: string[];
+}
+export declare function parseToolCallLines(stdout: string): ParsedToolCalls;
+export declare function parseTokenToolCallLines(stdout: string): ParsedTokenToolCalls;
+export declare function resolveBinary(agent: AgentName): string;
+export declare function runAgent(options: {
+    agent: AgentName;
+    prompt: string;
+    interactive: boolean;
+    timeoutMs: number;
+    model?: string;
+    onOutput?: (chunk: string) => void;
+}): Promise<AgentRunResult>;
+export type AgentAuthStatus = 'ok' | 'unauthenticated' | 'not-found';
+export declare function checkAgentAuth(agent: AgentName): Promise<AgentAuthStatus>;
+export declare function extractSentinelOutput(stdout: string): string | null | 'multiple';

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

@@ -0,0 +1,314 @@
+import { spawn } from 'node:child_process';
+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;
+        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;
+            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;
+            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;
+            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',
+};
+// 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
+    opencode: 'claude-haiku-4-5',
+    cursor: 'claude-3-5-haiku-20241022',
+};
+export function resolveBinary(agent) {
+    return AGENT_BINARIES[agent];
+}
+function buildArgs(agent, prompt, model) {
+    const m = model ?? DEFAULT_MODELS[agent];
+    switch (agent) {
+        case 'claude':
+            return ['--print', '--model', m, prompt];
+        case 'codex':
+            // --dangerously-bypass-approvals-and-sandbox required for non-interactive use
+            return ['exec', '--model', m, '--dangerously-bypass-approvals-and-sandbox', prompt];
+        case 'opencode':
+            return ['run', '--model', m, prompt];
+        case 'cursor':
+            // cursor-agent uses --print for non-interactive stdout output
+            return ['--print', '--model', m, prompt];
+    }
+}
+export async function runAgent(options) {
+    const { agent, prompt, interactive, timeoutMs, model, onOutput } = options;
+    const binary = resolveBinary(agent);
+    const args = buildArgs(agent, prompt, model);
+    return new Promise((resolve) => {
+        const child = spawn(binary, args, {
+            stdio: interactive ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+        });
+        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);
+            resolve({
+                exitCode: signal ? 1 : (code ?? 1),
+                stdout,
+                stderr,
+                timedOut,
+            });
+        });
+    });
+}
+export async function checkAgentAuth(agent) {
+    if (agent !== 'claude')
+        return 'ok';
+    const binary = resolveBinary(agent);
+    // Verify the binary exists first
+    const whichResult = await new Promise((resolve) => {
+        const child = spawn('which', [binary], { stdio: 'ignore' });
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+    if (whichResult !== 0)
+        return 'not-found';
+    // 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');
+            }
+        });
+    });
+}
+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/command.d.ts

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