savepoint 1.0.2 → 1.0.4

package/internal/board/board.go

@@ -5,53 +5,68 @@ import (
 	"os"
 	"path/filepath"
 
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/muesli/termenv"
+	xterm "github.com/charmbracelet/x/term"
 	"github.com/opencode/savepoint/internal/data"
 )
 
 func Run() error {
-	lipgloss.SetColorProfile(termenv.ANSI256)
+	return RunWithFilters("", "")
+}
 
-	model, err := newProjectModel(".")
-	if err != nil {
-		return err
+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})
+
+	debugf("board init: finding savepoint root from %q", start)
+	root, err := deps.Discoverer.FindSavepointRoot(start)
 	if err != nil {
 		return Model{}, err
 	}
+	debugf("board init: root = %q", root)
 
-	routerState, err := readRouterState(root)
+	routerState, err := readRouterState(root, deps.RouterReader)
 	if err != nil {
 		return Model{}, err
 	}
 
-	tasks, releaseIDs, releaseEpics, epicStatuses, err := loadBoardData(root)
+	tasks, releaseIDs, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
 	if err != nil {
 		return Model{}, err
 	}
+	debugf("board init: loaded %d tasks across %d releases", len(tasks), len(releaseIDs))
 
-	release := firstKnown(routerState.Release, releaseIDs)
-	epic := firstKnown(routerState.Epic, releaseEpics[release])
+	preferredRelease := routerState.Release
+	if releaseFilter != "" {
+		preferredRelease = releaseFilter
+	}
+	preferredEpic := routerState.Epic
+	if epicFilter != "" {
+		preferredEpic = epicFilter
+	}
+
+	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
@@ -66,13 +81,13 @@ func newProjectModel(start string) (Model, error) {
 		return Model{}, err
 	}
 	model.Watcher = watcher
+	debugf("board init: file watcher started at %q", root)
 
 	return model, nil
 }
 
-func loadBoardData(root string) ([]data.Task, []string, map[string][]string, map[string]string, 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, nil, nil, nil, err
 	}
@@ -84,13 +99,13 @@ func loadBoardData(root string) ([]data.Task, []string, map[string][]string, map
 
 	for _, release := range releases {
 		releaseIDs = append(releaseIDs, release.ID)
-		epics, err := d.ListEpics(root, release.ID)
+		epics, err := discoverer.ListEpics(root, release.ID)
 		if err != nil {
 			return nil, nil, nil, nil, err
 		}
 		for _, epic := range epics {
 			releaseEpics[release.ID] = append(releaseEpics[release.ID], epic.ID)
-			epicTasks, err := loadEpicTasks(d, root, release.ID, epic.ID)
+			epicTasks, err := loadEpicTasks(discoverer, parser, root, release.ID, epic.ID)
 			if err != nil {
 				return nil, nil, nil, nil, err
 			}
@@ -98,7 +113,6 @@ func loadBoardData(root string) ([]data.Task, []string, map[string][]string, map
 
 			detailPath := filepath.Join(epic.Path, shortID(epic.ID)+"-Detail.md")
 			if raw, err := os.ReadFile(detailPath); err == nil {
-				parser := data.NewParser()
 				if fm, err := parser.ParseFrontmatter(string(raw)); err == nil {
 					if status, ok := fm["status"].(string); ok {
 						epicStatuses[epic.ID] = status
@@ -111,27 +125,21 @@ func loadBoardData(root string) ([]data.Task, []string, map[string][]string, map
 	return tasks, releaseIDs, releaseEpics, epicStatuses, nil
 }
 
-func loadAllTasks(root string) ([]data.Task, error) {
-	tasks, _, _, _, err := loadBoardData(root)
-	return tasks, err
-}
-
-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)

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)
 	}
@@ -75,21 +64,10 @@ next_action: "test"
 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)
 	}
@@ -112,22 +90,11 @@ next_action: "test"
 func TestNewProjectModelResolvesShortRouterEpicToFullEpicID(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: E03
-task: T001
-next_action: "Build v1.1 E03/T001"
-`+"```"+`
-`)
+	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)
+	model, err := newProjectModel(projectRoot, "", "")
 	if err != nil {
 		t.Fatalf("newProjectModel() error = %v", err)
 	}
@@ -173,51 +140,29 @@ func TestUpdateReloadMsgRefreshesReleaseEpicIndex(t *testing.T) {
 	}
 }
 
-func writeTask(t *testing.T, root, release, epic, task string, column data.ColumnType) {
+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 := ""
-	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 writeTaskWithoutRelease(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 := ""
+	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"
 )
@@ -24,18 +25,20 @@ func RenderCard(t data.Task, width int, focused bool, routerState *data.RouterSt
 		inner = 2
 	}
 
-	var glyph string
-	if t.Status != "" {
-		glyph = statusGlyph(t.Status)
-	} else if t.Column == data.ColumnDone {
-		glyph = styles.GlyphBuild.Render(glyphBuild)
-	} else if isRouterPriority(t, routerState) {
-		glyph = styles.TagDone.Render(glyphBuild)
-	} else {
-		glyph = phaseGlyphStyled(t.Stage)
-	}
-	// glyph is 1 rune + 1 space prefix; leave room for "▣ "
-	idLine := fmt.Sprintf("%s %s", glyph, truncate(shortID(t.ID), inner-2))
+	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
+	}
 	titleLine := styles.CardMeta.Render(strings.Join(WrapText(t.Title, inner), "\n"))
 
 	content := idLine + "\n" + titleLine
@@ -46,6 +49,33 @@ func RenderCard(t data.Task, width int, focused bool, routerState *data.RouterSt
 	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:
@@ -96,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]) + "…"
-}
+

package/internal/board/card_test.go

@@ -194,13 +194,12 @@ func TestRenderCard_doneTaskUsesOrangeBuildGlyph(t *testing.T) {
 func TestRenderCard_explicitStatusUsesUnifiedGlyph(t *testing.T) {
 	tests := []struct {
 		name   string
-		status data.TaskStatus
+		status string
 		glyph  string
 	}{
-		{"planned", data.StatusPlanned, "○"},
-		{"in progress", data.StatusInProgress, "▶"},
-		{"done", data.StatusDone, "◉"},
-		{"audited", data.StatusAudited, "✓"},
+		{"planned", string(data.ColumnPlanned), "○"},
+		{"done", string(data.ColumnDone), "◉"},
+		{"audited", "audited", "✓"},
 	}
 
 	for _, tt := range tests {
@@ -216,3 +215,73 @@ func TestRenderCard_explicitStatusUsesUnifiedGlyph(t *testing.T) {
 		})
 	}
 }
+
+func TestRenderCard_inProgressShowsPhaseText(t *testing.T) {
+	tests := []struct {
+		name  string
+		stage data.ProgressStage
+		label string
+		glyph string
+	}{
+		{"build", data.StageBuild, "BUILD", glyphBuild},
+		{"test", data.StageTest, "TEST", glyphTest},
+		{"audit", data.StageAudit, "AUDIT", glyphAudit},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{ID: "T1", Column: data.ColumnInProgress, Status: string(data.ColumnInProgress), Stage: tt.stage}
+			got := RenderCard(task, 30, false, nil)
+			if !strings.Contains(got, tt.label) {
+				t.Errorf("RenderCard missing phase label %q", tt.label)
+			}
+			if !strings.Contains(got, tt.glyph) {
+				t.Errorf("RenderCard missing phase glyph %q", tt.glyph)
+			}
+			if strings.Contains(got, "▶") {
+				t.Error("RenderCard should not use generic in_progress glyph when phase is available")
+			}
+		})
+	}
+}
+
+func TestRenderCard_doneShowsDoneText(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnDone, Status: string(data.ColumnDone)}
+	got := RenderCard(task, 30, false, nil)
+	if !strings.Contains(got, "DONE") {
+		t.Error("RenderCard missing DONE phase label")
+	}
+}
+
+func BenchmarkRenderCard_narrow(b *testing.B) {
+	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout", Stage: data.StageBuild}
+	b.ReportAllocs()
+	for b.Loop() {
+		RenderCard(task, 24, false, nil)
+	}
+}
+
+func BenchmarkRenderCard_standard(b *testing.B) {
+	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout for the board view", Stage: data.StageTest}
+	b.ReportAllocs()
+	for b.Loop() {
+		RenderCard(task, 40, false, nil)
+	}
+}
+
+func BenchmarkRenderCard_wide(b *testing.B) {
+	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout for the board view with extra details", Stage: data.StageAudit}
+	b.ReportAllocs()
+	for b.Loop() {
+		RenderCard(task, 60, false, nil)
+	}
+}
+
+func BenchmarkRenderCard_focused(b *testing.B) {
+	task := data.Task{ID: "E06-atari-noir-layout/T004-component-refinement", Title: "Refine card layout", Stage: data.StageBuild}
+	router := &data.RouterState{Release: "v1", Epic: "E06", Task: "T004"}
+	b.ReportAllocs()
+	for b.Loop() {
+		RenderCard(task, 40, true, router)
+	}
+}

package/internal/board/column.go

@@ -28,17 +28,84 @@ func RenderColumn(tasks []data.Task, col data.ColumnType, width, maxHeight, offs
 	if len(tasks) == 0 {
 		lines = append(lines, styles.TaskItem.Render("(empty)"))
 	} else {
-		limit := visibleColumnTaskLimit(maxHeight)
-		end := min(offset+limit, len(tasks))
+		contentBudget := maxHeight - 2
+		if contentBudget < 1 {
+			contentBudget = 1
+		}
+
+		type cardEntry struct {
+			card  string
+			lines int
+		}
+		cardEntries := make([]cardEntry, 0, len(tasks)-offset)
+		for i := offset; i < len(tasks); i++ {
+			c := RenderCard(tasks[i], inner, focused && i == focusedTask, routerState)
+			cardEntries = append(cardEntries, cardEntry{card: c, lines: strings.Count(c, "\n") + 1})
+		}
+
+		// Standard window: fit as many cards as possible from the start of cardEntries.
+		reserveAbove := 0
 		if offset > 0 {
-			lines = append(lines, renderScrollIndicator("↑", offset, "above"))
+			reserveAbove = 1
+		}
+		usedLines := reserveAbove
+		endIdx := 0
+		for endIdx < len(cardEntries) {
+			hasMore := (offset + endIdx + 1) < len(tasks)
+			bottomReserve := 0
+			if hasMore {
+				bottomReserve = 1
+			}
+			if usedLines+cardEntries[endIdx].lines+bottomReserve > contentBudget {
+				break
+			}
+			usedLines += cardEntries[endIdx].lines
+			endIdx++
 		}
-		for i, t := range tasks[offset:end] {
-			taskIndex := offset + i
-			lines = append(lines, RenderCard(t, inner, focused && taskIndex == focusedTask, routerState))
+		if endIdx == 0 && len(cardEntries) > 0 {
+			endIdx = 1
 		}
-		if end < len(tasks) {
-			lines = append(lines, renderScrollIndicator("↓", len(tasks)-end, "more"))
+
+		// Determine what portion of cardEntries to render.
+		renderStart := 0
+		renderEnd := endIdx
+
+		focusedRelIdx := focusedTask - offset
+		if focused && focusedRelIdx >= 0 && focusedRelIdx < len(cardEntries) && focusedRelIdx >= endIdx {
+			// Focused task is beyond the standard window.
+			// Anchor viewport at focused task: fill backward to use remaining budget.
+			bottomCost := 0
+			if focusedTask+1 < len(tasks) {
+				bottomCost = 1
+			}
+			cardsLines := cardEntries[focusedRelIdx].lines
+			newStart := focusedRelIdx
+			for newStart > 0 {
+				prev := cardEntries[newStart-1]
+				topCost := 1
+				if offset+newStart-1 == 0 {
+					topCost = 0
+				}
+				if cardsLines+prev.lines+topCost+bottomCost > contentBudget {
+					break
+				}
+				cardsLines += prev.lines
+				newStart--
+			}
+			renderStart = newStart
+			renderEnd = focusedRelIdx + 1
+		}
+
+		effectiveOffset := offset + renderStart
+		if effectiveOffset > 0 {
+			lines = append(lines, renderScrollIndicator("↑", effectiveOffset, "above"))
+		}
+		for i := renderStart; i < renderEnd; i++ {
+			lines = append(lines, cardEntries[i].card)
+		}
+		if offset+renderEnd < len(tasks) {
+			remaining := len(tasks) - (offset + renderEnd)
+			lines = append(lines, renderScrollIndicator("↓", remaining, "more"))
 		}
 	}
 
@@ -87,10 +154,3 @@ func columnTitle(col data.ColumnType) string {
 		return strings.ToUpper(string(col))
 	}
 }
-
-func taskLabel(t data.Task) string {
-	if t.Title == "" {
-		return t.ID
-	}
-	return fmt.Sprintf("%s  %s", t.ID, t.Title)
-}