🤖 Fix: Vim 'e' motion and add '_' motion (#116)

Fixes two Vim mode bugs using TDD:

## Bug 1: `e` only jumps to end of current word
When cursor was at the end of a word, pressing `e` would not move to the
next word.

**Before:**
- Text: `hello world`
- Cursor on 'o' (end of "hello")
- Press `e` → stays at 'o' ❌

**After:**
- Cursor moves to 'd' (end of "world") ✅

## Bug 2: `_` motion not implemented
The `_` motion (jump to first non-whitespace character) was missing.

**Now supported:**
- `_` - Jump to first non-whitespace character
- `d_` - Delete to first non-whitespace character
- `c_` - Change to first non-whitespace character
- `y_` - Yank to first non-whitespace character

## Implementation Details

**TDD Approach:**
1. ✅ Wrote 6 failing tests first
2. ✅ Implemented fixes
3. ✅ All 45 tests passing

**Changes:**
- Fixed `moveWordEnd()` to detect when at end of word
- Added `moveToFirstNonWhitespace()` helper
- Wired up `_` motion in navigation and operator handlers
- Updated documentation

## Testing
```
45 pass
0 fail
81 expect() calls
```

_Generated with `cmux`_

---------

Co-authored-by: Ammar Bandukwala <ammar@ammar.io>

Author: ammar-agent

docs/vim-mode.md

@@ -48,6 +48,7 @@ Vim mode is always enabled. Press **ESC** to enter normal mode from insert mode.
 ### Line Movement
 
 - **0** - Move to beginning of line
+- **_** - Move to first non-whitespace character of line
 - **$** - Move to end of line
 - **Home** - Same as **0**
 - **End** - Same as **$**
@@ -101,6 +102,7 @@ Vim's power comes from combining operators with motions. All operators work with
 - **e** - To end of word
 - **$** - To end of line
 - **0** - To beginning of line
+- **_** - To first non-whitespace character
 
 ### Examples
 

src/utils/vim.test.ts

@@ -442,5 +442,77 @@ describe("Vim Command Integration Tests", () => {
       expect(state.text).toBe("h world");
       expect(state.mode).toBe("insert");
     });
+
+    test("e at end of word moves to end of next word", () => {
+      // Bug: when cursor is at end of word, 'e' should move to end of next word
+      const state = executeVimCommands(
+        { ...initialState, text: "hello world foo", cursor: 4, mode: "normal" }, // cursor on 'o' (end of "hello")
+        ["e"]
+      );
+      expect(state.cursor).toBe(10); // Should move to end of "world" (not stay at 4)
+    });
+
+    test("e at end of word with punctuation moves correctly", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "hello, world", cursor: 4, mode: "normal" }, // cursor on 'o' (end of "hello")
+        ["e"]
+      );
+      expect(state.cursor).toBe(11); // Should move to end of "world"
+    });
+  });
+
+  describe("_ motion (first non-whitespace character)", () => {
+    test("_ moves to first non-whitespace character", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "  hello world", cursor: 10, mode: "normal" },
+        ["_"]
+      );
+      expect(state.cursor).toBe(2); // Should move to 'h' (first non-whitespace)
+    });
+
+    test("_ on line with no leading whitespace goes to position 0", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "hello world", cursor: 6, mode: "normal" },
+        ["_"]
+      );
+      expect(state.cursor).toBe(0); // Should move to start of line
+    });
+
+    test("_ with tabs and spaces", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "\t  hello", cursor: 5, mode: "normal" },
+        ["_"]
+      );
+      expect(state.cursor).toBe(3); // Should move to 'h' after tab and spaces
+    });
+
+    test("d_ deletes entire line and newline (linewise motion)", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "  hello world\nnext", cursor: 10, mode: "normal" },
+        ["d", "_"]
+      );
+      expect(state.text).toBe("next"); // Entire current line removed (including newline)
+      expect(state.cursor).toBe(0);
+    });
+
+    test("c_ changes entire line like cc", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "  hello world\nnext", cursor: 5, mode: "normal" },
+        ["c", "_"]
+      );
+      expect(state.text).toBe("\nnext"); // Line cleared and enters insert mode
+      expect(state.mode).toBe("insert");
+      expect(state.cursor).toBe(0);
+    });
+
+    test("y_ yanks entire line", () => {
+      const state = executeVimCommands(
+        { ...initialState, text: "  hello world\nnext", cursor: 3, mode: "normal" },
+        ["y", "_"]
+      );
+      expect(state.yankBuffer).toBe("  hello world\n");
+      expect(state.text).toBe("  hello world\nnext");
+    });
   });
 });
+

src/utils/vim.ts

@@ -90,6 +90,20 @@ export function getLineBounds(
   return { lineStart, lineEnd, row };
 }
 
+/**
+ * Move to first non-whitespace character on current line (like '_').
+ */
+export function moveToFirstNonWhitespace(text: string, cursor: number): number {
+  const { lineStart, lineEnd } = getLineBounds(text, cursor);
+  let i = lineStart;
+  while (i < lineEnd && /\s/.test(text[i])) {
+    i++;
+  }
+  // If entire line is whitespace, go to line start
+  return i >= lineEnd ? lineStart : i;
+}
+
+
 /**
  * Move cursor vertically by delta lines, maintaining desiredColumn if provided.
  */
@@ -126,6 +140,7 @@ export function moveWordForward(text: string, cursor: number): number {
 /**
  * Move cursor to end of current/next word (like 'e').
  * If on a word character, goes to end of current word.
+ * If already at end of word, goes to end of next word.
  * If on whitespace, goes to end of next word.
  */
 export function moveWordEnd(text: string, cursor: number): number {
@@ -135,8 +150,18 @@ export function moveWordEnd(text: string, cursor: number): number {
   let i = cursor;
   const isWord = (ch: string) => /[A-Za-z0-9_]/.test(ch);
 
-  // If on a word char, move to end of this word
+  // If on a word char, check if we're at the end of it
   if (isWord(text[i])) {
+    // If next char is not a word char, we're at the end - move to next word
+    if (i < n - 1 && !isWord(text[i + 1])) {
+      // Skip whitespace to find next word
+      i++;
+      while (i < n - 1 && !isWord(text[i])) i++;
+      // Move to end of next word
+      while (i < n - 1 && isWord(text[i + 1])) i++;
+      return i;
+    }
+    // Not at end yet, move to end of current word
     while (i < n - 1 && isWord(text[i + 1])) i++;
     return i;
   }
@@ -474,6 +499,9 @@ function handlePendingOperator(
     if (key === "0" || key === "Home") {
       return { handled: true, newState: applyOperatorMotion(state, pending.op, "0") };
     }
+    if (key === "_") {
+      return { handled: true, newState: applyOperatorMotion(state, pending.op, "_") };
+    }
     // Text object prefix
     if (key === "i") {
       return handleKey(state, { pendingOp: { op: pending.op, at: now, args: ["i"] } });
@@ -513,7 +541,7 @@ function handleKey(state: VimState, updates: Partial<VimState>): VimKeyResult {
 function getMotionRange(
   text: string,
   cursor: number,
-  motion: "w" | "b" | "e" | "$" | "0" | "line"
+  motion: "w" | "b" | "e" | "$" | "0" | "_" | "line"
 ): { from: number; to: number } | null {
   switch (motion) {
     case "w":
@@ -530,6 +558,9 @@ function getMotionRange(
       const { lineStart } = getLineBounds(text, cursor);
       return { from: lineStart, to: cursor };
     }
+    case "_":
+      // '_' is a linewise motion in Vim - operates on whole lines
+      return null; // Use linewise handling like 'dd'
     case "line":
       return null; // Special case: handled separately
   }
@@ -541,12 +572,12 @@ function getMotionRange(
 function applyOperatorMotion(
   state: VimState,
   op: "d" | "c" | "y",
-  motion: "w" | "b" | "e" | "$" | "0" | "line"
+  motion: "w" | "b" | "e" | "$" | "0" | "_" | "line"
 ): VimState {
   const { text, cursor, yankBuffer } = state;
 
-  // Line operations use special functions
-  if (motion === "line") {
+  // Line operations use special functions (dd, cc, yy, d_, c_, y_)
+  if (motion === "line" || motion === "_") {
     if (op === "d") {
       const result = deleteLine(text, cursor, yankBuffer);
       return completeOperation(state, {
@@ -711,6 +742,9 @@ function tryHandleNavigation(state: VimState, key: string): VimKeyResult | null
       return handleKey(state, { cursor: lineStart, desiredColumn: null });
     }
 
+    case "_":
+      return handleKey(state, { cursor: moveToFirstNonWhitespace(text, cursor), desiredColumn: null });
+
     case "$":
     case "End": {
       const { lineStart, lineEnd } = getLineBounds(text, cursor);