savepoint 1.0.1 → 1.0.3

package/internal/buildtool/main.go

@@ -0,0 +1,211 @@
+package main
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strings"
+	"path/filepath"
+	"runtime"
+)
+
+type target struct {
+	os   string
+	arch string
+}
+
+var targets = []target{
+	{os: "linux", arch: "amd64"},
+	{os: "linux", arch: "arm64"},
+	{os: "darwin", arch: "amd64"},
+	{os: "darwin", arch: "arm64"},
+}
+
+var versionOverride string
+
+func main() {
+	if err := run(os.Args[1:]); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func run(args []string) error {
+	flags := flag.NewFlagSet("buildtool", flag.ContinueOnError)
+	flags.StringVar(&versionOverride, "version", "", "version to inject into the binary")
+	if err := flags.Parse(args); err != nil {
+		return err
+	}
+	if flags.NArg() != 1 {
+		return errors.New("usage: go run ./internal/buildtool [-version vX.Y.Z] <build|clean|build-linux|build-darwin|build-all|dist|smoke-test>")
+	}
+
+	switch flags.Arg(0) {
+	case "build":
+		return buildLocal()
+	case "clean":
+		return clean()
+	case "build-linux":
+		return buildMatching("linux")
+	case "build-darwin":
+		return buildMatching("darwin")
+	case "build-all":
+		return buildAll()
+	case "dist":
+		return dist()
+	case "smoke-test":
+		return smokeTest()
+	default:
+		return fmt.Errorf("unknown build target %q", flags.Arg(0))
+	}
+}
+
+func buildLocal() error {
+	return runGoBuild(localExecutable(), runtime.GOOS, runtime.GOARCH)
+}
+
+func clean() error {
+	for _, path := range []string{"savepoint", "savepoint.exe", "dist"} {
+		if err := os.RemoveAll(path); err != nil {
+			return fmt.Errorf("clean %s: %w", path, err)
+		}
+	}
+	return nil
+}
+
+func buildMatching(goos string) error {
+	for _, target := range targets {
+		if target.os != goos {
+			continue
+		}
+		if err := buildTarget(target); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func buildAll() error {
+	for _, target := range targets {
+		if err := buildTarget(target); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func buildTarget(target target) error {
+	output := filepath.Join("dist", target.os+"-"+target.arch, "savepoint")
+	return runGoBuild(output, target.os, target.arch)
+}
+
+func runGoBuild(output, goos, goarch string) error {
+	if err := os.MkdirAll(filepath.Dir(output), 0o755); err != nil && filepath.Dir(output) != "." {
+		return fmt.Errorf("create output dir: %w", err)
+	}
+
+	cmd := exec.Command("go", "build", "-ldflags", "-X main.version="+version(), "-o", output, "main.go")
+	cmd.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("build %s/%s: %w", goos, goarch, err)
+	}
+	return nil
+}
+
+func dist() error {
+	if err := buildAll(); err != nil {
+		return err
+	}
+	for _, target := range targets {
+		name := "savepoint-" + version() + "-" + target.os + "-" + target.arch + ".tar.gz"
+		source := filepath.Join("dist", target.os+"-"+target.arch, "savepoint")
+		archive := filepath.Join("dist", name)
+		if err := writeTarGz(archive, source, "savepoint"); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func writeTarGz(archivePath, sourcePath, archiveName string) error {
+	source, err := os.Open(sourcePath)
+	if err != nil {
+		return fmt.Errorf("open artifact source: %w", err)
+	}
+	defer source.Close()
+
+	info, err := source.Stat()
+	if err != nil {
+		return fmt.Errorf("stat artifact source: %w", err)
+	}
+
+	archive, err := os.Create(archivePath)
+	if err != nil {
+		return fmt.Errorf("create archive: %w", err)
+	}
+	defer archive.Close()
+
+	gzipWriter := gzip.NewWriter(archive)
+	defer gzipWriter.Close()
+
+	tarWriter := tar.NewWriter(gzipWriter)
+	defer tarWriter.Close()
+
+	header, err := tar.FileInfoHeader(info, "")
+	if err != nil {
+		return fmt.Errorf("create archive header: %w", err)
+	}
+	header.Name = archiveName
+	if err := tarWriter.WriteHeader(header); err != nil {
+		return fmt.Errorf("write archive header: %w", err)
+	}
+	if _, err := io.Copy(tarWriter, source); err != nil {
+		return fmt.Errorf("write archive content: %w", err)
+	}
+	return nil
+}
+
+func smokeTest() error {
+	if err := buildLocal(); err != nil {
+		return err
+	}
+	cmd := exec.Command("."+string(os.PathSeparator)+localExecutable(), "--version")
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("smoke test: %w", err)
+	}
+	fmt.Println("smoke test passed")
+	return nil
+}
+
+func version() string {
+	if versionOverride != "" {
+		return versionOverride
+	}
+	if value := os.Getenv("VERSION"); value != "" {
+		return value
+	}
+
+	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
+	output, err := cmd.Output()
+	if err == nil && len(output) > 0 {
+		return strings.TrimSpace(string(output))
+	}
+	return "v0.0.0"
+}
+
+func localExecutable() string {
+	if runtime.GOOS == "windows" {
+		return "savepoint.exe"
+	}
+	return "savepoint"
+}
+

package/internal/buildtool/main_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestVersion_override(t *testing.T) {
+	versionOverride = "v1.2.3"
+	defer func() { versionOverride = "" }()
+	if got := version(); got != "v1.2.3" {
+		t.Errorf("version() = %q, want %q", got, "v1.2.3")
+	}
+}
+
+func TestVersion_env(t *testing.T) {
+	versionOverride = ""
+	os.Setenv("VERSION", "v2.0.0-env")
+	defer os.Unsetenv("VERSION")
+	if got := version(); got != "v2.0.0-env" {
+		t.Errorf("version() = %q, want %q", got, "v2.0.0-env")
+	}
+}
+
+func TestVersion_fallback(t *testing.T) {
+	versionOverride = ""
+	os.Unsetenv("VERSION")
+	got := version()
+	if got == "" {
+		t.Error("version() returned empty string")
+	}
+}
+
+func TestLocalExecutable(t *testing.T) {
+	got := localExecutable()
+	if runtime.GOOS == "windows" {
+		if got != "savepoint.exe" {
+			t.Errorf("localExecutable() = %q, want %q", got, "savepoint.exe")
+		}
+	} else {
+		if got != "savepoint" {
+			t.Errorf("localExecutable() = %q, want %q", got, "savepoint")
+		}
+	}
+}

package/internal/data/config.go

@@ -16,8 +16,17 @@ type Theme struct {
 	Accents  map[string]string `yaml:"accents"`
 }
 
+type QualityGates struct {
+	Lint           *string `yaml:"lint"`
+	Typecheck      *string `yaml:"typecheck"`
+	Test           *string `yaml:"test"`
+	BlockOnFailure bool    `yaml:"block_on_failure"`
+	Timeout        string  `yaml:"gate_timeout"`
+}
+
 type Config struct {
-	Theme Theme `yaml:"theme"`
+	Theme         Theme         `yaml:"theme"`
+	QualityGates  QualityGates  `yaml:"quality_gates"`
 }
 
 var defaultTheme = Theme{
@@ -80,8 +89,13 @@ func fillThemeDefaults(theme Theme) Theme {
 	if theme.Text == "" {
 		theme.Text = defaultTheme.Text
 	}
-	if len(theme.Accents) == 0 {
-		theme.Accents = defaultTheme.Accents
+	if theme.Accents == nil {
+		theme.Accents = make(map[string]string)
+	}
+	for k, v := range defaultTheme.Accents {
+		if _, ok := theme.Accents[k]; !ok {
+			theme.Accents[k] = v
+		}
 	}
 	return theme
 }

package/internal/data/config_test.go

@@ -53,6 +53,55 @@ func TestConfigReaderRead(t *testing.T) {
 	}
 }
 
+func TestFillThemeDefaults_PartialAccents(t *testing.T) {
+	theme := Theme{
+		BG:      "#000000",
+		Accents: map[string]string{"planned": "#ff0000"},
+	}
+	result := fillThemeDefaults(theme)
+	if result.Accents["planned"] != "#ff0000" {
+		t.Errorf("Accents[planned] = %v, want #ff0000 (user value preserved)", result.Accents["planned"])
+	}
+	if result.Accents["in_progress"] != defaultTheme.Accents["in_progress"] {
+		t.Errorf("Accents[in_progress] = %v, want default %v", result.Accents["in_progress"], defaultTheme.Accents["in_progress"])
+	}
+	if result.Accents["done"] != defaultTheme.Accents["done"] {
+		t.Errorf("Accents[done] = %v, want default %v", result.Accents["done"], defaultTheme.Accents["done"])
+	}
+	if result.Accents["blocked"] != defaultTheme.Accents["blocked"] {
+		t.Errorf("Accents[blocked] = %v, want default %v", result.Accents["blocked"], defaultTheme.Accents["blocked"])
+	}
+	if result.Accents["epic"] != defaultTheme.Accents["epic"] {
+		t.Errorf("Accents[epic] = %v, want default %v", result.Accents["epic"], defaultTheme.Accents["epic"])
+	}
+}
+
+func TestFillThemeDefaults_NilAccents(t *testing.T) {
+	theme := Theme{
+		BG:      "#000000",
+		Accents: nil,
+	}
+	result := fillThemeDefaults(theme)
+	for k, v := range defaultTheme.Accents {
+		if result.Accents[k] != v {
+			t.Errorf("Accents[%s] = %v, want default %v", k, result.Accents[k], v)
+		}
+	}
+}
+
+func TestFillThemeDefaults_EmptyAccents(t *testing.T) {
+	theme := Theme{
+		BG:      "#000000",
+		Accents: map[string]string{},
+	}
+	result := fillThemeDefaults(theme)
+	for k, v := range defaultTheme.Accents {
+		if result.Accents[k] != v {
+			t.Errorf("Accents[%s] = %v, want default %v", k, result.Accents[k], v)
+		}
+	}
+}
+
 func TestConfigReaderMalformedYAML(t *testing.T) {
 	tmpfile, err := os.CreateTemp("", "config-*.yml")
 	if err != nil {

package/internal/data/discover.go

@@ -85,6 +85,32 @@ func (d *Discover) ListReleases(root string) ([]ReleaseInfo, error) {
 	return releases, nil
 }
 
+// ListRootDirs returns sorted child directory names directly under root.
+func (d *Discover) ListRootDirs(root string) ([]string, error) {
+	info, err := os.Stat(root)
+	if err != nil {
+		return nil, err
+	}
+	if !info.IsDir() {
+		return nil, fmt.Errorf("%s is not a directory", root)
+	}
+
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		return nil, err
+	}
+
+	var dirs []string
+	for _, entry := range entries {
+		if entry.IsDir() {
+			dirs = append(dirs, entry.Name())
+		}
+	}
+
+	sort.Strings(dirs)
+	return dirs, nil
+}
+
 func (d *Discover) ListEpics(root, release string) ([]EpicInfo, error) {
 	epicsPath := filepath.Join(root, "releases", release, "epics")
 	info, err := os.Stat(epicsPath)

package/internal/data/discover_test.go

@@ -1,18 +1,17 @@
 package data
 
 import (
-	"os"
 	"path/filepath"
 	"testing"
+
+	"github.com/opencode/savepoint/internal/testutil"
 )
 
 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)
-	}
+	testutil.MkdirAll(t, start)
 
 	root, err := d.FindSavepointRoot(start)
 	if err != nil {
@@ -40,6 +39,35 @@ func TestListReleases(t *testing.T) {
 	}
 }
 
+func TestListRootDirs(t *testing.T) {
+	d := NewDiscover()
+	root := t.TempDir()
+	testutil.MkdirAll(t, filepath.Join(root, "beta"))
+	testutil.MkdirAll(t, filepath.Join(root, "alpha"))
+	testutil.WriteFile(t, filepath.Join(root, "notes.txt"), "test")
+
+	dirs, err := d.ListRootDirs(root)
+	if err != nil {
+		t.Fatalf("ListRootDirs() error = %v", err)
+	}
+
+	if len(dirs) != 2 || dirs[0] != "alpha" || dirs[1] != "beta" {
+		t.Fatalf("ListRootDirs() = %v, want [alpha beta]", dirs)
+	}
+}
+
+func TestListRootDirsRejectsFile(t *testing.T) {
+	d := NewDiscover()
+	root := t.TempDir()
+	path := filepath.Join(root, "not-dir")
+	testutil.WriteFile(t, path, "test")
+
+	_, err := d.ListRootDirs(path)
+	if err == nil {
+		t.Fatal("ListRootDirs() error = nil, want not directory error")
+	}
+}
+
 func TestListEpics(t *testing.T) {
 	d := NewDiscover()
 	root := createDiscoveryFixture(t)
@@ -86,9 +114,7 @@ func createDiscoveryFixture(t *testing.T) string {
 		filepath.Join(savepointRoot, "releases", "v2", "epics"),
 	}
 	for _, path := range paths {
-		if err := os.MkdirAll(path, 0755); err != nil {
-			t.Fatal(err)
-		}
+		testutil.MkdirAll(t, path)
 	}
 
 	files := []string{
@@ -97,9 +123,7 @@ func createDiscoveryFixture(t *testing.T) string {
 		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)
-		}
+		testutil.WriteFile(t, file, "test")
 	}
 
 	return savepointRoot

package/internal/data/errors.go

@@ -6,4 +6,8 @@ var (
 	ErrNoFrontmatter             = errors.New("no frontmatter found")
 	ErrNoClosingFrontmatter      = errors.New("no closing frontmatter delimiter found")
 	ErrSavepointDirectoryMissing = errors.New(".savepoint directory not found")
+	ErrInvalidStatus             = errors.New("invalid router state")
+	ErrMissingFrontmatter        = errors.New("missing or invalid frontmatter")
+	ErrConfigNotFound            = errors.New("configuration file not found")
+	ErrStructureProblem          = errors.New("project structure problem")
 )

package/internal/data/lifecycle.go

@@ -2,17 +2,24 @@ package data
 
 import "fmt"
 
-func ValidateTaskLifecycle(task Task) error {
+func ValidateTaskLifecycle(task *Task) error {
 	if !IsCanonicalColumn(task.Column) {
-		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done", task.Column)
+		return fmt.Errorf("invalid status %q: use planned, in_progress, or done. Add 'status: planned' or 'status: in_progress' to task frontmatter", 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 {
+		if task.Stage == "" {
+			task.Stage = StageBuild
+			return nil
+		}
+		if !IsCanonicalStage(task.Stage) {
+			return fmt.Errorf("invalid phase %q: use build, test, or audit. Add 'phase: build' to task frontmatter", task.Stage)
+		}
+		return nil
 	}
 
-	if task.Column == ColumnInProgress && !IsCanonicalStage(task.Stage) {
-		return fmt.Errorf("invalid in_progress phase %q: use build, test, or audit", task.Stage)
+	if task.Stage != "" {
+		return fmt.Errorf("phase field %q is only valid when status is in_progress. Remove 'phase' or change status to in_progress", task.Stage)
 	}
 
 	return nil

package/internal/data/lifecycle_test.go

@@ -4,35 +4,38 @@ import "testing"
 
 func TestValidateTaskLifecycle_allowsPlannedWithoutPhase(t *testing.T) {
 	task := Task{Column: ColumnPlanned}
-	if err := ValidateTaskLifecycle(task); err != nil {
+	if err := ValidateTaskLifecycle(&task); err != nil {
 		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
 	}
 }
 
+func TestValidateTaskLifecycle_defaultsInProgressWithoutPhase(t *testing.T) {
+	task := Task{Column: ColumnInProgress}
+	if err := ValidateTaskLifecycle(&task); err != nil {
+		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
+	}
+	if task.Stage != StageBuild {
+		t.Fatalf("Task.Stage = %q, want %q", task.Stage, StageBuild)
+	}
+}
+
 func TestValidateTaskLifecycle_allowsInProgressWithPhase(t *testing.T) {
 	task := Task{Column: ColumnInProgress, Stage: StageAudit}
-	if err := ValidateTaskLifecycle(task); err != nil {
+	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 {
+	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 {
+	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")
-	}
-}

package/internal/data/parser.go

@@ -46,7 +46,7 @@ func (p *Parser) ParseTaskFile(path string, content string) (*Task, error) {
 		Epic:        firstNonEmpty(fields.Epic, extractEpicFromID(fields.ID)),
 		Release:     firstNonEmpty(fields.Release, "v1"),
 		Column:      normalizeColumn(rawColumn),
-		Stage:       firstStage(fields.Stage, fields.Phase),
+		Stage:       firstStage(fields.Phase, fields.Stage),
 		Priority:    fields.Priority,
 		Points:      fields.Points,
 		Tags:        fields.Tags,
@@ -61,6 +61,10 @@ func (p *Parser) ParseTaskFile(path string, content string) (*Task, error) {
 		return nil, fmt.Errorf("parse error for %s: %w", path, err)
 	}
 
+	if task.Column == ColumnInProgress && task.Stage == "" {
+		task.Stage = StageBuild
+	}
+
 	return task, nil
 }
 
@@ -84,8 +88,13 @@ type taskFrontmatter struct {
 	Progress    Progress      `yaml:"progress"`
 }
 
+// normalizeLineEndings replaces Windows line endings with Unix line endings.
+func normalizeLineEndings(s string) string {
+	return strings.ReplaceAll(s, "\r\n", "\n")
+}
+
 func extractFrontmatter(content string) (string, error) {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	normalized := normalizeLineEndings(content)
 	if !strings.HasPrefix(normalized, "---\n") {
 		return "", ErrNoFrontmatter
 	}
@@ -139,9 +148,15 @@ const legacyTodoColumn ColumnType = "todo"
 
 func validateParsedTaskLifecycle(rawColumn ColumnType, task Task) error {
 	if rawColumn != "" && rawColumn != legacyTodoColumn && !IsCanonicalColumn(rawColumn) {
-		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done", rawColumn)
+		return fmt.Errorf("invalid task status %q: use planned, in_progress, or done. Add 'status: planned' or 'status: in_progress' to task frontmatter", rawColumn)
+	}
+	if task.Column == ColumnInProgress && !IsCanonicalStage(task.Stage) && task.Stage != "" {
+		return fmt.Errorf("invalid phase %q: use build, test, or audit. Add 'phase: build' to task frontmatter", task.Stage)
 	}
-	return ValidateTaskLifecycle(task)
+	if task.Column != ColumnInProgress && task.Stage != "" {
+		return nil
+	}
+	return nil
 }
 
 func firstStage(values ...ProgressStage) ProgressStage {
@@ -163,7 +178,7 @@ func firstList(values ...[]string) []string {
 }
 
 func extractChecklistItems(content, heading string) []CheckItem {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	normalized := normalizeLineEndings(content)
 	start := strings.Index(normalized, heading)
 	if start == -1 {
 		return nil
@@ -175,25 +190,33 @@ func extractChecklistItems(content, heading string) []CheckItem {
 	}
 
 	items := []CheckItem{}
+	var current *CheckItem
 	for _, line := range strings.Split(section, "\n") {
 		trimmed := strings.TrimSpace(line)
 		if strings.HasPrefix(trimmed, "- [x] ") {
 			items = append(items, CheckItem{Text: strings.TrimSpace(trimmed[6:]), Done: true})
+			current = &items[len(items)-1]
 			continue
 		}
 		if strings.HasPrefix(trimmed, "- [ ] ") {
 			items = append(items, CheckItem{Text: strings.TrimSpace(trimmed[6:]), Done: false})
+			current = &items[len(items)-1]
 			continue
 		}
 		if strings.HasPrefix(trimmed, "- ") {
 			items = append(items, CheckItem{Text: strings.TrimSpace(trimmed[2:]), Done: false})
+			current = &items[len(items)-1]
+			continue
+		}
+		if trimmed != "" && current != nil {
+			current.Text = strings.TrimSpace(current.Text + " " + trimmed)
 		}
 	}
 	return items
 }
 
 func extractChecklistSection(content, heading string) []string {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	normalized := normalizeLineEndings(content)
 	start := strings.Index(normalized, heading)
 	if start == -1 {
 		return nil