@google/gemini-cli 0.26.0-preview.4 → 0.27.0-nightly.20260126.cb772a5b7

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

@@ -16,6 +16,10 @@ import { parsePastedPaths } from '../../utils/clipboardUtils.js';
 import { keyMatchers, Command } from '../../keyMatchers.js';
 import { handleVimAction } from './vim-buffer-actions.js';
 import { LRU_BUFFER_PERF_CACHE_LIMIT } from '../../constants.js';
+const LARGE_PASTE_LINE_THRESHOLD = 5;
+const LARGE_PASTE_CHAR_THRESHOLD = 500;
+// Regex to match paste placeholders like [Pasted Text: 6 lines] or [Pasted Text: 501 chars #2]
+export const PASTED_TEXT_PLACEHOLDER_REGEX = /\[Pasted Text: \d+ (?:lines|chars)(?: #\d+)?\]/g;
 // Helper functions for line-based word navigation
 export const isWordCharStrict = (char) => /[\w\p{L}\p{N}]/u.test(char); // Matches a single character that is any Unicode letter, any Unicode number, or an underscore
 export const isWhitespace = (char) => /\s/.test(char);
@@ -513,9 +517,9 @@ export function calculateTransformationsForLine(line) {
         return cached;
     }
     const transformations = [];
-    let match;
-    // Reset regex state to ensure clean matching from start of line
+    // 1. Detect image paths
     imagePathRegex.lastIndex = 0;
+    let match;
     while ((match = imagePathRegex.exec(line)) !== null) {
         const logicalText = match[0];
         const logStart = cpLen(line.substring(0, match.index));
@@ -525,8 +529,26 @@ export function calculateTransformationsForLine(line) {
             logEnd,
             logicalText,
             collapsedText: getTransformedImagePath(logicalText),
+            type: 'image',
+        });
+    }
+    // 2. Detect paste placeholders
+    const pasteRegex = new RegExp(PASTED_TEXT_PLACEHOLDER_REGEX.source, 'g');
+    while ((match = pasteRegex.exec(line)) !== null) {
+        const logicalText = match[0];
+        const logStart = cpLen(line.substring(0, match.index));
+        const logEnd = logStart + cpLen(logicalText);
+        transformations.push({
+            logStart,
+            logEnd,
+            logicalText,
+            collapsedText: logicalText,
+            type: 'paste',
+            id: logicalText,
         });
     }
+    // Sort transformations by logStart to maintain consistency
+    transformations.sort((a, b) => a.logStart - b.logStart);
     transformationsCache.set(line, transformations);
     return transformations;
 }
@@ -546,6 +568,39 @@ export function getTransformUnderCursor(row, col, spansByLine) {
     }
     return null;
 }
+/**
+ * Find atomic placeholder at cursor for backspace (cursor at end).
+ * Checks all placeholder types in priority order.
+ */
+function findAtomicPlaceholderForBackspace(line, cursorCol, transformations) {
+    for (const transform of transformations) {
+        if (cursorCol === transform.logEnd) {
+            return {
+                start: transform.logStart,
+                end: transform.logEnd,
+                type: transform.type,
+                id: transform.id,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Find atomic placeholder at cursor for delete (cursor at start).
+ */
+function findAtomicPlaceholderForDelete(line, cursorCol, transformations) {
+    for (const transform of transformations) {
+        if (cursorCol === transform.logStart) {
+            return {
+                start: transform.logStart,
+                end: transform.logEnd,
+                type: transform.type,
+                id: transform.id,
+            };
+        }
+    }
+    return null;
+}
 export function calculateTransformedLine(logLine, logIndex, logicalCursor, transformations) {
     let transformedLine = '';
     const transformedToLogMap = [];
@@ -558,7 +613,8 @@ export function calculateTransformedLine(logLine, logIndex, logicalCursor, trans
         for (let i = 0; i < cpLen(textBeforeTransformation); i++) {
             transformedToLogMap.push(lastLogPos + i);
         }
-        const isExpanded = cursorIsOnThisLine &&
+        const isExpanded = transform.type === 'image' &&
+            cursorIsOnThisLine &&
             cursorCol >= transform.logStart &&
             cursorCol <= transform.logEnd;
         const transformedText = isExpanded
@@ -817,6 +873,7 @@ export const pushUndo = (currentState) => {
         lines: [...currentState.lines],
         cursorRow: currentState.cursorRow,
         cursorCol: currentState.cursorCol,
+        pastedContent: { ...currentState.pastedContent },
     };
     const newStack = [...currentState.undoStack, snapshot];
     if (newStack.length > historyLimit) {
@@ -824,6 +881,18 @@ export const pushUndo = (currentState) => {
     }
     return { ...currentState, undoStack: newStack, redoStack: [] };
 };
+function generatePastedTextId(content, lineCount, pastedContent) {
+    const base = lineCount > LARGE_PASTE_LINE_THRESHOLD
+        ? `[Pasted Text: ${lineCount} lines]`
+        : `[Pasted Text: ${content.length} chars]`;
+    let id = base;
+    let suffix = 2;
+    while (pastedContent[id]) {
+        id = base.replace(']', ` #${suffix}]`);
+        suffix++;
+    }
+    return id;
+}
 function textBufferReducerLogic(state, action, options = {}) {
     const pushUndoLocal = pushUndo;
     const currentLine = (r) => state.lines[r] ?? '';
@@ -845,6 +914,7 @@ function textBufferReducerLogic(state, action, options = {}) {
                 cursorRow: lastNewLineIndex,
                 cursorCol: cpLen(lines[lastNewLineIndex] ?? ''),
                 preferredCol: null,
+                pastedContent: action.payload === '' ? {} : nextState.pastedContent,
             };
         }
         case 'insert': {
@@ -854,6 +924,21 @@ function textBufferReducerLogic(state, action, options = {}) {
             let newCursorCol = nextState.cursorCol;
             const currentLine = (r) => newLines[r] ?? '';
             let payload = action.payload;
+            let newPastedContent = nextState.pastedContent;
+            if (action.isPaste) {
+                // Normalize line endings for pastes
+                payload = payload.replace(/\r\n|\r/g, '\n');
+                const lineCount = payload.split('\n').length;
+                if (lineCount > LARGE_PASTE_LINE_THRESHOLD ||
+                    payload.length > LARGE_PASTE_CHAR_THRESHOLD) {
+                    const id = generatePastedTextId(payload, lineCount, newPastedContent);
+                    newPastedContent = {
+                        ...newPastedContent,
+                        [id]: payload,
+                    };
+                    payload = id;
+                }
+            }
             if (options.singleLine) {
                 payload = payload.replace(/[\r\n]/g, '');
             }
@@ -887,16 +972,57 @@ function textBufferReducerLogic(state, action, options = {}) {
                 cursorRow: newCursorRow,
                 cursorCol: newCursorCol,
                 preferredCol: null,
+                pastedContent: newPastedContent,
+            };
+        }
+        case 'add_pasted_content': {
+            const { id, text } = action.payload;
+            return {
+                ...state,
+                pastedContent: {
+                    ...state.pastedContent,
+                    [id]: text,
+                },
             };
         }
         case 'backspace': {
+            const { cursorRow, cursorCol, lines, transformationsByLine } = state;
+            // Early return if at start of buffer
+            if (cursorCol === 0 && cursorRow === 0)
+                return state;
+            // Check if cursor is at end of an atomic placeholder
+            const transformations = transformationsByLine[cursorRow] ?? [];
+            const placeholder = findAtomicPlaceholderForBackspace(lines[cursorRow], cursorCol, transformations);
+            if (placeholder) {
+                const nextState = pushUndoLocal(state);
+                const newLines = [...nextState.lines];
+                newLines[cursorRow] =
+                    cpSlice(newLines[cursorRow], 0, placeholder.start) +
+                        cpSlice(newLines[cursorRow], placeholder.end);
+                // Recalculate transformations for the modified line
+                const newTransformations = [...nextState.transformationsByLine];
+                newTransformations[cursorRow] = calculateTransformationsForLine(newLines[cursorRow]);
+                // Clean up pastedContent if this was a paste placeholder
+                let newPastedContent = nextState.pastedContent;
+                if (placeholder.type === 'paste' && placeholder.id) {
+                    const { [placeholder.id]: _, ...remaining } = nextState.pastedContent;
+                    newPastedContent = remaining;
+                }
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    cursorCol: placeholder.start,
+                    preferredCol: null,
+                    transformationsByLine: newTransformations,
+                    pastedContent: newPastedContent,
+                };
+            }
+            // Standard backspace logic
             const nextState = pushUndoLocal(state);
             const newLines = [...nextState.lines];
             let newCursorRow = nextState.cursorRow;
             let newCursorCol = nextState.cursorCol;
             const currentLine = (r) => newLines[r] ?? '';
-            if (newCursorCol === 0 && newCursorRow === 0)
-                return state;
             if (newCursorCol > 0) {
                 const lineContent = currentLine(newCursorRow);
                 newLines[newCursorRow] =
@@ -1078,7 +1204,35 @@ function textBufferReducerLogic(state, action, options = {}) {
             };
         }
         case 'delete': {
-            const { cursorRow, cursorCol, lines } = state;
+            const { cursorRow, cursorCol, lines, transformationsByLine } = state;
+            // Check if cursor is at start of an atomic placeholder
+            const transformations = transformationsByLine[cursorRow] ?? [];
+            const placeholder = findAtomicPlaceholderForDelete(lines[cursorRow], cursorCol, transformations);
+            if (placeholder) {
+                const nextState = pushUndoLocal(state);
+                const newLines = [...nextState.lines];
+                newLines[cursorRow] =
+                    cpSlice(newLines[cursorRow], 0, placeholder.start) +
+                        cpSlice(newLines[cursorRow], placeholder.end);
+                // Recalculate transformations for the modified line
+                const newTransformations = [...nextState.transformationsByLine];
+                newTransformations[cursorRow] = calculateTransformationsForLine(newLines[cursorRow]);
+                // Clean up pastedContent if this was a paste placeholder
+                let newPastedContent = nextState.pastedContent;
+                if (placeholder.type === 'paste' && placeholder.id) {
+                    const { [placeholder.id]: _, ...remaining } = nextState.pastedContent;
+                    newPastedContent = remaining;
+                }
+                return {
+                    ...nextState,
+                    lines: newLines,
+                    // cursorCol stays the same
+                    preferredCol: null,
+                    transformationsByLine: newTransformations,
+                    pastedContent: newPastedContent,
+                };
+            }
+            // Standard delete logic
             const lineContent = currentLine(cursorRow);
             if (cursorCol < currentLineLen(cursorRow)) {
                 const nextState = pushUndoLocal(state);
@@ -1218,6 +1372,7 @@ function textBufferReducerLogic(state, action, options = {}) {
                 lines: [...state.lines],
                 cursorRow: state.cursorRow,
                 cursorCol: state.cursorCol,
+                pastedContent: { ...state.pastedContent },
             };
             return {
                 ...state,
@@ -1234,6 +1389,7 @@ function textBufferReducerLogic(state, action, options = {}) {
                 lines: [...state.lines],
                 cursorRow: state.cursorRow,
                 cursorCol: state.cursorCol,
+                pastedContent: { ...state.pastedContent },
             };
             return {
                 ...state,
@@ -1349,10 +1505,11 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             viewportWidth: viewport.width,
             viewportHeight: viewport.height,
             visualLayout,
+            pastedContent: {},
         };
     }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
     const [state, dispatch] = useReducer((s, a) => textBufferReducer(s, a, { inputFilter, singleLine }), initialState);
-    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, transformationsByLine, } = state;
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, transformationsByLine, pastedContent, } = state;
     const text = useMemo(() => lines.join('\n'), [lines]);
     const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
     const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
@@ -1388,10 +1545,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         }
     }, [visualCursor, visualScrollRow, viewport, visualLines.length]);
     const insert = useCallback((ch, { paste = false } = {}) => {
-        if (!singleLine && /[\n\r]/.test(ch)) {
-            dispatch({ type: 'insert', payload: ch });
+        if (typeof ch !== 'string') {
             return;
         }
+        let textToInsert = ch;
         const minLengthToInferAsDragDrop = 3;
         if (ch.length >= minLengthToInferAsDragDrop &&
             !shellModeActive &&
@@ -1404,14 +1561,14 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             potentialPath = potentialPath.trim();
             const processed = parsePastedPaths(potentialPath, isValidPath);
             if (processed) {
-                ch = processed;
+                textToInsert = processed;
             }
         }
         let currentText = '';
-        for (const char of toCodePoints(ch)) {
+        for (const char of toCodePoints(textToInsert)) {
             if (char.codePointAt(0) === 127) {
                 if (currentText.length > 0) {
-                    dispatch({ type: 'insert', payload: currentText });
+                    dispatch({ type: 'insert', payload: currentText, isPaste: paste });
                     currentText = '';
                 }
                 dispatch({ type: 'backspace' });
@@ -1421,9 +1578,9 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             }
         }
         if (currentText.length > 0) {
-            dispatch({ type: 'insert', payload: currentText });
+            dispatch({ type: 'insert', payload: currentText, isPaste: paste });
         }
-    }, [isValidPath, shellModeActive, singleLine]);
+    }, [isValidPath, shellModeActive]);
     const newline = useCallback(() => {
         if (singleLine) {
             return;
@@ -1727,6 +1884,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         cursor: [cursorRow, cursorCol],
         preferredCol,
         selectionAnchor,
+        pastedContent,
         allVisualLines: visualLines,
         viewportVisualLines: renderedVisualLines,
         visualCursor,
@@ -1795,6 +1953,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         cursorCol,
         preferredCol,
         selectionAnchor,
+        pastedContent,
         visualLines,
         renderedVisualLines,
         visualCursor,