savepoint 1.0.0 → 1.0.2

package/internal/board/update.go

@@ -1,6 +1,10 @@
 package board
 
 import (
+	"os"
+	"path/filepath"
+	"strings"
+
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/opencode/savepoint/internal/data"
 )
@@ -13,35 +17,111 @@ var columnOrder = []data.ColumnType{
 
 func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
+	case fileChangeMsg:
+		if m.Root != "" {
+			return m, reloadTasks(m.Root)
+		}
+	case reloadMsg:
+		m.AllTasks = msg.tasks
+		m.Releases = append([]string(nil), msg.releases...)
+		m.ReleaseEpics = copyReleaseEpics(msg.releaseEpics)
+		m.EpicStatus = msg.epicStatuses
+		m.SelectedRelease = firstKnown(m.SelectedRelease, m.Releases)
+		m.refreshEpicsForRelease()
+		m.refreshTasks()
+		m.ensureFocusedTaskVisible()
+		if m.Watcher != nil {
+			return m, watchFiles(m.Watcher)
+		}
 	case tea.KeyMsg:
 		if m.Overlay != OverlayNone {
 			return m.updateOverlay(msg)
 		}
 		switch msg.String() {
 		case "q", "ctrl+c":
+			if m.Watcher != nil {
+				m.Watcher.Close()
+			}
 			return m, tea.Quit
+		case "e":
+			m.Overlay = OverlayEpic
+			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
+			return m, nil
+		case "r":
+			m.Overlay = OverlayRelease
+			m.ReleaseCursor = releaseIndex(m.Releases, m.SelectedRelease)
+			return m, nil
+		case "?":
+			m.Overlay = OverlayHelp
+			return m, nil
+		case "m":
+			task, ok := m.focusedTask()
+			if !ok {
+				return m, nil
+			}
+			if taskDone(task) {
+				m.StatusMessage = "Router not updated: focused task is done"
+				return m, nil
+			}
+			if m.Root == "" {
+				m.StatusMessage = "Router not updated: no savepoint root"
+				return m, nil
+			}
+			message, err := m.writeRouterTask(task)
+			if err != nil {
+				m.StatusMessage = err.Error()
+				return m, nil
+			}
+			m.StatusMessage = message
+			return m, nil
+		}
+		if m.EpicPanelFocus {
+			if !m.epicPanelAvailable() {
+				m.EpicPanelFocus = false
+			} else {
+				return m.updateEpicPanel(msg)
+			}
+		}
+		switch msg.String() {
 		case "left", "h":
+			if m.FocusedColumn == data.ColumnPlanned && m.epicPanelAvailable() {
+				m.EpicPanelFocus = true
+				m.EpicPanelCursor = epicIndex(m.Epics, m.SelectedEpic)
+				m.StatusMessage = ""
+				return m, nil
+			}
 			m.FocusedColumn = prevColumn(m.FocusedColumn)
 			m.FocusedTask = 0
+			m.ensureFocusedTaskVisible()
 			m.StatusMessage = ""
 		case "right", "l":
 			m.FocusedColumn = nextColumn(m.FocusedColumn)
 			m.FocusedTask = 0
+			m.ensureFocusedTaskVisible()
 			m.StatusMessage = ""
 		case "up", "k":
 			if m.FocusedTask > 0 {
 				m.FocusedTask--
 			}
+			m.ensureFocusedTaskVisible()
 			m.StatusMessage = ""
 		case "down", "j":
 			if m.FocusedTask < len(m.Tasks[m.FocusedColumn])-1 {
 				m.FocusedTask++
 			}
+			m.ensureFocusedTaskVisible()
+			m.StatusMessage = ""
+		case "pgup":
+			m.scrollFocusedColumn(-m.columnPageSize())
+			m.StatusMessage = ""
+		case "pgdown":
+			m.scrollFocusedColumn(m.columnPageSize())
 			m.StatusMessage = ""
 		case "enter":
 			tasks := m.Tasks[m.FocusedColumn]
 			if len(tasks) > 0 && m.FocusedTask < len(tasks) {
 				m.Overlay = OverlayDetail
+				m.DetailOffset = 0
 			}
 			m.StatusMessage = ""
 		case " ":
@@ -55,46 +135,153 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					for i, t := range m.AllTasks {
 						if t.ID == task.ID {
 							Advance(&m.AllTasks[i])
+							if m.AllTasks[i].Path != "" {
+								if err := data.WriteTaskStatus(m.AllTasks[i].Path, &m.AllTasks[i], task.Mtime); err != nil && err != data.ErrMtimeConflict {
+									m.StatusMessage = err.Error()
+								}
+							}
 							break
 						}
 					}
 					m.refreshTasks()
+					m.ensureFocusedTaskVisible()
 				}
 			}
 		case "backspace":
 			tasks := m.Tasks[m.FocusedColumn]
 			if len(tasks) > 0 && m.FocusedTask < len(tasks) {
 				task := tasks[m.FocusedTask]
+				m.StatusMessage = ""
 				for i, t := range m.AllTasks {
 					if t.ID == task.ID {
 						Retreat(&m.AllTasks[i])
+						if m.AllTasks[i].Path != "" {
+							if err := data.WriteTaskStatus(m.AllTasks[i].Path, &m.AllTasks[i], task.Mtime); err != nil && err != data.ErrMtimeConflict {
+								m.StatusMessage = err.Error()
+							}
+						}
 						break
 					}
 				}
 				m.refreshTasks()
+				m.ensureFocusedTaskVisible()
 			}
-			m.StatusMessage = ""
-		case "e":
-			m.Overlay = OverlayEpic
-			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
-		case "r":
-			m.Overlay = OverlayRelease
-			m.ReleaseCursor = releaseIndex(m.Releases, m.SelectedRelease)
-		case "?":
-			m.Overlay = OverlayHelp
 		}
 	case tea.WindowSizeMsg:
 		m.Width = msg.Width
 		m.Height = msg.Height
+		if !m.epicPanelAvailable() {
+			m.EpicPanelFocus = false
+		}
+		m.ensureFocusedTaskVisible()
 	}
 	return m, nil
 }
 
+func (m Model) updateEpicPanel(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	if len(m.Epics) == 0 {
+		m.EpicPanelFocus = false
+		return m, nil
+	}
+
+	m.StatusMessage = ""
+	switch msg.String() {
+	case "up", "k":
+		if m.EpicPanelCursor > 0 {
+			m.EpicPanelCursor--
+			m.selectEpicPanelEpic()
+		}
+	case "down", "j":
+		if m.EpicPanelCursor < len(m.Epics)-1 {
+			m.EpicPanelCursor++
+			m.selectEpicPanelEpic()
+		}
+	case "enter":
+		m.openEpicDetailOverlay()
+	case "right", "l":
+		m.EpicPanelFocus = false
+		m.FocusedColumn = data.ColumnPlanned
+		m.FocusedTask = 0
+		m.ensureFocusedTaskVisible()
+	case "left", "h":
+		// Stay in the panel; there is no focusable region further left.
+	}
+	return m, nil
+}
+
+func (m *Model) selectEpicPanelEpic() {
+	if len(m.Epics) == 0 || m.EpicPanelCursor < 0 || m.EpicPanelCursor >= len(m.Epics) {
+		return
+	}
+	m.SelectedEpic = m.Epics[m.EpicPanelCursor]
+	m.FocusedTask = 0
+	m.DetailOffset = 0
+	m.refreshTasks()
+	m.ensureFocusedTaskVisible()
+	if m.Root != "" {
+		if err := m.writeRouterReleaseEpic(); err != nil {
+			m.StatusMessage = err.Error()
+		}
+	}
+}
+
+func (m *Model) openEpicDetailOverlay() {
+	if len(m.Epics) == 0 || m.EpicPanelCursor < 0 || m.EpicPanelCursor >= len(m.Epics) {
+		return
+	}
+	epicSlug := m.Epics[m.EpicPanelCursor]
+	shortEpicID := epicSlug
+	if idx := strings.Index(epicSlug, "-"); idx >= 0 {
+		shortEpicID = epicSlug[:idx]
+	}
+	epicDir := filepath.Join(m.Root, "releases", m.SelectedRelease, "epics", epicSlug)
+	m.EpicDetailContent = readEpicDetailFile(epicDir, shortEpicID)
+	m.EpicDetailOffset = 0
+	m.Overlay = OverlayEpicDetail
+}
+
+// readEpicDetailFile finds and reads the canonical detail file for an epic.
+// Tries E##-Detail.md then E##-Design.md; falls back to any E##-*.md in the dir.
+func readEpicDetailFile(epicDir, shortID string) string {
+	for _, suffix := range []string{"-Detail.md", "-Design.md"} {
+		if raw, err := os.ReadFile(filepath.Join(epicDir, shortID+suffix)); err == nil {
+			return string(raw)
+		}
+	}
+	entries, err := os.ReadDir(epicDir)
+	if err != nil {
+		return "(no detail available)"
+	}
+	prefix := shortID + "-"
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasPrefix(e.Name(), prefix) && strings.HasSuffix(e.Name(), ".md") {
+			if raw, err := os.ReadFile(filepath.Join(epicDir, e.Name())); err == nil {
+				return string(raw)
+			}
+		}
+	}
+	return "(no detail available)"
+}
+
+func copyReleaseEpics(in map[string][]string) map[string][]string {
+	out := make(map[string][]string, len(in))
+	for release, epics := range in {
+		out[release] = append([]string(nil), epics...)
+	}
+	return out
+}
+
 func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 	switch msg.String() {
 	case "esc", "q":
 		m.Overlay = OverlayNone
 	case "up", "k":
+		if m.Overlay == OverlayDetail && m.DetailOffset > 0 {
+			m.DetailOffset--
+		}
+		if m.Overlay == OverlayEpicDetail && m.EpicDetailOffset > 0 {
+			m.EpicDetailOffset--
+		}
 		if m.Overlay == OverlayEpic && m.EpicCursor > 0 {
 			m.EpicCursor--
 		}
@@ -102,6 +289,12 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.ReleaseCursor--
 		}
 	case "down", "j":
+		if m.Overlay == OverlayDetail {
+			m.DetailOffset++
+		}
+		if m.Overlay == OverlayEpicDetail {
+			m.EpicDetailOffset++
+		}
 		if m.Overlay == OverlayEpic && len(m.Epics) > 0 && m.EpicCursor < len(m.Epics)-1 {
 			m.EpicCursor++
 		}
@@ -112,7 +305,9 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 		if m.Overlay == OverlayEpic && len(m.Epics) > 0 {
 			m.SelectedEpic = m.Epics[m.EpicCursor]
 			m.FocusedTask = 0
+			m.DetailOffset = 0
 			m.refreshTasks()
+			m.ensureFocusedTaskVisible()
 			m.Overlay = OverlayNone
 			if m.Root != "" {
 				if err := m.writeRouterReleaseEpic(); err != nil {
@@ -124,7 +319,9 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 			m.SelectedRelease = m.Releases[m.ReleaseCursor]
 			m.refreshEpicsForRelease()
 			m.FocusedTask = 0
+			m.DetailOffset = 0
 			m.refreshTasks()
+			m.ensureFocusedTaskVisible()
 			m.Overlay = OverlayNone
 			if m.Root != "" {
 				if err := m.writeRouterReleaseEpic(); err != nil {
@@ -132,10 +329,104 @@ func (m Model) updateOverlay(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 				}
 			}
 		}
+	case "pgup":
+		if m.Overlay == OverlayDetail {
+			m.DetailOffset -= m.detailPageSize()
+			if m.DetailOffset < 0 {
+				m.DetailOffset = 0
+			}
+		}
+		if m.Overlay == OverlayEpicDetail {
+			m.EpicDetailOffset -= m.detailPageSize()
+			if m.EpicDetailOffset < 0 {
+				m.EpicDetailOffset = 0
+			}
+		}
+	case "pgdown":
+		if m.Overlay == OverlayDetail {
+			m.DetailOffset += m.detailPageSize()
+		}
+		if m.Overlay == OverlayEpicDetail {
+			m.EpicDetailOffset += m.detailPageSize()
+		}
 	}
 	return m, nil
 }
 
+func (m *Model) ensureFocusedTaskVisible() {
+	if m.ColumnOffsets == nil {
+		m.ColumnOffsets = newColumnOffsets()
+	}
+	tasks := m.Tasks[m.FocusedColumn]
+	if len(tasks) == 0 {
+		m.ColumnOffsets[m.FocusedColumn] = 0
+		return
+	}
+	pageSize := m.columnPageSize()
+	offset := m.ColumnOffsets[m.FocusedColumn]
+	if m.FocusedTask < offset {
+		offset = m.FocusedTask
+	}
+	if m.FocusedTask >= offset+pageSize {
+		offset = m.FocusedTask - pageSize + 1
+	}
+	maxOffset := max(len(tasks)-pageSize, 0)
+	if offset > maxOffset {
+		offset = maxOffset
+	}
+	if offset < 0 {
+		offset = 0
+	}
+	m.ColumnOffsets[m.FocusedColumn] = offset
+}
+
+func (m *Model) scrollFocusedColumn(delta int) {
+	if m.ColumnOffsets == nil {
+		m.ColumnOffsets = newColumnOffsets()
+	}
+	tasks := m.Tasks[m.FocusedColumn]
+	if len(tasks) == 0 {
+		m.ColumnOffsets[m.FocusedColumn] = 0
+		m.FocusedTask = 0
+		return
+	}
+	pageSize := m.columnPageSize()
+	maxOffset := max(len(tasks)-pageSize, 0)
+	offset := m.ColumnOffsets[m.FocusedColumn] + delta
+	if offset < 0 {
+		offset = 0
+	}
+	if offset > maxOffset {
+		offset = maxOffset
+	}
+	m.ColumnOffsets[m.FocusedColumn] = offset
+	m.FocusedTask = min(offset, len(tasks)-1)
+}
+
+func (m Model) columnPageSize() int {
+	h := m.Height
+	if h == 0 {
+		h = defaultTermH
+	}
+	return visibleColumnTaskLimit(CalculateLayout(m.Width, h).ContentHeight)
+}
+
+func (m Model) detailPageSize() int {
+	return max(detailMaxHeight(m.Height)-3, 1)
+}
+
+func (m Model) epicPanelPageSize() int {
+	h := m.Height
+	if h == 0 {
+		h = defaultTermH
+	}
+	return max(h/2, 1)
+}
+
+func (m Model) epicPanelAvailable() bool {
+	return len(m.Epics) > 0 && CalculateLayout(m.Width, m.Height).EpicPanelVisible
+}
+
 func prevColumn(col data.ColumnType) data.ColumnType {
 	for i, c := range columnOrder {
 		if c == col {

package/internal/board/update_test.go

@@ -1,6 +1,9 @@
 package board
 
 import (
+	"os"
+	"path/filepath"
+	"strings"
 	"testing"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -90,6 +93,54 @@ func TestUpdate_downMovesTaskFocus(t *testing.T) {
 	}
 }
 
+func TestUpdate_downAutoScrollsFocusedTaskIntoViewport(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnPlanned},
+		{ID: "T3", Column: data.ColumnPlanned},
+		{ID: "T4", Column: data.ColumnPlanned},
+		{ID: "T5", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	m.Width = 100
+	m.Height = 24
+	m.FocusedTask = 3
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyDown})
+	updated := requireModel(t, got)
+
+	if updated.FocusedTask != 4 {
+		t.Errorf("FocusedTask = %d, want 4", updated.FocusedTask)
+	}
+	if updated.ColumnOffsets[data.ColumnPlanned] != 1 {
+		t.Errorf("ColumnOffsets[planned] = %d, want 1", updated.ColumnOffsets[data.ColumnPlanned])
+	}
+}
+
+func TestUpdate_pageDownScrollsFocusedColumnByPage(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned},
+		{ID: "T2", Column: data.ColumnPlanned},
+		{ID: "T3", Column: data.ColumnPlanned},
+		{ID: "T4", Column: data.ColumnPlanned},
+		{ID: "T5", Column: data.ColumnPlanned},
+		{ID: "T6", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1", "E03")
+	m.Width = 100
+	m.Height = 24
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyPgDown})
+	updated := requireModel(t, got)
+
+	if updated.ColumnOffsets[data.ColumnPlanned] != 2 {
+		t.Errorf("ColumnOffsets[planned] = %d, want 2", updated.ColumnOffsets[data.ColumnPlanned])
+	}
+	if updated.FocusedTask != 2 {
+		t.Errorf("FocusedTask = %d, want 2", updated.FocusedTask)
+	}
+}
+
 func TestUpdate_upMovesTaskFocus(t *testing.T) {
 	tasks := []data.Task{
 		{ID: "T1", Column: data.ColumnPlanned},
@@ -126,3 +177,118 @@ func TestUpdate_unknownMsgNoOp(t *testing.T) {
 		t.Errorf("Width changed unexpectedly: %d", updated.Width)
 	}
 }
+
+func TestUpdate_mSetsRouterToFocusedTask(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{
+		{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned},
+		{ID: "E05-tasking-permissions/T005-update-help-overlay", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if !strings.Contains(updated.StatusMessage, "Router set to v1.1 E05-tasking-permissions/T004") {
+		t.Fatalf("StatusMessage = %q", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.State != "task-building" {
+		t.Errorf("router state = %q, want task-building", state.State)
+	}
+	if state.Release != "v1.1" {
+		t.Errorf("router release = %q, want v1.1", state.Release)
+	}
+	if state.Epic != "E05-tasking-permissions" {
+		t.Errorf("router epic = %q, want E05-tasking-permissions", state.Epic)
+	}
+	if state.Task != "E05-tasking-permissions/T004-implement-m-hotkey" {
+		t.Errorf("router task = %q, want focused task", state.Task)
+	}
+}
+
+func TestUpdate_mSetsAuditPendingForLastUncompletedTask(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{
+		{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned},
+		{ID: "E05-tasking-permissions/T003-update-design-md", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnDone},
+	}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if updated.StatusMessage != "Audit pending for E05-tasking-permissions" {
+		t.Fatalf("StatusMessage = %q", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.State != "audit-pending" {
+		t.Errorf("router state = %q, want audit-pending", state.State)
+	}
+	if state.Task != "" {
+		t.Errorf("router task = %q, want empty", state.Task)
+	}
+}
+
+func TestUpdate_mDoesNothingWhenOverlayOpen(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnPlanned}}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+	m.Overlay = OverlayHelp
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if updated.StatusMessage != "" {
+		t.Fatalf("StatusMessage = %q, want empty", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.Task != "T001" {
+		t.Errorf("router task = %q, want unchanged T001", state.Task)
+	}
+}
+
+func TestUpdate_mDoesNotSetDoneTask(t *testing.T) {
+	root := writeRouterFixture(t)
+	tasks := []data.Task{{ID: "E05-tasking-permissions/T004-implement-m-hotkey", Release: "v1.1", Epic: "E05-tasking-permissions", Column: data.ColumnDone}}
+	m := NewModel(tasks, "v1.1", "E05-tasking-permissions")
+	m.Root = root
+	m.FocusedColumn = data.ColumnDone
+
+	got, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("m")})
+	updated := requireModel(t, got)
+
+	if updated.StatusMessage != "Router not updated: focused task is done" {
+		t.Fatalf("StatusMessage = %q", updated.StatusMessage)
+	}
+	state := readRouterFixture(t, root)
+	if state.Task != "T001" {
+		t.Errorf("router task = %q, want unchanged T001", state.Task)
+	}
+}
+
+func writeRouterFixture(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	content := "# Agent State Machine\n\n## Current state\n\n```yaml\nstate: task-building\nrelease: v1.1\nepic: E05\ntask: T001\nnext_action: Build T001.\n```\n"
+	if err := os.WriteFile(filepath.Join(root, "router.md"), []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func readRouterFixture(t *testing.T, root string) *data.RouterState {
+	t.Helper()
+	content, err := os.ReadFile(filepath.Join(root, "router.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	state, err := data.NewRouterReader().ReadState(string(content))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return state
+}