savepoint 1.0.1 → 1.0.3

package/internal/board/transitions.go

@@ -1,88 +1,113 @@
-package board
-
-import (
-	"fmt"
-
-	"github.com/opencode/savepoint/internal/data"
-)
-
-// Advance moves a task forward through the phase lifecycle.
-func Advance(t *data.Task) {
-	switch t.Column {
-	case data.ColumnPlanned:
-		t.Column = data.ColumnInProgress
-		t.Stage = data.StageBuild
-	case data.ColumnInProgress:
-		switch t.Stage {
-		case data.StageBuild:
-			t.Stage = data.StageTest
-		case data.StageTest:
-			t.Stage = data.StageAudit
-		case data.StageAudit:
-			t.Column = data.ColumnDone
-			t.Stage = ""
-		}
-	}
-}
-
-// Retreat moves a task backward through the phase lifecycle.
-func Retreat(t *data.Task) {
-	switch t.Column {
-	case data.ColumnDone:
-		t.Column = data.ColumnInProgress
-		t.Stage = data.StageAudit
-	case data.ColumnInProgress:
-		switch t.Stage {
-		case data.StageAudit:
-			t.Stage = data.StageTest
-		case data.StageTest:
-			t.Stage = data.StageBuild
-		case data.StageBuild:
-			t.Column = data.ColumnPlanned
-			t.Stage = ""
-		}
-	}
-}
-
-// CanAdvance checks whether a task is allowed to advance to its next phase.
-// It validates phase adjacency and dependency completion.
-// Returns (true, "") if allowed, or (false, reason) if blocked.
-func CanAdvance(t *data.Task, allTasks []data.Task) (bool, string) {
-	switch t.Column {
-	case data.ColumnPlanned:
-		return true, ""
-	case data.ColumnInProgress:
-		switch t.Stage {
-		case data.StageBuild:
-			return true, ""
-		case data.StageTest:
-			return true, ""
-		case data.StageAudit:
-			for _, depID := range t.DependsOn {
-				dep := findTask(depID, allTasks)
-				if dep == nil {
-					return false, fmt.Sprintf("dependency %q not found", depID)
-				}
-				if dep.Column != data.ColumnDone {
-					return false, fmt.Sprintf("dependency %q is not done", depID)
-				}
-			}
-			return true, ""
-		default:
-			return false, fmt.Sprintf("unknown stage %q", t.Stage)
-		}
-	case data.ColumnDone:
-		return false, "task is already done"
-	default:
-		return false, fmt.Sprintf("unknown column %q", t.Column)
-	}
-}
-
-func findTask(id string, tasks []data.Task) *data.Task {
-	for i := range tasks {
-		if tasks[i].ID == id {
-			return &tasks[i]
-		}
-	}
-	return nil
-}
+package board
+
+import (
+	"fmt"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+// Advance moves a task forward through the phase lifecycle.
+func Advance(t *data.Task) {
+	stage := t.Stage
+	if stage == "" {
+		stage = data.StageBuild
+	}
+	switch t.Column {
+	case data.ColumnPlanned:
+		t.Column = data.ColumnInProgress
+		t.Stage = data.StageBuild
+	case data.ColumnInProgress:
+		switch stage {
+		case data.StageBuild:
+			t.Stage = data.StageTest
+		case data.StageTest:
+			t.Stage = data.StageAudit
+		case data.StageAudit:
+			t.Column = data.ColumnDone
+			t.Stage = ""
+		}
+	}
+	t.Status = string(t.Column)
+}
+
+// Retreat moves a task backward through the phase lifecycle.
+func Retreat(t *data.Task) {
+	stage := t.Stage
+	if stage == "" {
+		stage = data.StageBuild
+	}
+	switch t.Column {
+	case data.ColumnDone:
+		t.Column = data.ColumnInProgress
+		t.Stage = data.StageAudit
+	case data.ColumnInProgress:
+		switch stage {
+		case data.StageAudit:
+			t.Stage = data.StageTest
+		case data.StageTest:
+			t.Stage = data.StageBuild
+		case data.StageBuild:
+			t.Column = data.ColumnPlanned
+			t.Stage = ""
+		}
+	}
+	t.Status = string(t.Column)
+}
+
+func taskTransitionMessage(prefix string, task data.Task) string {
+	if task.Column == data.ColumnInProgress {
+		return fmt.Sprintf("%s %s to %s", prefix, shortID(task.ID), task.Stage)
+	}
+	return fmt.Sprintf("%s %s to %s", prefix, shortID(task.ID), task.Column)
+}
+
+// CanAdvance checks whether a task is allowed to advance to its next phase.
+// It validates phase adjacency and dependency completion.
+// Returns (true, "") if allowed, or (false, reason) if blocked.
+func CanAdvance(t *data.Task, allTasks []data.Task) (bool, string) {
+	switch t.Column {
+	case data.ColumnPlanned:
+		return dependenciesDone(t, allTasks)
+	case data.ColumnInProgress:
+		stage := t.Stage
+		if stage == "" {
+			stage = data.StageBuild
+		}
+		switch stage {
+		case data.StageBuild:
+			return true, ""
+		case data.StageTest:
+			return true, ""
+		case data.StageAudit:
+			return dependenciesDone(t, allTasks)
+		default:
+			return false, fmt.Sprintf("unknown stage %q", stage)
+		}
+	case data.ColumnDone:
+		return false, "task is already done"
+	default:
+		return false, fmt.Sprintf("unknown column %q", t.Column)
+	}
+}
+
+func dependenciesDone(t *data.Task, allTasks []data.Task) (bool, string) {
+	for _, depID := range t.DependsOn {
+		dep := findTask(depID, allTasks)
+		if dep == nil {
+			return false, fmt.Sprintf("dependency %q not found", depID)
+		}
+		if dep.Column != data.ColumnDone {
+			return false, fmt.Sprintf("dependency %q is not done", depID)
+		}
+	}
+	return true, ""
+}
+
+func findTask(id string, tasks []data.Task) *data.Task {
+	for i := range tasks {
+		if tasks[i].ID == id {
+			return &tasks[i]
+		}
+	}
+	return nil
+}

package/internal/board/transitions_test.go

@@ -1,141 +1,164 @@
-package board
-
-import (
-	"testing"
-
-	"github.com/opencode/savepoint/internal/data"
-)
-
-func TestAdvance(t *testing.T) {
-	tests := []struct {
-		name       string
-		initialCol data.ColumnType
-		initialSt  data.ProgressStage
-		expectCol  data.ColumnType
-		expectSt   data.ProgressStage
-	}{
-		{"planned to in_progress/build", data.ColumnPlanned, "", data.ColumnInProgress, data.StageBuild},
-		{"in_progress/build to test", data.ColumnInProgress, data.StageBuild, data.ColumnInProgress, data.StageTest},
-		{"in_progress/test to audit", data.ColumnInProgress, data.StageTest, data.ColumnInProgress, data.StageAudit},
-		{"in_progress/audit to done", data.ColumnInProgress, data.StageAudit, data.ColumnDone, ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			task := data.Task{Column: tt.initialCol, Stage: tt.initialSt}
-			Advance(&task)
-			if task.Column != tt.expectCol || task.Stage != tt.expectSt {
-				t.Errorf("Advance() = %v/%v, want %v/%v", task.Column, task.Stage, tt.expectCol, tt.expectSt)
-			}
-		})
-	}
-}
-
-func TestRetreat(t *testing.T) {
-	tests := []struct {
-		name       string
-		initialCol data.ColumnType
-		initialSt  data.ProgressStage
-		expectCol  data.ColumnType
-		expectSt   data.ProgressStage
-	}{
-		{"done to in_progress/audit", data.ColumnDone, "", data.ColumnInProgress, data.StageAudit},
-		{"in_progress/audit to test", data.ColumnInProgress, data.StageAudit, data.ColumnInProgress, data.StageTest},
-		{"in_progress/test to build", data.ColumnInProgress, data.StageTest, data.ColumnInProgress, data.StageBuild},
-		{"in_progress/build to planned", data.ColumnInProgress, data.StageBuild, data.ColumnPlanned, ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			task := data.Task{Column: tt.initialCol, Stage: tt.initialSt}
-			Retreat(&task)
-			if task.Column != tt.expectCol || task.Stage != tt.expectSt {
-				t.Errorf("Retreat() = %v/%v, want %v/%v", task.Column, task.Stage, tt.expectCol, tt.expectSt)
-			}
-		})
-	}
-}
-
-func TestCanAdvance_plannedAlwaysAllowed(t *testing.T) {
-	task := data.Task{ID: "T1", Column: data.ColumnPlanned}
-	ok, reason := CanAdvance(&task, nil)
-	if !ok {
-		t.Errorf("CanAdvance(planned) = false %q, want true", reason)
-	}
-}
-
-func TestCanAdvance_buildAlwaysAllowed(t *testing.T) {
-	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageBuild}
-	ok, reason := CanAdvance(&task, nil)
-	if !ok {
-		t.Errorf("CanAdvance(build) = false %q, want true", reason)
-	}
-}
-
-func TestCanAdvance_testAlwaysAllowed(t *testing.T) {
-	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageTest}
-	ok, reason := CanAdvance(&task, nil)
-	if !ok {
-		t.Errorf("CanAdvance(test) = false %q, want true", reason)
-	}
-}
-
-func TestCanAdvance_auditDoneBlockedByDependency(t *testing.T) {
-	allTasks := []data.Task{
-		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
-		{ID: "T2", Column: data.ColumnInProgress, Stage: data.StageBuild},
-	}
-	ok, reason := CanAdvance(&allTasks[0], allTasks)
-	if ok {
-		t.Fatal("CanAdvance(audit with undep) = true, want false")
-	}
-	if reason == "" {
-		t.Fatal("expected non-empty reason string")
-	}
-}
-
-func TestCanAdvance_auditDoneAllowedWhenDepsDone(t *testing.T) {
-	allTasks := []data.Task{
-		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
-		{ID: "T2", Column: data.ColumnDone},
-	}
-	ok, reason := CanAdvance(&allTasks[0], allTasks)
-	if !ok {
-		t.Errorf("CanAdvance(audit with dep done) = false %q, want true", reason)
-	}
-}
-
-func TestCanAdvance_doneBlocked(t *testing.T) {
-	task := data.Task{ID: "T1", Column: data.ColumnDone}
-	ok, reason := CanAdvance(&task, nil)
-	if ok {
-		t.Fatal("CanAdvance(done) = true, want false")
-	}
-	if reason == "" {
-		t.Fatal("expected non-empty reason string")
-	}
-}
-
-func TestCanAdvance_unknownStageBlocked(t *testing.T) {
-	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: "invalid"}
-	ok, reason := CanAdvance(&task, nil)
-	if ok {
-		t.Fatal("CanAdvance(unknown stage) = true, want false")
-	}
-	if reason == "" {
-		t.Fatal("expected non-empty reason string")
-	}
-}
-
-func TestCanAdvance_auditDepsNotFoundBlocked(t *testing.T) {
-	allTasks := []data.Task{
-		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
-	}
-	ok, reason := CanAdvance(&allTasks[0], allTasks)
-	if ok {
-		t.Fatal("CanAdvance(audit missing dep) = true, want false")
-	}
-	if reason == "" {
-		t.Fatal("expected non-empty reason string")
-	}
-}
+package board
+
+import (
+	"testing"
+
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestAdvance(t *testing.T) {
+	tests := []struct {
+		name       string
+		initialCol data.ColumnType
+		initialSt  data.ProgressStage
+		expectCol  data.ColumnType
+		expectSt   data.ProgressStage
+	}{
+		{"planned to in_progress/build", data.ColumnPlanned, "", data.ColumnInProgress, data.StageBuild},
+		{"in_progress/build to test", data.ColumnInProgress, data.StageBuild, data.ColumnInProgress, data.StageTest},
+		{"in_progress/test to audit", data.ColumnInProgress, data.StageTest, data.ColumnInProgress, data.StageAudit},
+		{"in_progress/audit to done", data.ColumnInProgress, data.StageAudit, data.ColumnDone, ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{Column: tt.initialCol, Stage: tt.initialSt}
+			Advance(&task)
+			if task.Column != tt.expectCol || task.Stage != tt.expectSt {
+				t.Errorf("Advance() = %v/%v, want %v/%v", task.Column, task.Stage, tt.expectCol, tt.expectSt)
+			}
+			if task.Status != string(tt.expectCol) {
+				t.Errorf("Advance() status = %q, want %q", task.Status, tt.expectCol)
+			}
+		})
+	}
+}
+
+func TestRetreat(t *testing.T) {
+	tests := []struct {
+		name       string
+		initialCol data.ColumnType
+		initialSt  data.ProgressStage
+		expectCol  data.ColumnType
+		expectSt   data.ProgressStage
+	}{
+		{"done to in_progress/audit", data.ColumnDone, "", data.ColumnInProgress, data.StageAudit},
+		{"in_progress/audit to test", data.ColumnInProgress, data.StageAudit, data.ColumnInProgress, data.StageTest},
+		{"in_progress/test to build", data.ColumnInProgress, data.StageTest, data.ColumnInProgress, data.StageBuild},
+		{"in_progress/build to planned", data.ColumnInProgress, data.StageBuild, data.ColumnPlanned, ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			task := data.Task{Status: string(tt.initialCol), Column: tt.initialCol, Stage: tt.initialSt}
+			Retreat(&task)
+			if task.Column != tt.expectCol || task.Stage != tt.expectSt {
+				t.Errorf("Retreat() = %v/%v, want %v/%v", task.Column, task.Stage, tt.expectCol, tt.expectSt)
+			}
+			if task.Status != string(tt.expectCol) {
+				t.Errorf("Retreat() status = %q, want %q", task.Status, tt.expectCol)
+			}
+		})
+	}
+}
+
+func TestCanAdvance_plannedAllowedWhenDependenciesDone(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned, DependsOn: []string{"T2"}},
+		{ID: "T2", Column: data.ColumnDone},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if !ok {
+		t.Errorf("CanAdvance(planned with done dep) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_plannedBlockedByDependency(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnPlanned, DependsOn: []string{"T2"}},
+		{ID: "T2", Column: data.ColumnInProgress},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if ok {
+		t.Fatal("CanAdvance(planned with unfinished dep) = true, want false")
+	}
+	if reason != "dependency \"T2\" is not done" {
+		t.Errorf("reason = %q, want dependency warning", reason)
+	}
+}
+
+func TestCanAdvance_buildAlwaysAllowed(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageBuild}
+	ok, reason := CanAdvance(&task, nil)
+	if !ok {
+		t.Errorf("CanAdvance(build) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_testAlwaysAllowed(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageTest}
+	ok, reason := CanAdvance(&task, nil)
+	if !ok {
+		t.Errorf("CanAdvance(test) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_auditDoneBlockedByDependency(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
+		{ID: "T2", Column: data.ColumnInProgress, Stage: data.StageBuild},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if ok {
+		t.Fatal("CanAdvance(audit with undep) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}
+
+func TestCanAdvance_auditDoneAllowedWhenDepsDone(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
+		{ID: "T2", Column: data.ColumnDone},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if !ok {
+		t.Errorf("CanAdvance(audit with dep done) = false %q, want true", reason)
+	}
+}
+
+func TestCanAdvance_doneBlocked(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnDone}
+	ok, reason := CanAdvance(&task, nil)
+	if ok {
+		t.Fatal("CanAdvance(done) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}
+
+func TestCanAdvance_unknownStageBlocked(t *testing.T) {
+	task := data.Task{ID: "T1", Column: data.ColumnInProgress, Stage: "invalid"}
+	ok, reason := CanAdvance(&task, nil)
+	if ok {
+		t.Fatal("CanAdvance(unknown stage) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}
+
+func TestCanAdvance_auditDepsNotFoundBlocked(t *testing.T) {
+	allTasks := []data.Task{
+		{ID: "T1", Column: data.ColumnInProgress, Stage: data.StageAudit, DependsOn: []string{"T2"}},
+	}
+	ok, reason := CanAdvance(&allTasks[0], allTasks)
+	if ok {
+		t.Fatal("CanAdvance(audit missing dep) = true, want false")
+	}
+	if reason == "" {
+		t.Fatal("expected non-empty reason string")
+	}
+}

package/internal/board/tui.go

@@ -0,0 +1,32 @@
+package board
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+// RunTUI launches the Bubble Tea board with optional release/epic filters.
+func RunTUI(release, epic string) error {
+	model, err := newProjectModel(".", release, epic)
+	if err != nil {
+		return err
+	}
+
+	cfg, err := model.Dependencies.ConfigReader.Read(filepath.Join(model.Root, "config.yml"))
+	if err != nil {
+		return err
+	}
+	model.Theme = cfg.Theme
+
+	applyColorProfile()
+
+	p := tea.NewProgram(model, tea.WithAltScreen())
+	if _, err := p.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		return err
+	}
+	return nil
+}