@contentful/experience-design-system-cli 2.7.0 → 2.7.1-dev-build-02830eb.0

package/dist/src/analyze/select/tui/state.js

@@ -0,0 +1,385 @@
+import { stripScoringFields } from '../../../types.js';
+import { computeScrollOffset } from './utils.js';
+function makeEditorState(value) {
+    return {
+        cursor: { lines: value.split('\n'), cursorRow: 0, cursorCol: 0 },
+        undoStack: [],
+        scrollRow: 0,
+        validationError: null,
+    };
+}
+function editorWithCursor(e, next) {
+    return {
+        ...e,
+        cursor: next,
+        undoStack: e.undoStack.length >= 50 ? [...e.undoStack.slice(1), e.cursor] : [...e.undoStack, e.cursor],
+    };
+}
+function syncEditorScroll(e, visibleHeight) {
+    const { cursorRow } = e.cursor;
+    let { scrollRow } = e;
+    if (cursorRow < scrollRow)
+        scrollRow = cursorRow;
+    if (cursorRow >= scrollRow + visibleHeight)
+        scrollRow = cursorRow - visibleHeight + 1;
+    return scrollRow === e.scrollRow ? e : { ...e, scrollRow };
+}
+// Pure: apply one keypress to EditorState. Returns null if key has no effect.
+export function applyEditorKey(e, input, key, visibleHeight) {
+    const { lines, cursorRow, cursorCol } = e.cursor;
+    // Ctrl+Z undo
+    if (key.ctrl && input === 'z') {
+        if (e.undoStack.length === 0)
+            return null;
+        const prev = e.undoStack[e.undoStack.length - 1];
+        return syncEditorScroll({ ...e, cursor: prev, undoStack: e.undoStack.slice(0, -1) }, visibleHeight);
+    }
+    let newLines = [...lines];
+    let newRow = cursorRow;
+    let newCol = cursorCol;
+    if (key.return) {
+        const before = newLines[cursorRow].slice(0, cursorCol);
+        const after = newLines[cursorRow].slice(cursorCol);
+        newLines = [...newLines.slice(0, cursorRow), before, after, ...newLines.slice(cursorRow + 1)];
+        newRow = cursorRow + 1;
+        newCol = 0;
+    }
+    else if (key.backspace) {
+        if (cursorCol > 0) {
+            newLines[cursorRow] = newLines[cursorRow].slice(0, cursorCol - 1) + newLines[cursorRow].slice(cursorCol);
+            newCol = cursorCol - 1;
+        }
+        else if (cursorRow > 0) {
+            const prevLen = newLines[cursorRow - 1].length;
+            newLines[cursorRow - 1] = newLines[cursorRow - 1] + newLines[cursorRow];
+            newLines = [...newLines.slice(0, cursorRow), ...newLines.slice(cursorRow + 1)];
+            newRow = cursorRow - 1;
+            newCol = prevLen;
+        }
+        else {
+            return null;
+        }
+    }
+    else if (key.delete) {
+        if (cursorCol < newLines[cursorRow].length) {
+            newLines[cursorRow] = newLines[cursorRow].slice(0, cursorCol) + newLines[cursorRow].slice(cursorCol + 1);
+        }
+        else if (cursorRow < newLines.length - 1) {
+            newLines[cursorRow] = newLines[cursorRow] + newLines[cursorRow + 1];
+            newLines = [...newLines.slice(0, cursorRow + 1), ...newLines.slice(cursorRow + 2)];
+        }
+        else {
+            return null;
+        }
+    }
+    else if (key.leftArrow) {
+        if (cursorCol > 0) {
+            newCol = cursorCol - 1;
+        }
+        else if (cursorRow > 0) {
+            newRow = cursorRow - 1;
+            newCol = newLines[cursorRow - 1].length;
+        }
+        else
+            return null;
+    }
+    else if (key.rightArrow) {
+        if (cursorCol < newLines[cursorRow].length) {
+            newCol = cursorCol + 1;
+        }
+        else if (cursorRow < newLines.length - 1) {
+            newRow = cursorRow + 1;
+            newCol = 0;
+        }
+        else
+            return null;
+    }
+    else if (key.upArrow) {
+        if (cursorRow === 0)
+            return null;
+        newRow = cursorRow - 1;
+        newCol = Math.min(cursorCol, newLines[newRow].length);
+    }
+    else if (key.downArrow) {
+        if (cursorRow >= newLines.length - 1)
+            return null;
+        newRow = cursorRow + 1;
+        newCol = Math.min(cursorCol, newLines[newRow].length);
+    }
+    else if (input === '\x1b[H' || input === '\x1b[1~') {
+        newCol = 0; // Home
+    }
+    else if (input === '\x1b[F' || input === '\x1b[4~') {
+        newCol = newLines[cursorRow].length; // End
+    }
+    else if (input && input.length === 1 && !key.ctrl && !key.meta) {
+        newLines[cursorRow] = newLines[cursorRow].slice(0, cursorCol) + input + newLines[cursorRow].slice(cursorCol);
+        newCol = cursorCol + 1;
+    }
+    else {
+        return null;
+    }
+    return syncEditorScroll(editorWithCursor(e, { lines: newLines, cursorRow: newRow, cursorCol: newCol }), visibleHeight);
+}
+export const initialState = {
+    mode: { type: 'browsing', sidebarFocused: true, sourceVisible: false },
+    session: null,
+    paths: null,
+    selectedId: null,
+    sortedIds: [],
+    sessionSummary: [],
+    sidebarScrollOffset: 0,
+    jsonScrollOffset: 0,
+    draftsByComponentId: {},
+    editor: null,
+    sourceCodeById: {},
+    previewAnnotations: (() => {
+        const raw = process.env['EDS_PREVIEW_ANNOTATIONS'];
+        if (!raw)
+            return {};
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    })(),
+    previewResponse: null,
+    previewLoading: false,
+    previewError: null,
+    saveError: null,
+};
+// ── Derived data ──────────────────────────────────────────────────────────────
+function computeSortedIds(components) {
+    return [...components]
+        .map((c) => ({
+        id: c.id,
+        needsReview: c.originalProposal.needsReview ?? false,
+        status: c.status,
+        conf: c.originalProposal.extractionConfidence ?? 6,
+    }))
+        .sort((a, b) => {
+        const aF = a.needsReview && a.status === 'needs-review' ? 0 : 1;
+        const bF = b.needsReview && b.status === 'needs-review' ? 0 : 1;
+        if (aF !== bF)
+            return aF - bF;
+        return a.conf - b.conf;
+    })
+        .map((c) => c.id);
+}
+// Builds a stable summary array for Sidebar — same reference if nothing changed.
+// Keeping this in state means Sidebar never re-renders on scroll/selection alone.
+function computeSessionSummary(components, annotations, sortedIds) {
+    return sortedIds
+        .map((id) => components.find((c) => c.id === id))
+        .filter((c) => !!c)
+        .map((c) => ({
+        id: c.id,
+        name: c.name,
+        status: c.status,
+        previewAnnotation: annotations[c.name],
+        extractionConfidence: c.originalProposal.extractionConfidence ?? null,
+        needsReview: c.originalProposal.needsReview ?? false,
+    }));
+}
+// Rebuild both sortedIds and sessionSummary from updated components + annotations.
+function withUpdatedSession(state, components, annotations) {
+    const ann = annotations ?? state.previewAnnotations;
+    const sortedIds = computeSortedIds(components);
+    const sessionSummary = computeSessionSummary(components, ann, sortedIds);
+    return {
+        ...state,
+        session: { ...state.session, components },
+        previewAnnotations: ann,
+        sortedIds,
+        sessionSummary,
+    };
+}
+function updateStatus(state, newStatus) {
+    if (!state.session || !state.selectedId)
+        return state;
+    const components = state.session.components.map((c) => (c.id === state.selectedId ? { ...c, status: newStatus } : c));
+    return withUpdatedSession(state, components);
+}
+// ── Reducer ───────────────────────────────────────────────────────────────────
+export function reducer(state, action) {
+    switch (action.type) {
+        case 'SESSION_LOADED': {
+            const sortedIds = computeSortedIds(action.session.components);
+            const sessionSummary = computeSessionSummary(action.session.components, state.previewAnnotations, sortedIds);
+            return {
+                ...state,
+                session: action.session,
+                paths: action.paths,
+                sortedIds,
+                sessionSummary,
+                selectedId: sortedIds[0] ?? null,
+            };
+        }
+        case 'SELECT':
+            return { ...state, selectedId: action.id, jsonScrollOffset: 0 };
+        case 'SIDEBAR_UP': {
+            if (!state.session || !state.selectedId)
+                return state;
+            const idx = state.sortedIds.indexOf(state.selectedId);
+            if (idx <= 0)
+                return state;
+            const ni = idx - 1;
+            return {
+                ...state,
+                selectedId: state.sortedIds[ni],
+                jsonScrollOffset: 0,
+                sidebarScrollOffset: computeScrollOffset(ni, state.sidebarScrollOffset, action.visibleCount),
+            };
+        }
+        case 'SIDEBAR_DOWN': {
+            if (!state.session || !state.selectedId)
+                return state;
+            const idx = state.sortedIds.indexOf(state.selectedId);
+            if (idx >= state.sortedIds.length - 1)
+                return state;
+            const ni = idx + 1;
+            return {
+                ...state,
+                selectedId: state.sortedIds[ni],
+                jsonScrollOffset: 0,
+                sidebarScrollOffset: computeScrollOffset(ni, state.sidebarScrollOffset, action.visibleCount),
+            };
+        }
+        case 'ACCEPT':
+            return updateStatus(state, 'accepted');
+        case 'REJECT':
+            return updateStatus(state, 'rejected');
+        case 'APPROVE_ALL': {
+            if (!state.session)
+                return state;
+            const components = state.session.components.map((c) => c.status === 'needs-review' ? { ...c, status: 'accepted' } : c);
+            return withUpdatedSession(state, components);
+        }
+        case 'ENTER_EDIT': {
+            if (state.mode.type !== 'browsing' || !state.selectedId || !state.session)
+                return state;
+            const component = state.session.components.find((c) => c.id === state.selectedId);
+            if (!component)
+                return state;
+            const existing = state.draftsByComponentId[state.selectedId];
+            const draft = existing ?? JSON.stringify(stripScoringFields(component.editedProposal), null, 2);
+            const editor = makeEditorState(draft);
+            return {
+                ...state,
+                mode: { type: 'editing', componentId: state.selectedId },
+                draftsByComponentId: { ...state.draftsByComponentId, [state.selectedId]: draft },
+                editor,
+            };
+        }
+        case 'EDITOR_KEY': {
+            if (!state.editor || state.mode.type !== 'editing')
+                return state;
+            const next = applyEditorKey(state.editor, action.input, action.key, action.visibleHeight);
+            if (!next)
+                return state;
+            const newValue = next.cursor.lines.join('\n');
+            return {
+                ...state,
+                editor: next,
+                draftsByComponentId: { ...state.draftsByComponentId, [state.mode.componentId]: newValue },
+            };
+        }
+        case 'EDITOR_VALIDATE': {
+            // inputToAction calls this on Ctrl+S — reducer does the parse check
+            if (!state.editor || state.mode.type !== 'editing')
+                return state;
+            const text = state.editor.cursor.lines.join('\n');
+            try {
+                JSON.parse(text);
+                // Valid — switch mode back to browsing; side effect will detect the transition and persist
+                return {
+                    ...state,
+                    editor: { ...state.editor, validationError: null },
+                    mode: { type: 'browsing', sidebarFocused: true, sourceVisible: false },
+                    // keep draft in draftsByComponentId — side effect will persist it and clear it
+                };
+            }
+            catch (e) {
+                return {
+                    ...state,
+                    editor: { ...state.editor, validationError: e instanceof Error ? e.message : String(e) },
+                };
+            }
+        }
+        case 'DRAFT_DISCARD': {
+            if (state.mode.type !== 'editing')
+                return state;
+            const { componentId } = state.mode;
+            const { [componentId]: _removed, ...remaining } = state.draftsByComponentId;
+            return {
+                ...state,
+                mode: { type: 'browsing', sidebarFocused: true, sourceVisible: false },
+                draftsByComponentId: remaining,
+                editor: null,
+            };
+        }
+        case 'DRAFT_PERSIST_DONE': {
+            const { componentId, updatedComponents } = action;
+            const { [componentId]: _removed, ...remaining } = state.draftsByComponentId;
+            const base = withUpdatedSession(state, updatedComponents);
+            return { ...base, draftsByComponentId: remaining };
+        }
+        case 'TOGGLE_FOCUS': {
+            if (state.mode.type !== 'browsing')
+                return state;
+            return { ...state, mode: { ...state.mode, sidebarFocused: !state.mode.sidebarFocused } };
+        }
+        case 'SCROLL_UP':
+            return { ...state, jsonScrollOffset: Math.max(0, state.jsonScrollOffset - 1) };
+        case 'SCROLL_DOWN':
+            return { ...state, jsonScrollOffset: state.jsonScrollOffset + 1 };
+        case 'TOGGLE_SOURCE': {
+            if (state.mode.type !== 'browsing')
+                return state;
+            if (action.terminalWidth < 120)
+                return { ...state, saveError: 'Terminal too narrow for source panel (need 120+ cols)' };
+            return { ...state, mode: { ...state.mode, sourceVisible: !state.mode.sourceVisible } };
+        }
+        case 'OPEN_DIALOG':
+            return { ...state, mode: { type: 'dialog', which: action.which } };
+        case 'CLOSE_DIALOG':
+            return { ...state, mode: { type: 'browsing', sidebarFocused: true, sourceVisible: false } };
+        case 'FINALIZE_CONFIRM': {
+            if (!state.session)
+                return state;
+            const accepted = state.session.components.filter((c) => c.status === 'accepted').length;
+            const rejected = state.session.components.filter((c) => c.status === 'rejected').length;
+            const excluded = state.session.components.filter((c) => c.status === 'needs-review').length;
+            return { ...state, mode: { type: 'finalized', accepted, rejected, excluded } };
+        }
+        case 'QUIT_CONFIRM':
+            return state; // side effect handles exit
+        case 'SOURCE_LOADED':
+            return { ...state, sourceCodeById: { ...state.sourceCodeById, [action.componentId]: action.code } };
+        case 'PREVIEW_START':
+            return { ...state, previewLoading: true };
+        case 'PREVIEW_SUCCESS': {
+            const components = state.session?.components ?? [];
+            const sortedIds = computeSortedIds(components);
+            const sessionSummary = computeSessionSummary(components, action.annotations, sortedIds);
+            return {
+                ...state,
+                previewResponse: action.response,
+                previewAnnotations: action.annotations,
+                previewLoading: false,
+                previewError: null,
+                sortedIds,
+                sessionSummary,
+            };
+        }
+        case 'PREVIEW_ERROR':
+            return { ...state, previewLoading: false, previewError: action.message };
+        case 'SAVE_ERROR':
+            return { ...state, saveError: action.message };
+        case 'CLEAR_ERRORS':
+            return { ...state, saveError: null, previewError: null };
+        default:
+            return state;
+    }
+}

package/dist/src/analyze/select/tui/utils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Compute the new sidebar scroll offset after moving selection to `idx`.
+ * Keeps the selected item within the visible window.
+ */
+export declare function computeScrollOffset(idx: number, prev: number, visibleCount: number): number;

package/dist/src/analyze/select/tui/utils.js

@@ -0,0 +1,11 @@
+/**
+ * Compute the new sidebar scroll offset after moving selection to `idx`.
+ * Keeps the selected item within the visible window.
+ */
+export function computeScrollOffset(idx, prev, visibleCount) {
+    if (idx < prev)
+        return idx;
+    if (idx >= prev + visibleCount)
+        return idx - visibleCount + 1;
+    return prev;
+}

package/dist/src/analyze/tui/AnalyzeView.js

@@ -3,12 +3,14 @@ import { useState } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import { TopBar } from '../select/tui/components/TopBar.js';
 import { useImmediateInput } from '../select/tui/hooks/useImmediateInput.js';
+import { useRawMode } from '../select/tui/hooks/useRawMode.js';
 function truncateName(name, maxLen = 30) {
     if (name.length <= maxLen)
         return name;
     return name.slice(0, maxLen - 1) + '…';
 }
 export function AnalyzeView({ result, onExit }) {
+    useRawMode();
     const [scrollOffset, setScrollOffset] = useState(0);
     const { stdout } = useStdout();
     // Header lines: TopBar(1) + summary(3) + blank(1) + dividers+header(3) + blank(1) + footer(1) + footer-bar(1) = ~12

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

@@ -8,6 +8,7 @@ import { homedir, tmpdir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { execFile, spawn } from 'node:child_process';
 import { TopBar } from '../../analyze/select/tui/components/TopBar.js';
+import { useRawMode } from '../../analyze/select/tui/hooks/useRawMode.js';
 import { WelcomeStep } from './steps/WelcomeStep.js';
 import { PathValidationStep } from './steps/PathValidationStep.js';
 import { RunningStep } from './steps/RunningStep.js';
@@ -44,6 +45,7 @@ function logStep(entry) {
 export function WizardApp({ initialSpaceId = '', initialEnvironmentId = 'master', initialCmaToken = '', initialHost, initialAgent, initialProjectPath, host, } = {}) {
     const defaultConfiguredHost = toConfiguredHost(host || process.env['EDS_HOST']) ?? DEFAULT_CONFIGURED_HOST;
     const resolveWizardHost = (hostValue) => hostValue || defaultConfiguredHost;
+    useRawMode();
     const { stdout } = useStdout();
     const terminalWidth = stdout?.columns ?? 80;
     const logInit = useRef(false);

package/dist/src/import/tui/steps/GenerateReviewStep.js

@@ -8,6 +8,7 @@ import { StatusBar } from '../../../analyze/select/tui/components/StatusBar.js';
 import { FinalizeDialog } from '../../../analyze/select/tui/components/FinalizeDialog.js';
 import { QuitDialog } from '../../../analyze/select/tui/components/QuitDialog.js';
 import { useImmediateInput } from '../../../analyze/select/tui/hooks/useImmediateInput.js';
+import { computeScrollOffset } from '../../../analyze/select/tui/utils.js';
 import { openPipelineDb, loadCDFComponents, storeCDFComponents } from '../../../session/db.js';
 const VISIBLE_COUNT = 20;
 const PANEL_HEIGHT = 22;
@@ -161,7 +162,7 @@ export function GenerateReviewStep({ extractSessionId, onFinalize, onQuit, }) {
                 const newIdx = Math.min(components.length - 1, selectedIdx + 1);
                 setSelectedIdx(newIdx);
                 setJsonScrollOffset(0);
-                setSidebarScrollOffset((prev) => (newIdx >= prev + VISIBLE_COUNT ? newIdx - VISIBLE_COUNT + 1 : prev));
+                setSidebarScrollOffset((prev) => computeScrollOffset(newIdx, prev, VISIBLE_COUNT));
             }
         }
         else {
@@ -196,15 +197,7 @@ export function GenerateReviewStep({ extractSessionId, onFinalize, onQuit, }) {
     const needsReview = components.filter((c) => c.status === 'needs-review').length;
     const propCount = selected ? Object.keys(selected.entry.$properties).length : 0;
     const slotCount = selected?.entry.$slots ? Object.keys(selected.entry.$slots).length : 0;
-    return (_jsxs(Box, { flexDirection: "column", children: [showFinalize && (_jsx(FinalizeDialog, { accepted: accepted, rejected: rejected, needsReview: needsReview, onConfirm: handleFinalizeConfirm, onCancel: () => setShowFinalize(false) })), showQuit && _jsx(QuitDialog, { hasUnsavedDrafts: false, onConfirm: onQuit, onCancel: () => setShowQuit(false) }), !dialogOpen && (_jsxs(Box, { children: [_jsx(Sidebar, { components: sidebarItems, selectedId: selected?.key ?? null, focused: sidebarFocused, scrollOffset: sidebarScrollOffset, visibleCount: VISIBLE_COUNT, onSelect: (id) => {
-                            const idx = components.findIndex((c) => c.key === id);
-                            if (idx >= 0) {
-                                setSelectedIdx(idx);
-                                setJsonScrollOffset(0);
-                            }
-                        }, onScrollChange: setSidebarScrollOffset, width: sidebarWidth }), _jsx(Box, { flexGrow: 1, paddingLeft: 1, flexDirection: "column", children: selected ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: selected.key }), _jsx(Box, { flexGrow: 1 }), _jsxs(Text, { dimColor: true, children: [propCount, " prop", propCount !== 1 ? 's' : '', slotCount > 0 ? ` · ${slotCount} slot${slotCount !== 1 ? 's' : ''}` : '', '  ', sidebarFocused ? '[Tab] focus panel' : '[Tab] focus list'] })] }), editMode ? (_jsx(FieldEditor, { value: draftValue || selectedJson, width: panelWidth, height: PANEL_HEIGHT, onChange: setDraftValue, onSave: handleEditSave, onDiscard: handleEditDiscard })) : (_jsx(JsonPanel, { label: "GENERATED DEFINITION", value: selectedJson, scrollOffset: jsonScrollOffset, width: panelWidth, height: PANEL_HEIGHT, active: !sidebarFocused })), saveError && _jsx(Text, { color: "red", children: '✗ ' + saveError }), _jsx(Text, { dimColor: true, children: editMode
+    return (_jsxs(Box, { flexDirection: "column", children: [showFinalize && (_jsx(FinalizeDialog, { accepted: accepted, rejected: rejected, needsReview: needsReview, onConfirm: handleFinalizeConfirm, onCancel: () => setShowFinalize(false) })), showQuit && _jsx(QuitDialog, { hasUnsavedDrafts: false, onConfirm: onQuit, onCancel: () => setShowQuit(false) }), !dialogOpen && (_jsxs(Box, { children: [_jsx(Sidebar, { components: sidebarItems, selectedId: selected?.key ?? null, focused: sidebarFocused, scrollOffset: sidebarScrollOffset, visibleCount: VISIBLE_COUNT, width: sidebarWidth }), _jsx(Box, { flexGrow: 1, paddingLeft: 1, flexDirection: "column", children: selected ? (_jsxs(_Fragment, { children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: selected.key }), _jsx(Box, { flexGrow: 1 }), _jsxs(Text, { dimColor: true, children: [propCount, " prop", propCount !== 1 ? 's' : '', slotCount > 0 ? ` · ${slotCount} slot${slotCount !== 1 ? 's' : ''}` : '', '  ', sidebarFocused ? '[Tab] focus panel' : '[Tab] focus list'] })] }), editMode ? (_jsx(FieldEditor, { value: draftValue || selectedJson, width: panelWidth, height: PANEL_HEIGHT, onChange: setDraftValue, onSave: handleEditSave, onDiscard: handleEditDiscard })) : (_jsx(JsonPanel, { label: "GENERATED DEFINITION", value: selectedJson, scrollOffset: jsonScrollOffset, width: panelWidth, height: PANEL_HEIGHT, active: !sidebarFocused })), saveError && _jsx(Text, { color: "red", children: '✗ ' + saveError }), _jsx(Text, { dimColor: true, children: editMode
                                         ? '  [Ctrl+S] save  [Esc] discard'
-                                        : '  [a] accept  [r] reject  [e] edit  [A] accept all  [F] finalize  [Tab] toggle focus  [q] quit' })] })) : (_jsx(Text, { dimColor: true, children: "No component selected" })) })] })), !dialogOpen && (_jsx(StatusBar, { accepted: accepted, rejected: rejected, reviewed: 0, needsReview: needsReview, onApproveAll: () => {
-                    setComponents((prev) => prev.map((c) => (c.status === 'needs-review' ? { ...c, status: 'accepted' } : c)));
-                }, onFinalize: () => setShowFinalize(true) }))] }));
+                                        : '  [a] accept  [r] reject  [e] edit  [A] accept all  [F] finalize  [Tab] toggle focus  [q] quit' })] })) : (_jsx(Text, { dimColor: true, children: "No component selected" })) })] })), !dialogOpen && _jsx(StatusBar, { accepted: accepted, rejected: rejected, reviewed: 0, needsReview: needsReview })] }));
 }

package/dist/src/print/validate/tui/ValidateView.js

@@ -3,7 +3,9 @@ import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { TopBar } from '../../../analyze/select/tui/components/TopBar.js';
 import { useImmediateInput } from '../../../analyze/select/tui/hooks/useImmediateInput.js';
+import { useRawMode } from '../../../analyze/select/tui/hooks/useRawMode.js';
 export function ValidateView({ results, onExit }) {
+    useRawMode();
     const [scrollOffset, setScrollOffset] = useState(0);
     const allValid = results.every((r) => r.valid);
     useImmediateInput((input, key) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.7.0",
+  "version": "2.7.1-dev-build-02830eb.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -36,7 +36,7 @@
     "react-dom": "^18.3.1",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-types": "2.7.0"
+    "@contentful/experience-design-system-types": "2.7.1-dev-build-02830eb.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.3",