savepoint 1.0.3 → 1.0.6

package/internal/doctor/report.go

@@ -1,157 +0,0 @@
-package doctor
-
-import (
-	"fmt"
-	"strings"
-)
-
-// QualityGateReport wraps quality gate results.
-type QualityGateReport struct {
-	Results []GateResult
-}
-
-// DiagnosticReport is the complete output of all doctor checks.
-type DiagnosticReport struct {
-	ConfigCheck    error
-	RouterCheck    error
-	Structure      []Problem
-	Dependencies   []Problem
-	AuditState     []Problem
-	Orphans        []Problem
-	Gates          QualityGateReport
-	EpicFilter     string
-}
-
-// RunAllChecks runs every doctor check and returns a full report.
-func RunAllChecks(root string, epicFilter string) *DiagnosticReport {
-	report := &DiagnosticReport{
-		EpicFilter: epicFilter,
-	}
-
-	report.ConfigCheck = CheckConfig(root)
-	report.RouterCheck = CheckRouter(root, epicFilter)
-	report.Structure = CheckStructure(root, epicFilter)
-	report.Dependencies = CheckDependencies(root, epicFilter)
-	report.AuditState = CheckAuditState(root)
-	report.Orphans = CheckOrphans(root)
-	report.Gates.Results = RunQualityGates(root)
-
-	return report
-}
-
-// HasProblems returns true if any check found issues.
-func (r *DiagnosticReport) HasProblems() bool {
-	if r.ConfigCheck != nil {
-		return true
-	}
-	if r.RouterCheck != nil {
-		return true
-	}
-	if len(r.Structure) > 0 {
-		return true
-	}
-	if len(r.Dependencies) > 0 {
-		return true
-	}
-	if len(r.AuditState) > 0 {
-		return true
-	}
-	if len(r.Orphans) > 0 {
-		return true
-	}
-	for _, g := range r.Gates.Results {
-		if !g.Passed {
-			return true
-		}
-	}
-	return false
-}
-
-// Format produces the full human-readable diagnostic report.
-func (r *DiagnosticReport) Format() string {
-	var b strings.Builder
-
-	b.WriteString("savepoint doctor report\n")
-	if r.EpicFilter != "" {
-		fmt.Fprintf(&b, "  filtering to epic: %s\n", r.EpicFilter)
-	}
-	b.WriteString("────────────────────────────────\n\n")
-
-	sectionHeader(&b, "Config Check")
-	printSingleCheck(&b, "config", r.ConfigCheck)
-
-	sectionHeader(&b, "Router Check")
-	printSingleCheck(&b, "router", r.RouterCheck)
-
-	sectionHeader(&b, "Structure Check")
-	printProblems(&b, "structure", r.Structure)
-
-	sectionHeader(&b, "Dependency Check")
-	printProblems(&b, "dependency", r.Dependencies)
-
-	sectionHeader(&b, "Audit State Check")
-	printProblems(&b, "audit", r.AuditState)
-
-	sectionHeader(&b, "Orphan Check")
-	printProblems(&b, "orphan", r.Orphans)
-
-	sectionHeader(&b, "Quality Gates")
-	for _, g := range r.Gates.Results {
-		status := "PASS"
-		if !g.Passed {
-			status = "FAIL"
-		}
-		fmt.Fprintf(&b, "  [%s] %s", status, g.Name)
-		if g.Command != "" {
-			fmt.Fprintf(&b, " (%s)", g.Command)
-		}
-		b.WriteString("\n")
-		if !g.Passed {
-			hint := GateSuggestion(g.Name)
-			fmt.Fprintf(&b, "    repair: %s\n", hint)
-			if g.Output != "" {
-				for _, line := range strings.Split(g.Output, "\n") {
-					b.WriteString("    ")
-					b.WriteString(line)
-					b.WriteString("\n")
-				}
-			}
-		}
-	}
-
-	b.WriteString("\n")
-	if r.HasProblems() {
-		b.WriteString("result: PROBLEMS FOUND (exit code 1)\n")
-	} else {
-		b.WriteString("result: ALL CLEAN (exit code 0)\n")
-	}
-
-	return b.String()
-}
-
-func sectionHeader(b *strings.Builder, title string) {
-	fmt.Fprintf(b, "◆ %s\n", title)
-	b.WriteString(strings.Repeat("─", len(title)+2))
-	b.WriteString("\n")
-}
-
-func printSingleCheck(b *strings.Builder, name string, err error) {
-	if err == nil {
-		fmt.Fprintf(b, "  ✓ %s\n\n", name)
-	} else {
-		fmt.Fprintf(b, "  ✗ %s: %s\n", name, err.Error())
-		fmt.Fprintf(b, "    repair: %s\n\n", SuggestRepair(err))
-	}
-}
-
-func printProblems(b *strings.Builder, category string, problems []Problem) {
-	if len(problems) == 0 {
-		fmt.Fprintf(b, "  ✓ no problems\n\n")
-		return
-	}
-	for _, p := range problems {
-		fmt.Fprintf(b, "  ✗ %s: %s\n", category, p.Error())
-		fmt.Fprintf(b, "    repair: %s\n", SuggestRepair(p))
-	}
-	b.WriteString("\n")
-}

package/internal/doctor/report_test.go

@@ -1,89 +0,0 @@
-package doctor
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/opencode/savepoint/internal/testutil"
-)
-
-func TestDiagnosticReport_HasProblems(t *testing.T) {
-	root := t.TempDir()
-	report := RunAllChecks(root, "")
-	if !report.HasProblems() {
-		t.Fatal("RunAllChecks() on empty dir should have problems")
-	}
-}
-
-func TestDiagnosticReport_CleanProject(t *testing.T) {
-	root := t.TempDir()
-	writeReportProject(t, root)
-	report := RunAllChecks(root, "")
-	if report.HasProblems() {
-		t.Fatalf("RunAllChecks() on valid project should have no problems, got: config=%v router=%v structure=%v deps=%v audit=%v orphans=%v gates=%v",
-			report.ConfigCheck, report.RouterCheck, report.Structure, report.Dependencies, report.AuditState, report.Orphans, report.Gates.Results)
-	}
-}
-
-func TestDiagnosticReport_FormatContainsSections(t *testing.T) {
-	root := t.TempDir()
-	report := RunAllChecks(root, "")
-	output := report.Format()
-
-	sections := []string{
-		"Config Check",
-		"Router Check",
-		"Structure Check",
-		"Dependency Check",
-		"Audit State Check",
-		"Orphan Check",
-		"Quality Gates",
-		"PROBLEMS FOUND",
-	}
-	for _, s := range sections {
-		if !strings.Contains(output, s) {
-			t.Errorf("report.Format() missing section %q", s)
-		}
-	}
-}
-
-func TestDiagnosticReport_FormatWithEpicFilter(t *testing.T) {
-	root := t.TempDir()
-	report := RunAllChecks(root, "E03")
-	output := report.Format()
-	if !strings.Contains(output, "filtering to epic: E03") {
-		t.Errorf("report.Format() missing epic filter: %s", output)
-	}
-}
-
-func TestDiagnosticReport_FormatAllClean(t *testing.T) {
-	root := t.TempDir()
-	writeReportProject(t, root)
-	report := RunAllChecks(root, "")
-	output := report.Format()
-	if !strings.Contains(output, "ALL CLEAN") {
-		t.Errorf("report.Format() on clean project should say ALL CLEAN, got: %s", output)
-	}
-	if strings.Contains(output, "PROBLEMS FOUND") {
-		t.Errorf("report.Format() on clean project should not say PROBLEMS FOUND, got: %s", output)
-	}
-}
-
-func TestDiagnosticReport_FormatShowsRepairs(t *testing.T) {
-	root := t.TempDir()
-	report := RunAllChecks(root, "")
-	output := report.Format()
-	if !strings.Contains(output, "repair:") {
-		t.Errorf("report.Format() should include repair suggestions, got: %s", output)
-	}
-}
-
-func writeReportProject(t *testing.T, root string) {
-	t.Helper()
-	testutil.SetupMinimalProject(t, root, "v1", "E01-foo")
-	testutil.WriteTask(t, root, "v1", "E01-foo", testutil.TaskFixture{
-		Slug:      "T001-task",
-		Status:    "planned",
-		Objective: "Task",
-	})
-}

package/internal/init/clipboard.go

@@ -1,146 +0,0 @@
-package init
-
-import (
-	"bytes"
-	"fmt"
-	"os/exec"
-	"runtime"
-)
-
-type ClipboardStatus int
-
-const (
-	ClipboardCopied  ClipboardStatus = iota
-	ClipboardSkipped
-	ClipboardFailed
-)
-
-func (s ClipboardStatus) String() string {
-	switch s {
-	case ClipboardCopied:
-		return "copied"
-	case ClipboardSkipped:
-		return "skipped"
-	case ClipboardFailed:
-		return "failed"
-	default:
-		return "unknown"
-	}
-}
-
-type ClipboardResult struct {
-	Status  ClipboardStatus
-	Tool    string
-	Message string
-}
-
-func CopyToClipboard(text string) ClipboardResult {
-	switch runtime.GOOS {
-	case "windows":
-		return copyWindows(text)
-	case "darwin":
-		return copyDarwin(text)
-	case "linux":
-		return copyLinux(text)
-	default:
-		return ClipboardResult{
-			Status:  ClipboardSkipped,
-			Tool:    "",
-			Message: fmt.Sprintf("unsupported platform: %s", runtime.GOOS),
-		}
-	}
-}
-
-func copyWindows(text string) ClipboardResult {
-	if _, err := exec.LookPath("clip"); err != nil {
-		return ClipboardResult{
-			Status:  ClipboardSkipped,
-			Tool:    "clip.exe",
-			Message: "clip.exe not found in PATH",
-		}
-	}
-
-	cmd := exec.Command("clip")
-	cmd.Stdin = bytes.NewReader([]byte(text))
-	if err := cmd.Run(); err != nil {
-		return ClipboardResult{
-			Status:  ClipboardFailed,
-			Tool:    "clip.exe",
-			Message: fmt.Sprintf("clip.exe failed: %v", err),
-		}
-	}
-
-	return ClipboardResult{
-		Status:  ClipboardCopied,
-		Tool:    "clip.exe",
-		Message: "",
-	}
-}
-
-func copyDarwin(text string) ClipboardResult {
-	if _, err := exec.LookPath("pbcopy"); err != nil {
-		return ClipboardResult{
-			Status:  ClipboardSkipped,
-			Tool:    "pbcopy",
-			Message: "pbcopy not found in PATH",
-		}
-	}
-
-	cmd := exec.Command("pbcopy")
-	cmd.Stdin = bytes.NewReader([]byte(text))
-	if err := cmd.Run(); err != nil {
-		return ClipboardResult{
-			Status:  ClipboardFailed,
-			Tool:    "pbcopy",
-			Message: fmt.Sprintf("pbcopy failed: %v", err),
-		}
-	}
-
-	return ClipboardResult{
-		Status:  ClipboardCopied,
-		Tool:    "pbcopy",
-		Message: "",
-	}
-}
-
-func copyLinux(text string) ClipboardResult {
-	if path, err := exec.LookPath("xclip"); err == nil {
-		cmd := exec.Command(path, "-selection", "clipboard")
-		cmd.Stdin = bytes.NewReader([]byte(text))
-		if err := cmd.Run(); err != nil {
-			return ClipboardResult{
-				Status:  ClipboardFailed,
-				Tool:    "xclip",
-				Message: fmt.Sprintf("xclip failed: %v", err),
-			}
-		}
-		return ClipboardResult{
-			Status:  ClipboardCopied,
-			Tool:    "xclip",
-			Message: "",
-		}
-	}
-
-	if path, err := exec.LookPath("xsel"); err == nil {
-		cmd := exec.Command(path, "--input", "--clipboard")
-		cmd.Stdin = bytes.NewReader([]byte(text))
-		if err := cmd.Run(); err != nil {
-			return ClipboardResult{
-				Status:  ClipboardFailed,
-				Tool:    "xsel",
-				Message: fmt.Sprintf("xsel failed: %v", err),
-			}
-		}
-		return ClipboardResult{
-			Status:  ClipboardCopied,
-			Tool:    "xsel",
-			Message: "",
-		}
-	}
-
-	return ClipboardResult{
-		Status:  ClipboardSkipped,
-		Tool:    "",
-		Message: "no clipboard tool found (tried xclip, xsel)",
-	}
-}

package/internal/init/clipboard_test.go

@@ -1,74 +0,0 @@
-package init
-
-import (
-	"runtime"
-	"testing"
-)
-
-func TestCopyToClipboard_returnsWithoutPanic(t *testing.T) {
-	result := CopyToClipboard("test content")
-	if result.Status != ClipboardCopied &&
-		result.Status != ClipboardSkipped &&
-		result.Status != ClipboardFailed {
-		t.Fatalf("CopyToClipboard() returned unexpected status %v", result.Status)
-	}
-}
-
-func TestCopyToClipboard_resultHasNonEmptyStatusString(t *testing.T) {
-	result := CopyToClipboard("test")
-	if result.Status.String() == "" {
-		t.Fatal("Status.String() returned empty")
-	}
-}
-
-func TestCopyToClipboard_skippedOnUnsupportedPlatform(t *testing.T) {
-	if runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "linux" {
-		return
-	}
-	result := CopyToClipboard("test")
-	if result.Status != ClipboardSkipped {
-		t.Fatalf("on unsupported platform, expected ClipboardSkipped, got %v", result.Status)
-	}
-}
-
-func TestCopyToClipboard_emptyString(t *testing.T) {
-	result := CopyToClipboard("")
-	if result.Status != ClipboardCopied &&
-		result.Status != ClipboardSkipped &&
-		result.Status != ClipboardFailed {
-		t.Fatalf("CopyToClipboard('') returned unexpected status %v", result.Status)
-	}
-}
-
-func TestCopyToClipboard_toolName(t *testing.T) {
-	result := CopyToClipboard("test")
-	if result.Status == ClipboardCopied && result.Tool == "" {
-		t.Fatal("ClipboardCopied but Tool is empty")
-	}
-}
-
-func TestClipboardStatus_string(t *testing.T) {
-	tests := []struct {
-		status ClipboardStatus
-		want   string
-	}{
-		{ClipboardCopied, "copied"},
-		{ClipboardSkipped, "skipped"},
-		{ClipboardFailed, "failed"},
-	}
-	for _, tt := range tests {
-		if got := tt.status.String(); got != tt.want {
-			t.Errorf("ClipboardStatus(%d).String() = %q, want %q", tt.status, got, tt.want)
-		}
-	}
-}
-
-func TestCopyToClipboard_multipleCalls(t *testing.T) {
-	for i := 0; i < 3; i++ {
-		result := CopyToClipboard("test content")
-		if result.Status != ClipboardCopied &&
-			result.Status != ClipboardSkipped {
-			t.Fatalf("call %d: unexpected status %v", i, result.Status)
-		}
-	}
-}

package/internal/init/install.go

@@ -1,16 +0,0 @@
-package init
-
-import (
-	"fmt"
-	"os/exec"
-)
-
-func InstallDependencies(dir string) error {
-	cmd := exec.Command("npm", "install")
-	cmd.Dir = dir
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("npm install failed in %s: %w\noutput: %s", dir, err, string(out))
-	}
-	return nil
-}

package/internal/init/integration_test.go

@@ -1,197 +0,0 @@
-package init
-
-import (
-	"io/fs"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-	"testing/fstest"
-
-	"github.com/opencode/savepoint/internal/testutil"
-)
-
-func runInitPipeline(t *testing.T, dir string, force bool) string {
-	t.Helper()
-
-	if err := ValidateTarget(dir, force); err != nil {
-		t.Fatal(err)
-	}
-
-	templates := fstest.MapFS{
-		".savepoint":                            &fstest.MapFile{Mode: fs.ModeDir | 0755},
-		".savepoint/config.yml":                 &fstest.MapFile{Data: []byte("key: value")},
-		".savepoint/Design.md":                  &fstest.MapFile{Data: []byte("# {{PROJECT_NAME}} Design")},
-		".savepoint/PRD.md":                     &fstest.MapFile{Data: []byte("PRD: {{PROJECT_NAME}}")},
-		".savepoint/router.md":                  &fstest.MapFile{Data: []byte("# Router")},
-		".savepoint/visual-identity.md":         &fstest.MapFile{Data: []byte("# Visual Identity")},
-		"AGENTS.md":                             &fstest.MapFile{Data: []byte("# Agents Guide\n\nBuild: npm run build")},
-		"agent-skills/savepoint-audit/SKILL.md": &fstest.MapFile{Data: []byte("# Audit Skill")},
-	}
-
-	projectName := ProjectNameFromDir(dir)
-	if err := Scaffold(templates, dir, projectName, force); err != nil {
-		t.Fatal(err)
-	}
-
-	promptTemplates := fstest.MapFS{
-		"magic-prompt.prompt.md": &fstest.MapFile{
-			Data: []byte("<!-- AGENT: Read AGENTS.md -->\n\nProject: {{PROJECT_NAME}}\n\nStart by reading AGENTS.md"),
-		},
-	}
-
-	prompt, err := RenderMagicPrompt(promptTemplates, projectName)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return prompt
-}
-
-func TestIntegration_EmptyDirectory(t *testing.T) {
-	dir := t.TempDir()
-	prompt := runInitPipeline(t, dir, false)
-	projectName := filepath.Base(dir)
-
-	entries := []string{
-		".savepoint/config.yml",
-		".savepoint/Design.md",
-		".savepoint/PRD.md",
-		".savepoint/router.md",
-		".savepoint/visual-identity.md",
-		"AGENTS.md",
-		"agent-skills/savepoint-audit/SKILL.md",
-	}
-	for _, e := range entries {
-		if _, err := os.Stat(filepath.Join(dir, e)); err != nil {
-			t.Errorf("missing %s: %v", e, err)
-		}
-	}
-
-	data, err := os.ReadFile(filepath.Join(dir, ".savepoint", "Design.md"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(data), projectName) {
-		t.Errorf("Design.md content = %q, want to contain %q", string(data), projectName)
-	}
-
-	if !strings.Contains(prompt, projectName) {
-		t.Errorf("prompt = %q, want to contain %q", prompt, projectName)
-	}
-	if !strings.Contains(prompt, "AGENT") {
-		t.Errorf("prompt = %q, want AGENT marker", prompt)
-	}
-
-	result := CopyToClipboard(prompt)
-	if result.Status != ClipboardCopied &&
-		result.Status != ClipboardSkipped &&
-		result.Status != ClipboardFailed {
-		t.Errorf("unexpected clipboard status: %v", result.Status)
-	}
-}
-
-func TestIntegration_CompatibleProject(t *testing.T) {
-	dir := t.TempDir()
-
-	for _, name := range []string{"package.json", ".git", "README.md"} {
-		testutil.WriteFile(t, filepath.Join(dir, name), "")
-	}
-
-	prompt := runInitPipeline(t, dir, false)
-
-	if _, err := os.Stat(filepath.Join(dir, "package.json")); err != nil {
-		t.Errorf("package.json missing: %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(dir, ".savepoint", "config.yml")); err != nil {
-		t.Errorf(".savepoint/config.yml missing: %v", err)
-	}
-
-	if !strings.Contains(prompt, "AGENT") {
-		t.Errorf("prompt should contain AGENT marker")
-	}
-}
-
-func TestIntegration_NoForceOnExistingSavepoint(t *testing.T) {
-	dir := t.TempDir()
-
-	savepointDir := filepath.Join(dir, ".savepoint")
-	if err := os.Mkdir(savepointDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	err := ValidateTarget(dir, false)
-	if err == nil {
-		t.Fatal("expected error for existing .savepoint without --force")
-	}
-	if !strings.Contains(err.Error(), "already contains") {
-		t.Errorf("error = %q, want 'already contains'", err.Error())
-	}
-}
-
-func TestIntegration_ForceOverwritesExistingSavepoint(t *testing.T) {
-	dir := t.TempDir()
-
-	savepointDir := filepath.Join(dir, ".savepoint")
-	if err := os.Mkdir(savepointDir, 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	prompt := runInitPipeline(t, dir, true)
-
-	for _, path := range []string{
-		".savepoint/config.yml", ".savepoint/Design.md",
-		".savepoint/PRD.md", ".savepoint/router.md",
-	} {
-		if _, err := os.Stat(filepath.Join(dir, path)); err != nil {
-			t.Errorf("expected %s to exist after --force: %v", path, err)
-		}
-	}
-
-	if !strings.Contains(prompt, "AGENT") {
-		t.Errorf("prompt should contain AGENT marker")
-	}
-}
-
-func TestIntegration_InstallDependencies(t *testing.T) {
-	if _, err := exec.LookPath("npm"); err != nil {
-		t.Skip("npm not found in PATH, skipping install test")
-	}
-
-	dir := t.TempDir()
-
-	packageJSON := filepath.Join(dir, "package.json")
-	testutil.WriteFile(t, packageJSON, `{"name":"test","version":"0.0.0"}`)
-
-	if err := ValidateTarget(dir, false); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := InstallDependencies(dir); err != nil {
-		t.Fatalf("InstallDependencies() error = %v", err)
-	}
-
-	if _, err := os.Stat(filepath.Join(dir, "package-lock.json")); err != nil {
-		t.Errorf("package-lock.json not created after npm install: %v", err)
-	}
-}
-
-func TestIntegration_MagicPromptInOutput(t *testing.T) {
-	dir := t.TempDir()
-	prompt := runInitPipeline(t, dir, false)
-	projectName := filepath.Base(dir)
-
-	expectedParts := []string{
-		projectName,
-		"AGENT",
-		"AGENTS.md",
-		"Project",
-	}
-	for _, part := range expectedParts {
-		if !strings.Contains(prompt, part) {
-			t.Errorf("prompt missing %q", part)
-		}
-	}
-}

package/internal/init/prompt.go

@@ -1,14 +0,0 @@
-package init
-
-import (
-	"fmt"
-	"io/fs"
-)
-
-func RenderMagicPrompt(templates fs.FS, projectName string) (string, error) {
-	content, err := fs.ReadFile(templates, "magic-prompt.prompt.md")
-	if err != nil {
-		return "", fmt.Errorf("read magic prompt template: %w", err)
-	}
-	return interpolate(string(content), projectName), nil
-}