@contentful/experience-design-system-cli 2.14.2 → 2.15.0

package/dist/src/import/tui/ai-flag.d.ts

@@ -0,0 +1,5 @@
+export type AiFlaggable = {
+    aiDecision?: 'accepted' | 'rejected' | 'failed' | null;
+};
+export declare function isAiFlagged(row: AiFlaggable): boolean;
+export declare function isDefaultIncluded(row: AiFlaggable): boolean;

package/dist/src/import/tui/ai-flag.js

@@ -0,0 +1,6 @@
+export function isAiFlagged(row) {
+    return row.aiDecision === 'rejected' || row.aiDecision === 'failed';
+}
+export function isDefaultIncluded(row) {
+    return !isAiFlagged(row);
+}

package/dist/src/import/tui/autocomplete.d.ts

@@ -0,0 +1,5 @@
+export interface AutocompleteResult {
+    completion: string;
+    candidates: string[];
+}
+export declare function computeAutocomplete(query: string, names: string[]): AutocompleteResult;

package/dist/src/import/tui/autocomplete.js

@@ -0,0 +1,32 @@
+function longestCommonPrefix(names) {
+    if (names.length === 0)
+        return '';
+    let prefixLen = names[0].length;
+    for (let i = 1; i < names.length; i++) {
+        const other = names[i];
+        let j = 0;
+        while (j < prefixLen && j < other.length && names[0][j].toLowerCase() === other[j].toLowerCase()) {
+            j++;
+        }
+        prefixLen = j;
+        if (prefixLen === 0)
+            break;
+    }
+    return names[0].slice(0, prefixLen);
+}
+export function computeAutocomplete(query, names) {
+    const q = query.toLowerCase();
+    const candidates = names.filter((n) => n.toLowerCase().startsWith(q));
+    if (candidates.length === 0) {
+        return { completion: query, candidates: [] };
+    }
+    if (candidates.length === 1) {
+        return { completion: candidates[0], candidates: [] };
+    }
+    const lcp = longestCommonPrefix(candidates);
+    // Guard: never return a completion shorter than the current query (e.g. if
+    // casing differences shrank the LCP below the typed length, keep the query).
+    const completion = lcp.length >= query.length ? lcp : query;
+    const sorted = [...candidates].sort();
+    return { completion, candidates: sorted };
+}

package/dist/src/import/tui/components/AutoFilterBanner.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export type AutoFilterStatus = 'idle' | 'running' | 'complete' | 'cancelled' | 'failed';
+export declare function AutoFilterBanner(props: {
+    status?: AutoFilterStatus;
+    progress?: {
+        done: number;
+        total: number;
+    } | null;
+    error?: string | null;
+}): React.ReactElement | null;

package/dist/src/import/tui/components/AutoFilterBanner.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { PALETTE } from '../../../analyze/select/tui/theme.js';
+export function AutoFilterBanner(props) {
+    const { status, progress, error } = props;
+    const showRunningHeader = status === 'running' && progress !== null && progress !== undefined && progress.total > 0;
+    const showCancelledBanner = status === 'cancelled';
+    const showFailedBanner = status === 'failed';
+    if (showRunningHeader) {
+        return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: _jsxs(Text, { color: PALETTE.info, children: ["[AI filtering (", progress.done, "/", progress.total, ")\u2026] ", _jsx(Text, { dimColor: true, children: "[q] cancels" })] }) }));
+    }
+    if (showCancelledBanner) {
+        return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: PALETTE.warning, children: ["AI auto-filter cancelled", progress ? ` at ${progress.done}/${progress.total}` : '', ". Review remaining manually."] }) }));
+    }
+    if (showFailedBanner) {
+        return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: PALETTE.warning, children: ["AI auto-filter failed: ", error ?? 'unknown error', ". Continuing without AI suggestions."] }) }));
+    }
+    return null;
+}

package/dist/src/import/tui/components/CounterStrip.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export type CounterStripCounters = {
+    accepted: number;
+    rejected: number;
+    undecided: number;
+    groups: number;
+    total: number;
+};
+export declare function CounterStrip(props: {
+    counters: CounterStripCounters;
+    totalWidth: number;
+}): React.ReactElement;

package/dist/src/import/tui/components/CounterStrip.js

@@ -0,0 +1,12 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function CounterStrip(props) {
+    const { counters, totalWidth } = props;
+    const condensed = totalWidth < 60;
+    const labelAcc = condensed ? 'Acc' : 'Accepted';
+    const labelGrp = condensed ? 'Grp' : 'Groups';
+    const labelRej = condensed ? 'Rej' : 'Rejected';
+    const labelUnd = condensed ? 'Und' : 'Undecided';
+    const sep = condensed ? ' | ' : '    ';
+    return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsxs(Text, { dimColor: true, children: [labelAcc, " "] }), _jsx(Text, { bold: true, children: counters.accepted }), _jsx(Text, { dimColor: true, children: `/${counters.total}` }), _jsx(Text, { dimColor: true, children: sep }), _jsxs(Text, { dimColor: true, children: [labelGrp, " "] }), _jsx(Text, { bold: true, children: counters.groups }), _jsx(Text, { dimColor: true, children: sep }), _jsxs(Text, { dimColor: true, children: [labelRej, " "] }), _jsx(Text, { bold: true, children: counters.rejected }), _jsx(Text, { dimColor: true, children: sep }), _jsxs(Text, { dimColor: true, children: [labelUnd, " "] }), _jsx(Text, { bold: true, children: counters.undecided })] }) }));
+}

package/dist/src/import/tui/components/LegendEntry.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function legendEntry(keyBracket: string, label: string, active?: boolean): React.ReactElement;

package/dist/src/import/tui/components/LegendEntry.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { PALETTE } from '../../../analyze/select/tui/theme.js';
+export function legendEntry(keyBracket, label, active = false) {
+    return (_jsxs(Text, { children: [_jsx(Text, { color: active ? PALETTE.warning : PALETTE.info, inverse: active, children: keyBracket }), _jsx(Text, { color: active ? PALETTE.warning : undefined, inverse: active, dimColor: !active, children: ' ' + label })] }, keyBracket + label));
+}

package/dist/src/import/tui/cycle-panel-scroll.d.ts

@@ -0,0 +1,8 @@
+export declare const CYCLE_PANEL_PREAMBLE_LINES = 4;
+export interface CyclePanelLineCountable {
+    suggestedBreak?: unknown;
+}
+export declare function cycleLineCount(cycle: CyclePanelLineCountable): number;
+export declare function cycleLineOffsets(cycles: readonly CyclePanelLineCountable[], preamble?: number): number[];
+export declare function totalCyclePanelLines(cycles: readonly CyclePanelLineCountable[], preamble?: number): number;
+export declare function followCycleScroll(currentScroll: number, cursorIdx: number, cycles: readonly CyclePanelLineCountable[], panelHeight: number, preamble?: number): number;

package/dist/src/import/tui/cycle-panel-scroll.js

@@ -0,0 +1,33 @@
+export const CYCLE_PANEL_PREAMBLE_LINES = 4;
+export function cycleLineCount(cycle) {
+    return 3 + (cycle.suggestedBreak ? 1 : 0);
+}
+export function cycleLineOffsets(cycles, preamble = CYCLE_PANEL_PREAMBLE_LINES) {
+    const offsets = [];
+    let acc = preamble;
+    for (const cycle of cycles) {
+        offsets.push(acc);
+        acc += cycleLineCount(cycle);
+    }
+    return offsets;
+}
+export function totalCyclePanelLines(cycles, preamble = CYCLE_PANEL_PREAMBLE_LINES) {
+    let acc = preamble;
+    for (const cycle of cycles)
+        acc += cycleLineCount(cycle);
+    return acc;
+}
+export function followCycleScroll(currentScroll, cursorIdx, cycles, panelHeight, preamble = CYCLE_PANEL_PREAMBLE_LINES) {
+    if (cursorIdx < 0 || cursorIdx >= cycles.length)
+        return currentScroll;
+    const offsets = cycleLineOffsets(cycles, preamble);
+    const blockStart = offsets[cursorIdx];
+    const lastContentLine = blockStart + cycleLineCount(cycles[cursorIdx]) - 2;
+    let next = currentScroll;
+    if (blockStart < currentScroll)
+        next = blockStart;
+    else if (lastContentLine >= currentScroll + panelHeight)
+        next = lastContentLine - panelHeight + 1;
+    const maxOffset = Math.max(0, totalCyclePanelLines(cycles, preamble) - panelHeight);
+    return Math.max(0, Math.min(next, maxOffset));
+}

package/dist/src/import/tui/final-review-host.d.ts

@@ -1,8 +1,10 @@
 import React from 'react';
+import type { CompositionMode } from '../../lib/composition-mode.js';
 export type FinalReviewHostProps = {
     extractSessionId: string | null;
     generatedCount: number;
     autoAccept: boolean;
+    compositionMode?: CompositionMode;
     onFinalize: (accepted: number, rejected: number, unresolved: number) => void;
     onQuit: () => void;
     livePreview?: boolean;
@@ -11,12 +13,6 @@ export type FinalReviewHostProps = {
     cmaToken?: string;
     host?: string;
     tokensPath?: string;
-    /**
-     * INTEG-4411 refined: message displayed as an inline banner when the wizard
-     * routes back here after the preview API returned an empty diff (pure
-     * no-op push). Cleared on the next `a` / `A` keystroke inside
-     * GenerateReviewStep.
-     */
     initialFinalizeError?: string | null;
 };
-export declare function FinalReviewHost({ extractSessionId, generatedCount, autoAccept, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }: FinalReviewHostProps): React.ReactElement;
+export declare function FinalReviewHost({ extractSessionId, generatedCount, autoAccept, compositionMode, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }: FinalReviewHostProps): React.ReactElement;

package/dist/src/import/tui/final-review-host.js

@@ -1,20 +1,25 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
+import { PALETTE } from '../../analyze/select/tui/theme.js';
 import React from 'react';
 import { GenerateReviewStep } from './steps/GenerateReviewStep.js';
-export function FinalReviewHost({ extractSessionId, generatedCount, autoAccept, onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }) {
+import { AtomicGenerateReviewStep } from './steps/AtomicGenerateReviewStep.js';
+export function FinalReviewHost({ extractSessionId, generatedCount, autoAccept, compositionMode = 'atomic', onFinalize, onQuit, livePreview, spaceId, environmentId, cmaToken, host, tokensPath, initialFinalizeError, }) {
     if (!extractSessionId) {
-        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: "red", children: "Error: no session ID \u2014 cannot load generated definitions." }) }));
+        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: PALETTE.error, children: "Error: no session ID \u2014 cannot load generated definitions." }) }));
     }
     if (autoAccept) {
         return _jsx(FinalReviewAutoAccept, { generatedCount: generatedCount, onFinalize: onFinalize });
     }
-    return (_jsx(GenerateReviewStep, { extractSessionId: extractSessionId, onFinalize: onFinalize, onQuit: onQuit, livePreview: livePreview, spaceId: spaceId, environmentId: environmentId, cmaToken: cmaToken, host: host, tokensPath: tokensPath, initialFinalizeError: initialFinalizeError }));
+    // Atomic mode (spec T9): render the pre-composite flat review step. It never
+    // passes projectSlotGraph to FieldEditor and never walks closures/cycles, so
+    // slot-composition editing and every hierarchy affordance stay absent.
+    const StepComponent = compositionMode === 'atomic' ? AtomicGenerateReviewStep : GenerateReviewStep;
+    return (_jsx(StepComponent, { extractSessionId: extractSessionId, onFinalize: onFinalize, onQuit: onQuit, livePreview: livePreview, spaceId: spaceId, environmentId: environmentId, cmaToken: cmaToken, host: host, tokensPath: tokensPath, initialFinalizeError: initialFinalizeError }));
 }
 function FinalReviewAutoAccept({ generatedCount, onFinalize, }) {
     React.useEffect(() => {
         onFinalize(generatedCount, 0, 0);
-        // fire once on mount; deps intentionally empty so a re-render with new generatedCount doesn't double-finalize
     }, []);
     return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsxs(Text, { dimColor: true, children: ["Auto-accepting ", generatedCount, " generated components..."] }) }));
 }

package/dist/src/import/tui/group-collapse.d.ts

@@ -0,0 +1,2 @@
+import type { Closure } from '../../analyze/composite-closure.js';
+export declare function resolveGroupRoot(key: string, closures: Map<string, Closure>, cycleSet: Set<string>): string | undefined;

package/dist/src/import/tui/group-collapse.js

@@ -0,0 +1,11 @@
+export function resolveGroupRoot(key, closures, cycleSet) {
+    if (cycleSet.has(key))
+        return key;
+    if (closures.has(key))
+        return key;
+    for (const [root, closure] of closures.entries()) {
+        if (closure.nodes.some((n) => n.name === key))
+            return root;
+    }
+    return undefined;
+}

package/dist/src/import/tui/history.d.ts

@@ -0,0 +1,22 @@
+import type { CDFComponentEntry } from '@contentful/experience-design-system-types';
+import type { ReviewComponentStatus } from '../../analyze/select/types.js';
+export interface HistorySnapshot {
+    components: CdfReviewEntrySnapshot[];
+    autoRejected: string[];
+    undoSnapshot: Map<string, ReviewComponentStatus> | null;
+}
+export interface CdfReviewEntrySnapshot {
+    key: string;
+    entry: CDFComponentEntry;
+    status: ReviewComponentStatus;
+}
+export interface HistoryStack {
+    push(snapshot: HistorySnapshot, label: string): void;
+    undo(): HistorySnapshot | null;
+    redo(): HistorySnapshot | null;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    reset(seed: HistorySnapshot): void;
+    size(): number;
+}
+export declare function createHistoryStack(seed: HistorySnapshot, maxDepth?: number): HistoryStack;

package/dist/src/import/tui/history.js

@@ -0,0 +1,53 @@
+const DEFAULT_MAX_DEPTH = 50;
+function cloneSnapshot(snap) {
+    return {
+        components: snap.components.map((c) => ({
+            key: c.key,
+            entry: JSON.parse(JSON.stringify(c.entry)),
+            status: c.status,
+        })),
+        autoRejected: [...snap.autoRejected],
+        undoSnapshot: snap.undoSnapshot === null ? null : new Map(Array.from(snap.undoSnapshot.entries())),
+    };
+}
+export function createHistoryStack(seed, maxDepth = DEFAULT_MAX_DEPTH) {
+    const cap = Math.max(1, maxDepth);
+    let stack = [cloneSnapshot(seed)];
+    let cursor = 0;
+    function push(snapshot, _label) {
+        if (cursor < stack.length - 1) {
+            stack = stack.slice(0, cursor + 1);
+        }
+        stack.push(cloneSnapshot(snapshot));
+        while (stack.length > cap) {
+            stack.shift();
+        }
+        cursor = stack.length - 1;
+    }
+    function undo() {
+        if (cursor <= 0)
+            return null;
+        cursor -= 1;
+        return cloneSnapshot(stack[cursor]);
+    }
+    function redo() {
+        if (cursor >= stack.length - 1)
+            return null;
+        cursor += 1;
+        return cloneSnapshot(stack[cursor]);
+    }
+    function canUndo() {
+        return cursor > 0;
+    }
+    function canRedo() {
+        return cursor < stack.length - 1;
+    }
+    function reset(nextSeed) {
+        stack = [cloneSnapshot(nextSeed)];
+        cursor = 0;
+    }
+    function size() {
+        return stack.length;
+    }
+    return { push, undo, redo, canUndo, canRedo, reset, size };
+}

package/dist/src/import/tui/hooks/useLineage.d.ts

@@ -0,0 +1,32 @@
+import { type ComponentGraphNode } from '../../../analyze/composite-closure.js';
+export type LineageEntry = {
+    kind: 'section';
+    label: string;
+} | {
+    kind: 'ancestor';
+    label: string;
+    jumpTarget: string;
+} | {
+    kind: 'descendant';
+    label: string;
+    jumpTarget: string;
+} | {
+    kind: 'empty';
+    label: string;
+};
+export interface LineageJumpable {
+    /** Original index into the `entries` array — callers highlight the source row. */
+    i: number;
+    entry: LineageEntry;
+}
+export interface UseLineageResult {
+    entries: LineageEntry[];
+    /**
+     * Jumpable entries — those the operator can Tab/Enter to. Excludes
+     * `section` / `empty` rows. Order matches `entries` minus the non-jumpable
+     * rows; each item carries the original `entries` index so callers can
+     * highlight the source row.
+     */
+    jumpables: LineageJumpable[];
+}
+export declare function useLineage(focusedKey: string | null, graph: ComponentGraphNode[]): UseLineageResult;

package/dist/src/import/tui/hooks/useLineage.js

@@ -0,0 +1,50 @@
+import { useMemo } from 'react';
+import { computeAllClosures } from '../../../analyze/composite-closure.js';
+import { buildAncestorTree, renderAncestorTree } from '../../../analyze/lineage.js';
+export function useLineage(focusedKey, graph) {
+    const graphKey = useMemo(() => JSON.stringify(graph), [graph]);
+    const stableGraph = useMemo(() => graph, [graphKey]);
+    const closures = useMemo(() => computeAllClosures(stableGraph), [stableGraph]);
+    const entries = useMemo(() => {
+        if (!focusedKey)
+            return [];
+        const name = focusedKey;
+        const tree = buildAncestorTree(name, stableGraph);
+        const closure = closures.get(name);
+        const out = [];
+        out.push({ kind: 'section', label: 'Ancestors:' });
+        if (tree.parents.length === 0) {
+            out.push({ kind: 'empty', label: '  (no ancestors)' });
+        }
+        else {
+            const lines = renderAncestorTree(tree);
+            for (const line of lines) {
+                out.push({
+                    kind: 'ancestor',
+                    label: '  ' + line.text,
+                    jumpTarget: line.jumpTarget ?? name,
+                });
+            }
+        }
+        out.push({ kind: 'section', label: 'Descendants:' });
+        if (!closure || closure.nodes.length <= 1) {
+            out.push({ kind: 'empty', label: '  (none)' });
+        }
+        else {
+            for (const node of closure.nodes) {
+                if (node.name === name)
+                    continue;
+                out.push({
+                    kind: 'descendant',
+                    label: '  ' + '  '.repeat(Math.max(0, node.depth - 1)) + node.name,
+                    jumpTarget: node.name,
+                });
+            }
+        }
+        return out;
+    }, [focusedKey, stableGraph, closures]);
+    const jumpables = useMemo(() => entries
+        .map((entry, i) => ({ entry, i }))
+        .filter(({ entry }) => entry.kind === 'ancestor' || entry.kind === 'descendant'), [entries]);
+    return { entries, jumpables };
+}

package/dist/src/import/tui/hooks/useOverlayPanel.d.ts

@@ -0,0 +1,13 @@
+export interface UseOverlayPanelOptions {
+    toggleKey: string;
+    onClose?: () => void;
+}
+export interface UseOverlayPanelResult {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    handleInput: (input: string, key: {
+        escape?: boolean;
+    }) => boolean;
+}
+export declare function useOverlayPanel(opts: UseOverlayPanelOptions): UseOverlayPanelResult;

package/dist/src/import/tui/hooks/useOverlayPanel.js

@@ -0,0 +1,27 @@
+import { useCallback, useState } from 'react';
+export function useOverlayPanel(opts) {
+    const { toggleKey, onClose } = opts;
+    const [isOpen, setIsOpen] = useState(false);
+    const open = useCallback(() => {
+        setIsOpen(true);
+    }, []);
+    const close = useCallback(() => {
+        setIsOpen((prev) => {
+            if (prev && onClose)
+                onClose();
+            return false;
+        });
+    }, [onClose]);
+    const handleInput = useCallback((input, key) => {
+        if (!isOpen)
+            return false;
+        if (input === toggleKey || key.escape === true) {
+            if (onClose)
+                onClose();
+            setIsOpen(false);
+            return true;
+        }
+        return false;
+    }, [isOpen, toggleKey, onClose]);
+    return { isOpen, open, close, handleInput };
+}

package/dist/src/import/tui/lineage-layout.d.ts

@@ -0,0 +1,75 @@
+/** Sidebar height (rows) — unchanged whether or not the panel is open. */
+export declare const VISIBLE_COUNT = 20;
+/** Panel window ceiling (matches LineagePanel's DEFAULT_MAX_ROWS from L2b). */
+export declare const MAX_PANEL_ROWS = 15;
+/** Floors — both surfaces stay usable even on a small terminal. */
+export declare const SIDEBAR_MIN = 4;
+export declare const MIN_PANEL_ROWS = 4;
+/**
+ * Fallback when `stdout.rows` is unavailable (piped output, tests). No TTY
+ * means Ink is not interactively repainting, so there is no flicker risk — we
+ * assume enough height for the FULL sidebar (BASE_CHROME_OVERHEAD + the full
+ * VISIBLE_COUNT) so the non-interactive render is complete and unclipped.
+ */
+export declare const FALLBACK_ROWS = 40;
+/**
+ * Vertical space consumed by everything ABOVE/BELOW the columns row. The panel
+ * shares the columns row, so the fit constraint while open is simply
+ * `FIXED_OVERHEAD + panelBoxHeight <= rows`.
+ */
+export declare const FIXED_OVERHEAD: number;
+export declare const PANEL_BOX_CHROME = 6;
+/**
+ * L2e — fixed vertical chrome around the sidebar in the BASE (no-panel) case,
+ * counting EVERYTHING that is not a variable sidebar entry row: the wizard
+ * header bar, the "✓ Extraction complete" + "Found N…" intro, the counter
+ * strip (with its blank separator), the cycle banner, the nothing-selected /
+ * AI-exclusion hint, the GroupedSidebar box borders + scroll indicator, the
+ * focused-detail block, and the wrapping legend region. Measured via the PTY
+ * harness against the react-ux-matrix fixture (cycles present = a tall case):
+ * the base frame was 39 lines with a 20-row sidebar after the legend row-gap
+ * compression, i.e. ≈19 lines of chrome. We use 20 for a one-line safety
+ * margin so the total frame stays strictly within `stdout.rows`.
+ */
+export declare const BASE_CHROME_OVERHEAD = 20;
+export interface LineageLayoutInput {
+    /** Terminal height in rows (`stdout.rows`, or the fallback). */
+    rows: number;
+    /** Whether the lineage panel is currently open. */
+    panelOpen: boolean;
+    /** Number of lineage entries — caps the panel window so it never over-allocates. */
+    entryCount?: number;
+}
+export interface LineageLayout {
+    /** Rows the sidebar should render (`visibleCount`). Constant across open/closed. */
+    sidebarVisible: number;
+    /** Rows the LineagePanel should window to (`maxRows`). */
+    panelMaxRows: number;
+}
+/**
+ * The sidebar height is constant (the panel replaces it in the same slot, so
+ * there is nothing to shrink). When the panel is open its entry window is sized
+ * to fit the sidebar's footprint AND the terminal — never taller than the
+ * sidebar was, so opening lineage cannot grow the frame past `rows`.
+ */
+export declare function computeLineageLayout({ rows, panelOpen, entryCount }: LineageLayoutInput): LineageLayout;
+export interface SidebarBudget {
+    /** Rows the GroupedSidebar should render (`visibleCount`). */
+    sidebarVisibleCount: number;
+    /** Rows the LineagePanel should window to (`maxRows`). */
+    panelMaxRows: number;
+}
+/**
+ * L2e — autoscale the BASE frame to the terminal height. Even with the lineage
+ * panel closed, a fixed 20-row sidebar plus the always-on chrome can exceed a
+ * small terminal's rows, so plain Ink (no alt-screen) full-repaints (`\x1b[2J`)
+ * on every cursor move = flicker. This sizes the sidebar's visible-row budget
+ * from `stdout.rows` minus `BASE_CHROME_OVERHEAD` so the whole frame fits at
+ * 24/30/40 rows, and unifies the panel-open sizing with `computeLineageLayout`
+ * so BOTH cases stay within the terminal.
+ *
+ * Floor: `BASE_CHROME_OVERHEAD + SIDEBAR_MIN`. Below it `SIDEBAR_MIN`
+ * (usability) intentionally wins over the fit — a terminal that small can't
+ * host the chrome regardless.
+ */
+export declare function computeSidebarBudget({ rows, panelOpen, entryCount }: LineageLayoutInput): SidebarBudget;

package/dist/src/import/tui/lineage-layout.js

@@ -0,0 +1,82 @@
+/** Sidebar height (rows) — unchanged whether or not the panel is open. */
+export const VISIBLE_COUNT = 20;
+/** Panel window ceiling (matches LineagePanel's DEFAULT_MAX_ROWS from L2b). */
+export const MAX_PANEL_ROWS = 15;
+/** Floors — both surfaces stay usable even on a small terminal. */
+export const SIDEBAR_MIN = 4;
+export const MIN_PANEL_ROWS = 4;
+/**
+ * Fallback when `stdout.rows` is unavailable (piped output, tests). No TTY
+ * means Ink is not interactively repainting, so there is no flicker risk — we
+ * assume enough height for the FULL sidebar (BASE_CHROME_OVERHEAD + the full
+ * VISIBLE_COUNT) so the non-interactive render is complete and unclipped.
+ */
+export const FALLBACK_ROWS = 40;
+const HEADER_ROWS = 2;
+const COUNTER_STRIP_ROWS = 2;
+const FOCUSED_DETAIL_ROWS = 2;
+const LEGEND_ROWS = 3;
+/**
+ * Vertical space consumed by everything ABOVE/BELOW the columns row. The panel
+ * shares the columns row, so the fit constraint while open is simply
+ * `FIXED_OVERHEAD + panelBoxHeight <= rows`.
+ */
+export const FIXED_OVERHEAD = HEADER_ROWS + COUNTER_STRIP_ROWS + FOCUSED_DETAIL_ROWS + LEGEND_ROWS;
+// Panel box rows that are NOT entry rows: top border + header + footer hint +
+// bottom border (+ up to two scroll indicators on large lineages).
+export const PANEL_BOX_CHROME = 6;
+/**
+ * L2e — fixed vertical chrome around the sidebar in the BASE (no-panel) case,
+ * counting EVERYTHING that is not a variable sidebar entry row: the wizard
+ * header bar, the "✓ Extraction complete" + "Found N…" intro, the counter
+ * strip (with its blank separator), the cycle banner, the nothing-selected /
+ * AI-exclusion hint, the GroupedSidebar box borders + scroll indicator, the
+ * focused-detail block, and the wrapping legend region. Measured via the PTY
+ * harness against the react-ux-matrix fixture (cycles present = a tall case):
+ * the base frame was 39 lines with a 20-row sidebar after the legend row-gap
+ * compression, i.e. ≈19 lines of chrome. We use 20 for a one-line safety
+ * margin so the total frame stays strictly within `stdout.rows`.
+ */
+export const BASE_CHROME_OVERHEAD = 20;
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+/**
+ * The sidebar height is constant (the panel replaces it in the same slot, so
+ * there is nothing to shrink). When the panel is open its entry window is sized
+ * to fit the sidebar's footprint AND the terminal — never taller than the
+ * sidebar was, so opening lineage cannot grow the frame past `rows`.
+ */
+export function computeLineageLayout({ rows, panelOpen, entryCount }) {
+    const sidebarVisible = VISIBLE_COUNT;
+    if (!panelOpen) {
+        return { sidebarVisible, panelMaxRows: MAX_PANEL_ROWS };
+    }
+    // Rows available for panel ENTRIES given the terminal and the panel's box
+    // chrome; also never taller than the sidebar footprint it replaces.
+    const terminalFit = rows - FIXED_OVERHEAD - PANEL_BOX_CHROME;
+    let panelBase = Math.min(VISIBLE_COUNT, terminalFit);
+    if (entryCount !== undefined && entryCount > 0) {
+        panelBase = Math.min(panelBase, entryCount);
+    }
+    const panelMaxRows = clamp(panelBase, MIN_PANEL_ROWS, MAX_PANEL_ROWS);
+    return { sidebarVisible, panelMaxRows };
+}
+/**
+ * L2e — autoscale the BASE frame to the terminal height. Even with the lineage
+ * panel closed, a fixed 20-row sidebar plus the always-on chrome can exceed a
+ * small terminal's rows, so plain Ink (no alt-screen) full-repaints (`\x1b[2J`)
+ * on every cursor move = flicker. This sizes the sidebar's visible-row budget
+ * from `stdout.rows` minus `BASE_CHROME_OVERHEAD` so the whole frame fits at
+ * 24/30/40 rows, and unifies the panel-open sizing with `computeLineageLayout`
+ * so BOTH cases stay within the terminal.
+ *
+ * Floor: `BASE_CHROME_OVERHEAD + SIDEBAR_MIN`. Below it `SIDEBAR_MIN`
+ * (usability) intentionally wins over the fit — a terminal that small can't
+ * host the chrome regardless.
+ */
+export function computeSidebarBudget({ rows, panelOpen, entryCount }) {
+    const sidebarVisibleCount = clamp(rows - BASE_CHROME_OVERHEAD, SIDEBAR_MIN, VISIBLE_COUNT);
+    const { panelMaxRows } = computeLineageLayout({ rows, panelOpen, entryCount });
+    return { sidebarVisibleCount, panelMaxRows };
+}

package/dist/src/import/tui/runLivePreview.d.ts

@@ -15,6 +15,17 @@ export type RunLivePreviewOptions = {
     host: string;
     generation: number;
     timeoutMs?: number;
+    /** When true and no components are accepted, preview an empty-but-present
+     *  components manifest so the server returns the full delete-all diff
+     *  (every existing component as `removed`) instead of rejecting an empty
+     *  manifest. Lets the final-review UI show what a push would delete. */
+    deleteAllComponents?: boolean;
+    /** Restrict the preview to these component keys (the operator's accepted
+     *  set). Undefined = all generated components in the session. An empty set
+     *  narrows to zero components — pair with `deleteAllComponents` to preview a
+     *  full delete. Lets the Finalize dialog show exactly what the accepted push
+     *  would delete, independent of the session's on-disk generated rows. */
+    acceptedKeys?: ReadonlySet<string>;
 };
 /**
  * Pure async helper used by `useLivePreview` to re-fire `previewImport` after a

package/dist/src/import/tui/runLivePreview.js

@@ -42,11 +42,17 @@ export async function runLivePreview(opts) {
             db.close();
         }
     }
+    // Narrow to the accepted set when provided, so the preview reflects exactly
+    // what a push of those components would create/update/remove — the session's
+    // generated rows still include not-yet-reclassified rejects at this point.
+    if (opts.acceptedKeys) {
+        components = components.filter((c) => opts.acceptedKeys.has(c.key));
+    }
     let tokens = [];
     if (tokensPath) {
         tokens = await readTokensFromPath('tokens', tokensPath);
     }
-    const manifest = buildManifest(components, tokens);
+    const manifest = buildManifest(components, tokens, { deleteAllComponents: opts.deleteAllComponents === true });
     const client = new ImportApiClient({ host, cmaToken, spaceId, environmentId });
     const startedAt = Date.now();
     let timeoutHandle;