savepoint 1.0.0

package/internal/board/view_test.go

@@ -0,0 +1,147 @@
+package board
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+	"github.com/opencode/savepoint/internal/data"
+)
+
+func TestView_rendersWithoutPanic(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.Height = 40
+	got := m.View()
+	if got == "" {
+		t.Error("View() returned empty string")
+	}
+}
+
+func TestView_containsColumnTitles(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+
+	for _, title := range []string{"PLANNED", "IN PROGRESS", "DONE"} {
+		if !strings.Contains(got, title) {
+			t.Errorf("View() missing column title %q", title)
+		}
+	}
+}
+
+func TestView_containsHeader(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	if !strings.Contains(got, "S A V E P O I N T") {
+		t.Error("View() missing spaced header text")
+	}
+	if !strings.Contains(got, "▣") {
+		t.Error("View() missing header icon")
+	}
+}
+
+func TestView_containsDivider(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	if !strings.Contains(got, "─") {
+		t.Error("View() missing horizontal divider")
+	}
+}
+
+func TestView_containsFooterPhases(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	for _, phase := range []string{"PLAN", "BUILD", "AUDIT"} {
+		if !strings.Contains(got, phase) {
+			t.Errorf("View() missing footer phase %q", phase)
+		}
+	}
+}
+
+func TestView_containsFooterHints(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	footer := m.renderFooter(80)
+
+	if !strings.Contains(footer, "←/→:nav  E:epic  R:release  ?:help  q:quit") {
+		t.Fatal("renderFooter() missing navigation hints")
+	}
+
+	lines := strings.Split(footer, "\n")
+	if len(lines) != 3 {
+		t.Fatalf("renderFooter() returned %d lines, want 3", len(lines))
+	}
+	if strings.TrimSpace(lines[1]) != "" {
+		t.Fatalf("renderFooter() spacer line = %q, want blank", lines[1])
+	}
+	for i, line := range lines {
+		if got := lipgloss.Width(line); got > 80 {
+			t.Fatalf("renderFooter() line %d width = %d, want <= 80", i, got)
+		}
+	}
+}
+
+func TestView_containsBottomDivider(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	// There should be at least two divider lines (top and bottom)
+	count := strings.Count(got, "─")
+	if count < 2 {
+		t.Errorf("View() expected at least 2 divider chars, got %d", count)
+	}
+}
+
+func TestView_defaultWidthWhenZero(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	// Width=0: should use default and not panic
+	got := m.View()
+	if got == "" {
+		t.Error("View() with zero Width returned empty string")
+	}
+}
+
+func TestView_taskLabelFallback(t *testing.T) {
+	tasks := []data.Task{{ID: "T1", Title: "", Column: data.ColumnPlanned}}
+	m := NewModel(tasks, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	if !strings.Contains(got, "T1") {
+		t.Error("View() missing task ID when title is empty")
+	}
+}
+
+func TestView_taskLabelWithTitle(t *testing.T) {
+	tasks := []data.Task{{ID: "T2", Title: "My Task", Column: data.ColumnPlanned}}
+	m := NewModel(tasks, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	if !strings.Contains(got, "My Task") {
+		t.Error("View() missing task title")
+	}
+}
+
+func TestView_wideShowsEpicPanel(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	got := m.View()
+	if !strings.Contains(got, "E03") {
+		t.Error("View() at width>=120 missing epic panel content")
+	}
+}
+
+func TestView_narrowShowsSingleColumn(t *testing.T) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 60
+	m.FocusedColumn = data.ColumnInProgress
+	got := m.View()
+	if !strings.Contains(got, "IN PROGRESS") {
+		t.Error("View() at width<80 missing focused column title")
+	}
+	if strings.Contains(got, "PLANNED") {
+		t.Error("View() at width<80 should not show non-focused columns")
+	}
+}

package/internal/data/config.go

@@ -0,0 +1,87 @@
+package data
+
+import (
+	"fmt"
+	"os"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Theme struct {
+	BG       string            `yaml:"bg"`
+	Surface  string            `yaml:"surface"`
+	Surface2 string            `yaml:"surface_2"`
+	Border   string            `yaml:"border"`
+	Text     string            `yaml:"text"`
+	Accents  map[string]string `yaml:"accents"`
+}
+
+type Config struct {
+	Theme Theme `yaml:"theme"`
+}
+
+var defaultTheme = Theme{
+	BG:       "#1a1b26",
+	Surface:  "#24283b",
+	Surface2: "#414868",
+	Border:   "#565f89",
+	Text:     "#c0caf5",
+	Accents: map[string]string{
+		"planned":     "#7aa2f7",
+		"in_progress": "#bb9af7",
+		"done":        "#9ece6a",
+		"blocked":     "#f7768e",
+		"epic":        "#2ac3de",
+	},
+}
+
+var defaultConfig = Config{
+	Theme: defaultTheme,
+}
+
+type ConfigReader struct{}
+
+func NewConfigReader() *ConfigReader {
+	return &ConfigReader{}
+}
+
+func (r *ConfigReader) Read(path string) (*Config, error) {
+	data, err := os.ReadFile(path)
+	if os.IsNotExist(err) {
+		return &defaultConfig, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config: %w", err)
+	}
+
+	var config Config
+	if err := yaml.Unmarshal(data, &config); err != nil {
+		return nil, fmt.Errorf("failed to parse config YAML: %w", err)
+	}
+
+	config.Theme = fillThemeDefaults(config.Theme)
+
+	return &config, nil
+}
+
+func fillThemeDefaults(theme Theme) Theme {
+	if theme.BG == "" {
+		theme.BG = defaultTheme.BG
+	}
+	if theme.Surface == "" {
+		theme.Surface = defaultTheme.Surface
+	}
+	if theme.Surface2 == "" {
+		theme.Surface2 = defaultTheme.Surface2
+	}
+	if theme.Border == "" {
+		theme.Border = defaultTheme.Border
+	}
+	if theme.Text == "" {
+		theme.Text = defaultTheme.Text
+	}
+	if len(theme.Accents) == 0 {
+		theme.Accents = defaultTheme.Accents
+	}
+	return theme
+}

package/internal/data/config_test.go

@@ -0,0 +1,73 @@
+package data
+
+import (
+	"os"
+	"testing"
+)
+
+func TestConfigReaderDefault(t *testing.T) {
+	r := NewConfigReader()
+	config, err := r.Read("nonexistent.yml")
+	if err != nil {
+		t.Fatalf("Read() error = %v", err)
+	}
+
+	if config.Theme.BG != defaultTheme.BG {
+		t.Errorf("Theme.BG = %v, want %v", config.Theme.BG, defaultTheme.BG)
+	}
+}
+
+func TestConfigReaderRead(t *testing.T) {
+	content := `theme:
+  bg: "#000000"
+  surface: "#111111"
+  text: "#ffffff"
+  accents:
+    planned: "#222222"
+`
+	tmpfile, err := os.CreateTemp("", "config-*.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpfile.Name())
+
+	if _, err := tmpfile.Write([]byte(content)); err != nil {
+		t.Fatal(err)
+	}
+	tmpfile.Close()
+
+	r := NewConfigReader()
+	config, err := r.Read(tmpfile.Name())
+	if err != nil {
+		t.Fatalf("Read() error = %v", err)
+	}
+
+	if config.Theme.BG != "#000000" {
+		t.Errorf("Theme.BG = %v, want #000000", config.Theme.BG)
+	}
+	if config.Theme.Surface2 != defaultTheme.Surface2 {
+		t.Errorf("Theme.Surface2 = %v, want default %v", config.Theme.Surface2, defaultTheme.Surface2)
+	}
+	if config.Theme.Accents["planned"] != "#222222" {
+		t.Errorf("Theme.Accents[planned] = %v, want #222222", config.Theme.Accents["planned"])
+	}
+}
+
+func TestConfigReaderMalformedYAML(t *testing.T) {
+	tmpfile, err := os.CreateTemp("", "config-*.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tmpfile.Name())
+
+	if _, err := tmpfile.Write([]byte("theme: [broken")); err != nil {
+		t.Fatal(err)
+	}
+	tmpfile.Close()
+
+	r := NewConfigReader()
+	_, err = r.Read(tmpfile.Name())
+	if err == nil {
+		t.Fatal("Read() expected malformed YAML error")
+	}
+}

package/internal/data/discover.go

@@ -0,0 +1,152 @@
+package data
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+type ReleaseInfo struct {
+	ID    string
+	Path  string
+	Epics []EpicInfo
+}
+
+type EpicInfo struct {
+	ID    string
+	Path  string
+	Tasks []TaskInfo
+}
+
+type TaskInfo struct {
+	ID   string
+	Path string
+}
+
+type Discover struct{}
+
+func NewDiscover() *Discover {
+	return &Discover{}
+}
+
+func (d *Discover) FindSavepointRoot(start string) (string, error) {
+	dir, err := filepath.Abs(start)
+	if err != nil {
+		return "", err
+	}
+
+	for {
+		savepointPath := filepath.Join(dir, ".savepoint")
+		info, err := os.Stat(savepointPath)
+		if err == nil && info.IsDir() {
+			return savepointPath, nil
+		}
+
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			return "", ErrSavepointDirectoryMissing
+		}
+		dir = parent
+	}
+}
+
+func (d *Discover) ListReleases(root string) ([]ReleaseInfo, error) {
+	releasesPath := filepath.Join(root, "releases")
+	info, err := os.Stat(releasesPath)
+	if err != nil {
+		return nil, fmt.Errorf("releases directory not found: %w", err)
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("releases is not a directory")
+	}
+
+	entries, err := os.ReadDir(releasesPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var releases []ReleaseInfo
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		id := entry.Name()
+		releases = append(releases, ReleaseInfo{
+			ID:   id,
+			Path: filepath.Join(releasesPath, id),
+		})
+	}
+
+	sort.Slice(releases, func(i, j int) bool {
+		return releases[i].ID < releases[j].ID
+	})
+	return releases, nil
+}
+
+func (d *Discover) ListEpics(root, release string) ([]EpicInfo, error) {
+	epicsPath := filepath.Join(root, "releases", release, "epics")
+	info, err := os.Stat(epicsPath)
+	if err != nil {
+		return nil, fmt.Errorf("epics directory not found: %w", err)
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("epics is not a directory")
+	}
+
+	entries, err := os.ReadDir(epicsPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var epics []EpicInfo
+	for _, entry := range entries {
+		if !entry.IsDir() || strings.HasPrefix(entry.Name(), "_") {
+			continue
+		}
+		id := entry.Name()
+		epics = append(epics, EpicInfo{
+			ID:   id,
+			Path: filepath.Join(epicsPath, id),
+		})
+	}
+
+	sort.Slice(epics, func(i, j int) bool {
+		return epics[i].ID < epics[j].ID
+	})
+	return epics, nil
+}
+
+func (d *Discover) ListTasks(root, release, epic string) ([]TaskInfo, error) {
+	tasksPath := filepath.Join(root, "releases", release, "epics", epic, "tasks")
+	info, err := os.Stat(tasksPath)
+	if err != nil {
+		return nil, fmt.Errorf("tasks directory not found: %w", err)
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("tasks is not a directory")
+	}
+
+	entries, err := os.ReadDir(tasksPath)
+	if err != nil {
+		return nil, err
+	}
+
+	var tasks []TaskInfo
+	for _, entry := range entries {
+		if entry.IsDir() || filepath.Ext(entry.Name()) != ".md" {
+			continue
+		}
+		id := entry.Name()[:len(entry.Name())-3]
+		tasks = append(tasks, TaskInfo{
+			ID:   id,
+			Path: filepath.Join(tasksPath, entry.Name()),
+		})
+	}
+
+	sort.Slice(tasks, func(i, j int) bool {
+		return tasks[i].ID < tasks[j].ID
+	})
+	return tasks, nil
+}

package/internal/data/discover_test.go

@@ -0,0 +1,106 @@
+package data
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestFindSavepointRoot(t *testing.T) {
+	d := NewDiscover()
+	savepointRoot := createDiscoveryFixture(t)
+	start := filepath.Join(filepath.Dir(savepointRoot), "nested", "child")
+	if err := os.MkdirAll(start, 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	root, err := d.FindSavepointRoot(start)
+	if err != nil {
+		t.Fatalf("FindSavepointRoot() error = %v", err)
+	}
+	if root != savepointRoot {
+		t.Errorf("FindSavepointRoot() = %v, want %v", root, savepointRoot)
+	}
+}
+
+func TestListReleases(t *testing.T) {
+	d := NewDiscover()
+	root := createDiscoveryFixture(t)
+
+	releases, err := d.ListReleases(root)
+	if err != nil {
+		t.Fatalf("ListReleases() error = %v", err)
+	}
+
+	if len(releases) != 2 {
+		t.Fatalf("ListReleases() returned %d releases, want 2", len(releases))
+	}
+	if releases[0].ID != "v1" || releases[1].ID != "v2" {
+		t.Errorf("ListReleases() IDs = %v, want [v1 v2]", []string{releases[0].ID, releases[1].ID})
+	}
+}
+
+func TestListEpics(t *testing.T) {
+	d := NewDiscover()
+	root := createDiscoveryFixture(t)
+
+	epics, err := d.ListEpics(root, "v1")
+	if err != nil {
+		t.Fatalf("ListEpics() error = %v", err)
+	}
+
+	if len(epics) != 2 {
+		t.Fatalf("ListEpics() returned %d epics, want 2", len(epics))
+	}
+	if epics[0].ID != "E01-go-setup" || epics[1].ID != "E02-data-readers" {
+		t.Errorf("ListEpics() IDs = %v, want [E01-go-setup E02-data-readers]", []string{epics[0].ID, epics[1].ID})
+	}
+}
+
+func TestListTasks(t *testing.T) {
+	d := NewDiscover()
+	root := createDiscoveryFixture(t)
+
+	tasks, err := d.ListTasks(root, "v1", "E02-data-readers")
+	if err != nil {
+		t.Fatalf("ListTasks() error = %v", err)
+	}
+
+	if len(tasks) != 2 {
+		t.Fatalf("ListTasks() returned %d tasks, want 2", len(tasks))
+	}
+	if tasks[0].ID != "T001-task-struct" || tasks[1].ID != "T002-frontmatter-parser" {
+		t.Errorf("ListTasks() IDs = %v, want [T001-task-struct T002-frontmatter-parser]", []string{tasks[0].ID, tasks[1].ID})
+	}
+}
+
+func createDiscoveryFixture(t *testing.T) string {
+	t.Helper()
+
+	root := t.TempDir()
+	savepointRoot := filepath.Join(root, ".savepoint")
+	paths := []string{
+		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks"),
+		filepath.Join(savepointRoot, "releases", "v1", "epics", "E01-go-setup", "tasks"),
+		filepath.Join(savepointRoot, "releases", "v1", "epics", "_archived"),
+		filepath.Join(savepointRoot, "releases", "v2", "epics"),
+	}
+	for _, path := range paths {
+		if err := os.MkdirAll(path, 0755); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	files := []string{
+		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "T002-frontmatter-parser.md"),
+		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "T001-task-struct.md"),
+		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "notes.txt"),
+	}
+	for _, file := range files {
+		if err := os.WriteFile(file, []byte("test"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	return savepointRoot
+}

package/internal/data/errors.go

@@ -0,0 +1,9 @@
+package data
+
+import "errors"
+
+var (
+	ErrNoFrontmatter             = errors.New("no frontmatter found")
+	ErrNoClosingFrontmatter      = errors.New("no closing frontmatter delimiter found")
+	ErrSavepointDirectoryMissing = errors.New(".savepoint directory not found")
+)

package/internal/data/lifecycle.go

@@ -0,0 +1,37 @@
+package data
+
+import "fmt"
+
+func ValidateTaskLifecycle(task Task) error {
+	if !IsCanonicalColumn(task.Column) {
+		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done", task.Column)
+	}
+
+	if task.Column != ColumnInProgress && task.Stage != "" {
+		return fmt.Errorf("phase %q is only valid when status is in_progress", task.Stage)
+	}
+
+	if task.Column == ColumnInProgress && !IsCanonicalStage(task.Stage) {
+		return fmt.Errorf("invalid in_progress phase %q: use build, test, or audit", task.Stage)
+	}
+
+	return nil
+}
+
+func IsCanonicalColumn(value ColumnType) bool {
+	switch value {
+	case ColumnPlanned, ColumnInProgress, ColumnDone:
+		return true
+	default:
+		return false
+	}
+}
+
+func IsCanonicalStage(value ProgressStage) bool {
+	switch value {
+	case StageBuild, StageTest, StageAudit:
+		return true
+	default:
+		return false
+	}
+}

package/internal/data/lifecycle_test.go

@@ -0,0 +1,38 @@
+package data
+
+import "testing"
+
+func TestValidateTaskLifecycle_allowsPlannedWithoutPhase(t *testing.T) {
+	task := Task{Column: ColumnPlanned}
+	if err := ValidateTaskLifecycle(task); err != nil {
+		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
+	}
+}
+
+func TestValidateTaskLifecycle_allowsInProgressWithPhase(t *testing.T) {
+	task := Task{Column: ColumnInProgress, Stage: StageAudit}
+	if err := ValidateTaskLifecycle(task); err != nil {
+		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
+	}
+}
+
+func TestValidateTaskLifecycle_rejectsUnknownStatus(t *testing.T) {
+	task := Task{Column: "review"}
+	if err := ValidateTaskLifecycle(task); err == nil {
+		t.Fatal("ValidateTaskLifecycle() expected unknown status error")
+	}
+}
+
+func TestValidateTaskLifecycle_rejectsPhaseOutsideInProgress(t *testing.T) {
+	task := Task{Column: ColumnPlanned, Stage: StageBuild}
+	if err := ValidateTaskLifecycle(task); err == nil {
+		t.Fatal("ValidateTaskLifecycle() expected phase/status error")
+	}
+}
+
+func TestValidateTaskLifecycle_rejectsInProgressWithoutCanonicalPhase(t *testing.T) {
+	task := Task{Column: ColumnInProgress}
+	if err := ValidateTaskLifecycle(task); err == nil {
+		t.Fatal("ValidateTaskLifecycle() expected missing phase error")
+	}
+}