savepoint 1.0.0 → 1.0.2

package/internal/board/view.go

@@ -1,6 +1,7 @@
 package board
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
@@ -18,19 +19,26 @@ func (m Model) View() string {
 	if w == 0 {
 		w = defaultTermW
 	}
-
-	layout := CalculateLayout(w, m.Height)
-	icon := styles.HeaderIcon.Render("▣")
-	text := styles.HeaderText.Render("S A V E P O I N T")
-	header := styles.HeaderFrame.Width(w).Render(icon + "  " + text)
-	board := m.renderBoard(layout)
-	footer := m.renderFooter(w)
-	base := lipgloss.JoinVertical(lipgloss.Left, header, board, footer)
-
+	m.Width = w
 	h := m.Height
 	if h == 0 {
 		h = defaultTermH
 	}
+	m.Height = h
+
+	header := m.renderHeader(w)
+	nextActivity := m.renderNextActivityLine(w)
+	layout := CalculateLayoutWithChrome(w, h, extraHeaderLines(nextActivity))
+	topDivider := dividerLine(w)
+	board := m.renderBoard(layout)
+	bottomDivider := dividerLine(w)
+	footer := m.renderFooter(w)
+	sections := []string{header}
+	if nextActivity != "" {
+		sections = append(sections, nextActivity)
+	}
+	sections = append(sections, topDivider, board, bottomDivider, footer)
+	base := lipgloss.JoinVertical(lipgloss.Left, sections...)
 
 	if m.Overlay == OverlayEpic {
 		overlay := RenderEpicDropdown(m.Epics, m.EpicCursor, min(40, w))
@@ -53,13 +61,111 @@ func (m Model) View() string {
 			return base
 		}
 		ow := overlayWidth(w)
-		detail := RenderDetail(task, ow)
+		detail := RenderDetail(task, ow, m.RouterState, detailMaxHeight(h), m.DetailOffset)
+		return overlayOnBase(dimLines(base), detail, w, h)
+	}
+
+	if m.Overlay == OverlayEpicDetail {
+		ow := overlayWidth(w)
+		epicSlug := ""
+		if m.EpicPanelCursor >= 0 && m.EpicPanelCursor < len(m.Epics) {
+			epicSlug = m.Epics[m.EpicPanelCursor]
+		}
+		detail := RenderEpicDetail(epicSlug, m.EpicDetailContent, ow, detailMaxHeight(h), m.EpicDetailOffset)
 		return overlayOnBase(dimLines(base), detail, w, h)
 	}
 
 	return base
 }
 
+func (m Model) renderHeader(w int) string {
+	icon := styles.HeaderIcon.Render("▣")
+	text := styles.HeaderText.Render("S A V E P O I N T")
+	left := icon + "  " + text
+	return styles.HeaderFrame.Width(w).Render(left)
+}
+
+func extraHeaderLines(line string) int {
+	if line == "" {
+		return 0
+	}
+	return 1
+}
+
+func (m Model) renderNextActivityLine(w int) string {
+	if w <= 0 {
+		w = defaultTermW
+	}
+	return renderNextActivityLine(m.RouterState, w)
+}
+
+func renderNextActivityLine(state *data.RouterState, w int) string {
+	tag, style, ok := nextActivityPhase(state)
+	if !ok || strings.TrimSpace(state.NextAction) == "" {
+		return ""
+	}
+
+	content := style.Render(tag+":") + " " + state.NextAction
+	if lipgloss.Width(content) > w {
+		content = xansi.Truncate(content, w, "…")
+	}
+	return styles.RootLine.Width(w).Render(content)
+}
+
+func nextActivityPhase(state *data.RouterState) (string, lipgloss.Style, bool) {
+	if state == nil {
+		return "", lipgloss.Style{}, false
+	}
+	switch state.State {
+	case "task-building":
+		return "BUILD", styles.FooterPhaseBuild, true
+	case "audit-pending":
+		return "AUDIT", styles.FooterPhaseAudit, true
+	case "pre-implementation", "epic-design", "epic-task-breakdown":
+		return "PLAN", styles.FooterPhasePlan, true
+	default:
+		return "", lipgloss.Style{}, false
+	}
+}
+
+// FormatNextActivity formats a compact activity string from router state.
+// Returns empty string when state is nil. Result is capped at 20 visible chars.
+func FormatNextActivity(state *data.RouterState) string {
+	if state == nil {
+		return ""
+	}
+	var s string
+	switch state.State {
+	case "task-building":
+		s = fmt.Sprintf("Build %s %s/%s", state.Release, shortRouterID(state.Epic), shortRouterID(state.Task))
+	case "audit-pending":
+		s = fmt.Sprintf("Audit %s", shortRouterID(state.Epic))
+	case "epic-design":
+		s = fmt.Sprintf("Design %s", shortRouterID(state.Epic))
+	case "epic-task-breakdown":
+		s = fmt.Sprintf("Plan %s", shortRouterID(state.Epic))
+	case "pre-implementation":
+		s = fmt.Sprintf("Planning %s", state.Release)
+	default:
+		s = state.State
+	}
+	return xansi.Truncate(s, 20, "…")
+}
+
+// shortRouterID extracts the compact prefix from a full router slug.
+// "E01-tui-optimisation/T001-border-resize-fix" → "T001"
+// "E01-tui-optimisation" → "E01"
+func shortRouterID(full string) string {
+	part := full
+	if i := strings.LastIndex(full, "/"); i >= 0 {
+		part = full[i+1:]
+	}
+	if i := strings.Index(part, "-"); i >= 0 {
+		return part[:i]
+	}
+	return part
+}
+
 func (m Model) focusedTask() (data.Task, bool) {
 	tasks := m.Tasks[m.FocusedColumn]
 	if len(tasks) == 0 || m.FocusedTask >= len(tasks) {
@@ -147,23 +253,34 @@ func (m Model) renderBoard(layout Layout) string {
 
 func (m Model) renderColumns(layout Layout) string {
 	if layout.ColCount == 1 {
-		return m.renderColumn(m.FocusedColumn, layout.ColWidths[0])
+		return m.renderColumn(m.FocusedColumn, layout.ColWidths[0], layout.ContentHeight)
 	}
 	allCols := []data.ColumnType{data.ColumnPlanned, data.ColumnInProgress, data.ColumnDone}
 	rendered := make([]string, len(allCols))
 	for i, col := range allCols {
-		rendered[i] = m.renderColumn(col, layout.ColWidths[i])
+		rendered[i] = m.renderColumn(col, layout.ColWidths[i], layout.ContentHeight)
 	}
 	return lipgloss.JoinHorizontal(lipgloss.Top, rendered...)
 }
 
 func (m Model) renderEpicPanel(w int) string {
-	return RenderEpicSidebar(m.Epics, m.SelectedEpic, w)
+	return RenderEpicSidebar(m.Epics, m.SelectedEpic, w, m.EpicPanelFocus, m.EpicPanelCursor, m.EpicStatus)
 }
 
-func (m Model) renderColumn(col data.ColumnType, colW int) string {
-	focused := m.FocusedColumn == col
-	return RenderColumn(m.Tasks[col], col, colW, m.FocusedTask, focused)
+func (m Model) renderColumn(col data.ColumnType, colW, maxHeight int) string {
+	focused := !m.EpicPanelFocus && m.FocusedColumn == col
+	return RenderColumn(m.Tasks[col], col, colW, maxHeight, m.ColumnOffsets[col], m.FocusedTask, focused, m.RouterState)
+}
+
+func detailMaxHeight(termH int) int {
+	if termH <= 0 {
+		termH = defaultTermH
+	}
+	h := termH * 7 / 10
+	if h < 6 {
+		h = 6
+	}
+	return h
 }
 
 func (m Model) renderFooter(termW int) string {
@@ -179,6 +296,13 @@ func (m Model) renderFooter(termW int) string {
 	return lipgloss.JoinVertical(lipgloss.Center, phase, spacer, hints)
 }
 
+func dividerLine(termW int) string {
+	if termW <= 0 {
+		termW = defaultTermW
+	}
+	return styles.Divider.Render(strings.Repeat("─", termW))
+}
+
 func footerLine(termW int, content string) string {
 	if termW <= 0 {
 		termW = defaultTermW
@@ -186,5 +310,5 @@ func footerLine(termW int, content string) string {
 	if lipgloss.Width(content) > termW {
 		content = xansi.Truncate(content, termW, "")
 	}
-	return lipgloss.NewStyle().Width(termW).Align(lipgloss.Center).Render(content)
+	return styles.RootLine.Width(termW).Align(lipgloss.Center).Render(content)
 }

package/internal/board/view_test.go

@@ -46,8 +46,8 @@ func TestView_containsDivider(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 120
 	got := m.View()
-	if !strings.Contains(got, "─") {
-		t.Error("View() missing horizontal divider")
+	if !strings.Contains(got, strings.Repeat("─", 120)) {
+		t.Error("View() missing full-width horizontal divider")
 	}
 }
 
@@ -74,7 +74,7 @@ func TestView_containsFooterHints(t *testing.T) {
 	if len(lines) != 3 {
 		t.Fatalf("renderFooter() returned %d lines, want 3", len(lines))
 	}
-	if strings.TrimSpace(lines[1]) != "" {
+	if strings.TrimSpace(plainTerminal(lines[1])) != "" {
 		t.Fatalf("renderFooter() spacer line = %q, want blank", lines[1])
 	}
 	for i, line := range lines {
@@ -133,6 +133,164 @@ func TestView_wideShowsEpicPanel(t *testing.T) {
 	}
 }
 
+func TestFormatNextActivity_nil(t *testing.T) {
+	if got := FormatNextActivity(nil); got != "" {
+		t.Errorf("FormatNextActivity(nil) = %q, want empty", got)
+	}
+}
+
+func TestFormatNextActivity_states(t *testing.T) {
+	cases := []struct {
+		state *data.RouterState
+		want  string
+	}{
+		{&data.RouterState{State: "task-building", Task: "T010", Epic: "E06", Release: "v1"}, "Build v1 E06/T010"},
+		{&data.RouterState{State: "audit-pending", Epic: "E06"}, "Audit E06"},
+		{&data.RouterState{State: "epic-design", Epic: "E06"}, "Design E06"},
+		{&data.RouterState{State: "epic-task-breakdown", Epic: "E06"}, "Plan E06"},
+		{&data.RouterState{State: "pre-implementation", Release: "v1"}, "Planning v1"},
+	}
+	for _, c := range cases {
+		got := FormatNextActivity(c.state)
+		if got != c.want {
+			t.Errorf("FormatNextActivity(%q) = %q, want %q", c.state.State, got, c.want)
+		}
+	}
+}
+
+func TestFormatNextActivity_truncation(t *testing.T) {
+	state := &data.RouterState{State: "task-building", Task: "T001", Epic: "E01-very-long-epic-name", Release: "v1.1"}
+	got := FormatNextActivity(state)
+	if lipgloss.Width(got) > 20 {
+		t.Errorf("FormatNextActivity truncation: width %d > 20, got %q", lipgloss.Width(got), got)
+	}
+}
+
+func TestFormatNextActivity_taskBuildingKeepsMinorReleaseVisible(t *testing.T) {
+	state := &data.RouterState{State: "task-building", Task: "T001", Epic: "E03", Release: "v1.1"}
+	got := FormatNextActivity(state)
+	if got != "Build v1.1 E03/T001" {
+		t.Errorf("FormatNextActivity() = %q, want Build v1.1 E03/T001", got)
+	}
+}
+
+func TestView_headerShowsNextActivity(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.RouterState = &data.RouterState{State: "audit-pending", NextAction: "Audit E06"}
+	got := m.View()
+	if !strings.Contains(got, "AUDIT:") {
+		t.Error("View() missing Next Activity phase tag")
+	}
+	if !strings.Contains(got, "Audit E06") {
+		t.Error("View() missing activity text below header")
+	}
+	if strings.Contains(got, "Next Activity:") {
+		t.Error("View() should not render Next Activity inside the header")
+	}
+}
+
+func TestView_nextActivityLineImmediatelyBelowHeader(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.RouterState = &data.RouterState{State: "task-building", NextAction: "Build T010 (E06) v1"}
+	got := m.View()
+
+	lines := strings.Split(got, "\n")
+	headerIndex := -1
+	activityIndex := -1
+	dividerIndex := -1
+	for i, line := range lines {
+		if strings.Contains(line, "S A V E P O I N T") {
+			headerIndex = i
+		}
+		if strings.Contains(line, "BUILD:") && strings.Contains(line, "Build T010 (E06) v1") {
+			activityIndex = i
+		}
+		if dividerIndex == -1 && strings.Contains(line, strings.Repeat("─", 120)) {
+			dividerIndex = i
+		}
+	}
+	if headerIndex == -1 || activityIndex == -1 || dividerIndex == -1 {
+		t.Fatalf("View() missing expected header/activity/divider lines: header=%d activity=%d divider=%d", headerIndex, activityIndex, dividerIndex)
+	}
+	if !(headerIndex < activityIndex && activityIndex < dividerIndex) {
+		t.Fatalf("Next Activity line order invalid: header=%d activity=%d divider=%d", headerIndex, activityIndex, dividerIndex)
+	}
+}
+
+func TestView_headerNoActivityWhenNilState(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.RouterState = nil
+	got := m.View()
+	if strings.Contains(got, "Next Activity:") || strings.Contains(got, "BUILD:") || strings.Contains(got, "PLAN:") || strings.Contains(got, "AUDIT:") {
+		t.Error("View() should not show Next Activity line when RouterState is nil")
+	}
+}
+
+func TestView_headerNarrowWidth(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 40
+	m.RouterState = &data.RouterState{State: "audit-pending", NextAction: "Audit E06"}
+	got := m.View()
+	// Should not panic and header text should still be present
+	if !strings.Contains(got, "S A V E P O I N T") {
+		t.Error("View() at narrow width missing header text")
+	}
+}
+
+func TestRenderNextActivityLine_phaseMapping(t *testing.T) {
+	cases := []struct {
+		name  string
+		state *data.RouterState
+		tag   string
+	}{
+		{"build", &data.RouterState{State: "task-building", NextAction: "Build T010 (E06) v1"}, "BUILD:"},
+		{"audit", &data.RouterState{State: "audit-pending", NextAction: "Audit E03"}, "AUDIT:"},
+		{"pre implementation", &data.RouterState{State: "pre-implementation", NextAction: "Plan v1.1"}, "PLAN:"},
+		{"epic design", &data.RouterState{State: "epic-design", NextAction: "Design E03"}, "PLAN:"},
+		{"task breakdown", &data.RouterState{State: "epic-task-breakdown", NextAction: "Break down E03"}, "PLAN:"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := renderNextActivityLine(tc.state, 80)
+			if !strings.Contains(got, tc.tag) {
+				t.Fatalf("renderNextActivityLine() missing phase tag %q in %q", tc.tag, got)
+			}
+			if !strings.Contains(got, tc.state.NextAction) {
+				t.Fatalf("renderNextActivityLine() missing next_action %q in %q", tc.state.NextAction, got)
+			}
+		})
+	}
+}
+
+func TestRenderNextActivityLine_hiddenStates(t *testing.T) {
+	cases := []*data.RouterState{
+		nil,
+		{State: "idle", NextAction: "Wait"},
+		{State: "task-building", NextAction: ""},
+	}
+	for _, state := range cases {
+		if got := renderNextActivityLine(state, 80); got != "" {
+			t.Fatalf("renderNextActivityLine(%v) = %q, want empty", state, got)
+		}
+	}
+}
+
+func TestRenderNextActivityLine_truncatesAtNarrowWidth(t *testing.T) {
+	got := renderNextActivityLine(&data.RouterState{
+		State:      "pre-implementation",
+		NextAction: "Build T010 (E06) v1 with a very long follow-up activity",
+	}, 18)
+	if lipgloss.Width(got) > 18 {
+		t.Fatalf("renderNextActivityLine() width = %d, want <= 18; got %q", lipgloss.Width(got), got)
+	}
+	if !strings.Contains(got, "PLAN:") || !strings.Contains(got, "…") {
+		t.Fatalf("renderNextActivityLine() = %q, want PLAN tag and ellipsis", got)
+	}
+}
+
 func TestView_narrowShowsSingleColumn(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 60

package/internal/board/watch.go

@@ -0,0 +1,100 @@
+package board
+
+import (
+	"os"
+	"path/filepath"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/fsnotify/fsnotify"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+type fileChangeMsg struct{}
+type reloadMsg struct {
+	tasks        []data.Task
+	releases     []string
+	releaseEpics map[string][]string
+	epicStatuses map[string]string
+}
+
+// watchFiles blocks until a file event arrives, debounces for 100ms, emits fileChangeMsg.
+func watchFiles(w *fsnotify.Watcher) tea.Cmd {
+	return func() tea.Msg {
+		for {
+			select {
+			case event, ok := <-w.Events:
+				if !ok {
+					return nil
+				}
+				watchCreatedDir(w, event)
+				timer := time.NewTimer(100 * time.Millisecond)
+			drain:
+				for {
+					select {
+					case event, ok := <-w.Events:
+						if !ok {
+							timer.Stop()
+							return nil
+						}
+						watchCreatedDir(w, event)
+					case <-timer.C:
+						break drain
+					}
+				}
+				return fileChangeMsg{}
+			case _, ok := <-w.Errors:
+				if !ok {
+					return nil
+				}
+			}
+		}
+	}
+}
+
+func reloadTasks(root string) tea.Cmd {
+	return func() tea.Msg {
+		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root)
+		if err != nil {
+			return nil
+		}
+		return reloadMsg{tasks: tasks, releases: releases, releaseEpics: releaseEpics, epicStatuses: epicStatuses}
+	}
+}
+
+// newWatcher watches the releases directory by walking all subdirs (fsnotify v1.10 has no recursive opt).
+func newWatcher(root string) (*fsnotify.Watcher, error) {
+	w, err := fsnotify.NewWatcher()
+	if err != nil {
+		return nil, err
+	}
+	releasesPath := filepath.Join(root, "releases")
+	if err := addDirsRecursive(w, releasesPath); err != nil {
+		w.Close()
+		return nil, err
+	}
+	return w, nil
+}
+
+func watchCreatedDir(w *fsnotify.Watcher, event fsnotify.Event) {
+	if !event.Has(fsnotify.Create) {
+		return
+	}
+	info, err := os.Stat(event.Name)
+	if err != nil || !info.IsDir() {
+		return
+	}
+	_ = addDirsRecursive(w, event.Name)
+}
+
+func addDirsRecursive(w *fsnotify.Watcher, root string) error {
+	return filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return nil // skip unreadable dirs
+		}
+		if d.IsDir() {
+			return w.Add(path)
+		}
+		return nil
+	})
+}