savepoint 1.0.0

package/internal/data/parser.go

@@ -0,0 +1,189 @@
+package data
+
+import (
+	"fmt"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+)
+
+type Parser struct{}
+
+func NewParser() *Parser {
+	return &Parser{}
+}
+
+func (p *Parser) ParseFrontmatter(content string) (map[string]any, error) {
+	frontmatter, err := extractFrontmatter(content)
+	if err != nil {
+		return nil, err
+	}
+
+	var result map[string]any
+	if err := yaml.Unmarshal([]byte(frontmatter), &result); err != nil {
+		return nil, fmt.Errorf("failed to parse YAML: %w", err)
+	}
+
+	return result, nil
+}
+
+func (p *Parser) ParseTaskFile(path string, content string) (*Task, error) {
+	frontmatter, err := extractFrontmatter(content)
+	if err != nil {
+		return nil, fmt.Errorf("parse error for %s: %w", path, err)
+	}
+
+	var fields taskFrontmatter
+	if err := yaml.Unmarshal([]byte(frontmatter), &fields); err != nil {
+		return nil, fmt.Errorf("parse error for %s: failed to parse YAML: %w", path, err)
+	}
+
+	rawColumn := firstColumn(fields.Column, fields.Status)
+	task := &Task{
+		ID:          fields.ID,
+		Title:       firstNonEmpty(fields.Title, fields.Objective),
+		Description: fields.Description,
+		Epic:        firstNonEmpty(fields.Epic, extractEpicFromID(fields.ID)),
+		Release:     firstNonEmpty(fields.Release, "v1"),
+		Column:      normalizeColumn(rawColumn),
+		Stage:       firstStage(fields.Stage, fields.Phase),
+		Priority:    fields.Priority,
+		Points:      fields.Points,
+		Tags:        fields.Tags,
+		Acceptance:  firstList(fields.Acceptance, extractChecklistSection(content, "## Acceptance Criteria")),
+		Checklist:   extractChecklistSection(content, "## Implementation Plan"),
+		Notes:       fields.Notes,
+		DependsOn:   fields.DependsOn,
+		Progress:    fields.Progress,
+	}
+
+	if err := validateParsedTaskLifecycle(rawColumn, *task); err != nil {
+		return nil, fmt.Errorf("parse error for %s: %w", path, err)
+	}
+
+	return task, nil
+}
+
+type taskFrontmatter struct {
+	ID          string        `yaml:"id"`
+	Title       string        `yaml:"title"`
+	Objective   string        `yaml:"objective"`
+	Description string        `yaml:"description"`
+	Epic        string        `yaml:"epic"`
+	Release     string        `yaml:"release"`
+	Status      ColumnType    `yaml:"status"`
+	Column      ColumnType    `yaml:"column"`
+	Phase       ProgressStage `yaml:"phase"`
+	Stage       ProgressStage `yaml:"stage"`
+	Priority    string        `yaml:"priority"`
+	Points      int           `yaml:"points"`
+	Tags        []string      `yaml:"tags"`
+	Acceptance  []string      `yaml:"acceptance"`
+	Notes       string        `yaml:"notes"`
+	DependsOn   []string      `yaml:"depends_on"`
+	Progress    Progress      `yaml:"progress"`
+}
+
+func extractFrontmatter(content string) (string, error) {
+	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	if !strings.HasPrefix(normalized, "---\n") {
+		return "", ErrNoFrontmatter
+	}
+
+	end := strings.Index(normalized[len("---\n"):], "\n---")
+	if end == -1 {
+		return "", ErrNoClosingFrontmatter
+	}
+
+	return strings.TrimSpace(normalized[len("---\n") : len("---\n")+end]), nil
+}
+
+func extractEpicFromID(id string) string {
+	parts := strings.Split(id, "/")
+	if len(parts) >= 1 {
+		return parts[0]
+	}
+	return ""
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func firstColumn(values ...ColumnType) ColumnType {
+	for _, value := range values {
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func normalizeColumn(value ColumnType) ColumnType {
+	switch value {
+	case "", legacyTodoColumn:
+		return ColumnPlanned
+	case ColumnPlanned, ColumnInProgress, ColumnDone:
+		return value
+	default:
+		return value
+	}
+}
+
+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 ValidateTaskLifecycle(task)
+}
+
+func firstStage(values ...ProgressStage) ProgressStage {
+	for _, value := range values {
+		if value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func firstList(values ...[]string) []string {
+	for _, value := range values {
+		if len(value) > 0 {
+			return value
+		}
+	}
+	return nil
+}
+
+func extractChecklistSection(content, heading string) []string {
+	normalized := strings.ReplaceAll(content, "\r\n", "\n")
+	start := strings.Index(normalized, heading)
+	if start == -1 {
+		return nil
+	}
+
+	section := normalized[start+len(heading):]
+	if next := strings.Index(section, "\n## "); next != -1 {
+		section = section[:next]
+	}
+
+	items := []string{}
+	for _, line := range strings.Split(section, "\n") {
+		trimmed := strings.TrimSpace(line)
+		if strings.HasPrefix(trimmed, "- [ ] ") || strings.HasPrefix(trimmed, "- [x] ") {
+			items = append(items, strings.TrimSpace(trimmed[6:]))
+			continue
+		}
+		if strings.HasPrefix(trimmed, "- ") {
+			items = append(items, strings.TrimSpace(trimmed[2:]))
+		}
+	}
+	return items
+}

package/internal/data/parser_test.go

@@ -0,0 +1,216 @@
+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_rejectsPhaseOutsideInProgress(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.Fatal("ParseTaskFile() expected invalid phase/status error")
+	}
+}
+
+func TestParseTaskFile_rejectsInProgressWithoutPhase(t *testing.T) {
+	p := NewParser()
+	content := `---
+id: E06/T001
+status: in_progress
+objective: "Style the board"
+---
+
+# Task`
+
+	_, err := p.ParseTaskFile("test.md", content)
+	if err == nil {
+		t.Fatal("ParseTaskFile() expected missing phase error")
+	}
+}
+
+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 || task.Checklist[0] != "First checklist item." || task.Checklist[1] != "Second checklist item." {
+		t.Errorf("Task.Checklist = %v, want markdown checklist", task.Checklist)
+	}
+}

package/internal/data/router.go

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,46 @@
+package data
+
+import "fmt"
+
+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"`
+	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   []string      `yaml:"checklist,omitempty"`
+	Notes       string        `yaml:"notes,omitempty"`
+	DependsOn   []string      `yaml:"depends_on,omitempty"`
+	Progress    Progress      `yaml:"progress,omitempty"`
+}
+
+func (t Task) String() string {
+	return fmt.Sprintf("Task(%s)", t.ID)
+}

package/internal/data/task_test.go

@@ -0,0 +1,51 @@
+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)
+		}
+	}
+}