@machina.ai/cell-cli 1.33.0-rc1 → 1.38.1-rc1

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

@@ -3,23 +3,28 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-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 { LRUCache } from 'mnemonist';
-import { coreEvents, CoreEvent, debugLogger, unescapePath, getEditorCommand, isGuiEditor, } from '@google/gemini-cli-core';
+import { coreEvents, debugLogger, unescapePath, } from '@google/gemini-cli-core';
 import { toCodePoints, cpLen, cpSlice, stripUnsafeCharacters, getCachedStringWidth, } from '../../utils/textUtils.js';
 import { parsePastedPaths } from '../../utils/clipboardUtils.js';
-import { keyMatchers, Command } from '../../keyMatchers.js';
+import { Command } from '../../key/keyMatchers.js';
 import { handleVimAction } from './vim-buffer-actions.js';
 import { LRU_BUFFER_PERF_CACHE_LIMIT } from '../../constants.js';
+import { openFileInEditor } from '../../utils/editorUtils.js';
+import { useKeyMatchers } from '../../hooks/useKeyMatchers.js';
 export const LARGE_PASTE_LINE_THRESHOLD = 5;
 export 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;
+// Replace paste placeholder strings with their actual pasted content.
+export function expandPastePlaceholders(text, pastedContent) {
+    return text.replace(PASTED_TEXT_PLACEHOLDER_REGEX, (match) => pastedContent[match] || match);
+}
 // 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);
@@ -1093,6 +1098,39 @@ function generatePastedTextId(content, lineCount, pastedContent) {
     }
     return id;
 }
+function collectPlaceholderIdsFromLines(lines) {
+    const ids = new Set();
+    const pasteRegex = new RegExp(PASTED_TEXT_PLACEHOLDER_REGEX.source, 'g');
+    for (const line of lines) {
+        if (!line)
+            continue;
+        for (const match of line.matchAll(pasteRegex)) {
+            const placeholderId = match[0];
+            if (placeholderId) {
+                ids.add(placeholderId);
+            }
+        }
+    }
+    return ids;
+}
+function pruneOrphanedPastedContent(pastedContent, expandedPasteId, beforeChangedLines, allLines) {
+    if (Object.keys(pastedContent).length === 0)
+        return pastedContent;
+    const beforeIds = collectPlaceholderIdsFromLines(beforeChangedLines);
+    if (beforeIds.size === 0)
+        return pastedContent;
+    const afterIds = collectPlaceholderIdsFromLines(allLines);
+    const removedIds = [...beforeIds].filter((id) => !afterIds.has(id) && id !== expandedPasteId);
+    if (removedIds.length === 0)
+        return pastedContent;
+    const pruned = { ...pastedContent };
+    for (const id of removedIds) {
+        if (pruned[id]) {
+            delete pruned[id];
+        }
+    }
+    return pruned;
+}
 function textBufferReducerLogic(state, action, options = {}) {
     const pushUndoLocal = pushUndo;
     const currentLine = (r) => state.lines[r] ?? '';
@@ -1508,8 +1546,10 @@ function textBufferReducerLogic(state, action, options = {}) {
             const newLines = [...nextState.lines];
             let newCursorRow = cursorRow;
             let newCursorCol = cursorCol;
+            let beforeChangedLines = [];
             if (newCursorCol > 0) {
                 const lineContent = currentLine(newCursorRow);
+                beforeChangedLines = [lineContent];
                 const prevWordStart = findPrevWordStartInLine(lineContent, newCursorCol);
                 const start = prevWordStart === null ? 0 : prevWordStart;
                 newLines[newCursorRow] =
@@ -1520,18 +1560,21 @@ function textBufferReducerLogic(state, action, options = {}) {
                 // Act as a backspace
                 const prevLineContent = currentLine(cursorRow - 1);
                 const currentLineContentVal = currentLine(cursorRow);
+                beforeChangedLines = [prevLineContent, currentLineContentVal];
                 const newCol = cpLen(prevLineContent);
                 newLines[cursorRow - 1] = prevLineContent + currentLineContentVal;
                 newLines.splice(cursorRow, 1);
                 newCursorRow--;
                 newCursorCol = newCol;
             }
+            const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
             return {
                 ...nextState,
                 lines: newLines,
                 cursorRow: newCursorRow,
                 cursorCol: newCursorCol,
                 preferredCol: null,
+                pastedContent: newPastedContent,
             };
         }
         case 'delete_word_right': {
@@ -1545,22 +1588,27 @@ function textBufferReducerLogic(state, action, options = {}) {
             }
             const nextState = currentState;
             const newLines = [...nextState.lines];
+            let beforeChangedLines = [];
             if (cursorCol >= lineLen) {
                 // Act as a delete, joining with the next line
                 const nextLineContent = currentLine(cursorRow + 1);
+                beforeChangedLines = [lineContent, nextLineContent];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
             }
             else {
+                beforeChangedLines = [lineContent];
                 const nextWordStart = findNextWordStartInLine(lineContent, cursorCol);
                 const end = nextWordStart === null ? lineLen : nextWordStart;
                 newLines[cursorRow] =
                     cpSlice(lineContent, 0, cursorCol) + cpSlice(lineContent, end);
             }
+            const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
             return {
                 ...nextState,
                 lines: newLines,
                 preferredCol: null,
+                pastedContent: newPastedContent,
             };
         }
         case 'kill_line_right': {
@@ -1571,10 +1619,14 @@ function textBufferReducerLogic(state, action, options = {}) {
             if (cursorCol < currentLineLen(cursorRow)) {
                 const nextState = currentState;
                 const newLines = [...nextState.lines];
+                const beforeChangedLines = [lineContent];
                 newLines[cursorRow] = cpSlice(lineContent, 0, cursorCol);
+                const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
                 return {
                     ...nextState,
                     lines: newLines,
+                    preferredCol: null,
+                    pastedContent: newPastedContent,
                 };
             }
             else if (cursorRow < lines.length - 1) {
@@ -1582,12 +1634,15 @@ function textBufferReducerLogic(state, action, options = {}) {
                 const nextState = currentState;
                 const nextLineContent = currentLine(cursorRow + 1);
                 const newLines = [...nextState.lines];
+                const beforeChangedLines = [lineContent, nextLineContent];
                 newLines[cursorRow] = lineContent + nextLineContent;
                 newLines.splice(cursorRow + 1, 1);
+                const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
                 return {
                     ...nextState,
                     lines: newLines,
                     preferredCol: null,
+                    pastedContent: newPastedContent,
                 };
             }
             return currentState;
@@ -1600,12 +1655,15 @@ function textBufferReducerLogic(state, action, options = {}) {
                 const nextState = currentState;
                 const lineContent = currentLine(cursorRow);
                 const newLines = [...nextState.lines];
+                const beforeChangedLines = [lineContent];
                 newLines[cursorRow] = cpSlice(lineContent, cursorCol);
+                const newPastedContent = pruneOrphanedPastedContent(nextState.pastedContent, nextState.expandedPaste?.id ?? null, beforeChangedLines, newLines);
                 return {
                     ...nextState,
                     lines: newLines,
                     cursorCol: 0,
                     preferredCol: null,
+                    pastedContent: newPastedContent,
                 };
             }
             return currentState;
@@ -1693,6 +1751,7 @@ function textBufferReducerLogic(state, action, options = {}) {
         case 'vim_delete_line':
         case 'vim_change_line':
         case 'vim_delete_to_end_of_line':
+        case 'vim_delete_to_start_of_line':
         case 'vim_change_to_end_of_line':
         case 'vim_change_movement':
         case 'vim_move_left':
@@ -1719,6 +1778,26 @@ function textBufferReducerLogic(state, action, options = {}) {
         case 'vim_move_to_last_line':
         case 'vim_move_to_line':
         case 'vim_escape_insert_mode':
+        case 'vim_delete_to_first_nonwhitespace':
+        case 'vim_change_to_start_of_line':
+        case 'vim_change_to_first_nonwhitespace':
+        case 'vim_delete_to_first_line':
+        case 'vim_delete_to_last_line':
+        case 'vim_delete_char_before':
+        case 'vim_toggle_case':
+        case 'vim_replace_char':
+        case 'vim_find_char_forward':
+        case 'vim_find_char_backward':
+        case 'vim_delete_to_char_forward':
+        case 'vim_delete_to_char_backward':
+        case 'vim_yank_line':
+        case 'vim_yank_word_forward':
+        case 'vim_yank_big_word_forward':
+        case 'vim_yank_word_end':
+        case 'vim_yank_big_word_end':
+        case 'vim_yank_to_end_of_line':
+        case 'vim_paste_after':
+        case 'vim_paste_before':
             return handleVimAction(state, action);
         case 'toggle_paste_expansion': {
             const { id, row, col } = action.payload;
@@ -1877,6 +1956,7 @@ export function textBufferReducer(state, action, options = {}) {
 }
 // --- End of reducer logic ---
 export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewport, stdin, setRawMode, onChange, escapePastedPaths = false, shellModeActive = false, inputFilter, singleLine = false, getPreferredEditor, }) {
+    const keyMatchers = useKeyMatchers();
     const initialState = useMemo(() => {
         const lines = initialText.split('\n');
         const [initialCursorRow, initialCursorCol] = calculateInitialCursorPosition(lines.length === 0 ? [''] : lines, initialCursorOffset);
@@ -1897,6 +1977,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             visualLayout,
             pastedContent: {},
             expandedPaste: null,
+            yankRegister: null,
         };
     }, [initialText, initialCursorOffset, viewport.width, viewport.height]);
     const [state, dispatch] = useReducer((s, a) => textBufferReducer(s, a, { inputFilter, singleLine }), initialState);
@@ -1905,6 +1986,21 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const visualCursor = useMemo(() => calculateVisualCursorFromLayout(visualLayout, [cursorRow, cursorCol]), [visualLayout, cursorRow, cursorCol]);
     const { visualLines, visualToLogicalMap, transformedToLogicalMaps, visualToTransformedMap, } = visualLayout;
     const [scrollRowState, setScrollRowState] = useState(0);
+    const { height } = viewport;
+    const totalVisualLines = visualLines.length;
+    const maxScrollStart = Math.max(0, totalVisualLines - height);
+    let newVisualScrollRow = scrollRowState;
+    if (visualCursor[0] < scrollRowState) {
+        newVisualScrollRow = visualCursor[0];
+    }
+    else if (visualCursor[0] >= scrollRowState + height) {
+        newVisualScrollRow = visualCursor[0] - height + 1;
+    }
+    newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart);
+    if (newVisualScrollRow !== scrollRowState) {
+        setScrollRowState(newVisualScrollRow);
+    }
+    const actualScrollRowState = newVisualScrollRow;
     useEffect(() => {
         if (onChange) {
             onChange(text);
@@ -1916,25 +2012,6 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             payload: { width: viewport.width, height: viewport.height },
         });
     }, [viewport.width, viewport.height]);
-    // Update visual scroll (vertical)
-    useEffect(() => {
-        const { height } = viewport;
-        const totalVisualLines = visualLines.length;
-        const maxScrollStart = Math.max(0, totalVisualLines - height);
-        let newVisualScrollRow = scrollRowState;
-        if (visualCursor[0] < scrollRowState) {
-            newVisualScrollRow = visualCursor[0];
-        }
-        else if (visualCursor[0] >= scrollRowState + height) {
-            newVisualScrollRow = visualCursor[0] - height + 1;
-        }
-        // When the number of visual lines shrinks (e.g., after widening the viewport),
-        // ensure scroll never starts beyond the last valid start so we can render a full window.
-        newVisualScrollRow = clamp(newVisualScrollRow, 0, maxScrollStart);
-        if (newVisualScrollRow !== scrollRowState) {
-            setScrollRowState(newVisualScrollRow);
-        }
-    }, [visualCursor, scrollRowState, viewport, visualLines.length]);
     const insert = useCallback((ch, { paste = false } = {}) => {
         if (typeof ch !== 'string') {
             return;
@@ -1945,13 +2022,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             !shellModeActive &&
             paste &&
             escapePastedPaths) {
-            let potentialPath = ch.trim();
-            const quoteMatch = potentialPath.match(/^'(.*)'$/);
-            if (quoteMatch) {
-                potentialPath = quoteMatch[1];
-            }
-            potentialPath = potentialPath.trim();
-            const processed = parsePastedPaths(potentialPath);
+            const processed = parsePastedPaths(ch.trim());
             if (processed) {
                 textToInsert = processed;
             }
@@ -2052,11 +2123,29 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const vimChangeLine = useCallback((count) => {
         dispatch({ type: 'vim_change_line', payload: { count } });
     }, []);
-    const vimDeleteToEndOfLine = useCallback(() => {
-        dispatch({ type: 'vim_delete_to_end_of_line' });
+    const vimDeleteToEndOfLine = useCallback((count = 1) => {
+        dispatch({ type: 'vim_delete_to_end_of_line', payload: { count } });
+    }, []);
+    const vimDeleteToStartOfLine = useCallback(() => {
+        dispatch({ type: 'vim_delete_to_start_of_line' });
+    }, []);
+    const vimChangeToEndOfLine = useCallback((count = 1) => {
+        dispatch({ type: 'vim_change_to_end_of_line', payload: { count } });
+    }, []);
+    const vimDeleteToFirstNonWhitespace = useCallback(() => {
+        dispatch({ type: 'vim_delete_to_first_nonwhitespace' });
+    }, []);
+    const vimChangeToStartOfLine = useCallback(() => {
+        dispatch({ type: 'vim_change_to_start_of_line' });
+    }, []);
+    const vimChangeToFirstNonWhitespace = useCallback(() => {
+        dispatch({ type: 'vim_change_to_first_nonwhitespace' });
     }, []);
-    const vimChangeToEndOfLine = useCallback(() => {
-        dispatch({ type: 'vim_change_to_end_of_line' });
+    const vimDeleteToFirstLine = useCallback((count) => {
+        dispatch({ type: 'vim_delete_to_first_line', payload: { count } });
+    }, []);
+    const vimDeleteToLastLine = useCallback((count) => {
+        dispatch({ type: 'vim_delete_to_last_line', payload: { count } });
     }, []);
     const vimChangeMovement = useCallback((movement, count) => {
         dispatch({ type: 'vim_change_movement', payload: { movement, count } });
@@ -2095,6 +2184,39 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const vimDeleteChar = useCallback((count) => {
         dispatch({ type: 'vim_delete_char', payload: { count } });
     }, []);
+    const vimDeleteCharBefore = useCallback((count) => {
+        dispatch({ type: 'vim_delete_char_before', payload: { count } });
+    }, []);
+    const vimToggleCase = useCallback((count) => {
+        dispatch({ type: 'vim_toggle_case', payload: { count } });
+    }, []);
+    const vimReplaceChar = useCallback((char, count) => {
+        dispatch({ type: 'vim_replace_char', payload: { char, count } });
+    }, []);
+    const vimFindCharForward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_find_char_forward',
+            payload: { char, count, till },
+        });
+    }, []);
+    const vimFindCharBackward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_find_char_backward',
+            payload: { char, count, till },
+        });
+    }, []);
+    const vimDeleteToCharForward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_delete_to_char_forward',
+            payload: { char, count, till },
+        });
+    }, []);
+    const vimDeleteToCharBackward = useCallback((char, count, till) => {
+        dispatch({
+            type: 'vim_delete_to_char_backward',
+            payload: { char, count, till },
+        });
+    }, []);
     const vimInsertAtCursor = useCallback(() => {
         dispatch({ type: 'vim_insert_at_cursor' });
     }, []);
@@ -2134,39 +2256,39 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
     const vimEscapeInsertMode = useCallback(() => {
         dispatch({ type: 'vim_escape_insert_mode' });
     }, []);
+    const vimYankLine = useCallback((count) => {
+        dispatch({ type: 'vim_yank_line', payload: { count } });
+    }, []);
+    const vimYankWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_yank_word_forward', payload: { count } });
+    }, []);
+    const vimYankBigWordForward = useCallback((count) => {
+        dispatch({ type: 'vim_yank_big_word_forward', payload: { count } });
+    }, []);
+    const vimYankWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_yank_word_end', payload: { count } });
+    }, []);
+    const vimYankBigWordEnd = useCallback((count) => {
+        dispatch({ type: 'vim_yank_big_word_end', payload: { count } });
+    }, []);
+    const vimYankToEndOfLine = useCallback((count) => {
+        dispatch({ type: 'vim_yank_to_end_of_line', payload: { count } });
+    }, []);
+    const vimPasteAfter = useCallback((count) => {
+        dispatch({ type: 'vim_paste_after', payload: { count } });
+    }, []);
+    const vimPasteBefore = useCallback((count) => {
+        dispatch({ type: 'vim_paste_before', payload: { count } });
+    }, []);
     const openInExternalEditor = useCallback(async () => {
         const tmpDir = fs.mkdtempSync(pathMod.join(os.tmpdir(), 'gemini-edit-'));
         const filePath = pathMod.join(tmpDir, 'buffer.txt');
         // Expand paste placeholders so user sees full content in editor
-        const expandedText = text.replace(PASTED_TEXT_PLACEHOLDER_REGEX, (match) => pastedContent[match] || match);
+        const expandedText = expandPastePlaceholders(text, pastedContent);
         fs.writeFileSync(filePath, expandedText, 'utf8');
-        let command = undefined;
-        const args = [filePath];
-        const preferredEditorType = getPreferredEditor?.();
-        if (!command && preferredEditorType) {
-            command = getEditorCommand(preferredEditorType);
-            if (isGuiEditor(preferredEditorType)) {
-                args.unshift('--wait');
-            }
-        }
-        if (!command) {
-            command =
-                process.env['VISUAL'] ??
-                    process.env['EDITOR'] ??
-                    (process.platform === 'win32' ? 'notepad' : 'vi');
-        }
         dispatch({ type: 'create_undo_snapshot' });
-        const wasRaw = stdin?.isRaw ?? false;
         try {
-            setRawMode?.(false);
-            const { status, error } = spawnSync(command, args, {
-                stdio: 'inherit',
-                shell: process.platform === 'win32',
-            });
-            if (error)
-                throw error;
-            if (typeof status === 'number' && status !== 0)
-                throw new Error(`External editor exited with status ${status}`);
+            await openFileInEditor(filePath, stdin, setRawMode, getPreferredEditor?.());
             let newText = fs.readFileSync(filePath, 'utf8');
             newText = newText.replace(/\r\n?/g, '\n');
             // Attempt to re-collapse unchanged pasted content back into placeholders
@@ -2182,9 +2304,6 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
             coreEvents.emitFeedback('error', '[useTextBuffer] external editor error', err);
         }
         finally {
-            coreEvents.emit(CoreEvent.ExternalEditorClosed);
-            if (wasRaw)
-                setRawMode?.(true);
             try {
                 fs.unlinkSync(filePath);
             }
@@ -2321,11 +2440,12 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         text,
         visualCursor,
         visualLines,
+        keyMatchers,
     ]);
     const visualScrollRow = useMemo(() => {
         const totalVisualLines = visualLines.length;
-        return Math.min(scrollRowState, Math.max(0, totalVisualLines - viewport.height));
-    }, [visualLines.length, scrollRowState, viewport.height]);
+        return Math.min(actualScrollRowState, Math.max(0, totalVisualLines - viewport.height));
+    }, [visualLines.length, actualScrollRowState, viewport.height]);
     const renderedVisualLines = useMemo(() => visualLines.slice(visualScrollRow, visualScrollRow + viewport.height), [visualLines, visualScrollRow, viewport.height]);
     const replaceRange = useCallback((startRow, startCol, endRow, endCol, text) => {
         dispatch({
@@ -2433,6 +2553,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         viewportVisualLines: renderedVisualLines,
         visualCursor,
         visualScrollRow,
+        viewportHeight: viewport.height,
         visualToLogicalMap,
         transformedToLogicalMaps,
         visualToTransformedMap,
@@ -2477,7 +2598,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimDeleteLine,
         vimChangeLine,
         vimDeleteToEndOfLine,
+        vimDeleteToStartOfLine,
         vimChangeToEndOfLine,
+        vimDeleteToFirstNonWhitespace,
+        vimChangeToStartOfLine,
+        vimChangeToFirstNonWhitespace,
+        vimDeleteToFirstLine,
+        vimDeleteToLastLine,
         vimChangeMovement,
         vimMoveLeft,
         vimMoveRight,
@@ -2490,6 +2617,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveBigWordBackward,
         vimMoveBigWordEnd,
         vimDeleteChar,
+        vimDeleteCharBefore,
+        vimToggleCase,
+        vimReplaceChar,
+        vimFindCharForward,
+        vimFindCharBackward,
+        vimDeleteToCharForward,
+        vimDeleteToCharBackward,
         vimInsertAtCursor,
         vimAppendAtCursor,
         vimOpenLineBelow,
@@ -2503,6 +2637,14 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveToLastLine,
         vimMoveToLine,
         vimEscapeInsertMode,
+        vimYankLine,
+        vimYankWordForward,
+        vimYankBigWordForward,
+        vimYankWordEnd,
+        vimYankBigWordEnd,
+        vimYankToEndOfLine,
+        vimPasteAfter,
+        vimPasteBefore,
     }), [
         lines,
         text,
@@ -2515,6 +2657,7 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         renderedVisualLines,
         visualCursor,
         visualScrollRow,
+        viewport.height,
         visualToLogicalMap,
         transformedToLogicalMaps,
         visualToTransformedMap,
@@ -2558,7 +2701,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimDeleteLine,
         vimChangeLine,
         vimDeleteToEndOfLine,
+        vimDeleteToStartOfLine,
         vimChangeToEndOfLine,
+        vimDeleteToFirstNonWhitespace,
+        vimChangeToStartOfLine,
+        vimChangeToFirstNonWhitespace,
+        vimDeleteToFirstLine,
+        vimDeleteToLastLine,
         vimChangeMovement,
         vimMoveLeft,
         vimMoveRight,
@@ -2571,6 +2720,13 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveBigWordBackward,
         vimMoveBigWordEnd,
         vimDeleteChar,
+        vimDeleteCharBefore,
+        vimToggleCase,
+        vimReplaceChar,
+        vimFindCharForward,
+        vimFindCharBackward,
+        vimDeleteToCharForward,
+        vimDeleteToCharBackward,
         vimInsertAtCursor,
         vimAppendAtCursor,
         vimOpenLineBelow,
@@ -2584,6 +2740,14 @@ export function useTextBuffer({ initialText = '', initialCursorOffset = 0, viewp
         vimMoveToLastLine,
         vimMoveToLine,
         vimEscapeInsertMode,
+        vimYankLine,
+        vimYankWordForward,
+        vimYankBigWordForward,
+        vimYankWordEnd,
+        vimYankBigWordEnd,
+        vimYankToEndOfLine,
+        vimPasteAfter,
+        vimPasteBefore,
     ]);
     return returnValue;
 }