pi-vim 0.1.9 → 0.2.0

package/README.md

@@ -41,6 +41,7 @@ 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
 ```
 
@@ -71,6 +72,7 @@ ex-commands, etc.).
 | Join 3 lines with spacing | `3J` |
 | Jump 2 paragraphs forward | `2}` |
 | Undo last edit | `u` |
+| Redo last undone edit | `<C-r>` |
 
 ---
 
@@ -278,13 +280,14 @@ Line-wise detection: register content ending in `\n` is treated as line-wise.
 
 ---
 
-### Undo
+### Undo / Redo
 
-| Key | Action                                          |
-|-----|-------------------------------------------------|
-| `u` | Undo — sends `ctrl+_` (`\x1f`) to the underlying readline editor |
-
-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) |
 
 ---
 
@@ -308,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 |
@@ -332,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
 

package/index.ts

@@ -77,6 +77,7 @@ import {
   CTRL_A,
   CTRL_E,
   CTRL_K,
+  CTRL_R,
   CTRL_UNDERSCORE,
   NEWLINE,
   ESC_DOWN,
@@ -99,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;
@@ -111,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 = "";
@@ -126,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;
@@ -176,6 +375,8 @@ export class ModalEditor extends CustomEditor {
   }
 
   handleInput(data: string): void {
+    this.ensureOnChangeHook();
+
     if (this.mode !== "insert") {
       if (this.discardingBracketedPasteInNormalMode) {
         if (this.isEscapeLikeInput(data)) {
@@ -227,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) {
@@ -631,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)
@@ -754,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;
     }
 
@@ -788,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) {
@@ -809,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":
@@ -951,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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.1.9",
+  "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