savepoint 1.0.2 → 1.0.3

package/cmd/doctor_test.go

@@ -0,0 +1,146 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+)
+
+func TestRunDoctorHelp(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	code, err := RunDoctor(context.Background(), []string{"--help"}, &stdout, func(DoctorOptions) (int, error) {
+		called = true
+		return 0, nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if called {
+		t.Fatal("RunDoctor() called runner for help")
+	}
+	if code != 0 {
+		t.Fatalf("RunDoctor() code = %d, want 0", code)
+	}
+	if !strings.Contains(stdout.String(), "doctor [--epic <epic>]") {
+		t.Fatalf("help output = %q", stdout.String())
+	}
+}
+
+func TestRunDoctorNoArgs(t *testing.T) {
+	got := runDoctorOptions(t, nil)
+
+	if got.Epic != "" {
+		t.Fatalf("Epic = %q, want empty", got.Epic)
+	}
+}
+
+func TestRunDoctorEpic(t *testing.T) {
+	got := runDoctorOptions(t, []string{"--epic", "E03"})
+
+	if got.Epic != "E03" {
+		t.Fatalf("Epic = %q, want E03", got.Epic)
+	}
+}
+
+func TestRunDoctorEpicMissingValue(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), []string{"--epic"}, &stdout, func(DoctorOptions) (int, error) {
+		return 0, nil
+	})
+
+	if err == nil {
+		t.Fatal("RunDoctor() error = nil, want missing value error")
+	}
+	if !strings.Contains(err.Error(), "--epic requires a value") {
+		t.Fatalf("error = %q", err.Error())
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func TestRunDoctorRejectsUnknownFlag(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), []string{"--bogus"}, &stdout, func(DoctorOptions) (int, error) {
+		return 0, nil
+	})
+
+	if err == nil {
+		t.Fatal("RunDoctor() error = nil, want unknown flag error")
+	}
+	if !strings.Contains(err.Error(), "unknown doctor flag") {
+		t.Fatalf("error = %q", err.Error())
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func TestRunDoctorRejectsPositionalArgs(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), []string{"extra"}, &stdout, func(DoctorOptions) (int, error) {
+		return 0, nil
+	})
+
+	if err == nil {
+		t.Fatal("RunDoctor() error = nil, want positional arg error")
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func TestRunDoctorExitCode1(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), nil, &stdout, func(DoctorOptions) (int, error) {
+		return 1, nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if code != 1 {
+		t.Fatalf("code = %d, want 1", code)
+	}
+}
+
+func TestRunDoctorExitCode2(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), nil, &stdout, func(DoctorOptions) (int, error) {
+		return 2, nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func runDoctorOptions(t *testing.T, args []string) DoctorOptions {
+	t.Helper()
+
+	var stdout bytes.Buffer
+	var got DoctorOptions
+	code, err := RunDoctor(context.Background(), args, &stdout, func(options DoctorOptions) (int, error) {
+		got = options
+		return 0, nil
+	})
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if code != 0 {
+		t.Fatalf("RunDoctor() code = %d, want 0", code)
+	}
+	return got
+}

package/cmd/init.go

@@ -0,0 +1,63 @@
+package cmd
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+)
+
+const initUsage = "Usage: init [dir] [--force] [--install]"
+
+type InitOptions struct {
+	Dir     string
+	Force   bool
+	Install bool
+}
+
+type InitRunner func(context.Context, InitOptions) error
+
+var ErrInitNotImplemented = errors.New("init scaffold is not implemented yet")
+
+func RunInit(ctx context.Context, args []string, stdout io.Writer, runner InitRunner) error {
+	options, help, err := ParseInitArgs(args)
+	if help {
+		_, writeErr := fmt.Fprintln(stdout, initUsage)
+		return writeErr
+	}
+	if err != nil {
+		return err
+	}
+	return runner(ctx, options)
+}
+
+func ParseInitArgs(args []string) (InitOptions, bool, error) {
+	options := InitOptions{Dir: "."}
+	var dirSet bool
+
+	for _, arg := range args {
+		switch arg {
+		case "--help":
+			return InitOptions{}, true, nil
+		case "--force":
+			options.Force = true
+		case "--install":
+			options.Install = true
+		default:
+			if len(arg) > 0 && arg[0] == '-' {
+				return InitOptions{}, false, fmt.Errorf("unknown init flag %q", arg)
+			}
+			if dirSet {
+				return InitOptions{}, false, fmt.Errorf("init accepts at most one directory")
+			}
+			options.Dir = arg
+			dirSet = true
+		}
+	}
+
+	return options, false, nil
+}
+
+func InitNotImplemented(context.Context, InitOptions) error {
+	return ErrInitNotImplemented
+}

package/cmd/init_test.go

@@ -0,0 +1,104 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestRunInitHelp(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	err := RunInit(context.Background(), []string{"--help"}, &stdout, func(context.Context, InitOptions) error {
+		called = true
+		return nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunInit() error = %v", err)
+	}
+	if called {
+		t.Fatal("RunInit() called runner for help")
+	}
+	if !strings.Contains(stdout.String(), "Usage: init [dir] [--force] [--install]") {
+		t.Fatalf("help output = %q", stdout.String())
+	}
+}
+
+func TestRunInitDefaultsToCurrentDirectory(t *testing.T) {
+	got := runInitOptions(t, nil)
+
+	if got.Dir != "." {
+		t.Fatalf("Dir = %q, want .", got.Dir)
+	}
+}
+
+func TestRunInitUsesSpecifiedDirectory(t *testing.T) {
+	got := runInitOptions(t, []string{"example"})
+
+	if got.Dir != "example" {
+		t.Fatalf("Dir = %q, want example", got.Dir)
+	}
+}
+
+func TestRunInitParsesForceAndInstall(t *testing.T) {
+	got := runInitOptions(t, []string{"example", "--force", "--install"})
+
+	if !got.Force {
+		t.Fatal("Force = false, want true")
+	}
+	if !got.Install {
+		t.Fatal("Install = false, want true")
+	}
+}
+
+func TestRunInitRejectsUnknownFlags(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	err := RunInit(context.Background(), []string{"--bogus"}, &stdout, func(context.Context, InitOptions) error {
+		called = true
+		return nil
+	})
+
+	if err == nil {
+		t.Fatal("RunInit() error = nil, want unknown flag error")
+	}
+	if called {
+		t.Fatal("RunInit() called runner after invalid args")
+	}
+	if !strings.Contains(err.Error(), "unknown init flag") {
+		t.Fatalf("error = %q, want unknown flag", err.Error())
+	}
+}
+
+func TestRunInitReturnsRunnerError(t *testing.T) {
+	want := errors.New("runner failed")
+	var stdout bytes.Buffer
+
+	err := RunInit(context.Background(), nil, &stdout, func(context.Context, InitOptions) error {
+		return want
+	})
+
+	if !errors.Is(err, want) {
+		t.Fatalf("RunInit() error = %v, want %v", err, want)
+	}
+}
+
+func runInitOptions(t *testing.T, args []string) InitOptions {
+	t.Helper()
+
+	var stdout bytes.Buffer
+	var got InitOptions
+	err := RunInit(context.Background(), args, &stdout, func(_ context.Context, options InitOptions) error {
+		got = options
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("RunInit() error = %v", err)
+	}
+	return got
+}

package/internal/board/board.go

@@ -5,53 +5,65 @@ 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})
+
+	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
 	}
 
-	tasks, releaseIDs, releaseEpics, epicStatuses, err := loadBoardData(root)
+	tasks, releaseIDs, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
 	if err != nil {
 		return Model{}, err
 	}
 
-	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
@@ -70,9 +82,8 @@ func newProjectModel(start string) (Model, error) {
 	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 +95,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 +109,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 +121,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)
 }