savepoint 1.0.2 → 1.0.4

package/internal/board/interfaces.go

@@ -0,0 +1,65 @@
+package board
+
+import "github.com/opencode/savepoint/internal/data"
+
+// taskDiscoverer provides project traversal for board loading.
+type taskDiscoverer interface {
+	FindSavepointRoot(start string) (string, error)
+	ListReleases(root string) ([]data.ReleaseInfo, error)
+	ListEpics(root, release string) ([]data.EpicInfo, error)
+	ListTasks(root, release, epic string) ([]data.TaskInfo, error)
+}
+
+// taskParser parses Savepoint frontmatter and task files for board loading.
+type taskParser interface {
+	ParseFrontmatter(content string) (map[string]any, error)
+	ParseTaskFile(path string, content string) (*data.Task, error)
+}
+
+// configReader reads board display configuration.
+type configReader interface {
+	Read(path string) (*data.Config, error)
+}
+
+// routerReader parses router state from router.md content.
+type routerReader interface {
+	ReadState(content string) (*data.RouterState, error)
+}
+
+// ModelDependencies contains board data-access dependencies.
+type ModelDependencies struct {
+	Discoverer   taskDiscoverer
+	Parser       taskParser
+	ConfigReader configReader
+	RouterReader routerReader
+}
+
+func defaultModelDependencies() ModelDependencies {
+	return ModelDependencies{
+		Discoverer:   data.NewDiscover(),
+		Parser:       data.NewParser(),
+		ConfigReader: data.NewConfigReader(),
+		RouterReader: data.NewRouterReader(),
+	}
+}
+
+func modelDependencies(overrides []ModelDependencies) ModelDependencies {
+	deps := defaultModelDependencies()
+	if len(overrides) == 0 {
+		return deps
+	}
+	override := overrides[0]
+	if override.Discoverer != nil {
+		deps.Discoverer = override.Discoverer
+	}
+	if override.Parser != nil {
+		deps.Parser = override.Parser
+	}
+	if override.ConfigReader != nil {
+		deps.ConfigReader = override.ConfigReader
+	}
+	if override.RouterReader != nil {
+		deps.RouterReader = override.RouterReader
+	}
+	return deps
+}

package/internal/board/interfaces_test.go

@@ -0,0 +1,114 @@
+package board
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+type stubBoardDiscoverer struct {
+	root      string
+	releases  []data.ReleaseInfo
+	epics     map[string][]data.EpicInfo
+	tasks     map[string][]data.TaskInfo
+	findCalls int
+}
+
+func (d *stubBoardDiscoverer) FindSavepointRoot(start string) (string, error) {
+	d.findCalls++
+	return d.root, nil
+}
+
+func (d *stubBoardDiscoverer) ListReleases(root string) ([]data.ReleaseInfo, error) {
+	return d.releases, nil
+}
+
+func (d *stubBoardDiscoverer) ListEpics(root, release string) ([]data.EpicInfo, error) {
+	return d.epics[release], nil
+}
+
+func (d *stubBoardDiscoverer) ListTasks(root, release, epic string) ([]data.TaskInfo, error) {
+	return d.tasks[release+"/"+epic], nil
+}
+
+type countingBoardParser struct {
+	parser           *data.Parser
+	frontmatterCalls int
+	taskFileCalls    int
+}
+
+func (p *countingBoardParser) ParseFrontmatter(content string) (map[string]any, error) {
+	p.frontmatterCalls++
+	return p.parser.ParseFrontmatter(content)
+}
+
+func (p *countingBoardParser) ParseTaskFile(path string, content string) (*data.Task, error) {
+	p.taskFileCalls++
+	return p.parser.ParseTaskFile(path, content)
+}
+
+type stubBoardRouterReader struct {
+	state *data.RouterState
+	calls int
+}
+
+func (r *stubBoardRouterReader) ReadState(content string) (*data.RouterState, error) {
+	r.calls++
+	return r.state, nil
+}
+
+func TestNewProjectModelUsesInjectedInterfaces(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	epicPath := filepath.Join(savepointRoot, "releases", "v9", "epics", "E01-mock")
+	taskPath := filepath.Join(epicPath, "tasks", "T001-mock.md")
+
+	testutil.WriteFile(t, filepath.Join(savepointRoot, "router.md"), "# router")
+	testutil.WriteFile(t, filepath.Join(epicPath, "E01-Detail.md"), "---\ntype: epic-design\nstatus: planned\n---\n\n# Epic\n")
+	testutil.WriteFile(t, taskPath, "---\nid: E01-mock/T001-mock\nstatus: planned\nobjective: Mock task\ndepends_on: []\n---\n\n# Task\n")
+
+	discoverer := &stubBoardDiscoverer{
+		root: savepointRoot,
+		releases: []data.ReleaseInfo{{
+			ID:   "v9",
+			Path: filepath.Join(savepointRoot, "releases", "v9"),
+		}},
+		epics: map[string][]data.EpicInfo{
+			"v9": {{ID: "E01-mock", Path: epicPath}},
+		},
+		tasks: map[string][]data.TaskInfo{
+			"v9/E01-mock": {{ID: "T001-mock", Path: taskPath}},
+		},
+	}
+	parser := &countingBoardParser{parser: data.NewParser()}
+	router := &stubBoardRouterReader{state: &data.RouterState{
+		State:   "task-building",
+		Release: "v9",
+		Epic:    "E01-mock",
+		Task:    "E01-mock/T001-mock",
+	}}
+
+	model, err := newProjectModelWithDependencies(projectRoot, "", "", ModelDependencies{
+		Discoverer:   discoverer,
+		Parser:       parser,
+		RouterReader: router,
+	})
+	if err != nil {
+		t.Fatalf("newProjectModelWithDependencies() error = %v", err)
+	}
+
+	if discoverer.findCalls != 1 {
+		t.Fatalf("FindSavepointRoot calls = %d, want 1", discoverer.findCalls)
+	}
+	if router.calls != 1 {
+		t.Fatalf("ReadState calls = %d, want 1", router.calls)
+	}
+	if parser.frontmatterCalls != 1 || parser.taskFileCalls != 1 {
+		t.Fatalf("parser calls = frontmatter:%d task:%d, want 1 each", parser.frontmatterCalls, parser.taskFileCalls)
+	}
+	if got := model.Tasks[data.ColumnPlanned][0].ID; got != "E01-mock/T001-mock" {
+		t.Fatalf("loaded task = %q, want injected task", got)
+	}
+}

package/internal/board/io.go

@@ -0,0 +1,93 @@
+package board
+
+import (
+	"os"
+	"path/filepath"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func writeRouterTaskCmd(root string, task data.Task, reader routerReader) tea.Cmd {
+	return func() tea.Msg {
+		routerPath := filepath.Join(root, "router.md")
+		fi, err := os.Stat(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		content, err := os.ReadFile(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state, err := reader.ReadState(string(content))
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state.Release = task.Release
+		state.Epic = task.Epic
+		state.State = "task-building"
+		state.Task = task.ID
+		state.NextAction = "Build " + task.ID + "."
+		if err := data.WriteRouterState(root, state, fi.ModTime()); err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		message := "Router set to " + task.Release + " " + task.Epic + "/" + shortID(task.ID)
+		return routerWriteMsg{message: message, state: state, taskID: task.ID}
+	}
+}
+
+func writeRouterReleaseEpicCmd(root, selectedEpic, selectedRelease string, reader routerReader) tea.Cmd {
+	return func() tea.Msg {
+		routerPath := filepath.Join(root, "router.md")
+		fi, err := os.Stat(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		content, err := os.ReadFile(routerPath)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state, err := reader.ReadState(string(content))
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		state.Epic = shortID(selectedEpic)
+		state.Release = selectedRelease
+		if err := data.WriteRouterState(root, state, fi.ModTime()); err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		return routerWriteMsg{state: state}
+	}
+}
+
+func writeTaskStatusCmd(orig, next data.Task, expectedMtime time.Time, prefix string) tea.Cmd {
+	return func() tea.Msg {
+		if err := data.WriteTaskStatus(next.Path, &next, expectedMtime); err != nil {
+			return errorMsg{message: taskWriteErrorMessage(err)}
+		}
+		fi, err := os.Stat(next.Path)
+		if err != nil {
+			return errorMsg{message: err.Error()}
+		}
+		next.Mtime = fi.ModTime()
+		return taskWriteMsg{prefix: prefix, next: next}
+	}
+}
+
+func readEpicDetailCmd(epicDir, shortIDStr string) tea.Cmd {
+	return func() tea.Msg {
+		content := readEpicDetailFile(epicDir, shortIDStr)
+		return epicDetailMsg{content: content}
+	}
+}
+
+func readEpicAuditCmd(epicDir, shortIDStr string) tea.Cmd {
+	return func() tea.Msg {
+		raw, err := os.ReadFile(filepath.Join(epicDir, shortIDStr+"-Audit.md"))
+		if err != nil {
+			return auditContentMsg{content: "(no audit available)"}
+		}
+		return auditContentMsg{content: string(raw)}
+	}
+}

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"
@@ -20,46 +17,94 @@ const (
 	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
-	ColumnOffsets     map[data.ColumnType]int
-	DetailOffset      int
+// 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
-	SelectedRelease   string
 	Epics             []string
 	EpicCursor        int
 	EpicPanelFocus    bool
 	EpicPanelCursor   int
 	EpicDetailOffset  int
+	EpicDetailEpic    string
 	EpicDetailContent string
-	Releases          []string
-	ReleaseEpics      map[string][]string
-	ReleaseCursor     int
-	Overlay           OverlayType
-	Width             int
-	Height            int
-	StatusMessage     string
-	Root              string
-	EpicStatus        map[string]string
-	RouterTask        string
-	RouterState       *data.RouterState
-	Watcher           *fsnotify.Watcher
+	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
+	Releases        []string
+	ReleaseEpics    map[string][]string
+	ReleaseCursor   int
+}
+
+// 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,
-		ColumnOffsets:   newColumnOffsets(),
-		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
@@ -129,7 +174,7 @@ func (m *Model) refreshEpicsForRelease() {
 
 	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
 		}
@@ -185,90 +230,6 @@ func (m *Model) clampColumnOffsets() {
 	}
 }
 
-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
-	}
-
-	r := data.NewRouterReader()
-	state, err := r.ReadState(string(content))
-	if err != nil {
-		return err
-	}
-
-	state.Epic = shortID(m.SelectedEpic)
-	state.Release = m.SelectedRelease
-
-	return data.WriteRouterState(m.Root, state, fi.ModTime())
-}
-
-func (m *Model) writeRouterTask(task data.Task) (string, 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
-	}
-
-	r := data.NewRouterReader()
-	state, err := r.ReadState(string(content))
-	if err != nil {
-		return "", err
-	}
-
-	state.Release = task.Release
-	state.Epic = task.Epic
-	if m.isLastUncompletedTask(task) {
-		state.State = "audit-pending"
-		state.Task = ""
-		state.NextAction = "Audit " + task.Epic + "."
-		if err := data.WriteRouterState(m.Root, state, fi.ModTime()); err != nil {
-			return "", err
-		}
-		m.RouterState = state
-		m.RouterTask = ""
-		return "Audit pending for " + task.Epic, nil
-	}
-
-	state.State = "task-building"
-	state.Task = task.ID
-	state.NextAction = "Build " + task.ID + "."
-	if err := data.WriteRouterState(m.Root, state, fi.ModTime()); err != nil {
-		return "", err
-	}
-	m.RouterState = state
-	m.RouterTask = task.ID
-	return "Router set to " + task.Release + " " + task.Epic + "/" + shortID(task.ID), nil
-}
-
-func (m Model) isLastUncompletedTask(task data.Task) bool {
-	for _, candidate := range m.AllTasks {
-		if candidate.ID == task.ID {
-			continue
-		}
-		if candidate.Release != task.Release || candidate.Epic != task.Epic {
-			continue
-		}
-		if !taskDone(candidate) {
-			return false
-		}
-	}
-	return true
-}
-
 func taskDone(task data.Task) bool {
-	return task.Column == data.ColumnDone || task.Status == string(data.StatusDone)
+	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
+}