savepoint 1.0.3 → 1.0.6

package/internal/data/parser_test.go

@@ -1,281 +0,0 @@
-package data
-
-import (
-	"testing"
-)
-
-func TestParseFrontmatter(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E01/T001
-status: done
-objective: "Test objective"
-depends_on: []
----
-
-body content here`
-
-	result, err := p.ParseFrontmatter(content)
-	if err != nil {
-		t.Fatalf("ParseFrontmatter() error = %v", err)
-	}
-
-	if result["id"] != "E01/T001" {
-		t.Errorf("ParseFrontmatter() id = %v, want E01/T001", result["id"])
-	}
-	if result["objective"] != "Test objective" {
-		t.Errorf("ParseFrontmatter() objective = %v, want Test objective", result["objective"])
-	}
-}
-
-func TestParseFrontmatterMissing(t *testing.T) {
-	p := NewParser()
-	content := `# No frontmatter here`
-
-	_, err := p.ParseFrontmatter(content)
-	if err == nil {
-		t.Error("ParseFrontmatter() expected error for missing frontmatter")
-	}
-}
-
-func TestParseFrontmatterMalformedYAML(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: [broken
----
-
-# Task description`
-
-	_, err := p.ParseFrontmatter(content)
-	if err == nil {
-		t.Fatal("ParseFrontmatter() expected malformed YAML error")
-	}
-}
-
-func TestParseTaskFile(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E02/T001
-status: in_progress
-phase: test
-objective: "Define Task struct"
-description: "Build the task model"
-priority: high
-points: 3
-tags: [data, parser]
-acceptance:
-  - parses metadata
-notes: "Keep it small"
-depends_on: [E01/T003]
----
-
-# Task description`
-
-	task, err := p.ParseTaskFile("test.md", content)
-	if err != nil {
-		t.Fatalf("ParseTaskFile() error = %v", err)
-	}
-
-	if task.ID != "E02/T001" {
-		t.Errorf("Task.ID = %v, want E02/T001", task.ID)
-	}
-	if task.Title != "Define Task struct" {
-		t.Errorf("Task.Title = %v, want Define Task struct", task.Title)
-	}
-	if task.Epic != "E02" {
-		t.Errorf("Task.Epic = %v, want E02", task.Epic)
-	}
-	if task.Release != "v1" {
-		t.Errorf("Task.Release = %v, want v1", task.Release)
-	}
-	if task.Column != ColumnInProgress {
-		t.Errorf("Task.Column = %v, want %v", task.Column, ColumnInProgress)
-	}
-	if task.Stage != StageTest {
-		t.Errorf("Task.Stage = %v, want %v", task.Stage, StageTest)
-	}
-	if len(task.DependsOn) != 1 || task.DependsOn[0] != "E01/T003" {
-		t.Errorf("Task.DependsOn = %v, want [E01/T003]", task.DependsOn)
-	}
-	if task.Priority != "high" || task.Points != 3 {
-		t.Errorf("Task priority/points = %v/%v, want high/3", task.Priority, task.Points)
-	}
-	if len(task.Tags) != 2 || task.Tags[0] != "data" || task.Tags[1] != "parser" {
-		t.Errorf("Task.Tags = %v, want [data parser]", task.Tags)
-	}
-	if len(task.Acceptance) != 1 || task.Acceptance[0] != "parses metadata" {
-		t.Errorf("Task.Acceptance = %v, want [parses metadata]", task.Acceptance)
-	}
-	if task.Notes != "Keep it small" {
-		t.Errorf("Task.Notes = %v, want Keep it small", task.Notes)
-	}
-}
-
-func TestParseTaskFile_normalizesLegacyTodoStatusToPlanned(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E06/T001
-status: todo
-objective: "Style the board"
----
-
-# Task`
-
-	task, err := p.ParseTaskFile("test.md", content)
-	if err != nil {
-		t.Fatalf("ParseTaskFile() error = %v", err)
-	}
-	if task.Column != ColumnPlanned {
-		t.Errorf("Task.Column = %v, want %v", task.Column, ColumnPlanned)
-	}
-}
-
-func TestParseTaskFile_rejectsUnknownStatus(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E06/T001
-status: review
-objective: "Style the board"
----
-
-# Task`
-
-	_, err := p.ParseTaskFile("test.md", content)
-	if err == nil {
-		t.Fatal("ParseTaskFile() expected unknown status error")
-	}
-}
-
-func TestParseTaskFile_allowsPhaseOutsideInProgress(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E06/T001
-status: planned
-phase: build
-objective: "Style the board"
----
-
-# Task`
-
-	_, err := p.ParseTaskFile("test.md", content)
-	if err != nil {
-		t.Fatalf("ParseTaskFile() error = %v, want no error for legacy phase field", err)
-	}
-}
-
-func TestParseTaskFile_includesDefaultBuildForInProgress(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E06/T001
-status: in_progress
-objective: "Style the board"
----
-
-# Task`
-
-	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)
-	}
-}
-
-func TestParseTaskFile_extractsMarkdownAcceptanceAndChecklist(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E06/T001
-status: planned
-objective: "Style the board"
----
-
-# Task
-
-## Acceptance Criteria
-
-- First criterion.
-- Second criterion.
-
-## Implementation Plan
-
-- [ ] First checklist item.
-- [x] Second checklist item.
-
-## Context Log
-
-Notes here.`
-
-	task, err := p.ParseTaskFile("test.md", content)
-	if err != nil {
-		t.Fatalf("ParseTaskFile() error = %v", err)
-	}
-	if len(task.Acceptance) != 2 || task.Acceptance[0] != "First criterion." || task.Acceptance[1] != "Second criterion." {
-		t.Errorf("Task.Acceptance = %v, want markdown criteria", task.Acceptance)
-	}
-	if len(task.Checklist) != 2 {
-		t.Fatalf("Task.Checklist len = %d, want 2", len(task.Checklist))
-	}
-	if task.Checklist[0].Text != "First checklist item." || task.Checklist[0].Done {
-		t.Errorf("Task.Checklist[0] = %+v, want {Text:\"First checklist item.\", Done:false}", task.Checklist[0])
-	}
-	if task.Checklist[1].Text != "Second checklist item." || !task.Checklist[1].Done {
-		t.Errorf("Task.Checklist[1] = %+v, want {Text:\"Second checklist item.\", Done:true}", task.Checklist[1])
-	}
-}
-
-func TestParseTaskFile_joinsHardWrappedChecklistItems(t *testing.T) {
-	p := NewParser()
-	content := `---
-id: E06/T001
-status: planned
-objective: "Style the board"
----
-
-# Task
-
-## Implementation Plan
-
-- [ ] First sentence spans across a hard markdown line break
-  before it ends. Second sentence stays in the same checklist item.
-- [x] Already checked sentence wraps
-  without becoming another checklist item.
-`
-
-	task, err := p.ParseTaskFile("test.md", content)
-	if err != nil {
-		t.Fatalf("ParseTaskFile() error = %v", err)
-	}
-	if len(task.Checklist) != 2 {
-		t.Fatalf("Task.Checklist len = %d, want 2", len(task.Checklist))
-	}
-	wantFirst := "First sentence spans across a hard markdown line break before it ends. Second sentence stays in the same checklist item."
-	if task.Checklist[0].Text != wantFirst || task.Checklist[0].Done {
-		t.Errorf("Task.Checklist[0] = %+v, want text %q and Done=false", task.Checklist[0], wantFirst)
-	}
-	wantSecond := "Already checked sentence wraps without becoming another checklist item."
-	if task.Checklist[1].Text != wantSecond || !task.Checklist[1].Done {
-		t.Errorf("Task.Checklist[1] = %+v, want text %q and Done=true", task.Checklist[1], wantSecond)
-	}
-}

package/internal/data/router.go

@@ -1,52 +0,0 @@
-package data
-
-import (
-	"fmt"
-	"strings"
-
-	"gopkg.in/yaml.v3"
-)
-
-const stateBlockStart = "## Current state"
-const stateBlockEnd = "```"
-
-type RouterState struct {
-	State      string `yaml:"state"`
-	Release   string `yaml:"release"`
-	Epic      string `yaml:"epic"`
-	Task      string `yaml:"task"`
-	NextAction string `yaml:"next_action"`
-}
-
-type RouterReader struct{}
-
-func NewRouterReader() *RouterReader {
-	return &RouterReader{}
-}
-
-func (r *RouterReader) ReadState(content string) (*RouterState, error) {
-	startIdx := strings.Index(content, stateBlockStart)
-	if startIdx == -1 {
-		return nil, fmt.Errorf("no Current state block found")
-	}
-
-	yamlStart := strings.Index(content[startIdx:], "```yaml")
-	if yamlStart == -1 {
-		return nil, fmt.Errorf("no yaml code block found")
-	}
-
-	yamlStart += startIdx + len("```yaml")
-	yamlEnd := strings.Index(content[yamlStart:], "```")
-	if yamlEnd == -1 {
-		return nil, fmt.Errorf("no closing code block found")
-	}
-
-	yamlContent := strings.TrimSpace(content[yamlStart : yamlStart+yamlEnd])
-
-	var state RouterState
-	if err := yaml.Unmarshal([]byte(yamlContent), &state); err != nil {
-		return nil, fmt.Errorf("failed to parse router YAML: %w", err)
-	}
-
-	return &state, nil
-}

package/internal/data/router_test.go

@@ -1,35 +0,0 @@
-package data
-
-import (
-	"testing"
-)
-
-func TestRouterReaderReadState(t *testing.T) {
-	r := NewRouterReader()
-	content := "## Current state\n\n```yaml\nstate: building\nrelease: v1\nepic: E01-go-setup\ntask: E01-go-setup/T002-entrypoint\nnext_action: \"Start T002-entrypoint\"\n```\n"
-
-	state, err := r.ReadState(content)
-	if err != nil {
-		t.Fatalf("ReadState() error = %v", err)
-	}
-
-	if state.State != "building" {
-		t.Errorf("State = %v, want building", state.State)
-	}
-	if state.Epic != "E01-go-setup" {
-		t.Errorf("Epic = %v, want E01-go-setup", state.Epic)
-	}
-	if state.Task != "E01-go-setup/T002-entrypoint" {
-		t.Errorf("Task = %v, want E01-go-setup/T002-entrypoint", state.Task)
-	}
-}
-
-func TestRouterReaderMissing(t *testing.T) {
-	r := NewRouterReader()
-	content := "# No state block here"
-
-	_, err := r.ReadState(content)
-	if err == nil {
-		t.Error("ReadState() expected error for missing state block")
-	}
-}

package/internal/data/task.go

@@ -1,57 +0,0 @@
-package data
-
-import (
-	"fmt"
-	"time"
-)
-
-type CheckItem struct {
-	Text string
-	Done bool
-}
-
-type ColumnType string
-
-const (
-	ColumnPlanned    ColumnType = "planned"
-	ColumnInProgress ColumnType = "in_progress"
-	ColumnDone       ColumnType = "done"
-)
-
-type ProgressStage string
-
-const (
-	StageBuild ProgressStage = "build"
-	StageTest  ProgressStage = "test"
-	StageAudit ProgressStage = "audit"
-)
-
-type Progress struct {
-	Stage   ProgressStage `yaml:"stage"`
-	Started bool          `yaml:"started"`
-}
-
-type Task struct {
-	ID          string        `yaml:"id"`
-	Title       string        `yaml:"title"`
-	Description string        `yaml:"description,omitempty"`
-	Status      string        `yaml:"status,omitempty"`
-	Epic        string        `yaml:"epic"`
-	Release     string        `yaml:"release"`
-	Column      ColumnType    `yaml:"column"`
-	Stage       ProgressStage `yaml:"stage,omitempty"`
-	Priority    string        `yaml:"priority,omitempty"`
-	Points      int           `yaml:"points,omitempty"`
-	Tags        []string      `yaml:"tags,omitempty"`
-	Acceptance  []string      `yaml:"acceptance,omitempty"`
-	Checklist   []CheckItem   `yaml:"checklist,omitempty"`
-	Notes       string        `yaml:"notes,omitempty"`
-	DependsOn   []string      `yaml:"depends_on,omitempty"`
-	Progress    Progress      `yaml:"progress,omitempty"`
-	Path        string        `yaml:"-"`
-	Mtime       time.Time     `yaml:"-"`
-}
-
-func (t Task) String() string {
-	return fmt.Sprintf("Task(%s)", t.ID)
-}

package/internal/data/task_test.go

@@ -1,51 +0,0 @@
-package data
-
-import (
-	"testing"
-)
-
-func TestTaskString(t *testing.T) {
-	task := Task{
-		ID:      "E01/T001",
-		Title:   "Test Task",
-		Column:  ColumnPlanned,
-	}
-	want := "Task(E01/T001)"
-	if got := task.String(); got != want {
-		t.Errorf("Task.String() = %v, want %v", got, want)
-	}
-}
-
-func TestColumnTypes(t *testing.T) {
-	tests := []struct {
-		input ColumnType
-		want  string
-	}{
-		{ColumnPlanned, "planned"},
-		{ColumnInProgress, "in_progress"},
-		{ColumnDone, "done"},
-	}
-
-	for _, tt := range tests {
-		if string(tt.input) != tt.want {
-			t.Errorf("ColumnType = %v, want %v", tt.input, tt.want)
-		}
-	}
-}
-
-func TestProgressStage(t *testing.T) {
-	tests := []struct {
-		input ProgressStage
-		want  string
-	}{
-		{StageBuild, "build"},
-		{StageTest, "test"},
-		{StageAudit, "audit"},
-	}
-
-	for _, tt := range tests {
-		if string(tt.input) != tt.want {
-			t.Errorf("ProgressStage = %v, want %v", tt.input, tt.want)
-		}
-	}
-}

package/internal/data/write.go

@@ -1,218 +0,0 @@
-package data
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"gopkg.in/yaml.v3"
-)
-
-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)
-	raw, err := extractFrontmatter(normalized)
-	if err != nil {
-		return "", "", err
-	}
-	delimLen := 4
-	bodyStart := delimLen + len(raw) + delimLen
-	body = ""
-	if bodyStart < len(normalized) {
-		body = normalized[bodyStart:]
-	}
-	return raw, 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 {
-		return err
-	}
-
-	fi, err := os.Stat(path)
-	if err != nil {
-		return fmt.Errorf("stat %s: %w", path, err)
-	}
-
-	if !fi.ModTime().Equal(expectedMtime) {
-		return ErrMtimeConflict
-	}
-
-	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, "status", string(task.Column))
-
-	if task.Stage == "" {
-		removeMappingField(mapping, "phase")
-		removeMappingField(mapping, "stage")
-	} else {
-		setMappingField(mapping, "phase", string(task.Stage))
-		removeMappingField(mapping, "stage")
-	}
-
-	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 setMappingField(mapping *yaml.Node, key, value string) {
-	for i := 0; i < len(mapping.Content)-1; i += 2 {
-		if mapping.Content[i].Value == key {
-			mapping.Content[i+1].Value = value
-			mapping.Content[i+1].Tag = "!!str"
-			return
-		}
-	}
-	keyNode := &yaml.Node{Kind: yaml.ScalarNode, Value: key, Tag: "!!str"}
-	valNode := &yaml.Node{Kind: yaml.ScalarNode, Value: value, Tag: "!!str"}
-	mapping.Content = append(mapping.Content, keyNode, valNode)
-}
-
-func removeMappingField(mapping *yaml.Node, key string) {
-	for i := 0; i < len(mapping.Content)-1; i += 2 {
-		if mapping.Content[i].Value == key {
-			mapping.Content = append(mapping.Content[:i], mapping.Content[i+2:]...)
-			return
-		}
-	}
-}
-
-func WriteRouterState(root string, state *RouterState, expectedMtime time.Time) error {
-	path := filepath.Join(root, "router.md")
-	fi, err := os.Stat(path)
-	if err != nil {
-		return fmt.Errorf("stat %s: %w", path, err)
-	}
-
-	if !fi.ModTime().Equal(expectedMtime) {
-		return ErrMtimeConflict
-	}
-
-	content, err := os.ReadFile(path)
-	if err != nil {
-		return fmt.Errorf("read %s: %w", path, err)
-	}
-
-	normalized := normalizeLineEndings(string(content))
-
-	startIdx := strings.Index(normalized, stateBlockStart)
-	if startIdx == -1 {
-		return fmt.Errorf("no Current state block found")
-	}
-
-	yamlStart := strings.Index(normalized[startIdx:], "```yaml")
-	if yamlStart == -1 {
-		return fmt.Errorf("no yaml code block found")
-	}
-
-	yamlStart += startIdx + len("```yaml")
-	yamlEnd := strings.Index(normalized[yamlStart:], "```")
-	if yamlEnd == -1 {
-		return fmt.Errorf("no closing code block found")
-	}
-
-	out, err := yaml.Marshal(state)
-	if err != nil {
-		return fmt.Errorf("marshal yaml: %w", err)
-	}
-
-	newContent := normalized[:yamlStart] + "\n" + strings.TrimSpace(string(out)) + "\n" + normalized[yamlStart+yamlEnd:]
-
-	return os.WriteFile(path, []byte(newContent), 0644)
-}