@abacus-ai/cli 2.0.0-canary.1 → 2.0.0-canary.11

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

@@ -1,732 +0,0 @@
-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;
-    }
-  }
-}