feat(unreleased): interactive commit re/viewer

cmd/unreleased.go

···
 	"slices"
 	"strings"
 
+	tea "github.com/charmbracelet/bubbletea"
 	"github.com/spf13/cobra"
 	"github.com/stormlightlabs/git-storm/internal/changeset"
 	"github.com/stormlightlabs/git-storm/internal/style"
+	"github.com/stormlightlabs/git-storm/internal/ui"
 )
 
 func unreleasedCmd() *cobra.Command {
···
 		Long: `Launches an interactive Bubble Tea TUI to review, edit, or categorize
 unreleased entries before final release.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			fmt.Println("unreleased review not implemented (TUI)")
+			changesDir := ".changes"
+			entries, err := changeset.List(changesDir)
+			if err != nil {
+				return fmt.Errorf("failed to list changelog entries: %w", err)
+			}
+
+			if len(entries) == 0 {
+				style.Println("No unreleased changes found")
+				return nil
+			}
+
+			model := ui.NewChangesetReviewModel(entries)
+			p := tea.NewProgram(model, tea.WithAltScreen())
+
+			finalModel, err := p.Run()
+			if err != nil {
+				return fmt.Errorf("failed to run review TUI: %w", err)
+			}
+
+			reviewModel, ok := finalModel.(ui.ChangesetReviewModel)
+			if !ok {
+				return fmt.Errorf("unexpected model type")
+			}
+
+			if reviewModel.IsCancelled() {
+				style.Headline("Review cancelled")
+				return nil
+			}
+
+			items := reviewModel.GetReviewedItems()
+			deleteCount := 0
+			editCount := 0
+
+			for _, item := range items {
+				switch item.Action {
+				case ui.ActionDelete:
+					deleteCount++
+				case ui.ActionEdit:
+					editCount++
+				}
+			}
+
+			if deleteCount == 0 && editCount == 0 {
+				style.Headline("No changes requested")
+				return nil
+			}
+
+			style.Headlinef("Review completed: %d to delete, %d to edit", deleteCount, editCount)
+			style.Println("Note: Delete and edit actions are not yet implemented")
+
 			return nil
 		},
 	}

internal/ui/changeset_review.go

···
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/bubbles/key"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/git-storm/internal/changeset"
+	"github.com/stormlightlabs/git-storm/internal/style"
+)
+
+// ReviewAction represents an action to perform on a changeset entry.
+type ReviewAction int
+
+const (
+	ActionKeep ReviewAction = iota
+	ActionDelete
+	ActionEdit
+)
+
+// ReviewItem wraps a changeset entry with its review state.
+type ReviewItem struct {
+	Entry  changeset.EntryWithFile
+	Action ReviewAction
+}
+
+// ChangesetReviewModel holds the state for the interactive changeset review TUI.
+type ChangesetReviewModel struct {
+	viewport  viewport.Model
+	items     []ReviewItem
+	cursor    int
+	ready     bool
+	width     int
+	height    int
+	confirmed bool
+	cancelled bool
+}
+
+// changesetReviewKeyMap defines keyboard shortcuts for the changeset reviewer.
+type changesetReviewKeyMap struct {
+	Up       key.Binding
+	Down     key.Binding
+	PageUp   key.Binding
+	PageDown key.Binding
+	Top      key.Binding
+	Bottom   key.Binding
+	Delete   key.Binding
+	Edit     key.Binding
+	Keep     key.Binding
+	Confirm  key.Binding
+	Quit     key.Binding
+}
+
+var reviewKeys = changesetReviewKeyMap{
+	Up: key.NewBinding(
+		key.WithKeys("up", "k"),
+		key.WithHelp("↑/k", "up"),
+	),
+	Down: key.NewBinding(
+		key.WithKeys("down", "j"),
+		key.WithHelp("↓/j", "down"),
+	),
+	PageUp: key.NewBinding(
+		key.WithKeys("pgup", "u"),
+		key.WithHelp("pgup/u", "page up"),
+	),
+	PageDown: key.NewBinding(
+		key.WithKeys("pgdown", "d"),
+		key.WithHelp("pgdn/d", "page down"),
+	),
+	Top: key.NewBinding(
+		key.WithKeys("g", "home"),
+		key.WithHelp("g/home", "top"),
+	),
+	Bottom: key.NewBinding(
+		key.WithKeys("G", "end"),
+		key.WithHelp("G/end", "bottom"),
+	),
+	Delete: key.NewBinding(
+		key.WithKeys("x"),
+		key.WithHelp("x", "mark delete"),
+	),
+	Edit: key.NewBinding(
+		key.WithKeys("e"),
+		key.WithHelp("e", "mark edit"),
+	),
+	Keep: key.NewBinding(
+		key.WithKeys(" "),
+		key.WithHelp("space", "keep"),
+	),
+	Confirm: key.NewBinding(
+		key.WithKeys("enter", "c"),
+		key.WithHelp("enter/c", "confirm"),
+	),
+	Quit: key.NewBinding(
+		key.WithKeys("q", "esc", "ctrl+c"),
+		key.WithHelp("q", "quit"),
+	),
+}
+
+// NewChangesetReviewModel creates a new changeset review model.
+func NewChangesetReviewModel(entries []changeset.EntryWithFile) ChangesetReviewModel {
+	items := make([]ReviewItem, 0, len(entries))
+
+	for _, entry := range entries {
+		items = append(items, ReviewItem{
+			Entry:  entry,
+			Action: ActionKeep,
+		})
+	}
+
+	return ChangesetReviewModel{
+		items:  items,
+		cursor: 0,
+		ready:  false,
+	}
+}
+
+// Init initializes the model (required by Bubble Tea).
+func (m ChangesetReviewModel) Init() tea.Cmd {
+	return nil
+}
+
+// Update handles messages and updates the model state.
+func (m ChangesetReviewModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	var cmd tea.Cmd
+
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		switch {
+		case key.Matches(msg, reviewKeys.Quit):
+			m.cancelled = true
+			return m, tea.Quit
+
+		case key.Matches(msg, reviewKeys.Confirm):
+			m.confirmed = true
+			return m, tea.Quit
+
+		case key.Matches(msg, reviewKeys.Up):
+			if m.cursor > 0 {
+				m.cursor--
+				m.ensureVisible()
+			}
+
+		case key.Matches(msg, reviewKeys.Down):
+			if m.cursor < len(m.items)-1 {
+				m.cursor++
+				m.ensureVisible()
+			}
+
+		case key.Matches(msg, reviewKeys.PageUp):
+			m.cursor -= m.viewport.Height
+			if m.cursor < 0 {
+				m.cursor = 0
+			}
+			m.ensureVisible()
+
+		case key.Matches(msg, reviewKeys.PageDown):
+			m.cursor += m.viewport.Height
+			if m.cursor >= len(m.items) {
+				m.cursor = len(m.items) - 1
+			}
+			m.ensureVisible()
+
+		case key.Matches(msg, reviewKeys.Top):
+			m.cursor = 0
+			m.ensureVisible()
+
+		case key.Matches(msg, reviewKeys.Bottom):
+			m.cursor = len(m.items) - 1
+			m.ensureVisible()
+
+		case key.Matches(msg, reviewKeys.Delete):
+			if m.cursor >= 0 && m.cursor < len(m.items) {
+				m.items[m.cursor].Action = ActionDelete
+				m.updateContent()
+			}
+
+		case key.Matches(msg, reviewKeys.Edit):
+			if m.cursor >= 0 && m.cursor < len(m.items) {
+				m.items[m.cursor].Action = ActionEdit
+				m.updateContent()
+			}
+
+		case key.Matches(msg, reviewKeys.Keep):
+			if m.cursor >= 0 && m.cursor < len(m.items) {
+				m.items[m.cursor].Action = ActionKeep
+				m.updateContent()
+			}
+		}
+
+	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
+			m.updateContent()
+		} else {
+			m.viewport.Width = msg.Width
+			m.viewport.Height = msg.Height - 4
+			m.updateContent()
+		}
+	}
+
+	m.viewport, cmd = m.viewport.Update(msg)
+	return m, cmd
+}
+
+// View renders the current view of the changeset reviewer.
+func (m ChangesetReviewModel) View() string {
+	if !m.ready {
+		return "\n  Initializing..."
+	}
+
+	header := m.renderReviewHeader()
+	footer := m.renderReviewFooter()
+
+	return fmt.Sprintf("%s\n%s\n%s", header, m.viewport.View(), footer)
+}
+
+// GetReviewedItems returns all items with their review actions.
+func (m ChangesetReviewModel) GetReviewedItems() []ReviewItem {
+	return m.items
+}
+
+// IsCancelled returns true if the user quit without confirming.
+func (m ChangesetReviewModel) IsCancelled() bool {
+	return m.cancelled
+}
+
+// IsConfirmed returns true if the user confirmed their review.
+func (m ChangesetReviewModel) IsConfirmed() bool {
+	return m.confirmed
+}
+
+// ensureVisible scrolls the viewport to keep the cursor visible.
+func (m *ChangesetReviewModel) ensureVisible() {
+	lineHeight := 1
+	cursorY := m.cursor * lineHeight
+
+	if cursorY < m.viewport.YOffset {
+		m.viewport.YOffset = cursorY
+	} else if cursorY >= m.viewport.YOffset+m.viewport.Height {
+		m.viewport.YOffset = cursorY - m.viewport.Height + 1
+	}
+
+	m.updateContent()
+}
+
+// updateContent regenerates the viewport content.
+func (m *ChangesetReviewModel) updateContent() {
+	if !m.ready {
+		return
+	}
+
+	var content strings.Builder
+
+	for i, item := range m.items {
+		content.WriteString(m.renderReviewLine(i, item))
+		content.WriteString("\n")
+	}
+
+	m.viewport.SetContent(content.String())
+}
+
+// renderReviewLine renders a single changeset entry line with action state.
+func (m ChangesetReviewModel) renderReviewLine(index int, item ReviewItem) string {
+	var actionIcon string
+	var actionStyle lipgloss.Style
+
+	switch item.Action {
+	case ActionKeep:
+		actionIcon = "[✓]"
+		actionStyle = lipgloss.NewStyle().Foreground(style.AddedColor)
+	case ActionDelete:
+		actionIcon = "[✗]"
+		actionStyle = lipgloss.NewStyle().Foreground(style.RemovedColor)
+	case ActionEdit:
+		actionIcon = "[✎]"
+		actionStyle = lipgloss.NewStyle().Foreground(style.SecurityColor)
+	}
+
+	categoryStyle := getCategoryStyle(item.Entry.Entry.Type)
+	lineStyle := lipgloss.NewStyle()
+
+	if index == m.cursor {
+		lineStyle = lineStyle.Background(lipgloss.Color("#1f2428"))
+		actionStyle = actionStyle.Bold(true)
+	}
+
+	typeLabel := fmt.Sprintf("%-8s", item.Entry.Entry.Type)
+	scopePart := ""
+	if item.Entry.Entry.Scope != "" {
+		scopePart = fmt.Sprintf("(%s) ", item.Entry.Entry.Scope)
+	}
+
+	maxSummaryLen := max(m.width-40, 20)
+	summary := item.Entry.Entry.Summary
+	if len(summary) > maxSummaryLen {
+		summary = summary[:maxSummaryLen-3] + "..."
+	}
+
+	line := fmt.Sprintf("%s %s %s%s",
+		actionStyle.Render(actionIcon),
+		categoryStyle.Render(typeLabel),
+		scopePart,
+		summary,
+	)
+
+	return lineStyle.Render(line)
+}
+
+// renderReviewHeader creates the header showing entry count.
+func (m ChangesetReviewModel) renderReviewHeader() string {
+	headerStyle := lipgloss.NewStyle().
+		Foreground(style.AccentBlue).
+		Bold(true).
+		Padding(0, 1)
+
+	return headerStyle.Render(
+		fmt.Sprintf("Review unreleased changes (%d entries)", len(m.items)),
+	)
+}
+
+// renderReviewFooter creates the footer with help text and action summary.
+func (m ChangesetReviewModel) renderReviewFooter() string {
+	footerStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#6C7A89")).
+		Faint(true).
+		Padding(0, 1)
+
+	keepCount := 0
+	deleteCount := 0
+	editCount := 0
+
+	for _, item := range m.items {
+		switch item.Action {
+		case ActionKeep:
+			keepCount++
+		case ActionDelete:
+			deleteCount++
+		case ActionEdit:
+			editCount++
+		}
+	}
+
+	helpText := "↑/↓: navigate • space: keep • x: delete • e: edit • enter: confirm • q: quit"
+	actionInfo := fmt.Sprintf("keep: %d | delete: %d | edit: %d", keepCount, deleteCount, editCount)
+
+	totalWidth := m.width
+	helpWidth := lipgloss.Width(helpText)
+	actionWidth := lipgloss.Width(actionInfo)
+	padding := max(totalWidth-helpWidth-actionWidth-2, 0)
+
+	return footerStyle.Render(
+		helpText + strings.Repeat(" ", padding) + actionInfo,
+	)
+}

internal/ui/changeset_review_test.go

···
+package ui
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/exp/teatest"
+	"github.com/stormlightlabs/git-storm/internal/changeset"
+)
+
+func createMockEntry(filename, entryType, scope, summary string) changeset.EntryWithFile {
+	return changeset.EntryWithFile{
+		Entry: changeset.Entry{
+			Type:     entryType,
+			Scope:    scope,
+			Summary:  summary,
+			Breaking: false,
+		},
+		Filename: filename,
+	}
+}
+
+func TestChangesetReviewModel_Init(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	cmd := model.Init()
+	if cmd != nil {
+		t.Errorf("Init() should return nil, got %v", cmd)
+	}
+}
+
+func TestChangesetReviewModel_DefaultActions(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test1.md", "added", "cli", "Test entry 1"),
+		createMockEntry("test2.md", "fixed", "", "Test entry 2"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	for i, item := range model.items {
+		if item.Action != ActionKeep {
+			t.Errorf("Item %d should default to ActionKeep, got %v", i, item.Action)
+		}
+	}
+}
+
+func TestChangesetReviewModel_MarkDelete(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	model = updated.(ChangesetReviewModel)
+
+	if model.items[0].Action != ActionDelete {
+		t.Errorf("Item should be marked for deletion, got action %v", model.items[0].Action)
+	}
+}
+
+func TestChangesetReviewModel_MarkEdit(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'e'}})
+	model = updated.(ChangesetReviewModel)
+
+	if model.items[0].Action != ActionEdit {
+		t.Errorf("Item should be marked for editing, got action %v", model.items[0].Action)
+	}
+}
+
+func TestChangesetReviewModel_KeepAction(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	model = updated.(ChangesetReviewModel)
+
+	if model.items[0].Action != ActionDelete {
+		t.Fatal("Setup failed: item should be marked for deletion")
+	}
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeySpace})
+	model = updated.(ChangesetReviewModel)
+
+	if model.items[0].Action != ActionKeep {
+		t.Errorf("Item should be marked for keeping, got action %v", model.items[0].Action)
+	}
+}
+
+func TestChangesetReviewModel_Navigation(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test1.md", "added", "cli", "Test 1"),
+		createMockEntry("test2.md", "fixed", "", "Test 2"),
+		createMockEntry("test3.md", "changed", "api", "Test 3"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	if model.cursor != 0 {
+		t.Error("Cursor should start at 0")
+	}
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyDown})
+	model = updated.(ChangesetReviewModel)
+
+	if model.cursor != 1 {
+		t.Errorf("Cursor should be at 1 after down, got %d", model.cursor)
+	}
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyUp})
+	model = updated.(ChangesetReviewModel)
+
+	if model.cursor != 0 {
+		t.Errorf("Cursor should be at 0 after up, got %d", model.cursor)
+	}
+}
+
+func TestChangesetReviewModel_TopBottom(t *testing.T) {
+	entries := make([]changeset.EntryWithFile, 10)
+	for i := range entries {
+		entries[i] = createMockEntry("test.md", "added", "", "Test")
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'G'}})
+	model = updated.(ChangesetReviewModel)
+
+	if model.cursor != len(entries)-1 {
+		t.Errorf("Cursor should be at bottom (index %d), got %d", len(entries)-1, model.cursor)
+	}
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'g'}})
+	model = updated.(ChangesetReviewModel)
+
+	if model.cursor != 0 {
+		t.Errorf("Cursor should be at top (index 0), got %d", model.cursor)
+	}
+}
+
+func TestChangesetReviewModel_Confirm(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+	tm := teatest.NewTestModel(t, model)
+
+	tm.Send(tea.KeyMsg{Type: tea.KeyEnter})
+	tm.WaitFinished(t, teatest.WithFinalTimeout(time.Second))
+
+	finalModel := tm.FinalModel(t, teatest.WithFinalTimeout(time.Second))
+	reviewModel, ok := finalModel.(ChangesetReviewModel)
+	if !ok {
+		t.Fatal("Expected ChangesetReviewModel")
+	}
+
+	if !reviewModel.IsConfirmed() {
+		t.Error("Model should be confirmed after pressing enter")
+	}
+	if reviewModel.IsCancelled() {
+		t.Error("Model should not be cancelled")
+	}
+}
+
+func TestChangesetReviewModel_QuitKeys(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	quitKeys := []struct {
+		name    string
+		keyType tea.KeyType
+		runes   []rune
+	}{
+		{"q", tea.KeyRunes, []rune{'q'}},
+		{"esc", tea.KeyEsc, nil},
+		{"ctrl+c", tea.KeyCtrlC, nil},
+	}
+
+	for _, tc := range quitKeys {
+		t.Run(tc.name, func(t *testing.T) {
+			model := NewChangesetReviewModel(entries)
+			tm := teatest.NewTestModel(t, model)
+
+			var msg tea.Msg
+			if tc.runes != nil {
+				msg = tea.KeyMsg{Type: tc.keyType, Runes: tc.runes}
+			} else {
+				msg = tea.KeyMsg{Type: tc.keyType}
+			}
+
+			tm.Send(msg)
+			tm.WaitFinished(t, teatest.WithFinalTimeout(time.Second))
+
+			finalModel := tm.FinalModel(t, teatest.WithFinalTimeout(time.Second))
+			reviewModel, ok := finalModel.(ChangesetReviewModel)
+			if !ok {
+				t.Fatal("Expected ChangesetReviewModel")
+			}
+
+			if !reviewModel.IsCancelled() {
+				t.Error("Model should be cancelled after quit key")
+			}
+			if reviewModel.IsConfirmed() {
+				t.Error("Model should not be confirmed")
+			}
+		})
+	}
+}
+
+func TestChangesetReviewModel_GetReviewedItems(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test1.md", "added", "cli", "Test 1"),
+		createMockEntry("test2.md", "fixed", "", "Test 2"),
+		createMockEntry("test3.md", "changed", "api", "Test 3"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyDown})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'e'}})
+	model = updated.(ChangesetReviewModel)
+
+	items := model.GetReviewedItems()
+
+	if len(items) != 3 {
+		t.Errorf("Expected 3 items, got %d", len(items))
+	}
+
+	if items[0].Action != ActionDelete {
+		t.Errorf("First item should be ActionDelete, got %v", items[0].Action)
+	}
+
+	if items[1].Action != ActionEdit {
+		t.Errorf("Second item should be ActionEdit, got %v", items[1].Action)
+	}
+
+	if items[2].Action != ActionKeep {
+		t.Errorf("Third item should be ActionKeep, got %v", items[2].Action)
+	}
+}
+
+func TestChangesetReviewModel_View(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	view := model.View()
+
+	if !strings.Contains(view, "Review unreleased changes") {
+		t.Error("View should contain header text")
+	}
+	if !strings.Contains(view, "navigate") {
+		t.Error("View should contain navigation help")
+	}
+	if !strings.Contains(view, "keep") {
+		t.Error("View should contain action counts")
+	}
+}
+
+func TestChangesetReviewModel_RenderHeader(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test1.md", "added", "cli", "Test 1"),
+		createMockEntry("test2.md", "fixed", "", "Test 2"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+	model.width = 100
+
+	header := model.renderReviewHeader()
+
+	if !strings.Contains(header, "Review unreleased changes") {
+		t.Error("Header should contain title")
+	}
+	if !strings.Contains(header, "2") {
+		t.Error("Header should contain entry count")
+	}
+}
+
+func TestChangesetReviewModel_RenderFooter(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test1.md", "added", "cli", "Test 1"),
+		createMockEntry("test2.md", "fixed", "", "Test 2"),
+		createMockEntry("test3.md", "changed", "api", "Test 3"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+	model.width = 100
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyDown})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'e'}})
+	model = updated.(ChangesetReviewModel)
+
+	footer := model.renderReviewFooter()
+
+	if !strings.Contains(footer, "keep: 1") {
+		t.Error("Footer should show 1 keep action")
+	}
+	if !strings.Contains(footer, "delete: 1") {
+		t.Error("Footer should show 1 delete action")
+	}
+	if !strings.Contains(footer, "edit: 1") {
+		t.Error("Footer should show 1 edit action")
+	}
+}
+
+func TestChangesetReviewModel_RenderReviewLine(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+	model.width = 100
+
+	line := model.renderReviewLine(0, model.items[0])
+
+	if !strings.Contains(line, "[") {
+		t.Error("Line should contain action icon")
+	}
+	if !strings.Contains(line, "added") {
+		t.Error("Line should contain type")
+	}
+	if !strings.Contains(line, "cli") {
+		t.Error("Line should contain scope")
+	}
+	if !strings.Contains(line, "Test entry") {
+		t.Error("Line should contain summary")
+	}
+}
+
+func TestChangesetReviewModel_EmptyEntries(t *testing.T) {
+	entries := []changeset.EntryWithFile{}
+
+	model := NewChangesetReviewModel(entries)
+
+	if len(model.items) != 0 {
+		t.Errorf("Expected 0 items, got %d", len(model.items))
+	}
+
+	items := model.GetReviewedItems()
+	if len(items) != 0 {
+		t.Errorf("Expected 0 reviewed items, got %d", len(items))
+	}
+}
+
+func TestChangesetReviewModel_WindowResize(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test.md", "added", "cli", "Test entry"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 80, Height: 24})
+	model = updated.(ChangesetReviewModel)
+
+	if model.width != 80 || model.height != 24 {
+		t.Errorf("Expected dimensions 80x24, got %dx%d", model.width, model.height)
+	}
+	if !model.ready {
+		t.Error("Model should be ready after window size message")
+	}
+
+	updated, _ = model.Update(tea.WindowSizeMsg{Width: 120, Height: 40})
+	model = updated.(ChangesetReviewModel)
+
+	if model.width != 120 || model.height != 40 {
+		t.Errorf("Expected dimensions 120x40, got %dx%d", model.width, model.height)
+	}
+}
+
+func TestChangesetReviewModel_ActionCounts(t *testing.T) {
+	entries := []changeset.EntryWithFile{
+		createMockEntry("test1.md", "added", "cli", "Test 1"),
+		createMockEntry("test2.md", "fixed", "", "Test 2"),
+		createMockEntry("test3.md", "changed", "api", "Test 3"),
+		createMockEntry("test4.md", "removed", "", "Test 4"),
+	}
+
+	model := NewChangesetReviewModel(entries)
+
+	updated, _ := model.Update(tea.WindowSizeMsg{Width: 100, Height: 30})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyDown})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'x'}})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyDown})
+	model = updated.(ChangesetReviewModel)
+
+	updated, _ = model.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'e'}})
+	model = updated.(ChangesetReviewModel)
+
+	items := model.GetReviewedItems()
+
+	deleteCount := 0
+	editCount := 0
+	keepCount := 0
+
+	for _, item := range items {
+		switch item.Action {
+		case ActionDelete:
+			deleteCount++
+		case ActionEdit:
+			editCount++
+		case ActionKeep:
+			keepCount++
+		}
+	}
+
+	if deleteCount != 2 {
+		t.Errorf("Expected 2 delete actions, got %d", deleteCount)
+	}
+	if editCount != 1 {
+		t.Errorf("Expected 1 edit action, got %d", editCount)
+	}
+	if keepCount != 1 {
+		t.Errorf("Expected 1 keep action, got %d", keepCount)
+	}
+}

internal/ui/ui.go

···
 			return m, tea.Quit
 
 		case key.Matches(msg, key.NewBinding(key.WithKeys("e"))):
-			// Toggle expanded/compressed view
 			m.expanded = !m.expanded
 			m.updateViewport()
 
···
 			m.viewport.GotoTop()
 
 		case key.Matches(msg, keys.Up):
-			m.viewport.LineUp(1)
+			m.viewport.ScrollUp(1)
 
 		case key.Matches(msg, keys.Down):
-			m.viewport.LineDown(1)
+			m.viewport.ScrollDown(1)
 
 		case key.Matches(msg, keys.PageUp):
-			m.viewport.ViewUp()
+			m.viewport.PageUp()
 
 		case key.Matches(msg, keys.PageDown):
-			m.viewport.ViewDown()
+			m.viewport.PageDown()
 
 		case key.Matches(msg, keys.HalfUp):
-			m.viewport.HalfViewUp()
+			m.viewport.HalfPageUp()
 
 		case key.Matches(msg, keys.HalfDown):
-			m.viewport.HalfViewDown()
+			m.viewport.HalfPageDown()
 
 		case key.Matches(msg, keys.Top):
 			m.viewport.GotoTop()