@contentful/experience-design-system-cli 2.11.4-dev-build-d47ab65.0 → 2.12.1-dev-build-589b615.0

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

@@ -1,16 +1,30 @@
-import { openPipelineDb, loadRawComponents, loadScannedFiles, createStep, updateStep } from '../../session/db.js';
+import { openPipelineDb, loadRawComponents, loadScannedFiles, createStep, updateStep, computeComponentInputHash, lookupSelectCache, storeSelectCache, getCliCacheVersion, } from '../../session/db.js';
+import { hashPromptForSkill } from '../../session/cache-keys.js';
 import { appendReviewEvent, getRefineArtifactsRoot, ensureRefineSession, getRefineSessionPaths, saveReviewState, } from '../select/persistence.js';
 import { loadReviewInput } from '../select/parser.js';
 import { buildPrompt } from '../../generate/prompt-builder.js';
+import { formatCustomPromptBanner } from '../../generate/command.js';
 import { parseSelectToolCallLines, runAgent } from '../../generate/agent-runner.js';
+import { access } from 'node:fs/promises';
 import { readExperiencesCredentials } from '../../credentials-store.js';
 import { OutputFormatter, c } from '../../output/format.js';
 import { buildRepoContextIndex, buildSelectionContext } from './context-builder.js';
+import { runShowRationale } from './show-rationale.js';
 import { isAbsolute, resolve } from 'node:path';
 import { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, } from '../extract/validate.js';
 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_CONCURRENCY = 5;
+export const DEFAULT_CONCURRENCY = 10;
+export const DEFAULT_BATCH_SIZE = 5;
+function resolveBatchSize() {
+    const raw = process.env.EDS_SELECT_BATCH_SIZE;
+    if (!raw)
+        return DEFAULT_BATCH_SIZE;
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1)
+        return DEFAULT_BATCH_SIZE;
+    return Math.floor(n);
+}
 function resolveSessionId(sessionFlag) {
     if (sessionFlag)
         return sessionFlag;
@@ -83,15 +97,14 @@ function resolveProjectRoot(sessionId, projectRootFlag) {
         db.close();
     }
 }
-async function selectOneComponent(agent, model, candidate, index, total, verbose) {
-    const { component } = candidate;
+async function selectBatch(agent, model, batch, total, verbose, skillPathOverride) {
     const prompt = await buildPrompt({
         skill: 'select',
         mode: 'autonomous',
-        rawComponentsInline: JSON.stringify([buildComponentData(candidate)], null, 2),
+        rawComponentsInline: JSON.stringify(batch.map((b) => buildComponentData(b.candidate)), null, 2),
         outDir: process.cwd(),
+        skillPathOverride,
     });
-    const pos = c.dim(`[${index + 1}/${total}]`);
     let outputBuf = '';
     const formatter = new OutputFormatter(verbose, (s) => {
         outputBuf += s;
@@ -106,67 +119,183 @@ async function selectOneComponent(agent, model, candidate, index, total, verbose
     });
     formatter.flush();
     if (verbose) {
-        process.stderr.write(`  ${pos}  ${c.bold(component.name)}\n${outputBuf}`);
+        const names = batch.map((b) => b.candidate.component.name).join(', ');
+        process.stderr.write(`  ${c.bold(`batch: ${names}`)}\n${outputBuf}`);
     }
+    // Feature 3: emit one progress= line per component (in input order) regardless
+    // of batch outcome. The wizard's runAutoFilter parser depends on this contract.
+    const emitProgress = (item, decision, reason) => {
+        const reasonEncoded = reason ? encodeURIComponent(reason) : '';
+        process.stderr.write(`progress=select-agent:${item.index + 1}/${total}:${decision}:${item.candidate.component.name}:${reasonEncoded}\n`);
+    };
+    // Whole-batch failure: timeout or non-zero exit. Mark every item failed and
+    // do NOT emit progress lines (no decision was made).
     if (result.timedOut) {
-        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.yellow('timed out')}\n`);
-        return {
-            componentKey: componentKey(component),
-            componentName: component.name,
+        for (const item of batch) {
+            const pos = c.dim(`[${item.index + 1}/${total}]`);
+            process.stderr.write(`  ${pos}  ${c.bold(item.candidate.component.name)}  ${c.yellow('timed out')}\n`);
+        }
+        return batch.map((item) => ({
+            componentKey: componentKey(item.candidate.component),
+            componentName: item.candidate.component.name,
             decision: null,
             failed: true,
-        };
+        }));
     }
     if (result.exitCode !== 0) {
-        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.red(`agent exited with code ${result.exitCode}`)}\n`);
-        return {
-            componentKey: componentKey(component),
-            componentName: component.name,
+        for (const item of batch) {
+            const pos = c.dim(`[${item.index + 1}/${total}]`);
+            process.stderr.write(`  ${pos}  ${c.bold(item.candidate.component.name)}  ${c.red(`agent exited with code ${result.exitCode}`)}\n`);
+        }
+        return batch.map((item) => ({
+            componentKey: componentKey(item.candidate.component),
+            componentName: item.candidate.component.name,
             decision: null,
             failed: true,
-        };
+        }));
     }
     const { calls, warnings } = parseSelectToolCallLines(result.stdout);
     if (warnings.length > 0) {
         for (const warning of warnings) {
-            process.stderr.write(`  ${c.yellow('⚠')}  ${component.name}: ${warning}\n`);
+            process.stderr.write(`  ${c.yellow('⚠')}  batch: ${warning}\n`);
         }
     }
-    const call = calls.find((toolCall) => toolCall.name === component.name) ?? calls[0];
-    if (!call) {
-        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.yellow('no tool call')}\n`);
-        return {
+    const results = [];
+    for (const item of batch) {
+        const { component } = item.candidate;
+        const pos = c.dim(`[${item.index + 1}/${total}]`);
+        const call = calls.find((toolCall) => toolCall.name === component.name);
+        if (!call) {
+            process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${c.yellow('no tool call')}\n`);
+            results.push({
+                componentKey: componentKey(component),
+                componentName: component.name,
+                decision: null,
+                failed: true,
+            });
+            continue;
+        }
+        const decision = call.tool === 'select_component' ? 'accepted' : 'rejected';
+        const finalColor = decision === 'accepted' ? c.green : c.red;
+        process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${finalColor(decision)}${call.reason ? `  ${c.dim(call.reason)}` : ''}\n`);
+        emitProgress(item, decision, call.reason);
+        results.push({
             componentKey: componentKey(component),
             componentName: component.name,
-            decision: null,
-            failed: true,
-        };
+            decision,
+            reason: call.reason,
+            failed: false,
+        });
     }
-    const decision = call.tool === 'select_component' ? 'accepted' : 'rejected';
-    const finalColor = decision === 'accepted' ? c.green : c.red;
-    process.stderr.write(`  ${pos}  ${c.bold(component.name)}  ${finalColor(decision)}${call.reason ? `  ${c.dim(call.reason)}` : ''}\n`);
-    return {
-        componentKey: componentKey(component),
-        componentName: component.name,
-        decision,
-        reason: call.reason,
-        failed: false,
-    };
+    return results;
 }
-async function selectAllComponents(agent, model, components, verbose) {
+async function selectAllComponents(agent, model, components, verbose, skillPathOverride, cacheConfig = { noCache: true }) {
     const concurrency = Number(process.env.EDS_GENERATE_CONCURRENCY ?? DEFAULT_CONCURRENCY);
-    process.stderr.write(`Validating ${c.bold(String(components.length))} component${components.length === 1 ? '' : 's'}` +
-        c.dim(`  (concurrency: ${concurrency})`) +
+    const batchSize = resolveBatchSize();
+    const total = components.length;
+    // ── Fine-grained select cache: replay decisions for components whose
+    // (component_hash, prompt_hash, cli_version) triple already has a row. Only
+    // uncached components are forwarded to the LLM batches.
+    const cachedResults = new Map();
+    let promptHash = '';
+    let cliVersion = '';
+    if (!cacheConfig.noCache) {
+        try {
+            promptHash = await hashPromptForSkill('select', skillPathOverride);
+            cliVersion = await getCliCacheVersion();
+            const db = openPipelineDb(cacheConfig.dbPath);
+            try {
+                for (let i = 0; i < components.length; i++) {
+                    const candidate = components[i];
+                    const compHash = computeComponentInputHash(candidate.component);
+                    const hit = lookupSelectCache(db, compHash, promptHash, cliVersion);
+                    if (hit) {
+                        const finalColor = hit.decision === 'accepted' ? c.green : c.red;
+                        process.stderr.write(`  ${c.dim(`[${i + 1}/${total}]`)}  ${c.bold(candidate.component.name)}  ${finalColor(hit.decision)} ${c.dim('(cached)')}` +
+                            (hit.reason ? `  ${c.dim(hit.reason)}` : '') +
+                            '\n');
+                        // Mirror the progress= line that selectBatch emits for live LLM
+                        // calls so the wizard's parser sees a uniform stream.
+                        const reasonEncoded = hit.reason ? encodeURIComponent(hit.reason) : '';
+                        process.stderr.write(`progress=select-agent:${i + 1}/${total}:${hit.decision}:${candidate.component.name}:${reasonEncoded}\n`);
+                        cachedResults.set(i, {
+                            componentKey: componentKey(candidate.component),
+                            componentName: candidate.component.name,
+                            decision: hit.decision,
+                            reason: hit.reason ?? undefined,
+                            failed: false,
+                        });
+                    }
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Cache prefill is best-effort. On any error, fall through and run the
+            // full LLM batch path.
+        }
+    }
+    // Build the work-set of components we still need to ask the LLM about.
+    const uncached = [];
+    const uncachedIndices = [];
+    for (let i = 0; i < components.length; i++) {
+        if (!cachedResults.has(i)) {
+            uncached.push(components[i]);
+            uncachedIndices.push(i);
+        }
+    }
+    // Chunk into batches of `batchSize`, preserving original indices for the
+    // per-component progress=select-agent: lines.
+    const batches = [];
+    for (let i = 0; i < uncached.length; i += batchSize) {
+        const slice = uncached.slice(i, i + batchSize);
+        batches.push(slice.map((candidate, j) => ({ candidate, index: uncachedIndices[i + j] })));
+    }
+    process.stderr.write(`Validating ${c.bold(String(uncached.length))} component${uncached.length === 1 ? '' : 's'}` +
+        (cachedResults.size > 0 ? c.dim(`  (${cachedResults.size} cached)`) : '') +
+        c.dim(`  (concurrency: ${concurrency}, batch: ${batchSize}, batches: ${batches.length})`) +
         '\n');
-    const results = new Array(components.length);
-    let next = 0;
+    const results = new Array(total);
+    for (const [i, r] of cachedResults)
+        results[i] = r;
+    let nextBatch = 0;
     async function worker() {
-        while (next < components.length) {
-            const i = next++;
-            results[i] = await selectOneComponent(agent, model, components[i], i, components.length, verbose);
+        while (nextBatch < batches.length) {
+            const b = nextBatch++;
+            const batch = batches[b];
+            const batchResults = await selectBatch(agent, model, batch, total, verbose, skillPathOverride);
+            for (let k = 0; k < batch.length; k++) {
+                results[batch[k].index] = batchResults[k];
+            }
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(concurrency, batches.length) }, worker));
+    // Persist fresh decisions (skip cached + failed ones).
+    if (!cacheConfig.noCache && promptHash) {
+        try {
+            const db = openPipelineDb(cacheConfig.dbPath);
+            try {
+                for (let i = 0; i < results.length; i++) {
+                    if (cachedResults.has(i))
+                        continue;
+                    const r = results[i];
+                    if (!r || r.failed || !r.decision)
+                        continue;
+                    const candidate = components[i];
+                    const compHash = computeComponentInputHash(candidate.component);
+                    storeSelectCache(db, compHash, promptHash, cliVersion, r.decision, r.reason ?? null);
+                }
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            // Best-effort.
         }
     }
-    await Promise.all(Array.from({ length: Math.min(concurrency, components.length) }, worker));
     return results;
 }
 export function registerAnalyzeSelectAgentCommand(program) {
@@ -180,7 +309,29 @@ export function registerAnalyzeSelectAgentCommand(program) {
         .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)')
+        .option('--select-prompt-path <path>', 'Path to a custom .md skill prompt for select-agent (bypasses bundled prompt invariants)')
+        .option('--no-select-cache', 'Skip the per-component select cache and re-LLM every component')
+        .option('--no-cache', 'Skip ALL fine-grained caches (extract, select, generate)')
+        .option('--show-rationale', 'Read-only: print the AI rejection rationale persisted by a prior select-agent run and exit. ' +
+        'No LLM call. Combine with --json for machine-readable output.')
+        .option('--json', 'When used with --show-rationale, emit a JSON array instead of a human-readable table')
         .action(async (opts) => {
+        // --show-rationale is a read-only branch that short-circuits the normal
+        // select-agent flow. It re-reads the rationale columns persisted by a
+        // prior run (raw_components.status + reject_reason) and prints them.
+        // No LLM call, no agent resolution, no validation gates.
+        if (opts.showRationale) {
+            try {
+                runShowRationale({ session: opts.session, json: opts.json });
+                return;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`Error: ${message}\n`);
+                process.exit(1);
+                return;
+            }
+        }
         const savedCreds = await readExperiencesCredentials();
         const agentName = opts.agent ?? savedCreds.agent;
         const model = opts.model ?? savedCreds.agentModel;
@@ -190,6 +341,24 @@ export function registerAnalyzeSelectAgentCommand(program) {
             return;
         }
         const agent = agentName;
+        // Feature 8: validate + announce custom prompt path before any heavy
+        // work. Flag wins over saved credentials.
+        const selectPromptPath = opts.selectPromptPath ?? savedCreds.selectPromptPath;
+        if (selectPromptPath) {
+            const resolvedPath = resolve(selectPromptPath);
+            const exists = await access(resolvedPath)
+                .then(() => true)
+                .catch(() => false);
+            if (!exists) {
+                process.stderr.write(`Error: custom prompt path not found: ${resolvedPath}\n`);
+                process.exit(1);
+                return;
+            }
+            if (!selectPromptPath.toLowerCase().endsWith('.md')) {
+                process.stderr.write(`WARNING: custom prompt path does not end in .md (${selectPromptPath}) — proceeding anyway.\n`);
+            }
+            process.stderr.write(formatCustomPromptBanner('select', resolvedPath));
+        }
         const sessionId = resolveSessionId(opts.session);
         const selectionRoot = resolveProjectRoot(sessionId, opts.projectRoot);
         const db = openPipelineDb();
@@ -265,19 +434,64 @@ export function registerAnalyzeSelectAgentCommand(program) {
                 mode: 'autonomous',
                 rawComponentsInline: JSON.stringify([buildComponentData(first)], null, 2),
                 outDir: process.cwd(),
+                skillPathOverride: selectPromptPath ? resolve(selectPromptPath) : undefined,
             });
             process.stdout.write(prompt + '\n');
             process.exit(0);
             return;
         }
-        const selectResults = await selectAllComponents(agent, model, selectionCandidates, opts.verbose ?? false);
+        // --no-cache is the global kill-switch; --no-select-cache is the stage-
+        // specific opt-out. Both Commander negation flags arrive as `false` when
+        // the user passed --no-*; default (undefined) means cache stays on.
+        const noCache = opts.cache === false || opts.selectCache === false || process.env.EDS_NO_CACHE === '1';
+        const selectResults = await selectAllComponents(agent, model, selectionCandidates, opts.verbose ?? false, selectPromptPath ? resolve(selectPromptPath) : undefined, { noCache });
         // Build decision map from results. Seed auto-rejections from validation exclusions first.
         const decisions = new Map();
+        // Track per-component reasons (for raw_components.reject_reason persistence).
+        // Validation auto-rejections get a synthesized "validation error: <codes>" reason
+        // so the scope-gate UI can distinguish wizard- vs LLM-driven exclusions.
+        const reasons = new Map();
         for (const comp of invalidComponents) {
             decisions.set(componentKey(comp), 'rejected');
+            const codes = (comp.validationIssues ?? [])
+                .filter((i) => i.severity === 'error')
+                .map((i) => i.code)
+                .join(', ');
+            reasons.set(componentKey(comp), `validation error: ${codes}`);
         }
         for (const r of selectResults) {
             decisions.set(r.componentKey, r.decision);
+            if (r.decision === 'rejected' && r.reason) {
+                reasons.set(r.componentKey, r.reason);
+            }
+            else if (r.decision === 'accepted') {
+                // Defensive: clear any previously-stored reason on re-runs that flip a
+                // rejected component to accepted.
+                reasons.set(r.componentKey, null);
+            }
+        }
+        // Feature 3: persist decisions to raw_components (status + reject_reason)
+        // so the wizard can render LLM exclusions in the scope-gate without re-reading
+        // the snapshot file. We open a fresh DB handle here (the earlier one was closed
+        // after loading raw components above) and reuse it for the step-recording below.
+        const persistDb = openPipelineDb();
+        try {
+            const updateStmt = persistDb.prepare(`UPDATE raw_components
+             SET status = ?, reject_reason = ?
+             WHERE session_id = ? AND component_id = ?`);
+            for (const comp of validatedComponents) {
+                const key = componentKey(comp);
+                const decision = decisions.get(key);
+                if (!decision)
+                    continue;
+                if (!comp.component_id)
+                    continue;
+                const reason = reasons.get(key) ?? null;
+                updateStmt.run(decision, decision === 'accepted' ? null : reason, sessionId, comp.component_id);
+            }
+        }
+        finally {
+            persistDb.close();
         }
         const artifactsRoot = getRefineArtifactsRoot();
         let snapshot;

package/dist/src/analyze/select-agent/show-rationale.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Read-only rationale view for the `analyze select-agent --show-rationale` flag.
+ *
+ * Reads the rationale data already persisted by a previous `analyze select-agent`
+ * run (component-level decision + reject reason on raw_components; per-prop
+ * rationale on raw_props — both populated by the writer path in command.ts and
+ * the rationale columns added in the schema migration for PR #52). No LLM
+ * invocation, no schema changes.
+ *
+ * Schema-version assertion: if the rationale columns are absent (older DB),
+ * throw with a clear message pointing at the remediation step.
+ */
+export interface RationaleRow {
+    name: string;
+    decision: 'accepted' | 'rejected' | 'needs-review' | 'extracted';
+    reason: string | null;
+}
+/**
+ * Resolves which session to read from. If `sessionFlag` is provided, asserts
+ * the session exists and has at least one raw component; otherwise falls back
+ * to the most recent completed `analyze select` step.
+ */
+export declare function resolveRationaleSession(sessionFlag: string | undefined, dbPath?: string): string;
+export declare function loadRationaleRows(sessionId: string, dbPath?: string): RationaleRow[];
+export declare function formatRationaleTable(rows: RationaleRow[]): string;
+export declare function formatRationaleJson(rows: RationaleRow[]): string;
+/**
+ * Top-level dispatch for `analyze select-agent --show-rationale`. Pure I/O
+ * boundary: reads DB, writes formatted output to stdout, throws on error.
+ */
+export declare function runShowRationale(opts: {
+    session?: string;
+    json?: boolean;
+    dbPath?: string;
+}): void;

package/dist/src/analyze/select-agent/show-rationale.js

@@ -0,0 +1,92 @@
+import { openPipelineDb, findLatestSessionForCommand } from '../../session/db.js';
+const REQUIRED_COLUMNS = ['status', 'reject_reason'];
+function assertSchema(dbPath) {
+    const db = openPipelineDb(dbPath);
+    try {
+        const cols = db.prepare('PRAGMA table_info(raw_components)').all();
+        const have = new Set(cols.map((c) => c.name));
+        const missing = REQUIRED_COLUMNS.filter((c) => !have.has(c));
+        if (missing.length > 0) {
+            throw new Error(`Rationale data missing — run a fresh 'experiences import' on this session first. ` +
+                `(raw_components is missing column(s): ${missing.join(', ')})`);
+        }
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Resolves which session to read from. If `sessionFlag` is provided, asserts
+ * the session exists and has at least one raw component; otherwise falls back
+ * to the most recent completed `analyze select` step.
+ */
+export function resolveRationaleSession(sessionFlag, dbPath) {
+    const db = openPipelineDb(dbPath);
+    try {
+        if (sessionFlag) {
+            const row = db.prepare('SELECT 1 AS ok FROM raw_components WHERE session_id = ? LIMIT 1').get(sessionFlag);
+            if (!row) {
+                throw new Error(`Session not found or has no components: '${sessionFlag}'. ` +
+                    `Run 'analyze extract' + 'analyze select-agent' on this session first.`);
+            }
+            return sessionFlag;
+        }
+        const latest = findLatestSessionForCommand(db, 'analyze select');
+        if (!latest) {
+            throw new Error(`No completed 'analyze select' session found. Run 'analyze select-agent' first, or pass --session <id>.`);
+        }
+        return latest;
+    }
+    finally {
+        db.close();
+    }
+}
+export function loadRationaleRows(sessionId, dbPath) {
+    const db = openPipelineDb(dbPath);
+    try {
+        const rows = db
+            .prepare(`SELECT name, status, reject_reason FROM raw_components
+         WHERE session_id = ?
+         ORDER BY name`)
+            .all(sessionId);
+        return rows.map((r) => ({
+            name: r.name,
+            decision: r.status ?? 'extracted',
+            reason: r.reject_reason,
+        }));
+    }
+    finally {
+        db.close();
+    }
+}
+export function formatRationaleTable(rows) {
+    if (rows.length === 0) {
+        return 'No rationale rows found for this session.\n';
+    }
+    const header = { name: 'Component', decision: 'Decision', reason: 'Reason' };
+    const all = [header, ...rows.map((r) => ({ name: r.name, decision: r.decision, reason: r.reason ?? '' }))];
+    const nameWidth = Math.max(...all.map((r) => r.name.length));
+    const decisionWidth = Math.max(...all.map((r) => r.decision.length));
+    const lines = [];
+    const fmt = (n, d, r) => `${n.padEnd(nameWidth)}  ${d.padEnd(decisionWidth)}  ${r}`;
+    lines.push(fmt(header.name, header.decision, header.reason));
+    lines.push(fmt('-'.repeat(nameWidth), '-'.repeat(decisionWidth), '-'.repeat(Math.max(6, header.reason.length))));
+    for (const row of rows) {
+        lines.push(fmt(row.name, row.decision, row.reason ?? ''));
+    }
+    return lines.join('\n') + '\n';
+}
+export function formatRationaleJson(rows) {
+    return (JSON.stringify(rows.map((r) => ({ name: r.name, decision: r.decision, reason: r.reason })), null, 2) + '\n');
+}
+/**
+ * Top-level dispatch for `analyze select-agent --show-rationale`. Pure I/O
+ * boundary: reads DB, writes formatted output to stdout, throws on error.
+ */
+export function runShowRationale(opts) {
+    assertSchema(opts.dbPath);
+    const sessionId = resolveRationaleSession(opts.session, opts.dbPath);
+    const rows = loadRationaleRows(sessionId, opts.dbPath);
+    const output = opts.json ? formatRationaleJson(rows) : formatRationaleTable(rows);
+    process.stdout.write(output);
+}

package/dist/src/apply/command.js

@@ -7,6 +7,7 @@ import { ApiError, ImportApiClient } from './api-client.js';
 import { openPipelineDb, loadCDFComponents } from '../session/db.js';
 import { ServerPreviewApp, ServerPreviewConfirm, ServerApplyProgress, ServerApplyDone } from './tui/ServerApplyView.js';
 import { SelectView, makeSelectKey } from './tui/SelectView.js';
+import { buildPostPushUrl } from '../lib/contentful-urls.js';
 function die(message) {
     process.stderr.write(`${message}\n`);
     process.exit(1);
@@ -214,7 +215,7 @@ function buildPreviewOutput(preview, spaceId, environmentId) {
         },
     };
 }
-function buildApplyOutput(operation, spaceId, environmentId) {
+function buildApplyOutput(operation, spaceId, environmentId, host) {
     const items = operation.items ?? [];
     const componentItems = items.filter((i) => i.entityType === 'ComponentType');
     const tokenItems = items.filter((i) => i.entityType === 'DesignToken');
@@ -233,6 +234,7 @@ function buildApplyOutput(operation, spaceId, environmentId) {
         summary: operation.summary,
         componentTypes: countByAction(componentItems),
         designTokens: countByAction(tokenItems),
+        viewUrl: buildPostPushUrl({ host: host ?? 'api.contentful.com', spaceId, environmentId }),
         failures: items
             .filter((item) => item.status === 'failed')
             .map((item) => ({
@@ -529,7 +531,7 @@ export function registerApplyCommand(program) {
                     die(`Error: ${e.message}`);
                 throw e;
             }
-            const summary = buildApplyOutput(operation, spaceId, environmentId);
+            const summary = buildApplyOutput(operation, spaceId, environmentId, opts.host);
             process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
             process.exit(operation.sys.status === 'succeeded' ? 0 : 1);
             return;
@@ -583,6 +585,7 @@ export function registerApplyCommand(program) {
                     operation,
                     spaceId,
                     environmentId,
+                    host: opts.host,
                 }));
                 resolvePromise();
             };
@@ -696,7 +699,7 @@ export function registerApplyCommand(program) {
                     die(`Error: ${e.message}`);
                 throw e;
             }
-            const summary = buildApplyOutput(operation, spaceId, environmentId);
+            const summary = buildApplyOutput(operation, spaceId, environmentId, opts.host);
             process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
             process.exit(operation.sys.status === 'succeeded' ? 0 : 1);
             return;
@@ -762,6 +765,7 @@ export function registerApplyCommand(program) {
                     operation,
                     spaceId,
                     environmentId,
+                    host: opts.host,
                 }));
                 resolvePromise();
             };

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

@@ -27,6 +27,8 @@ interface ServerApplyDoneProps {
     operation: ApplyOperationResponse;
     spaceId: string;
     environmentId: string;
+    /** Configured API host (e.g. `api.contentful.com`). Used to derive the post-push webapp URL. */
+    host?: string;
 }
-export declare function ServerApplyDone({ operation, spaceId, environmentId }: ServerApplyDoneProps): React.ReactElement;
+export declare function ServerApplyDone({ operation, spaceId, environmentId, host }: ServerApplyDoneProps): React.ReactElement;
 export {};

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

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from 'ink';
 import { ServerPreviewView } from './ServerPreviewView.js';
+import { buildPostPushUrl } from '../../lib/contentful-urls.js';
 export function ServerPreviewConfirm({ preview, spaceId, environmentId, breakingWithImpact, onConfirm, onCancel, }) {
     useInput((input, key) => {
         if (key.return)
@@ -24,14 +25,14 @@ export function ServerApplyProgress({ spaceId, environmentId, status, operationI
     });
     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 }) {
+export function ServerApplyDone({ operation, spaceId, environmentId, host }) {
     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." })] }));
+    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)))] })), operation.sys.status === 'succeeded' && operation.summary.succeeded > 0 && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: " View your design system:" }), _jsxs(Text, { color: "cyan", children: [" ", buildPostPushUrl({ host: host ?? 'api.contentful.com', spaceId, environmentId })] })] })), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: " Press Q to exit." })] }));
 }
 function formatItemError(error) {
     if (!error)

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

@@ -5,6 +5,11 @@ export type ExperiencesCredentials = {
     host?: string;
     agent?: string;
     agentModel?: string;
+    /** Feature 8: persisted custom prompt path for `analyze select-agent`. */
+    selectPromptPath?: string;
+    /** Feature 8: persisted custom prompt path for `generate components`. */
+    generatePromptPath?: string;
+    autoFilter?: boolean;
 };
 export declare function readExperiencesCredentials(): Promise<ExperiencesCredentials>;
 export declare function writeExperiencesCredentials(creds: ExperiencesCredentials): Promise<void>;