savepoint 1.0.1 → 1.0.3

package/internal/doctor/report.go

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,146 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,14 @@
+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
+}