savepoint 1.0.3 → 1.0.6

package/internal/data/discover.go

@@ -1,178 +0,0 @@
-package data
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-)
-
-type ReleaseInfo struct {
-	ID    string
-	Path  string
-	Epics []EpicInfo
-}
-
-type EpicInfo struct {
-	ID    string
-	Path  string
-	Tasks []TaskInfo
-}
-
-type TaskInfo struct {
-	ID   string
-	Path string
-}
-
-type Discover struct{}
-
-func NewDiscover() *Discover {
-	return &Discover{}
-}
-
-func (d *Discover) FindSavepointRoot(start string) (string, error) {
-	dir, err := filepath.Abs(start)
-	if err != nil {
-		return "", err
-	}
-
-	for {
-		savepointPath := filepath.Join(dir, ".savepoint")
-		info, err := os.Stat(savepointPath)
-		if err == nil && info.IsDir() {
-			return savepointPath, nil
-		}
-
-		parent := filepath.Dir(dir)
-		if parent == dir {
-			return "", ErrSavepointDirectoryMissing
-		}
-		dir = parent
-	}
-}
-
-func (d *Discover) ListReleases(root string) ([]ReleaseInfo, error) {
-	releasesPath := filepath.Join(root, "releases")
-	info, err := os.Stat(releasesPath)
-	if err != nil {
-		return nil, fmt.Errorf("releases directory not found: %w", err)
-	}
-	if !info.IsDir() {
-		return nil, fmt.Errorf("releases is not a directory")
-	}
-
-	entries, err := os.ReadDir(releasesPath)
-	if err != nil {
-		return nil, err
-	}
-
-	var releases []ReleaseInfo
-	for _, entry := range entries {
-		if !entry.IsDir() {
-			continue
-		}
-		id := entry.Name()
-		releases = append(releases, ReleaseInfo{
-			ID:   id,
-			Path: filepath.Join(releasesPath, id),
-		})
-	}
-
-	sort.Slice(releases, func(i, j int) bool {
-		return releases[i].ID < releases[j].ID
-	})
-	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)
-	if err != nil {
-		return nil, fmt.Errorf("epics directory not found: %w", err)
-	}
-	if !info.IsDir() {
-		return nil, fmt.Errorf("epics is not a directory")
-	}
-
-	entries, err := os.ReadDir(epicsPath)
-	if err != nil {
-		return nil, err
-	}
-
-	var epics []EpicInfo
-	for _, entry := range entries {
-		if !entry.IsDir() || strings.HasPrefix(entry.Name(), "_") {
-			continue
-		}
-		id := entry.Name()
-		epics = append(epics, EpicInfo{
-			ID:   id,
-			Path: filepath.Join(epicsPath, id),
-		})
-	}
-
-	sort.Slice(epics, func(i, j int) bool {
-		return epics[i].ID < epics[j].ID
-	})
-	return epics, nil
-}
-
-func (d *Discover) ListTasks(root, release, epic string) ([]TaskInfo, error) {
-	tasksPath := filepath.Join(root, "releases", release, "epics", epic, "tasks")
-	info, err := os.Stat(tasksPath)
-	if err != nil {
-		return nil, fmt.Errorf("tasks directory not found: %w", err)
-	}
-	if !info.IsDir() {
-		return nil, fmt.Errorf("tasks is not a directory")
-	}
-
-	entries, err := os.ReadDir(tasksPath)
-	if err != nil {
-		return nil, err
-	}
-
-	var tasks []TaskInfo
-	for _, entry := range entries {
-		if entry.IsDir() || filepath.Ext(entry.Name()) != ".md" {
-			continue
-		}
-		id := entry.Name()[:len(entry.Name())-3]
-		tasks = append(tasks, TaskInfo{
-			ID:   id,
-			Path: filepath.Join(tasksPath, entry.Name()),
-		})
-	}
-
-	sort.Slice(tasks, func(i, j int) bool {
-		return tasks[i].ID < tasks[j].ID
-	})
-	return tasks, nil
-}

package/internal/data/discover_test.go

@@ -1,130 +0,0 @@
-package data
-
-import (
-	"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")
-	testutil.MkdirAll(t, start)
-
-	root, err := d.FindSavepointRoot(start)
-	if err != nil {
-		t.Fatalf("FindSavepointRoot() error = %v", err)
-	}
-	if root != savepointRoot {
-		t.Errorf("FindSavepointRoot() = %v, want %v", root, savepointRoot)
-	}
-}
-
-func TestListReleases(t *testing.T) {
-	d := NewDiscover()
-	root := createDiscoveryFixture(t)
-
-	releases, err := d.ListReleases(root)
-	if err != nil {
-		t.Fatalf("ListReleases() error = %v", err)
-	}
-
-	if len(releases) != 2 {
-		t.Fatalf("ListReleases() returned %d releases, want 2", len(releases))
-	}
-	if releases[0].ID != "v1" || releases[1].ID != "v2" {
-		t.Errorf("ListReleases() IDs = %v, want [v1 v2]", []string{releases[0].ID, releases[1].ID})
-	}
-}
-
-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)
-
-	epics, err := d.ListEpics(root, "v1")
-	if err != nil {
-		t.Fatalf("ListEpics() error = %v", err)
-	}
-
-	if len(epics) != 2 {
-		t.Fatalf("ListEpics() returned %d epics, want 2", len(epics))
-	}
-	if epics[0].ID != "E01-go-setup" || epics[1].ID != "E02-data-readers" {
-		t.Errorf("ListEpics() IDs = %v, want [E01-go-setup E02-data-readers]", []string{epics[0].ID, epics[1].ID})
-	}
-}
-
-func TestListTasks(t *testing.T) {
-	d := NewDiscover()
-	root := createDiscoveryFixture(t)
-
-	tasks, err := d.ListTasks(root, "v1", "E02-data-readers")
-	if err != nil {
-		t.Fatalf("ListTasks() error = %v", err)
-	}
-
-	if len(tasks) != 2 {
-		t.Fatalf("ListTasks() returned %d tasks, want 2", len(tasks))
-	}
-	if tasks[0].ID != "T001-task-struct" || tasks[1].ID != "T002-frontmatter-parser" {
-		t.Errorf("ListTasks() IDs = %v, want [T001-task-struct T002-frontmatter-parser]", []string{tasks[0].ID, tasks[1].ID})
-	}
-}
-
-func createDiscoveryFixture(t *testing.T) string {
-	t.Helper()
-
-	root := t.TempDir()
-	savepointRoot := filepath.Join(root, ".savepoint")
-	paths := []string{
-		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks"),
-		filepath.Join(savepointRoot, "releases", "v1", "epics", "E01-go-setup", "tasks"),
-		filepath.Join(savepointRoot, "releases", "v1", "epics", "_archived"),
-		filepath.Join(savepointRoot, "releases", "v2", "epics"),
-	}
-	for _, path := range paths {
-		testutil.MkdirAll(t, path)
-	}
-
-	files := []string{
-		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "T002-frontmatter-parser.md"),
-		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "T001-task-struct.md"),
-		filepath.Join(savepointRoot, "releases", "v1", "epics", "E02-data-readers", "tasks", "notes.txt"),
-	}
-	for _, file := range files {
-		testutil.WriteFile(t, file, "test")
-	}
-
-	return savepointRoot
-}

package/internal/data/errors.go

@@ -1,13 +0,0 @@
-package data
-
-import "errors"
-
-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

@@ -1,44 +0,0 @@
-package data
-
-import "fmt"
-
-func ValidateTaskLifecycle(task *Task) error {
-	if !IsCanonicalColumn(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 {
-		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.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
-}
-
-func IsCanonicalColumn(value ColumnType) bool {
-	switch value {
-	case ColumnPlanned, ColumnInProgress, ColumnDone:
-		return true
-	default:
-		return false
-	}
-}
-
-func IsCanonicalStage(value ProgressStage) bool {
-	switch value {
-	case StageBuild, StageTest, StageAudit:
-		return true
-	default:
-		return false
-	}
-}

package/internal/data/lifecycle_test.go

@@ -1,41 +0,0 @@
-package data
-
-import "testing"
-
-func TestValidateTaskLifecycle_allowsPlannedWithoutPhase(t *testing.T) {
-	task := Task{Column: ColumnPlanned}
-	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 {
-		t.Fatalf("ValidateTaskLifecycle() error = %v", err)
-	}
-}
-
-func TestValidateTaskLifecycle_rejectsUnknownStatus(t *testing.T) {
-	task := Task{Column: "review"}
-	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 {
-		t.Fatal("ValidateTaskLifecycle() expected phase/status error")
-	}
-}

package/internal/data/parser.go

@@ -1,242 +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 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 := 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
-}