Support vim last nonblank g motion

Author: SqlRush

docs/first-second-parity-audit.md

@@ -242,6 +242,7 @@ M7 progress now includes:
 - `internal/tui`: Vim prompt editing now includes `gu`/`gU`/`g~` case-conversion operators across motion, linewise, find/till, text-object, and dot-repeat paths without updating the yank register.
 - `internal/tui`: Vim prompt editing now includes normal-mode `gJ` raw line joins that do not insert or normalize whitespace and can be dot-repeated.
 - `internal/tui`: Vim prompt editing now supports normal, operator, and visual `+`/`-`/`_` first-nonblank line motions, including linewise operator ranges and dot-repeat replay.
+- `internal/tui`: Vim prompt editing now supports normal, operator, and visual `g_` last-nonblank line motions, preserving charwise operator ranges for commands such as `dg_`.
 - `internal/tui`: Vim prompt editing now includes visual and visual-line `J`/`gJ` joins across selected line ranges, sharing the normal whitespace-normalized and raw join semantics plus undo, `gv`, and dot-repeat recording.
 - `internal/tui`: Vim prompt editing now includes visual and visual-line `p`/`P` paste-over-selection behavior for characterwise and linewise registers, updating the unnamed register with the replaced text and avoiding extra trailing blank lines for end-of-buffer line replacements.
 - `internal/tui`: Vim prompt editing now includes visual and visual-line `r{char}` selection replacement, replacing non-newline characters while preserving line structure, supporting undo, and remembering the previous visual range for `gv`.

internal/tui/tui_test.go

@@ -3573,6 +3573,47 @@ func TestREPLScreenVimFirstNonBlankLineMotions(t *testing.T) {
 	}
 }
 
+func TestREPLScreenVimLastNonBlankGMotion(t *testing.T) {
+	screen := NewREPLScreen(40, 8, nil)
+	screen.SetVimEnabled(true)
+	typePromptText(&screen, "one   \n  two  \nthree")
+	screen.ApplyKey(ParseKey("\x1b"))
+	for _, seq := range []string{"g", "g", "g", "_"} {
+		screen.ApplyKey(ParseKey(seq))
+	}
+	if screen.Prompt.Cursor != len([]rune("one"))-1 {
+		t.Fatalf("cursor after g_ = %d", screen.Prompt.Cursor)
+	}
+	for _, seq := range []string{"g", "g", "2", "g", "_"} {
+		screen.ApplyKey(ParseKey(seq))
+	}
+	if screen.Prompt.Cursor != len([]rune("one   \n  two"))-1 {
+		t.Fatalf("cursor after 2g_ = %d", screen.Prompt.Cursor)
+	}
+
+	screen = NewREPLScreen(40, 8, nil)
+	screen.SetVimEnabled(true)
+	typePromptText(&screen, "one   \n  two")
+	screen.ApplyKey(ParseKey("\x1b"))
+	for _, seq := range []string{"g", "g", "v", "g", "_", "y"} {
+		screen.ApplyKey(ParseKey(seq))
+	}
+	if screen.VimMode != VimNormal || screen.VimRegister != "one" || screen.VimRegisterLinewise || screen.Prompt.Text != "one   \n  two" {
+		t.Fatalf("after visual g_ yank screen = %#v", screen)
+	}
+
+	screen = NewREPLScreen(40, 8, nil)
+	screen.SetVimEnabled(true)
+	typePromptText(&screen, "one   \n  two")
+	screen.ApplyKey(ParseKey("\x1b"))
+	for _, seq := range []string{"g", "g", "d", "g", "_"} {
+		screen.ApplyKey(ParseKey(seq))
+	}
+	if screen.Prompt.Text != "   \n  two" || screen.Prompt.Cursor != 0 || screen.VimRegister != "one" || screen.VimRegisterLinewise {
+		t.Fatalf("after dg_ screen = %#v", screen)
+	}
+}
+
 func TestREPLScreenVimBackwardEndMotions(t *testing.T) {
 	screen := NewREPLScreen(40, 8, nil)
 	screen.SetVimEnabled(true)

internal/tui/vim.go

@@ -434,6 +434,8 @@ func (s *REPLScreen) applyVimVisualG(r rune) ScreenEvent {
 		applyN(count, func() { s.Prompt.moveWORDBackwardEnd() })
 	case 'J':
 		s.applyVimVisualJoin(true)
+	case '_':
+		s.Prompt.moveVimLastNonBlankMotion(count)
 	}
 	return ScreenEvent{}
 }
@@ -862,6 +864,12 @@ func (s *REPLScreen) applyVimG(r rune) ScreenEvent {
 		} else {
 			s.applyVimBackwardEndMotionOperator(operator, r, count)
 		}
+	case '_':
+		if operator == 0 {
+			s.Prompt.moveVimLastNonBlankMotion(count)
+		} else {
+			s.applyVimMotionOperator(operator, r, count)
+		}
 	}
 	return ScreenEvent{}
 }
@@ -1676,13 +1684,55 @@ func (p *PromptState) moveVimFirstNonBlankMotion(motion rune, count int) {
 	p.moveFirstNonBlank()
 }
 
+func (p *PromptState) vimLastNonBlankMotionTargetLine(count int) int {
+	if count <= 0 {
+		count = 1
+	}
+	return p.currentLogicalLine() + count
+}
+
+func (p *PromptState) moveVimLastNonBlankMotion(count int) {
+	lines := strings.Split(p.Text, "\n")
+	line := p.vimLastNonBlankMotionTargetLine(count)
+	if line < 1 {
+		line = 1
+	}
+	if line > len(lines) {
+		line = len(lines)
+	}
+	lineIndex := line - 1
+	p.Cursor = lineStartOffset(lines, lineIndex) + lastNonBlankOffset(lines[lineIndex])
+}
+
+func lastNonBlankOffset(line string) int {
+	runes := []rune(line)
+	for i := len(runes) - 1; i >= 0; i-- {
+		if !unicode.IsSpace(runes[i]) {
+			return i
+		}
+	}
+	return 0
+}
+
 func (p *PromptState) operatorMotionRange(operator rune, motion rune, count int) (int, int, bool, bool) {
 	if count <= 0 {
 		count = 1
 	}
 	runes := []rune(p.Text)
 	start := p.clampCursor(p.Cursor)
 	cursor := *p
+	if motion == '_' {
+		cursor.moveVimLastNonBlankMotion(count)
+		end := cursor.Cursor
+		if end >= start {
+			if end < len(runes) {
+				end++
+			}
+		} else if start < len(runes) {
+			start++
+		}
+		return orderedRange(start, end, false)
+	}
 	switch motion {
 	case 'j':
 		start, end, ok := p.lineMotionRange(p.currentLogicalLine() + count + 1)