feat: add { and } paragraph motions

README.md

@@ -54,7 +54,7 @@ Toggle via command palette (`Ctrl+p` -> `Toggle vim mode`).
 
 **Movement**
 
-`h` `j` `k` `l` `w` `b` `e` `W` `B` `E` `0` `^` `_` `$` `gg` `G`
+`h` `j` `k` `l` `w` `b` `e` `W` `B` `E` `0` `^` `_` `$` `{` `}` `gg` `G`
 `f` `F` `t` `T` `;` `,`
 `Ctrl+e` `Ctrl+y` `Ctrl+d` `Ctrl+u` `Ctrl+f` `Ctrl+b`
 
@@ -63,11 +63,11 @@ Toggle via command palette (`Ctrl+p` -> `Toggle vim mode`).
 
 **Editing**
 
-`i` `I` `a` `A` `o` `O` `R` `x` `~` `dd` `dw` `db` `cc` `cw` `cb` `S` `J`
+`i` `I` `a` `A` `o` `O` `R` `x` `~` `dd` `dw` `db` `d}` `d{` `cc` `cw` `cb` `c}` `c{` `S` `J`
 
 **yank / put / undo**
 
-`yy` `yw` `p` `P` `u` `ctrl+r`
+`yy` `yw` `y}` `y{` `p` `P` `u` `ctrl+r`
 
 - Copy the current prompt selection with `<leader>y` (default: `ctrl+x` then `y`).
 - Configure it with `keybinds.prompt_copy_selection`.

packages/opencode/src/cli/cmd/tui/component/prompt/index.tsx

@@ -101,6 +101,8 @@ export type PromptProps = {
     jump: (action: "top" | "bottom" | "high" | "middle" | "low") => void
     wordNext: (big: boolean) => boolean
     wordPrev: (big: boolean) => boolean
+    nextParagraph: () => boolean
+    previousParagraph: () => boolean
     text: () => string
     col: () => number
     setCol: (offset: number) => void
@@ -530,6 +532,12 @@ export function Prompt(props: PromptProps) {
     copyWordPrev(big) {
       return props.copy?.wordPrev(big) ?? false
     },
+    copyNextParagraph() {
+      return props.copy?.nextParagraph() ?? false
+    },
+    copyPreviousParagraph() {
+      return props.copy?.previousParagraph() ?? false
+    },
     copyText() {
       return props.copy?.text() ?? ""
     },

packages/opencode/src/cli/cmd/tui/component/vim/vim-handler.ts

@@ -10,6 +10,7 @@ import {
   deleteLine,
   deleteLineEnd,
   deleteSelection,
+  deleteSpan,
   deleteUnderCursor,
   deleteWord,
   deleteWordBackward,
@@ -27,16 +28,22 @@ import {
   moveLineBeginning,
   moveLineDown,
   moveLineUp,
+  moveNextParagraph,
+  movePreviousParagraph,
   moveRight,
   moveLineEnd,
   moveWordEnd,
   moveWordNext,
   moveWordPrev,
+  nextParagraphOperation,
   nextWordStart,
   openLineAbove,
   openLineBelow,
+  type ParagraphOperation,
+  type ParagraphResult,
   pasteAfter,
   pasteBefore,
+  previousParagraphOperation,
   prevWordStart,
   replaceUnderCursor,
   substituteLine,
@@ -80,6 +87,8 @@ export function createVimHandler(input: {
   copyJump?: (action: VimJump) => void
   copyWordNext?: (big: boolean) => boolean
   copyWordPrev?: (big: boolean) => boolean
+  copyNextParagraph?: () => boolean
+  copyPreviousParagraph?: () => boolean
   copyText?: () => string
   copyCol?: () => number
   setCopyCol?: (offset: number) => void
@@ -167,6 +176,39 @@ export function createVimHandler(input: {
     run?.()
   }
 
+  function applyParagraphYank(result: ParagraphResult) {
+    if (result.register) setRegister(result.register, true)
+    if (result.span && result.span.end > result.span.start) input.flash?.(result.span)
+    input.state.clearPending()
+  }
+
+  function applyParagraphEdit(textarea: TextareaRenderable, result: ParagraphResult, operation: "d" | "c") {
+    const apply = () => {
+      if (result.span) deleteSpan(textarea, result.span)
+      if (result.register) setRegister(result.register)
+      input.state.clearPending()
+      if (operation === "c") input.state.setMode("insert")
+    }
+    if (operation === "c") begin(apply)
+    else edit(apply)
+  }
+
+  function paragraphOperator(key: string, operation: ParagraphOperation): boolean {
+    if (key !== "{" && key !== "}") return false
+
+    const textarea = input.textarea()
+
+    const result =
+      key === "}" ? nextParagraphOperation(textarea, operation) : previousParagraphOperation(textarea, operation)
+
+    // no motion: vim no-ops the operator without editing or changing mode.
+    if (!result.span && !result.register) input.state.clearPending()
+    else if (operation === "y") applyParagraphYank(result)
+    else applyParagraphEdit(textarea, result, operation)
+
+    return true
+  }
+
   function undo() {
     if (!tracked()) return false
     const next = input.state.undo(snapshot())
@@ -323,7 +365,12 @@ export function createVimHandler(input: {
     }
 
     if (input.state.pending() === "c") {
-      if (key === "c" && !event.shift && !hasModifier(event)) {
+      if (hasModifier(event)) {
+        input.state.clearPending()
+        return false
+      }
+
+      if (key === "c" && !event.shift) {
         begin(() => {
           const reg = substituteLine(input.textarea())
           if (reg) setRegister(reg)
@@ -334,7 +381,7 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (key === "w" && !event.shift && !hasModifier(event)) {
+      if (key === "w" && !event.shift) {
         begin(() => {
           const reg = deleteWord(input.textarea())
           if (reg) setRegister(reg)
@@ -345,7 +392,7 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (key === "b" && !event.shift && !hasModifier(event)) {
+      if (key === "b" && !event.shift) {
         begin(() => {
           const reg = deleteWordBackward(input.textarea())
           if (reg) setRegister(reg)
@@ -368,16 +415,21 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (hasModifier(event)) {
-        input.state.clearPending()
-        return false
+      if (paragraphOperator(key, "c")) {
+        event.preventDefault()
+        return true
       }
 
       input.state.clearPending()
     }
 
     if (input.state.pending() === "d") {
-      if (key === "d" && !event.shift && !hasModifier(event)) {
+      if (hasModifier(event)) {
+        input.state.clearPending()
+        return false
+      }
+
+      if (key === "d" && !event.shift) {
         edit(() => {
           const reg = deleteLine(input.textarea())
           if (reg) setRegister(reg)
@@ -387,7 +439,7 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (key === "w" && !event.shift && !hasModifier(event)) {
+      if (key === "w" && !event.shift) {
         edit(() => {
           const reg = deleteWord(input.textarea())
           if (reg) setRegister(reg)
@@ -397,7 +449,7 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (key === "b" && !event.shift && !hasModifier(event)) {
+      if (key === "b" && !event.shift) {
         edit(() => {
           const reg = deleteWordBackward(input.textarea())
           if (reg) setRegister(reg)
@@ -418,16 +470,21 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (hasModifier(event)) {
-        input.state.clearPending()
-        return false
+      if (paragraphOperator(key, "d")) {
+        event.preventDefault()
+        return true
       }
 
       input.state.clearPending()
     }
 
     if (input.state.pending() === "y") {
-      if (key === "y" && !event.shift && !hasModifier(event)) {
+      if (hasModifier(event)) {
+        input.state.clearPending()
+        return false
+      }
+
+      if (key === "y" && !event.shift) {
         const span = yankLineSpan(input.textarea())
         const reg = yankLine(input.textarea())
         if (reg) setRegister(reg, true)
@@ -437,7 +494,7 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (key === "w" && !event.shift && !hasModifier(event)) {
+      if (key === "w" && !event.shift) {
         const span = yankWordSpan(input.textarea())
         const reg = yankWord(input.textarea())
         if (reg) setRegister(reg, true)
@@ -458,9 +515,9 @@ export function createVimHandler(input: {
         return true
       }
 
-      if (hasModifier(event)) {
-        input.state.clearPending()
-        return false
+      if (paragraphOperator(key, "y")) {
+        event.preventDefault()
+        return true
       }
 
       input.state.clearPending()
@@ -736,6 +793,18 @@ export function createVimHandler(input: {
       return true
     }
 
+    if (key === "{" && !hasModifier(event)) {
+      movePreviousParagraph(input.textarea())
+      event.preventDefault()
+      return true
+    }
+
+    if (key === "}" && !hasModifier(event)) {
+      moveNextParagraph(input.textarea())
+      event.preventDefault()
+      return true
+    }
+
     if (key === "x" && !event.shift && !hasModifier(event)) {
       edit(() => {
         const reg = deleteUnderCursor(input.textarea())
@@ -1029,6 +1098,19 @@ export function createVimHandler(input: {
       return true
     }
 
+    // paragraph motions
+    if (key === "{" && !hasModifier(event)) {
+      input.copyPreviousParagraph?.()
+      event.preventDefault()
+      return true
+    }
+
+    if (key === "}" && !hasModifier(event)) {
+      input.copyNextParagraph?.()
+      event.preventDefault()
+      return true
+    }
+
     // find-char pending
     if ((key === "f" || key === "t") && !event.shift) {
       input.state.setPending(key)