@google/gemini-cli 0.23.0-preview.4 → 0.24.0-nightly.20251231.05049b5ab

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

@@ -7,8 +7,9 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import pathMod from 'node:path';
+import * as path from 'node:path';
 import { useState, useCallback, useEffect, useMemo, useReducer } from 'react';
-import { coreEvents, CoreEvent } from '@google/gemini-cli-core';
+import { coreEvents, CoreEvent, debugLogger, unescapePath, } from '@google/gemini-cli-core';
 import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
 import { parsePastedPaths } from '../../utils/clipboardUtils.js';
 import { handleVimAction } from './vim-buffer-actions.js';
@@ -483,24 +484,136 @@ export function logicalPosToOffset(lines, row, col) {
     }
     return offset;
 }
+export const imagePathRegex = /@((?:\\.|[^\s\r\n\\])+?\.(?:png|jpg|jpeg|gif|webp|svg|bmp))\b/gi;
+export function getTransformedImagePath(filePath) {
+    const raw = filePath;
+    // Ignore leading @ when stripping directories, but keep it for simple '@file.png'
+    const withoutAt = raw.startsWith('@') ? raw.slice(1) : raw;
+    // Unescape the path to handle escaped spaces and other characters
+    const unescaped = unescapePath(withoutAt);
+    // Find last directory separator, supporting both POSIX and Windows styles
+    const lastSepIndex = Math.max(unescaped.lastIndexOf('/'), unescaped.lastIndexOf('\\'));
+    // If we saw a separator, take the segment after it; otherwise fall back to the unescaped string
+    const fileName = lastSepIndex >= 0 ? unescaped.slice(lastSepIndex + 1) : unescaped;
+    const extension = path.extname(fileName);
+    const baseName = path.basename(fileName, extension);
+    const maxBaseLength = 10;
+    const truncatedBase = baseName.length > maxBaseLength
+        ? `...${baseName.slice(-maxBaseLength)}`
+        : baseName;
+    return `[Image ${truncatedBase}${extension}]`;
+}
+export function calculateTransformationsForLine(line) {
+    const transformations = [];
+    let match;
+    // Reset regex state to ensure clean matching from start of line
+    imagePathRegex.lastIndex = 0;
+    while ((match = imagePathRegex.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: getTransformedImagePath(logicalText),
+        });
+    }
+    return transformations;
+}
+export function calculateTransformations(lines) {
+    return lines.map((ln) => calculateTransformationsForLine(ln));
+}
+export function getTransformUnderCursor(row, col, spansByLine) {
+    const spans = spansByLine[row];
+    if (!spans || spans.length === 0)
+        return null;
+    for (const span of spans) {
+        if (col >= span.logStart && col <= span.logEnd) {
+            return span;
+        }
+        if (col < span.logStart)
+            break;
+    }
+    return null;
+}
+export function calculateTransformedLine(logLine, logIndex, logicalCursor, transformations) {
+    let transformedLine = '';
+    const transformedToLogMap = [];
+    let lastLogPos = 0;
+    const cursorIsOnThisLine = logIndex === logicalCursor[0];
+    const cursorCol = logicalCursor[1];
+    for (const transform of transformations) {
+        const textBeforeTransformation = cpSlice(logLine, lastLogPos, transform.logStart);
+        transformedLine += textBeforeTransformation;
+        for (let i = 0; i < cpLen(textBeforeTransformation); i++) {
+            transformedToLogMap.push(lastLogPos + i);
+        }
+        const isExpanded = cursorIsOnThisLine &&
+            cursorCol >= transform.logStart &&
+            cursorCol <= transform.logEnd;
+        const transformedText = isExpanded
+            ? transform.logicalText
+            : transform.collapsedText;
+        transformedLine += transformedText;
+        // Map transformed characters back to logical characters
+        const transformedLen = cpLen(transformedText);
+        if (isExpanded) {
+            for (let i = 0; i < transformedLen; i++) {
+                transformedToLogMap.push(transform.logStart + i);
+            }
+        }
+        else {
+            // Collapsed: distribute transformed positions monotonically across the raw span.
+            // This preserves ordering across wrapped slices so logicalToVisualMap has
+            // increasing startColInLogical and visual cursor mapping remains consistent.
+            const logicalLength = Math.max(0, transform.logEnd - transform.logStart);
+            for (let i = 0; i < transformedLen; i++) {
+                // Map the i-th transformed code point into [logStart, logEnd)
+                const transformationToLogicalOffset = logicalLength === 0
+                    ? 0
+                    : Math.floor((i * logicalLength) / transformedLen);
+                const transformationToLogicalIndex = transform.logStart +
+                    Math.min(transformationToLogicalOffset, Math.max(logicalLength - 1, 0));
+                transformedToLogMap.push(transformationToLogicalIndex);
+            }
+        }
+        lastLogPos = transform.logEnd;
+    }
+    // Append text after last transform
+    const remainingUntransformedText = cpSlice(logLine, lastLogPos);
+    transformedLine += remainingUntransformedText;
+    for (let i = 0; i < cpLen(remainingUntransformedText); i++) {
+        transformedToLogMap.push(lastLogPos + i);
+    }
+    // For a cursor at the very end of the transformed line
+    transformedToLogMap.push(cpLen(logLine));
+    return { transformedLine, transformedToLogMap };
+}
 // 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) {
+function calculateLayout(logicalLines, viewportWidth, logicalCursor) {
     const visualLines = [];
     const logicalToVisualMap = [];
     const visualToLogicalMap = [];
+    const transformedToLogicalMaps = [];
+    const visualToTransformedMap = [];
     logicalLines.forEach((logLine, logIndex) => {
         logicalToVisualMap[logIndex] = [];
-        if (logLine.length === 0) {
+        const transformations = calculateTransformationsForLine(logLine);
+        const { transformedLine, transformedToLogMap } = calculateTransformedLine(logLine, logIndex, logicalCursor, transformations);
+        transformedToLogicalMaps[logIndex] = transformedToLogMap;
+        if (transformedLine.length === 0) {
             // Handle empty logical line
             logicalToVisualMap[logIndex].push([visualLines.length, 0]);
             visualToLogicalMap.push([logIndex, 0]);
+            visualToTransformedMap.push(0);
             visualLines.push('');
         }
         else {
             // Non-empty logical line
             let currentPosInLogLine = 0; // Tracks position within the current logical line (code point index)
-            const codePointsInLogLine = toCodePoints(logLine);
+            const codePointsInLogLine = toCodePoints(transformedLine);
             while (currentPosInLogLine < codePointsInLogLine.length) {
                 let currentChunk = '';
                 let currentChunkVisualWidth = 0;
@@ -570,11 +683,13 @@ function calculateLayout(logicalLines, viewportWidth) {
                     currentChunk = codePointsInLogLine[currentPosInLogLine];
                     numCodePointsInChunk = 1;
                 }
+                const logicalStartCol = transformedToLogMap[currentPosInLogLine] ?? 0;
                 logicalToVisualMap[logIndex].push([
                     visualLines.length,
-                    currentPosInLogLine,
+                    logicalStartCol,
                 ]);
-                visualToLogicalMap.push([logIndex, currentPosInLogLine]);
+                visualToLogicalMap.push([logIndex, logicalStartCol]);
+                visualToTransformedMap.push(currentPosInLogLine);
                 visualLines.push(currentChunk);
                 const logicalStartOfThisChunk = currentPosInLogLine;
                 currentPosInLogLine += numCodePointsInChunk;
@@ -599,18 +714,21 @@ function calculateLayout(logicalLines, viewportWidth) {
                 logicalToVisualMap[0] = [];
             logicalToVisualMap[0].push([0, 0]);
             visualToLogicalMap.push([0, 0]);
+            visualToTransformedMap.push(0);
         }
     }
     return {
         visualLines,
         logicalToVisualMap,
         visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
     };
 }
 // 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 { logicalToVisualMap, visualLines, transformedToLogicalMaps } = layout;
     const [logicalRow, logicalCol] = logicalCursor;
     const segmentsForLogicalLine = logicalToVisualMap[logicalRow];
     if (!segmentsForLogicalLine || segmentsForLogicalLine.length === 0) {
@@ -635,9 +753,26 @@ function calculateVisualCursorFromLayout(layout, logicalCursor) {
         }
     }
     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] ?? ''));
+    // Find the coordinates in transformed space in order to conver to visual
+    const transformedToLogicalMap = transformedToLogicalMaps[logicalRow] ?? [];
+    let transformedCol = 0;
+    for (let i = 0; i < transformedToLogicalMap.length; i++) {
+        if (transformedToLogicalMap[i] > logicalCol) {
+            transformedCol = Math.max(0, i - 1);
+            break;
+        }
+        if (i === transformedToLogicalMap.length - 1) {
+            transformedCol = transformedToLogicalMap.length - 1;
+        }
+    }
+    let startColInTransformed = 0;
+    while (startColInTransformed < transformedToLogicalMap.length &&
+        transformedToLogicalMap[startColInTransformed] < startColInLogical) {
+        startColInTransformed++;
+    }
+    const clampedTransformedCol = Math.min(transformedCol, Math.max(0, transformedToLogicalMap.length - 1));
+    const visualCol = clampedTransformedCol - startColInTransformed;
+    const clampedVisualCol = Math.min(Math.max(visualCol, 0), cpLen(visualLines[visualRow] ?? ''));
     return [visualRow, clampedVisualCol];
 }
 const historyLimit = 100;
@@ -827,16 +962,25 @@ function textBufferReducerLogic(state, action, options = {}) {
                         break;
                     default: {
                         const exhaustiveCheck = dir;
-                        console.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
+                        debugLogger.error(`Unknown visual movement direction: ${exhaustiveCheck}`);
                         return state;
                     }
                 }
                 if (visualToLogicalMap[newVisualRow]) {
-                    const [logRow, logStartCol] = visualToLogicalMap[newVisualRow];
+                    const [logRow, logicalStartCol] = visualToLogicalMap[newVisualRow];
+                    const transformedToLogicalMap = visualLayout.transformedToLogicalMaps?.[logRow] ?? [];
+                    let transformedStartCol = 0;
+                    while (transformedStartCol < transformedToLogicalMap.length &&
+                        transformedToLogicalMap[transformedStartCol] < logicalStartCol) {
+                        transformedStartCol++;
+                    }
+                    const clampedTransformedCol = Math.min(transformedStartCol + newVisualCol, Math.max(0, transformedToLogicalMap.length - 1));
+                    const newLogicalCol = transformedToLogicalMap[clampedTransformedCol] ??
+                        cpLen(lines[logRow] ?? '');
                     return {
                         ...state,
                         cursorRow: logRow,
-                        cursorCol: clamp(logStartCol + newVisualCol, 0, cpLen(lines[logRow] ?? '')),
+                        cursorCol: newLogicalCol,
                         preferredCol: newPreferredCol,
                     };
                 }
@@ -1116,18 +1260,35 @@ function textBufferReducerLogic(state, action, options = {}) {
             return handleVimAction(state, action);
         default: {
             const exhaustiveCheck = action;
-            console.error(`Unknown action encountered: ${exhaustiveCheck}`);
+            debugLogger.error(`Unknown action encountered: ${exhaustiveCheck}`);
             return state;
         }
     }
 }
 export function textBufferReducer(state, action, options = {}) {
     const newState = textBufferReducerLogic(state, action, options);
+    const newTransformedLines = newState.lines !== state.lines
+        ? calculateTransformations(newState.lines)
+        : state.transformationsByLine;
+    const oldTransform = getTransformUnderCursor(state.cursorRow, state.cursorCol, state.transformationsByLine);
+    const newTransform = getTransformUnderCursor(newState.cursorRow, newState.cursorCol, newTransformedLines);
+    const oldInside = oldTransform !== null;
+    const newInside = newTransform !== null;
+    const movedBetweenTransforms = oldTransform !== newTransform &&
+        (oldTransform !== null || newTransform !== null);
     if (newState.lines !== state.lines ||
-        newState.viewportWidth !== state.viewportWidth) {
+        newState.viewportWidth !== state.viewportWidth ||
+        oldInside !== newInside ||
+        movedBetweenTransforms) {
+        const shouldResetPreferred = oldInside !== newInside || movedBetweenTransforms;
         return {
             ...newState,
-            visualLayout: calculateLayout(newState.lines, newState.viewportWidth),
+            preferredCol: shouldResetPreferred ? null : newState.preferredCol,
+            visualLayout: calculateLayout(newState.lines, newState.viewportWidth, [
+                newState.cursorRow,
+                newState.cursorCol,
+            ]),
+            transformationsByLine: newTransformedLines,
         };
     }
     return newState;
@@ -1137,11 +1298,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     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);
+        const transformationsByLine = calculateTransformations(lines.length === 0 ? [''] : lines);
+        const visualLayout = calculateLayout(lines.length === 0 ? [''] : lines, viewport.width, [initialCursorRow, initialCursorCol]);
         return {
             lines: lines.length === 0 ? [''] : lines,
             cursorRow: initialCursorRow,
             cursorCol: initialCursorCol,
+            transformationsByLine,
             preferredCol: null,
             undoStack: [],
             redoStack: [],
@@ -1153,10 +1316,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         };
     }, [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, } = state;
+    const { lines, cursorRow, cursorCol, preferredCol, selectionAnchor, visualLayout, transformationsByLine, } = state;
     const text = useMemo(() => lines.join('\n'), [lines]);
     const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
-    const { visualLines, visualToLogicalMap } = visualLayout;
+    const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
     const [visualScrollRow, setVisualScrollRow] = useState(0);
     useEffect(() => {
         if (onChange) {
@@ -1383,7 +1546,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             dispatch({ type: 'set_text', payload: newText, pushToUndo: false });
         }
         catch (err) {
-            console.error('[useTextBuffer] external editor error', err);
+            coreEvents.emitFeedback('error', '[useTextBuffer] external editor error', err);
         }
         finally {
             coreEvents.emit(CoreEvent.ExternalEditorClosed);
@@ -1494,12 +1657,16 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         dispatch({ type: 'move_to_offset', payload: { offset } });
     }, []);
     const moveToVisualPosition = useCallback((visRow, visCol) => {
-        const { visualLines, visualToLogicalMap } = visualLayout;
+        const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
         // Clamp visRow to valid range
         const clampedVisRow = Math.max(0, Math.min(visRow, visualLines.length - 1));
         const visualLine = visualLines[clampedVisRow] || '';
         if (visualToLogicalMap[clampedVisRow]) {
-            const [logRow, logStartCol] = visualToLogicalMap[clampedVisRow];
+            const [logRow] = visualToLogicalMap[clampedVisRow];
+            const transformedToLogicalMap = transformedToLogicalMaps?.[logRow] ?? [];
+            // Where does this visual line begin within the transformed line?
+            const startColInTransformed = visualToTransformedMap?.[clampedVisRow] ?? 0;
+            // Handle wide characters: convert visual X position to character offset
             const codePoints = toCodePoints(visualLine);
             let currentVisX = 0;
             let charOffset = 0;
@@ -1518,8 +1685,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             }
             // Clamp charOffset to length
             charOffset = Math.min(charOffset, codePoints.length);
+            // Map character offset through transformations to get logical position
+            const transformedCol = Math.min(startColInTransformed + charOffset, Math.max(0, transformedToLogicalMap.length - 1));
             const newCursorRow = logRow;
-            const newCursorCol = logStartCol + charOffset;
+            const newCursorCol = transformedToLogicalMap[transformedCol] ?? cpLen(lines[logRow] ?? '');
             dispatch({
                 type: 'set_cursor',
                 payload: {
@@ -1529,7 +1698,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
                 },
             });
         }
-    }, [visualLayout]);
+    }, [visualLayout, lines]);
     const getOffset = useCallback(() => logicalPosToOffset(lines, cursorRow, cursorCol), [lines, cursorRow, cursorCol]);
     const returnValue = useMemo(() => ({
         lines,
@@ -1542,6 +1711,9 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         visualCursor,
         visualScrollRow,
         visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+        transformationsByLine,
         setText,
         insert,
         newline,
@@ -1605,6 +1777,10 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         renderedVisualLines,
         visualCursor,
         visualScrollRow,
+        visualToLogicalMap,
+        transformedToLogicalMaps,
+        visualToTransformedMap,
+        transformationsByLine,
         setText,
         insert,
         newline,
@@ -1656,7 +1832,6 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveToLastLine,
         vimMoveToLine,
         vimEscapeInsertMode,
-        visualToLogicalMap,
     ]);
     return returnValue;
 }