savepoint 1.0.4 → 1.0.7

package/internal/data/parser.go

@@ -1,243 +0,0 @@
-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.Phase, fields.Stage),
-		Priority:    fields.Priority,
-		Points:      fields.Points,
-		Tags:        fields.Tags,
-		Acceptance:  firstList(fields.Acceptance, extractChecklistSection(content, "## Acceptance Criteria")),
-		Checklist:   extractChecklistItems(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)
-	}
-
-	if task.Column == ColumnInProgress && task.Stage == "" {
-		task.Stage = StageBuild
-	}
-
-	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"`
-}
-
-// 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 := normalizeLineEndings(content)
-	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. 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)
-	}
-	if task.Column != ColumnInProgress && task.Stage != "" {
-		return nil
-	}
-	return nil
-}
-
-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 extractChecklistItems(content, heading string) []CheckItem {
-	normalized := normalizeLineEndings(content)
-	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 := []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 := normalizeLineEndings(content)
-	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

@@ -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)
-}