nook: jump to next/previous diagnostic with F8 / Alt+F8

The only ways to reach a diagnostic were the Alt+P workspace panel or
scrolling to the gutter marker by hand — there was no cursor-level
navigation between problems in the active buffer.

F8 moves the cursor to the next diagnostic, Alt+F8 to the previous one,
both wrapping around the ends. Positions are sorted by (row, col) and
deduplicated so several diagnostics on one spot count once. The landing
cursor is pushed to the jump list first, so Alt+- returns to where you
were, and the status bar reports the ordinal. bubbletea has no portable
shift+f8 constant, so Alt is the backward fallback, consistent with the
debug F-keys' Alt+F5 / Alt+F11.

Author: truffle-dev

CHANGELOG.md

@@ -8,6 +8,13 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- nook can now jump between diagnostics in the active buffer with F8 (next)
+  and Alt+F8 (previous), mirroring Zed's f8 / shift+f8. Both directions wrap
+  around the ends of the buffer, the landing position is recorded in the jump
+  list so Alt+- returns to where you were, and the status bar reports the
+  ordinal (`diagnostic 2/3 — L5:2`). Previously the only way to reach a
+  problem was the Alt+P workspace panel or scrolling to the gutter marker by
+  hand; there was no cursor-level navigation between them.
 - nook's status bar now shows a breadcrumb of the enclosing-symbol path at
   the cursor — `Server > Handle` when the caret sits inside the `Handle`
   method of `Server`, matching Zed and VSCode. The trail reads a warm

cmd/nook/internal/help/help.go

@@ -118,6 +118,7 @@ func Default() []Section {
 		}},
 		{Name: "Problems", Bindings: []Binding{
 			{"alt+p", "Workspace-wide diagnostics panel"},
+			{"f8 / alt+f8", "Jump to next / previous diagnostic in the buffer (wraps)"},
 			{"↑ ↓", "Navigate rows"},
 			{"pgup / pgdn", "Page through entries"},
 			{"home / end", "Jump to first / last row"},

cmd/nook/main.go

@@ -2292,6 +2292,13 @@ func (m model) routeKey(km tea.KeyMsg) (tea.Model, tea.Cmd) {
 		// identifier under the cursor, not whatever character the
 		// user happened to be over.
 		return m.triggerRename()
+	case tea.KeyF8:
+		// F8 jumps to the next diagnostic in the active buffer, Alt+F8 to
+		// the previous one — mirroring Zed's f8 / shift+f8. bubbletea has no
+		// portable shift+f8 constant (the same gap that forces Alt+F5 for
+		// debug stop), so Alt is the backward fallback. Both directions wrap
+		// around the ends of the buffer.
+		return m.jumpDiagnostic(!km.Alt)
 	case tea.KeyF5:
 		// F5 launches a debug session when none is live, or resumes
 		// the paused thread when one is. Alt+F5 (handled further
@@ -5483,6 +5490,83 @@ func (m model) diagCounts() (errs, warns int) {
 	return
 }
 
+// diagnosticPositions returns the active buffer's diagnostics as (row, col)
+// pairs sorted ascending by row then col, with duplicates at the same position
+// collapsed. Both coordinates are 0-based, matching the editor cursor. Returns
+// nil when no buffer is active or the buffer carries no diagnostics.
+func (m model) diagnosticPositions() []diagPos {
+	p := m.bufs.Active()
+	if p == nil || p.Path() == "" {
+		return nil
+	}
+	items := m.diagnostics[p.Path()]
+	if len(items) == 0 {
+		return nil
+	}
+	pos := make([]diagPos, 0, len(items))
+	for _, d := range items {
+		pos = append(pos, diagPos{Row: int(d.Range.Start.Line), Col: int(d.Range.Start.Character)})
+	}
+	sort.Slice(pos, func(i, j int) bool {
+		if pos[i].Row != pos[j].Row {
+			return pos[i].Row < pos[j].Row
+		}
+		return pos[i].Col < pos[j].Col
+	})
+	out := pos[:1]
+	for _, q := range pos[1:] {
+		if last := out[len(out)-1]; q == last {
+			continue
+		}
+		out = append(out, q)
+	}
+	return out
+}
+
+type diagPos struct{ Row, Col int }
+
+// jumpDiagnostic moves the cursor to the next (forward) or previous diagnostic
+// in the active buffer, wrapping around the ends. The cursor position is
+// recorded in the jump list first so Alt+- returns to it. A no-op with a status
+// hint when the buffer has no diagnostics.
+func (m model) jumpDiagnostic(forward bool) (tea.Model, tea.Cmd) {
+	pos := m.diagnosticPositions()
+	if len(pos) == 0 {
+		m.status = "no diagnostics in buffer"
+		return m, nil
+	}
+	p := m.bufs.Active()
+	curRow, curCol := p.CursorRow(), p.CursorCol()
+	target := -1
+	if forward {
+		for i, q := range pos {
+			if q.Row > curRow || (q.Row == curRow && q.Col > curCol) {
+				target = i
+				break
+			}
+		}
+		if target == -1 {
+			target = 0 // past the last diagnostic: wrap to the first
+		}
+	} else {
+		for i := len(pos) - 1; i >= 0; i-- {
+			if q := pos[i]; q.Row < curRow || (q.Row == curRow && q.Col < curCol) {
+				target = i
+				break
+			}
+		}
+		if target == -1 {
+			target = len(pos) - 1 // before the first diagnostic: wrap to the last
+		}
+	}
+	t := pos[target]
+	m.pushNavCurrent()
+	*p = p.JumpTo(t.Row+1, t.Col+1).Focus()
+	m = m.resize()
+	m.status = fmt.Sprintf("diagnostic %d/%d — L%d:%d", target+1, len(pos), t.Row+1, t.Col+1)
+	return m, tea.Batch(m.refreshGutterCmd(), m.refreshInlayHintsCmd(), m.refreshBlameCmd())
+}
+
 func renderDiff(t theme.Theme, title, body string, w, h int) string {
 	header := lipgloss.NewStyle().Foreground(t.TextMuted).Bold(true).Render("diff: " + title)
 	addStyle := lipgloss.NewStyle().Foreground(t.Success)

cmd/nook/main_test.go

@@ -690,6 +690,123 @@ func TestDiagCounts(t *testing.T) {
 	}
 }
 
+// diagJumpModel builds a hermetic model with a single buffer open and three
+// diagnostics seeded on content lines (rows 2, 4, 6, cols within the line
+// length so JumpTo does not clamp), returned unsorted to prove the jump path
+// sorts them. The cursor starts at row 0, col 0.
+func diagJumpModel(t *testing.T) (model, string) {
+	t.Helper()
+	root := t.TempDir()
+	path := filepath.Join(root, "a.go")
+	body := "package main\n\nfunc a() {}\n\nfunc b() {}\n\nfunc c() {}\n"
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	m := newModel(root)
+	m.width, m.height = 100, 30
+	m = m.resize()
+	m.bufs.OpenOrSwitch(path)
+	m.diagnostics[path] = []protocol.Diagnostic{
+		{Range: protocol.Range{Start: protocol.Position{Line: 6, Character: 2}}, Severity: protocol.DiagnosticSeverityWarning, Message: "c"},
+		{Range: protocol.Range{Start: protocol.Position{Line: 2, Character: 0}}, Severity: protocol.DiagnosticSeverityError, Message: "a"},
+		{Range: protocol.Range{Start: protocol.Position{Line: 4, Character: 5}}, Severity: protocol.DiagnosticSeverityWarning, Message: "b"},
+	}
+	return m, path
+}
+
+// TestJumpDiagnosticForwardWraps walks F8 through all three diagnostics in
+// sorted order and confirms the fourth press wraps to the first.
+func TestJumpDiagnosticForwardWraps(t *testing.T) {
+	m, _ := diagJumpModel(t)
+	want := []struct{ row, col int }{{2, 0}, {4, 5}, {6, 2}, {2, 0}}
+	for i, w := range want {
+		updated, _ := m.jumpDiagnostic(true)
+		m = updated.(model)
+		p := m.bufs.Active()
+		if p.CursorRow() != w.row || p.CursorCol() != w.col {
+			t.Fatalf("forward step %d: cursor at (%d,%d), want (%d,%d)", i, p.CursorRow(), p.CursorCol(), w.row, w.col)
+		}
+	}
+}
+
+// TestJumpDiagnosticBackwardWraps confirms Alt+F8 from the top of the buffer
+// wraps to the last diagnostic, then walks upward in order.
+func TestJumpDiagnosticBackwardWraps(t *testing.T) {
+	m, _ := diagJumpModel(t)
+	want := []struct{ row, col int }{{6, 2}, {4, 5}, {2, 0}, {6, 2}}
+	for i, w := range want {
+		updated, _ := m.jumpDiagnostic(false)
+		m = updated.(model)
+		p := m.bufs.Active()
+		if p.CursorRow() != w.row || p.CursorCol() != w.col {
+			t.Fatalf("backward step %d: cursor at (%d,%d), want (%d,%d)", i, p.CursorRow(), p.CursorCol(), w.row, w.col)
+		}
+	}
+}
+
+// TestJumpDiagnosticF8KeyWiring proves the F8 / Alt+F8 keys are routed into
+// jumpDiagnostic through the real Update path, not just the helper.
+func TestJumpDiagnosticF8KeyWiring(t *testing.T) {
+	m, _ := diagJumpModel(t)
+	updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyF8})
+	m = updated.(model)
+	if p := m.bufs.Active(); p.CursorRow() != 2 {
+		t.Fatalf("F8 should move cursor to first diagnostic row 2, got %d", p.CursorRow())
+	}
+	updated, _ = m.Update(tea.KeyMsg{Type: tea.KeyF8, Alt: true})
+	m = updated.(model)
+	if p := m.bufs.Active(); p.CursorRow() != 6 {
+		t.Fatalf("Alt+F8 from row 2 should wrap back to last diagnostic row 6, got %d", p.CursorRow())
+	}
+}
+
+// TestJumpDiagnosticNoDiagnostics confirms the jump is a no-op with a status
+// hint when the buffer carries no diagnostics — the mutation-proof: strip the
+// seeded map and the cursor must not move.
+func TestJumpDiagnosticNoDiagnostics(t *testing.T) {
+	m, path := diagJumpModel(t)
+	delete(m.diagnostics, path)
+	if got := m.diagnosticPositions(); got != nil {
+		t.Fatalf("diagnosticPositions should be nil with no diagnostics, got %v", got)
+	}
+	before := m.bufs.Active().CursorRow()
+	updated, _ := m.jumpDiagnostic(true)
+	m = updated.(model)
+	if p := m.bufs.Active(); p.CursorRow() != before {
+		t.Fatalf("cursor moved from %d to %d despite no diagnostics", before, p.CursorRow())
+	}
+	if m.status != "no diagnostics in buffer" {
+		t.Fatalf("status = %q, want no-diagnostics hint", m.status)
+	}
+}
+
+// TestDiagnosticPositionsSortedDeduped proves the position list is sorted and
+// collapses duplicate diagnostics sharing one (row,col).
+func TestDiagnosticPositionsSortedDeduped(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "a.go")
+	if err := os.WriteFile(path, []byte("package main\n\nfunc a() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	m := newModel(root)
+	m.bufs.OpenOrSwitch(path)
+	m.diagnostics[path] = []protocol.Diagnostic{
+		{Range: protocol.Range{Start: protocol.Position{Line: 2, Character: 5}}, Message: "dup2"},
+		{Range: protocol.Range{Start: protocol.Position{Line: 0, Character: 0}}, Message: "first"},
+		{Range: protocol.Range{Start: protocol.Position{Line: 2, Character: 5}}, Message: "dup1"},
+	}
+	got := m.diagnosticPositions()
+	want := []diagPos{{0, 0}, {2, 5}}
+	if len(got) != len(want) {
+		t.Fatalf("positions len=%d want %d (%v)", len(got), len(want), got)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("position %d = %v, want %v", i, got[i], want[i])
+		}
+	}
+}
+
 // TestTabFlowMultipleBuffers exercises the full v0.4.0 tab story end-to-end:
 // open three buffers, walk forward/back with Alt+]/Alt+[, close with Ctrl+W,
 // and verify the welcome card returns when the last buffer closes.