@contentful/experience-design-system-cli 2.2.1

package/dist/src/generate/command.js

@@ -0,0 +1,545 @@
+import { createElement } from 'react';
+import { render } from 'ink';
+import { access, readFile, readdir, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { parseToolCallLines, parseTokenToolCallLines, resolveBinary, runAgent, } from './agent-runner.js';
+import { OutputFormatter, c } from '../output/format.js';
+import { buildPrompt, resolveSkillPath } from './prompt-builder.js';
+import { GenerateView } from './tui/GenerateView.js';
+import { registerGenerateEditCommand } from './edit/command.js';
+import { openPipelineDb, loadRawComponents, applyToolCalls, applyTokenToolCalls, computeComponentInputHash, computeTokenInputHash, lookupCache, lookupCacheByEntity, storeCache, copyComponentFromCache, copyTokensFromCache, } from '../session/db.js';
+import { getRefineArtifactsRoot, getRefineSessionPaths } from '../analyze/select/persistence.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);
+const DEFAULT_COMPONENT_CONCURRENCY = 10;
+const RETRY_BACKOFF_MS = Number(process.env.EDS_RETRY_BACKOFF_MS ?? 5_000);
+function die(message) {
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+}
+async function pathExists(p) {
+    return access(p)
+        .then(() => true)
+        .catch(() => false);
+}
+async function assertFileExists(flag, p) {
+    if (!(await pathExists(p)))
+        die(`Error: file not found: ${p} (from ${flag})`);
+}
+async function readFileInline(path) {
+    if (!path)
+        return undefined;
+    const resolved = resolve(path);
+    let s;
+    try {
+        s = await stat(resolved);
+    }
+    catch {
+        return undefined;
+    }
+    if (!s.isDirectory())
+        return readFile(resolved, 'utf8');
+    // Directory: collect and concatenate all JSON files
+    const files = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries.sort()) {
+            const full = join(dir, entry);
+            let es;
+            try {
+                es = await stat(full);
+            }
+            catch {
+                continue;
+            }
+            if (es.isDirectory()) {
+                await walk(full);
+            }
+            else if (entry.endsWith('.json')) {
+                files.push(full);
+            }
+        }
+    }
+    await walk(resolved);
+    if (files.length === 0)
+        return undefined;
+    const parts = await Promise.all(files.map((f) => readFile(f, 'utf8').catch(() => '')));
+    return parts.filter(Boolean).join('\n\n');
+}
+async function assertBinaryInPath(binary) {
+    try {
+        await execFileAsync('which', [binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function printFallbackInstructions(options) {
+    const binary = resolveBinary(options.agent);
+    const skillPath = resolveSkillPath(options.skill);
+    const lines = [
+        `Error: agent '${options.agent}' not found in $PATH (looked for binary: ${binary}).`,
+        `Install it or use one of: claude, codex, opencode, cursor`,
+        ``,
+        `To run the generation step manually:`,
+        ``,
+        `  1. Open your coding agent`,
+        `  2. Run this skill (all input data will be embedded inline):`,
+        `       ${skillPath}`,
+        ``,
+        `  Use --dry-run to print the full prompt including all inline data.`,
+    ];
+    lines.push(``, `  When done, the agent output must be stored in the session database.`);
+    lines.push(`  Re-run the generate command with the agent available, or use --dry-run to inspect the prompt.`);
+    process.stderr.write(lines.join('\n') + '\n');
+}
+async function runOneComponent(agent, model, db, sessionId, component, tokensInline, tokenMapInline, index, total, verbose, noCache) {
+    const pos = c.dim(`[${index + 1}/${total}]`);
+    if (!noCache) {
+        const inputHash = computeComponentInputHash(component);
+        const cached = lookupCache(db, inputHash, 'component', component.component_id);
+        if (cached) {
+            copyComponentFromCache(db, cached.sourceSessionId, sessionId, component.component_id);
+            process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.green('cached')}\n`);
+            return {
+                componentName: component.name,
+                classified: 0,
+                excluded: 0,
+                slots: 0,
+                warnings: [],
+                failed: false,
+                cached: true,
+            };
+        }
+        // Check for pinned (human-edited) entry with a different hash
+        const pinned = lookupCacheByEntity(db, 'component', component.component_id);
+        if (pinned?.humanEdited) {
+            copyComponentFromCache(db, pinned.sourceSessionId, sessionId, component.component_id);
+            process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.cyan('pinned (human-edited)')}\n`);
+            return {
+                componentName: component.name,
+                classified: 0,
+                excluded: 0,
+                slots: 0,
+                warnings: [`${component.name}: source changed but human edits preserved`],
+                failed: false,
+                cached: true,
+            };
+        }
+    }
+    const rawComponentsInline = JSON.stringify([
+        {
+            name: component.name,
+            source: component.source,
+            framework: component.framework,
+            props: component.props,
+            slots: component.slots,
+        },
+    ], null, 2);
+    const prompt = await buildPrompt({
+        skill: 'components',
+        mode: 'autonomous',
+        rawComponentsInline,
+        tokensInline,
+        tokenMapInline,
+        outDir: process.cwd(),
+        componentName: component.name,
+    });
+    const maxAttempts = 2;
+    let lastError = '';
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        if (attempt > 1)
+            await new Promise((res) => setTimeout(res, RETRY_BACKOFF_MS));
+        let outputBuf = '';
+        const formatter = new OutputFormatter(verbose, (s) => {
+            outputBuf += s;
+        });
+        const result = await runAgent({
+            agent,
+            model,
+            prompt,
+            interactive: false,
+            timeoutMs: DEFAULT_TIMEOUT_MS,
+            onOutput: (chunk) => formatter.push(chunk),
+        });
+        formatter.flush();
+        // Write header + all tool-call output as one block so concurrent workers don't interleave.
+        const retryNote = attempt > 1 ? `  ${c.yellow(`retrying (${attempt}/${maxAttempts})`)}` : '';
+        process.stderr.write(`  ${pos}  ${c.bold(component.name)}${retryNote}\n${outputBuf}`);
+        if (result.timedOut) {
+            // Don't retry timeouts — same timeout will hit again
+            return {
+                componentName: component.name,
+                classified: 0,
+                excluded: 0,
+                slots: 0,
+                warnings: [],
+                failed: true,
+                error: `timed out after ${DEFAULT_TIMEOUT_MS / 60000} minutes`,
+            };
+        }
+        if (result.exitCode !== 0) {
+            lastError = `agent exited with code ${result.exitCode}`;
+            continue;
+        }
+        const { calls, warnings } = parseToolCallLines(result.stdout);
+        if (calls.length === 0) {
+            lastError = 'agent produced no tool calls';
+            continue;
+        }
+        const applied = applyToolCalls(db, sessionId, component.component_id, component.name, calls, warnings);
+        if (!noCache) {
+            const inputHash = computeComponentInputHash(component);
+            storeCache(db, inputHash, 'component', component.component_id, sessionId, false);
+        }
+        return {
+            componentName: component.name,
+            classified: applied.classified,
+            excluded: applied.excluded,
+            slots: applied.slots,
+            warnings: applied.warnings,
+            failed: false,
+        };
+    }
+    return {
+        componentName: component.name,
+        classified: 0,
+        excluded: 0,
+        slots: 0,
+        warnings: [],
+        failed: true,
+        error: lastError,
+    };
+}
+async function runAllComponents(agent, model, db, sessionId, components, tokensInline, tokenMapInline, verbose, noCache) {
+    const concurrency = Number(process.env.EDS_GENERATE_CONCURRENCY ?? DEFAULT_COMPONENT_CONCURRENCY);
+    process.stderr.write(`Categorizing ${c.bold(String(components.length))} component${components.length === 1 ? '' : 's'}` +
+        c.dim(`  (concurrency: ${concurrency})`) +
+        '\n');
+    const results = new Array(components.length);
+    let next = 0;
+    async function worker() {
+        while (next < components.length) {
+            const i = next++;
+            results[i] = await runOneComponent(agent, model, db, sessionId, components[i], tokensInline, tokenMapInline, i, components.length, verbose, noCache);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, components.length) }, worker));
+    return results;
+}
+function resolveSessionId(sessionFlag) {
+    if (sessionFlag)
+        return sessionFlag;
+    const db = openPipelineDb();
+    try {
+        const row = db
+            .prepare(`SELECT s.id FROM sessions s
+         JOIN steps st ON st.session_id = s.id
+         WHERE st.command = 'analyze extract'
+           AND st.status = 'complete'
+         ORDER BY st.started_at DESC
+         LIMIT 1`)
+            .get();
+        if (!row) {
+            process.stderr.write('Error: no completed analyze extract session found. Run analyze extract first, or pass --session <id>.\n');
+            process.exit(1);
+        }
+        return row.id;
+    }
+    finally {
+        db.close();
+    }
+}
+async function loadAcceptedNames(sessionId) {
+    try {
+        const artifactsRoot = getRefineArtifactsRoot();
+        const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
+        const raw = await readFile(paths.statePath, 'utf8');
+        const snapshot = JSON.parse(raw);
+        const accepted = snapshot.components.filter((c) => c.status === 'accepted').map((c) => c.name);
+        if (accepted.length === 0)
+            return null;
+        return new Set(accepted);
+    }
+    catch {
+        return null;
+    }
+}
+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 agent = opts.agent;
+    if (skill === 'tokens' && !opts.rawTokens) {
+        die('Error: --raw-tokens is required when using generate tokens');
+    }
+    if (opts.rawTokens)
+        await assertFileExists('--raw-tokens', opts.rawTokens);
+    if (opts.tokens)
+        await assertFileExists('--tokens', opts.tokens);
+    if (opts.tokenMap)
+        await assertFileExists('--token-map', opts.tokenMap);
+    // Read all token files inline so the agent never needs to read files itself
+    const [rawTokensInline, tokensInline, tokenMapInline] = await Promise.all([
+        readFileInline(opts.rawTokens),
+        readFileInline(opts.tokens),
+        readFileInline(opts.tokenMap),
+    ]);
+    // Load raw components from DB for the components skill
+    let sessionId;
+    let allComponents;
+    if (skill === 'components') {
+        sessionId = resolveSessionId(opts.session);
+        const acceptedNames = await loadAcceptedNames(sessionId);
+        const db = openPipelineDb();
+        try {
+            allComponents = loadRawComponents(db, sessionId, acceptedNames ?? undefined);
+        }
+        finally {
+            db.close();
+        }
+        if (allComponents.length === 0) {
+            die(`Error: session '${sessionId}' has no raw components. Run analyze extract first.`);
+        }
+        if (acceptedNames) {
+            process.stderr.write(`Scope: ${allComponents.length} accepted component(s) from analyze select\n`);
+        }
+        // Warn about duplicate component names — later occurrences will overwrite earlier ones
+        const nameCounts = new Map();
+        for (const c of allComponents) {
+            const sources = nameCounts.get(c.name) ?? [];
+            sources.push(c.source);
+            nameCounts.set(c.name, sources);
+        }
+        const dupes = [...nameCounts.entries()].filter(([, srcs]) => srcs.length > 1);
+        if (dupes.length > 0) {
+            process.stderr.write(`Warning: ${dupes.length} duplicate component name(s) detected — only the last occurrence will be generated:\n`);
+            for (const [name, sources] of dupes) {
+                process.stderr.write(`  ${name}:\n`);
+                for (const src of sources)
+                    process.stderr.write(`    ${src}\n`);
+            }
+        }
+    }
+    if (opts.dryRun) {
+        const sampleComponent = allComponents?.[0];
+        const sampleInline = sampleComponent
+            ? JSON.stringify([
+                {
+                    name: sampleComponent.name,
+                    source: sampleComponent.source,
+                    framework: sampleComponent.framework,
+                    props: sampleComponent.props,
+                    slots: sampleComponent.slots,
+                },
+            ], null, 2)
+            : undefined;
+        const prompt = await buildPrompt({
+            skill,
+            mode: 'autonomous',
+            rawComponentsInline: sampleInline ?? rawTokensInline,
+            rawTokensInline: skill === 'tokens' ? rawTokensInline : undefined,
+            rawTokensFilename: opts.rawTokens ? resolve(opts.rawTokens).split('/').pop() : undefined,
+            tokensInline,
+            tokenMapInline,
+            outDir: process.cwd(),
+        });
+        process.stdout.write(prompt + '\n');
+        process.exit(0);
+    }
+    const binary = resolveBinary(agent);
+    if (!(await assertBinaryInPath(binary))) {
+        printFallbackInstructions({
+            agent,
+            skill,
+            sessionId: sessionId ?? '',
+        });
+        process.exit(1);
+    }
+    if (skill === 'components' && allComponents && sessionId) {
+        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');
+        }
+        finally {
+            db.close();
+        }
+        const failed = componentResults.filter((r) => r.failed);
+        const cachedResults = componentResults.filter((r) => r.cached);
+        const generated = componentResults.filter((r) => !r.failed && !r.cached);
+        const allWarnings = componentResults.flatMap((r) => r.warnings.map((w) => `  ${r.componentName}: ${w}`));
+        if (allWarnings.length > 0) {
+            process.stderr.write(c.yellow('Warnings:') + '\n' + allWarnings.join('\n') + '\n');
+        }
+        if (failed.length > 0) {
+            process.stderr.write(c.red(`Failed (${failed.length}/${componentResults.length}):`) + '\n');
+            for (const f of failed) {
+                process.stderr.write(`  ${c.red('✗')}  ${f.componentName}  ${c.dim(f.error ?? 'unknown error')}\n`);
+            }
+        }
+        const totalClassified = generated.reduce((s, r) => s + r.classified, 0);
+        const totalExcluded = generated.reduce((s, r) => s + r.excluded, 0);
+        const allOk = failed.length === 0;
+        const cachedNote = cachedResults.length > 0 ? c.dim(`  (${cachedResults.length} cached)`) : '';
+        process.stderr.write((allOk ? c.green('✓') : c.yellow('⚠')) +
+            `  ${generated.length + cachedResults.length}/${componentResults.length} components` +
+            cachedNote +
+            c.dim(`  ${totalClassified} classified, ${totalExcluded} excluded`) +
+            '\n');
+        if (generated.length === 0 && cachedResults.length === 0) {
+            die('Error: all components failed to generate — check agent output above');
+        }
+    }
+    else if (skill === 'tokens') {
+        const noCache = opts.cache === false || process.env.EDS_NO_CACHE === '1';
+        const tokenInputContent = rawTokensInline ?? '';
+        const tokenInputHash = computeTokenInputHash(tokenInputContent);
+        const db = openPipelineDb();
+        try {
+            let resolvedSessionId = opts.session;
+            if (!resolvedSessionId) {
+                const s = db
+                    .prepare(`SELECT s.id FROM sessions s
+           JOIN steps st ON st.session_id = s.id
+           WHERE st.command = 'analyze extract' AND st.status = 'complete'
+           ORDER BY st.started_at DESC LIMIT 1`)
+                    .get();
+                if (s) {
+                    resolvedSessionId = s.id;
+                }
+                else {
+                    const { generateSessionId } = await import('../session/session-id.js');
+                    const newId = generateSessionId();
+                    const now = new Date().toISOString();
+                    db.prepare('INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, NULL, ?, ?)').run(newId, now, now);
+                    resolvedSessionId = newId;
+                }
+            }
+            // Check cache before invoking agent
+            if (!noCache) {
+                const tokenCached = lookupCache(db, tokenInputHash, 'token_set', '__tokens__');
+                if (tokenCached) {
+                    copyTokensFromCache(db, tokenCached.sourceSessionId, resolvedSessionId);
+                    sessionId = resolvedSessionId;
+                    process.stderr.write(`Done: tokens reused from cache ${c.dim(`(source: ${tokenCached.sourceSessionId.slice(0, 12)})`)}\n`);
+                    db.close();
+                    // Skip agent invocation — jump to view
+                    const viewResult = { skill, agent, sessionId: sessionId ?? '' };
+                    if (process.stdout.isTTY) {
+                        const { waitUntilExit } = render(createElement(GenerateView, { result: viewResult, onExit: () => process.exit(0) }));
+                        await waitUntilExit();
+                    }
+                    else {
+                        process.stdout.write(`generate complete\nskill: ${skill}\nagent: ${agent}\nsession: ${sessionId ?? ''}\n`);
+                        process.exit(0);
+                    }
+                    return;
+                }
+            }
+            // Cache miss — invoke agent
+            const prompt = await buildPrompt({
+                skill,
+                mode: 'autonomous',
+                rawTokensInline,
+                rawTokensFilename: opts.rawTokens ? resolve(opts.rawTokens).split('/').pop() : undefined,
+                tokensInline,
+                tokenMapInline,
+                outDir: process.cwd(),
+            });
+            const result = await runAgent({
+                agent,
+                model: opts.model,
+                prompt,
+                interactive: false,
+                timeoutMs: DEFAULT_TIMEOUT_MS * 5,
+            });
+            if (result.timedOut) {
+                die(`Error: agent did not complete within ${(DEFAULT_TIMEOUT_MS * 5) / 60000} minutes`);
+            }
+            if (result.exitCode !== 0) {
+                if (result.stderr)
+                    process.stderr.write(result.stderr);
+                die(`Error: agent exited with code ${result.exitCode}`);
+            }
+            const { calls: tokenCalls, warnings: tokenWarnings } = parseTokenToolCallLines(result.stdout);
+            const tokenCount = tokenCalls.filter((tc) => tc.tool === 'set_token').length;
+            if (tokenCount === 0) {
+                process.stderr.write(`Error: agent produced no set_token calls.\n` +
+                    `Run with --dry-run to inspect the prompt.\n\n` +
+                    `Agent output:\n${result.stdout}\n`);
+                process.exit(1);
+            }
+            if (tokenWarnings.length > 0) {
+                process.stderr.write(`Warnings:\n${tokenWarnings.map((w) => `  ${w}`).join('\n')}\n`);
+            }
+            applyTokenToolCalls(db, resolvedSessionId, tokenCalls, []);
+            if (!noCache) {
+                storeCache(db, tokenInputHash, 'token_set', '__tokens__', resolvedSessionId, false);
+            }
+            sessionId = resolvedSessionId;
+            const groupCount = tokenCalls.filter((tc) => tc.tool === 'set_group').length;
+            process.stderr.write(`Done: ${tokenCount} tokens, ${groupCount} groups stored\n`);
+        }
+        finally {
+            db.close();
+        }
+    }
+    const viewResult = {
+        skill,
+        agent,
+        sessionId: sessionId ?? '',
+    };
+    if (process.stdout.isTTY) {
+        const { waitUntilExit } = render(createElement(GenerateView, {
+            result: viewResult,
+            onExit: () => process.exit(0),
+        }));
+        await waitUntilExit();
+    }
+    else {
+        process.stdout.write(`generate complete\nskill: ${skill}\nagent: ${agent}\nsession: ${sessionId ?? ''}\n`);
+        process.exit(0);
+    }
+}
+function addAgentFlags(cmd) {
+    return cmd
+        .requiredOption('--agent <name>', 'Agent to use: claude, codex, opencode, cursor')
+        .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')
+        .option('--no-cache', 'Bypass generation cache and force AI re-generation');
+}
+export function registerGenerateCommand(program) {
+    const generate = program.command('generate').description('Generate CDF/DTCG artifacts or correct generation output');
+    // generate components subcommand
+    const componentsCmd = generate
+        .command('components')
+        .description('Invoke a coding agent to produce components.json from raw analysis output')
+        .option('--session <id>', 'Session ID from analyze extract (defaults to most recent)')
+        .option('--tokens <path>', 'Path to tokens.json for token-linked prop resolution')
+        .option('--token-map <path>', 'Path to token-name-map.json sidecar');
+    addAgentFlags(componentsCmd).action(async (opts) => {
+        await runGenerateSkill('components', opts, opts.verbose ?? false);
+    });
+    registerGenerateEditCommand(componentsCmd, 'components');
+    // generate tokens subcommand
+    const tokensCmd = generate
+        .command('tokens')
+        .description('Invoke a coding agent to produce tokens.json from raw token data')
+        .option('--raw-tokens <path>', 'Path to raw token input file');
+    addAgentFlags(tokensCmd).action(async (opts) => {
+        await runGenerateSkill('tokens', opts, opts.verbose ?? false);
+    });
+    registerGenerateEditCommand(tokensCmd, 'tokens');
+}

package/dist/src/generate/edit/command.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerGenerateEditCommand(parent: Command, skill: string): void;

package/dist/src/generate/edit/command.js

@@ -0,0 +1,126 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const SAFE_PATH_RE = /^[a-zA-Z0-9_.$[\]=]+$/;
+const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function applyDotPath(obj, path, value) {
+    if (!SAFE_PATH_RE.test(path)) {
+        process.stderr.write(`Warning: --patch path contains invalid characters: '${path}', skipping\n`);
+        return;
+    }
+    const parts = path.split('.');
+    if (parts.some((p) => PROTO_KEYS.has(p))) {
+        process.stderr.write(`Warning: --patch path contains forbidden key: '${path}', skipping\n`);
+        return;
+    }
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        const arrayMatch = /^(.+)\[name=(.+)\]$/.exec(part);
+        if (arrayMatch) {
+            const [, fieldName, matchValue] = arrayMatch;
+            const arr = current[fieldName];
+            if (Array.isArray(arr)) {
+                const item = arr.find((el) => el['name'] === matchValue);
+                if (item) {
+                    current = item;
+                }
+                else {
+                    process.stderr.write(`Warning: --patch array item [name=${matchValue}] not found in '${fieldName}', skipping\n`);
+                    return;
+                }
+            }
+        }
+        else {
+            if (typeof current[part] !== 'object' || current[part] === null) {
+                process.stderr.write(`Warning: --patch path '${path}' — '${part}' is not an object, skipping\n`);
+                return;
+            }
+            current = current[part];
+        }
+    }
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = value;
+}
+function applyPatch(components, ops) {
+    return components.map((c) => {
+        const op = ops.find((o) => o.component === c.name);
+        if (!op)
+            return c;
+        let updated = { ...c };
+        if (op.status) {
+            updated = { ...updated, status: op.status };
+        }
+        if (op.set) {
+            const clone = structuredClone(updated);
+            for (const [path, value] of Object.entries(op.set)) {
+                applyDotPath(clone, path, value);
+            }
+            updated = clone;
+        }
+        return updated;
+    });
+}
+async function loadComponentsFromSession(_sessionId, _skill) {
+    // TODO: read from pipeline.db session when the unified session layer ships
+    // For now return empty list; non-interactive flags operate on whatever is in the DB
+    process.stderr.write('Error: generate edit requires a session database (not yet implemented — coming in the next release)\n');
+    process.exit(1);
+}
+async function runNonInteractive(opts, skill) {
+    let components = await loadComponentsFromSession(opts.session, skill);
+    if (opts.acceptAll || (opts.reject ?? []).length > 0) {
+        const rejectPatterns = (opts.reject ?? []).map((p) => p.toLowerCase());
+        components = components.map((c) => {
+            const rejected = rejectPatterns.some((p) => c.name.toLowerCase().includes(p));
+            return { ...c, status: rejected ? 'rejected' : 'accepted' };
+        });
+    }
+    if (opts.patch) {
+        let patchOps;
+        try {
+            const raw = await readFile(resolve(opts.patch), 'utf8');
+            patchOps = JSON.parse(raw);
+        }
+        catch {
+            process.stderr.write(`Error: cannot read or parse --patch file: ${opts.patch}\n`);
+            process.exit(1);
+            return;
+        }
+        const knownNames = new Set(components.map((c) => c.name));
+        for (const op of patchOps) {
+            if (!knownNames.has(op.component)) {
+                process.stderr.write(`Warning: --patch targets unknown component '${op.component}', skipping\n`);
+            }
+        }
+        components = applyPatch(components, patchOps);
+    }
+    const accepted = components.filter((c) => c.status === 'accepted');
+    const rejected = components.filter((c) => c.status === 'rejected');
+    process.stderr.write(`Accepted: ${accepted.length}  Rejected: ${rejected.length}\n`);
+}
+export function registerGenerateEditCommand(parent, skill) {
+    parent
+        .command('edit')
+        .description(`Review and correct generate ${skill} output before pushing`)
+        .option('--session <id>', 'Session ID to operate on (defaults to most recent active session)')
+        .option('--accept-all', 'Accept all definitions without launching the TUI')
+        .option('--reject <pattern>', 'Reject definitions whose name contains pattern (repeatable)', collect, [])
+        .option('--patch <path>', 'Path to a JSON patch file for structured definition overrides')
+        .action(async ({ session, acceptAll, reject, patch }) => {
+        const nonInteractive = acceptAll || (reject ?? []).length > 0 || !!patch;
+        if (nonInteractive) {
+            await runNonInteractive({ session, acceptAll, reject, patch }, skill);
+            return;
+        }
+        if (!process.stdout.isTTY) {
+            process.stderr.write(`Error: generate ${skill} edit requires an interactive terminal\n`);
+            process.exit(1);
+        }
+        // TUI not yet implemented
+        process.stderr.write(`Error: interactive generate ${skill} edit TUI is not yet available. Use --accept-all, --reject, or --patch for non-interactive mode.\n`);
+        process.exit(1);
+    });
+}
+function collect(val, prev) {
+    return [...prev, val];
+}

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

@@ -0,0 +1,18 @@
+/** `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;
+}
+export declare function buildPrompt(options: PromptOptions): Promise<string>;
+export declare function resolveSkillPath(skill: Skill): string;