savepoint 1.0.4 → 1.0.6

package/internal/doctor/gates.go

@@ -1,193 +0,0 @@
-package doctor
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-// GateResult holds the outcome of a single quality gate.
-type GateResult struct {
-	Name     string
-	Command  string
-	Passed   bool
-	ExitCode int
-	Output   string
-}
-
-// RunQualityGates executes configured quality gates (lint, typecheck, test).
-func RunQualityGates(root string, overrides ...DoctorDependencies) []GateResult {
-	deps := doctorDependencies(overrides)
-	configPath := filepath.Join(root, "config.yml")
-	cfg, err := deps.ConfigReader.Read(configPath)
-	if err != nil {
-		return []GateResult{{
-			Name:    "config",
-			Command: "",
-			Passed:  false,
-			Output:  fmt.Sprintf("cannot read config: %v", err),
-		}}
-	}
-
-	timeout := 60 * time.Second
-	if cfg.QualityGates.Timeout != "" {
-		if d, err := time.ParseDuration(cfg.QualityGates.Timeout); err == nil {
-			timeout = d
-		}
-	}
-
-	var results []GateResult
-
-	if cfg.QualityGates.Lint != nil && *cfg.QualityGates.Lint != "" {
-		results = append(results, runGate("lint", *cfg.QualityGates.Lint, root, timeout))
-	}
-	if cfg.QualityGates.Typecheck != nil && *cfg.QualityGates.Typecheck != "" {
-		results = append(results, runGate("typecheck", *cfg.QualityGates.Typecheck, root, timeout))
-	}
-	if cfg.QualityGates.Test != nil && *cfg.QualityGates.Test != "" {
-		results = append(results, runGate("test", *cfg.QualityGates.Test, root, timeout))
-	}
-
-	if len(results) == 0 {
-		results = append(results, GateResult{
-			Name:    "quality_gates",
-			Command: "",
-			Passed:  true,
-			Output:  "no quality gates configured",
-		})
-	}
-
-	return results
-}
-
-func runGate(name, command string, root string, timeout time.Duration) GateResult {
-	parts := splitCommand(command)
-	if len(parts) == 0 {
-		return GateResult{
-			Name:    name,
-			Command: command,
-			Passed:  false,
-			Output:  "empty command",
-		}
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), timeout)
-	defer cancel()
-
-	cmd := exec.CommandContext(ctx, parts[0], parts[1:]...)
-	cmd.Dir = root
-	cmd.Env = os.Environ()
-
-	output, err := cmd.CombinedOutput()
-	outStr := strings.TrimSpace(string(output))
-
-	switch {
-	case err != nil && ctx.Err() == context.DeadlineExceeded:
-		return GateResult{
-			Name:    name,
-			Command: command,
-			Passed:  false,
-			Output:  fmt.Sprintf("timed out after %v", timeout),
-		}
-	case err != nil:
-		if exitErr, ok := err.(*exec.ExitError); ok {
-			return GateResult{
-				Name:     name,
-				Command:  command,
-				Passed:   false,
-				ExitCode: exitErr.ExitCode(),
-				Output:   outStr,
-			}
-		}
-		return GateResult{
-			Name:    name,
-			Command: command,
-			Passed:  false,
-			Output:  fmt.Sprintf("failed to execute: %v", err),
-		}
-	default:
-		return GateResult{
-			Name:     name,
-			Command:  command,
-			Passed:   true,
-			ExitCode: 0,
-			Output:   outStr,
-		}
-	}
-}
-
-func splitCommand(command string) []string {
-	var parts []string
-	current := strings.Builder{}
-	inDoubleQuote := false
-	inSingleQuote := false
-	tokenStarted := false
-
-	flush := func() {
-		if tokenStarted || current.Len() > 0 {
-			parts = append(parts, current.String())
-			current.Reset()
-			tokenStarted = false
-		}
-	}
-
-	for i := 0; i < len(command); i++ {
-		c := command[i]
-
-		if inSingleQuote {
-			tokenStarted = true
-			if c == '\'' {
-				inSingleQuote = false
-			} else {
-				current.WriteByte(c)
-			}
-			continue
-		}
-
-		if inDoubleQuote {
-			tokenStarted = true
-			if c == '\\' && i+1 < len(command) {
-				next := command[i+1]
-				if next == '"' || next == '\\' || next == '$' || next == '`' {
-					i++
-					current.WriteByte(command[i])
-					continue
-				}
-			}
-			if c == '"' {
-				inDoubleQuote = false
-				continue
-			}
-			current.WriteByte(c)
-			continue
-		}
-
-		switch c {
-		case '\\':
-			tokenStarted = true
-			if i+1 < len(command) {
-				i++
-				current.WriteByte(command[i])
-			} else {
-				current.WriteByte(c)
-			}
-		case '"':
-			tokenStarted = true
-			inDoubleQuote = true
-		case '\'':
-			tokenStarted = true
-			inSingleQuote = true
-		case ' ', '\t', '\n', '\r':
-			flush()
-		default:
-			tokenStarted = true
-			current.WriteByte(c)
-		}
-	}
-	flush()
-	return parts
-}

package/internal/doctor/gates_test.go

@@ -1,166 +0,0 @@
-package doctor
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func writeConfig(t *testing.T, root, content string) {
-	t.Helper()
-	if err := os.WriteFile(filepath.Join(root, "config.yml"), []byte(content), 0644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestRunQualityGates_NoConfig(t *testing.T) {
-	root := t.TempDir()
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
-	}
-	if !results[0].Passed {
-		t.Fatalf("RunQualityGates() = %v, want passed (default config has no gates)", results[0])
-	}
-	if !strings.Contains(results[0].Output, "no quality gates configured") {
-		t.Fatalf("RunQualityGates() output = %q, want 'no quality gates configured'", results[0].Output)
-	}
-}
-
-func TestRunQualityGates_AllNull(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: null\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
-
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1 (no gates configured)", len(results))
-	}
-	if !results[0].Passed {
-		t.Fatalf("RunQualityGates() = %v, want passed with 'no gates configured'", results[0])
-	}
-	if !strings.Contains(results[0].Output, "no quality gates configured") {
-		t.Fatalf("RunQualityGates() output = %q, want 'no quality gates configured'", results[0].Output)
-	}
-}
-
-func TestRunQualityGates_LintOnly(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: \"go version\"\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
-
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1 (lint only)", len(results))
-	}
-	if !results[0].Passed {
-		t.Fatalf("RunQualityGates() lint should pass: %v", results[0])
-	}
-	if results[0].Name != "lint" {
-		t.Fatalf("RunQualityGates()[0].Name = %q, want \"lint\"", results[0].Name)
-	}
-}
-
-func TestRunQualityGates_AllThree(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: \"go version\"\n  typecheck: \"go version\"\n  test: \"go version\"\ntheme:\n  bg: \"#000\"\n")
-
-	results := RunQualityGates(root)
-	if len(results) != 3 {
-		t.Fatalf("RunQualityGates() = %d results, want 3", len(results))
-	}
-	for _, r := range results {
-		if !r.Passed {
-			t.Fatalf("RunQualityGates() %s should pass: %v", r.Name, r)
-		}
-	}
-}
-
-func TestRunQualityGates_FailingCommand(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: \"cmd-that-does-not-exist-12345\"\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
-
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
-	}
-	if results[0].Passed {
-		t.Fatal("RunQualityGates() should fail for non-existent command")
-	}
-}
-
-func TestRunQualityGates_ExitCodeNonZero(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: \"go vet\"\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
-	// Write a bad Go file so go vet fails
-	badPath := filepath.Join(root, "bad.go")
-	os.WriteFile(badPath, []byte("package x\n\nfunc f() { return 1 }\n"), 0644)
-
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
-	}
-	if results[0].Passed {
-		t.Fatal("RunQualityGates() should fail when go vet fails")
-	}
-}
-
-func TestRunQualityGates_Timeout(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: \"go test -test.run TestNonexistent -count=1 ./...\"\n  gate_timeout: \"1ns\"\ntheme:\n  bg: \"#000\"\n")
-
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
-	}
-	if results[0].Passed {
-		t.Fatal("RunQualityGates() should fail due to timeout")
-	}
-	if !strings.Contains(results[0].Output, "timed out") {
-		t.Fatalf("RunQualityGates() output = %q, want 'timed out'", results[0].Output)
-	}
-}
-
-func TestRunQualityGates_DefaultTimeout(t *testing.T) {
-	root := t.TempDir()
-	writeConfig(t, root, "quality_gates:\n  lint: \"go version\"\n  # no gate_timeout set — uses 60s default\ntheme:\n  bg: \"#000\"\n")
-
-	results := RunQualityGates(root)
-	if len(results) != 1 {
-		t.Fatalf("RunQualityGates() = %d results, want 1", len(results))
-	}
-	if !results[0].Passed {
-		t.Fatalf("RunQualityGates() lint should pass with default timeout: %v", results[0])
-	}
-}
-
-func TestSplitCommand(t *testing.T) {
-	tests := []struct {
-		input string
-		want  []string
-	}{
-		{"echo hello", []string{"echo", "hello"}},
-		{"go test ./...", []string{"go", "test", "./..."}},
-		{"\"c:\\program files\\go\\bin\\go\"", []string{"c:\\program files\\go\\bin\\go"}},
-		{"echo 'hello world'", []string{"echo", "hello world"}},
-		{"echo \"hello \\\"world\\\"\"", []string{"echo", "hello \"world\""}},
-		{"echo hello\\ world", []string{"echo", "hello world"}},
-		{"echo 'it''s'", []string{"echo", "its"}},
-		{"go test -run \"\" ./...", []string{"go", "test", "-run", "", "./..."}},
-		{"printf ''", []string{"printf", ""}},
-		{"echo trailing\\", []string{"echo", "trailing\\"}},
-		{"", nil},
-		{"   ", nil},
-	}
-	for _, tt := range tests {
-		got := splitCommand(tt.input)
-		if len(got) != len(tt.want) {
-			t.Errorf("splitCommand(%q) = %v, want %v", tt.input, got, tt.want)
-			continue
-		}
-		for i := range got {
-			if got[i] != tt.want[i] {
-				t.Errorf("splitCommand(%q)[%d] = %q, want %q", tt.input, i, got[i], tt.want[i])
-			}
-		}
-	}
-}

package/internal/doctor/interfaces.go

@@ -1,64 +0,0 @@
-package doctor
-
-import "github.com/opencode/savepoint/internal/data"
-
-// taskDiscoverer provides project traversal for doctor checks.
-type taskDiscoverer interface {
-	ListRootDirs(root string) ([]string, error)
-	ListReleases(root string) ([]data.ReleaseInfo, error)
-	ListEpics(root, release string) ([]data.EpicInfo, error)
-	ListTasks(root, release, epic string) ([]data.TaskInfo, error)
-}
-
-// taskParser parses Savepoint frontmatter for doctor checks.
-type taskParser interface {
-	ParseFrontmatter(content string) (map[string]any, error)
-}
-
-// configReader reads quality gate configuration.
-type configReader interface {
-	Read(path string) (*data.Config, error)
-}
-
-// routerReader parses router state from router.md content.
-type routerReader interface {
-	ReadState(content string) (*data.RouterState, error)
-}
-
-// DoctorDependencies contains doctor data-access dependencies.
-type DoctorDependencies struct {
-	Discoverer   taskDiscoverer
-	Parser       taskParser
-	ConfigReader configReader
-	RouterReader routerReader
-}
-
-func defaultDoctorDependencies() DoctorDependencies {
-	return DoctorDependencies{
-		Discoverer:   data.NewDiscover(),
-		Parser:       data.NewParser(),
-		ConfigReader: data.NewConfigReader(),
-		RouterReader: data.NewRouterReader(),
-	}
-}
-
-func doctorDependencies(overrides []DoctorDependencies) DoctorDependencies {
-	deps := defaultDoctorDependencies()
-	if len(overrides) == 0 {
-		return deps
-	}
-	override := overrides[0]
-	if override.Discoverer != nil {
-		deps.Discoverer = override.Discoverer
-	}
-	if override.Parser != nil {
-		deps.Parser = override.Parser
-	}
-	if override.ConfigReader != nil {
-		deps.ConfigReader = override.ConfigReader
-	}
-	if override.RouterReader != nil {
-		deps.RouterReader = override.RouterReader
-	}
-	return deps
-}

package/internal/doctor/interfaces_test.go

@@ -1,104 +0,0 @@
-package doctor
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/opencode/savepoint/internal/data"
-	"github.com/opencode/savepoint/internal/testutil"
-)
-
-type stubDoctorRouterReader struct {
-	state *data.RouterState
-	calls int
-}
-
-func (r *stubDoctorRouterReader) ReadState(content string) (*data.RouterState, error) {
-	r.calls++
-	return r.state, nil
-}
-
-type stubDoctorDiscoverer struct {
-	releases []data.ReleaseInfo
-	epics    map[string][]data.EpicInfo
-	tasks    map[string][]data.TaskInfo
-	calls    int
-}
-
-func (d *stubDoctorDiscoverer) ListRootDirs(root string) ([]string, error) {
-	d.calls++
-	return nil, nil
-}
-
-func (d *stubDoctorDiscoverer) ListReleases(root string) ([]data.ReleaseInfo, error) {
-	d.calls++
-	return d.releases, nil
-}
-
-func (d *stubDoctorDiscoverer) ListEpics(root, release string) ([]data.EpicInfo, error) {
-	d.calls++
-	return d.epics[release], nil
-}
-
-func (d *stubDoctorDiscoverer) ListTasks(root, release, epic string) ([]data.TaskInfo, error) {
-	d.calls++
-	return d.tasks[release+"/"+epic], nil
-}
-
-type countingDoctorParser struct {
-	parser *data.Parser
-	calls  int
-}
-
-func (p *countingDoctorParser) ParseFrontmatter(content string) (map[string]any, error) {
-	p.calls++
-	return p.parser.ParseFrontmatter(content)
-}
-
-func TestCheckRouterUsesInjectedRouterReader(t *testing.T) {
-	root := t.TempDir()
-	testutil.WriteFile(t, filepath.Join(root, "router.md"), "# intentionally not a router state block")
-	testutil.MkdirAll(t, filepath.Join(root, "releases", "v9", "epics", "E01-mock"))
-
-	reader := &stubDoctorRouterReader{state: &data.RouterState{
-		State:   "task-building",
-		Release: "v9",
-		Epic:    "E01-mock",
-	}}
-
-	if err := CheckRouter(root, "", DoctorDependencies{RouterReader: reader}); err != nil {
-		t.Fatalf("CheckRouter() with injected reader = %v, want nil", err)
-	}
-	if reader.calls != 1 {
-		t.Fatalf("ReadState calls = %d, want 1", reader.calls)
-	}
-}
-
-func TestCheckDependenciesUsesInjectedDiscovererAndParser(t *testing.T) {
-	root := t.TempDir()
-	taskPath := filepath.Join(root, "virtual", "T001-task.md")
-	testutil.MkdirAll(t, filepath.Dir(taskPath))
-	testutil.WriteFile(t, taskPath, "---\nid: E01-mock/T001-task\nstatus: planned\nobjective: Mock\ndepends_on: []\n---\n")
-
-	discoverer := &stubDoctorDiscoverer{
-		releases: []data.ReleaseInfo{{ID: "v9", Path: filepath.Join(root, "virtual-release")}},
-		epics: map[string][]data.EpicInfo{
-			"v9": {{ID: "E01-mock", Path: filepath.Join(root, "virtual-epic")}},
-		},
-		tasks: map[string][]data.TaskInfo{
-			"v9/E01-mock": {{ID: "T001-task", Path: taskPath}},
-		},
-	}
-	parser := &countingDoctorParser{parser: data.NewParser()}
-
-	problems := CheckDependencies(root, "", DoctorDependencies{Discoverer: discoverer, Parser: parser})
-	if len(problems) > 0 {
-		t.Fatalf("CheckDependencies() = %v, want no problems", problems)
-	}
-	if discoverer.calls == 0 {
-		t.Fatal("injected discoverer was not used")
-	}
-	if parser.calls != 1 {
-		t.Fatalf("ParseFrontmatter calls = %d, want 1", parser.calls)
-	}
-}

package/internal/doctor/repairs.go

@@ -1,80 +0,0 @@
-package doctor
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-
-	"github.com/opencode/savepoint/internal/data"
-)
-
-func SuggestRepair(err error) string {
-	switch {
-	case errors.Is(err, data.ErrConfigNotFound):
-		return "Run `savepoint init` to scaffold a new project"
-	case errors.Is(err, data.ErrInvalidStatus):
-		return "Set router state to a recognized workflow state (see router.md State → action section)"
-	case errors.Is(err, data.ErrMissingFrontmatter):
-		return "Fix the YAML frontmatter between the --- delimiters"
-	case errors.Is(err, data.ErrStructureProblem):
-		return "Review the file and fix the reported issue"
-	}
-
-	msg := err.Error()
-	switch {
-	case strings.Contains(msg, "config.yml not found"):
-		return "Run `savepoint init` to scaffold a new project"
-	case strings.Contains(msg, "config.yml missing required field"):
-		return "Add the missing field to config.yml — see the project template for reference"
-	case strings.Contains(msg, "invalid YAML"):
-		return "Fix the YAML syntax error at the indicated line"
-	case strings.Contains(msg, "router.md not found"):
-		return "Run `savepoint init` to scaffold a new project"
-	case strings.Contains(msg, "unknown state"):
-		return "Set router state to a recognized workflow state (see router.md State → action section)"
-	case strings.Contains(msg, "release PRD file not found"):
-		return "Create a {release}-PRD.md file with frontmatter for the release"
-	case strings.Contains(msg, "release"):
-		return "Create the release directory at releases/<release-id>/"
-	case strings.Contains(msg, "epic") && strings.Contains(msg, "directory not found"):
-		return "Create the epic directory at releases/<release>/epics/<epic-id>/"
-	case strings.Contains(msg, "epic detail file not found"):
-		return "Create an E##-Detail.md with frontmatter for the epic"
-	case strings.Contains(msg, "invalid frontmatter"):
-		return "Fix the YAML frontmatter between the --- delimiters"
-	case strings.Contains(msg, "task missing required frontmatter field"):
-		return "Add the missing field to the task frontmatter"
-	case strings.Contains(msg, "missing ## Acceptance Criteria"):
-		return "Add an ## Acceptance Criteria section with checkable items"
-	case strings.Contains(msg, "depends_on must be a list"):
-		return "Change depends_on to a YAML list format"
-	case strings.Contains(msg, "references non-existent"):
-		return "Create the referenced task or remove the dependency"
-	case strings.Contains(msg, "duplicate task ID"):
-		return "Rename one of the tasks to have a unique ID"
-	case strings.Contains(msg, "dependency cycle"):
-		return "Break the circular dependency chain between tasks"
-	case strings.Contains(msg, "audit proposal exists"):
-		return "Set router state to audit-pending for the matching epic, or remove stale audit files"
-	case strings.Contains(msg, "orphaned"):
-		return "Move the task directory to the correct epic or create the referenced epic"
-	case strings.Contains(msg, "quality gate"):
-		return "Fix the issue reported by the quality gate tool"
-	default:
-		return "Review the file and fix the reported issue"
-	}
-}
-
-// GateSuggestion returns a command-specific repair hint.
-func GateSuggestion(name string) string {
-	switch name {
-	case "lint":
-		return "Run `make lint` locally and fix reported issues"
-	case "typecheck":
-		return "Run `make typecheck` locally and fix type errors"
-	case "test":
-		return "Run `make test` locally and fix failing tests"
-	default:
-		return fmt.Sprintf("Run %q locally and fix reported issues", name)
-	}
-}

package/internal/doctor/repairs_test.go

@@ -1,81 +0,0 @@
-package doctor
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/opencode/savepoint/internal/data"
-)
-
-func TestSuggestRepair(t *testing.T) {
-	tests := []struct {
-		err      error
-		contains string
-	}{
-		{Problem{Message: "config.yml not found"}, "savepoint init"},
-		{Problem{Message: "config.yml missing required field: theme"}, "Add the missing field"},
-		{Problem{Message: "config.yml invalid YAML: yaml: line 3: could not find expected"}, "Fix the YAML syntax"},
-		{Problem{Message: "router.md not found"}, "savepoint init"},
-		{Problem{Message: "router.md unknown state \"bogus\""}, "Set router state to a recognized"},
-		{Problem{Message: "router.md release \"v99\" directory not found"}, "Create the release directory"},
-		{Problem{Message: "router.md epic \"E99-foo\" directory not found"}, "Create the epic directory"},
-		{Problem{Message: "release PRD file not found"}, "Create a {release}-PRD.md"},
-		{Problem{Message: "epic detail file not found"}, "Create an E##-Detail.md"},
-		{Problem{Message: "invalid frontmatter: yaml: line 5:"}, "Fix the YAML frontmatter"},
-		{Problem{Message: "task missing required frontmatter field: status"}, "Add the missing field"},
-		{Problem{Message: "task missing ## Acceptance Criteria section"}, "Add an ## Acceptance Criteria section"},
-		{Problem{Message: "task frontmatter field depends_on must be a list"}, "Change depends_on to a YAML list"},
-		{Problem{Message: "depends_on references non-existent task \"E99/T999\""}, "Create the referenced task"},
-		{Problem{Message: "duplicate task ID \"E01-foo/T001-task\" (first seen in"}, "Rename one of the tasks"},
-		{Problem{Message: "dependency cycle detected:"}, "Break the circular dependency chain"},
-		{Problem{Message: "audit proposal exists but router state is"}, "Set router state to audit-pending"},
-		{Problem{Message: "orphaned task: epic \"E99-ghost\" does not exist"}, "Move the task directory"},
-		{Problem{Message: "quality gate \"lint\" failed"}, "Fix the issue reported by the quality gate"},
-		{Problem{Message: "some random unknown problem"}, "Review the file and fix"},
-	}
-	for _, tt := range tests {
-		got := SuggestRepair(tt.err)
-		if !strings.Contains(got, tt.contains) {
-			t.Errorf("SuggestRepair(%q) = %q, want containing %q", tt.err.Error(), got, tt.contains)
-		}
-	}
-}
-
-func TestGateSuggestion(t *testing.T) {
-	tests := []struct {
-		name     string
-		contains string
-	}{
-		{"lint", "make lint"},
-		{"typecheck", "make typecheck"},
-		{"test", "make test"},
-		{"custom", "Run \"custom\" locally"},
-	}
-	for _, tt := range tests {
-		got := GateSuggestion(tt.name)
-		if !strings.Contains(got, tt.contains) {
-			t.Errorf("GateSuggestion(%q) = %q, want containing %q", tt.name, got, tt.contains)
-		}
-	}
-}
-
-func TestSuggestRepair_typedErrors(t *testing.T) {
-	tests := []struct {
-		err      error
-		contains string
-	}{
-		{fmt.Errorf("config.yml not found: %w", data.ErrConfigNotFound), "savepoint init"},
-		{fmt.Errorf("router.md not found: %w", data.ErrConfigNotFound), "savepoint init"},
-	}
-	for _, tt := range tests {
-		if !errors.Is(tt.err, data.ErrConfigNotFound) {
-			t.Fatalf("test error should wrap %v", data.ErrConfigNotFound)
-		}
-		got := SuggestRepair(tt.err)
-		if !strings.Contains(got, tt.contains) {
-			t.Errorf("SuggestRepair(%q) = %q, want containing %q", tt.err.Error(), got, tt.contains)
-		}
-	}
-}