chore: rename project

* basic side by side diffing

.gitignore

···
 # .idea/
 # .vscode/
 .gocache/
+.task/
+tmp/

PROJECT.md

···
 ```ruby
 class Gostorm < Formula
   desc "Git-aware changelog manager with TUI review"
-  homepage "https://github.com/stormlightlabs/storm"
+  homepage "https://github.com/stormlightlabs/git-storm"
   version "1.3.0"
-  url "https://github.com/stormlightlabs/storm/archive/refs/tags/v1.3.0.tar.gz"
+  url "https://github.com/stormlightlabs/git-storm/archive/refs/tags/v1.3.0.tar.gz"
   sha256 "<insert_sha256_here>"
   license "MIT"
 
···
 ```powershell
 $ErrorActionPreference = 'Stop'
 $toolsDir   = "$(Split-Path -Parent $MyInvocation.MyCommand.Definition)"
-$url        = 'https://github.com/stormlightlabs/storm/releases/download/v1.3.0/storm_1.3.0_windows_amd64.zip'
+$url        = 'https://github.com/stormlightlabs/git-storm/releases/download/v1.3.0/storm_1.3.0_windows_amd64.zip'
 
 Install-ChocolateyZipPackage 'storm' $url $toolsDir
 ```
···
     <authors>Owais Jamil</authors>
     <description>Git-aware changelog manager with TUI review</description>
     <licenseUrl>https://opensource.org/licenses/MIT</licenseUrl>
-    <projectUrl>https://github.com/stormlightlabs/storm</projectUrl>
+    <projectUrl>https://github.com/stormlightlabs/git-storm</projectUrl>
   </metadata>
 </package>
 ```
···
 pkgrel=1
 pkgdesc="Git-aware changelog manager with TUI review"
 arch=('x86_64')
-url="https://github.com/stormlightlabs/storm"
+url="https://github.com/stormlightlabs/git-storm"
 license=('MIT')
 depends=('git' 'go')
 source=("$url/archive/refs/tags/v${pkgver}.tar.gz")

Taskfile.yml

···
+version: "3"
+
+vars:
+  BINARY_NAME: storm
+  BUILD_DIR: ./tmp
+  MAIN_PATH: ./main.go
+  VERSION:
+    sh: git describe --tags --always --dirty 2>/dev/null || echo "dev"
+
+tasks:
+  default:
+    desc: Show available tasks
+    cmds:
+      - task --list
+
+  build:
+    desc: Build the storm binary to ./tmp
+    cmds:
+      - mkdir -p {{.BUILD_DIR}}
+      - go build -o {{.BUILD_DIR}}/{{.BINARY_NAME}} {{.MAIN_PATH}}
+    sources:
+      - "**/*.go"
+      - go.mod
+      - go.sum
+    generates:
+      - "{{.BUILD_DIR}}/{{.BINARY_NAME}}"
+
+  build:release:
+    desc: Build optimized release binary
+    cmds:
+      - mkdir -p {{.BUILD_DIR}}
+      - go build -ldflags="-s -w -X main.versionString={{.VERSION}}" -o {{.BUILD_DIR}}/{{.BINARY_NAME}} {{.MAIN_PATH}}
+
+  install:
+    desc: Install storm to $GOPATH/bin
+    cmds:
+      - go install {{.MAIN_PATH}}
+
+  clean:
+    desc: Remove build artifacts
+    cmds:
+      - rm -rf {{.BUILD_DIR}}
+      - go clean
+
+  test:
+    desc: Run all tests with verbose output
+    cmds:
+      - go test -v ./...
+
+  test:quiet:
+    desc: Run all tests
+    cmds:
+      - go test ./...
+
+  test:cover:
+    desc: Run tests with coverage report
+    cmds:
+      - go test -coverprofile={{.BUILD_DIR}}/coverage.out ./...
+      - go tool cover -html={{.BUILD_DIR}}/coverage.out -o {{.BUILD_DIR}}/coverage.html
+      - 'echo "Coverage report: {{.BUILD_DIR}}/coverage.html"'
+
+  fmt:
+    desc: Format Go code
+    cmds:
+      - go fmt ./...
+
+  tidy:
+    desc: Tidy and verify dependencies
+    cmds:
+      - go mod tidy
+      - go mod verify
+
+  deps:
+    desc: Download dependencies
+    cmds:
+      - go mod download
+
+  check:
+    desc: Run all checks (fmt, test, lint)
+    cmds:
+      - task: fmt
+      - task: test
+
+  vet:
+    desc: Run go vet
+    cmds:
+      - go vet ./...
+
+  setup:
+    desc: Initial setup - install dependencies and build
+    cmds:
+      - task: deps
+      - task: tidy
+      - task: build
+      - echo "Setup complete."

go.mod

···
-module github.com/stormlightlabs/storm
+module github.com/stormlightlabs/git-storm
 
 go 1.24.5
 
 require (
+	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/fang v0.4.3
 	github.com/charmbracelet/lipgloss v1.1.1-0.20250404203927-76690c660834
 	github.com/charmbracelet/log v0.4.2

go.sum

···
 github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
 github.com/aymanbagabas/go-udiff v0.3.1 h1:LV+qyBQ2pqe0u42ZsUEtPiCaUoqgA9gYRDs3vj1nolY=
 github.com/aymanbagabas/go-udiff v0.3.1/go.mod h1:G0fsKmG+P6ylD0r6N/KgQD/nWzgfnl8ZBcNLgcbrw8E=
+github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
+github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=
 github.com/charmbracelet/bubbletea v1.3.10/go.mod h1:ORQfo0fk8U+po9VaNvnV95UPWA1BitP1E0N6xJPlHr4=
 github.com/charmbracelet/colorprofile v0.3.3 h1:DjJzJtLP6/NZ8p7Cgjno0CKGr7wwRJGxWUwh2IyhfAI=

internal/diff/format.go

···
+package diff
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/stormlightlabs/git-storm/internal/style"
+)
+
+const (
+	// Layout constants for side-by-side view
+	lineNumWidth = 4
+	gutterWidth  = 3
+	minPaneWidth = 40
+)
+
+// SideBySideFormatter renders diff edits in a split-pane layout with syntax highlighting.
+type SideBySideFormatter struct {
+	// TerminalWidth is the total available width for rendering
+	TerminalWidth int
+	// ShowLineNumbers controls whether line numbers are displayed
+	ShowLineNumbers 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")
+	}
+
+	paneWidth := f.calculatePaneWidth()
+
+	var sb strings.Builder
+	lineNumStyle := lipgloss.NewStyle().Foreground(lipgloss.Color("#6C7A89")).Faint(true)
+
+	for _, edit := range edits {
+		left, right := f.renderEdit(edit, paneWidth)
+
+		if f.ShowLineNumbers {
+			leftNum := f.formatLineNum(edit.AIndex, lineNumStyle)
+			rightNum := f.formatLineNum(edit.BIndex, lineNumStyle)
+
+			sb.WriteString(leftNum)
+			sb.WriteString(left)
+			sb.WriteString(f.renderGutter(edit.Kind))
+			sb.WriteString(rightNum)
+			sb.WriteString(right)
+		} else {
+			sb.WriteString(left)
+			sb.WriteString(f.renderGutter(edit.Kind))
+			sb.WriteString(right)
+		}
+		sb.WriteString("\n")
+	}
+
+	return sb.String()
+}
+
+// calculatePaneWidth determines the width available for each content pane.
+func (f *SideBySideFormatter) calculatePaneWidth() int {
+	usedWidth := gutterWidth
+	if f.ShowLineNumbers {
+		usedWidth += 2 * lineNumWidth
+	}
+
+	availableWidth := f.TerminalWidth - usedWidth
+	paneWidth := availableWidth / 2
+
+	if paneWidth < minPaneWidth {
+		paneWidth = minPaneWidth
+	}
+
+	return paneWidth
+}
+
+// renderEdit formats a single edit operation for both left and right panes.
+func (f *SideBySideFormatter) renderEdit(edit Edit, paneWidth int) (left, right string) {
+	content := f.truncateContent(edit.Content, paneWidth)
+
+	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)
+		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("")
+		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)
+		return leftStyled, rightStyled
+
+	default:
+		// Fallback for unknown edit kinds
+		return lipgloss.NewStyle().Width(paneWidth).Render(content),
+			lipgloss.NewStyle().Width(paneWidth).Render(content)
+	}
+}
+
+// renderGutter creates the visual separator between left and right panes.
+func (f *SideBySideFormatter) renderGutter(kind EditKind) string {
+	var symbol string
+	var st lipgloss.Style
+
+	switch kind {
+	case Equal:
+		symbol = " │ "
+		st = lipgloss.NewStyle().Foreground(lipgloss.Color("#6C7A89"))
+	case Delete:
+		symbol = " < "
+		st = style.StyleRemoved
+	case Insert:
+		symbol = " > "
+		st = style.StyleAdded
+	default:
+		symbol = " │ "
+		st = lipgloss.NewStyle()
+	}
+
+	return st.Render(symbol)
+}
+
+// formatLineNum renders a line number with styling.
+func (f *SideBySideFormatter) formatLineNum(index int, st lipgloss.Style) string {
+	if index < 0 {
+		return st.Width(lineNumWidth).Render("")
+	}
+	return st.Width(lineNumWidth).Render(fmt.Sprintf("%4d", index+1))
+}
+
+// truncateContent ensures content fits within the pane 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 {
+		return content
+	}
+
+	if maxWidth <= 3 {
+		return content[:maxWidth]
+	}
+
+	return content[:maxWidth-3] + "..."
+}

internal/diff/format_test.go

···
+package diff
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestSideBySideFormatter_Format(t *testing.T) {
+	tests := []struct {
+		name   string
+		edits  []Edit
+		width  int
+		expect func(string) bool
+	}{
+		{
+			name:  "empty edits",
+			edits: []Edit{},
+			width: 80,
+			expect: func(output string) bool {
+				return strings.Contains(output, "No changes")
+			},
+		},
+		{
+			name: "equal lines",
+			edits: []Edit{
+				{Kind: Equal, AIndex: 0, BIndex: 0, Content: "hello world"},
+			},
+			width: 80,
+			expect: func(output string) bool {
+				return strings.Contains(output, "hello world")
+			},
+		},
+		{
+			name: "insert operation",
+			edits: []Edit{
+				{Kind: Insert, AIndex: -1, BIndex: 0, Content: "new line"},
+			},
+			width: 80,
+			expect: func(output string) bool {
+				return strings.Contains(output, "new line") && strings.Contains(output, ">")
+			},
+		},
+		{
+			name: "delete operation",
+			edits: []Edit{
+				{Kind: Delete, AIndex: 0, BIndex: -1, Content: "old line"},
+			},
+			width: 80,
+			expect: func(output string) bool {
+				return strings.Contains(output, "old line") && strings.Contains(output, "<")
+			},
+		},
+		{
+			name: "mixed operations",
+			edits: []Edit{
+				{Kind: Equal, AIndex: 0, BIndex: 0, Content: "unchanged"},
+				{Kind: Delete, AIndex: 1, BIndex: -1, Content: "removed"},
+				{Kind: Insert, AIndex: -1, BIndex: 1, Content: "added"},
+				{Kind: Equal, AIndex: 2, BIndex: 2, Content: "also unchanged"},
+			},
+			width: 100,
+			expect: func(output string) bool {
+				return strings.Contains(output, "unchanged") &&
+					strings.Contains(output, "removed") &&
+					strings.Contains(output, "added")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			formatter := &SideBySideFormatter{
+				TerminalWidth:   tt.width,
+				ShowLineNumbers: true,
+			}
+
+			output := formatter.Format(tt.edits)
+
+			if !tt.expect(output) {
+				t.Errorf("Format() output did not meet expectations.\nGot:\n%s", output)
+			}
+		})
+	}
+}
+
+func TestSideBySideFormatter_CalculatePaneWidth(t *testing.T) {
+	tests := []struct {
+		name            string
+		terminalWidth   int
+		showLineNumbers bool
+		minExpected     int
+	}{
+		{
+			name:            "standard width with line numbers",
+			terminalWidth:   120,
+			showLineNumbers: true,
+			minExpected:     40,
+		},
+		{
+			name:            "narrow terminal",
+			terminalWidth:   60,
+			showLineNumbers: true,
+			minExpected:     minPaneWidth,
+		},
+		{
+			name:            "without line numbers",
+			terminalWidth:   100,
+			showLineNumbers: false,
+			minExpected:     40,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			formatter := &SideBySideFormatter{
+				TerminalWidth:   tt.terminalWidth,
+				ShowLineNumbers: tt.showLineNumbers,
+			}
+
+			paneWidth := formatter.calculatePaneWidth()
+
+			if paneWidth < tt.minExpected {
+				t.Errorf("calculatePaneWidth() = %d, expected at least %d", paneWidth, tt.minExpected)
+			}
+		})
+	}
+}
+
+func TestSideBySideFormatter_TruncateContent(t *testing.T) {
+	formatter := &SideBySideFormatter{}
+
+	tests := []struct {
+		name     string
+		content  string
+		maxWidth int
+		expected string
+	}{
+		{
+			name:     "short content",
+			content:  "hello",
+			maxWidth: 10,
+			expected: "hello",
+		},
+		{
+			name:     "exact fit",
+			content:  "hello world",
+			maxWidth: 11,
+			expected: "hello world",
+		},
+		{
+			name:     "needs truncation",
+			content:  "hello world this is a long line",
+			maxWidth: 10,
+			expected: "hello w...",
+		},
+		{
+			name:     "very small width",
+			content:  "hello",
+			maxWidth: 3,
+			expected: "hel",
+		},
+		{
+			name:     "trailing whitespace removed",
+			content:  "hello   ",
+			maxWidth: 10,
+			expected: "hello",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := formatter.truncateContent(tt.content, tt.maxWidth)
+			if result != tt.expected {
+				t.Errorf("truncateContent() = %q, expected %q", result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestSideBySideFormatter_RenderEdit(t *testing.T) {
+	formatter := &SideBySideFormatter{
+		TerminalWidth:   100,
+		ShowLineNumbers: true,
+	}
+	paneWidth := 40
+
+	tests := []struct {
+		name   string
+		edit   Edit
+		expect func(left, right string) bool
+	}{
+		{
+			name: "equal edit shows on both sides",
+			edit: Edit{Kind: Equal, AIndex: 0, BIndex: 0, Content: "same"},
+			expect: func(left, right string) bool {
+				return strings.Contains(left, "same") && strings.Contains(right, "same")
+			},
+		},
+		{
+			name: "delete shows only on left",
+			edit: Edit{Kind: Delete, AIndex: 0, BIndex: -1, Content: "removed"},
+			expect: func(left, right string) bool {
+				return strings.Contains(left, "removed") && !strings.Contains(right, "removed")
+			},
+		},
+		{
+			name: "insert shows only on right",
+			edit: Edit{Kind: Insert, AIndex: -1, BIndex: 0, Content: "added"},
+			expect: func(left, right string) bool {
+				return !strings.Contains(left, "added") && strings.Contains(right, "added")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			left, right := formatter.renderEdit(tt.edit, paneWidth)
+
+			if !tt.expect(left, right) {
+				t.Errorf("renderEdit() failed expectations.\nLeft: %q\nRight: %q", left, right)
+			}
+		})
+	}
+}

internal/ui/ui.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/diff"
+	"github.com/stormlightlabs/git-storm/internal/style"
+)
+
+// DiffModel holds the state for the side-by-side diff viewer.
+type DiffModel struct {
+	viewport viewport.Model
+	content  string
+	ready    bool
+	oldPath  string
+	newPath  string
+}
+
+// keyMap defines keyboard shortcuts for the diff viewer.
+type keyMap struct {
+	Up       key.Binding
+	Down     key.Binding
+	PageUp   key.Binding
+	PageDown key.Binding
+	HalfUp   key.Binding
+	HalfDown key.Binding
+	Top      key.Binding
+	Bottom   key.Binding
+	Quit     key.Binding
+}
+
+var keys = keyMap{
+	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", "b"),
+		key.WithHelp("pgup/b", "page up"),
+	),
+	PageDown: key.NewBinding(
+		key.WithKeys("pgdown", "f", " "),
+		key.WithHelp("pgdn/f/space", "page down"),
+	),
+	HalfUp: key.NewBinding(
+		key.WithKeys("u", "ctrl+u"),
+		key.WithHelp("u", "half page up"),
+	),
+	HalfDown: key.NewBinding(
+		key.WithKeys("d", "ctrl+d"),
+		key.WithHelp("d", "half page down"),
+	),
+	Top: key.NewBinding(
+		key.WithKeys("home", "g"),
+		key.WithHelp("g/home", "top"),
+	),
+	Bottom: key.NewBinding(
+		key.WithKeys("end", "G"),
+		key.WithHelp("G/end", "bottom"),
+	),
+	Quit: key.NewBinding(
+		key.WithKeys("q", "esc", "ctrl+c"),
+		key.WithHelp("q", "quit"),
+	),
+}
+
+// NewDiffModel creates a new diff viewer model with the given edits.
+func NewDiffModel(edits []diff.Edit, oldPath, newPath string, terminalWidth, terminalHeight int) DiffModel {
+	formatter := &diff.SideBySideFormatter{
+		TerminalWidth:   terminalWidth,
+		ShowLineNumbers: true,
+	}
+
+	content := formatter.Format(edits)
+
+	vp := viewport.New(terminalWidth, terminalHeight-2) // Reserve space for header
+	vp.SetContent(content)
+
+	return DiffModel{
+		viewport: vp,
+		content:  content,
+		ready:    true,
+		oldPath:  oldPath,
+		newPath:  newPath,
+	}
+}
+
+// Init initializes the model (required by Bubble Tea).
+func (m DiffModel) Init() tea.Cmd {
+	return nil
+}
+
+// Update handles messages and updates the model state.
+func (m DiffModel) Update(msg tea.Msg) (tea.Model, 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, 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:
+		if !m.ready {
+			m.viewport = viewport.New(msg.Width, msg.Height-2)
+			m.viewport.SetContent(m.content)
+			m.ready = true
+		} else {
+			m.viewport.Width = msg.Width
+			m.viewport.Height = msg.Height - 2
+		}
+	}
+
+	m.viewport, cmd = m.viewport.Update(msg)
+	return m, cmd
+}
+
+// View renders the current view of the diff viewer.
+func (m DiffModel) View() string {
+	if !m.ready {
+		return "\n  Initializing..."
+	}
+
+	header := m.renderHeader()
+	footer := m.renderFooter()
+
+	return fmt.Sprintf("%s\n%s\n%s", header, m.viewport.View(), footer)
+}
+
+// renderHeader creates the header bar showing file paths.
+func (m DiffModel) renderHeader() string {
+	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("+")
+
+	return headerStyle.Render(
+		fmt.Sprintf("%s %s  %s %s", oldLabel, m.oldPath, newLabel, m.newPath),
+	)
+}
+
+// renderFooter creates the footer bar with help text and scroll position.
+func (m DiffModel) renderFooter() string {
+	footerStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#6C7A89")).
+		Faint(true).
+		Padding(0, 1)
+
+	helpText := "↑/↓: scroll • space/b: page • g/G: top/bottom • q: quit"
+
+	scrollPercent := m.viewport.ScrollPercent()
+	scrollInfo := fmt.Sprintf("%.0f%%", scrollPercent*100)
+
+	totalWidth := m.viewport.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

···
+package ui
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/x/exp/teatest"
+	"github.com/stormlightlabs/git-storm/internal/diff"
+)
+
+func TestDiffModel_Init(t *testing.T) {
+	edits := []diff.Edit{
+		{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "line 1"},
+	}
+
+	model := NewDiffModel(edits, "old.txt", "new.txt", 80, 24)
+
+	cmd := model.Init()
+	if cmd != nil {
+		t.Errorf("Init() should return nil, got %v", cmd)
+	}
+}
+
+func TestDiffModel_View(t *testing.T) {
+	edits := []diff.Edit{
+		{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "unchanged line"},
+		{Kind: diff.Delete, AIndex: 1, BIndex: -1, Content: "removed line"},
+		{Kind: diff.Insert, AIndex: -1, BIndex: 1, Content: "added line"},
+	}
+
+	model := NewDiffModel(edits, "old.txt", "new.txt", 100, 30)
+
+	view := model.View()
+
+	if !strings.Contains(view, "old.txt") {
+		t.Error("View should contain old file path")
+	}
+	if !strings.Contains(view, "new.txt") {
+		t.Error("View should contain new file path")
+	}
+	if !strings.Contains(view, "unchanged line") {
+		t.Error("View should contain unchanged line")
+	}
+}
+
+func TestDiffModel_KeyboardNavigation(t *testing.T) {
+	edits := make([]diff.Edit, 100)
+	for i := range edits {
+		edits[i] = diff.Edit{
+			Kind:    diff.Equal,
+			AIndex:  i,
+			BIndex:  i,
+			Content: "line content",
+		}
+	}
+
+	model := NewDiffModel(edits, "old.txt", "new.txt", 80, 20)
+
+	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))
+}
+
+func TestDiffModel_QuitKeys(t *testing.T) {
+	edits := []diff.Edit{
+		{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "test"},
+	}
+
+	quitKeys := []tea.KeyType{
+		tea.KeyRunes, // 'q'
+		tea.KeyEsc,
+		tea.KeyCtrlC,
+	}
+
+	for _, keyType := range quitKeys {
+		t.Run(keyType.String(), func(t *testing.T) {
+			model := NewDiffModel(edits, "old.txt", "new.txt", 80, 20)
+			tm := teatest.NewTestModel(t, model)
+
+			var msg tea.Msg
+			if keyType == tea.KeyRunes {
+				msg = tea.KeyMsg{Type: keyType, Runes: []rune{'q'}}
+			} else {
+				msg = tea.KeyMsg{Type: keyType}
+			}
+
+			tm.Send(msg)
+			tm.WaitFinished(t, teatest.WithFinalTimeout(3*time.Second))
+		})
+	}
+}
+
+func TestDiffModel_RenderHeader(t *testing.T) {
+	edits := []diff.Edit{}
+	model := NewDiffModel(edits, "src/old.go", "src/new.go", 80, 20)
+
+	header := model.renderHeader()
+
+	if !strings.Contains(header, "old.go") {
+		t.Error("Header should contain old file path")
+	}
+	if !strings.Contains(header, "new.go") {
+		t.Error("Header should contain new file path")
+	}
+}
+
+func TestDiffModel_RenderFooter(t *testing.T) {
+	edits := []diff.Edit{
+		{Kind: diff.Equal, AIndex: 0, BIndex: 0, Content: "test"},
+	}
+	model := NewDiffModel(edits, "old.txt", "new.txt", 80, 20)
+
+	footer := model.renderFooter()
+
+	if !strings.Contains(footer, "scroll") {
+		t.Error("Footer should contain help text about scrolling")
+	}
+	if !strings.Contains(footer, "quit") {
+		t.Error("Footer should contain help text about quitting")
+	}
+}

main.go

···
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/fang"
+	"github.com/charmbracelet/log"
+	"github.com/go-git/go-git/v6"
+	"github.com/go-git/go-git/v6/plumbing"
+	"github.com/spf13/cobra"
+	"github.com/stormlightlabs/git-storm/internal/diff"
+	"github.com/stormlightlabs/git-storm/internal/ui"
+)
+
+var (
+	repoPath string
+	output   string
+)
+
+var (
+	fromRef     string
+	toRef       string
+	interactive bool
+	sinceTag    string
+)
+
+var (
+	changeType string
+	scope      string
+	summary    string
+	outputJSON bool
+)
+
+var (
+	releaseVersion string
+	tagRelease     bool
+	dryRun         bool
+)
+
+const versionString string = "0.1.0-dev"
+
+// runDiff executes the diff command by reading file contents from two git refs and launching the TUI.
+func runDiff(fromRef, toRef, filePath string) 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)
+	}
+
+	newContent, err := getFileContent(repo, toRef, filePath)
+	if err != nil {
+		return fmt.Errorf("failed to read %s from %s: %w", filePath, toRef, err)
+	}
+
+	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: %w", err)
+	}
+
+	model := ui.NewDiffModel(edits, fromRef+":"+filePath, toRef+":"+filePath, 120, 30)
+
+	p := tea.NewProgram(model, tea.WithAltScreen())
+	if _, err := p.Run(); err != nil {
+		return fmt.Errorf("TUI failed: %w", err)
+	}
+
+	return nil
+}
+
+// getFileContent reads the content of a file at a specific ref (commit, tag, or branch).
+func getFileContent(repo *git.Repository, ref, filePath string) (string, error) {
+	hash, err := repo.ResolveRevision(plumbing.Revision(ref))
+	if err != nil {
+		return "", fmt.Errorf("failed to resolve %s: %w", ref, err)
+	}
+
+	commit, err := repo.CommitObject(*hash)
+	if err != nil {
+		return "", fmt.Errorf("failed to get commit: %w", err)
+	}
+
+	tree, err := commit.Tree()
+	if err != nil {
+		return "", fmt.Errorf("failed to get tree: %w", err)
+	}
+
+	file, err := tree.File(filePath)
+	if err != nil {
+		return "", fmt.Errorf("file not found: %w", err)
+	}
+
+	content, err := file.Contents()
+	if err != nil {
+		return "", fmt.Errorf("failed to read file content: %w", err)
+	}
+
+	return content, nil
+}
+
+func versionCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "version",
+		Short: "Print the current storm version",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println(versionString)
+			return nil
+		},
+	}
+}
+
+func diffCmd() *cobra.Command {
+	var filePath string
+
+	c := &cobra.Command{
+		Use:   "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),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runDiff(args[0], args[1], filePath)
+		},
+	}
+
+	c.Flags().StringVarP(&filePath, "file", "f", "", "File path to diff (required)")
+	c.MarkFlagRequired("file")
+
+	return c
+}
+
+func releaseCmd() *cobra.Command {
+	c := &cobra.Command{
+		Use:   "release",
+		Short: "Promote unreleased changes into a new changelog version",
+		Long: `Merges all .changes entries into CHANGELOG.md under a new version header.
+Optionally creates a Git tag and clears the .changes directory.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("release command not implemented")
+			fmt.Printf("version=%v tag=%v dry-run=%v\n", releaseVersion, tagRelease, dryRun)
+			return nil
+		},
+	}
+
+	c.Flags().StringVar(&releaseVersion, "version", "", "Semantic version for the new release (e.g., 1.3.0)")
+	c.Flags().BoolVar(&tagRelease, "tag", false, "Create a Git tag after release")
+	c.Flags().BoolVar(&dryRun, "dry-run", false, "Preview changes without writing files")
+	c.MarkFlagRequired("version")
+
+	return c
+}
+
+func unreleasedCmd() *cobra.Command {
+	add := &cobra.Command{
+		Use:   "add",
+		Short: "Add a new unreleased change entry",
+		Long: `Creates a new .changes/<date>-<summary>.md file with the specified type,
+scope, and summary.`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("unreleased add not implemented")
+			fmt.Printf("type=%q scope=%q summary=%q\n", changeType, scope, summary)
+			return nil
+		},
+	}
+	add.Flags().StringVar(&changeType, "type", "", "Type of change (added, changed, fixed, removed, security)")
+	add.Flags().StringVar(&scope, "scope", "", "Optional scope or subsystem name")
+	add.Flags().StringVar(&summary, "summary", "", "Short summary of the change")
+	add.MarkFlagRequired("type")
+	add.MarkFlagRequired("summary")
+
+	list := &cobra.Command{
+		Use:   "list",
+		Short: "List all unreleased changes",
+		Long:  "Prints all pending .changes entries to stdout. Supports JSON output.",
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("unreleased list not implemented")
+			fmt.Printf("outputJSON=%v\n", outputJSON)
+			return nil
+		},
+	}
+	list.Flags().BoolVar(&outputJSON, "json", false, "Output results as JSON")
+
+	review := &cobra.Command{
+		Use:   "review",
+		Short: "Review unreleased changes interactively",
+		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)")
+			return nil
+		},
+	}
+
+	root := &cobra.Command{
+		Use:   "unreleased",
+		Short: "Manage unreleased changes (.changes directory)",
+		Long: `Work with unreleased change notes. Supports adding, listing,
+and reviewing pending entries before release.`,
+	}
+	root.AddCommand(add, list, review)
+
+	return root
+}
+
+func generateCmd() *cobra.Command {
+	c := &cobra.Command{
+		Use:   "generate [from] [to]",
+		Short: "Generate changelog entries from Git commits",
+		Long: `Scans commits between two Git refs (tags or hashes) and outputs draft
+entries in .changes/. Supports conventional commit parsing and
+interactive review mode.`,
+		Args: cobra.MaximumNArgs(2),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			fmt.Println("generate command not implemented")
+			fmt.Printf("from=%v to=%v interactive=%v sinceTag=%v\n", fromRef, toRef, interactive, sinceTag)
+			return nil
+		},
+	}
+
+	c.Flags().BoolVarP(&interactive, "interactive", "i", false, "Review changes interactively in a TUI")
+	c.Flags().StringVar(&sinceTag, "since", "", "Generate changes since the given tag")
+
+	return c
+}
+
+func main() {
+	ctx := context.Background()
+	root := &cobra.Command{
+		Use:   "storm",
+		Short: "A Git-aware changelog manager for Go projects",
+		Long: `storm is a modern changelog generator inspired by Towncrier.
+It manages .changes/ entries, generates Keep a Changelog sections,
+and can review commits interactively through a TUI.`,
+	}
+
+	root.PersistentFlags().StringVar(&repoPath, "repo", ".", "Path to the Git repository")
+	root.PersistentFlags().StringVarP(&output, "output", "o", "CHANGELOG.md", "Output changelog file path")
+	root.AddCommand(generateCmd(), unreleasedCmd(), releaseCmd(), diffCmd(), versionCmd())
+
+	if err := fang.Execute(ctx, root); err != nil {
+		log.Fatalf("Execution failed: %v", err)
+	}
+}