Add git blame gutter toggle (B key)

Show author name and relative commit age per line in a gutter column,
toggled with the B key. Blame data loads asynchronously via git blame
and is keyed by new-side line numbers (blank for removed lines/dividers).

- Add diff/blame.go with FileBlame parser and RelativeAge formatter
- Add Blamer interface in ui/, wired via ModelConfig from cmd/main.go
- Add blameGutter rendering in diffview.go alongside lineNumGutter
- Extract shared gutter helpers (lineGutters, gutterExtra, gutterBlanks,
  applyHorizontalScroll) to reduce duplication across render paths
- Add ActionToggleBlame keymap action bound to B
- Update status bar mode icons to show @ when blame is active
- Update README, docs, site, CLAUDE.md, and plugin references

Author: melonamin

.claude-plugin/skills/revdiff/references/usage.md

@@ -99,6 +99,7 @@ When `--only` specifies a file that has no git changes (or when no git repo exis
 | `w` | Toggle word wrap (long lines wrap with `↪` continuation markers) |
 | `t` | Toggle tree/TOC pane visibility (gives diff full terminal width) |
 | `L` | Toggle line numbers (side-by-side old/new numbers in gutter) |
+| `B` | Toggle git blame gutter (author name + commit age per line) |
 | `.` | Expand/collapse individual hunk under cursor (collapsed mode only) |
 | `f` | Toggle filter: all files / annotated only |
 | `?` | Toggle help overlay showing all keybindings |

CLAUDE.md

@@ -38,6 +38,11 @@ git diff → diff.ParseUnifiedDiff() → []DiffLine
     lineNumGutter(dl) formats " OOO NNN" gutter via m.styles.LineNumber,
     prepended in renderDiffLine, renderWrappedDiffLine, renderCollapsedAddLine, renderDeletePlaceholder
     lineNumWidth recomputed per file in handleFileLoaded; lineNumGutterWidth() = 2*W+2
+  when blame gutter is on (`B` toggle, orthogonal to above):
+    blameGutter(dl) formats " author age" gutter via m.styles.LineNumber,
+    prepended after lineNumGutter in renderDiffLine, renderWrappedDiffLine, renderCollapsedAddLine, renderDeletePlaceholder
+    blame data loaded async via loadBlame() → blameLoadedMsg; keyed by NewNum (blank for removed lines/dividers)
+    blameAuthorLen capped at 8; blameGutterWidth() = W+5; Blamer interface (optional, nil when git unavailable)
   when wrap mode is on (`w` toggle, orthogonal to above):
     wrapContent() splits long lines via ansi.Wrap,
     continuation lines get `↪` gutter marker, cursorViewportY() sums wrapped line counts
@@ -98,7 +103,7 @@ git diff → diff.ParseUnifiedDiff() → []DiffLine
 - Help overlay uses `overlayCenter()` (ANSI-aware compositing via `charmbracelet/x/ansi.Cut`) to render on top of existing content; background (tree pane) remains visible at the edges
 - **ANSI nesting with lipgloss**: `lipgloss.Render()` emits `\033[0m` (full reset) which breaks outer style backgrounds. For styled substrings inside a lipgloss container (status bar separators, search highlights), use raw ANSI sequences via `ansiColor(hex, code)` — code 38 for fg, 48 for bg. Never use `lipgloss.NewStyle().Render()` for inline elements within a lipgloss-rendered parent.
 - **Background fill for themed panes**: lipgloss pane `Render()` and viewport internal padding emit plain spaces after `\033[0m` reset, causing pane background to show terminal default. Three workarounds: (1) `extendLineBg()` pads individual add/remove/modify lines to full content width with their specific bg color; (2) `padContentBg()` strips viewport trailing spaces and re-pads every line of pane content with DiffBg/TreeBg; (3) `BorderBackground()` is set on pane border styles to match pane bg. Context and line-number styles also set DiffBg explicitly via `contextStyle()`/`lineNumberStyle()`/`contextHighlightStyle()`.
-- Status bar mode icons (`▼ ◉ ↩ ≋ ⊟ #`) are always rendered on the right side via `statusModeIcons()`. `⊟` indicates tree/TOC pane hidden via `t` toggle. Active modes use `StatusFg`, inactive use `Muted` — both via raw ANSI fg sequences. Graceful degradation on narrow terminals drops left segments: search position first (`statusSegmentsNoSearch`), then line number and hunk info (`statusSegmentsMinimal`), then truncates filename.
+- Status bar mode icons (`▼ ◉ ↩ ≋ ⊟ # @`) are always rendered on the right side via `statusModeIcons()`. `@` indicates blame gutter active via `B` toggle. `⊟` indicates tree/TOC pane hidden via `t` toggle. Active modes use `StatusFg`, inactive use `Muted` — both via raw ANSI fg sequences. Graceful degradation on narrow terminals drops left segments: search position first (`statusSegmentsNoSearch`), then line number and hunk info (`statusSegmentsMinimal`), then truncates filename.
 - Search and hunk navigation both use `centerViewportOnCursor()` to center the target in the middle of the viewport. Use `syncViewportToCursor()` only for cursor movements that should keep the cursor barely visible (j/k scrolling).
 - Single-file mode (`m.singleFile`): when diff has exactly one file, tree pane is hidden, `treeWidth = 0`, diff gets full width (`m.width - 2` for borders, content width `m.width - 3`). Pane-switching keys (tab, h, l) and file navigation (n/p, f) become no-ops. Search nav (n/N) still works. Detection happens in `handleFilesLoaded`. Exception: when the file is markdown and full-context (all `ChangeContext` lines), an `mdTOC` pane replaces the tree pane with header navigation — see `ui/mdtoc.go`.
 - Tree pane toggle (`t` key): `m.treeHidden` hides the tree/TOC pane and gives diff full width. Orthogonal to `singleFile` — sets `treeWidth = 0`, forces `focus = paneDiff`, blocks `togglePane()`/`handleSwitchToTree()`. `handleViewToggle()` dispatches `v`, `w`, `t`, and `L` keys. `handleFileLoaded` respects `treeHidden` when setting up mdTOC layout.

README.md

@@ -11,6 +11,7 @@ Built for a specific use case: reviewing code changes, plans, and documents with
 - Collapsed diff mode: shows final text with change markers, toggle with `v`
 - Word wrap mode: wraps long lines at viewport boundary with `↪` continuation markers, toggle with `w`
 - Line numbers: side-by-side old/new line number gutter, toggle with `L`
+- Git blame gutter: shows author name and commit age per line, toggle with `B`
 - Annotate any line in the diff (added, removed, or context) plus file-level notes
 - Single-file auto-detection: when a diff contains exactly one file, hides the tree pane and gives full terminal width to the diff view
 - Two-pane TUI: file tree (left) + colorized diff viewport (right)
@@ -397,6 +398,7 @@ This mode activates when all three conditions are met: single file, markdown ext
 | `w` | Toggle word wrap (long lines wrap with `↪` continuation markers) |
 | `t` | Toggle tree/TOC pane visibility (gives diff full terminal width) |
 | `L` | Toggle line numbers (side-by-side old/new numbers in gutter) |
+| `B` | Toggle git blame gutter (author name + commit age per line) |
 | `.` | Expand/collapse individual hunk under cursor (collapsed mode only) |
 | `f` | Toggle filter: all files / annotated only (shown when annotations exist) |
 | `?` | Toggle help overlay showing all keybindings |

cmd/revdiff/main.go

@@ -280,8 +280,16 @@ func run(opts options) error {
 		keysPath = defaultKeysPath()
 	}
 	km := keymap.LoadOrDefault(keysPath)
+
+	// blame is only available when git is present
+	var blamer ui.Blamer
+	if gitErr == nil {
+		blamer = diff.NewGit(gitRoot)
+	}
+
 	model := ui.NewModel(renderer, store, hl, ui.ModelConfig{
 		Keymap:           km,
+		Blamer:           blamer,
 		NoColors:         opts.NoColors,
 		NoStatusBar:      opts.NoStatusBar,
 		NoConfirmDiscard: opts.NoConfirmDiscard,

diff/blame.go

@@ -0,0 +1,149 @@
+package diff
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// BlameLine holds blame information for a single line of a file.
+type BlameLine struct {
+	Author string
+	Time   time.Time
+}
+
+// FileBlame returns blame information for each line of the rendered side of a file diff.
+// For unstaged single-ref diffs this is the worktree; for two-ref diffs this is the target ref.
+// For staged diffs this is the index snapshot. The returned map is keyed by 1-based line
+// number (matching DiffLine.NewNum).
+func (g *Git) FileBlame(ref string, file string, staged bool) (map[int]BlameLine, error) {
+	args := []string{"blame", "--line-porcelain"}
+	if staged {
+		indexContent, err := g.runGit("show", ":"+file)
+		if err != nil {
+			return nil, fmt.Errorf("read index contents for %s: %w", file, err)
+		}
+
+		tmp, err := os.CreateTemp("", "revdiff-blame-*")
+		if err != nil {
+			return nil, fmt.Errorf("create temp blame file for %s: %w", file, err)
+		}
+		tmpName := tmp.Name()
+		defer os.Remove(tmpName)
+		if _, err := tmp.WriteString(indexContent); err != nil {
+			tmp.Close()
+			return nil, fmt.Errorf("write temp blame file for %s: %w", file, err)
+		}
+		if err := tmp.Close(); err != nil {
+			return nil, fmt.Errorf("close temp blame file for %s: %w", file, err)
+		}
+
+		args = append(args, "--contents", tmpName)
+	} else if targetRef := blameTargetRef(ref); targetRef != "" {
+		args = append(args, targetRef)
+	}
+	args = append(args, "--", file)
+	out, err := g.runGit(args...)
+	if err != nil {
+		return nil, fmt.Errorf("blame %s: %w", file, err)
+	}
+	return parseBlame(out)
+}
+
+func blameTargetRef(ref string) string {
+	parts := strings.Split(ref, "..")
+	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
+		return ""
+	}
+	return parts[1]
+}
+
+// parseBlame parses git blame --line-porcelain output into a map of line number to BlameLine.
+func parseBlame(raw string) (map[int]BlameLine, error) {
+	result := make(map[int]BlameLine)
+	scanner := bufio.NewScanner(strings.NewReader(raw))
+	scanner.Buffer(make([]byte, 0, bufio.MaxScanTokenSize), 1024*1024)
+
+	var lineNum int
+	var author string
+	var authorTime time.Time
+
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		// header line: <40-hex-hash> <orig_line> <final_line> [<group_lines>]
+		if len(line) >= 40 && isHexString(line[:40]) {
+			parts := strings.Fields(line)
+			if len(parts) >= 3 {
+				if n, err := strconv.Atoi(parts[2]); err == nil {
+					lineNum = n
+				}
+			}
+			author = ""
+			authorTime = time.Time{}
+			continue
+		}
+
+		if v, ok := strings.CutPrefix(line, "author "); ok {
+			author = v
+			continue
+		}
+
+		if v, ok := strings.CutPrefix(line, "author-time "); ok {
+			if epoch, err := strconv.ParseInt(v, 10, 64); err == nil {
+				authorTime = time.Unix(epoch, 0)
+			}
+			continue
+		}
+
+		// content line (starts with tab) marks end of entry
+		if strings.HasPrefix(line, "\t") && lineNum > 0 {
+			result[lineNum] = BlameLine{Author: author, Time: authorTime}
+			continue
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("scan blame output: %w", err)
+	}
+	return result, nil
+}
+
+// isHexString returns true if all characters in s are hexadecimal digits.
+func isHexString(s string) bool {
+	if s == "" {
+		return false
+	}
+	for _, c := range s {
+		if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
+			return false
+		}
+	}
+	return true
+}
+
+// RelativeAge formats a timestamp as a compact relative age string (3 chars wide).
+// Examples: " 5m" (minutes), " 3h" (hours), " 2d" (days), " 1w" (weeks), " 4M" (months), " 2y" (years).
+func RelativeAge(t, now time.Time) string {
+	if t.IsZero() {
+		return "  ?"
+	}
+	d := max(0, now.Sub(t))
+	switch {
+	case d < time.Hour:
+		return fmt.Sprintf("%2dm", max(1, int(d.Minutes())))
+	case d < 24*time.Hour:
+		return fmt.Sprintf("%2dh", int(d.Hours()))
+	case d < 7*24*time.Hour:
+		return fmt.Sprintf("%2dd", int(d.Hours()/24))
+	case d < 30*24*time.Hour:
+		return fmt.Sprintf("%2dw", int(d.Hours()/(24*7)))
+	case d < 365*24*time.Hour:
+		return fmt.Sprintf("%2dM", int(d.Hours()/(24*30)))
+	default:
+		return fmt.Sprintf("%2dy", int(d.Hours()/(24*365)))
+	}
+}

diff/blame_test.go

@@ -0,0 +1,174 @@
+package diff
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseBlame(t *testing.T) {
+	// simulated git blame --line-porcelain output for a 3-line file
+	raw := "abc1234567890123456789012345678901234567 1 1 2\n" +
+		"author Alice\n" +
+		"author-mail <alice@example.com>\n" +
+		"author-time 1700000000\n" +
+		"author-tz +0000\n" +
+		"committer Alice\n" +
+		"committer-mail <alice@example.com>\n" +
+		"committer-time 1700000000\n" +
+		"committer-tz +0000\n" +
+		"summary initial commit\n" +
+		"filename main.go\n" +
+		"\tpackage main\n" +
+		"abc1234567890123456789012345678901234567 1 2\n" +
+		"author Alice\n" +
+		"author-mail <alice@example.com>\n" +
+		"author-time 1700000000\n" +
+		"author-tz +0000\n" +
+		"committer Alice\n" +
+		"committer-mail <alice@example.com>\n" +
+		"committer-time 1700000000\n" +
+		"committer-tz +0000\n" +
+		"summary initial commit\n" +
+		"filename main.go\n" +
+		"\t\n" +
+		"def4567890123456789012345678901234567890 3 3 1\n" +
+		"author Bob\n" +
+		"author-mail <bob@example.com>\n" +
+		"author-time 1710000000\n" +
+		"author-tz -0500\n" +
+		"committer Bob\n" +
+		"committer-mail <bob@example.com>\n" +
+		"committer-time 1710000000\n" +
+		"committer-tz -0500\n" +
+		"summary add feature\n" +
+		"previous abc1234567890123456789012345678901234567 main.go\n" +
+		"filename main.go\n" +
+		"\tfunc main() {}\n"
+
+	result, err := parseBlame(raw)
+	require.NoError(t, err)
+	assert.Len(t, result, 3)
+
+	assert.Equal(t, "Alice", result[1].Author)
+	assert.Equal(t, time.Unix(1700000000, 0), result[1].Time)
+
+	assert.Equal(t, "Alice", result[2].Author)
+	assert.Equal(t, time.Unix(1700000000, 0), result[2].Time)
+
+	assert.Equal(t, "Bob", result[3].Author)
+	assert.Equal(t, time.Unix(1710000000, 0), result[3].Time)
+}
+
+func TestParseBlame_empty(t *testing.T) {
+	result, err := parseBlame("")
+	require.NoError(t, err)
+	assert.Empty(t, result)
+}
+
+func TestIsHexString(t *testing.T) {
+	assert.True(t, isHexString("abcdef0123456789"))
+	assert.True(t, isHexString("ABCDEF"))
+	assert.False(t, isHexString("xyz"))
+	assert.False(t, isHexString(""))
+}
+
+func TestRelativeAge(t *testing.T) {
+	now := time.Date(2026, 4, 6, 12, 0, 0, 0, time.UTC)
+
+	tests := []struct {
+		name string
+		t    time.Time
+		want string
+	}{
+		{"zero", time.Time{}, "  ?"},
+		{"30 seconds", now.Add(-30 * time.Second), " 1m"},
+		{"5 minutes", now.Add(-5 * time.Minute), " 5m"},
+		{"59 minutes", now.Add(-59 * time.Minute), "59m"},
+		{"1 hour", now.Add(-1 * time.Hour), " 1h"},
+		{"23 hours", now.Add(-23 * time.Hour), "23h"},
+		{"1 day", now.Add(-24 * time.Hour), " 1d"},
+		{"6 days", now.Add(-6 * 24 * time.Hour), " 6d"},
+		{"1 week", now.Add(-7 * 24 * time.Hour), " 1w"},
+		{"3 weeks", now.Add(-21 * 24 * time.Hour), " 3w"},
+		{"2 months", now.Add(-60 * 24 * time.Hour), " 2M"},
+		{"11 months", now.Add(-330 * 24 * time.Hour), "11M"},
+		{"1 year", now.Add(-365 * 24 * time.Hour), " 1y"},
+		{"3 years", now.Add(-3 * 365 * 24 * time.Hour), " 3y"},
+		{"future", now.Add(1 * time.Hour), " 1m"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := RelativeAge(tt.t, now)
+			assert.Equal(t, tt.want, got)
+			assert.Len(t, got, 3, "age string should be exactly 3 chars wide")
+		})
+	}
+}
+
+func TestGit_FileBlame_UsesWorktreeForSingleRefDiffs(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := NewGit(dir)
+
+	writeFile(t, dir, "f.txt", "one\ntwo\n")
+	gitCmd(t, dir, "add", "f.txt")
+	gitCmd(t, dir, "commit", "-m", "initial")
+
+	writeFile(t, dir, "f.txt", "one\ntwo committed\n")
+	gitCmd(t, dir, "add", "f.txt")
+	gitCmd(t, dir, "commit", "-m", "second")
+
+	writeFile(t, dir, "f.txt", "one\ntwo worktree\n")
+
+	result, err := g.FileBlame("HEAD~1", "f.txt", false)
+	require.NoError(t, err)
+	require.Len(t, result, 2)
+
+	assert.Equal(t, "Test", result[1].Author)
+	assert.Equal(t, "Not Committed Yet", result[2].Author)
+}
+
+func TestGit_FileBlame_UsesTargetRefForTwoRefDiffs(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := NewGit(dir)
+
+	writeFile(t, dir, "f.txt", "one\ntwo\n")
+	gitCmd(t, dir, "add", "f.txt")
+	gitCmd(t, dir, "commit", "-m", "initial")
+
+	writeFile(t, dir, "f.txt", "one\ntwo target\n")
+	gitCmd(t, dir, "add", "f.txt")
+	gitCmd(t, dir, "commit", "-m", "target")
+
+	writeFile(t, dir, "f.txt", "one\ntwo worktree\n")
+
+	result, err := g.FileBlame("HEAD~1..HEAD", "f.txt", false)
+	require.NoError(t, err)
+	require.Len(t, result, 2)
+
+	assert.Equal(t, "Test", result[1].Author)
+	assert.Equal(t, "Test", result[2].Author)
+}
+
+func TestGit_FileBlame_UsesIndexForStagedDiffs(t *testing.T) {
+	dir := setupTestRepo(t)
+	g := NewGit(dir)
+
+	writeFile(t, dir, "f.txt", "one\ntwo\n")
+	gitCmd(t, dir, "add", "f.txt")
+	gitCmd(t, dir, "commit", "-m", "initial")
+
+	writeFile(t, dir, "f.txt", "one\ntwo staged\n")
+	gitCmd(t, dir, "add", "f.txt")
+
+	writeFile(t, dir, "f.txt", "one\ntwo unstaged\n")
+
+	result, err := g.FileBlame("", "f.txt", true)
+	require.NoError(t, err)
+	require.Len(t, result, 2)
+
+	assert.Equal(t, "Test", result[1].Author)
+	assert.Equal(t, "External file (--contents)", result[2].Author)
+}