savepoint 1.0.3 → 1.0.6

package/internal/doctor/checks.go

@@ -1,567 +0,0 @@
-package doctor
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/opencode/savepoint/internal/data"
-	"gopkg.in/yaml.v3"
-)
-
-// CheckConfig validates config.yml: exists, valid YAML, required fields present.
-func CheckConfig(root string) error {
-	configPath := filepath.Join(root, "config.yml")
-	raw, err := os.ReadFile(configPath)
-	if os.IsNotExist(err) {
-		return fmt.Errorf("config.yml not found: %w", data.ErrConfigNotFound)
-	}
-	if err != nil {
-		return fmt.Errorf("config.yml unreadable: %w", err)
-	}
-
-	var fields map[string]any
-	if err := yaml.Unmarshal(raw, &fields); err != nil {
-		return fmt.Errorf("config.yml invalid YAML: %w", err)
-	}
-
-	if _, ok := fields["quality_gates"]; !ok {
-		return fmt.Errorf("config.yml missing required field: quality_gates")
-	}
-	if _, ok := fields["theme"]; !ok {
-		return fmt.Errorf("config.yml missing required field: theme")
-	}
-
-	return nil
-}
-
-// CheckRouter validates router.md: valid state name, release/epic directories exist.
-// epicFilter, if non-empty, skips directory checks when the router epic doesn't match.
-func CheckRouter(root, epicFilter string, overrides ...DoctorDependencies) error {
-	deps := doctorDependencies(overrides)
-	routerPath := filepath.Join(root, "router.md")
-	raw, err := os.ReadFile(routerPath)
-	if os.IsNotExist(err) {
-		return fmt.Errorf("router.md not found: %w", data.ErrConfigNotFound)
-	}
-	if err != nil {
-		return fmt.Errorf("router.md unreadable: %w", err)
-	}
-
-	state, err := deps.RouterReader.ReadState(string(raw))
-	if err != nil {
-		return fmt.Errorf("router.md invalid state block: %w", err)
-	}
-
-	if epicFilter != "" && state.Epic != epicFilter {
-		return nil
-	}
-
-	if state.Release != "" && state.Release != "none" {
-		releasePath := filepath.Join(root, "releases", state.Release)
-		if _, err := os.Stat(releasePath); os.IsNotExist(err) {
-			return fmt.Errorf("router.md release %q directory not found", state.Release)
-		}
-	}
-
-	if state.Epic != "" && state.Epic != "none" {
-		if state.Release == "" || state.Release == "none" {
-			return fmt.Errorf("router.md has epic %q but no release", state.Epic)
-		}
-		epicPath := filepath.Join(root, "releases", state.Release, "epics", state.Epic)
-		if _, err := os.Stat(epicPath); os.IsNotExist(err) {
-			return fmt.Errorf("router.md epic %q directory not found", state.Epic)
-		}
-	}
-
-	return nil
-}
-
-// Problem describes a single issue found during a structure check.
-type Problem struct {
-	File    string
-	Line    int
-	Message string
-}
-
-func (p Problem) Error() string {
-	if p.Line > 0 {
-		return fmt.Sprintf("%s:%d: %s", p.File, p.Line, p.Message)
-	}
-	if p.File != "" {
-		return fmt.Sprintf("%s: %s", p.File, p.Message)
-	}
-	return p.Message
-}
-
-// CheckStructure validates release/epic/task structure and YAML across the project.
-// epicFilter, if non-empty, restricts checks to matching epics.
-func CheckStructure(root string, epicFilter string, overrides ...DoctorDependencies) []Problem {
-	deps := doctorDependencies(overrides)
-	var problems []Problem
-
-	releasesPath := filepath.Join(root, "releases")
-	if _, err := os.Stat(releasesPath); os.IsNotExist(err) {
-		problems = append(problems, Problem{File: releasesPath, Message: "releases directory not found"})
-		return problems
-	}
-
-	releases, err := deps.Discoverer.ListReleases(root)
-	if err != nil {
-		problems = append(problems, Problem{File: releasesPath, Message: fmt.Sprintf("listing releases: %v", err)})
-		return problems
-	}
-
-	if len(releases) == 0 {
-		problems = append(problems, Problem{File: releasesPath, Message: "no release directories found"})
-		return problems
-	}
-
-	for _, release := range releases {
-		checkReleasePRD(release.Path, release.ID, deps.Parser, &problems)
-
-		epics, err := deps.Discoverer.ListEpics(root, release.ID)
-		if err != nil {
-			problems = append(problems, Problem{
-				File:    filepath.Join(release.Path, "epics"),
-				Message: fmt.Sprintf("listing epics in release %q: %v", release.ID, err),
-			})
-			continue
-		}
-
-		for _, epic := range epics {
-			if epicFilter != "" && epic.ID != epicFilter && !strings.HasPrefix(epic.ID, epicFilter) {
-				continue
-			}
-
-			checkEpicDetail(epic.Path, epic.ID, deps.Parser, &problems)
-
-			tasks, err := deps.Discoverer.ListTasks(root, release.ID, epic.ID)
-			if err != nil {
-				problems = append(problems, Problem{
-					File:    filepath.Join(epic.Path, "tasks"),
-					Message: fmt.Sprintf("listing tasks in epic %q: %v", epic.ID, err),
-				})
-				continue
-			}
-
-			for _, task := range tasks {
-				checkTaskFile(task.Path, deps.Parser, &problems)
-			}
-		}
-	}
-
-	return problems
-}
-
-func checkReleasePRD(releasePath string, releaseID string, parser taskParser, problems *[]Problem) {
-	prdPath := filepath.Join(releasePath, releaseID+"-PRD.md")
-	raw, err := os.ReadFile(prdPath)
-	if os.IsNotExist(err) {
-		*problems = append(*problems, Problem{File: prdPath, Message: "release PRD file not found"})
-		return
-	}
-	if err != nil {
-		*problems = append(*problems, Problem{File: prdPath, Message: fmt.Sprintf("unreadable: %v", err)})
-		return
-	}
-	validateFrontmatter(prdPath, string(raw), parser, problems)
-}
-
-func checkEpicDetail(epicPath string, epicID string, parser taskParser, problems *[]Problem) {
-	prefix := extractPrefix(epicID)
-	detailPath := filepath.Join(epicPath, prefix+"-Detail.md")
-	raw, err := os.ReadFile(detailPath)
-	if os.IsNotExist(err) {
-		*problems = append(*problems, Problem{File: detailPath, Message: "epic detail file not found"})
-		return
-	}
-	if err != nil {
-		*problems = append(*problems, Problem{File: detailPath, Message: fmt.Sprintf("unreadable: %v", err)})
-		return
-	}
-	validateFrontmatter(detailPath, string(raw), parser, problems)
-}
-
-func extractPrefix(epicID string) string {
-	if idx := strings.IndexByte(epicID, '-'); idx != -1 {
-		return epicID[:idx]
-	}
-	return epicID
-}
-
-func checkTaskFile(path string, parser taskParser, problems *[]Problem) {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		*problems = append(*problems, Problem{File: path, Message: fmt.Sprintf("unreadable: %v", err)})
-		return
-	}
-
-	content := string(raw)
-	fm, err := parser.ParseFrontmatter(content)
-	if err != nil {
-		line := extractYAMLLine(err)
-		*problems = append(*problems, Problem{File: path, Line: line, Message: fmt.Sprintf("invalid frontmatter: %v", err)})
-		return
-	}
-
-	checkRequiredString(fm, path, "id", problems)
-	checkRequiredString(fm, path, "status", problems)
-	checkRequiredString(fm, path, "objective", problems)
-	checkDependsOn(fm, path, problems)
-
-	if !hasAcceptanceCriteria(content) {
-		*problems = append(*problems, Problem{File: path, Message: "task missing ## Acceptance Criteria section"})
-	}
-}
-
-func checkRequiredString(fm map[string]any, path, field string, problems *[]Problem) {
-	val, ok := fm[field]
-	if !ok {
-		*problems = append(*problems, Problem{File: path, Message: fmt.Sprintf("task missing required frontmatter field: %s", field)})
-		return
-	}
-	s, ok := val.(string)
-	if !ok || s == "" {
-		*problems = append(*problems, Problem{File: path, Message: fmt.Sprintf("task frontmatter field %q must be a non-empty string", field)})
-	}
-}
-
-func checkDependsOn(fm map[string]any, path string, problems *[]Problem) {
-	val, ok := fm["depends_on"]
-	if !ok {
-		return
-	}
-	switch val.(type) {
-	case []any, []string:
-	default:
-		*problems = append(*problems, Problem{File: path, Message: "task frontmatter field depends_on must be a list"})
-	}
-}
-
-func hasAcceptanceCriteria(content string) bool {
-	normalized := strings.ReplaceAll(content, "\r\n", "\n")
-	idx := strings.Index(normalized, "## Acceptance Criteria")
-	if idx == -1 {
-		return false
-	}
-	section := normalized[idx+len("## Acceptance Criteria"):]
-	if next := strings.Index(section, "\n## "); next != -1 {
-		section = section[:next]
-	}
-	section = strings.TrimSpace(section)
-	return section != ""
-}
-
-func validateFrontmatter(path, content string, parser taskParser, problems *[]Problem) {
-	_, err := parser.ParseFrontmatter(content)
-	if err != nil {
-		line := extractYAMLLine(err)
-		*problems = append(*problems, Problem{File: path, Line: line, Message: fmt.Sprintf("invalid frontmatter: %v", err)})
-	}
-}
-
-// taskDep describes a parsed task's dependency information.
-type taskDep struct {
-	File      string
-	ID        string
-	DependsOn []string
-}
-
-// CheckDependencies validates task dependency integrity:
-// missing deps, duplicate IDs, and dependency cycles.
-// epicFilter restricts checks to matching epics if non-empty.
-func CheckDependencies(root string, epicFilter string, overrides ...DoctorDependencies) []Problem {
-	deps := doctorDependencies(overrides)
-	var problems []Problem
-
-	releases, err := deps.Discoverer.ListReleases(root)
-	if err != nil {
-		problems = append(problems, Problem{Message: fmt.Sprintf("listing releases: %v", err)})
-		return problems
-	}
-
-	var allTasks []taskDep
-	idSet := make(map[string]string) // id -> first file seen
-
-	for _, release := range releases {
-		epics, err := deps.Discoverer.ListEpics(root, release.ID)
-		if err != nil {
-			continue
-		}
-		for _, epic := range epics {
-			if epicFilter != "" && epic.ID != epicFilter && !strings.HasPrefix(epic.ID, epicFilter) {
-				continue
-			}
-			tasks, err := deps.Discoverer.ListTasks(root, release.ID, epic.ID)
-			if err != nil {
-				continue
-			}
-			for _, t := range tasks {
-				td := parseTaskDep(t.Path, deps.Parser)
-				if td == nil {
-					continue
-				}
-				allTasks = append(allTasks, *td)
-				if existing, ok := idSet[td.ID]; ok {
-					problems = append(problems, Problem{
-						File:    td.File,
-						Message: fmt.Sprintf("duplicate task ID %q (first seen in %s)", td.ID, existing),
-					})
-				} else {
-					idSet[td.ID] = td.File
-				}
-			}
-		}
-	}
-
-	// Check for missing dependencies and cycles
-	graph := make(map[string][]string) // id -> list of dependencies
-	idToFile := make(map[string]string)
-
-	for _, td := range allTasks {
-		idToFile[td.ID] = td.File
-		graph[td.ID] = td.DependsOn
-	}
-
-	for _, td := range allTasks {
-		for _, dep := range td.DependsOn {
-			if _, exists := idSet[dep]; !exists {
-				problems = append(problems, Problem{
-					File:    td.File,
-					Message: fmt.Sprintf("depends_on references non-existent task %q", dep),
-				})
-			}
-		}
-	}
-
-	// Cycle detection using DFS
-	cycleProblems := detectCycles(graph, idToFile)
-	problems = append(problems, cycleProblems...)
-
-	return problems
-}
-
-func parseTaskDep(path string, parser taskParser) *taskDep {
-	raw, err := os.ReadFile(path)
-	if err != nil {
-		return nil
-	}
-	fm, err := parser.ParseFrontmatter(string(raw))
-	if err != nil {
-		return nil
-	}
-	id, _ := fm["id"].(string)
-	if id == "" {
-		return nil
-	}
-	var deps []string
-	switch v := fm["depends_on"].(type) {
-	case []any:
-		for _, d := range v {
-			if s, ok := d.(string); ok {
-				deps = append(deps, s)
-			}
-		}
-	case []string:
-		deps = v
-	}
-	return &taskDep{
-		File:      path,
-		ID:        id,
-		DependsOn: deps,
-	}
-}
-
-// detectCycles runs DFS on the dependency graph and returns cycle problems.
-// Uses a path stack to accurately reconstruct cycle paths (avoids parent-map
-// overwrite issues that produced inaccurate paths).
-func detectCycles(graph map[string][]string, idToFile map[string]string) []Problem {
-	const (
-		white = 0
-		gray  = 1
-		black = 2
-	)
-	color := make(map[string]int)
-	path := make([]string, 0)
-
-	for id := range graph {
-		color[id] = white
-	}
-
-	var problems []Problem
-
-	var dfs func(id string)
-	dfs = func(id string) {
-		color[id] = gray
-		path = append(path, id)
-		for _, dep := range graph[id] {
-			switch color[dep] {
-			case white:
-				dfs(dep)
-			case gray:
-				cycleStart := -1
-				for i, n := range path {
-					if n == dep {
-						cycleStart = i
-						break
-					}
-				}
-				if cycleStart >= 0 {
-					cycle := path[cycleStart:]
-					cyclePath := make([]string, 0, len(cycle))
-					for _, cid := range cycle {
-						if f, ok := idToFile[cid]; ok {
-							cyclePath = append(cyclePath, f)
-						} else {
-							cyclePath = append(cyclePath, cid)
-						}
-					}
-					problems = append(problems, Problem{
-						Message: fmt.Sprintf("dependency cycle detected: %s", strings.Join(cyclePath, " → ")),
-					})
-				}
-			}
-		}
-		path = path[:len(path)-1]
-		color[id] = black
-	}
-
-	for id := range graph {
-		if color[id] == white {
-			dfs(id)
-		}
-	}
-	return problems
-}
-
-// CheckAuditState finds audit proposal files without matching audit-pending state in the router.
-func CheckAuditState(root string, overrides ...DoctorDependencies) []Problem {
-	deps := doctorDependencies(overrides)
-	var problems []Problem
-
-	routerPath := filepath.Join(root, "router.md")
-	raw, err := os.ReadFile(routerPath)
-	if err != nil {
-		return problems
-	}
-
-	state, err := deps.RouterReader.ReadState(string(raw))
-	if err != nil {
-		return problems
-	}
-
-	releases, err := deps.Discoverer.ListReleases(root)
-	if err != nil {
-		return problems
-	}
-
-	for _, release := range releases {
-		epics, err := deps.Discoverer.ListEpics(root, release.ID)
-		if err != nil {
-			continue
-		}
-		for _, epic := range epics {
-			prefix := extractPrefix(epic.ID)
-			auditPath := filepath.Join(epic.Path, prefix+"-Audit.md")
-			if _, err := os.Stat(auditPath); os.IsNotExist(err) {
-				continue
-			}
-			if state.State != "audit-pending" || state.Epic != epic.ID {
-				problems = append(problems, Problem{
-					File:    auditPath,
-					Message: fmt.Sprintf("audit proposal exists but router state is %q (epic: %q) — expected audit-pending for %q", state.State, state.Epic, epic.ID),
-				})
-			}
-		}
-	}
-
-	return problems
-}
-
-// CheckOrphans finds tasks whose epic prefix in their ID does not match any existing epic directory.
-func CheckOrphans(root string, overrides ...DoctorDependencies) []Problem {
-	deps := doctorDependencies(overrides)
-	var problems []Problem
-
-	existingEpics := make(map[string]bool)
-	releasesPath := filepath.Join(root, "releases")
-	releaseDirs, err := deps.Discoverer.ListRootDirs(releasesPath)
-	if err != nil {
-		problems = append(problems, Problem{File: releasesPath, Message: fmt.Sprintf("listing releases: %v", err)})
-		return problems
-	}
-
-	for _, release := range releaseDirs {
-		epicsPath := filepath.Join(releasesPath, release, "epics")
-		epics, err := deps.Discoverer.ListRootDirs(epicsPath)
-		if err != nil {
-			continue
-		}
-		for _, epic := range epics {
-			existingEpics[epic] = true
-		}
-	}
-
-	// Collect all tasks and check their epic references
-	allReleases, err := deps.Discoverer.ListReleases(root)
-	if err != nil {
-		return problems
-	}
-
-	for _, release := range allReleases {
-		epics, err := deps.Discoverer.ListEpics(root, release.ID)
-		if err != nil {
-			continue
-		}
-		for _, epic := range epics {
-			tasks, err := deps.Discoverer.ListTasks(root, release.ID, epic.ID)
-			if err != nil {
-				continue
-			}
-			for _, t := range tasks {
-				raw, err := os.ReadFile(t.Path)
-				if err != nil {
-					continue
-				}
-				fm, err := deps.Parser.ParseFrontmatter(string(raw))
-				if err != nil {
-					continue
-				}
-				id, _ := fm["id"].(string)
-				if id == "" {
-					continue
-				}
-				idx := strings.IndexByte(id, '/')
-				if idx == -1 {
-					continue
-				}
-				taskEpic := id[:idx]
-				if !existingEpics[taskEpic] {
-					problems = append(problems, Problem{
-						File:    t.Path,
-						Message: fmt.Sprintf("orphaned task: epic %q does not exist in any release — consider moving to .savepoint/orphans/", taskEpic),
-					})
-				}
-			}
-		}
-	}
-
-	return problems
-}
-
-func extractYAMLLine(err error) int {
-	s := err.Error()
-	const prefix = "yaml: line "
-	if idx := strings.Index(s, prefix); idx != -1 {
-		rest := s[idx+len(prefix):]
-		if end := strings.IndexByte(rest, ':'); end != -1 {
-			if line, err := strconv.Atoi(rest[:end]); err == nil {
-				return line
-			}
-		}
-	}
-	return 0
-}