@google/gemini-cli 0.5.5 → 0.6.0-preview.0

package/dist/src/ui/components/shared/text-buffer.js

@@ -8,9 +8,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import pathMod from 'node:path';
 import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
-import stringWidth from 'string-width';
 import { unescapePath } from '@google/gemini-cli-core';
-import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, } from '../../utils/textUtils.js';
+import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
 import { handleVimAction } from './vim-buffer-actions.js';
 // Simple helper for word‑wise ops.
 function isWordChar(ch) {
@@ -455,12 +454,12 @@ export function logicalPosToOffset(lines, row, col) {
     }
     return offset;
 }
-// Helper to calculate visual lines and map cursor positions
-function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
+// Calculates the visual wrapping of lines and the mapping between logical and visual coordinates.
+// This is an expensive operation and should be memoized.
+function calculateLayout(logicalLines, viewportWidth) {
     const visualLines = [];
     const logicalToVisualMap = [];
     const visualToLogicalMap = [];
-    let currentVisualCursor = [0, 0];
     logicalLines.forEach((logLine, logIndex) => {
         logicalToVisualMap[logIndex] = [];
         if (logLine.length === 0) {
@@ -468,9 +467,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
             logicalToVisualMap[logIndex].push([visualLines.length, 0]);
             visualToLogicalMap.push([logIndex, 0]);
             visualLines.push('');
-            if (logIndex === logicalCursor[0] && logicalCursor[1] === 0) {
-                currentVisualCursor = [visualLines.length - 1, 0];
-            }
         }
         else {
             // Non-empty logical line
@@ -485,7 +481,7 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                 // Iterate through code points to build the current visual line (chunk)
                 for (let i = currentPosInLogLine; i < codePointsInLogLine.length; i++) {
                     const char = codePointsInLogLine[i];
-                    const charVisualWidth = stringWidth(char);
+                    const charVisualWidth = getCachedStringWidth(char);
                     if (currentChunkVisualWidth + charVisualWidth > viewportWidth) {
                         // Character would exceed viewport width
                         if (lastWordBreakPoint !== -1 &&
@@ -551,27 +547,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                 ]);
                 visualToLogicalMap.push([logIndex, currentPosInLogLine]);
                 visualLines.push(currentChunk);
-                // Cursor mapping logic
-                // Note: currentPosInLogLine here is the start of the currentChunk within the logical line.
-                if (logIndex === logicalCursor[0]) {
-                    const cursorLogCol = logicalCursor[1]; // This is a code point index
-                    if (cursorLogCol >= currentPosInLogLine &&
-                        cursorLogCol < currentPosInLogLine + numCodePointsInChunk // Cursor is within this chunk
-                    ) {
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            cursorLogCol - currentPosInLogLine, // Visual col is also code point index within visual line
-                        ];
-                    }
-                    else if (cursorLogCol === currentPosInLogLine + numCodePointsInChunk &&
-                        numCodePointsInChunk > 0) {
-                        // Cursor is exactly at the end of this non-empty chunk
-                        currentVisualCursor = [
-                            visualLines.length - 1,
-                            numCodePointsInChunk,
-                        ];
-                    }
-                }
                 const logicalStartOfThisChunk = currentPosInLogLine;
                 currentPosInLogLine += numCodePointsInChunk;
                 // If the chunk processed did not consume the entire logical line,
@@ -584,20 +559,6 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
                     currentPosInLogLine++;
                 }
             }
-            // After all chunks of a non-empty logical line are processed,
-            // if the cursor is at the very end of this logical line, update visual cursor.
-            if (logIndex === logicalCursor[0] &&
-                logicalCursor[1] === codePointsInLogLine.length // Cursor at end of logical line
-            ) {
-                const lastVisualLineIdx = visualLines.length - 1;
-                if (lastVisualLineIdx >= 0 &&
-                    visualLines[lastVisualLineIdx] !== undefined) {
-                    currentVisualCursor = [
-                        lastVisualLineIdx,
-                        cpLen(visualLines[lastVisualLineIdx]), // Cursor at end of last visual line for this logical line
-                    ];
-                }
-            }
         }
     });
     // If the entire logical text was empty, ensure there's one empty visual line.
@@ -610,23 +571,46 @@ function calculateVisualLayout(logicalLines, logicalCursor, viewportWidth) {
             logicalToVisualMap[0].push([0, 0]);
             visualToLogicalMap.push([0, 0]);
         }
-        currentVisualCursor = [0, 0];
-    }
-    // Handle cursor at the very end of the text (after all processing)
-    // This case might be covered by the loop end condition now, but kept for safety.
-    else if (logicalCursor[0] === logicalLines.length - 1 &&
-        logicalCursor[1] === cpLen(logicalLines[logicalLines.length - 1]) &&
-        visualLines.length > 0) {
-        const lastVisLineIdx = visualLines.length - 1;
-        currentVisualCursor = [lastVisLineIdx, cpLen(visualLines[lastVisLineIdx])];
     }
     return {
         visualLines,
-        visualCursor: currentVisualCursor,
         logicalToVisualMap,
         visualToLogicalMap,
     };
 }
+// Calculates the visual cursor position based on a pre-calculated layout.
+// This is a lightweight operation.
+function calculateVisualCursorFromLayout(layout, logicalCursor) {
+    const { logicalToVisualMap, visualLines } = layout;
+    const [logicalRow, logicalCol] = logicalCursor;
+    const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
+    if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
+        // This can happen for an empty document.
+        return [0, 0];
+    }
+    // Find the segment where the logical column fits.
+    // The segments are sorted by startColInLogical.
+    let targetSegmentIndex = segmentsForLogicalLine.findIndex(([, startColInLogical], index) => {
+        const nextStartColInLogical = index + 1 < segmentsForLogicalLine.length
+            ? segmentsForLogicalLine[index + 1][1]
+            : Infinity;
+        return (logicalCol >= startColInLogical && logicalCol < nextStartColInLogical);
+    });
+    // If not found, it means the cursor is at the end of the logical line.
+    if (targetSegmentIndex === -1) {
+        if (logicalCol === 0) {
+            targetSegmentIndex = 0;
+        }
+        else {
+            targetSegmentIndex = segmentsForLogicalLine.length - 1;
+        }
+    }
+    const [visualRow, startColInLogical] = segmentsForLogicalLine[targetSegmentIndex];
+    const visualCol = logicalCol - startColInLogical;
+    // The visual column should not exceed the length of the visual line.
+    const clampedVisualCol = Math.min(visualCol, cpLen(visualLines[visualRow] ?? ''));
+    return [visualRow, clampedVisualCol];
+}
 const historyLimit = 100;
 export const pushUndo = (currentState) => {
     const snapshot = {
@@ -640,7 +624,7 @@ export const pushUndo = (currentState) => {
     }
     return { ...currentState, undoStack: newStack, redoStack: [] };
 };
-export function textBufferReducer(state, action) {
+function textBufferReducerLogic(state, action) {
     const pushUndoLocal = pushUndo;
     const currentLine = (r) => state.lines[r] ?? '';
     const currentLineLen = (r) => cpLen(currentLine(r));
@@ -727,68 +711,101 @@ export function textBufferReducer(state, action) {
                 preferredCol: null,
             };
         }
-        case 'set_viewport_width': {
-            if (action.payload === state.viewportWidth) {
+        case 'set_viewport': {
+            const { width, height } = action.payload;
+            if (width === state.viewportWidth && height === state.viewportHeight) {
                 return state;
             }
-            return { ...state, viewportWidth: action.payload };
+            return {
+                ...state,
+                viewportWidth: width,
+                viewportHeight: height,
+            };
         }
         case 'move': {
             const { dir } = action.payload;
-            const { lines, cursorRow, cursorCol, viewportWidth } = state;
-            const visualLayout = calculateVisualLayout(lines, [cursorRow, cursorCol], viewportWidth);
-            const { visualLines, visualCursor, visualToLogicalMap } = visualLayout;
-            let newVisualRow = visualCursor[0];
-            let newVisualCol = visualCursor[1];
-            let newPreferredCol = state.preferredCol;
-            const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
-            switch (dir) {
-                case 'left':
-                    newPreferredCol = null;
-                    if (newVisualCol > 0) {
-                        newVisualCol--;
-                    }
-                    else if (newVisualRow > 0) {
-                        newVisualRow--;
-                        newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
-                    }
-                    break;
-                case 'right':
-                    newPreferredCol = null;
-                    if (newVisualCol < currentVisLineLen) {
-                        newVisualCol++;
-                    }
-                    else if (newVisualRow < visualLines.length - 1) {
-                        newVisualRow++;
+            const { cursorRow, cursorCol, lines, visualLayout, preferredCol } = state;
+            // Visual movements
+            if (dir === 'left' ||
+                dir === 'right' ||
+                dir === 'up' ||
+                dir === 'down' ||
+                dir === 'home' ||
+                dir === 'end') {
+                const visualCursor = calculateVisualCursorFromLayout(visualLayout, [
+                    cursorRow,
+                    cursorCol,
+                ]);
+                const { visualLines, visualToLogicalMap } = visualLayout;
+                let newVisualRow = visualCursor[0];
+                let newVisualCol = visualCursor[1];
+                let newPreferredCol = preferredCol;
+                const currentVisLineLen = cpLen(visualLines[newVisualRow] ?? '');
+                switch (dir) {
+                    case 'left':
+                        newPreferredCol = null;
+                        if (newVisualCol > 0) {
+                            newVisualCol--;
+                        }
+                        else if (newVisualRow > 0) {
+                            newVisualRow--;
+                            newVisualCol = cpLen(visualLines[newVisualRow] ?? '');
+                        }
+                        break;
+                    case 'right':
+                        newPreferredCol = null;
+                        if (newVisualCol < currentVisLineLen) {
+                            newVisualCol++;
+                        }
+                        else if (newVisualRow < visualLines.length - 1) {
+                            newVisualRow++;
+                            newVisualCol = 0;
+                        }
+                        break;
+                    case 'up':
+                        if (newVisualRow > 0) {
+                            if (newPreferredCol === null)
+                                newPreferredCol = newVisualCol;
+                            newVisualRow--;
+                            newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
+                        }
+                        break;
+                    case 'down':
+                        if (newVisualRow < visualLines.length - 1) {
+                            if (newPreferredCol === null)
+                                newPreferredCol = newVisualCol;
+                            newVisualRow++;
+                            newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
+                        }
+                        break;
+                    case 'home':
+                        newPreferredCol = null;
                         newVisualCol = 0;
+                        break;
+                    case 'end':
+                        newPreferredCol = null;
+                        newVisualCol = currentVisLineLen;
+                        break;
+                    default: {
+                        const exhaustiveCheck = dir;
+                        console.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+                        return state;
                     }
-                    break;
-                case 'up':
-                    if (newVisualRow > 0) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow--;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'down':
-                    if (newVisualRow < visualLines.length - 1) {
-                        if (newPreferredCol === null)
-                            newPreferredCol = newVisualCol;
-                        newVisualRow++;
-                        newVisualCol = clamp(newPreferredCol, 0, cpLen(visualLines[newVisualRow] ?? ''));
-                    }
-                    break;
-                case 'home':
-                    newPreferredCol = null;
-                    newVisualCol = 0;
-                    break;
-                case 'end':
-                    newPreferredCol = null;
-                    newVisualCol = currentVisLineLen;
-                    break;
+                }
+                if (visualToLogicalMap[newVisualRow]) {
+                    const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+                    return {
+                        ...state,
+                        cursorRow: logRow,
+                        cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(lines[logRow] ?? '')),
+                        preferredCol: newPreferredCol,
+                    };
+                }
+                return state;
+            }
+            // Logical movements
+            switch (dir) {
                 case 'wordLeft': {
-                    const { cursorRow, cursorCol, lines } = state;
                     if (cursorCol === 0 && cursorRow === 0)
                         return state;
                     let newCursorRow = cursorRow;
@@ -827,7 +844,6 @@ export function textBufferReducer(state, action) {
                     };
                 }
                 case 'wordRight': {
-                    const { cursorRow, cursorCol, lines } = state;
                     if (cursorRow === lines.length - 1 &&
                         cursorCol === cpLen(lines[cursorRow] ?? '')) {
                         return state;
@@ -856,18 +872,14 @@ export function textBufferReducer(state, action) {
                     };
                 }
                 default:
-                    break;
-            }
-            if (visualToLogicalMap[newVisualRow]) {
-                const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
-                return {
-                    ...state,
-                    cursorRow: logRow,
-                    cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(state.lines[logRow] ?? '')),
-                    preferredCol: newPreferredCol,
-                };
+                    return state;
             }
-            return state;
+        }
+        case 'set_cursor': {
+            return {
+                ...state,
+                ...action.payload,
+            };
         }
         case 'delete': {
             const { cursorRow, cursorCol, lines } = state;
@@ -878,7 +890,11 @@ export function textBufferReducer(state, action) {
                 newLines[cursorRow] =
                     cpSlice(lineContent, 0, cursorCol) +
                         cpSlice(lineContent, cursorCol + 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             else if (cursorRow < lines.length - 1) {
                 const nextState = pushUndoLocal(state);
@@ -886,7 +902,11 @@ export function textBufferReducer(state, action) {
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             return state;
         }
@@ -958,7 +978,10 @@ export function textBufferReducer(state, action) {
                 const nextState = pushUndoLocal(state);
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
-                return { ...nextState, lines: newLines };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                };
             }
             else if (cursorRow < lines.length - 1) {
                 // Act as a delete
@@ -967,7 +990,11 @@ export function textBufferReducer(state, action) {
                 const newLines = [...nextState.lines];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
-                return { ...nextState, lines: newLines, preferredCol: null };
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    preferredCol: null,
+                };
             }
             return state;
         }
@@ -1078,11 +1105,23 @@ export function textBufferReducer(state, action) {
         }
     }
 }
+export function textBufferReducer(state, action) {
+    const newState = textBufferReducerLogic(state, action);
+    if (newState.lines !== state.lines ||
+        newState.viewportWidth !== state.viewportWidth) {
+        return {
+            ...newState,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth),
+        };
+    }
+    return newState;
+}
 // --- End of reducer logic ---
 export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, isValidPath, shellModeActive = false, }) {
     const initialState = useMemo(() => {
         const lines = initialText.split('\n');
         const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines.length === 0 ? [''] : lines, initialCursorOffset);
+        const visualLayout = calculateLayout(lines.length === 0 ? [''] : lines, viewport.width);
         return {
             lines: lines.length === 0 ? [''] : lines,
             cursorRow: initialCursorRow,
@@ -1093,13 +1132,15 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             clipboard: null,
             selectionAnchor: null,
             viewportWidth: viewport.width,
+            viewportHeight: viewport.height,
+            visualLayout,
         };
-    }, [initialText, initialCursorOffset, viewport.width]);
+    }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
     const [state, dispatch] = useReducer(textBufferReducer, initialState);
-    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor } = state;
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, } = state;
     const text = useMemo(() => lines.join('\n'), [lines]);
-    const visualLayout = useMemo(() => calculateVisualLayout(lines, [cursorRow, cursorCol], state.viewportWidth), [lines, cursorRow, cursorCol, state.viewportWidth]);
-    const { visualLines, visualCursor } = visualLayout;
+    const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
+    const { visualLines } = visualLayout;
     const [visualScrollRow, setVisualScrollRow] = useState(0);
     useEffect(() => {
         if (onChange) {
@@ -1107,8 +1148,11 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         }
     }, [text, onChange]);
     useEffect(() => {
-        dispatch({ type: 'set_viewport_width', payload: viewport.width });
-    }, [viewport.width]);
+        dispatch({
+            type: 'set_viewport',
+            payload: { width: viewport.width, height: viewport.height },
+        });
+    }, [viewport.width, viewport.height]);
     // Update visual scroll (vertical)
     useEffect(() => {
         const { height } = viewport;
@@ -1170,7 +1214,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     }, []);
     const move = useCallback((dir) => {
         dispatch({ type: 'move', payload: { dir } });
-    }, []);
+    }, [dispatch]);
     const undo = useCallback(() => {
         dispatch({ type: 'undo' });
     }, []);
@@ -1388,10 +1432,24 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             backspace();
         else if (key.name === 'delete' || (key.ctrl && key.name === 'd'))
             del();
+        else if (key.ctrl && !key.shift && key.name === 'z')
+            undo();
+        else if (key.ctrl && key.shift && key.name === 'z')
+            redo();
         else if (input && !key.ctrl && !key.meta) {
             insert(input, { paste: key.paste });
         }
-    }, [newline, move, deleteWordLeft, deleteWordRight, backspace, del, insert]);
+    }, [
+        newline,
+        move,
+        deleteWordLeft,
+        deleteWordRight,
+        backspace,
+        del,
+        insert,
+        undo,
+        redo,
+    ]);
     const renderedVisualLines = useMemo(() => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), [visualLines, visualScrollRow, viewport.height]);
     const replaceRange = useCallback((startRow, startCol, endRow, endCol, text) => {
         dispatch({