@contentful/experience-design-system-cli 2.26.1-dev-build-a852362.0 → 2.26.1-dev-build-f03f014.0

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

@@ -1,484 +0,0 @@
-import { access, readFile } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { createElement } from 'react';
-import { render } from 'ink';
-import { requireInteractiveTerminal } from '../../lib/terminal-capabilities.js';
-import { getRefineArtifactsRoot, ensureRefineSession, getRefineSessionPaths, saveReviewState } from './persistence.js';
-import { loadReviewInput } from './parser.js';
-import { App } from './tui/App.js';
-import { openPipelineDb, loadRawComponents, storeRawComponents, createStep, updateStep } from '../../session/db.js';
-import { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, } from '@contentful/experience-design-system-extraction';
-import { bindAnalyticsSessionId, enrichCommandResult, exitWithAnalytics } from '../../analytics/index.js';
-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];
-        // Handle array predicate syntax: field[name=value]
-        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(snapshot, ops) {
-    const components = snapshot.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 editedProposal = structuredClone(updated.editedProposal);
-            for (const [path, value] of Object.entries(op.set)) {
-                applyDotPath(editedProposal, path, value);
-            }
-            updated = {
-                ...updated,
-                editedProposal: editedProposal,
-            };
-        }
-        return updated;
-    });
-    return { ...snapshot, components };
-}
-async function runNonInteractive(snapshot, opts, paths, sessionId) {
-    // --exclude-components on its own (no --select-all / --select / --deselect /
-    // --reject / --patch) is the orchestrator's 422 retry-loop invocation: only
-    // the named components should change. The rebuild path below calls
-    // storeRawComponents which DELETEs all rows and re-inserts with default
-    // status='extracted', wiping the post-generate state required by
-    // loadCDFComponents (status='generated' + raw_props.cdf_type populated).
-    // Short-circuit through rejectComponentsByName, which is a pure UPDATE.
-    const onlyExcludeComponents = !!opts.excludeComponents &&
-        !opts.acceptAll &&
-        !opts.selectAll &&
-        !(opts.select ?? []).length &&
-        !(opts.deselect ?? []).length &&
-        !(opts.reject ?? []).length &&
-        !opts.patch;
-    if (onlyExcludeComponents) {
-        const names = opts
-            .excludeComponents.split(',')
-            .map((n) => n.trim())
-            .filter(Boolean);
-        if (names.length > 0) {
-            // paths.sessionDir = resolve(artifactsRoot, sessionId), so dirname gives
-            // back the artifactsRoot — keeps rejectComponentsByName from re-resolving
-            // it via env var when the caller already knows it.
-            const artifactsRoot = dirname(paths.sessionDir);
-            await rejectComponentsByName(sessionId, names, { artifactsRoot });
-        }
-        const accepted = snapshot.components.filter((c) => c.status === 'accepted').length;
-        const rejected = snapshot.components.filter((c) => c.status === 'rejected').length + (names.length || 0);
-        enrichCommandResult({ accepted_component_count: accepted });
-        process.stderr.write(`Accepted: ${accepted}  Rejected: ${rejected}\n`);
-        return;
-    }
-    let result = { ...snapshot };
-    const rejectPatterns = [...(opts.reject ?? []), ...(opts.deselect ?? [])].map((p) => p.toLowerCase());
-    const selectPatterns = (opts.select ?? []).map((p) => p.toLowerCase());
-    const selectAll = opts.acceptAll || opts.selectAll;
-    // Fail-loud gate: --select-all stops with a non-zero exit when ANY component
-    // has error-severity validation issues. The user must opt in to auto-rejection
-    // with --exclude-invalid. Silent exclusion in CI / orchestrator contexts is
-    // dangerous — the caller should see and acknowledge that components are
-    // being dropped from the import.
-    if (selectAll && !opts.excludeInvalid) {
-        const invalid = result.components.filter((c) => shouldExcludeDueToValidation(c.originalProposal));
-        if (invalid.length > 0) {
-            const lines = [
-                `Error: ${invalid.length} component(s) failed validation; refusing --select-all without --exclude-invalid:`,
-            ];
-            for (const c of invalid) {
-                const codes = (c.originalProposal.validationIssues ?? [])
-                    .filter((i) => i.severity === 'error')
-                    .map((i) => i.code)
-                    .join(', ');
-                lines.push(`  ✗  ${c.name}  ${codes}`);
-            }
-            lines.push('');
-            lines.push('Re-run with --exclude-invalid to auto-reject these components, or run analyze select interactively to fix them.');
-            process.stderr.write(lines.join('\n') + '\n');
-            await exitWithAnalytics(1);
-            return;
-        }
-    }
-    if (selectAll || rejectPatterns.length > 0 || selectPatterns.length > 0) {
-        result = {
-            ...result,
-            components: result.components.map((c) => {
-                const nameLower = c.name.toLowerCase();
-                if (rejectPatterns.some((p) => nameLower.includes(p))) {
-                    return { ...c, status: 'rejected' };
-                }
-                if (selectAll && opts.excludeInvalid && shouldExcludeDueToValidation(c.originalProposal)) {
-                    return { ...c, status: 'rejected' };
-                }
-                if (selectAll || selectPatterns.some((p) => nameLower.includes(p))) {
-                    return { ...c, status: 'accepted' };
-                }
-                return c;
-            }),
-        };
-    }
-    // Apply --exclude-components: force-reject the named components regardless of
-    // how --select-all / --select / --deselect classified them. Used by the
-    // orchestrator's 422 retry loop to exclude server-validation offenders.
-    if (opts.excludeComponents) {
-        const excludeNames = new Set(opts.excludeComponents
-            .split(',')
-            .map((n) => n.trim())
-            .filter(Boolean));
-        if (excludeNames.size > 0) {
-            result = {
-                ...result,
-                components: result.components.map((c) => excludeNames.has(c.name) ? { ...c, status: 'rejected' } : c),
-            };
-        }
-    }
-    // Apply --patch
-    if (opts.patch) {
-        let patchOps;
-        try {
-            const raw = await readFile(resolve(opts.patch), 'utf8');
-            const parsed = JSON.parse(raw);
-            if (!Array.isArray(parsed)) {
-                process.stderr.write(`Error: --patch file must be a JSON array of patch operations: ${opts.patch}\n`);
-                await exitWithAnalytics(1);
-                return;
-            }
-            patchOps = parsed;
-        }
-        catch {
-            process.stderr.write(`Error: cannot read or parse --patch file: ${opts.patch}\n`);
-            await exitWithAnalytics(1);
-            return;
-        }
-        // Warn on unknown component names
-        const knownNames = new Set(result.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`);
-            }
-        }
-        result = applyPatch(result, patchOps);
-    }
-    const accepted = result.components.filter((c) => c.status === 'accepted');
-    const rejected = result.components.filter((c) => c.status === 'rejected');
-    // Surface what was excluded by --select-all --exclude-invalid so the
-    // non-interactive caller (CI, orchestrator, scripted pipeline) doesn't
-    // have to guess what failed validation. The warning is printed BEFORE
-    // saveReviewState so the message lands ahead of the bare counts.
-    if (selectAll && opts.excludeInvalid) {
-        const autoRejected = rejected
-            .filter((c) => shouldExcludeDueToValidation(c.originalProposal))
-            .map((c) => ({ name: c.name, validationIssues: c.originalProposal.validationIssues }));
-        process.stderr.write(formatExclusionWarning(autoRejected));
-    }
-    // Persist decisions to session state so pipeline orchestrator can read them
-    await saveReviewState(paths.statePath, result);
-    // Sync edited proposals back to the DB so generation uses the user's edits.
-    //
-    // Only --patch can mutate editedProposal — the other non-interactive flags
-    // (--select-all / --select / --deselect / --reject / --exclude-invalid)
-    // change status only. Calling storeRawComponents in the no-edit case is
-    // not just wasteful: it's destructive. storeRawComponents starts with
-    // `DELETE FROM raw_components WHERE session_id = ?` and re-inserts only
-    // the components passed in — so on a --select-all run, every rejected
-    // component (including its raw_slots / raw_props children) is physically
-    // removed. A second invocation of the same command would then see a
-    // smaller snapshot, lose the rejected component(s), and report different
-    // counts.
-    if (opts.patch && accepted.length > 0) {
-        const db = openPipelineDb();
-        try {
-            storeRawComponents(db, sessionId, accepted.map((c) => c.editedProposal));
-        }
-        finally {
-            db.close();
-        }
-    }
-    enrichCommandResult({ accepted_component_count: accepted.length });
-    process.stderr.write(`Accepted: ${accepted.length}  Rejected: ${rejected.length}\n`);
-}
-/**
- * Load components from the pipeline DB and re-run extraction validation.
- *
- * `validationIssues` is intentionally not persisted (the validator is pure
- * and cheap to re-run), so any cold-start of `analyze select` from a prior
- * `analyze extract` session needs to recompute it before building the
- * review snapshot — otherwise the TUI sees no validation errors at all.
- */
-export async function loadAndValidateForReview(sessionId, projectRoot) {
-    const db = openPipelineDb();
-    let rawComponents;
-    try {
-        rawComponents = loadRawComponents(db, sessionId);
-    }
-    finally {
-        db.close();
-    }
-    const validatedComponents = validateExtractedComponents(rawComponents);
-    return loadReviewInput(validatedComponents, { reviewRoot: projectRoot });
-}
-/**
- * Synthesize SERVER_VALIDATION_FAILED issues onto the review state file's
- * matching components. Used by the wizard's 422 recovery path: after a
- * preview-API validation error, this runs before re-launching the
- * analyze-select TUI so the Sidebar's existing red-warning rendering
- * pins the offenders to the top.
- *
- * Idempotent on identical input is NOT a contract: each call appends.
- * The wizard's 422 path is a one-shot per preview attempt, so duplicate
- * issues only matter if a caller invokes this twice without the user
- * round-tripping through the TUI in between.
- */
-export async function patchReviewStateWithValidationErrors(sessionId, errors, opts = {}) {
-    const artifactsRoot = opts.artifactsRoot ?? getRefineArtifactsRoot();
-    const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-    let snapshot;
-    try {
-        await access(paths.statePath);
-        snapshot = JSON.parse(await readFile(paths.statePath, 'utf8'));
-    }
-    catch {
-        snapshot = await loadAndValidateForReview(sessionId, undefined);
-        snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
-    }
-    const errorsByName = new Map();
-    for (const err of errors) {
-        const list = errorsByName.get(err.componentName) ?? [];
-        list.push(err);
-        errorsByName.set(err.componentName, list);
-    }
-    const patchedNames = [];
-    const knownNames = new Set(snapshot.components.map((c) => c.name));
-    const components = snapshot.components.map((c) => {
-        const matched = errorsByName.get(c.name);
-        if (!matched || matched.length === 0)
-            return c;
-        patchedNames.push(c.name);
-        const newIssues = matched.map((err) => ({
-            severity: 'error',
-            code: 'SERVER_VALIDATION_FAILED',
-            message: err.message,
-        }));
-        const existing = c.originalProposal.validationIssues ?? [];
-        return {
-            ...c,
-            originalProposal: {
-                ...c.originalProposal,
-                validationIssues: [...existing, ...newIssues],
-            },
-        };
-    });
-    const missingNames = [...errorsByName.keys()].filter((n) => !knownNames.has(n));
-    await saveReviewState(paths.statePath, { ...snapshot, components });
-    return { patchedNames, missingNames };
-}
-/**
- * Exclude components whose names appear in `names` from the next preview/push.
- * Used by the wizard's "skip and retry" path after a 422.
- *
- * Two stores are updated:
- *   - Pipeline DB (`raw_components.status` → `'generate-rejected'`) so that
- *     `loadCDFComponents()` excludes them from the next manifest. This is the
- *     load-bearing change — preview reads from the DB, not the JSON file.
- *   - Review state JSON (`status` → `'rejected'`) so that if the user re-enters
- *     the analyze-select TUI later, the rejected status is reflected.
- *
- * `'generate-rejected'` matches the existing convention for "component was
- * generated successfully but later excluded" (see GenerateReviewStep) — the
- * component generated fine locally but failed server-side validation.
- */
-export async function rejectComponentsByName(sessionId, names, opts = {}) {
-    if (names.length === 0)
-        return;
-    const db = openPipelineDb();
-    try {
-        const placeholders = names.map(() => '?').join(',');
-        db.prepare(`UPDATE raw_components SET status = 'generate-rejected' WHERE session_id = ? AND name IN (${placeholders})`).run(sessionId, ...names);
-    }
-    finally {
-        db.close();
-    }
-    const artifactsRoot = opts.artifactsRoot ?? getRefineArtifactsRoot();
-    const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-    const nameSet = new Set(names);
-    let snapshot;
-    try {
-        snapshot = JSON.parse(await readFile(paths.statePath, 'utf8'));
-    }
-    catch {
-        return;
-    }
-    const components = snapshot.components.map((c) => (nameSet.has(c.name) ? { ...c, status: 'rejected' } : c));
-    await saveReviewState(paths.statePath, { ...snapshot, components });
-}
-async 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');
-            return await exitWithAnalytics(1);
-        }
-        return row.id;
-    }
-    finally {
-        db.close();
-    }
-}
-export function registerAnalyzeEditCommand(program) {
-    program
-        .command('select')
-        .alias('edit')
-        .description('Select components for generation and optionally patch their definitions')
-        .option('--session <id>', 'Session ID from analyze extract (defaults to most recent)')
-        .option('--project-root <path>', 'Project root for resolving component source files')
-        .option('--select-all', 'Select all components without launching the TUI')
-        .option('--select <pattern>', 'Select components whose name contains pattern (repeatable)', collect, [])
-        .option('--deselect <pattern>', 'Deselect components whose name contains pattern (repeatable)', collect, [])
-        .option('--accept-all', 'Alias for --select-all', false)
-        .option('--reject <pattern>', 'Alias for --deselect <pattern> (repeatable)', collect, [])
-        .option('--patch <path>', 'Path to a JSON patch file for structured component overrides')
-        .option('--exclude-invalid', 'With --select-all: auto-reject components with validation errors instead of failing loud (opt-in bypass for the gate)')
-        .option('--exclude-components <names>', 'Comma-separated component names to force-reject, regardless of other selection flags')
-        .action(async ({ session: sessionFlag, projectRoot, acceptAll, selectAll, reject, deselect, select, patch, excludeInvalid, excludeComponents, }) => {
-        const sessionId = await resolveSessionId(sessionFlag);
-        await bindAnalyticsSessionId(sessionId);
-        const db = openPipelineDb();
-        let rawComponentCount = 0;
-        try {
-            rawComponentCount = loadRawComponents(db, sessionId).length;
-        }
-        finally {
-            db.close();
-        }
-        if (rawComponentCount === 0) {
-            process.stderr.write(`Error: session '${sessionId}' has no raw components. Run analyze extract first.\n`);
-            await exitWithAnalytics(1);
-            return;
-        }
-        const artifactsRoot = getRefineArtifactsRoot();
-        const nonInteractive = acceptAll ||
-            selectAll ||
-            (reject ?? []).length > 0 ||
-            (deselect ?? []).length > 0 ||
-            (select ?? []).length > 0 ||
-            !!patch ||
-            !!excludeComponents;
-        let paths;
-        let snapshot;
-        try {
-            snapshot = await loadAndValidateForReview(sessionId, projectRoot);
-            paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-            if (!nonInteractive) {
-                snapshot = await ensureRefineSession(sessionId, artifactsRoot, snapshot);
-            }
-            else {
-                await ensureRefineSession(sessionId, artifactsRoot, snapshot);
-            }
-        }
-        catch (error) {
-            process.stderr.write(`Error: unable to initialize refine session.\n${error instanceof Error ? error.message : String(error)}\n`);
-            await exitWithAnalytics(1);
-            return;
-        }
-        // Non-interactive path
-        if (nonInteractive) {
-            const stepDb = openPipelineDb();
-            const stepId = createStep(stepDb, sessionId, 'analyze select', {
-                sessionId,
-            });
-            try {
-                await runNonInteractive(snapshot, {
-                    session: sessionFlag,
-                    projectRoot,
-                    acceptAll,
-                    selectAll,
-                    reject,
-                    deselect,
-                    select,
-                    patch,
-                    excludeInvalid,
-                    excludeComponents,
-                }, paths, sessionId);
-                updateStep(stepDb, stepId, 'complete', { sessionId });
-            }
-            catch (err) {
-                updateStep(stepDb, stepId, 'failed', {}, err instanceof Error ? err.message : String(err));
-                stepDb.close();
-                throw err;
-            }
-            stepDb.close();
-            return;
-        }
-        // Test mode: print launch contract and return without launching TUI
-        if (process.env.EDS_REVIEW_TEST_MODE === '1') {
-            process.stdout.write(`session=${sessionId}\n` +
-                `session_dir=${paths.sessionDir}\n` +
-                `events.jsonl=${paths.eventsPath}\n` +
-                `current-review-state.json=${paths.statePath}\n`);
-            return;
-        }
-        requireInteractiveTerminal({
-            alternative: 'pass `--accept-all`, `--select-all`, `--reject`, `--deselect`, `--select`, or `--patch`',
-        });
-        if (process.stdout.columns !== undefined && process.stdout.columns < 60) {
-            process.stderr.write(`Error: terminal too narrow (${process.stdout.columns} cols). Resize to 60+ columns.\n`);
-            await exitWithAnalytics(1);
-        }
-        const { waitUntilExit } = render(createElement(App, {
-            sessionId,
-            artifactsRoot,
-            reviewRoot: projectRoot,
-        }));
-        await waitUntilExit();
-    });
-}
-function collect(val, prev) {
-    return [...prev, val];
-}

package/dist/src/analyze/select/index.js

@@ -1,5 +0,0 @@
-export { registerAnalyzeEditCommand } from './command.js';
-export { loadReviewInput } from './parser.js';
-export { appendReviewEvent, ensureRefineSession, getRefineArtifactsRoot, getRefineSessionPaths, saveReviewState, } from './persistence.js';
-export { formatFinalizeContract } from './stdout.js';
-export { createReviewSessionSummary } from './types.js';

package/dist/src/analyze/select/parser.js

@@ -1,53 +0,0 @@
-import { createHash } from 'node:crypto';
-import { access } from 'node:fs/promises';
-import { isAbsolute, relative, resolve } from 'node:path';
-function createComponentId(name, resolvedSourcePath) {
-    const sourceHash = createHash('sha256').update(`${name}:${resolvedSourcePath}`).digest('hex').slice(0, 12);
-    return `${name}-${sourceHash}`;
-}
-async function resolveComponentSourcePath(source, reviewRoot) {
-    // Absolute paths stored in the DB are used directly — no reviewRoot boundary check needed.
-    if (isAbsolute(source)) {
-        try {
-            await access(source);
-            return source;
-        }
-        catch {
-            throw new Error(`Unable to access component source at ${source}`);
-        }
-    }
-    const candidate = resolve(reviewRoot, source);
-    const relativeToRoot = relative(reviewRoot, candidate);
-    if (relativeToRoot.startsWith('..') || relativeToRoot === '..' || isAbsolute(relativeToRoot)) {
-        throw new Error(`Resolved component source is outside the review root: ${source}. Pass --project-root <path> to set the correct base.`);
-    }
-    try {
-        await access(candidate);
-        return candidate;
-    }
-    catch {
-        throw new Error(`Unable to access component source at ${candidate}`);
-    }
-}
-export async function loadReviewInput(components, options = {}) {
-    const reviewRoot = resolve(options.reviewRoot ?? process.cwd());
-    const records = await Promise.all(components.map(async (component) => {
-        let resolvedSourcePath;
-        try {
-            resolvedSourcePath = await resolveComponentSourcePath(component.source, reviewRoot);
-        }
-        catch (error) {
-            throw new Error(`Unable to access component source for ${component.name}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return {
-            id: createComponentId(component.name, resolvedSourcePath),
-            name: component.name,
-            resolvedSourcePath,
-            sourceCode: null,
-            originalProposal: component,
-            editedProposal: structuredClone(component),
-            status: 'needs-review',
-        };
-    }));
-    return { components: records };
-}

package/dist/src/analyze/select/persistence.js

@@ -1,80 +0,0 @@
-import { access, appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { resolve } from 'node:path';
-import { loadRawComponents } from '../../session/db.js';
-export function getRefineArtifactsRoot() {
-    if (process.env.EDS_REVIEW_ARTIFACTS_DIR) {
-        return resolve(process.env.EDS_REVIEW_ARTIFACTS_DIR);
-    }
-    return resolve(homedir(), '.contentful', 'experience-design-system-cli', 'reviews');
-}
-export async function getRefineSessionPaths(sessionId, artifactsRoot) {
-    const sessionDir = resolve(artifactsRoot, sessionId);
-    return {
-        sessionDir,
-        eventsPath: resolve(sessionDir, 'events.jsonl'),
-        statePath: resolve(sessionDir, 'current-review-state.json'),
-    };
-}
-export async function saveReviewState(statePath, session) {
-    await writeFile(statePath, JSON.stringify(session, null, 2), 'utf8');
-}
-export async function appendReviewEvent(eventsPath, event) {
-    const record = {
-        type: event.type,
-        timestamp: new Date().toISOString(),
-        payload: event.payload,
-    };
-    await appendFile(eventsPath, JSON.stringify(record) + '\n', 'utf8');
-}
-export async function ensureRefineSession(sessionId, artifactsRoot, initialSnapshot) {
-    const paths = await getRefineSessionPaths(sessionId, artifactsRoot);
-    await mkdir(paths.sessionDir, { recursive: true });
-    try {
-        await access(paths.statePath);
-        const savedState = await readFile(paths.statePath, 'utf8');
-        return JSON.parse(savedState);
-    }
-    catch {
-        await writeFile(paths.statePath, JSON.stringify(initialSnapshot, null, 2), 'utf8');
-        await writeFile(paths.eventsPath, '', 'utf8');
-        return initialSnapshot;
-    }
-}
-/**
- * Persist scope-gate decisions to `current-review-state.json` so downstream
- * consumers (notably `loadAcceptedNames` in `generate components`) can filter
- * out rejected components. The wizard's scope-gate doesn't drive the rich
- * `analyze select` TUI, so fields that file consumes (resolvedSourcePath,
- * sourceCode) are populated with safe placeholders. Only `name` and `status`
- * matter for `loadAcceptedNames`.
- */
-export async function writeScopeDecisionsSnapshot(db, sessionId, decisions) {
-    const acceptedSet = new Set(decisions.accepted);
-    const rawComponents = loadRawComponents(db, sessionId);
-    const records = rawComponents.map((c) => {
-        const status = acceptedSet.has(c.name) ? 'accepted' : 'rejected';
-        const proposal = {
-            name: c.name,
-            source: c.source,
-            framework: c.framework,
-            props: c.props,
-            slots: c.slots,
-            ...(c.extractionConfidence !== undefined ? { extractionConfidence: c.extractionConfidence } : {}),
-            ...(c.reviewReasons !== undefined ? { reviewReasons: c.reviewReasons } : {}),
-            ...(c.needsReview !== undefined ? { needsReview: c.needsReview } : {}),
-        };
-        return {
-            id: c.component_id,
-            name: c.name,
-            resolvedSourcePath: '',
-            sourceCode: null,
-            originalProposal: proposal,
-            editedProposal: proposal,
-            status,
-        };
-    });
-    const paths = await getRefineSessionPaths(sessionId, getRefineArtifactsRoot());
-    await mkdir(paths.sessionDir, { recursive: true });
-    await saveReviewState(paths.statePath, { components: records });
-}

package/dist/src/analyze/select/preview-annotations.js

@@ -1,62 +0,0 @@
-/**
- * Pure mapper from a `ServerPreviewResponse` to a per-component-name
- * `PreviewAnnotation` map. Consumed by the wizard's final-review sidebar
- * (and any other surface that wants to render diff badges next to a
- * component row).
- *
- * The `new` bucket of `ServerPreviewResponse.components` is `CDFComponentEntry[]`
- * — those entries do NOT carry a `name` field on the wire (the name is the
- * KEY in the parent manifest). So instead of trying to read names off entries,
- * we derive the "new" set as:
- *
- *   new = localNames \ (unchangedNames ∪ changedNames ∪ removedNames)
- *
- * Callers must pass the local manifest's component keys as `localNames` so
- * we can perform the set difference. Removed components from the server that
- * aren't in the local manifest are still annotated as `'removed'` (so the
- * detail panel can list them).
- *
- * Precedence: `breaking` > `changed` > `removed` > `new`.
- *
- * Unchanged entries are omitted from the map — callers should treat
- * `map.get(name) === undefined` as "no annotation".
- */
-export function applyPreviewAnnotations(preview, localNames) {
-    const out = new Map();
-    const unchanged = new Set(preview.components.unchanged);
-    // Annotate changed first; collect their names so we can exclude from "new".
-    const changedNames = new Set();
-    for (const item of preview.components.changed) {
-        const name = item.current?.name;
-        if (typeof name !== 'string')
-            continue;
-        changedNames.add(name);
-        if (item.changeClassification?.classification === 'breaking') {
-            out.set(name, 'breaking');
-        }
-        else {
-            out.set(name, 'changed');
-        }
-    }
-    // Annotate removed.
-    const removedNames = new Set();
-    for (const entity of preview.components.removed) {
-        if (entity.name) {
-            removedNames.add(entity.name);
-            out.set(entity.name, 'removed');
-        }
-    }
-    // Derive `new` = localNames \ (unchanged ∪ changed ∪ removed).
-    for (const name of localNames) {
-        if (unchanged.has(name))
-            continue;
-        if (changedNames.has(name))
-            continue;
-        if (removedNames.has(name))
-            continue;
-        if (out.has(name))
-            continue;
-        out.set(name, 'new');
-    }
-    return out;
-}