pi-vim 0.1.8 → 0.2.0

package/README.md

@@ -1,35 +1,89 @@
-# vim-bindings — Pi REPL Vim Mode
+# pi-vim — Vim Mode for Pi REPL
 
-A modal vim-like editing extension for Pi's REPL prompt, covering the
-high-frequency ("90%") command surface without trying to clone full Vim.
+Modal vim-like editing for Pi's REPL prompt.
+Focus: the high-frequency 90% command surface, not full Vim.
 
-## Loading
+## TL;DR
 
+- Problem: REPL editing is slow with only linear cursor movement.
+- Solution: modal editing (`INSERT`/`NORMAL`) with Vim-style motions,
+  operators, counts, and repeatable workflows.
+- Install: `pi install npm:pi-vim`
+
+## Install
+
+```bash
+pi install npm:pi-vim
 ```
-pi --extension /path/to/vim-bindings/index.ts
+
+Restart Pi after install.
+
+### Local loading (dev)
+
+```bash
+pi --extension /path/to/pi-vim/index.ts
 ```
 
 Or add to `.pi/settings.json`:
 
 ```json
 {
-  "extensions": ["./pi-extensions/vim-bindings/index.ts"]
+  "extensions": ["./pi-extensions/pi-vim/index.ts"]
 }
 ```
 
-The mode indicator (`INSERT` / `NORMAL`) is shown in the bottom-right corner
-of the prompt.
+## 30-second quickstart
+
+Try on multi-line input:
+
+```text
+Esc        # NORMAL mode
+3gg        # jump to absolute line 3
+2dw        # delete two words
+u          # undo
+<C-r>      # redo last undone edit (safe no-op when empty)
+2}         # jump two paragraphs forward
+```
+
+Mode indicator (`INSERT` / `NORMAL`) appears at bottom-right.
+
+## Why pi-vim
+
+- Fast modal editing without leaving Pi.
+- Count-aware motions/operators (`2dw`, `3G`, `d2j`, `2}`).
+- Strong REPL-focused defaults; safe out-of-scope boundaries documented.
+- Clipboard/register behavior is explicit and tested.
+
+## For you / not for you
+
+Use pi-vim if you want fast Vim muscle-memory in Pi prompts.
+Skip it if you need full Vim feature parity (visual mode, macros, search,
+ex-commands, etc.).
+
+## Common recipes
+
+| Goal | Keys |
+|------|------|
+| Jump to exact line 25 | `25gg` (or `25G`) |
+| Delete two words | `2dw` |
+| Change to end of line | `C` |
+| Delete current + 2 lines below | `d2j` |
+| Yank 3 lines | `3yy` |
+| Join 3 lines with spacing | `3J` |
+| Jump 2 paragraphs forward | `2}` |
+| Undo last edit | `u` |
+| Redo last undone edit | `<C-r>` |
 
 ---
 
-## Supported command surface
+## Full reference
 
 ### Mode switching
 
 | Key      | Action                                 |
 |----------|----------------------------------------|
-| `Esc`    | Insert → Normal mode                   |
-| `Esc`    | Normal mode → pass to Pi (abort agent) |
+| `Esc` / `Ctrl+[` | Insert → Normal mode                   |
+| `Esc` / `Ctrl+[` | Normal mode → pass to Pi (abort agent) |
 | `i`      | Normal → Insert at cursor              |
 | `a`      | Normal → Insert after cursor           |
 | `I`      | Normal → Insert at line start          |
@@ -61,6 +115,7 @@ A `{count}` prefix can be prepended to any navigation key (max: `9999`).
 | `{count}h/l`  | Move left/right `{count}` cols  |
 | `{count}j/k`  | Move down/up `{count}` lines (clamped to buffer size) |
 | `0`           | Line start                    |
+| `^`           | First non-whitespace char of line |
 | `$`           | Line end                      |
 | `gg`          | Buffer start (line 1)         |
 | `{count}gg`   | Go to line `{count}` (1-indexed, clamped) |
@@ -133,6 +188,7 @@ word, char-find, and linewise motions. Maximum total count: `9999`.
 | `d{count}W/E/B`   | Forward/backward `{count}` `WORD` motions                 |
 | `d$`              | To end of line                                            |
 | `d0`              | To start of line                                          |
+| `d^`              | To first non-whitespace char of line                      |
 | `dd`              | Current line (linewise)                                   |
 | `{count}dd`       | `{count}` lines (linewise)                                |
 | `d{count}j`       | Current line + `{count}` lines below (linewise)           |
@@ -162,7 +218,7 @@ Same motion and count set as `d`. Deletes text then enters Insert mode.
 | `ciw`           | Change inner word                             |
 | `caw`           | Change around word                            |
 | `cc`            | Delete line content + Insert                  |
-| `c$`            | Delete to EOL + Insert                        |
+| `c$` / `c0` / `c^` | Delete to EOL / BOL / first non-whitespace + Insert |
 | …               | All `d` motions apply                         |
 
 #### Single-key edits
@@ -199,6 +255,7 @@ Same motion set as `d`. Writes to register, **no text mutation**.
 | `yB`         | Backward to `WORD` start                          |
 | `y$`         | To end of line                                    |
 | `y0`         | To start of line                                  |
+| `y^`         | To first non-whitespace char of line              |
 | `yf{c}`      | To and including `char`                           |
 | `yiw`        | Inner word                                        |
 | `yaw`        | Around word (includes spaces)                     |
@@ -223,13 +280,14 @@ Line-wise detection: register content ending in `\n` is treated as line-wise.
 
 ---
 
-### Undo
-
-| Key | Action                                          |
-|-----|-------------------------------------------------|
-| `u` | Undo — sends `ctrl+_` (`\x1f`) to the underlying readline editor |
+### Undo / Redo
 
-Redo (`<C-r>`) is **not implemented** — see [Out of scope](#out-of-scope).
+| Key | Action |
+|-----|--------|
+| `u` | Undo in normal mode |
+| `Ctrl+_` | Undo in normal mode (alias for `u`) |
+| `<C-r>` | Redo one undone change in normal mode; safe no-op when redo history is empty |
+| `{count}<C-r>` | Redo up to `{count}` undone changes in order; clamps at available history and consumes count state (no leak to the next command) |
 
 ---
 
@@ -253,7 +311,7 @@ Redo (`<C-r>`) is **not implemented** — see [Out of scope](#out-of-scope).
 | `w` / `e` / `b` + `W` / `E` / `B` | Cross-line for `word` + `WORD` motions | Cross-line                    |
 | `0` / `$` operators   | Exclusive of anchor col                | `0` inclusive of col 0        |
 | Undo depth            | Delegates to underlying readline undo  | Full per-change undo tree     |
-| Redo                  | Not implemented                        | `<C-r>`                       |
+| Redo                  | Normal-mode `<C-r>` supported (safe no-op when empty; counted redo is stepwise, clamps to available history, and preserves single-step undo granularity) | `<C-r>`                       |
 | Visual mode           | Not implemented                        | `v`, `V`, `<C-v>`            |
 | Text objects          | Supports `iw`/`aw` only               | Full text-object set           |
 | Count prefix          | Supported for operators, word/char motions, navigation, and edits (`x`, `p`/`P`); capped at `MAX_COUNT=9999` to prevent abuse | Full support |
@@ -277,8 +335,9 @@ These are **explicitly deferred** and not planned for this feature:
 - Search mode (`/`, `?`, `n`, `N`)
 - Repeat (`.`)
 - Extended count prefix beyond currently supported motions (e.g. `:`, global operator counts)
-- Redo (`<C-r>`) — no native redo primitive in the underlying readline editor;
-  deferred until a suitable hook is available.
+- No insert-mode `<C-r>` feature expansion beyond current underlying-editor behavior.
+- No cross-session redo persistence.
+- No upstream `pi-tui` redo prerequisite in this wave.
 - Window / tab / buffer management
 - Plugin / runtime ecosystem compatibility
 
@@ -295,6 +354,6 @@ These are **explicitly deferred** and not planned for this feature:
 Run tests:
 
 ```
-cd vim-bindings
+cd pi-vim
 npm test
 ```

package/index.ts

@@ -3,7 +3,7 @@
  *
  * Usage: pi --extension ./index.ts
  *
- * - Escape: insert → normal mode (in normal mode, aborts agent)
+ * - Escape / ctrl+[: insert → normal mode (in normal mode, aborts agent)
  * - i: normal → insert mode (at cursor)
  * - a: insert after cursor
  * - A: insert at end of line
@@ -12,11 +12,12 @@
  * - O: open new line above (insert mode)
  * - hjkl: navigation in normal mode
  * - 0/$: line start/end
+ * - ^: first non-whitespace char of line
  * - x: delete char under cursor
  * - D: delete to end of line
  * - S: substitute line (delete line content + insert mode)
  * - s: substitute char (delete char + insert mode)
- * - d{motion}: delete with motion (`w/b/e` + `W/B/E`, `$`, `0`, `dd`, `f/t/F/T{char}`)
+ * - d{motion}: delete with motion (`w/b/e` + `W/B/E`, `$`, `0`, `^`, `dd`, `f/t/F/T{char}`)
  * - c{motion}: change with same motion set as `d` (then enter insert mode)
  * - y{motion}: yank with same motion set as `d` (no text mutation)
  * - f{char}: jump to next {char} on line
@@ -76,6 +77,7 @@ import {
   CTRL_A,
   CTRL_E,
   CTRL_K,
+  CTRL_R,
   CTRL_UNDERSCORE,
   NEWLINE,
   ESC_DOWN,
@@ -84,6 +86,7 @@ import {
   reverseCharMotion,
   findCharMotionTarget,
   findParagraphMotionTarget,
+  findFirstNonWhitespaceColumn,
   type WordMotionClass,
 } from "./motions.js";
 import {
@@ -97,6 +100,24 @@ const BRACKETED_PASTE_END = "\x1b[201~";
 const BRACKETED_PASTE_END_TAIL = BRACKETED_PASTE_END.slice(1);
 const MAX_COUNT = 9999;
 
+type EditorSnapshot = {
+  text: string;
+  cursor: { line: number; col: number };
+};
+
+type TransitionState = "none" | "undo" | "redo";
+
+type ModalEditorInternals = {
+  state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
+  preferredVisualCol?: number | null;
+  lastAction?: string | null;
+  historyIndex?: number;
+  onChange?: (text: string) => void;
+  tui?: { requestRender?: () => void };
+  pushUndoSnapshot?: () => void;
+  setCursorCol?: (col: number) => void;
+};
+
 export class ModalEditor extends CustomEditor {
   private mode: Mode = "insert";
   private pendingMotion: PendingMotion = null;
@@ -109,7 +130,10 @@ export class ModalEditor extends CustomEditor {
   private lastCharMotion: LastCharMotion | null = null;
   private discardingBracketedPasteInNormalMode: boolean = false;
   private pendingEscWhileDiscardingBracketedPasteInNormalMode: boolean = false;
-  private readonly wordBoundaryCache = new WordBoundaryCache();
+  private wordBoundaryCache = new WordBoundaryCache();
+  private readonly redoStack: EditorSnapshot[] = [];
+  private currentTransition: TransitionState = "none";
+  private onChangeHooked: boolean = false;
 
   // Unnamed register
   private unnamedRegister: string = "";
@@ -124,6 +148,183 @@ export class ModalEditor extends CustomEditor {
   getMode(): Mode { return this.mode; }
   getText(): string { return this.getLines().join("\n"); }
 
+  override setText(text: string): void {
+    this.clearRedoStack();
+    super.setText(text);
+  }
+
+  private captureSnapshot(): EditorSnapshot {
+    const cursor = this.getCursor();
+    return {
+      text: this.getText(),
+      cursor: { line: cursor.line, col: cursor.col },
+    };
+  }
+
+  private requireRedoRestoreState(
+    editor: ModalEditorInternals,
+  ): { lines: string[]; cursorLine?: number; cursorCol?: number } {
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines)) {
+      throw new Error("Redo restore prerequisite: editor state unavailable");
+    }
+    return state;
+  }
+
+  private restoreSnapshot(snapshot: EditorSnapshot): void {
+    const editor = this as unknown as ModalEditorInternals;
+    const state = this.requireRedoRestoreState(editor);
+
+    const lines = snapshot.text.split("\n");
+    state.lines = lines.length > 0 ? lines : [""];
+
+    const maxLine = Math.max(0, state.lines.length - 1);
+    const cursorLine = Math.max(0, Math.min(snapshot.cursor.line, maxLine));
+    const line = state.lines[cursorLine] ?? "";
+    const cursorCol = Math.max(0, Math.min(snapshot.cursor.col, line.length));
+
+    state.cursorLine = cursorLine;
+    if (typeof editor.setCursorCol === "function") {
+      editor.setCursorCol(cursorCol);
+    } else {
+      state.cursorCol = cursorCol;
+      editor.preferredVisualCol = null;
+    }
+
+    this.invalidateWordBoundaryCache();
+
+    editor.historyIndex = -1;
+    editor.lastAction = null;
+    editor.onChange?.(this.getText());
+    editor.tui?.requestRender?.();
+  }
+
+  private snapshotChanged(a: EditorSnapshot, b: EditorSnapshot): boolean {
+    return a.text !== b.text
+      || a.cursor.line !== b.cursor.line
+      || a.cursor.col !== b.cursor.col;
+  }
+
+  private withTransition<T>(
+    transition: Exclude<TransitionState, "none">,
+    action: () => T,
+  ): T {
+    const previousTransition = this.currentTransition;
+    this.currentTransition = transition;
+    try {
+      return action();
+    } finally {
+      this.currentTransition = previousTransition;
+    }
+  }
+
+  private performUndo(): void {
+    this.withTransition("undo", () => {
+      const beforeUndo = this.captureSnapshot();
+      super.handleInput(CTRL_UNDERSCORE);
+      const afterUndo = this.captureSnapshot();
+
+      if (this.snapshotChanged(beforeUndo, afterUndo)) {
+        this.redoStack.push(beforeUndo);
+      }
+    });
+  }
+
+  private performRedo(count: number = this.takeTotalCount(1)): void {
+    const maxSteps = Math.max(1, Math.min(MAX_COUNT, count));
+    const editor = this as unknown as ModalEditorInternals;
+
+    for (let i = 0; i < maxSteps; i++) {
+      const snapshot = this.redoStack[this.redoStack.length - 1];
+      if (!snapshot) break;
+
+      this.withTransition("redo", () => {
+        this.requireRedoRestoreState(editor);
+        if (typeof editor.pushUndoSnapshot !== "function") {
+          throw new Error(
+            "Redo restore prerequisite: pushUndoSnapshot unavailable",
+          );
+        }
+        editor.pushUndoSnapshot();
+        this.restoreSnapshot(snapshot);
+        this.redoStack.pop();
+      });
+    }
+  }
+
+  private clearRedoStack(): void {
+    this.redoStack.length = 0;
+  }
+
+  private invalidateWordBoundaryCache(): void {
+    this.wordBoundaryCache = new WordBoundaryCache();
+  }
+
+  private ensureOnChangeHook(): void {
+    if (this.onChangeHooked) return;
+
+    const editor = this as unknown as ModalEditorInternals;
+    const originalOnChange = editor.onChange;
+
+    editor.onChange = (text: string) => {
+      originalOnChange?.(text);
+      this.centralInvalidationCheck();
+    };
+
+    this.onChangeHooked = true;
+  }
+
+  private centralInvalidationCheck(): void {
+    if (this.redoStack.length === 0) return;
+    if (this.currentTransition !== "none") return;
+    this.clearRedoStack();
+  }
+
+  private applySyntheticEdit(mutation: () => void): void {
+    const editor = this as unknown as ModalEditorInternals;
+    if (!editor.state || !Array.isArray(editor.state.lines)) {
+      throw new Error(
+        "Synthetic edit prerequisite: editor state unavailable",
+      );
+    }
+
+    if (typeof editor.pushUndoSnapshot !== "function") {
+      throw new Error(
+        "Synthetic edit prerequisite: pushUndoSnapshot unavailable",
+      );
+    }
+
+    const textBefore = this.getText();
+    const preCursorLine = editor.state.cursorLine;
+    const preCursorCol = editor.state.cursorCol;
+
+    mutation();
+
+    if (this.getText() === textBefore) return;
+
+    // Text changed — push undo boundary for pre-mutation state.
+    // Briefly swap pre-mutation state in for the snapshot, then
+    // restore the post-mutation result.
+    const postLines = editor.state.lines.slice();
+    const postCursorLine = editor.state.cursorLine;
+    const postCursorCol = editor.state.cursorCol;
+    const postPreferredCol = editor.preferredVisualCol;
+
+    const preLines = textBefore.split("\n");
+    editor.state.lines = preLines.length > 0 ? preLines : [""];
+    editor.state.cursorLine = preCursorLine;
+    editor.state.cursorCol = preCursorCol;
+    editor.pushUndoSnapshot();
+
+    editor.state.lines = postLines;
+    editor.state.cursorLine = postCursorLine;
+    editor.state.cursorCol = postCursorCol;
+    editor.preferredVisualCol = postPreferredCol;
+
+    editor.onChange?.(this.getText());
+    editor.tui?.requestRender?.();
+  }
+
   private clearPendingState(): void {
     this.pendingMotion = null;
     this.pendingTextObject = null;
@@ -134,6 +335,10 @@ export class ModalEditor extends CustomEditor {
     this.pendingGCount = "";
   }
 
+  private isEscapeLikeInput(data: string): boolean {
+    return matchesKey(data, "escape") || matchesKey(data, "ctrl+[");
+  }
+
   private stripBracketedPasteInNormalMode(data: string): { filtered: string | null; stripped: boolean } {
     let chunk = data;
     let stripped = false;
@@ -170,9 +375,11 @@ export class ModalEditor extends CustomEditor {
   }
 
   handleInput(data: string): void {
+    this.ensureOnChangeHook();
+
     if (this.mode !== "insert") {
       if (this.discardingBracketedPasteInNormalMode) {
-        if (data === "\x1b") {
+        if (this.isEscapeLikeInput(data)) {
           if (this.pendingEscWhileDiscardingBracketedPasteInNormalMode) {
             this.pendingEscWhileDiscardingBracketedPasteInNormalMode = false;
             this.discardingBracketedPasteInNormalMode = false;
@@ -206,7 +413,7 @@ export class ModalEditor extends CustomEditor {
       data = filtered;
     }
 
-    if (matchesKey(data, "escape")) {
+    if (this.isEscapeLikeInput(data)) {
       return this.handleEscape();
     }
 
@@ -221,19 +428,17 @@ export class ModalEditor extends CustomEditor {
       }
       // Alt+o: open new line below (stay in insert mode)
       if (matchesKey(data, Key.alt("o")) || data === "\x1bo") {
-        super.handleInput(CTRL_E);
-        super.handleInput(NEWLINE);
+        this.openLineBelow();
         return;
       }
       // Alt+Shift+o: open new line above (stay in insert mode)
       // \x1bO is the legacy sequence for Alt+Shift+O (VT100 SS3 prefix in non-Kitty terminals)
       if (matchesKey(data, Key.shiftAlt("o")) || data === "\x1bO") {
-        super.handleInput(CTRL_A);
-        super.handleInput(NEWLINE);
-        super.handleInput(ESC_UP);
+        this.openLineAbove();
         return;
       }
-      return super.handleInput(data);
+      super.handleInput(data);
+      return;
     }
 
     if (this.pendingTextObject) {
@@ -625,6 +830,8 @@ export class ModalEditor extends CustomEditor {
         || data === "p"
         || data === "P"
         || data === "J"
+        || data === CTRL_R
+        || matchesKey(data, "ctrl+r")
       );
       const supportsCountedCharMotion = (
         CHAR_MOTION_KEYS.has(data)
@@ -748,8 +955,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
-    if (data === "u") {
-      super.handleInput(CTRL_UNDERSCORE); // ctrl+_ — readline undo
+    if (data === "u" || data === CTRL_UNDERSCORE || matchesKey(data, "ctrl+_")) {
+      this.performUndo();
+      return;
+    }
+
+    if (data === CTRL_R || matchesKey(data, "ctrl+r")) {
+      this.performRedo();
       return;
     }
 
@@ -758,6 +970,11 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "^") {
+      this.moveCursorToFirstNonWhitespace();
+      return;
+    }
+
     if (data === "w") {
       const count = this.takeTotalCount(1);
       return this.moveWord("forward", "start", count, "word");
@@ -777,6 +994,17 @@ export class ModalEditor extends CustomEditor {
     super.handleInput(data);
   }
 
+  private openLineBelow(): void {
+    super.handleInput(CTRL_E);
+    super.handleInput(NEWLINE);
+  }
+
+  private openLineAbove(): void {
+    super.handleInput(CTRL_A);
+    super.handleInput(NEWLINE);
+    super.handleInput(ESC_UP);
+  }
+
   private handleMappedKey(key: string): void {
     const seq = NORMAL_KEYS[key];
     switch (key) {
@@ -798,14 +1026,11 @@ export class ModalEditor extends CustomEditor {
         super.handleInput(CTRL_A);
         break;
       case "o":
-        super.handleInput(CTRL_E);
-        super.handleInput(NEWLINE);
+        this.openLineBelow();
         this.mode = "insert";
         break;
       case "O":
-        super.handleInput(CTRL_A);
-        super.handleInput(NEWLINE);
-        super.handleInput(ESC_UP);
+        this.openLineAbove();
         this.mode = "insert";
         break;
       case "D":
@@ -920,6 +1145,12 @@ export class ModalEditor extends CustomEditor {
     super.handleInput(CTRL_A);
   }
 
+  private moveCursorToFirstNonWhitespace(): void {
+    const { line, col } = this.getCurrentLineAndCol();
+    const targetCol = findFirstNonWhitespaceColumn(line);
+    this.moveCursorBy(targetCol - col);
+  }
+
   private moveCursorToBufferStart(): void {
     this.moveCursorToLineStart(0);
   }
@@ -934,43 +1165,39 @@ export class ModalEditor extends CustomEditor {
     const steps = Math.max(0, count - 1);
     if (steps === 0) return;
 
-    const editor = this as unknown as {
-      state?: { lines?: string[]; cursorLine?: number; cursorCol?: number };
-      preferredVisualCol?: number;
-      tui?: { requestRender?: () => void };
-    };
+    this.applySyntheticEdit(() => {
+      const editor = this as unknown as ModalEditorInternals;
+      const state = editor.state;
+      if (!state || !Array.isArray(state.lines)) return;
 
-    const state = editor.state;
-    if (!state || !Array.isArray(state.lines)) return;
+      const currentLine = state.cursorLine ?? 0;
+      let joinPoint = state.cursorCol ?? 0;
 
-    const currentLine = state.cursorLine ?? 0;
-    let joinPoint = state.cursorCol ?? 0;
+      for (let i = 0; i < steps; i++) {
+        if (currentLine >= state.lines.length - 1) break;
 
-    for (let i = 0; i < steps; i++) {
-      if (currentLine >= state.lines.length - 1) break;
+        const left = state.lines[currentLine]!;
+        const right = state.lines[currentLine + 1]!;
+        let joined: string;
 
-      const left = state.lines[currentLine]!;
-      const right = state.lines[currentLine + 1]!;
-      let joined: string;
+        if (normalize) {
+          const trimmedRight = right.trimStart();
+          const leftEndsWithSpace = left.length > 0 && /\s/.test(left[left.length - 1]!);
+          const needsSeparator = !leftEndsWithSpace && trimmedRight.length > 0;
+          joined = needsSeparator ? `${left} ${trimmedRight}` : left + trimmedRight;
+          joinPoint = left.length;
+        } else {
+          joined = left + right;
+          joinPoint = left.length;
+        }
 
-      if (normalize) {
-        const trimmedRight = right.trimStart();
-        const leftEndsWithSpace = left.length > 0 && /\s/.test(left[left.length - 1]!);
-        const needsSeparator = !leftEndsWithSpace && trimmedRight.length > 0;
-        joined = needsSeparator ? `${left} ${trimmedRight}` : left + trimmedRight;
-        joinPoint = left.length;
-      } else {
-        joined = left + right;
-        joinPoint = left.length;
+        state.lines.splice(currentLine, 2, joined);
       }
 
-      state.lines.splice(currentLine, 2, joined);
-    }
-
-    state.cursorLine = currentLine;
-    state.cursorCol = joinPoint;
-    editor.preferredVisualCol = joinPoint;
-    editor.tui?.requestRender?.();
+      state.cursorLine = currentLine;
+      state.cursorCol = joinPoint;
+      editor.preferredVisualCol = joinPoint;
+    });
   }
 
   private isWordChar(ch: string): boolean {
@@ -1388,6 +1615,11 @@ export class ModalEditor extends CustomEditor {
       return true;
     }
 
+    if (motion === "^") {
+      this.deleteRange(col, findFirstNonWhitespaceColumn(this.getLines()[cursor.line] ?? ""), false);
+      return true;
+    }
+
     const wordMotion = this.resolveWordMotion(motion);
     if (wordMotion) {
       const lineLocalRange = this.tryWordMotionLineLocalRange(
@@ -1511,6 +1743,11 @@ export class ModalEditor extends CustomEditor {
       return true;
     }
 
+    if (motion === "^") {
+      this.yankRange(col, findFirstNonWhitespaceColumn(line), false);
+      return true;
+    }
+
     const wordMotion = this.resolveWordMotion(motion);
     if (wordMotion) {
       const lineLocalRange = this.tryWordMotionLineLocalRange(

package/motions.ts

@@ -30,6 +30,14 @@ function clampLineIndex(lines: readonly string[], lineIndex: number): number {
   return Math.max(0, Math.min(normalized, lines.length - 1));
 }
 
+/**
+ * Column of first non-whitespace char, or 0 for blank lines.
+ */
+export function findFirstNonWhitespaceColumn(line: string): number {
+  const match = line.search(/\S/);
+  return match === -1 ? 0 : match;
+}
+
 /**
  * True when line matches ^\s*$.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.1.8",
+  "version": "0.2.0",
   "description": "Vim-style modal editing for Pi's TUI editor",
   "type": "module",
   "keywords": [

package/types.ts

@@ -43,6 +43,7 @@ export const ESC_DELETE = "\x1b[3~";
 export const CTRL_A = "\x01"; // line start
 export const CTRL_E = "\x05"; // line end
 export const CTRL_K = "\x0b"; // kill to end of line
+export const CTRL_R = "\x12"; // ctrl+r — readline redo trigger in vim layer
 export const CTRL_UNDERSCORE = "\x1f"; // ctrl+_ — readline undo
 export const NEWLINE = "\n"; // newline character
 export const ESC_UP = "\x1b[A"; // cursor up