@abacus-ai/cli 1.106.25007 → 2.0.0-canary.0

package/src/lib/vim-buffer-actions.ts

@@ -0,0 +1,732 @@
+import {
+  findNextWordAcrossLines,
+  findPrevWordAcrossLines,
+  findWordEndInLine,
+  getLineRangeOffsets,
+  getPositionFromOffsets,
+  isCombiningMark,
+  isWordCharStrict,
+  isWordCharWithCombining,
+  pushUndo,
+  replaceRangeInternal,
+  TextBufferAction,
+  TextBufferState,
+} from "./text-buffer.js";
+import { cpLen, toCodePoints } from "./text-utils.js";
+
+/* Fail to compile on unexpected values. */
+export function assumeExhaustive(_value: never): void {}
+
+// Check if we're at the end of a base word (on the last base character)
+// Returns true if current position has a base character followed only by combining marks until non-word
+function isAtEndOfBaseWord(lineCodePoints: string[], col: number): boolean {
+  if (!isWordCharStrict(lineCodePoints[col])) {
+    return false;
+  }
+
+  // Look ahead to see if we have only combining marks followed by non-word
+  let i = col + 1;
+
+  // Skip any combining marks
+  while (i < lineCodePoints.length && isCombiningMark(lineCodePoints[i])) {
+    i++;
+  }
+
+  // If we hit end of line or non-word character, we were at end of base word
+  return i >= lineCodePoints.length || !isWordCharStrict(lineCodePoints[i]);
+}
+
+export type VimAction = Extract<
+  TextBufferAction,
+  | { type: "vim_delete_word_forward" }
+  | { type: "vim_delete_word_backward" }
+  | { type: "vim_delete_word_end" }
+  | { type: "vim_change_word_forward" }
+  | { type: "vim_change_word_backward" }
+  | { type: "vim_change_word_end" }
+  | { type: "vim_delete_line" }
+  | { type: "vim_change_line" }
+  | { type: "vim_delete_to_end_of_line" }
+  | { type: "vim_change_to_end_of_line" }
+  | { type: "vim_change_movement" }
+  | { type: "vim_move_left" }
+  | { type: "vim_move_right" }
+  | { type: "vim_move_up" }
+  | { type: "vim_move_down" }
+  | { type: "vim_move_word_forward" }
+  | { type: "vim_move_word_backward" }
+  | { type: "vim_move_word_end" }
+  | { type: "vim_delete_char" }
+  | { type: "vim_insert_at_cursor" }
+  | { type: "vim_append_at_cursor" }
+  | { type: "vim_open_line_below" }
+  | { type: "vim_open_line_above" }
+  | { type: "vim_append_at_line_end" }
+  | { type: "vim_insert_at_line_start" }
+  | { type: "vim_move_to_line_start" }
+  | { type: "vim_move_to_line_end" }
+  | { type: "vim_move_to_first_nonwhitespace" }
+  | { type: "vim_move_to_first_line" }
+  | { type: "vim_move_to_last_line" }
+  | { type: "vim_move_to_line" }
+  | { type: "vim_escape_insert_mode" }
+>;
+
+export function handleVimAction(state: TextBufferState, action: VimAction): TextBufferState {
+  const { lines, cursorRow, cursorCol } = state;
+
+  switch (action.type) {
+    case "vim_delete_word_forward":
+    case "vim_change_word_forward": {
+      const { count } = action.payload;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const nextWord = findNextWordAcrossLines(lines, endRow, endCol, true);
+        if (nextWord) {
+          endRow = nextWord.row;
+          endCol = nextWord.col;
+        } else {
+          // No more words, delete/change to end of current word or line
+          const currentLine = lines[endRow] || "";
+          const wordEnd = findWordEndInLine(currentLine, endCol);
+          if (wordEnd !== null) {
+            endCol = wordEnd + 1; // Include the character at word end
+          } else {
+            endCol = cpLen(currentLine);
+          }
+          break;
+        }
+      }
+
+      if (endRow !== cursorRow || endCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(nextState, cursorRow, cursorCol, endRow, endCol, "");
+      }
+      return state;
+    }
+
+    case "vim_delete_word_backward":
+    case "vim_change_word_backward": {
+      const { count } = action.payload;
+      let startRow = cursorRow;
+      let startCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const prevWord = findPrevWordAcrossLines(lines, startRow, startCol);
+        if (prevWord) {
+          startRow = prevWord.row;
+          startCol = prevWord.col;
+        } else {
+          break;
+        }
+      }
+
+      if (startRow !== cursorRow || startCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(nextState, startRow, startCol, cursorRow, cursorCol, "");
+      }
+      return state;
+    }
+
+    case "vim_delete_word_end":
+    case "vim_change_word_end": {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+      let endRow = cursorRow;
+      let endCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          endRow = wordEnd.row;
+          endCol = wordEnd.col + 1; // Include the character at word end
+          // For next iteration, move to start of next word
+          if (i < count - 1) {
+            const nextWord = findNextWordAcrossLines(lines, wordEnd.row, wordEnd.col + 1, true);
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+            } else {
+              break; // No more words
+            }
+          }
+        } else {
+          break;
+        }
+      }
+
+      // Ensure we don't go past the end of the last line
+      if (endRow < lines.length) {
+        const lineLen = cpLen(lines[endRow] || "");
+        endCol = Math.min(endCol, lineLen);
+      }
+
+      if (endRow !== cursorRow || endCol !== cursorCol) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(nextState, cursorRow, cursorCol, endRow, endCol, "");
+      }
+      return state;
+    }
+
+    case "vim_delete_line": {
+      const { count } = action.payload;
+      if (lines.length === 0) {
+        return state;
+      }
+
+      const linesToDelete = Math.min(count, lines.length - cursorRow);
+      const totalLines = lines.length;
+
+      if (totalLines === 1 || linesToDelete >= totalLines) {
+        // If there's only one line, or we're deleting all remaining lines,
+        // clear the content but keep one empty line (text editors should never be completely empty)
+        const nextState = pushUndo(state);
+        return {
+          ...nextState,
+          lines: [""],
+          cursorRow: 0,
+          cursorCol: 0,
+          preferredCol: null,
+        };
+      }
+
+      const nextState = pushUndo(state);
+      const newLines = [...nextState.lines];
+      newLines.splice(cursorRow, linesToDelete);
+
+      // Adjust cursor position
+      const newCursorRow = Math.min(cursorRow, newLines.length - 1);
+      const newCursorCol = 0; // Vim places cursor at beginning of line after dd
+
+      return {
+        ...nextState,
+        lines: newLines,
+        cursorRow: newCursorRow,
+        cursorCol: newCursorCol,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_change_line": {
+      const { count } = action.payload;
+      if (lines.length === 0) {
+        return state;
+      }
+
+      const linesToChange = Math.min(count, lines.length - cursorRow);
+      const nextState = pushUndo(state);
+
+      const { startOffset, endOffset } = getLineRangeOffsets(
+        cursorRow,
+        linesToChange,
+        nextState.lines,
+      );
+      const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
+        startOffset,
+        endOffset,
+        nextState.lines,
+      );
+      return replaceRangeInternal(nextState, startRow, startCol, endRow, endCol, "");
+    }
+
+    case "vim_delete_to_end_of_line":
+    case "vim_change_to_end_of_line": {
+      const currentLine = lines[cursorRow] || "";
+      if (cursorCol < cpLen(currentLine)) {
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          cursorRow,
+          cpLen(currentLine),
+          "",
+        );
+      }
+      return state;
+    }
+
+    case "vim_change_movement": {
+      const { movement, count } = action.payload;
+      const totalLines = lines.length;
+
+      switch (movement) {
+        case "h": {
+          // Left
+          // Change N characters to the left
+          const startCol = Math.max(0, cursorCol - count);
+          return replaceRangeInternal(
+            pushUndo(state),
+            cursorRow,
+            startCol,
+            cursorRow,
+            cursorCol,
+            "",
+          );
+        }
+
+        case "j": {
+          // Down
+          const linesToChange = Math.min(count, totalLines - cursorRow);
+          if (linesToChange > 0) {
+            if (totalLines === 1) {
+              const currentLine = state.lines[0] || "";
+              return replaceRangeInternal(pushUndo(state), 0, 0, 0, cpLen(currentLine), "");
+            } else {
+              const nextState = pushUndo(state);
+              const { startOffset, endOffset } = getLineRangeOffsets(
+                cursorRow,
+                linesToChange,
+                nextState.lines,
+              );
+              const { startRow, startCol, endRow, endCol } = getPositionFromOffsets(
+                startOffset,
+                endOffset,
+                nextState.lines,
+              );
+              return replaceRangeInternal(nextState, startRow, startCol, endRow, endCol, "");
+            }
+          }
+          return state;
+        }
+
+        case "k": {
+          // Up
+          const upLines = Math.min(count, cursorRow + 1);
+          if (upLines > 0) {
+            if (state.lines.length === 1) {
+              const currentLine = state.lines[0] || "";
+              return replaceRangeInternal(pushUndo(state), 0, 0, 0, cpLen(currentLine), "");
+            } else {
+              const startRow = Math.max(0, cursorRow - count + 1);
+              const linesToChange = cursorRow - startRow + 1;
+              const nextState = pushUndo(state);
+              const { startOffset, endOffset } = getLineRangeOffsets(
+                startRow,
+                linesToChange,
+                nextState.lines,
+              );
+              const {
+                startRow: newStartRow,
+                startCol,
+                endRow,
+                endCol,
+              } = getPositionFromOffsets(startOffset, endOffset, nextState.lines);
+              const resultState = replaceRangeInternal(
+                nextState,
+                newStartRow,
+                startCol,
+                endRow,
+                endCol,
+                "",
+              );
+              return {
+                ...resultState,
+                cursorRow: startRow,
+                cursorCol: 0,
+              };
+            }
+          }
+          return state;
+        }
+
+        case "l": {
+          // Right
+          // Change N characters to the right
+          return replaceRangeInternal(
+            pushUndo(state),
+            cursorRow,
+            cursorCol,
+            cursorRow,
+            Math.min(cpLen(lines[cursorRow] || ""), cursorCol + count),
+            "",
+          );
+        }
+
+        default:
+          return state;
+      }
+    }
+
+    case "vim_move_left": {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      let newRow = cursorRow;
+      let newCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        if (newCol > 0) {
+          newCol--;
+        } else if (newRow > 0) {
+          // Move to end of previous line
+          newRow--;
+          const prevLine = lines[newRow] || "";
+          const prevLineLength = cpLen(prevLine);
+          // Position on last character, or column 0 for empty lines
+          newCol = prevLineLength === 0 ? 0 : prevLineLength - 1;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_right": {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      let newRow = cursorRow;
+      let newCol = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const currentLine = lines[newRow] || "";
+        const lineLength = cpLen(currentLine);
+        // Don't move past the last character of the line
+        // For empty lines, stay at column 0; for non-empty lines, don't go past last character
+        if (lineLength === 0) {
+          // Empty line - try to move to next line
+          if (newRow < lines.length - 1) {
+            newRow++;
+            newCol = 0;
+          }
+        } else if (newCol < lineLength - 1) {
+          newCol++;
+
+          // Skip over combining marks - don't let cursor land on them
+          const currentLinePoints = toCodePoints(currentLine);
+          while (
+            newCol < currentLinePoints.length &&
+            isCombiningMark(currentLinePoints[newCol]) &&
+            newCol < lineLength - 1
+          ) {
+            newCol++;
+          }
+        } else if (newRow < lines.length - 1) {
+          // At end of line - move to beginning of next line
+          newRow++;
+          newCol = 0;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_up": {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const newRow = Math.max(0, cursorRow - count);
+      const targetLine = lines[newRow] || "";
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(cursorCol, targetLineLength > 0 ? targetLineLength - 1 : 0);
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_down": {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const newRow = Math.min(lines.length - 1, cursorRow + count);
+      const targetLine = lines[newRow] || "";
+      const targetLineLength = cpLen(targetLine);
+      const newCol = Math.min(cursorCol, targetLineLength > 0 ? targetLineLength - 1 : 0);
+
+      return {
+        ...state,
+        cursorRow: newRow,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_word_forward": {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const nextWord = findNextWordAcrossLines(lines, row, col, true);
+        if (nextWord) {
+          row = nextWord.row;
+          col = nextWord.col;
+        } else {
+          // No more words to move to
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_word_backward": {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        const prevWord = findPrevWordAcrossLines(lines, row, col);
+        if (prevWord) {
+          row = prevWord.row;
+          col = prevWord.col;
+        } else {
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_word_end": {
+      const { count } = action.payload;
+      let row = cursorRow;
+      let col = cursorCol;
+
+      for (let i = 0; i < count; i++) {
+        // Special handling for the first iteration when we're at end of word
+        if (i === 0) {
+          const currentLine = lines[row] || "";
+          const lineCodePoints = toCodePoints(currentLine);
+
+          // Check if we're at the end of a word (on the last base character)
+          const atEndOfWord =
+            col < lineCodePoints.length &&
+            isWordCharStrict(lineCodePoints[col]) &&
+            (col + 1 >= lineCodePoints.length ||
+              !isWordCharWithCombining(lineCodePoints[col + 1]) ||
+              // Or if we're on a base char followed only by combining marks until non-word
+              (isWordCharStrict(lineCodePoints[col]) && isAtEndOfBaseWord(lineCodePoints, col)));
+
+          if (atEndOfWord) {
+            // We're already at end of word, find next word end
+            const nextWord = findNextWordAcrossLines(lines, row, col + 1, false);
+            if (nextWord) {
+              row = nextWord.row;
+              col = nextWord.col;
+              continue;
+            }
+          }
+        }
+
+        const wordEnd = findNextWordAcrossLines(lines, row, col, false);
+        if (wordEnd) {
+          row = wordEnd.row;
+          col = wordEnd.col;
+        } else {
+          break;
+        }
+      }
+
+      return {
+        ...state,
+        cursorRow: row,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_delete_char": {
+      const { count } = action.payload;
+      const { cursorRow, cursorCol, lines } = state;
+      const currentLine = lines[cursorRow] || "";
+      const lineLength = cpLen(currentLine);
+
+      if (cursorCol < lineLength) {
+        const deleteCount = Math.min(count, lineLength - cursorCol);
+        const nextState = pushUndo(state);
+        return replaceRangeInternal(
+          nextState,
+          cursorRow,
+          cursorCol,
+          cursorRow,
+          cursorCol + deleteCount,
+          "",
+        );
+      }
+      return state;
+    }
+
+    case "vim_insert_at_cursor": {
+      // Just return state - mode change is handled elsewhere
+      return state;
+    }
+
+    case "vim_append_at_cursor": {
+      const { cursorRow, cursorCol, lines } = state;
+      const currentLine = lines[cursorRow] || "";
+      const newCol = cursorCol < cpLen(currentLine) ? cursorCol + 1 : cursorCol;
+
+      return {
+        ...state,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_open_line_below": {
+      const { cursorRow, lines } = state;
+      const nextState = pushUndo(state);
+
+      // Insert newline at end of current line
+      const endOfLine = cpLen(lines[cursorRow] || "");
+      return replaceRangeInternal(nextState, cursorRow, endOfLine, cursorRow, endOfLine, "\n");
+    }
+
+    case "vim_open_line_above": {
+      const { cursorRow } = state;
+      const nextState = pushUndo(state);
+
+      // Insert newline at beginning of current line
+      const resultState = replaceRangeInternal(nextState, cursorRow, 0, cursorRow, 0, "\n");
+
+      // Move cursor to the new line above
+      return {
+        ...resultState,
+        cursorRow,
+        cursorCol: 0,
+      };
+    }
+
+    case "vim_append_at_line_end": {
+      const { cursorRow, lines } = state;
+      const lineLength = cpLen(lines[cursorRow] || "");
+
+      return {
+        ...state,
+        cursorCol: lineLength,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_insert_at_line_start": {
+      const { cursorRow, lines } = state;
+      const currentLine = lines[cursorRow] || "";
+      let col = 0;
+
+      // Find first non-whitespace character using proper Unicode handling
+      const lineCodePoints = toCodePoints(currentLine);
+      while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
+        col++;
+      }
+
+      return {
+        ...state,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_to_line_start": {
+      return {
+        ...state,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_to_line_end": {
+      const { cursorRow, lines } = state;
+      const lineLength = cpLen(lines[cursorRow] || "");
+
+      return {
+        ...state,
+        cursorCol: lineLength > 0 ? lineLength - 1 : 0,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_to_first_nonwhitespace": {
+      const { cursorRow, lines } = state;
+      const currentLine = lines[cursorRow] || "";
+      let col = 0;
+
+      // Find first non-whitespace character using proper Unicode handling
+      const lineCodePoints = toCodePoints(currentLine);
+      while (col < lineCodePoints.length && /\s/.test(lineCodePoints[col])) {
+        col++;
+      }
+
+      return {
+        ...state,
+        cursorCol: col,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_to_first_line": {
+      return {
+        ...state,
+        cursorRow: 0,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_to_last_line": {
+      const { lines } = state;
+      const lastRow = lines.length - 1;
+
+      return {
+        ...state,
+        cursorRow: lastRow,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_move_to_line": {
+      const { lineNumber } = action.payload;
+      const { lines } = state;
+      const targetRow = Math.min(Math.max(0, lineNumber - 1), lines.length - 1);
+
+      return {
+        ...state,
+        cursorRow: targetRow,
+        cursorCol: 0,
+        preferredCol: null,
+      };
+    }
+
+    case "vim_escape_insert_mode": {
+      // Move cursor left if not at beginning of line (vim behavior when exiting insert mode)
+      const { cursorCol } = state;
+      const newCol = cursorCol > 0 ? cursorCol - 1 : 0;
+
+      return {
+        ...state,
+        cursorCol: newCol,
+        preferredCol: null,
+      };
+    }
+
+    default: {
+      // This should never happen if TypeScript is working correctly
+      assumeExhaustive(action);
+      return state;
+    }
+  }
+}