pi-vim 0.1.4 → 0.1.7

package/README.md

@@ -64,10 +64,30 @@ A `{count}` prefix can be prepended to any navigation key (max: `9999`).
 | `$`           | Line end                      |
 | `gg`          | Buffer start (line 1)         |
 | `G`           | Buffer end (last line)        |
-| `w`           | Next word start               |
-| `b`           | Previous word start           |
-| `e`           | Word end (inclusive)          |
-| `{count}w/b/e`| Move `{count}` words          |
+| `w`           | Next `word` start (keyword/punctuation aware) |
+| `b`           | Previous `word` start         |
+| `e`           | `word` end (inclusive)        |
+| `W`           | Next `WORD` start (whitespace-delimited token) |
+| `B`           | Previous `WORD` start         |
+| `E`           | `WORD` end (inclusive)        |
+| `{count}w/b/e`| Move `{count}` `word` motions |
+| `{count}W/B/E`| Move `{count}` `WORD` motions |
+| `}`           | Move to next paragraph start (line start col `0`) |
+| `{`           | Move to previous paragraph start (line start col `0`) |
+| `{count}}`    | Repeat `}` `{count}` times |
+| `{count}{`    | Repeat `{` `{count}` times |
+
+`word` (`w/b/e`) splits punctuation from keyword chars. `WORD` (`W/B/E`)
+treats any non-whitespace run as one token (`foo-bar`, `path/to`, `x.y`).
+
+Paragraph boundary definition (this extension wave):
+- blank line: matches `^\s*$`
+- paragraph start: non-blank line at BOF, or non-blank line immediately after a blank line
+
+Standalone `{` / `}` motions are navigation-only (no text/register mutation).
+Counted forms (`{count}{`, `{count}}`) step paragraph-by-paragraph.
+If no further paragraph boundary exists, motions clamp at BOF/EOF.
+Operator forms with braces (`d{`, `d}`, `c{`, `c}`, `y{`, `y}`) are out of scope for this wave.
 
 ---
 
@@ -101,10 +121,14 @@ word, char-find, and linewise motions. Maximum total count: `9999`.
 
 | Command           | Deletes                                                   |
 |-------------------|-----------------------------------------------------------|
-| `dw`              | Forward to next word start (exclusive, can cross lines)   |
-| `de`              | Forward to word end (inclusive, can cross lines)          |
-| `db`              | Backward to word start (exclusive, can cross lines)       |
-| `d{count}w/e/b`   | Forward/backward `{count}` words                          |
+| `dw`              | Forward to next `word` start (exclusive, can cross lines) |
+| `de`              | Forward to `word` end (inclusive, can cross lines)        |
+| `db`              | Backward to `word` start (exclusive, can cross lines)     |
+| `dW`              | Forward to next `WORD` start (exclusive, can cross lines) |
+| `dE`              | Forward to `WORD` end (inclusive, can cross lines)        |
+| `dB`              | Backward to `WORD` start (exclusive, can cross lines)     |
+| `d{count}w/e/b`   | Forward/backward `{count}` `word` motions                 |
+| `d{count}W/E/B`   | Forward/backward `{count}` `WORD` motions                 |
 | `d$`              | To end of line                                            |
 | `d0`              | To start of line                                          |
 | `dd`              | Current line (linewise)                                   |
@@ -127,13 +151,17 @@ Same motion and count set as `d`. Deletes text then enters Insert mode.
 
 | Command         | Action                             |
 |-----------------|------------------------------------|
-| `cw`            | Delete word + Insert               |
-| `c{count}w/e/b` | Delete `{count}` words + Insert    |
-| `ciw`           | Change inner word                  |
-| `caw`           | Change around word                 |
-| `cc`            | Delete line content + Insert       |
-| `c$`            | Delete to EOL + Insert             |
-| …               | All `d` motions apply              |
+| `cw`            | Change `word` + Insert                        |
+| `ce` / `cb`     | Change to `word` end / previous `word` start  |
+| `cW`            | Change `WORD` + Insert (`cW` on non-space behaves like `cE`) |
+| `cE` / `cB`     | Change to `WORD` end / previous `WORD` start  |
+| `c{count}w/e/b` | Change `{count}` `word` motions + Insert      |
+| `c{count}W/E/B` | Change `{count}` `WORD` motions + Insert      |
+| `ciw`           | Change inner word                             |
+| `caw`           | Change around word                            |
+| `cc`            | Delete line content + Insert                  |
+| `c$`            | Delete to EOL + Insert                        |
+| …               | All `d` motions apply                         |
 
 #### Single-key edits
 
@@ -161,15 +189,22 @@ Same motion set as `d`. Writes to register, **no text mutation**.
 | `y{count}j`  | Current line + `{count}` lines below (linewise) |
 | `y{count}k`  | Current line + `{count}` lines above (linewise) |
 | `yG`         | Current line to end of buffer (linewise)         |
-| `yw`         | Forward to next word start                        |
-| `ye`         | To word end (inclusive)                           |
-| `yb`         | Backward to word start                            |
+| `yw`         | Forward to next `word` start                      |
+| `ye`         | To `word` end (inclusive)                         |
+| `yb`         | Backward to `word` start                          |
+| `yW`         | Forward to next `WORD` start                      |
+| `yE`         | To `WORD` end (inclusive)                         |
+| `yB`         | Backward to `WORD` start                          |
 | `y$`         | To end of line                                    |
 | `y0`         | To start of line                                  |
 | `yf{c}`      | To and including `char`                           |
 | `yiw`        | Inner word                                        |
 | `yaw`        | Around word (includes spaces)                     |
 
+Counted yank caveat: counted `word`/`WORD` yank motions are intentionally not
+implemented (`y2w`, `2yw`, `y2W`, `2yW`, etc. cancel the pending operator).
+Linewise counted yank (`{count}yy`, `y{count}j/k`) remains supported.
+
 ---
 
 ### Put / Paste
@@ -213,7 +248,7 @@ Redo (`<C-r>`) is **not implemented** — see [Out of scope](#out-of-scope).
 | Area                  | This extension                         | Full Vim                      |
 |-----------------------|----------------------------------------|-------------------------------|
 | `$` motion            | Moves past last char (readline CTRL+E) | Moves to last char            |
-| `w` / `e` / `b`       | Cross-line for word motions            | Cross-line                    |
+| `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>`                       |
@@ -224,7 +259,7 @@ Redo (`<C-r>`) is **not implemented** — see [Out of scope](#out-of-scope).
 | Macros                | Not implemented (`q`, `@`)             | Supported                     |
 | Search                | Not implemented (`/`, `?`, `n`, `N`)   | Supported                     |
 | Ex commands           | Not implemented (`:s`, `:g`, etc.)     | Supported                     |
-| Multi-line operators  | Supports `d/y` with `w/e/b`, `j/k` counts, and `G`; not full Vim motion matrix | Rich cross-line semantics |
+| Multi-line operators  | Supports `d/c/y` with `w/e/b` and `W/E/B`, plus `j/k` counts and `G`; not full Vim motion matrix | Rich cross-line semantics |
 
 ---
 

package/index.ts

@@ -16,16 +16,21 @@
  * - 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 (dw, db, de, d$, d0, dd, df/dt/dF/dT{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
  * - F{char}: jump to previous {char} on line
  * - t{char}: jump to just before next {char} on line
  * - T{char}: jump to just after previous {char} on line
  * - ;: repeat last f/F/t/T motion (same direction)
  * - ,: repeat last f/F/t/T motion (reverse direction)
- * - w: move to start of next word
- * - b: move to start of previous word
- * - e: move to end of word
+ * - w/b/e: `word` motions (keyword/punctuation aware)
+ * - W/B/E: `WORD` motions (whitespace-delimited non-space runs)
+ * - {/}: paragraph motions to previous/next paragraph start (line start col 0)
+ * - `{count}` prefixes supported for navigation, paragraph motions, and `d/c` word/WORD motions
+ * - operator forms with braces (`d{`, `d}`, `c{`, `c}`, `y{`, `y}`) are out of scope
+ * - counted yank caveat: `y2w`, `2yw`, `y2W`, `2yW` cancel (linewise counts still supported)
  * - Shift+Alt+A: go to end of line (insert mode shortcut)
  * - Shift+Alt+I: go to start of line (insert mode shortcut)
  * - Alt+o: open new line below (insert mode shortcut)
@@ -78,6 +83,8 @@ import {
 import {
   reverseCharMotion,
   findCharMotionTarget,
+  findParagraphMotionTarget,
+  type WordMotionClass,
 } from "./motions.js";
 import {
   WordBoundaryCache,
@@ -98,6 +105,7 @@ export class ModalEditor extends CustomEditor {
   private prefixCount: string = "";
   private operatorCount: string = "";
   private pendingG: boolean = false;
+  private pendingGCount: string = "";
   private lastCharMotion: LastCharMotion | null = null;
   private discardingBracketedPasteInNormalMode: boolean = false;
   private pendingEscWhileDiscardingBracketedPasteInNormalMode: boolean = false;
@@ -123,6 +131,7 @@ export class ModalEditor extends CustomEditor {
     this.prefixCount = "";
     this.operatorCount = "";
     this.pendingG = false;
+    this.pendingGCount = "";
   }
 
   private stripBracketedPasteInNormalMode(data: string): { filtered: string | null; stripped: boolean } {
@@ -276,6 +285,7 @@ export class ModalEditor extends CustomEditor {
       || this.prefixCount
       || this.operatorCount
       || this.pendingG
+      || this.pendingGCount
     ) {
       this.clearPendingState();
       return;
@@ -454,12 +464,19 @@ export class ModalEditor extends CustomEditor {
     }
 
     const hasCount = this.prefixCount.length > 0 || this.operatorCount.length > 0;
-    const supportsCountedWordMotion = data === "w" || data === "e" || data === "b";
+    const supportsCountedWordMotion = (
+      data === "w"
+      || data === "e"
+      || data === "b"
+      || data === "W"
+      || data === "E"
+      || data === "B"
+    );
     const supportsCountedTextObject = data === "i" || data === "a";
 
     if (hasCount && !supportsCountedWordMotion && !supportsCountedTextObject) {
       // Counted forms beyond dd, d{count}j/k, d{count}{f/F/t/T}, and
-      // d{count}{w/e/b}/{i/a}w are out of scope.
+      // d{count}{w/e/b/W/E/B}/{i/a}w are out of scope.
       this.cancelPendingOperator(data);
       return;
     }
@@ -509,7 +526,14 @@ export class ModalEditor extends CustomEditor {
     }
 
     const hasCount = this.prefixCount.length > 0 || this.operatorCount.length > 0;
-    const supportsCountedWordMotion = data === "w" || data === "e" || data === "b";
+    const supportsCountedWordMotion = (
+      data === "w"
+      || data === "e"
+      || data === "b"
+      || data === "W"
+      || data === "E"
+      || data === "B"
+    );
     const supportsCountedTextObject = data === "i" || data === "a";
 
     if (hasCount && !supportsCountedWordMotion && !supportsCountedTextObject) {
@@ -523,7 +547,10 @@ export class ModalEditor extends CustomEditor {
     }
 
     const motionCount = supportsCountedWordMotion ? this.takeTotalCount(1) : 1;
-    if (this.deleteWithMotion(data, motionCount)) {
+    const effectiveMotion = data === "W" && this.isCursorOnNonWhitespace()
+      ? "E"
+      : data;
+    if (this.deleteWithMotion(effectiveMotion, motionCount)) {
       this.pendingOperator = null;
       this.mode = "insert";
       return;
@@ -535,12 +562,30 @@ export class ModalEditor extends CustomEditor {
 
   private handleNormalMode(data: string): void {
     if (this.pendingG) {
-      this.pendingG = false;
-      if (data === "g") {
-        this.moveCursorToBufferStart();
+      if (this.isDigit(data)) {
+        this.pendingGCount += data;
         return;
       }
-      // Unsupported g-prefix command: discard prefix and keep processing input.
+
+      this.pendingG = false;
+      const hadGCount = this.pendingGCount.length > 0;
+      this.pendingGCount = "";
+
+      if (!hadGCount) {
+        if (data === "g") {
+          this.takeTotalCount(1);
+          this.moveCursorToBufferStart();
+          return;
+        }
+
+        if (data === "J") {
+          this.joinLines(false);
+          return;
+        }
+      }
+
+      this.clearPendingState();
+      return;
     }
 
     if (this.prefixCount.length > 0) {
@@ -559,6 +604,12 @@ export class ModalEditor extends CustomEditor {
         return;
       }
 
+      if (data === "g") {
+        this.pendingGCount = "";
+        this.pendingG = true;
+        return;
+      }
+
       const supportsCountedStandaloneEdit = (
         data === "x"
         || data === "s"
@@ -567,6 +618,7 @@ export class ModalEditor extends CustomEditor {
         || data === "C"
         || data === "p"
         || data === "P"
+        || data === "J"
       );
       const supportsCountedCharMotion = (
         CHAR_MOTION_KEYS.has(data)
@@ -577,7 +629,11 @@ export class ModalEditor extends CustomEditor {
         data === "w"
         || data === "e"
         || data === "b"
+        || data === "W"
+        || data === "E"
+        || data === "B"
       );
+      const supportsCountedParagraphMotion = data === "{" || data === "}";
       const supportsCountedNav = (
         data === "h"
         || data === "j"
@@ -607,7 +663,17 @@ export class ModalEditor extends CustomEditor {
         return;
       }
 
-      if (!supportsCountedStandaloneEdit && !supportsCountedCharMotion && !supportsCountedWordMotion) {
+      if (supportsCountedParagraphMotion) {
+        this.executeParagraphMotion(data === "}" ? "forward" : "backward");
+        return;
+      }
+
+      if (
+        !supportsCountedStandaloneEdit
+        && !supportsCountedCharMotion
+        && !supportsCountedWordMotion
+        && !supportsCountedParagraphMotion
+      ) {
         // Unsupported prefixed forms: drop count and keep processing this key.
         this.prefixCount = "";
         this.operatorCount = "";
@@ -617,7 +683,13 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "J") {
+      this.joinLines(true);
+      return;
+    }
+
     if (data === "g") {
+      this.pendingGCount = "";
       this.pendingG = true;
       return;
     }
@@ -675,12 +747,20 @@ export class ModalEditor extends CustomEditor {
       return;
     }
 
+    if (data === "}" || data === "{") {
+      this.executeParagraphMotion(data === "}" ? "forward" : "backward");
+      return;
+    }
+
     if (data === "w") {
       const count = this.takeTotalCount(1);
-      return this.moveWord("forward", "start", count);
+      return this.moveWord("forward", "start", count, "word");
     }
-    if (data === "b") return this.moveWord("backward", "start", this.takeTotalCount(1));
-    if (data === "e") return this.moveWord("forward", "end", this.takeTotalCount(1));
+    if (data === "b") return this.moveWord("backward", "start", this.takeTotalCount(1), "word");
+    if (data === "e") return this.moveWord("forward", "end", this.takeTotalCount(1), "word");
+    if (data === "W") return this.moveWord("forward", "start", this.takeTotalCount(1), "WORD");
+    if (data === "B") return this.moveWord("backward", "start", this.takeTotalCount(1), "WORD");
+    if (data === "E") return this.moveWord("forward", "end", this.takeTotalCount(1), "WORD");
 
     if (Object.hasOwn(NORMAL_KEYS, data)) {
       return this.handleMappedKey(data);
@@ -763,6 +843,14 @@ export class ModalEditor extends CustomEditor {
     }
   }
 
+  private executeParagraphMotion(direction: "forward" | "backward"): void {
+    const lines = this.getLines();
+    const fromLine = this.getCursor().line;
+    const count = this.takeTotalCount(1);
+    const targetLine = findParagraphMotionTarget(lines, fromLine, direction, count);
+    this.moveCursorToLineStart(targetLine);
+  }
+
   private tryMoveCursorByState(delta: number): boolean {
     if (delta === 0) return true;
 
@@ -835,16 +923,79 @@ export class ModalEditor extends CustomEditor {
     this.moveCursorToLineStart(Math.max(0, lines.length - 1));
   }
 
+  private joinLines(normalize: boolean): void {
+    const count = this.takeTotalCount(2);
+    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 };
+    };
+
+    const state = editor.state;
+    if (!state || !Array.isArray(state.lines)) return;
+
+    const currentLine = state.cursorLine ?? 0;
+    let joinPoint = state.cursorCol ?? 0;
+
+    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;
+
+      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.cursorLine = currentLine;
+    state.cursorCol = joinPoint;
+    editor.preferredVisualCol = joinPoint;
+    editor.tui?.requestRender?.();
+  }
+
   private isWordChar(ch: string): boolean {
     return /\w/.test(ch);
   }
 
-  private charType(ch: string | undefined): "space" | "word" | "other" {
+  private charType(
+    ch: string | undefined,
+    semanticClass: WordMotionClass = "word",
+  ): "space" | "word" | "other" {
     if (!ch || /\s/.test(ch)) return "space";
+    if (semanticClass === "WORD") return "word";
     if (this.isWordChar(ch)) return "word";
     return "other";
   }
 
+  private resolveWordMotion(
+    motion: string,
+  ): { motion: "w" | "e" | "b"; semanticClass: WordMotionClass } | null {
+    if (motion === "w" || motion === "e" || motion === "b") {
+      return { motion, semanticClass: "word" };
+    }
+
+    if (motion === "W" || motion === "E" || motion === "B") {
+      const normalizedMotion = motion.toLowerCase() as "w" | "e" | "b";
+      return { motion: normalizedMotion, semanticClass: "WORD" };
+    }
+
+    return null;
+  }
+
   private getAbsoluteIndex(line: number, col: number): number {
     const lines = this.getLines();
     let idx = 0;
@@ -865,6 +1016,7 @@ export class ModalEditor extends CustomEditor {
     direction: "forward" | "backward",
     target: "start" | "end",
     count: number = 1,
+    semanticClass: WordMotionClass = "word",
   ): number {
     const len = text.length;
     if (len === 0) return 0;
@@ -879,27 +1031,27 @@ export class ModalEditor extends CustomEditor {
         if (next >= len) {
           next = len;
         } else if (target === "start") {
-          const startType = this.charType(text[next]);
+          const startType = this.charType(text[next], semanticClass);
           if (startType !== "space") {
-            while (next < len && this.charType(text[next]) === startType) next++;
+            while (next < len && this.charType(text[next], semanticClass) === startType) next++;
           }
-          while (next < len && this.charType(text[next]) === "space") next++;
+          while (next < len && this.charType(text[next], semanticClass) === "space") next++;
         } else {
           if (next < len - 1) next++;
-          while (next < len && this.charType(text[next]) === "space") next++;
+          while (next < len && this.charType(text[next], semanticClass) === "space") next++;
           if (next >= len) {
             next = len;
           } else {
-            const t = this.charType(text[next]);
-            while (next < len - 1 && this.charType(text[next + 1]) === t) next++;
+            const t = this.charType(text[next], semanticClass);
+            while (next < len - 1 && this.charType(text[next + 1], semanticClass) === t) next++;
           }
         }
       } else {
         if (next >= len) next = len - 1;
         if (next > 0) next--;
-        while (next > 0 && this.charType(text[next]) === "space") next--;
-        const t = this.charType(text[next]);
-        while (next > 0 && this.charType(text[next - 1]) === t) next--;
+        while (next > 0 && this.charType(text[next], semanticClass) === "space") next--;
+        const t = this.charType(text[next], semanticClass);
+        while (next > 0 && this.charType(text[next - 1], semanticClass) === t) next--;
       }
 
       if (next === i) break;
@@ -915,6 +1067,7 @@ export class ModalEditor extends CustomEditor {
     direction: WordMotionDirection,
     target: WordMotionTarget,
     allowSameColumn: boolean = false,
+    semanticClass: WordMotionClass = "word",
   ): number | null {
     if (line.length === 0) return null;
     if (col < 0 || col > line.length) return null;
@@ -926,7 +1079,13 @@ export class ModalEditor extends CustomEditor {
       if (!/\S/.test(line.slice(0, col))) return null;
     }
 
-    const targetCol = this.wordBoundaryCache.tryFindTarget(line, col, direction, target);
+    const targetCol = this.wordBoundaryCache.tryFindTarget(
+      line,
+      col,
+      direction,
+      target,
+      semanticClass,
+    );
     if (targetCol === null) return null;
 
     if (direction === "forward") {
@@ -952,6 +1111,7 @@ export class ModalEditor extends CustomEditor {
     direction: WordMotionDirection,
     target: WordMotionTarget,
     allowSameColumn: boolean = false,
+    semanticClass: WordMotionClass = "word",
   ): number | null {
     const cursor = this.getCursor();
     const lineIndex = cursor.line;
@@ -964,6 +1124,7 @@ export class ModalEditor extends CustomEditor {
       direction,
       target,
       allowSameColumn,
+      semanticClass,
     );
     if (targetCol === null) return null;
 
@@ -977,9 +1138,10 @@ export class ModalEditor extends CustomEditor {
   private tryMoveWordLineLocal(
     direction: "forward" | "backward",
     target: "start" | "end",
+    semanticClass: WordMotionClass = "word",
   ): boolean {
     const col = this.getCursor().col;
-    const targetCol = this.tryFindWordTargetLineLocal(direction, target);
+    const targetCol = this.tryFindWordTargetLineLocal(direction, target, false, semanticClass);
     if (targetCol === null || targetCol === col) return false;
 
     this.moveCursorBy(targetCol - col);
@@ -989,6 +1151,7 @@ export class ModalEditor extends CustomEditor {
   private tryWordMotionLineLocalRange(
     motion: "w" | "e" | "b",
     count: number = 1,
+    semanticClass: WordMotionClass = "word",
   ): { col: number; targetCol: number; inclusive: boolean } | null {
     const cursor = this.getCursor();
     const lineIndex = cursor.line;
@@ -1006,6 +1169,7 @@ export class ModalEditor extends CustomEditor {
         direction,
         target,
         motion === "e",
+        semanticClass,
       );
       if (nextCol === null) return null;
       if (nextCol === currentCol && step < steps - 1) return null;
@@ -1027,18 +1191,26 @@ export class ModalEditor extends CustomEditor {
     direction: "forward" | "backward",
     target: "start" | "end",
     count: number = 1,
+    semanticClass: WordMotionClass = "word",
   ): void {
     let remaining = Math.max(1, Math.min(MAX_COUNT, count));
 
     while (remaining > 0) {
-      if (this.tryMoveWordLineLocal(direction, target)) {
+      if (this.tryMoveWordLineLocal(direction, target, semanticClass)) {
         remaining--;
         continue;
       }
 
       const text = this.getText();
       const currentAbs = this.getAbsoluteIndexFromCursor();
-      const targetAbs = this.findWordTargetInText(text, currentAbs, direction, target, remaining);
+      const targetAbs = this.findWordTargetInText(
+        text,
+        currentAbs,
+        direction,
+        target,
+        remaining,
+        semanticClass,
+      );
       if (targetAbs !== currentAbs) {
         this.moveCursorBy(targetAbs - currentAbs);
       }
@@ -1058,6 +1230,12 @@ export class ModalEditor extends CustomEditor {
     return { line, col };
   }
 
+  private isCursorOnNonWhitespace(): boolean {
+    const { line, col } = this.getCurrentLineAndCol();
+    const ch = line[col];
+    return ch !== undefined && !/\s/.test(ch);
+  }
+
   private isCursorAtOrPastEol(): boolean {
     const { line, col } = this.getCurrentLineAndCol();
     return col >= line.length;
@@ -1204,8 +1382,13 @@ export class ModalEditor extends CustomEditor {
       return true;
     }
 
-    if (motion === "w" || motion === "e" || motion === "b") {
-      const lineLocalRange = this.tryWordMotionLineLocalRange(motion, count);
+    const wordMotion = this.resolveWordMotion(motion);
+    if (wordMotion) {
+      const lineLocalRange = this.tryWordMotionLineLocalRange(
+        wordMotion.motion,
+        count,
+        wordMotion.semanticClass,
+      );
       if (lineLocalRange) {
         this.deleteRange(
           lineLocalRange.col,
@@ -1220,11 +1403,12 @@ export class ModalEditor extends CustomEditor {
       const targetAbs = this.findWordTargetInText(
         text,
         currentAbs,
-        motion === "b" ? "backward" : "forward",
-        motion === "e" ? "end" : "start",
+        wordMotion.motion === "b" ? "backward" : "forward",
+        wordMotion.motion === "e" ? "end" : "start",
         count,
+        wordMotion.semanticClass,
       );
-      this.deleteRangeByAbsolute(currentAbs, targetAbs, motion === "e");
+      this.deleteRangeByAbsolute(currentAbs, targetAbs, wordMotion.motion === "e");
       return true;
     }
 
@@ -1321,8 +1505,13 @@ export class ModalEditor extends CustomEditor {
       return true;
     }
 
-    if (motion === "w" || motion === "e" || motion === "b") {
-      const lineLocalRange = this.tryWordMotionLineLocalRange(motion);
+    const wordMotion = this.resolveWordMotion(motion);
+    if (wordMotion) {
+      const lineLocalRange = this.tryWordMotionLineLocalRange(
+        wordMotion.motion,
+        1,
+        wordMotion.semanticClass,
+      );
       if (lineLocalRange) {
         this.yankRange(
           lineLocalRange.col,
@@ -1337,10 +1526,12 @@ export class ModalEditor extends CustomEditor {
       const targetAbs = this.findWordTargetInText(
         text,
         currentAbs,
-        motion === "b" ? "backward" : "forward",
-        motion === "e" ? "end" : "start",
+        wordMotion.motion === "b" ? "backward" : "forward",
+        wordMotion.motion === "e" ? "end" : "start",
+        1,
+        wordMotion.semanticClass,
       );
-      this.yankRangeByAbsolute(currentAbs, targetAbs, motion === "e");
+      this.yankRangeByAbsolute(currentAbs, targetAbs, wordMotion.motion === "e");
       return true;
     }
 
@@ -1571,7 +1762,11 @@ export class ModalEditor extends CustomEditor {
       return ` NORMAL ${prefixCount}${this.pendingOperator}${operatorCount}_ `;
     }
     if (this.pendingMotion) return ` NORMAL ${this.pendingMotion}_ `;
-    if (this.pendingG) return " NORMAL g_ ";
+    if (this.pendingG) {
+      return this.pendingGCount
+        ? ` NORMAL g${this.pendingGCount}_ `
+        : " NORMAL g_ ";
+    }
 
     const count = `${prefixCount}${operatorCount}`;
     if (count) return ` NORMAL ${count}_ `;

package/motions.ts

@@ -5,18 +5,105 @@
 import type { CharMotion } from "./types.js";
 
 // Character types for word boundary detection
+export type WordMotionClass = "word" | "WORD";
+
 enum CharType {
   Space = 0,
-  Keyword = 1, // alphanumeric + underscore
+  Keyword = 1, // alphanumeric + underscore (or all non-space in WORD mode)
   Other = 2, // punctuation/symbols
 }
 
-function getCharType(c: string | undefined): CharType {
+function getCharType(
+  c: string | undefined,
+  semanticClass: WordMotionClass = "word",
+): CharType {
   if (!c || /\s/.test(c)) return CharType.Space;
+  if (semanticClass === "WORD") return CharType.Keyword;
   if (/\w/.test(c)) return CharType.Keyword;
   return CharType.Other;
 }
 
+function clampLineIndex(lines: readonly string[], lineIndex: number): number {
+  if (lines.length === 0) return 0;
+  if (!Number.isFinite(lineIndex)) return 0;
+  const normalized = Math.trunc(lineIndex);
+  return Math.max(0, Math.min(normalized, lines.length - 1));
+}
+
+/**
+ * True when line matches ^\s*$.
+ */
+export function isBlankLine(line: string | undefined): boolean {
+  if (line === undefined) return true;
+  return /^\s*$/.test(line);
+}
+
+/**
+ * Paragraph start: non-blank line at BOF or after a blank line.
+ */
+export function isParagraphStart(lines: readonly string[], lineIndex: number): boolean {
+  if (!Number.isInteger(lineIndex)) return false;
+  if (lineIndex < 0 || lineIndex >= lines.length) return false;
+  if (isBlankLine(lines[lineIndex])) return false;
+  if (lineIndex === 0) return true;
+  return isBlankLine(lines[lineIndex - 1]);
+}
+
+/**
+ * One step of } motion from current line index.
+ */
+export function findNextParagraphStart(lines: readonly string[], fromLine: number): number {
+  if (lines.length === 0) return 0;
+
+  const start = clampLineIndex(lines, fromLine) + 1;
+  for (let i = start; i < lines.length; i++) {
+    if (isParagraphStart(lines, i)) return i;
+  }
+
+  return lines.length - 1;
+}
+
+/**
+ * One step of { motion from current line index.
+ */
+export function findPrevParagraphStart(lines: readonly string[], fromLine: number): number {
+  if (lines.length === 0) return 0;
+
+  const start = clampLineIndex(lines, fromLine) - 1;
+  for (let i = start; i >= 0; i--) {
+    if (isParagraphStart(lines, i)) return i;
+  }
+
+  return 0;
+}
+
+/**
+ * Paragraph motion target for counted { / } semantics.
+ */
+export function findParagraphMotionTarget(
+  lines: readonly string[],
+  fromLine: number,
+  direction: "forward" | "backward",
+  count: number = 1,
+): number {
+  if (lines.length === 0) return 0;
+
+  const steps = Number.isFinite(count) && count > 0 ? Math.floor(count) : 1;
+  let currentLine = clampLineIndex(lines, fromLine);
+
+  for (let i = 0; i < steps; i++) {
+    const nextLine =
+      direction === "forward"
+        ? findNextParagraphStart(lines, currentLine)
+        : findPrevParagraphStart(lines, currentLine);
+
+    if (nextLine === currentLine) break;
+    currentLine = nextLine;
+  }
+
+  return currentLine;
+}
+
 /**
  * Reverse a character motion direction (f ↔ F, t ↔ T).
  */
@@ -80,6 +167,7 @@ export function findWordMotionTarget(
   col: number,
   direction: "forward" | "backward",
   target: "start" | "end",
+  semanticClass: WordMotionClass = "word",
 ): number {
   const len = line.length;
   if (len === 0) return 0;
@@ -91,15 +179,15 @@ export function findWordMotionTarget(
 
     if (target === "start") {
       // w: move to start of next word
-      const startType = getCharType(line[i]);
+      const startType = getCharType(line[i], semanticClass);
 
       // Skip current word/punct block
       if (startType !== CharType.Space) {
-        while (i < len && getCharType(line[i]) === startType) i++;
+        while (i < len && getCharType(line[i], semanticClass) === startType) i++;
       }
 
       // Skip whitespace
-      while (i < len && getCharType(line[i]) === CharType.Space) i++;
+      while (i < len && getCharType(line[i], semanticClass) === CharType.Space) i++;
 
       return i;
     }
@@ -108,13 +196,13 @@ export function findWordMotionTarget(
     if (i < len - 1) i++;
 
     // Skip whitespace forward
-    while (i < len && getCharType(line[i]) === CharType.Space) i++;
+    while (i < len && getCharType(line[i], semanticClass) === CharType.Space) i++;
 
     // Now at start of next word (or end of line). Find end.
     if (i >= len) return len;
 
-    const type = getCharType(line[i]);
-    while (i < len - 1 && getCharType(line[i + 1]) === type) i++;
+    const type = getCharType(line[i], semanticClass);
+    while (i < len - 1 && getCharType(line[i + 1], semanticClass) === type) i++;
 
     return i;
   }
@@ -124,11 +212,11 @@ export function findWordMotionTarget(
   if (i > 0) i--;
 
   // Skip whitespace backward
-  while (i > 0 && getCharType(line[i]) === CharType.Space) i--;
+  while (i > 0 && getCharType(line[i], semanticClass) === CharType.Space) i--;
 
   // Now at end of prev word (or start of line). Find start.
-  const type = getCharType(line[i]);
-  while (i > 0 && getCharType(line[i - 1]) === type) i--;
+  const type = getCharType(line[i], semanticClass);
+  while (i > 0 && getCharType(line[i - 1], semanticClass) === type) i--;
 
   return i;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vim",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Vim-style modal editing for Pi's TUI editor",
   "type": "module",
   "keywords": [
@@ -23,7 +23,9 @@
   "scripts": {
     "build": "echo 'nothing to build'",
     "test": "node --import tsx/esm --test 'test/**/*.test.ts'",
-    "check": "npm run test"
+    "check": "npm run test",
+    "pack:check": "node --import tsx/esm script/pack-check.ts",
+    "prepublishOnly": "npm run pack:check && npm test"
   },
   "pi": {
     "extensions": [

package/word-boundary-cache.ts

@@ -1,9 +1,11 @@
 /**
  * Line-local cache for Vim word motion boundaries.
  *
- * Keyed by exact line content to avoid stale boundary reuse.
+ * Keyed by semantic class + exact line content to avoid stale boundary reuse.
  */
 
+import type { WordMotionClass } from "./motions.js";
+
 export type WordMotionDirection = "forward" | "backward";
 export type WordMotionTarget = "start" | "end";
 
@@ -22,13 +24,20 @@ export interface WordBoundaryData {
   readonly prevNonSpaceAtOrBefore: Int32Array;
 }
 
-function getCharType(ch: string | undefined): CharType {
+function getCharType(
+  ch: string | undefined,
+  semanticClass: WordMotionClass = "word",
+): CharType {
   if (!ch || /\s/.test(ch)) return CharType.Space;
+  if (semanticClass === "WORD") return CharType.Word;
   if (/\w/.test(ch)) return CharType.Word;
   return CharType.Other;
 }
 
-function buildWordBoundaryData(line: string): WordBoundaryData {
+function buildWordBoundaryData(
+  line: string,
+  semanticClass: WordMotionClass = "word",
+): WordBoundaryData {
   const len = line.length;
   const charTypes = new Uint8Array(len);
   const runStartByIndex = new Int32Array(len);
@@ -40,7 +49,7 @@ function buildWordBoundaryData(line: string): WordBoundaryData {
   prevNonSpaceAtOrBefore.fill(-1);
 
   for (let i = 0; i < len; i++) {
-    charTypes[i] = getCharType(line[i]);
+    charTypes[i] = getCharType(line[i], semanticClass);
   }
 
   for (let runStart = 0; runStart < len;) {
@@ -149,11 +158,16 @@ export class WordBoundaryCache {
       : DEFAULT_MAX_CACHE_ENTRIES;
   }
 
-  get(line: string): WordBoundaryData {
-    const cached = this.entries.get(line);
+  private makeCacheKey(line: string, semanticClass: WordMotionClass): string {
+    return `${semanticClass}\u0000${line}`;
+  }
+
+  get(line: string, semanticClass: WordMotionClass = "word"): WordBoundaryData {
+    const key = this.makeCacheKey(line, semanticClass);
+    const cached = this.entries.get(key);
     if (cached) return cached;
 
-    const built = buildWordBoundaryData(line);
+    const built = buildWordBoundaryData(line, semanticClass);
 
     if (this.entries.size >= this.maxEntries) {
       const oldestKey = this.entries.keys().next().value;
@@ -162,7 +176,7 @@ export class WordBoundaryCache {
       }
     }
 
-    this.entries.set(line, built);
+    this.entries.set(key, built);
     return built;
   }
 
@@ -171,10 +185,11 @@ export class WordBoundaryCache {
     col: number,
     direction: WordMotionDirection,
     target: WordMotionTarget,
+    semanticClass: WordMotionClass = "word",
   ): number | null {
     if (!Number.isInteger(col) || col < 0) return null;
 
-    const boundaries = this.get(line);
+    const boundaries = this.get(line, semanticClass);
     return findTargetInLine(boundaries, col, direction, target);
   }
 }