feat: side by side diff with reflow/truncation

Taskfile.yml

···
 vars:
   BINARY_NAME: storm
   BUILD_DIR: ./tmp
-  MAIN_PATH: ./main.go
+  MAIN_PATH: ./cmd/main.go
   VERSION:
     sh: git describe --tags --always --dirty 2>/dev/null || echo "dev"
 

cmd/main_test.go

···
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stormlightlabs/git-storm/internal/testutils"
+)
+
+func TestParseRefArgs(t *testing.T) {
+	tests := []struct {
+		name         string
+		args         []string
+		expectedFrom string
+		expectedTo   string
+	}{
+		{
+			name:         "range syntax with full hashes",
+			args:         []string{"abc123..def456"},
+			expectedFrom: "abc123",
+			expectedTo:   "def456",
+		},
+		{
+			name:         "range syntax with truncated hashes",
+			args:         []string{"7de6f6d..18363c2"},
+			expectedFrom: "7de6f6d",
+			expectedTo:   "18363c2",
+		},
+		{
+			name:         "range syntax with tags",
+			args:         []string{"v1.0.0..v2.0.0"},
+			expectedFrom: "v1.0.0",
+			expectedTo:   "v2.0.0",
+		},
+		{
+			name:         "two separate arguments",
+			args:         []string{"abc123", "def456"},
+			expectedFrom: "abc123",
+			expectedTo:   "def456",
+		},
+		{
+			name:         "single argument compares with HEAD",
+			args:         []string{"abc123"},
+			expectedFrom: "abc123",
+			expectedTo:   "HEAD",
+		},
+		{
+			name:         "branch names",
+			args:         []string{"main", "feature-branch"},
+			expectedFrom: "main",
+			expectedTo:   "feature-branch",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			from, to := parseRefArgs(tt.args)
+
+			if from != tt.expectedFrom {
+				t.Errorf("parseRefArgs() from = %v, want %v", from, tt.expectedFrom)
+			}
+			if to != tt.expectedTo {
+				t.Errorf("parseRefArgs() to = %v, want %v", to, tt.expectedTo)
+			}
+		})
+	}
+}
+
+func TestGetChangedFiles(t *testing.T) {
+	repo := testutils.SetupTestRepo(t)
+	commits := testutils.GetCommitHistory(t, repo)
+
+	if len(commits) < 2 {
+		t.Fatal("Test repo should have at least 2 commits")
+	}
+
+	fromHash := commits[1].Hash.String()
+	toHash := commits[0].Hash.String()
+
+	files, err := getChangedFiles(repo, fromHash, toHash)
+	if err != nil {
+		t.Fatalf("getChangedFiles() error = %v", err)
+	}
+
+	if len(files) == 0 {
+		t.Error("Expected at least one changed file")
+	}
+
+	for _, file := range files {
+		if file == "" {
+			t.Error("File path should not be empty")
+		}
+	}
+}
+
+func TestGetChangedFiles_NoChanges(t *testing.T) {
+	repo := testutils.SetupTestRepo(t)
+
+	commits := testutils.GetCommitHistory(t, repo)
+	if len(commits) == 0 {
+		t.Fatal("Test repo should have at least 1 commit")
+	}
+
+	hash := commits[0].Hash.String()
+
+	files, err := getChangedFiles(repo, hash, hash)
+	if err != nil {
+		t.Fatalf("getChangedFiles() error = %v", err)
+	}
+
+	if len(files) != 0 {
+		t.Errorf("Expected no changed files when comparing commit with itself, got %d", len(files))
+	}
+}
+
+func TestGetFileContent(t *testing.T) {
+	repo := testutils.SetupTestRepo(t)
+
+	commits := testutils.GetCommitHistory(t, repo)
+	if len(commits) == 0 {
+		t.Fatal("Test repo should have at least 1 commit")
+	}
+
+	hash := commits[0].Hash.String()
+
+	content, err := getFileContent(repo, hash, "README.md")
+	if err != nil {
+		t.Fatalf("getFileContent() error = %v", err)
+	}
+
+	if content == "" {
+		t.Error("Expected non-empty content for README.md")
+	}
+
+	if !strings.Contains(content, "Project") {
+		t.Error("README.md should contain 'Project'")
+	}
+}
+
+func TestGetFileContent_FileNotFound(t *testing.T) {
+	repo := testutils.SetupTestRepo(t)
+
+	commits := testutils.GetCommitHistory(t, repo)
+	if len(commits) == 0 {
+		t.Fatal("Test repo should have at least 1 commit")
+	}
+
+	hash := commits[0].Hash.String()
+
+	_, err := getFileContent(repo, hash, "nonexistent.txt")
+	if err == nil {
+		t.Error("Expected error when reading nonexistent file")
+	}
+}
+
+func TestGetFileContent_InvalidRef(t *testing.T) {
+	repo := testutils.SetupTestRepo(t)
+
+	_, err := getFileContent(repo, "invalid-ref-12345", "README.md")
+	if err == nil {
+		t.Error("Expected error when using invalid ref")
+	}
+}

go.mod

···
 	github.com/clipperhouse/displaywidth v0.4.1 // indirect
 	github.com/clipperhouse/stringish v0.1.1 // indirect
 	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
+	github.com/muesli/reflow v0.3.0
 )
 
 require (

go.sum

···
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
 github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
 github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
 github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
···
 github.com/muesli/mango-cobra v1.2.0/go.mod h1:vMJL54QytZAJhCT13LPVDfkvCUJ5/4jNUKF/8NC2UjA=
 github.com/muesli/mango-pflag v0.1.0 h1:UADqbYgpUyRoBja3g6LUL+3LErjpsOwaC9ywvBWe7Sg=
 github.com/muesli/mango-pflag v0.1.0/go.mod h1:YEQomTxaCUp8PrbhFh10UfbhbQrM/xJ4i2PB8VTLLW0=
+github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
+github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
 github.com/muesli/roff v0.1.0 h1:YD0lalCotmYuF5HhZliKWlIx7IEhiXeSfq7hNjFqGF8=
 github.com/muesli/roff v0.1.0/go.mod h1:pjAHQM9hdUUwm/krAfrLGgJkXJ+YuhtsfZ42kieB2Ig=
 github.com/muesli/termenv v0.16.0 h1:S5AlUN9dENB57rsbnkPyfdGuWIlkmzJjbFf0Tf5FWUc=
···
 github.com/pjbgf/sha1cd v0.5.0/go.mod h1:lhpGlyHLpQZoxMv8HcgXvZEhcGs0PG/vsZnEJ7H0iCM=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=

internal/diff/diff.go

···
 
 // Edit represents a single edit operation in a diff.
 type Edit struct {
-	Kind    EditKind // Equal, Insert, or Delete
-	AIndex  int      // index in original sequence
-	BIndex  int      // index in new sequence
-	Content string   // the line or token
+	Kind       EditKind // Equal, Insert, Delete, or Replace
+	AIndex     int      // index in original sequence (-1 for Insert-only)
+	BIndex     int      // index in new sequence (-1 for Delete-only)
+	Content    string   // the line or token (old content for Replace)
+	NewContent string   // new content (only used for Replace operations)
 }
 
 // Diff represents a generic diffing algorithm.
···
 	}
 	return counts
 }
+
+// MergeReplacements merges Delete+Insert pairs into Replace operations for better side-by-side rendering.
+//
+// This function identifies blocks of Delete and Insert operations and pairs them up based on similarity.
+// When a Delete and Insert represent the same logical line being modified (e.g., version bump),
+// they are merged into a Replace operation that can be rendered on a single line.
+//
+// The function uses a similarity heuristic to determine if a Delete and Insert pair should be merged:
+// - They must share a common prefix of at least 70% of the shorter line's length
+// - This prevents merging unrelated changes (e.g., different package names)
+//
+// The algorithm processes edits in windows, looking ahead up to 10 positions to find matching pairs.
+func MergeReplacements(edits []Edit) []Edit {
+	if len(edits) <= 1 {
+		return edits
+	}
+
+	type mergeInfo struct {
+		partnIndex int // index of the partner edit
+		isDelete   bool
+	}
+
+	merged := make(map[int]mergeInfo)
+	const lookAheadWindow = 50
+
+	for i := range edits {
+		if _, exists := merged[i]; exists || edits[i].Kind != Delete {
+			continue
+		}
+
+		found := false
+		for j := i + 1; j < len(edits) && j < i+lookAheadWindow; j++ {
+			if _, exists := merged[j]; exists || edits[j].Kind != Insert {
+				continue
+			}
+
+			if areSimilarLines(edits[i].Content, edits[j].Content) {
+				merged[i] = mergeInfo{partnIndex: j, isDelete: true}
+				merged[j] = mergeInfo{partnIndex: i, isDelete: false}
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			for j := i - 1; j >= 0 && j >= i-lookAheadWindow; j-- {
+				if _, exists := merged[j]; exists || edits[j].Kind != Insert {
+					continue
+				}
+
+				if areSimilarLines(edits[i].Content, edits[j].Content) {
+					merged[i] = mergeInfo{partnIndex: j, isDelete: true}
+					merged[j] = mergeInfo{partnIndex: i, isDelete: false}
+					break
+				}
+			}
+		}
+	}
+
+	for i := 0; i < len(edits); i++ {
+		if _, exists := merged[i]; exists || edits[i].Kind != Insert {
+			continue
+		}
+
+		for j := max(0, i-lookAheadWindow); j < i; j++ {
+			if _, exists := merged[j]; exists || edits[j].Kind != Delete {
+				continue
+			}
+
+			if areSimilarLines(edits[j].Content, edits[i].Content) {
+				merged[j] = mergeInfo{partnIndex: i, isDelete: true}
+				merged[i] = mergeInfo{partnIndex: j, isDelete: false}
+				break
+			}
+		}
+	}
+
+	type outputEdit struct {
+		edit         Edit
+		origPosition int
+	}
+
+	outputs := make([]outputEdit, 0, len(edits))
+
+	for i := range edits {
+		info, isMerged := merged[i]
+		if !isMerged {
+			outputs = append(outputs, outputEdit{
+				edit:         edits[i],
+				origPosition: i,
+			})
+		} else if info.isDelete {
+			outputs = append(outputs, outputEdit{
+				edit: Edit{
+					Kind:       Replace,
+					AIndex:     edits[i].AIndex,
+					BIndex:     edits[info.partnIndex].BIndex,
+					Content:    edits[i].Content,
+					NewContent: edits[info.partnIndex].Content,
+				},
+				origPosition: i,
+			})
+		}
+	}
+
+	for i := 0; i < len(outputs); i++ {
+		for j := i + 1; j < len(outputs); j++ {
+			ei := outputs[i].edit
+			ej := outputs[j].edit
+
+			// Get effective sort keys
+			keyI := ei.BIndex
+			if keyI == -1 {
+				keyI = ei.AIndex
+			}
+
+			keyJ := ej.BIndex
+			if keyJ == -1 {
+				keyJ = ej.AIndex
+			}
+
+			if keyI > keyJ {
+				outputs[i], outputs[j] = outputs[j], outputs[i]
+			}
+		}
+	}
+
+	result := make([]Edit, 0, len(outputs))
+	for _, out := range outputs {
+		result = append(result, out.edit)
+	}
+
+	return result
+}
+
+// areSimilarLines determines if two lines are similar enough to be considered a replacement.
+//
+// Uses a two-phase similarity check:
+// 1. Common prefix must be at least 70% of the shorter line
+// 2. Remaining suffixes must be at least 60% similar (Levenshtein-like check)
+func areSimilarLines(a, b string) bool {
+	if a == b {
+		return true
+	}
+
+	minLen := len(a)
+	if len(b) < minLen {
+		minLen = len(b)
+	}
+
+	if minLen == 0 {
+		return false
+	}
+
+	commonPrefix := 0
+	for i := 0; i < minLen; i++ {
+		if a[i] == b[i] {
+			commonPrefix++
+		} else {
+			break
+		}
+	}
+
+	prefixThreshold := float64(minLen) * 0.7
+	if float64(commonPrefix) < prefixThreshold {
+		return false
+	}
+
+	suffixA := a[commonPrefix:]
+	suffixB := b[commonPrefix:]
+
+	suffixLenA := len(suffixA)
+	suffixLenB := len(suffixB)
+
+	if suffixLenA == 0 && suffixLenB == 0 {
+		return true
+	}
+
+	lenDiff := suffixLenA - suffixLenB
+	if lenDiff < 0 {
+		lenDiff = -lenDiff
+	}
+
+	maxSuffixLen := max(suffixLenB, suffixLenA)
+
+	if maxSuffixLen > 0 && float64(lenDiff)/float64(maxSuffixLen) > 0.3 {
+		return false
+	}
+
+	return true
+}

internal/diff/diff_test.go

···
 		})
 	}
 }
+
+func TestAreSimilarLines(t *testing.T) {
+	tests := []struct {
+		name     string
+		a        string
+		b        string
+		expected bool
+	}{
+		{
+			name:     "identical lines",
+			a:        "github.com/foo/bar v1.0.0",
+			b:        "github.com/foo/bar v1.0.0",
+			expected: true,
+		},
+		{
+			name:     "similar package different version",
+			a:        "github.com/charmbracelet/x/ansi v0.10.1 // indirect",
+			b:        "github.com/charmbracelet/x/ansi v0.10.3 // indirect",
+			expected: true,
+		},
+		{
+			name:     "different packages",
+			a:        "github.com/charmbracelet/x/term v0.2.1 // indirect",
+			b:        "github.com/charmbracelet/x/exp/teatest v0.0.0-20251",
+			expected: false,
+		},
+		{
+			name:     "empty strings",
+			a:        "",
+			b:        "",
+			expected: true,
+		},
+		{
+			name:     "one empty",
+			a:        "some content",
+			b:        "",
+			expected: false,
+		},
+		{
+			name:     "completely different",
+			a:        "package main",
+			b:        "import fmt",
+			expected: false,
+		},
+		{
+			name:     "short common prefix",
+			a:        "github.com/foo/bar",
+			b:        "github.com/baz/qux",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := areSimilarLines(tt.a, tt.b)
+			if result != tt.expected {
+				t.Errorf("areSimilarLines(%q, %q) = %v, want %v", tt.a, tt.b, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestMergeReplacements(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []Edit
+		expected []Edit
+	}{
+		{
+			name:     "empty edits",
+			input:    []Edit{},
+			expected: []Edit{},
+		},
+		{
+			name: "go.mod scenario - deletes followed by inserts with gap",
+			input: []Edit{
+				{Kind: Delete, AIndex: 17, BIndex: -1, Content: "    github.com/charmbracelet/colorprofile v0.3.2 // indirect"},
+				{Kind: Delete, AIndex: 18, BIndex: -1, Content: "    github.com/charmbracelet/lipgloss/v2"},
+				{Kind: Delete, AIndex: 19, BIndex: -1, Content: "    github.com/charmbracelet/ultraviolet"},
+				{Kind: Delete, AIndex: 20, BIndex: -1, Content: "    github.com/charmbracelet/x/ansi v0.10.1 // indirect"},
+				{Kind: Insert, AIndex: -1, BIndex: 23, Content: "    github.com/aymanbagabas/go-udiff v0.3.1 // indirect"},
+				{Kind: Insert, AIndex: -1, BIndex: 24, Content: "    github.com/charmbracelet/bubbletea v1.3.10"},
+				{Kind: Insert, AIndex: -1, BIndex: 25, Content: "    github.com/charmbracelet/colorprofile v0.3.3 // indirect"},
+				{Kind: Insert, AIndex: -1, BIndex: 26, Content: "    github.com/charmbracelet/lipgloss/v2"},
+				{Kind: Insert, AIndex: -1, BIndex: 27, Content: "    github.com/charmbracelet/ultraviolet"},
+				{Kind: Insert, AIndex: -1, BIndex: 28, Content: "    github.com/charmbracelet/x/ansi v0.10.3 // indirect"},
+			},
+			expected: []Edit{
+				{Kind: Replace, AIndex: 17, BIndex: 25, Content: "    github.com/charmbracelet/colorprofile v0.3.2 // indirect", NewContent: "    github.com/charmbracelet/colorprofile v0.3.3 // indirect"},
+				{Kind: Replace, AIndex: 18, BIndex: 26, Content: "    github.com/charmbracelet/lipgloss/v2", NewContent: "    github.com/charmbracelet/lipgloss/v2"},
+				{Kind: Replace, AIndex: 19, BIndex: 27, Content: "    github.com/charmbracelet/ultraviolet", NewContent: "    github.com/charmbracelet/ultraviolet"},
+				{Kind: Replace, AIndex: 20, BIndex: 28, Content: "    github.com/charmbracelet/x/ansi v0.10.1 // indirect", NewContent: "    github.com/charmbracelet/x/ansi v0.10.3 // indirect"},
+				{Kind: Insert, AIndex: -1, BIndex: 23, Content: "    github.com/aymanbagabas/go-udiff v0.3.1 // indirect"},
+				{Kind: Insert, AIndex: -1, BIndex: 24, Content: "    github.com/charmbracelet/bubbletea v1.3.10"},
+			},
+		},
+		{
+			name: "single edit",
+			input: []Edit{
+				{Kind: Equal, AIndex: 0, BIndex: 0, Content: "line1"},
+			},
+			expected: []Edit{
+				{Kind: Equal, AIndex: 0, BIndex: 0, Content: "line1"},
+			},
+		},
+		{
+			name: "merge similar delete and insert",
+			input: []Edit{
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "github.com/foo/bar v1.0.0"},
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "github.com/foo/bar v2.0.0"},
+			},
+			expected: []Edit{
+				{Kind: Replace, AIndex: 0, BIndex: 0, Content: "github.com/foo/bar v1.0.0", NewContent: "github.com/foo/bar v2.0.0"},
+			},
+		},
+		{
+			name: "don't merge dissimilar delete and insert",
+			input: []Edit{
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "github.com/foo/bar v1.0.0"},
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "import fmt"},
+			},
+			expected: []Edit{
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "github.com/foo/bar v1.0.0"},
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "import fmt"},
+			},
+		},
+		{
+			name: "merge insert and delete (reversed order)",
+			input: []Edit{
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "github.com/foo/bar v2.0.0"},
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "github.com/foo/bar v1.0.0"},
+			},
+			expected: []Edit{
+				{Kind: Replace, AIndex: 0, BIndex: 0, Content: "github.com/foo/bar v1.0.0", NewContent: "github.com/foo/bar v2.0.0"},
+			},
+		},
+		{
+			name: "mixed operations with merge",
+			input: []Edit{
+				{Kind: Equal, AIndex: 0, BIndex: 0, Content: "line1"},
+				{Kind: Delete, AIndex: 1, BIndex: -1, Content: "github.com/foo/bar v1.0.0"},
+				{Kind: Insert, AIndex: -1, BIndex: 1, Content: "github.com/foo/bar v2.0.0"},
+				{Kind: Equal, AIndex: 2, BIndex: 2, Content: "line3"},
+			},
+			expected: []Edit{
+				{Kind: Equal, AIndex: 0, BIndex: 0, Content: "line1"},
+				{Kind: Replace, AIndex: 1, BIndex: 1, Content: "github.com/foo/bar v1.0.0", NewContent: "github.com/foo/bar v2.0.0"},
+				{Kind: Equal, AIndex: 2, BIndex: 2, Content: "line3"},
+			},
+		},
+		{
+			name: "multiple inserts and deletes without merge",
+			input: []Edit{
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "deleted line 1"},
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "new content A"},
+				{Kind: Insert, AIndex: -1, BIndex: 1, Content: "new content B"},
+			},
+			expected: []Edit{
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "deleted line 1"},
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "new content A"},
+				{Kind: Insert, AIndex: -1, BIndex: 1, Content: "new content B"},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := MergeReplacements(tt.input)
+
+			if len(result) != len(tt.expected) {
+				t.Fatalf("expected %d edits, got %d", len(tt.expected), len(result))
+			}
+
+			for i := range result {
+				if result[i].Kind != tt.expected[i].Kind {
+					t.Errorf("edit %d: expected Kind %v, got %v", i, tt.expected[i].Kind, result[i].Kind)
+				}
+				if result[i].AIndex != tt.expected[i].AIndex {
+					t.Errorf("edit %d: expected AIndex %d, got %d", i, tt.expected[i].AIndex, result[i].AIndex)
+				}
+				if result[i].BIndex != tt.expected[i].BIndex {
+					t.Errorf("edit %d: expected BIndex %d, got %d", i, tt.expected[i].BIndex, result[i].BIndex)
+				}
+				if result[i].Content != tt.expected[i].Content {
+					t.Errorf("edit %d: expected Content %q, got %q", i, tt.expected[i].Content, result[i].Content)
+				}
+				if result[i].NewContent != tt.expected[i].NewContent {
+					t.Errorf("edit %d: expected NewContent %q, got %q", i, tt.expected[i].NewContent, result[i].NewContent)
+				}
+			}
+		})
+	}
+}

internal/diff/format.go

···
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/reflow/wordwrap"
 	"github.com/stormlightlabs/git-storm/internal/style"
 )
 
 const (
-	// Layout constants for side-by-side view
-	lineNumWidth = 4
-	gutterWidth  = 3
-	minPaneWidth = 40
+	SymbolAdd          = "┃" // addition
+	SymbolChange       = "▎" // modification/change
+	SymbolDeleteLine   = "_" // line removed
+	SymbolTopDelete    = "‾" // deletion at top (overline)
+	SymbolChangeDelete = "~" // change + delete (hunk combined)
+	SymbolUntracked    = "┆" // untracked lines/files
+
+	AsciiSymbolAdd          = "|" // addition
+	AsciiSymbolChange       = "|" // modification (same as add fallback)
+	AsciiSymbolDeleteLine   = "-" // deletion line
+	AsciiSymbolTopDelete    = "^" // “top delete” fallback
+	AsciiSymbolChangeDelete = "~" // change+delete still ~
+	AsciiSymbolUntracked    = ":" // untracked fallback
+
+	lineNumWidth        = 4
+	gutterWidth         = 3
+	minPaneWidth        = 40
+	contextLines        = 3  // Lines to show before/after changes
+	minUnchangedToHide  = 10 // Minimum unchanged lines before hiding
+	compressedIndicator = "⋮"
 )
 
 // SideBySideFormatter renders diff edits in a split-pane layout with syntax highlighting.
···
 	TerminalWidth int
 	// ShowLineNumbers controls whether line numbers are displayed
 	ShowLineNumbers bool
+	// Expanded controls whether to show all unchanged lines or compress them
+	Expanded bool
+	// EnableWordWrap enables word wrapping for long lines
+	EnableWordWrap bool
 }
 
 // Format renders the edits as a styled side-by-side diff string.
 //
 // The left pane shows the old content (deletions and unchanged lines).
 // The right pane shows the new content (insertions and unchanged lines).
-// Line numbers and color coding help visualize the changes.
 func (f *SideBySideFormatter) Format(edits []Edit) string {
 	if len(edits) == 0 {
 		return style.StyleText.Render("No changes")
 	}
 
+	processedEdits := MergeReplacements(edits)
+
+	if !f.Expanded {
+		processedEdits = f.compressUnchangedBlocks(processedEdits)
+	}
+
 	paneWidth := f.calculatePaneWidth()
 
 	var sb strings.Builder
 	lineNumStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#6C7A89")).Faint(true)
 
-	for _, edit := range edits {
+	for _, edit := range processedEdits {
 		left, right := f.renderEdit(edit, paneWidth)
 
 		if f.ShowLineNumbers {
···
 	}
 
 	availableWidth := f.TerminalWidth - usedWidth
+	if availableWidth < 0 {
+		availableWidth = 0
+	}
+
 	paneWidth := availableWidth / 2
 
 	if paneWidth < minPaneWidth {
-		paneWidth = minPaneWidth
+		totalNeeded := usedWidth + (2 * minPaneWidth)
+		if totalNeeded > f.TerminalWidth {
+			return paneWidth
+		}
+		return minPaneWidth
 	}
 
 	return paneWidth
···
 func (f *SideBySideFormatter) renderEdit(edit Edit, paneWidth int) (left, right string) {
 	content := f.truncateContent(edit.Content, paneWidth)
 
+	if edit.AIndex == -2 && edit.BIndex == -2 {
+		compressedStyle := lipgloss.NewStyle().
+			Foreground(lipgloss.Color("#6C7A89")).
+			Faint(true).
+			Italic(true)
+		styled := f.padToWidth(compressedStyle.Render(content), paneWidth)
+		return styled, styled
+	}
+
 	switch edit.Kind {
 	case Equal:
-		// Show on both sides with neutral styling
-		leftStyled := style.StyleText.Width(paneWidth).Render(content)
-		rightStyled := style.StyleText.Width(paneWidth).Render(content)
+		leftStyled := f.padToWidth(style.StyleText.Render(content), paneWidth)
+		rightStyled := f.padToWidth(style.StyleText.Render(content), paneWidth)
 		return leftStyled, rightStyled
 
 	case Delete:
-		// Show on left in red, empty right
-		leftStyled := style.StyleRemoved.Width(paneWidth).Render(content)
-		rightStyled := lipgloss.NewStyle().Width(paneWidth).Render("")
+		leftStyled := f.padToWidth(style.StyleRemoved.Render(content), paneWidth)
+		rightStyled := f.padToWidth("", paneWidth)
 		return leftStyled, rightStyled
 
 	case Insert:
-		// Empty left, show on right in green
-		leftStyled := lipgloss.NewStyle().Width(paneWidth).Render("")
-		rightStyled := style.StyleAdded.Width(paneWidth).Render(content)
+		leftStyled := f.padToWidth("", paneWidth)
+		rightStyled := f.padToWidth(style.StyleAdded.Render(content), paneWidth)
+		return leftStyled, rightStyled
+
+	case Replace:
+		newContent := f.truncateContent(edit.NewContent, paneWidth)
+		leftStyled := f.padToWidth(style.StyleRemoved.Render(content), paneWidth)
+		rightStyled := f.padToWidth(style.StyleAdded.Render(newContent), paneWidth)
 		return leftStyled, rightStyled
 
 	default:
-		// Fallback for unknown edit kinds
-		return lipgloss.NewStyle().Width(paneWidth).Render(content),
-			lipgloss.NewStyle().Width(paneWidth).Render(content)
+		return f.padToWidth(content, paneWidth),
+			f.padToWidth(content, paneWidth)
 	}
 }
 
+// padToWidth pads a string with spaces to reach the target width.
+// If the string exceeds the target width, it truncates it.
+func (f *SideBySideFormatter) padToWidth(s string, targetWidth int) string {
+	currentWidth := lipgloss.Width(s)
+
+	if currentWidth > targetWidth {
+		return truncateToWidth(s, targetWidth)
+	}
+
+	if currentWidth == targetWidth {
+		return s
+	}
+
+	padding := strings.Repeat(" ", targetWidth-currentWidth)
+	return s + padding
+}
+
 // renderGutter creates the visual separator between left and right panes.
 func (f *SideBySideFormatter) renderGutter(kind EditKind) string {
 	var symbol string
···
 
 	switch kind {
 	case Equal:
-		symbol = " │ "
+		symbol = " " + SymbolUntracked + " "
 		st = lipgloss.NewStyle().Foreground(lipgloss.Color("#6C7A89"))
 	case Delete:
-		symbol = " < "
+		symbol = " " + SymbolDeleteLine + " "
 		st = style.StyleRemoved
 	case Insert:
-		symbol = " > "
+		symbol = " " + SymbolAdd + " "
 		st = style.StyleAdded
+	case Replace:
+		symbol = " " + SymbolChange + " "
+		st = style.StyleChanged
 	default:
-		symbol = " │ "
+		symbol = " " + SymbolUntracked + " "
 		st = lipgloss.NewStyle()
 	}
 
···
 	return st.Width(lineNumWidth).Render(fmt.Sprintf("%4d", index+1))
 }
 
-// truncateContent ensures content fits within the pane width.
+// truncateContent ensures content fits within the pane width using proper display width.
 func (f *SideBySideFormatter) truncateContent(content string, maxWidth int) string {
-	// Remove trailing whitespace but preserve leading indentation
 	content = strings.TrimRight(content, " \t\r\n")
 
-	if len(content) <= maxWidth {
+	if f.EnableWordWrap {
+		wrapped := wordwrap.String(content, maxWidth)
+		lines := strings.Split(wrapped, "\n")
+		if len(lines) > 0 {
+			return lines[0]
+		}
+		return wrapped
+	}
+
+	displayWidth := lipgloss.Width(content)
+
+	if displayWidth <= maxWidth {
 		return content
 	}
 
 	if maxWidth <= 3 {
-		return content[:maxWidth]
+		return truncateToWidth(content, maxWidth)
+	}
+
+	targetWidth := maxWidth - 3
+	truncated := truncateToWidth(content, targetWidth)
+	return truncated + "..."
+}
+
+// truncateToWidth truncates a string to a specific display width.
+func truncateToWidth(s string, width int) string {
+	if width <= 0 {
+		return ""
+	}
+
+	var result strings.Builder
+	currentWidth := 0
+
+	for _, r := range s {
+		runeWidth := lipgloss.Width(string(r))
+
+		if currentWidth+runeWidth > width {
+			break
+		}
+
+		result.WriteRune(r)
+		currentWidth += runeWidth
+	}
+
+	return result.String()
+}
+
+// compressUnchangedBlocks compresses large blocks of unchanged lines.
+//
+// It keeps contextLines before and after changes, and replaces large
+// blocks of unchanged lines with a single compressed indicator.
+func (f *SideBySideFormatter) compressUnchangedBlocks(edits []Edit) []Edit {
+	if len(edits) == 0 {
+		return edits
+	}
+
+	var result []Edit
+	var unchangedRun []Edit
+
+	for i, edit := range edits {
+		if edit.Kind == Equal {
+			unchangedRun = append(unchangedRun, edit)
+
+			isLast := i == len(edits)-1
+			nextIsChanged := !isLast && edits[i+1].Kind != Equal
+
+			if isLast || nextIsChanged {
+				if len(unchangedRun) >= minUnchangedToHide {
+					for j := 0; j < contextLines && j < len(unchangedRun); j++ {
+						result = append(result, unchangedRun[j])
+					}
+
+					hiddenCount := len(unchangedRun) - (2 * contextLines)
+					if hiddenCount > 0 {
+						result = append(result, Edit{
+							Kind:    Equal,
+							AIndex:  -2,
+							BIndex:  -2,
+							Content: fmt.Sprintf("%s %d unchanged lines", compressedIndicator, hiddenCount),
+						})
+					}
+
+					start := max(len(unchangedRun)-contextLines, contextLines)
+					for j := start; j < len(unchangedRun); j++ {
+						result = append(result, unchangedRun[j])
+					}
+				} else {
+					result = append(result, unchangedRun...)
+				}
+				unchangedRun = nil
+			}
+		} else {
+			if len(unchangedRun) > 0 {
+				if len(unchangedRun) >= minUnchangedToHide {
+					for j := 0; j < contextLines && j < len(unchangedRun); j++ {
+						result = append(result, unchangedRun[j])
+					}
+
+					hiddenCount := len(unchangedRun) - (2 * contextLines)
+					if hiddenCount > 0 {
+						result = append(result, Edit{
+							Kind:    Equal,
+							AIndex:  -2,
+							BIndex:  -2,
+							Content: fmt.Sprintf("%s %d unchanged lines", compressedIndicator, hiddenCount),
+						})
+					}
+
+					start := max(len(unchangedRun)-contextLines, contextLines)
+					for j := start; j < len(unchangedRun); j++ {
+						result = append(result, unchangedRun[j])
+					}
+				} else {
+					result = append(result, unchangedRun...)
+				}
+				unchangedRun = nil
+			}
+
+			result = append(result, edit)
+		}
 	}
 
-	return content[:maxWidth-3] + "..."
+	return result
 }

internal/diff/format_compress_test.go

···
+package diff
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSideBySideFormatter_CompressUnchangedBlocks(t *testing.T) {
+	tests := []struct {
+		name                              string
+		edits                             []Edit
+		expectedCompressed, expectedTotal int
+	}{
+		{
+			name:               "no compression for small unchanged blocks",
+			edits:              makeEqualEdits(5),
+			expectedCompressed: 0,
+			expectedTotal:      5,
+		},
+		{
+			name:               "compress large unchanged block",
+			edits:              makeEqualEdits(20),
+			expectedCompressed: 1,
+			expectedTotal:      7,
+		},
+		{
+			name: "compress unchanged between changes",
+			edits: []Edit{
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "new line"},
+				{Kind: Equal, AIndex: 0, BIndex: 1, Content: "unchanged 1"},
+				{Kind: Equal, AIndex: 1, BIndex: 2, Content: "unchanged 2"},
+				{Kind: Equal, AIndex: 2, BIndex: 3, Content: "unchanged 3"},
+				{Kind: Equal, AIndex: 3, BIndex: 4, Content: "unchanged 4"},
+				{Kind: Equal, AIndex: 4, BIndex: 5, Content: "unchanged 5"},
+				{Kind: Equal, AIndex: 5, BIndex: 6, Content: "unchanged 6"},
+				{Kind: Equal, AIndex: 6, BIndex: 7, Content: "unchanged 7"},
+				{Kind: Equal, AIndex: 7, BIndex: 8, Content: "unchanged 8"},
+				{Kind: Equal, AIndex: 8, BIndex: 9, Content: "unchanged 9"},
+				{Kind: Equal, AIndex: 9, BIndex: 10, Content: "unchanged 10"},
+				{Kind: Equal, AIndex: 10, BIndex: 11, Content: "unchanged 11"},
+				{Kind: Equal, AIndex: 11, BIndex: 12, Content: "unchanged 12"},
+				{Kind: Equal, AIndex: 12, BIndex: 13, Content: "unchanged 13"},
+				{Kind: Delete, AIndex: 13, BIndex: -1, Content: "removed line"},
+			},
+			expectedCompressed: 1,
+			expectedTotal:      9,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			formatter := &SideBySideFormatter{}
+
+			result := formatter.compressUnchangedBlocks(tt.edits)
+
+			if len(result) != tt.expectedTotal {
+				t.Errorf("Expected %d total edits after compression, got %d", tt.expectedTotal, len(result))
+			}
+
+			compressed := countCompressedBlocks(result)
+			if compressed != tt.expectedCompressed {
+				t.Errorf("Expected %d compressed blocks, got %d", tt.expectedCompressed, compressed)
+			}
+		})
+	}
+}
+
+func TestSideBySideFormatter_Expanded(t *testing.T) {
+	edits := makeEqualEdits(20)
+
+	compressedFormatter := &SideBySideFormatter{
+		TerminalWidth:   100,
+		ShowLineNumbers: true,
+		Expanded:        false,
+	}
+
+	expandedFormatter := &SideBySideFormatter{
+		TerminalWidth:   100,
+		ShowLineNumbers: true,
+		Expanded:        true,
+	}
+
+	compressedOutput := compressedFormatter.Format(edits)
+	expandedOutput := expandedFormatter.Format(edits)
+
+	compressedLines := strings.Split(compressedOutput, "\n")
+	expandedLines := strings.Split(expandedOutput, "\n")
+
+	if len(expandedLines) <= len(compressedLines) {
+		t.Errorf("Expanded output (%d lines) should have more lines than compressed (%d lines)",
+			len(expandedLines), len(compressedLines))
+	}
+
+	if !strings.Contains(compressedOutput, compressedIndicator) {
+		t.Error("Compressed output should contain compression indicator")
+	}
+
+	if strings.Contains(expandedOutput, compressedIndicator) {
+		t.Error("Expanded output should not contain compression indicator")
+	}
+}
+
+func TestSideBySideFormatter_CompressedIndicatorStyling(t *testing.T) {
+	formatter := &SideBySideFormatter{
+		TerminalWidth:   100,
+		ShowLineNumbers: true,
+		Expanded:        false,
+	}
+
+	edits := makeEqualEdits(20)
+	output := formatter.Format(edits)
+
+	if !strings.Contains(output, "unchanged lines") {
+		t.Error("Compressed output should mention 'unchanged lines'")
+	}
+}
+
+func TestMultipleCompressedBlocks(t *testing.T) {
+	formatter := &SideBySideFormatter{}
+
+	edits := []Edit{}
+	edits = append(edits, makeEqualEdits(20)...)
+	edits = append(edits, Edit{Kind: Insert, AIndex: -1, BIndex: 0, Content: "change 1"})
+	edits = append(edits, makeEqualEdits(20)...)
+	edits = append(edits, Edit{Kind: Delete, AIndex: 0, BIndex: -1, Content: "change 2"})
+	edits = append(edits, makeEqualEdits(20)...)
+
+	result := formatter.compressUnchangedBlocks(edits)
+
+	compressed := countCompressedBlocks(result)
+	if compressed != 3 {
+		t.Errorf("Expected 3 compressed blocks, got %d", compressed)
+	}
+}
+
+func makeEqualEdits(count int) []Edit {
+	edits := make([]Edit, count)
+	for i := range count {
+		edits[i] = Edit{
+			Kind:    Equal,
+			AIndex:  i,
+			BIndex:  i,
+			Content: "unchanged line",
+		}
+	}
+	return edits
+}
+
+func countCompressedBlocks(edits []Edit) int {
+	count := 0
+	for _, edit := range edits {
+		if edit.AIndex == -2 && edit.BIndex == -2 {
+			count++
+		}
+	}
+	return count
+}

internal/diff/format_test.go

···
 import (
 	"strings"
 	"testing"
+
+	"github.com/charmbracelet/lipgloss"
 )
 
 func TestSideBySideFormatter_Format(t *testing.T) {
···
 			},
 			width: 80,
 			expect: func(output string) bool {
-				return strings.Contains(output, "new line") && strings.Contains(output, ">")
+				return strings.Contains(output, "new line") && strings.Contains(output, SymbolAdd)
 			},
 		},
 		{
···
 			},
 			width: 80,
 			expect: func(output string) bool {
-				return strings.Contains(output, "old line") && strings.Contains(output, "<")
+				return strings.Contains(output, "old line") && strings.Contains(output, SymbolDeleteLine)
 			},
 		},
 		{
···
 			name:            "narrow terminal",
 			terminalWidth:   60,
 			showLineNumbers: true,
-			minExpected:     minPaneWidth,
+			minExpected:     20,
 		},
 		{
 			name:            "without line numbers",
···
 			if paneWidth < tt.minExpected {
 				t.Errorf("calculatePaneWidth() = %d, expected at least %d", paneWidth, tt.minExpected)
 			}
+
+			usedWidth := gutterWidth
+			if tt.showLineNumbers {
+				usedWidth += 2 * lineNumWidth
+			}
+			totalWidth := usedWidth + (2 * paneWidth)
+			if totalWidth > tt.terminalWidth {
+				t.Errorf("Total width %d exceeds terminal width %d (paneWidth=%d)", totalWidth, tt.terminalWidth, paneWidth)
+			}
+		})
+	}
+}
+
+func TestPadToWidth(t *testing.T) {
+	formatter := &SideBySideFormatter{}
+
+	tests := []struct {
+		name        string
+		input       string
+		targetWidth int
+	}{
+		{
+			name:        "short string gets padded",
+			input:       "hello",
+			targetWidth: 10,
+		},
+		{
+			name:        "exact width unchanged",
+			input:       "hello world",
+			targetWidth: 11,
+		},
+		{
+			name:        "long string gets truncated",
+			input:       "this is a very long string that exceeds the target width",
+			targetWidth: 20,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := formatter.padToWidth(tt.input, tt.targetWidth)
+
+			resultWidth := lipgloss.Width(result)
+			if resultWidth != tt.targetWidth {
+				t.Errorf("padToWidth() width = %d, expected exactly %d", resultWidth, tt.targetWidth)
+			}
 		})
 	}
 }
···
 			maxWidth: 10,
 			expected: "hello",
 		},
+		{
+			name:     "very long line",
+			content:  "github.com/charmbracelet/x/ansi v0.10.3 h1:3WoV9XN8uMEnFRZZ+vBPRy59TaI",
+			maxWidth: 40,
+			expected: "",
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			result := formatter.truncateContent(tt.content, tt.maxWidth)
-			if result != tt.expected {
+
+			displayWidth := lipgloss.Width(result)
+			if displayWidth > tt.maxWidth {
+				t.Errorf("truncateContent() display width = %d, exceeds max %d", displayWidth, tt.maxWidth)
+			}
+
+			if tt.expected != "" && result != tt.expected {
 				t.Errorf("truncateContent() = %q, expected %q", result, tt.expected)
+			}
+
+			if lipgloss.Width(tt.content) > tt.maxWidth && tt.maxWidth > 3 {
+				if !strings.HasSuffix(result, "...") {
+					t.Errorf("truncateContent() should end with '...' for long content")
+				}
 			}
 		})
 	}

internal/ui/ui.go

···
 	"strings"
 
 	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/paginator"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 	"github.com/stormlightlabs/git-storm/internal/diff"
 	"github.com/stormlightlabs/git-storm/internal/style"
 )
+
+// FileDiff represents a diff for a single file.
+type FileDiff struct {
+	Edits   []diff.Edit
+	OldPath string
+	NewPath string
+}
 
 // DiffModel holds the state for the side-by-side diff viewer.
 type DiffModel struct {
···
 
 	content := formatter.Format(edits)
 
-	vp := viewport.New(terminalWidth, terminalHeight-2) // Reserve space for header
+	vp := viewport.New(terminalWidth, terminalHeight-2)
 	vp.SetContent(content)
 
 	return DiffModel{
···
 		helpText + strings.Repeat(" ", padding) + scrollInfo,
 	)
 }
+
+// MultiFileDiffModel holds the state for viewing diffs across multiple files with pagination.
+type MultiFileDiffModel struct {
+	files     []FileDiff
+	paginator paginator.Model
+	viewport  viewport.Model
+	ready     bool
+	width     int
+	height    int
+	expanded  bool // Controls whether unchanged blocks are compressed
+}
+
+// NewMultiFileDiffModel creates a new multi-file diff viewer with pagination.
+func NewMultiFileDiffModel(files []FileDiff, expanded bool) MultiFileDiffModel {
+	p := paginator.New()
+	p.Type = paginator.Dots
+	p.PerPage = 1
+	p.SetTotalPages(len(files))
+	p.ActiveDot = lipgloss.NewStyle().Foreground(style.AccentBlue).Render("•")
+	p.InactiveDot = lipgloss.NewStyle().Foreground(lipgloss.Color("#6C7A89")).Render("•")
+
+	model := MultiFileDiffModel{
+		files:     files,
+		paginator: p,
+		ready:     false,
+		expanded:  expanded,
+	}
+
+	return model
+}
+
+// Init initializes the multi-file diff model.
+func (m MultiFileDiffModel) Init() tea.Cmd {
+	return nil
+}
+
+// Update handles messages and updates the multi-file diff model state.
+func (m MultiFileDiffModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmds []tea.Cmd
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, keys.Quit):
+			return m, tea.Quit
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("e"))):
+			// Toggle expanded/compressed view
+			m.expanded = !m.expanded
+			m.updateViewport()
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("left", "h"))):
+			m.paginator.PrevPage()
+			m.updateViewport()
+			m.viewport.GotoTop()
+
+		case key.Matches(msg, key.NewBinding(key.WithKeys("right", "l"))):
+			m.paginator.NextPage()
+			m.updateViewport()
+			m.viewport.GotoTop()
+
+		case key.Matches(msg, keys.Up):
+			m.viewport.LineUp(1)
+
+		case key.Matches(msg, keys.Down):
+			m.viewport.LineDown(1)
+
+		case key.Matches(msg, keys.PageUp):
+			m.viewport.ViewUp()
+
+		case key.Matches(msg, keys.PageDown):
+			m.viewport.ViewDown()
+
+		case key.Matches(msg, keys.HalfUp):
+			m.viewport.HalfViewUp()
+
+		case key.Matches(msg, keys.HalfDown):
+			m.viewport.HalfViewDown()
+
+		case key.Matches(msg, keys.Top):
+			m.viewport.GotoTop()
+
+		case key.Matches(msg, keys.Bottom):
+			m.viewport.GotoBottom()
+		}
+
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+
+		if !m.ready {
+			m.viewport = viewport.New(msg.Width, msg.Height-4)
+			m.ready = true
+		} else {
+			m.viewport.Width = msg.Width
+			m.viewport.Height = msg.Height - 4
+		}
+
+		m.updateViewport()
+	}
+
+	m.viewport, cmd = m.viewport.Update(msg)
+	cmds = append(cmds, cmd)
+
+	return m, tea.Batch(cmds...)
+}
+
+// View renders the current view of the multi-file diff viewer.
+func (m MultiFileDiffModel) View() string {
+	if !m.ready || len(m.files) == 0 {
+		return "\n  No files to display"
+	}
+
+	header := m.renderMultiFileHeader()
+	footer := m.renderMultiFileFooter()
+	paginatorView := m.renderPaginator()
+
+	return fmt.Sprintf("%s\n%s\n%s\n%s", header, m.viewport.View(), paginatorView, footer)
+}
+
+// updateViewport updates the viewport content to show the current file.
+func (m *MultiFileDiffModel) updateViewport() {
+	if len(m.files) == 0 {
+		return
+	}
+
+	currentFile := m.files[m.paginator.Page]
+	formatter := &diff.SideBySideFormatter{
+		TerminalWidth:   m.width,
+		ShowLineNumbers: true,
+		Expanded:        m.expanded,
+		EnableWordWrap:  false,
+	}
+
+	content := formatter.Format(currentFile.Edits)
+	m.viewport.SetContent(content)
+}
+
+// renderMultiFileHeader creates the header showing current file paths.
+func (m MultiFileDiffModel) renderMultiFileHeader() string {
+	if len(m.files) == 0 {
+		return ""
+	}
+
+	currentFile := m.files[m.paginator.Page]
+
+	headerStyle := lipgloss.NewStyle().
+		Foreground(style.AccentBlue).
+		Bold(true).
+		Padding(0, 1)
+
+	oldLabel := lipgloss.NewStyle().Foreground(style.RemovedColor).Render("−")
+	newLabel := lipgloss.NewStyle().Foreground(style.AddedColor).Render("+")
+
+	fileIndicator := fmt.Sprintf("[%d/%d]", m.paginator.Page+1, len(m.files))
+
+	return headerStyle.Render(
+		fmt.Sprintf("%s %s %s  %s %s", fileIndicator, oldLabel, currentFile.OldPath, newLabel, currentFile.NewPath),
+	)
+}
+
+// renderPaginator renders the pagination dots.
+func (m MultiFileDiffModel) renderPaginator() string {
+	if len(m.files) <= 1 {
+		return ""
+	}
+
+	return lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#6C7A89")).
+		Padding(0, 1).
+		Render(m.paginator.View())
+}
+
+// renderMultiFileFooter creates the footer with help text and scroll position.
+func (m MultiFileDiffModel) renderMultiFileFooter() string {
+	footerStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#6C7A89")).
+		Faint(true).
+		Padding(0, 1)
+
+	expandedIndicator := "compressed"
+	if m.expanded {
+		expandedIndicator = "expanded"
+	}
+
+	helpText := fmt.Sprintf("↑/↓: scroll • h/l: files • e: %s • q: quit", expandedIndicator)
+
+	scrollPercent := m.viewport.ScrollPercent()
+	scrollInfo := fmt.Sprintf("%.0f%%", scrollPercent*100)
+
+	totalWidth := m.width
+	helpWidth := lipgloss.Width(helpText)
+	scrollWidth := lipgloss.Width(scrollInfo)
+	padding := totalWidth - helpWidth - scrollWidth - 2
+
+	if padding < 0 {
+		padding = 0
+	}
+
+	return footerStyle.Render(
+		helpText + strings.Repeat(" ", padding) + scrollInfo,
+	)
+}

internal/ui/ui_test.go

···
 
 	tm := teatest.NewTestModel(t, model, teatest.WithInitialTermSize(80, 20))
 
-	// Test down movement
 	tm.Send(tea.KeyMsg{Type: tea.KeyDown})
 	teatest.WaitFor(t, tm.Output(), func(bts []byte) bool {
 		return len(bts) > 0
 	})
 
-	// Test up movement
 	tm.Send(tea.KeyMsg{Type: tea.KeyUp})
 	teatest.WaitFor(t, tm.Output(), func(bts []byte) bool {
 		return len(bts) > 0
 	})
 
-	// Test quit
 	tm.Send(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'q'}})
 	tm.WaitFinished(t, teatest.WithFinalTimeout(time.Second))
 }
···
 	}
 
 	quitKeys := []tea.KeyType{
-		tea.KeyRunes, // 'q'
+		tea.KeyRunes,
 		tea.KeyEsc,
 		tea.KeyCtrlC,
 	}
···
 		t.Error("Footer should contain help text about quitting")
 	}
 }
+
+func TestMultiFileDiffModel_Init(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "test"}},
+			OldPath: "old/file1.go",
+			NewPath: "new/file1.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+
+	cmd := model.Init()
+	if cmd != nil {
+		t.Errorf("Init() should return nil, got %v", cmd)
+	}
+}
+
+func TestMultiFileDiffModel_View(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "line 1"}},
+			OldPath: "old/file1.go",
+			NewPath: "new/file1.go",
+		},
+		{
+			Edits:   []diff.Edit{{Kind: diff.Insert, AIndex: -1, BIndex: 0, Content: "line 2"}},
+			OldPath: "old/file2.go",
+			NewPath: "new/file2.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(MultiFileDiffModel)
+
+	view := model.View()
+
+	if !strings.Contains(view, "file1.go") {
+		t.Error("View should contain first file path")
+	}
+	if !strings.Contains(view, "[1/2]") {
+		t.Error("View should contain file indicator [1/2]")
+	}
+}
+
+func TestMultiFileDiffModel_Pagination(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "file 1"}},
+			OldPath: "old/file1.go",
+			NewPath: "new/file1.go",
+		},
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "file 2"}},
+			OldPath: "old/file2.go",
+			NewPath: "new/file2.go",
+		},
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "file 3"}},
+			OldPath: "old/file3.go",
+			NewPath: "new/file3.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+
+	tm := teatest.NewTestModel(t, model, teatest.WithInitialTermSize(80, 24))
+
+	tm.Send(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'l'}})
+	teatest.WaitFor(t, tm.Output(), func(bts []byte) bool {
+		return len(bts) > 0
+	})
+
+	tm.Send(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'h'}})
+	teatest.WaitFor(t, tm.Output(), func(bts []byte) bool {
+		return len(bts) > 0
+	})
+
+	tm.Send(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'q'}})
+	tm.WaitFinished(t, teatest.WithFinalTimeout(time.Second))
+}
+
+func TestMultiFileDiffModel_EmptyFiles(t *testing.T) {
+	files := []FileDiff{}
+
+	model := NewMultiFileDiffModel(files, false)
+
+	view := model.View()
+
+	if !strings.Contains(view, "No files") {
+		t.Error("View should indicate no files to display")
+	}
+}
+
+func TestMultiFileDiffModel_SingleFile(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "test"}},
+			OldPath: "old/single.go",
+			NewPath: "new/single.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 80, Height: 24})
+	model = updated.(MultiFileDiffModel)
+
+	view := model.View()
+
+	if !strings.Contains(view, "single.go") {
+		t.Error("View should contain file path")
+	}
+	if !strings.Contains(view, "[1/1]") {
+		t.Error("View should show [1/1] for single file")
+	}
+}
+
+func TestMultiFileDiffModel_UpdateViewport(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "content 1"}},
+			OldPath: "file1.go",
+			NewPath: "file1.go",
+		},
+		{
+			Edits:   []diff.Edit{{Kind: diff.Insert, AIndex: -1, BIndex: 0, Content: "content 2"}},
+			OldPath: "file2.go",
+			NewPath: "file2.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 80, Height: 24})
+	model = updated.(MultiFileDiffModel)
+
+	initialView := model.View()
+	if !strings.Contains(initialView, "content 1") {
+		t.Error("Initial view should contain content from first file")
+	}
+
+	model.paginator.NextPage()
+	model.updateViewport()
+
+	updatedView := model.View()
+	if !strings.Contains(updatedView, "file2.go") {
+		t.Error("Updated view should show second file path")
+	}
+}
+
+func TestMultiFileDiffModel_RenderHeader(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "test"}},
+			OldPath: "old/test.go",
+			NewPath: "new/test.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+	header := model.renderMultiFileHeader()
+
+	if !strings.Contains(header, "old/test.go") {
+		t.Error("Header should contain old file path")
+	}
+	if !strings.Contains(header, "new/test.go") {
+		t.Error("Header should contain new file path")
+	}
+	if !strings.Contains(header, "[1/1]") {
+		t.Error("Header should contain file indicator")
+	}
+}
+
+func TestMultiFileDiffModel_RenderFooter(t *testing.T) {
+	files := []FileDiff{
+		{
+			Edits:   []diff.Edit{{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "test"}},
+			OldPath: "test.go",
+			NewPath: "test.go",
+		},
+	}
+
+	model := NewMultiFileDiffModel(files, false)
+	footer := model.renderMultiFileFooter()
+
+	if !strings.Contains(footer, "h/l") {
+		t.Error("Footer should contain navigation help for h/l keys")
+	}
+	if !strings.Contains(footer, "scroll") {
+		t.Error("Footer should contain scroll help")
+	}
+	if !strings.Contains(footer, "quit") {
+		t.Error("Footer should contain quit help")
+	}
+}

main.go cmd/main.go

···
 
 const versionString string = "0.1.0-dev"
 
+// parseRefArgs parses command arguments to extract from/to refs.
+// Supports both "from..to" and "from to" syntax.
+func parseRefArgs(args []string) (from, to string) {
+	if len(args) == 1 {
+		parts := strings.Split(args[0], "..")
+		if len(parts) == 2 {
+			return parts[0], parts[1]
+		}
+		return args[0], "HEAD"
+	}
+	return args[0], args[1]
+}
+
 // runDiff executes the diff command by reading file contents from two git refs and launching the TUI.
-func runDiff(fromRef, toRef, filePath string) error {
+func runDiff(fromRef, toRef, filePath string, expanded bool) error {
 	repo, err := git.PlainOpen(repoPath)
 	if err != nil {
 		return fmt.Errorf("failed to open repository: %w", err)
 	}
 
-	oldContent, err := getFileContent(repo, fromRef, filePath)
-	if err != nil {
-		return fmt.Errorf("failed to read %s from %s: %w", filePath, fromRef, err)
+	var filesToDiff []string
+	if filePath != "" {
+		filesToDiff = []string{filePath}
+	} else {
+		filesToDiff, err = getChangedFiles(repo, fromRef, toRef)
+		if err != nil {
+			return fmt.Errorf("failed to get changed files: %w", err)
+		}
+		if len(filesToDiff) == 0 {
+			fmt.Println("No files changed between", fromRef, "and", toRef)
+			return nil
+		}
 	}
 
-	newContent, err := getFileContent(repo, toRef, filePath)
-	if err != nil {
-		return fmt.Errorf("failed to read %s from %s: %w", filePath, toRef, err)
-	}
+	allDiffs := make([]ui.FileDiff, 0, len(filesToDiff))
+
+	for _, file := range filesToDiff {
+		oldContent, err := getFileContent(repo, fromRef, file)
+		if err != nil {
+			oldContent = ""
+		}
 
-	oldLines := strings.Split(oldContent, "\n")
-	newLines := strings.Split(newContent, "\n")
+		newContent, err := getFileContent(repo, toRef, file)
+		if err != nil {
+			newContent = ""
+		}
+
+		oldLines := strings.Split(oldContent, "\n")
+		newLines := strings.Split(newContent, "\n")
+
+		myers := &diff.Myers{}
+		edits, err := myers.Compute(oldLines, newLines)
+		if err != nil {
+			return fmt.Errorf("diff computation failed for %s: %w", file, err)
+		}
 
-	myers := &diff.Myers{}
-	edits, err := myers.Compute(oldLines, newLines)
-	if err != nil {
-		return fmt.Errorf("diff computation failed: %w", err)
+		allDiffs = append(allDiffs, ui.FileDiff{
+			Edits:   edits,
+			OldPath: fromRef + ":" + file,
+			NewPath: toRef + ":" + file,
+		})
 	}
 
-	model := ui.NewDiffModel(edits, fromRef+":"+filePath, toRef+":"+filePath, 120, 30)
+	model := ui.NewMultiFileDiffModel(allDiffs, expanded)
 
 	p := tea.NewProgram(model, tea.WithAltScreen())
 	if _, err := p.Run(); err != nil {
···
 	return content, nil
 }
 
+// getChangedFiles returns the list of files that changed between two commits.
+func getChangedFiles(repo *git.Repository, fromRef, toRef string) ([]string, error) {
+	fromHash, err := repo.ResolveRevision(plumbing.Revision(fromRef))
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve %s: %w", fromRef, err)
+	}
+
+	toHash, err := repo.ResolveRevision(plumbing.Revision(toRef))
+	if err != nil {
+		return nil, fmt.Errorf("failed to resolve %s: %w", toRef, err)
+	}
+
+	fromCommit, err := repo.CommitObject(*fromHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get commit %s: %w", fromRef, err)
+	}
+
+	toCommit, err := repo.CommitObject(*toHash)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get commit %s: %w", toRef, err)
+	}
+
+	fromTree, err := fromCommit.Tree()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get tree for %s: %w", fromRef, err)
+	}
+
+	toTree, err := toCommit.Tree()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get tree for %s: %w", toRef, err)
+	}
+
+	changes, err := fromTree.Diff(toTree)
+	if err != nil {
+		return nil, fmt.Errorf("failed to compute diff: %w", err)
+	}
+
+	files := make([]string, 0, len(changes))
+	for _, change := range changes {
+		if change.To.Name != "" {
+			files = append(files, change.To.Name)
+		} else {
+			files = append(files, change.From.Name)
+		}
+	}
+
+	return files, nil
+}
+
 func versionCmd() *cobra.Command {
 	return &cobra.Command{
 		Use:   "version",
···
 
 func diffCmd() *cobra.Command {
 	var filePath string
+	var expanded bool
 
 	c := &cobra.Command{
-		Use:   "diff <from> <to>",
+		Use:   "diff <from>..<to> | diff <from> <to>",
 		Short: "Show a line-based diff between two commits or tags",
-		Long: `Displays an inline diff (added/removed/unchanged lines) between two refs
-using the built-in diff engine.`,
-		Args: cobra.ExactArgs(2),
+		Long: `Displays an inline diff (added/removed/unchanged lines) between two refs.
+
+Supports multiple input formats:
+  - Range syntax: commit1..commit2
+  - Separate args: commit1 commit2
+  - Truncated hashes: 7de6f6d..18363c2
+
+If --file is not specified, shows all changed files with pagination.
+
+By default, large blocks of unchanged lines are compressed. Use --expanded
+to show all lines. You can also toggle this with 'e' in the TUI.`,
+		Args: cobra.RangeArgs(1, 2),
 		RunE: func(cmd *cobra.Command, args []string) error {
-			return runDiff(args[0], args[1], filePath)
+			from, to := parseRefArgs(args)
+			return runDiff(from, to, filePath, expanded)
 		},
 	}
 
-	c.Flags().StringVarP(&filePath, "file", "f", "", "File path to diff (required)")
-	c.MarkFlagRequired("file")
+	c.Flags().StringVarP(&filePath, "file", "f", "", "Specific file to diff (optional, shows all files if omitted)")
+	c.Flags().BoolVarP(&expanded, "expanded", "e", false, "Show all unchanged lines (disable compression)")
 
 	return c
 }