savepoint 1.0.2 → 1.0.4

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/fuzz_test.go

@@ -0,0 +1,75 @@
+package data
+
+import (
+	"testing"
+)
+
+func FuzzExtractFrontmatter(f *testing.F) {
+	seeds := []string{
+		"---\nid: E01/T001\nstatus: planned\n---\nbody",
+		"---\n---\n",
+		"---\n\n---\n",
+		"---\nid: test\n---",
+		"",
+		"# no frontmatter",
+		"---\nid: [broken\n---\n",
+		"---\nname: héllo wörld\n---\n",
+		"---\nid: test\nstatus: in_progress\nphase: build\n---\nbody content",
+		"---\r\nid: test\r\n---\r\nbody",
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, content string) {
+		_, _ = extractFrontmatter(content)
+	})
+}
+
+func FuzzParseFrontmatter(f *testing.F) {
+	seeds := []string{
+		"---\nid: E01/T001\nstatus: planned\n---\nbody",
+		"---\n---\n",
+		"---\nid: [broken\n---\n",
+		"---\nname: héllo\n---\n",
+		"",
+		"no frontmatter",
+		"---\ntags: [a, b, c]\n---\n",
+		"---\nnested:\n  key: val\n---\n",
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, content string) {
+		p := NewParser()
+		_, _ = p.ParseFrontmatter(content)
+	})
+}
+
+func FuzzSplitFrontmatterBody(f *testing.F) {
+	seeds := []string{
+		"---\nid: E01/T001\nstatus: planned\n---\nbody",
+		"---\n---\n",
+		"---\nkey: value\n---",
+		"",
+		"# no frontmatter",
+		"---\nid: test\nstatus: in_progress\n---\n\n## Section\n\nContent.",
+		"---\nid: test\n---\n\nbody with unicode: 日本語",
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, content string) {
+		yamlStr, body, err := SplitFrontmatterBody(content)
+		if err != nil {
+			return
+		}
+		reconstructed := "---\n" + yamlStr + "\n---" + body
+		_, body2, err2 := SplitFrontmatterBody(reconstructed)
+		if err2 != nil {
+			t.Errorf("round-trip SplitFrontmatterBody failed on reconstructed: %v", err2)
+		}
+		if body2 != body {
+			t.Errorf("round-trip body mismatch: got %q, want %q", body2, body)
+		}
+	})
+}

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,14 @@ type taskFrontmatter struct {
 	Progress    Progress      `yaml:"progress"`
 }
 
+// normalizeLineEndings replaces Windows (CRLF) and legacy Mac (CR) line endings with LF.
+func normalizeLineEndings(s string) string {
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+	return strings.ReplaceAll(s, "\r", "\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 +149,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)
 	}
-	return ValidateTaskLifecycle(task)
+	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)
+	}
+	if task.Column != ColumnInProgress && task.Stage != "" {
+		return nil
+	}
+	return nil
 }
 
 func firstStage(values ...ProgressStage) ProgressStage {
@@ -163,7 +179,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
@@ -201,7 +217,7 @@ func extractChecklistItems(content, heading string) []CheckItem {
 }
 
 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

package/internal/data/parser_test.go

@@ -146,7 +146,7 @@ objective: "Style the board"
 	}
 }
 
-func TestParseTaskFile_rejectsPhaseOutsideInProgress(t *testing.T) {
+func TestParseTaskFile_allowsPhaseOutsideInProgress(t *testing.T) {
 	p := NewParser()
 	content := `---
 id: E06/T001
@@ -158,12 +158,12 @@ objective: "Style the board"
 # Task`
 
 	_, err := p.ParseTaskFile("test.md", content)
-	if err == nil {
-		t.Fatal("ParseTaskFile() expected invalid phase/status error")
+	if err != nil {
+		t.Fatalf("ParseTaskFile() error = %v, want no error for legacy phase field", err)
 	}
 }
 
-func TestParseTaskFile_rejectsInProgressWithoutPhase(t *testing.T) {
+func TestParseTaskFile_includesDefaultBuildForInProgress(t *testing.T) {
 	p := NewParser()
 	content := `---
 id: E06/T001
@@ -173,9 +173,33 @@ objective: "Style the board"
 
 # Task`
 
-	_, err := p.ParseTaskFile("test.md", content)
-	if err == nil {
-		t.Fatal("ParseTaskFile() expected missing phase error")
+	task, err := p.ParseTaskFile("test.md", content)
+	if err != nil {
+		t.Fatalf("ParseTaskFile() error = %v", err)
+	}
+	if task.Stage != StageBuild {
+		t.Fatalf("ParseTaskFile() expected StageBuild default, got %q", task.Stage)
+	}
+}
+
+func TestParseTaskFile_prefersPhaseOverLegacyStage(t *testing.T) {
+	p := NewParser()
+	content := `---
+id: E06/T001
+status: in_progress
+stage: build
+phase: test
+objective: "Style the board"
+---
+
+# Task`
+
+	task, err := p.ParseTaskFile("test.md", content)
+	if err != nil {
+		t.Fatalf("ParseTaskFile() error = %v", err)
+	}
+	if task.Stage != StageTest {
+		t.Fatalf("Task.Stage = %q, want test from phase", task.Stage)
 	}
 }
 

package/internal/data/task.go

@@ -26,15 +26,6 @@ const (
 	StageAudit ProgressStage = "audit"
 )
 
-type TaskStatus string
-
-const (
-	StatusPlanned    TaskStatus = "planned"
-	StatusInProgress TaskStatus = "in_progress"
-	StatusDone       TaskStatus = "done"
-	StatusAudited    TaskStatus = "audited"
-)
-
 type Progress struct {
 	Stage   ProgressStage `yaml:"stage"`
 	Started bool          `yaml:"started"`

package/internal/data/testdata/fuzz/FuzzSplitFrontmatterBody/68eb66b0fe91e7e3

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("---\n\n---\r\r\n")

package/internal/data/write.go

@@ -11,9 +11,91 @@ import (
 )
 
 var ErrMtimeConflict = fmt.Errorf("file modified since last read")
+var ErrProposalNotFound = fmt.Errorf("target text not found in file")
+
+// ApplyProposal replaces the first occurrence of old with newText in the file at path.
+func ApplyProposal(path, old, newText string) error {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("read %s: %w", path, err)
+	}
+	normalized := normalizeLineEndings(string(content))
+	if !strings.Contains(normalized, old) {
+		return fmt.Errorf("%w: %s", ErrProposalNotFound, path)
+	}
+	updated := strings.Replace(normalized, old, newText, 1)
+	return os.WriteFile(path, []byte(updated), 0644)
+}
+
+// UpdateEpicStatus sets the status field in the frontmatter of an E##-Detail.md file.
+func UpdateEpicStatus(path, status string) error {
+	return updateFrontmatterField(path, "status", status)
+}
+
+// UpdateLastAudited sets the last_audited field in the frontmatter of Design.md.
+func UpdateLastAudited(path, value string) error {
+	return updateFrontmatterField(path, "last_audited", value)
+}
+
+// SplitFrontmatterBody splits content into frontmatter YAML and body.
+func SplitFrontmatterBody(content string) (yamlStr string, body string, err error) {
+	normalized := normalizeLineEndings(content)
+	if !strings.HasPrefix(normalized, "---\n") {
+		return "", "", ErrNoFrontmatter
+	}
+	end := strings.Index(normalized[4:], "\n---")
+	if end == -1 {
+		return "", "", ErrNoClosingFrontmatter
+	}
+	yamlStr = strings.TrimSpace(normalized[4 : 4+end])
+	bodyStart := 4 + end + 4 // "---\n" + yaml + "\n---"
+	body = ""
+	if bodyStart < len(normalized) {
+		body = normalized[bodyStart:]
+	}
+	return yamlStr, body, nil
+}
+
+func updateFrontmatterField(path, key, value string) error {
+	content, err := os.ReadFile(path)
+	if err != nil {
+		return fmt.Errorf("read %s: %w", path, err)
+	}
+
+	normalized := normalizeLineEndings(string(content))
+
+	raw, body, err := SplitFrontmatterBody(normalized)
+	if err != nil {
+		return fmt.Errorf("extract frontmatter: %w", err)
+	}
+
+	var doc yaml.Node
+	if err := yaml.Unmarshal([]byte(raw), &doc); err != nil {
+		return fmt.Errorf("parse yaml: %w", err)
+	}
+
+	if doc.Kind != yaml.DocumentNode || len(doc.Content) == 0 {
+		return fmt.Errorf("unexpected yaml structure")
+	}
+
+	mapping := doc.Content[0]
+	if mapping.Kind != yaml.MappingNode {
+		return fmt.Errorf("frontmatter is not a mapping")
+	}
+
+	setMappingField(mapping, key, value)
+
+	out, err := yaml.Marshal(&doc)
+	if err != nil {
+		return fmt.Errorf("marshal yaml: %w", err)
+	}
+
+	newContent := "---\n" + strings.TrimSpace(string(out)) + "\n---" + body
+	return os.WriteFile(path, []byte(newContent), 0644)
+}
 
 func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
-	if err := ValidateTaskLifecycle(*task); err != nil {
+	if err := ValidateTaskLifecycle(task); err != nil {
 		return err
 	}
 
@@ -31,9 +113,9 @@ func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
 		return fmt.Errorf("read %s: %w", path, err)
 	}
 
-	normalized := strings.ReplaceAll(string(content), "\r\n", "\n")
+	normalized := normalizeLineEndings(string(content))
 
-	raw, err := extractFrontmatter(normalized)
+	raw, body, err := SplitFrontmatterBody(normalized)
 	if err != nil {
 		return fmt.Errorf("extract frontmatter: %w", err)
 	}
@@ -56,8 +138,10 @@ func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
 
 	if task.Stage == "" {
 		removeMappingField(mapping, "phase")
+		removeMappingField(mapping, "stage")
 	} else {
 		setMappingField(mapping, "phase", string(task.Stage))
+		removeMappingField(mapping, "stage")
 	}
 
 	out, err := yaml.Marshal(&doc)
@@ -65,13 +149,6 @@ func WriteTaskStatus(path string, task *Task, expectedMtime time.Time) error {
 		return fmt.Errorf("marshal yaml: %w", err)
 	}
 
-	delimLen := 4
-	bodyStart := delimLen + len(raw) + delimLen
-	body := ""
-	if bodyStart < len(normalized) {
-		body = normalized[bodyStart:]
-	}
-
 	newContent := "---\n" + strings.TrimSpace(string(out)) + "\n---" + body
 
 	return os.WriteFile(path, []byte(newContent), 0644)
@@ -115,7 +192,7 @@ func WriteRouterState(root string, state *RouterState, expectedMtime time.Time)
 		return fmt.Errorf("read %s: %w", path, err)
 	}
 
-	normalized := strings.ReplaceAll(string(content), "\r\n", "\n")
+	normalized := normalizeLineEndings(string(content))
 
 	startIdx := strings.Index(normalized, stateBlockStart)
 	if startIdx == -1 {