savepoint 1.0.2 → 1.0.3

package/internal/init/write_test.go

@@ -0,0 +1,91 @@
+package init
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+func TestAtomicWrite_createsFile(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "output.txt")
+
+	if err := AtomicWrite(target, []byte("hello")); err != nil {
+		t.Fatalf("AtomicWrite() error = %v", err)
+	}
+
+	data, err := os.ReadFile(target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "hello" {
+		t.Fatalf("got %q, want %q", string(data), "hello")
+	}
+}
+
+func TestAtomicWrite_replacesExistingFile(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "output.txt")
+	testutil.WriteFile(t, target, "old")
+
+	if err := AtomicWrite(target, []byte("new")); err != nil {
+		t.Fatalf("AtomicWrite() error = %v", err)
+	}
+
+	data, err := os.ReadFile(target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "new" {
+		t.Fatalf("got %q, want %q", string(data), "new")
+	}
+
+	assertNoWriteArtifacts(t, dir)
+}
+
+func TestAtomicWrite_noTempFileLeftBehind(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "output.txt")
+
+	if err := AtomicWrite(target, []byte("data")); err != nil {
+		t.Fatalf("AtomicWrite() error = %v", err)
+	}
+
+	assertNoWriteArtifacts(t, dir)
+}
+
+func TestAtomicWrite_handlesNestedDirectories(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "deep", "nested", "output.txt")
+
+	// Parent directories must exist before calling AtomicWrite
+	testutil.MkdirAll(t, filepath.Dir(target))
+
+	if err := AtomicWrite(target, []byte("nested")); err != nil {
+		t.Fatalf("AtomicWrite() error = %v", err)
+	}
+
+	if _, err := os.Stat(target); err != nil {
+		t.Errorf("target not created: %v", err)
+	}
+}
+
+func assertNoWriteArtifacts(t *testing.T, dir string) {
+	t.Helper()
+
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, e := range entries {
+		if strings.HasPrefix(e.Name(), ".tmp-") && strings.HasSuffix(e.Name(), ".write") {
+			t.Errorf("temp file %q left behind after successful write", e.Name())
+		}
+		if strings.HasSuffix(e.Name(), ".savepoint-bak") {
+			t.Errorf("backup file %q left behind after successful write", e.Name())
+		}
+	}
+}

package/internal/styles/styles_test.go

@@ -0,0 +1,133 @@
+package styles
+
+import (
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+func TestPaletteConstants_present(t *testing.T) {
+	// Truecolor tier
+	if Background == "" {
+		t.Error("Background constant is empty")
+	}
+	if Surface == "" {
+		t.Error("Surface constant is empty")
+	}
+	if Surface2 == "" {
+		t.Error("Surface2 constant is empty")
+	}
+	if Border == "" {
+		t.Error("Border constant is empty")
+	}
+	if BorderSubtle == "" {
+		t.Error("BorderSubtle constant is empty")
+	}
+	if PrimaryText == "" {
+		t.Error("PrimaryText constant is empty")
+	}
+	if AtariOrange == "" {
+		t.Error("AtariOrange constant is empty")
+	}
+	if NPPGreen == "" {
+		t.Error("NPPGreen constant is empty")
+	}
+	if VibePurple == "" {
+		t.Error("VibePurple constant is empty")
+	}
+	if Dim == "" {
+		t.Error("Dim constant is empty")
+	}
+}
+
+func TestPaletteConstants_256tier(t *testing.T) {
+	if Background256 == "" {
+		t.Error("Background256 constant is empty")
+	}
+	if Surface256 == "" {
+		t.Error("Surface256 constant is empty")
+	}
+	if Surface2256 == "" {
+		t.Error("Surface2256 constant is empty")
+	}
+	if Border256 == "" {
+		t.Error("Border256 constant is empty")
+	}
+	if BorderSubtle256 == "" {
+		t.Error("BorderSubtle256 constant is empty")
+	}
+	if PrimaryText256 == "" {
+		t.Error("PrimaryText256 constant is empty")
+	}
+	if AtariOrange256 == "" {
+		t.Error("AtariOrange256 constant is empty")
+	}
+	if NPPGreen256 == "" {
+		t.Error("NPPGreen256 constant is empty")
+	}
+	if VibePurple256 == "" {
+		t.Error("VibePurple256 constant is empty")
+	}
+	if Dim256 == "" {
+		t.Error("Dim256 constant is empty")
+	}
+}
+
+func TestPaletteConstants_16tier(t *testing.T) {
+	if Background16 == "" {
+		t.Error("Background16 constant is empty")
+	}
+	if Surface16 == "" {
+		t.Error("Surface16 constant is empty")
+	}
+	if Surface216 == "" {
+		t.Error("Surface216 constant is empty")
+	}
+	if Border16 == "" {
+		t.Error("Border16 constant is empty")
+	}
+	if BorderSubtle16 == "" {
+		t.Error("BorderSubtle16 constant is empty")
+	}
+	if PrimaryText16 == "" {
+		t.Error("PrimaryText16 constant is empty")
+	}
+	if AtariOrange16 == "" {
+		t.Error("AtariOrange16 constant is empty")
+	}
+	if NPPGreen16 == "" {
+		t.Error("NPPGreen16 constant is empty")
+	}
+	if VibePurple16 == "" {
+		t.Error("VibePurple16 constant is empty")
+	}
+}
+
+func TestColor(t *testing.T) {
+	c := color("#FF0000", "196", "9")
+	expected := lipgloss.CompleteColor{TrueColor: "#FF0000", ANSI256: "196", ANSI: "9"}
+	if c != expected {
+		t.Errorf("color() = %+v, want %+v", c, expected)
+	}
+}
+
+func TestColor_usesPaletteConstants(t *testing.T) {
+	c := color(AtariOrange, AtariOrange256, AtariOrange16)
+	if c.TrueColor != AtariOrange {
+		t.Errorf("color TrueColor = %q, want %q", c.TrueColor, AtariOrange)
+	}
+	if c.ANSI256 != AtariOrange256 {
+		t.Errorf("color ANSI256 = %q, want %q", c.ANSI256, AtariOrange256)
+	}
+	if c.ANSI != AtariOrange16 {
+		t.Errorf("color ANSI = %q, want %q", c.ANSI, AtariOrange16)
+	}
+}
+
+func TestColor_returnsCompleteColor(t *testing.T) {
+	var cc lipgloss.CompleteColor
+	cc = color(Background, Background256, Background16)
+	if cc.TrueColor != Background {
+		t.Errorf("expected TrueColor %q, got %q", Background, cc.TrueColor)
+	}
+}

package/internal/testutil/fixture.go

@@ -0,0 +1,113 @@
+package testutil
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// WriteRouter writes a router.md at root with the given fields.
+// If nextAction is empty, it defaults to "".
+func WriteRouter(t testing.TB, root, state, release, epic, task, nextAction string) {
+	t.Helper()
+	if nextAction == "" {
+		nextAction = `""`
+	} else {
+		nextAction = `"` + nextAction + `"`
+	}
+	if task == "" {
+		task = `""`
+	} else {
+		task = `"` + task + `"`
+	}
+	content := "# Agent State Machine\n\n## Current state\n\n```yaml\nstate: " + state + "\nrelease: " + release + "\nepic: " + epic + "\ntask: " + task + "\nnext_action: " + nextAction + "\n```\n"
+	WriteFile(t, filepath.Join(root, "router.md"), content)
+}
+
+// WriteReleasePRD writes a minimal release PRD file.
+func WriteReleasePRD(t testing.TB, releasePath string) {
+	t.Helper()
+	releaseID := filepath.Base(releasePath)
+	WriteFile(t, filepath.Join(releasePath, releaseID+"-PRD.md"), "---\ntype: project-prd\nstatus: active\n---\n\n# Release\n")
+}
+
+// WriteEpicDetail writes a minimal epic detail file.
+func WriteEpicDetail(t testing.TB, epicPath, prefix string) {
+	t.Helper()
+	WriteFile(t, filepath.Join(epicPath, prefix+"-Detail.md"), "---\ntype: epic-design\nstatus: planned\n---\n\n# Epic\n")
+}
+
+// TaskFixture describes a task file to create.
+type TaskFixture struct {
+	Slug      string            // e.g. "T001-task" — becomes filename
+	Release   string            // optional; omitted if empty
+	Status    string
+	Phase     string            // optional; omitted if empty
+	Objective string
+	DependsOn []string          // optional; defaults to empty list
+	Body      string            // optional; defaults to minimal body
+	Extra     map[string]string // optional; extra frontmatter fields
+}
+
+// WriteTask writes a task file in the savepoint directory structure.
+func WriteTask(t testing.TB, root, release, epic string, task TaskFixture) {
+	t.Helper()
+	path := filepath.Join(root, "releases", release, "epics", epic, "tasks", task.Slug+".md")
+	id := epic + "/" + task.Slug
+
+	var b strings.Builder
+	b.WriteString("---\n")
+	b.WriteString("id: " + id + "\n")
+	if task.Release != "" {
+		b.WriteString("release: " + task.Release + "\n")
+	}
+	b.WriteString("status: " + task.Status + "\n")
+	if task.Phase != "" {
+		b.WriteString("phase: " + task.Phase + "\n")
+	}
+	b.WriteString("objective: \"" + task.Objective + "\"\n")
+
+	deps := "[]"
+	if len(task.DependsOn) > 0 {
+		quoted := make([]string, len(task.DependsOn))
+		for i, d := range task.DependsOn {
+			quoted[i] = fmt.Sprintf("%q", d)
+		}
+		deps = "[" + strings.Join(quoted, ", ") + "]"
+	}
+	b.WriteString("depends_on: " + deps + "\n")
+	for k, v := range task.Extra {
+		b.WriteString(k + ": " + v + "\n")
+	}
+	b.WriteString("---\n\n")
+
+	if task.Body != "" {
+		b.WriteString(task.Body)
+	} else {
+		b.WriteString("# " + task.Slug + "\n\n## Acceptance Criteria\n\n- it works\n")
+	}
+
+	WriteFile(t, path, b.String())
+}
+
+// SetupMinimalProject creates a minimal valid savepoint project structure.
+// It creates config.yml, router.md, release PRD, epic detail, and the directory tree.
+func SetupMinimalProject(t testing.TB, root, release, epic string) {
+	t.Helper()
+	releasePath := filepath.Join(root, "releases", release)
+	//nolint:gocritic // assignment to same epicPath variable is fine
+	epicPath := filepath.Join(releasePath, "epics", epic)
+	tasksPath := filepath.Join(epicPath, "tasks")
+	MkdirAll(t, tasksPath)
+
+	prefix := epic
+	if idx := strings.IndexByte(epic, '-'); idx != -1 {
+		prefix = epic[:idx]
+	}
+
+	WriteFile(t, filepath.Join(root, "config.yml"), "quality_gates:\n  lint: null\n  typecheck: null\n  test: null\ntheme:\n  bg: \"#000\"\n")
+	WriteRouter(t, root, "task-building", release, epic, "", "")
+	WriteReleasePRD(t, releasePath)
+	WriteEpicDetail(t, epicPath, prefix)
+}

package/internal/testutil/fs.go

@@ -0,0 +1,26 @@
+package testutil
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// WriteFile writes content to path, creating parent directories if needed.
+func WriteFile(t testing.TB, path, content string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(content), 0644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// MkdirAll creates directories with mode 0755, fatal on error.
+func MkdirAll(t testing.TB, path string) {
+	t.Helper()
+	if err := os.MkdirAll(path, 0755); err != nil {
+		t.Fatal(err)
+	}
+}

package/main.go

@@ -1,20 +1,117 @@
 package main
 
 import (
+	"context"
+	"embed"
 	"fmt"
+	"io/fs"
 	"os"
 
+	"github.com/opencode/savepoint/cmd"
 	"github.com/opencode/savepoint/internal/board"
+	"github.com/opencode/savepoint/internal/data"
+	"github.com/opencode/savepoint/internal/doctor"
+	savepointinit "github.com/opencode/savepoint/internal/init"
 )
 
+//go:embed templates/project
+//go:embed templates/project/.savepoint
+//go:embed templates/prompts
+var projectTemplates embed.FS
+
 var version = "dev"
 
 func main() {
-	if len(os.Args) > 1 && os.Args[1] == "--version" {
-		fmt.Println(version)
-		os.Exit(0)
+	if len(os.Args) > 1 {
+		switch os.Args[1] {
+		case "--version":
+			fmt.Println(version)
+			os.Exit(0)
+		case "init":
+			if err := cmd.RunInit(context.Background(), os.Args[2:], os.Stdout, initRunner); err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				os.Exit(1)
+			}
+			os.Exit(0)
+		case "board":
+			if err := cmd.RunBoard(context.Background(), os.Args[2:], os.Stdout, func(opts cmd.BoardOptions) error {
+				return board.RunWithFilters(opts.Release, opts.Epic)
+			}); err != nil {
+				fmt.Fprintln(os.Stderr, err)
+				os.Exit(1)
+			}
+			os.Exit(0)
+		case "doctor":
+			code, err := cmd.RunDoctor(context.Background(), os.Args[2:], os.Stdout, func(opts cmd.DoctorOptions) (int, error) {
+				return runDoctorChecks(opts)
+			})
+			if err != nil {
+				fmt.Fprintln(os.Stderr, err)
+			}
+			os.Exit(code)
+		}
 	}
 	if err := board.Run(); err != nil {
 		panic(err)
 	}
-}
+}
+
+func runDoctorChecks(opts cmd.DoctorOptions) (int, error) {
+	discover := data.NewDiscover()
+	root, err := discover.FindSavepointRoot(".")
+	if err != nil {
+		return 2, fmt.Errorf("savepoint root not found: %w", err)
+	}
+
+	report := doctor.RunAllChecks(root, opts.Epic)
+	fmt.Fprint(os.Stdout, report.Format())
+
+	if report.HasProblems() {
+		return 1, nil
+	}
+	return 0, nil
+}
+
+func initRunner(ctx context.Context, opts cmd.InitOptions) error {
+	if err := savepointinit.ValidateTarget(opts.Dir, opts.Force); err != nil {
+		return err
+	}
+
+	sub, err := fs.Sub(projectTemplates, "templates/project")
+	if err != nil {
+		return fmt.Errorf("cannot load templates: %w", err)
+	}
+
+	projectName := savepointinit.ProjectNameFromDir(opts.Dir)
+	if err := savepointinit.Scaffold(sub, opts.Dir, projectName, opts.Force); err != nil {
+		return err
+	}
+
+	promptSub, err := fs.Sub(projectTemplates, "templates/prompts")
+	if err != nil {
+		return fmt.Errorf("cannot load prompt templates: %w", err)
+	}
+
+	prompt, err := savepointinit.RenderMagicPrompt(promptSub, projectName)
+	if err != nil {
+		return fmt.Errorf("render magic prompt: %w", err)
+	}
+
+	fmt.Println(prompt)
+
+	result := savepointinit.CopyToClipboard(prompt)
+	switch result.Status {
+	case savepointinit.ClipboardCopied:
+		fmt.Fprintf(os.Stderr, "prompt copied to clipboard via %s\n", result.Tool)
+	case savepointinit.ClipboardFailed:
+		fmt.Fprintf(os.Stderr, "warning: clipboard copy failed: %s\n", result.Message)
+	}
+
+	if opts.Install {
+		if err := savepointinit.InstallDependencies(opts.Dir); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "savepoint",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "It’s a simple, file-based state machine and cinematic Terminal UI (TUI) designed to force you—and your agent (Claude, Cursor, Aider, Gemini)—to slow down, write down what you're actually building, and check your work before moving on.",
   "keywords": [
     "board",
@@ -21,6 +21,6 @@
     "savepoint": "./savepoint"
   },
   "scripts": {
-    "test": "savepoint init"
+    "test": "echo \"Run 'make test' for Go tests\""
   }
 }