savepoint 1.0.1 → 1.0.3

package/internal/board/board.go

@@ -5,122 +5,137 @@ import (
 	"os"
 	"path/filepath"
 
-	tea "github.com/charmbracelet/bubbletea"
+	xterm "github.com/charmbracelet/x/term"
 	"github.com/opencode/savepoint/internal/data"
 )
 
 func Run() error {
-	model, err := newProjectModel(".")
-	if err != nil {
-		return err
+	return RunWithFilters("", "")
+}
+
+func RunWithFilters(release, epic string) error {
+	if !xterm.IsTerminal(os.Stdout.Fd()) {
+		return runPlainOutput(release, epic)
 	}
+	return RunTUI(release, epic)
+}
 
-	p := tea.NewProgram(model, tea.WithAltScreen())
-	if _, err := p.Run(); err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+func runPlainOutput(release, epic string) error {
+	model, err := newProjectModel(".", release, epic)
+	if err != nil {
 		return err
 	}
+	fmt.Print(RenderPlainTable(model))
 	return nil
 }
 
-func newProgramModel() Model {
-	return NewModel(nil, "v1", "E03-board-tui-core")
+func newProjectModel(start, releaseFilter, epicFilter string) (Model, error) {
+	return newProjectModelWithDependencies(start, releaseFilter, epicFilter, defaultModelDependencies())
 }
 
-func newProjectModel(start string) (Model, error) {
-	d := data.NewDiscover()
-	root, err := d.FindSavepointRoot(start)
+func newProjectModelWithDependencies(start, releaseFilter, epicFilter string, deps ModelDependencies) (Model, error) {
+	deps = modelDependencies([]ModelDependencies{deps})
+
+	root, err := deps.Discoverer.FindSavepointRoot(start)
 	if err != nil {
 		return Model{}, err
 	}
 
-	routerState, err := readRouterState(root)
+	routerState, err := readRouterState(root, deps.RouterReader)
 	if err != nil {
 		return Model{}, err
 	}
 
-	releases, err := d.ListReleases(root)
+	tasks, releaseIDs, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
 	if err != nil {
 		return Model{}, err
 	}
 
-	releaseIDs := make([]string, 0, len(releases))
-	releaseEpics := make(map[string][]string, len(releases))
-
-	for _, release := range releases {
-		releaseIDs = append(releaseIDs, release.ID)
-		epics, err := d.ListEpics(root, release.ID)
-		if err != nil {
-			return Model{}, err
-		}
-		for _, epic := range epics {
-			releaseEpics[release.ID] = append(releaseEpics[release.ID], epic.ID)
-		}
+	preferredRelease := routerState.Release
+	if releaseFilter != "" {
+		preferredRelease = releaseFilter
 	}
-
-	tasks, err := loadAllTasks(root)
-	if err != nil {
-		return Model{}, err
+	preferredEpic := routerState.Epic
+	if epicFilter != "" {
+		preferredEpic = epicFilter
 	}
 
-	release := firstKnown(routerState.Release, releaseIDs)
-	epic := firstKnown(routerState.Epic, releaseEpics[release])
+	release := firstKnown(preferredRelease, releaseIDs)
+	epic := firstKnown(preferredEpic, releaseEpics[release])
 
-	model := NewModel(tasks, release, epic)
+	model := NewModel(tasks, release, epic, deps)
 	model.Root = root
 	model.RouterTask = routerState.Task
+	model.RouterState = routerState
 	model.Releases = releaseIDs
 	model.ReleaseEpics = releaseEpics
+	model.EpicStatus = epicStatuses
 	model.refreshEpicsForRelease()
 	model.refreshTasks()
 
 	watcher, err := newWatcher(root)
-	if err == nil {
-		model.Watcher = watcher
+	if err != nil {
+		return Model{}, err
 	}
+	model.Watcher = watcher
 
 	return model, nil
 }
 
-func loadAllTasks(root string) ([]data.Task, error) {
-	d := data.NewDiscover()
-	releases, err := d.ListReleases(root)
+func loadBoardData(root string, discoverer taskDiscoverer, parser taskParser) ([]data.Task, []string, map[string][]string, map[string]string, error) {
+	releases, err := discoverer.ListReleases(root)
 	if err != nil {
-		return nil, err
+		return nil, nil, nil, nil, err
 	}
+
+	releaseIDs := make([]string, 0, len(releases))
+	releaseEpics := make(map[string][]string, len(releases))
 	var tasks []data.Task
+	epicStatuses := make(map[string]string)
+
 	for _, release := range releases {
-		epics, err := d.ListEpics(root, release.ID)
+		releaseIDs = append(releaseIDs, release.ID)
+		epics, err := discoverer.ListEpics(root, release.ID)
 		if err != nil {
-			return nil, err
+			return nil, nil, nil, nil, err
 		}
 		for _, epic := range epics {
-			epicTasks, err := loadEpicTasks(d, root, release.ID, epic.ID)
+			releaseEpics[release.ID] = append(releaseEpics[release.ID], epic.ID)
+			epicTasks, err := loadEpicTasks(discoverer, parser, root, release.ID, epic.ID)
 			if err != nil {
-				return nil, err
+				return nil, nil, nil, nil, err
 			}
 			tasks = append(tasks, epicTasks...)
+
+			detailPath := filepath.Join(epic.Path, shortID(epic.ID)+"-Detail.md")
+			if raw, err := os.ReadFile(detailPath); err == nil {
+				if fm, err := parser.ParseFrontmatter(string(raw)); err == nil {
+					if status, ok := fm["status"].(string); ok {
+						epicStatuses[epic.ID] = status
+					}
+				}
+			}
 		}
 	}
-	return tasks, nil
+
+	return tasks, releaseIDs, releaseEpics, epicStatuses, nil
 }
 
-func readRouterState(root string) (*data.RouterState, error) {
+func readRouterState(root string, reader routerReader) (*data.RouterState, error) {
 	content, err := os.ReadFile(filepath.Join(root, "router.md"))
 	if err != nil {
 		return nil, err
 	}
 
-	return data.NewRouterReader().ReadState(string(content))
+	return reader.ReadState(string(content))
 }
 
-func loadEpicTasks(d *data.Discover, root, release, epic string) ([]data.Task, error) {
-	taskInfos, err := d.ListTasks(root, release, epic)
+func loadEpicTasks(discoverer taskDiscoverer, parser taskParser, root, release, epic string) ([]data.Task, error) {
+	taskInfos, err := discoverer.ListTasks(root, release, epic)
 	if err != nil {
 		return nil, err
 	}
 
-	parser := data.NewParser()
 	tasks := make([]data.Task, 0, len(taskInfos))
 	for _, taskInfo := range taskInfos {
 		content, err := os.ReadFile(taskInfo.Path)
@@ -150,6 +165,11 @@ func firstKnown(preferred string, values []string) string {
 			return preferred
 		}
 	}
+	for _, value := range values {
+		if shortID(value) == shortID(preferred) {
+			return value
+		}
+	}
 	if len(values) == 0 {
 		return ""
 	}

package/internal/board/board_test.go

@@ -1,16 +1,16 @@
 package board
 
 import (
-	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 
 	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/testutil"
 )
 
-func TestNewProgramModelUsesBoardCore(t *testing.T) {
-	m := newProgramModel()
+func TestNewModelUsesBoardCore(t *testing.T) {
+	m := NewModel(nil, "v1", "E03-board-tui-core")
 	m.Width = 100
 
 	got := m.View()
@@ -27,22 +27,11 @@ func TestNewProgramModelUsesBoardCore(t *testing.T) {
 func TestNewProjectModelLoadsReleasesEpicsAndTasks(t *testing.T) {
 	projectRoot := t.TempDir()
 	savepointRoot := filepath.Join(projectRoot, ".savepoint")
-	writeFile(t, filepath.Join(savepointRoot, "router.md"), `# Agent State Machine
-
-## Current state
-
-`+"```"+`yaml
-state: task-building
-release: v2
-epic: E03-live
-task: ""
-next_action: "test"
-`+"```"+`
-`)
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v2", "E03-live", "", "test")
 	writeTask(t, savepointRoot, "v1", "E01-old", "T001-old", data.ColumnPlanned)
 	writeTask(t, savepointRoot, "v2", "E03-live", "T001-live", data.ColumnInProgress)
 
-	model, err := newProjectModel(projectRoot)
+	model, err := newProjectModel(projectRoot, "", "")
 	if err != nil {
 		t.Fatalf("newProjectModel() error = %v", err)
 	}
@@ -66,26 +55,19 @@ next_action: "test"
 	if len(tasks) != 1 || tasks[0].ID != "E03-live/T001-live" {
 		t.Errorf("visible in-progress tasks = %v, want E03-live/T001-live", tasks)
 	}
+	if model.Watcher == nil {
+		t.Fatal("Watcher is nil, want auto-refresh watcher")
+	}
+	t.Cleanup(func() { model.Watcher.Close() })
 }
 
 func TestNewProjectModelUsesPathReleaseForTaskWithoutReleaseFrontmatter(t *testing.T) {
 	projectRoot := t.TempDir()
 	savepointRoot := filepath.Join(projectRoot, ".savepoint")
-	writeFile(t, filepath.Join(savepointRoot, "router.md"), `# Agent State Machine
-
-## Current state
-
-`+"```"+`yaml
-state: task-building
-release: v1.1
-epic: E01-tui-optimisation
-task: E01-tui-optimisation/T001-border-resize-fix
-next_action: "test"
-`+"```"+`
-`)
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v1.1", "E01-tui-optimisation", "E01-tui-optimisation/T001-border-resize-fix", "test")
 	writeTaskWithoutRelease(t, savepointRoot, "v1.1", "E01-tui-optimisation", "T001-border-resize-fix", data.ColumnInProgress)
 
-	model, err := newProjectModel(projectRoot)
+	model, err := newProjectModel(projectRoot, "", "")
 	if err != nil {
 		t.Fatalf("newProjectModel() error = %v", err)
 	}
@@ -100,53 +82,87 @@ next_action: "test"
 	if tasks[0].Release != "v1.1" {
 		t.Errorf("Task.Release = %q, want v1.1", tasks[0].Release)
 	}
+	if model.Watcher != nil {
+		t.Cleanup(func() { model.Watcher.Close() })
+	}
 }
 
-func writeTask(t *testing.T, root, release, epic, task string, column data.ColumnType) {
-	t.Helper()
-	path := filepath.Join(root, "releases", release, "epics", epic, "tasks", task+".md")
-	phase := ""
-	if column == data.ColumnInProgress {
-		phase = "phase: build\n"
-	}
-	content := `---
-id: ` + epic + `/` + task + `
-release: ` + release + `
-status: ` + string(column) + `
-` + phase + `objective: "Test task"
-depends_on: []
----
-
-# Test task
-`
-	writeFile(t, path, content)
+func TestNewProjectModelResolvesShortRouterEpicToFullEpicID(t *testing.T) {
+	projectRoot := t.TempDir()
+	savepointRoot := filepath.Join(projectRoot, ".savepoint")
+	testutil.WriteRouter(t, savepointRoot, "task-building", "v1.1", "E03", "T001", "Build v1.1 E03/T001")
+	writeTask(t, savepointRoot, "v1.1", "E01-tui-optimisation", "T007-column-focus-border-stability", data.ColumnInProgress)
+	writeTask(t, savepointRoot, "v1.1", "E03-ui-visual-refinement", "T001-border-resize-fix", data.ColumnInProgress)
+
+	model, err := newProjectModel(projectRoot, "", "")
+	if err != nil {
+		t.Fatalf("newProjectModel() error = %v", err)
+	}
+
+	if model.SelectedEpic != "E03-ui-visual-refinement" {
+		t.Errorf("SelectedEpic = %q, want E03-ui-visual-refinement", model.SelectedEpic)
+	}
+	tasks := model.Tasks[data.ColumnInProgress]
+	if len(tasks) != 1 || tasks[0].ID != "E03-ui-visual-refinement/T001-border-resize-fix" {
+		t.Errorf("visible in-progress tasks = %v, want E03-ui-visual-refinement/T001-border-resize-fix", tasks)
+	}
+	if model.Watcher != nil {
+		t.Cleanup(func() { model.Watcher.Close() })
+	}
 }
 
-func writeTaskWithoutRelease(t *testing.T, root, release, epic, task string, column data.ColumnType) {
+func TestUpdateReloadMsgRefreshesReleaseEpicIndex(t *testing.T) {
+	m := NewModel(nil, "v1", "E01-old")
+	m.Releases = []string{"v1"}
+	m.ReleaseEpics = map[string][]string{"v1": []string{"E01-old"}}
+
+	task := data.Task{
+		ID:      "E02-new/T001-new",
+		Release: "v1",
+		Epic:    "E02-new",
+		Column:  data.ColumnPlanned,
+	}
+	got, _ := m.Update(reloadMsg{
+		tasks:        []data.Task{task},
+		releases:     []string{"v1"},
+		releaseEpics: map[string][]string{"v1": []string{"E02-new"}},
+	})
+	updated := requireModel(t, got)
+
+	if updated.SelectedEpic != "E02-new" {
+		t.Errorf("SelectedEpic = %q, want E02-new", updated.SelectedEpic)
+	}
+	if len(updated.Epics) != 1 || updated.Epics[0] != "E02-new" {
+		t.Errorf("Epics = %v, want [E02-new]", updated.Epics)
+	}
+	if len(updated.Tasks[data.ColumnPlanned]) != 1 {
+		t.Errorf("planned tasks = %v, want reloaded task visible", updated.Tasks[data.ColumnPlanned])
+	}
+}
+
+func writeTask(t *testing.T, root, release, epic, taskSlug string, column data.ColumnType) {
 	t.Helper()
-	path := filepath.Join(root, "releases", release, "epics", epic, "tasks", task+".md")
-	phase := ""
+	tf := testutil.TaskFixture{
+		Slug:      taskSlug,
+		Release:   release,
+		Status:    string(column),
+		Objective: "Test task",
+	}
 	if column == data.ColumnInProgress {
-		phase = "phase: build\n"
-	}
-	content := `---
-id: ` + epic + `/` + task + `
-status: ` + string(column) + `
-` + phase + `objective: "Test task"
-depends_on: []
----
-
-# Test task
-`
-	writeFile(t, path, content)
+		tf.Phase = "build"
+	}
+	testutil.WriteTask(t, root, release, epic, tf)
 }
 
-func writeFile(t *testing.T, path, content string) {
+func writeTaskWithoutRelease(t *testing.T, root, release, epic, taskSlug string, column data.ColumnType) {
 	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
-		t.Fatal(err)
+	tf := testutil.TaskFixture{
+		Slug:      taskSlug,
+		Status:    string(column),
+		Objective: "Test task",
 	}
-	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
-		t.Fatal(err)
+	if column == data.ColumnInProgress {
+		tf.Phase = "build"
 	}
+	testutil.WriteTask(t, root, release, epic, tf)
 }

package/internal/board/card.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/charmbracelet/lipgloss"
 	"github.com/opencode/savepoint/internal/data"
 	"github.com/opencode/savepoint/internal/styles"
 )
@@ -17,21 +18,27 @@ const (
 )
 
 // RenderCard renders a task card with phase glyph, truncated ID+title, and focus styling.
-// When routerTaskID matches t.ID, a green priority glyph replaces the phase glyph.
-func RenderCard(t data.Task, width int, focused bool, routerTaskID string) string {
+// When router state matches t's release/epic/task, a green priority glyph replaces the phase glyph.
+func RenderCard(t data.Task, width int, focused bool, routerState *data.RouterState) string {
 	inner := width - cardOverhead
 	if inner < 2 {
 		inner = 2
 	}
 
-	var glyph string
-	if routerTaskID != "" && t.ID == routerTaskID {
-		glyph = styles.TagDone.Render(glyphBuild)
-	} else {
-		glyph = phaseGlyphStyled(t.Stage)
+	glyph := taskGlyph(t, routerState)
+	phase := taskPhaseText(t)
+	idWidth := inner - 2
+	if phase != "" {
+		idWidth -= lipgloss.Width(phase) + 1
+	}
+	if idWidth < 1 {
+		idWidth = 1
+	}
+
+	idLine := fmt.Sprintf("%s %s", glyph, truncate(shortID(t.ID), idWidth))
+	if phase != "" && lipgloss.Width(idLine)+1+lipgloss.Width(phase) <= inner {
+		idLine += " " + phase
 	}
-	// glyph is 1 rune + 1 space prefix; leave room for "▣ "
-	idLine := fmt.Sprintf("%s %s", glyph, truncate(shortID(t.ID), inner-2))
 	titleLine := styles.CardMeta.Render(strings.Join(WrapText(t.Title, inner), "\n"))
 
 	content := idLine + "\n" + titleLine
@@ -42,6 +49,33 @@ func RenderCard(t data.Task, width int, focused bool, routerTaskID string) strin
 	return styles.Card.Width(width).Render(content)
 }
 
+func taskGlyph(t data.Task, routerState *data.RouterState) string {
+	if t.Column == data.ColumnInProgress {
+		return phaseGlyphStyled(t.Stage)
+	}
+	if t.Column == data.ColumnDone {
+		return styles.GlyphBuild.Render(glyphBuild)
+	}
+	if isRouterPriority(t, routerState) {
+		return styles.TagDone.Render(glyphBuild)
+	}
+	if t.Status != "" {
+		return statusGlyph(t.Status)
+	}
+	return phaseGlyphStyled(t.Stage)
+}
+
+func taskPhaseText(t data.Task) string {
+	switch t.Column {
+	case data.ColumnInProgress:
+		return styles.CardMeta.Render(strings.ToUpper(phaseLabel(t.Stage)))
+	case data.ColumnDone:
+		return styles.CardMeta.Render("DONE")
+	default:
+		return ""
+	}
+}
+
 func phaseGlyphStyled(stage data.ProgressStage) string {
 	switch stage {
 	case data.StageTest:
@@ -53,6 +87,33 @@ func phaseGlyphStyled(stage data.ProgressStage) string {
 	}
 }
 
+func isRouterPriority(t data.Task, state *data.RouterState) bool {
+	if state == nil || state.Task == "" {
+		return false
+	}
+	if shortID(t.ID) != shortID(state.Task) {
+		return false
+	}
+	if state.Release != "" && t.Release != "" && t.Release != state.Release {
+		return false
+	}
+	routerEpic := state.Epic
+	if routerEpic == "" {
+		routerEpic = taskEpic(state.Task)
+	}
+	if routerEpic != "" && t.Epic != "" && shortID(t.Epic) != shortID(routerEpic) {
+		return false
+	}
+	return true
+}
+
+func taskEpic(taskID string) string {
+	if idx := strings.LastIndex(taskID, "/"); idx >= 0 {
+		return taskID[:idx]
+	}
+	return ""
+}
+
 // shortID strips the epic prefix and slug from a task ID.
 // "E06-atari-noir-layout/T004-component-refinement" → "T004"
 func shortID(id string) string {
@@ -65,14 +126,4 @@ func shortID(id string) string {
 	return id
 }
 
-// truncate clips s to max runes, appending "…" if clipped.
-func truncate(s string, max int) string {
-	runes := []rune(s)
-	if len(runes) <= max {
-		return s
-	}
-	if max <= 1 {
-		return "…"
-	}
-	return string(runes[:max-1]) + "…"
-}
+