savepoint 1.0.1 → 1.0.3

package/internal/board/model.go

@@ -1,9 +1,6 @@
 package board
 
 import (
-	"os"
-	"path/filepath"
-
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/fsnotify/fsnotify"
 	"github.com/opencode/savepoint/internal/data"
@@ -12,44 +9,102 @@ import (
 type OverlayType string
 
 const (
-	OverlayNone    OverlayType = ""
-	OverlayHelp    OverlayType = "help"
-	OverlayEpic    OverlayType = "epic"
-	OverlayRelease OverlayType = "release"
-	OverlayDetail  OverlayType = "detail"
+	OverlayNone       OverlayType = ""
+	OverlayHelp       OverlayType = "help"
+	OverlayEpic       OverlayType = "epic"
+	OverlayRelease    OverlayType = "release"
+	OverlayDetail     OverlayType = "detail"
+	OverlayEpicDetail OverlayType = "detail-epic"
 )
 
-// Model holds all board state. Tasks are grouped by column for O(1) column access.
-type Model struct {
-	AllTasks        []data.Task
-	Tasks           map[data.ColumnType][]data.Task
-	FocusedColumn   data.ColumnType
-	FocusedTask     int
-	SelectedEpic    string
+// ViewConfig holds terminal and overlay presentation state.
+type ViewConfig struct {
+	Theme         data.Theme
+	Overlay       OverlayType
+	Width         int
+	Height        int
+	StatusMessage string
+}
+
+// DataState holds task, router, and filesystem state used by the board.
+type DataState struct {
+	AllTasks    []data.Task
+	Tasks       map[data.ColumnType][]data.Task
+	Root        string
+	EpicStatus  map[string]string
+	RouterTask  string
+	RouterState *data.RouterState
+	Watcher     *fsnotify.Watcher
+}
+
+// NavigationState holds board-column and detail scrolling state.
+type NavigationState struct {
+	FocusedColumn data.ColumnType
+	FocusedTask   int
+	ColumnOffsets map[data.ColumnType]int
+	DetailOffset  int
+}
+
+// EpicState holds epic list, sidebar, and detail overlay state.
+type EpicState struct {
+	SelectedEpic      string
+	Epics             []string
+	EpicCursor        int
+	EpicPanelFocus    bool
+	EpicPanelCursor   int
+	EpicDetailOffset  int
+	EpicDetailEpic    string
+	EpicDetailContent string
+	EpicDetailTab     int    // 0=Detail, 1=Audit
+	EpicAuditContent  string // cached E##-Audit.md content
+}
+
+// ReleaseState holds release list and release picker state.
+type ReleaseState struct {
 	SelectedRelease string
-	Epics           []string
-	EpicCursor      int
 	Releases        []string
 	ReleaseEpics    map[string][]string
 	ReleaseCursor   int
-	Overlay         OverlayType
-	Width           int
-	Height          int
-	StatusMessage   string
-	Root            string
-	RouterTask      string
-	Watcher         *fsnotify.Watcher
+}
+
+// DataAccessState holds board data-access implementations.
+type DataAccessState struct {
+	Dependencies ModelDependencies
+}
+
+// Model holds all board state. Tasks are grouped by column for O(1) column access.
+type Model struct {
+	ViewConfig
+	DataState
+	NavigationState
+	EpicState
+	ReleaseState
+	DataAccessState
 }
 
 // NewModel groups tasks by column and returns an initialized Model.
-func NewModel(tasks []data.Task, release, epic string) Model {
+func NewModel(tasks []data.Task, release, epic string, deps ...ModelDependencies) Model {
 	m := Model{
-		AllTasks:        append([]data.Task(nil), tasks...),
-		FocusedColumn:   data.ColumnPlanned,
-		FocusedTask:     0,
-		SelectedEpic:    epic,
-		SelectedRelease: release,
-		Overlay:         OverlayNone,
+		ViewConfig: ViewConfig{
+			Overlay: OverlayNone,
+		},
+		DataState: DataState{
+			AllTasks: append([]data.Task(nil), tasks...),
+		},
+		NavigationState: NavigationState{
+			FocusedColumn: data.ColumnPlanned,
+			FocusedTask:   0,
+			ColumnOffsets: newColumnOffsets(),
+		},
+		EpicState: EpicState{
+			SelectedEpic: epic,
+		},
+		ReleaseState: ReleaseState{
+			SelectedRelease: release,
+		},
+		DataAccessState: DataAccessState{
+			Dependencies: modelDependencies(deps),
+		},
 	}
 	m.refreshTasks()
 	return m
@@ -91,6 +146,15 @@ func (m *Model) refreshTasks() {
 	}
 	m.Tasks = groupedTasks(visible)
 	m.clampFocusedTask()
+	m.clampColumnOffsets()
+}
+
+func newColumnOffsets() map[data.ColumnType]int {
+	return map[data.ColumnType]int{
+		data.ColumnPlanned:    0,
+		data.ColumnInProgress: 0,
+		data.ColumnDone:       0,
+	}
 }
 
 func (m *Model) refreshEpicsForRelease() {
@@ -103,18 +167,36 @@ func (m *Model) refreshEpicsForRelease() {
 	if len(m.Epics) == 0 {
 		m.SelectedEpic = ""
 		m.EpicCursor = 0
+		m.EpicPanelCursor = 0
+		m.EpicPanelFocus = false
 		return
 	}
 
 	for _, epic := range m.Epics {
 		if epic == m.SelectedEpic {
-			m.EpicCursor = epicIndex(m.Epics, m.SelectedEpic)
+			m.EpicCursor = sliceIndex(m.Epics, m.SelectedEpic)
+			m.clampEpicPanelCursor()
 			return
 		}
 	}
 
 	m.SelectedEpic = m.Epics[0]
 	m.EpicCursor = 0
+	m.clampEpicPanelCursor()
+}
+
+func (m *Model) clampEpicPanelCursor() {
+	if len(m.Epics) == 0 {
+		m.EpicPanelCursor = 0
+		m.EpicPanelFocus = false
+		return
+	}
+	if m.EpicPanelCursor >= len(m.Epics) {
+		m.EpicPanelCursor = len(m.Epics) - 1
+	}
+	if m.EpicPanelCursor < 0 {
+		m.EpicPanelCursor = 0
+	}
 }
 
 func (m *Model) clampFocusedTask() {
@@ -131,27 +213,23 @@ func (m *Model) clampFocusedTask() {
 	}
 }
 
-func (m *Model) writeRouterReleaseEpic() error {
-	routerPath := filepath.Join(m.Root, "router.md")
-
-	fi, err := os.Stat(routerPath)
-	if err != nil {
-		return err
-	}
-
-	content, err := os.ReadFile(routerPath)
-	if err != nil {
-		return err
+func (m *Model) clampColumnOffsets() {
+	if m.ColumnOffsets == nil {
+		m.ColumnOffsets = newColumnOffsets()
 	}
-
-	r := data.NewRouterReader()
-	state, err := r.ReadState(string(content))
-	if err != nil {
-		return err
+	for _, col := range columnOrder {
+		tasks := m.Tasks[col]
+		offset := m.ColumnOffsets[col]
+		if offset < 0 || len(tasks) == 0 {
+			m.ColumnOffsets[col] = 0
+			continue
+		}
+		if offset >= len(tasks) {
+			m.ColumnOffsets[col] = len(tasks) - 1
+		}
 	}
+}
 
-	state.Epic = m.SelectedEpic
-	state.Release = m.SelectedRelease
-
-	return data.WriteRouterState(m.Root, state, fi.ModTime())
+func taskDone(task data.Task) bool {
+	return task.Column == data.ColumnDone
 }

package/internal/board/plain.go

@@ -0,0 +1,88 @@
+package board
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+const plainNonTTYWarning = "[non-interactive mode — run in a TTY to launch the board UI]"
+const plainAuditSignal = "[◆ audit proposals pending]"
+
+// RenderPlainTable renders a plain text three-column task table for non-TTY output.
+func RenderPlainTable(model Model) string {
+	var b strings.Builder
+
+	fmt.Fprintln(&b, plainNonTTYWarning)
+	if hasAuditProposals(model.Root) {
+		fmt.Fprintln(&b, plainAuditSignal)
+	}
+	fmt.Fprintln(&b)
+
+	cols := []struct {
+		label string
+		col   data.ColumnType
+	}{
+		{"PLANNED", data.ColumnPlanned},
+		{"IN PROGRESS", data.ColumnInProgress},
+		{"DONE", data.ColumnDone},
+	}
+
+	for _, c := range cols {
+		tasks := model.Tasks[c.col]
+		fmt.Fprintln(&b, c.label)
+		if len(tasks) == 0 {
+			fmt.Fprintln(&b, "  (none)")
+		}
+		for _, t := range tasks {
+			title := t.Title
+			if title == "" {
+				title = "(no title)"
+			}
+			fmt.Fprintf(&b, "  %-52s  %s\n", t.ID, title)
+		}
+		fmt.Fprintln(&b)
+	}
+
+	return b.String()
+}
+
+// hasAuditProposals reports whether any audit file under root contains a Proposed Changes section.
+func hasAuditProposals(root string) bool {
+	releasesDir := filepath.Join(root, "releases")
+	releases, err := os.ReadDir(releasesDir)
+	if err != nil {
+		return false
+	}
+	for _, r := range releases {
+		if !r.IsDir() {
+			continue
+		}
+		epicsDir := filepath.Join(releasesDir, r.Name(), "epics")
+		epics, err := os.ReadDir(epicsDir)
+		if err != nil {
+			continue
+		}
+		for _, e := range epics {
+			if !e.IsDir() {
+				continue
+			}
+			short := e.Name()
+			if idx := strings.Index(short, "-"); idx >= 0 {
+				short = short[:idx]
+			}
+			auditPath := filepath.Join(epicsDir, e.Name(), short+"-Audit.md")
+			raw, err := os.ReadFile(auditPath)
+			if err != nil {
+				continue
+			}
+			if strings.Contains(string(raw), "## Proposed Changes") {
+				return true
+			}
+		}
+	}
+	return false
+}

package/internal/board/plain_test.go

@@ -0,0 +1,117 @@
+package board
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestRenderPlainTable_warningBanner(t *testing.T) {
+	m := NewModel(nil, "", "")
+	got := RenderPlainTable(m)
+	if !strings.Contains(got, plainNonTTYWarning) {
+		t.Errorf("RenderPlainTable missing warning banner, got:\n%s", got)
+	}
+}
+
+func TestRenderPlainTable_columnHeaders(t *testing.T) {
+	m := NewModel(nil, "", "")
+	got := RenderPlainTable(m)
+	for _, header := range []string{"PLANNED", "IN PROGRESS", "DONE"} {
+		if !strings.Contains(got, header) {
+			t.Errorf("RenderPlainTable missing column header %q", header)
+		}
+	}
+}
+
+func TestRenderPlainTable_taskIDsAndTitles(t *testing.T) {
+	tasks := []data.Task{
+		{ID: "E08/T001", Title: "CLI entrypoint", Column: data.ColumnDone},
+		{ID: "E08/T002", Title: "Non-TTY fallback", Column: data.ColumnInProgress},
+		{ID: "E08/T003", Title: "TUI app shell", Column: data.ColumnPlanned},
+	}
+	m := NewModel(tasks, "", "")
+	got := RenderPlainTable(m)
+
+	for _, want := range []string{"E08/T001", "CLI entrypoint", "E08/T002", "Non-TTY fallback", "E08/T003", "TUI app shell"} {
+		if !strings.Contains(got, want) {
+			t.Errorf("RenderPlainTable missing %q", want)
+		}
+	}
+}
+
+func TestRenderPlainTable_noneWhenColumnEmpty(t *testing.T) {
+	m := NewModel(nil, "", "")
+	got := RenderPlainTable(m)
+	if !strings.Contains(got, "(none)") {
+		t.Errorf("RenderPlainTable should show (none) for empty columns")
+	}
+}
+
+func TestRenderPlainTable_auditSignalWhenProposalsExist(t *testing.T) {
+	root := t.TempDir()
+	epicDir := filepath.Join(root, "releases", "v1", "epics", "E01-test")
+	if err := os.MkdirAll(epicDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	auditContent := "---\ntype: audit\n---\n## Main Findings\nOK\n\n## Proposed Changes\n\n### Target File\nfoo.go\n"
+	if err := os.WriteFile(filepath.Join(epicDir, "E01-Audit.md"), []byte(auditContent), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	m := NewModel(nil, "", "")
+	m.Root = root
+	got := RenderPlainTable(m)
+	if !strings.Contains(got, plainAuditSignal) {
+		t.Errorf("RenderPlainTable missing audit signal when proposals exist, got:\n%s", got)
+	}
+}
+
+func TestRenderPlainTable_noAuditSignalWhenNone(t *testing.T) {
+	root := t.TempDir()
+	m := NewModel(nil, "", "")
+	m.Root = root
+	got := RenderPlainTable(m)
+	if strings.Contains(got, plainAuditSignal) {
+		t.Errorf("RenderPlainTable should not show audit signal when no proposals exist")
+	}
+}
+
+func TestHasAuditProposals_detectsSection(t *testing.T) {
+	root := t.TempDir()
+	epicDir := filepath.Join(root, "releases", "v1", "epics", "E02-slug")
+	if err := os.MkdirAll(epicDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	content := "## Main Findings\nAll good.\n\n## Proposed Changes\n\n### Target File\nbar.go\n"
+	if err := os.WriteFile(filepath.Join(epicDir, "E02-Audit.md"), []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if !hasAuditProposals(root) {
+		t.Error("hasAuditProposals should return true when Proposed Changes section exists")
+	}
+}
+
+func TestHasAuditProposals_noProposals(t *testing.T) {
+	root := t.TempDir()
+	epicDir := filepath.Join(root, "releases", "v1", "epics", "E03-slug")
+	if err := os.MkdirAll(epicDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	content := "## Main Findings\nAll good.\n"
+	if err := os.WriteFile(filepath.Join(epicDir, "E03-Audit.md"), []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+	if hasAuditProposals(root) {
+		t.Error("hasAuditProposals should return false when no Proposed Changes section")
+	}
+}
+
+func TestHasAuditProposals_missingRoot(t *testing.T) {
+	if hasAuditProposals("/nonexistent/path/xyz") {
+		t.Error("hasAuditProposals should return false for missing root")
+	}
+}

package/internal/board/release.go

@@ -31,12 +31,4 @@ func RenderReleaseDropdown(releases []string, cursor int, width int) string {
 	return styles.EpicPanel.Width(width).Render(strings.Join(lines, "\n"))
 }
 
-// releaseIndex returns the index of selected in releases, or 0 if not found.
-func releaseIndex(releases []string, selected string) int {
-	for i, r := range releases {
-		if r == selected {
-			return i
-		}
-	}
-	return 0
-}
+

package/internal/board/release_test.go

@@ -40,17 +40,17 @@ func TestRenderReleaseDropdown_hintsPresent(t *testing.T) {
 	}
 }
 
-func TestReleaseIndex_found(t *testing.T) {
+func TestSliceIndexRelease_found(t *testing.T) {
 	releases := []string{"v1", "v2", "v3"}
-	if got := releaseIndex(releases, "v2"); got != 1 {
-		t.Errorf("releaseIndex = %d, want 1", got)
+	if got := sliceIndex(releases, "v2"); got != 1 {
+		t.Errorf("sliceIndex = %d, want 1", got)
 	}
 }
 
-func TestReleaseIndex_notFound(t *testing.T) {
+func TestSliceIndexRelease_notFound(t *testing.T) {
 	releases := []string{"v1", "v2"}
-	if got := releaseIndex(releases, "v9"); got != 0 {
-		t.Errorf("releaseIndex = %d, want 0", got)
+	if got := sliceIndex(releases, "v9"); got != 0 {
+		t.Errorf("sliceIndex = %d, want 0", got)
 	}
 }
 

package/internal/board/render_policy_test.go

@@ -0,0 +1,77 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestRenderPolicy_noBackgroundEscapes(t *testing.T) {
+	lipgloss.SetColorProfile(termenv.ANSI256)
+
+	task := data.Task{
+		ID:      "E05-tasking-permissions/T004-implement-m-hotkey",
+		Title:   "Implement router priority",
+		Release: "v1.1",
+		Epic:    "E05-tasking-permissions",
+		Column:  data.ColumnInProgress,
+		Stage:   data.StageBuild,
+	}
+	m := NewModel([]data.Task{
+		{
+			ID:      task.ID,
+			Title:   task.Title,
+			Release: task.Release,
+			Epic:    task.Epic,
+			Column:  task.Column,
+			Stage:   task.Stage,
+		},
+	}, "v1.1", "E05-tasking-permissions")
+	m.Width = 120
+	m.Height = 30
+	m.FocusedColumn = data.ColumnInProgress
+	m.RouterState = &data.RouterState{
+		State:      "task-building",
+		Release:    "v1.1",
+		Epic:       "E05-tasking-permissions",
+		Task:       "E05-tasking-permissions/T004-implement-m-hotkey",
+		NextAction: "Build E05-tasking-permissions/T004-implement-m-hotkey.",
+	}
+
+	cases := map[string]string{
+		"board":            m.View(),
+		"card":             RenderCard(task, 30, true, m.RouterState),
+		"detail":           RenderDetail(task, 60, m.RouterState, 0, 0),
+		"epic dropdown":    RenderEpicDropdown([]string{"E05-tasking-permissions"}, 0, 40),
+		"release dropdown": RenderReleaseDropdown([]string{"v1.1"}, 0, 40),
+		"help":             RenderHelp(60),
+	}
+	for name, got := range cases {
+		assertNoBackgroundEscapes(t, name, got)
+	}
+}
+
+func assertNoBackgroundEscapes(t *testing.T, name, got string) {
+	t.Helper()
+	for _, escape := range []string{"\x1b[48;", "\x1b[40m"} {
+		if strings.Contains(got, escape) {
+			t.Fatalf("%s emitted background escape prefix %q in %q", name, escape, got)
+		}
+	}
+}
+
+func TestRenderPolicy_usesSingleLineBorders(t *testing.T) {
+	m := NewModel([]data.Task{{ID: "T001", Title: "Task", Column: data.ColumnPlanned}}, "v1", "E01")
+	m.Width = 120
+	got := m.View()
+
+	if strings.Contains(got, "╭") || strings.Contains(got, "╮") || strings.Contains(got, "╰") || strings.Contains(got, "╯") {
+		t.Fatalf("View should use single-line borders, got rounded border glyphs in %q", got)
+	}
+	if !strings.Contains(got, "┌") || !strings.Contains(got, "┐") || !strings.Contains(got, "└") || !strings.Contains(got, "┘") {
+		t.Fatalf("View missing expected single-line border glyphs in %q", got)
+	}
+}

package/internal/board/status.go

@@ -0,0 +1,23 @@
+package board
+
+import (
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/styles"
+)
+
+const statusGlyphDefault = " "
+
+func statusGlyph(status string) string {
+	switch status {
+	case string(data.ColumnPlanned):
+		return styles.CardMeta.Render("○")
+	case string(data.ColumnInProgress):
+		return styles.GlyphBuild.Render("▶")
+	case string(data.ColumnDone):
+		return styles.TagDone.Render("◉")
+	case "audited":
+		return styles.TagDone.Render("✓")
+	default:
+		return statusGlyphDefault
+	}
+}

package/internal/board/theme.go

@@ -0,0 +1,24 @@
+package board
+
+import (
+	"os"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/muesli/termenv"
+)
+
+// applyColorProfile detects terminal color support and configures lipgloss.
+// Priority: NO_COLOR → COLORTERM env hint → termenv auto-detect.
+func applyColorProfile() {
+	lipgloss.SetColorProfile(detectProfile())
+}
+
+func detectProfile() termenv.Profile {
+	if os.Getenv("NO_COLOR") != "" {
+		return termenv.Ascii
+	}
+	if c := os.Getenv("COLORTERM"); c == "truecolor" || c == "24bit" {
+		return termenv.TrueColor
+	}
+	return termenv.ColorProfile()
+}

package/internal/board/theme_test.go

@@ -0,0 +1,31 @@
+package board
+
+import (
+	"testing"
+
+	"github.com/muesli/termenv"
+)
+
+func TestDetectProfileNOCOLOR(t *testing.T) {
+	t.Setenv("NO_COLOR", "1")
+	t.Setenv("COLORTERM", "")
+	if got := detectProfile(); got != termenv.Ascii {
+		t.Fatalf("want Ascii, got %v", got)
+	}
+}
+
+func TestDetectProfileTruecolor(t *testing.T) {
+	t.Setenv("NO_COLOR", "")
+	t.Setenv("COLORTERM", "truecolor")
+	if got := detectProfile(); got != termenv.TrueColor {
+		t.Fatalf("want TrueColor, got %v", got)
+	}
+}
+
+func TestDetectProfile24bit(t *testing.T) {
+	t.Setenv("NO_COLOR", "")
+	t.Setenv("COLORTERM", "24bit")
+	if got := detectProfile(); got != termenv.TrueColor {
+		t.Fatalf("want TrueColor, got %v", got)
+	}
+}