savepoint 1.0.2 → 1.0.4

package/internal/init/prompt_test.go

@@ -0,0 +1,77 @@
+package init
+
+import (
+	"strings"
+	"testing"
+	"testing/fstest"
+)
+
+func TestRenderMagicPrompt_rendersTemplate(t *testing.T) {
+	templates := fstest.MapFS{
+		"magic-prompt.prompt.md": &fstest.MapFile{
+			Data: []byte("Project: {{PROJECT_NAME}}"),
+		},
+	}
+
+	got, err := RenderMagicPrompt(templates, "myapp")
+	if err != nil {
+		t.Fatalf("RenderMagicPrompt() error = %v", err)
+	}
+
+	want := "Project: myapp"
+	if got != want {
+		t.Fatalf("RenderMagicPrompt() = %q, want %q", got, want)
+	}
+}
+
+func TestRenderMagicPrompt_interpolatesAllVariables(t *testing.T) {
+	templates := fstest.MapFS{
+		"magic-prompt.prompt.md": &fstest.MapFile{
+			Data: []byte("{{PROJECT_NAME}} v{{RELEASE_NUMBER}}"),
+		},
+	}
+
+	got, err := RenderMagicPrompt(templates, "myapp")
+	if err != nil {
+		t.Fatalf("RenderMagicPrompt() error = %v", err)
+	}
+
+	want := "myapp v1"
+	if got != want {
+		t.Fatalf("RenderMagicPrompt() = %q, want %q", got, want)
+	}
+}
+
+func TestRenderMagicPrompt_handlesMissingTemplate(t *testing.T) {
+	_, err := RenderMagicPrompt(fstest.MapFS{}, "myapp")
+	if err == nil {
+		t.Fatal("RenderMagicPrompt() expected error for missing template")
+	}
+}
+
+func TestRenderMagicPrompt_usesEmbeddedTemplate(t *testing.T) {
+	templates := fstest.MapFS{
+		"magic-prompt.prompt.md": &fstest.MapFile{
+			Data: []byte("<!-- AGENT: Read AGENTS.md -->\n\nProject: {{PROJECT_NAME}}"),
+		},
+	}
+
+	got, err := RenderMagicPrompt(templates, "my-project")
+	if err != nil {
+		t.Fatalf("RenderMagicPrompt() error = %v", err)
+	}
+
+	if !strings.Contains(got, "my-project") {
+		t.Fatalf("RenderMagicPrompt() = %q, does not contain project name", got)
+	}
+	if !strings.Contains(got, "AGENT") {
+		t.Fatalf("RenderMagicPrompt() = %q, does not contain template content", got)
+	}
+}
+
+func TestRenderMagicPrompt_handlesEmptyMapFS(t *testing.T) {
+	_, err := RenderMagicPrompt(fstest.MapFS{}, "")
+	if err == nil {
+		t.Fatal("RenderMagicPrompt() expected error for empty MapFS")
+	}
+}

package/internal/init/scaffold.go

@@ -0,0 +1,59 @@
+package init
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const ReleaseNumber = "1"
+
+func Scaffold(templates fs.FS, targetDir, projectName string, force bool) error {
+	return fs.WalkDir(templates, ".", func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return fmt.Errorf("walk error at %s: %w", path, err)
+		}
+
+		targetPath := filepath.Join(targetDir, path)
+
+		if d.IsDir() {
+			if path == "." {
+				return nil
+			}
+			return os.MkdirAll(targetPath, 0755)
+		}
+
+		if path == "." {
+			return nil
+		}
+
+		content, err := fs.ReadFile(templates, path)
+		if err != nil {
+			return fmt.Errorf("read %s: %w", path, err)
+		}
+
+		interpolated := interpolate(string(content), projectName)
+
+		if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+			return fmt.Errorf("create parent dirs for %s: %w", targetPath, err)
+		}
+
+		return AtomicWrite(targetPath, []byte(interpolated))
+	})
+}
+
+func ProjectNameFromDir(dir string) string {
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return "my-project"
+	}
+	return filepath.Base(abs)
+}
+
+func interpolate(content, projectName string) string {
+	result := strings.ReplaceAll(content, "{{PROJECT_NAME}}", projectName)
+	result = strings.ReplaceAll(result, "{{RELEASE_NUMBER}}", ReleaseNumber)
+	return result
+}

package/internal/init/scaffold_test.go

@@ -0,0 +1,179 @@
+package init
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+	"testing/fstest"
+
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+func TestScaffold_createsDirectories(t *testing.T) {
+	target := t.TempDir()
+	templates := fstest.MapFS{
+		".savepoint":            &fstest.MapFile{Mode: fs.ModeDir | 0755},
+		".savepoint/config.yml": &fstest.MapFile{Data: []byte("key: value")},
+		"AGENTS.md":             &fstest.MapFile{Data: []byte("# Agents Guide")},
+	}
+
+	if err := Scaffold(templates, target, "myapp", false); err != nil {
+		t.Fatalf("Scaffold() error = %v", err)
+	}
+
+	if _, err := os.Stat(filepath.Join(target, ".savepoint", "config.yml")); err != nil {
+		t.Errorf(".savepoint/config.yml not created: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(target, "AGENTS.md")); err != nil {
+		t.Errorf("AGENTS.md not created: %v", err)
+	}
+}
+
+func TestScaffold_interpolatesProjectName(t *testing.T) {
+	target := t.TempDir()
+	templates := fstest.MapFS{
+		"Design.md": &fstest.MapFile{Data: []byte("# {{PROJECT_NAME}} Design")},
+		"PRD.md":    &fstest.MapFile{Data: []byte("Project: {{PROJECT_NAME}}")},
+	}
+
+	if err := Scaffold(templates, target, "myapp", false); err != nil {
+		t.Fatalf("Scaffold() error = %v", err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(target, "Design.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "# myapp Design" {
+		t.Fatalf("Design.md = %q, want %q", string(data), "# myapp Design")
+	}
+
+	data, err = os.ReadFile(filepath.Join(target, "PRD.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "Project: myapp" {
+		t.Fatalf("PRD.md = %q, want %q", string(data), "Project: myapp")
+	}
+}
+
+func TestScaffold_interpolatesReleaseNumber(t *testing.T) {
+	target := t.TempDir()
+	templates := fstest.MapFS{
+		"AGENTS.md": &fstest.MapFile{Data: []byte("release: v{{RELEASE_NUMBER}}")},
+	}
+
+	if err := Scaffold(templates, target, "myapp", false); err != nil {
+		t.Fatalf("Scaffold() error = %v", err)
+	}
+
+	data, err := os.ReadFile(filepath.Join(target, "AGENTS.md"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "release: v1" {
+		t.Fatalf("AGENTS.md = %q, want %q", string(data), "release: v1")
+	}
+}
+
+func TestScaffold_createsParentDirs(t *testing.T) {
+	target := t.TempDir()
+	templates := fstest.MapFS{
+		"deep/nested/dir/file.txt": &fstest.MapFile{Data: []byte("content")},
+	}
+
+	if err := Scaffold(templates, target, "myapp", false); err != nil {
+		t.Fatalf("Scaffold() error = %v", err)
+	}
+
+	path := filepath.Join(target, "deep", "nested", "dir", "file.txt")
+	if _, err := os.Stat(path); err != nil {
+		t.Errorf("deep/nested/dir/file.txt not created: %v", err)
+	}
+}
+
+func TestScaffold_overwritesWithForce(t *testing.T) {
+	target := t.TempDir()
+	existingPath := filepath.Join(target, "file.txt")
+	testutil.WriteFile(t, existingPath, "old")
+
+	templates := fstest.MapFS{
+		"file.txt": &fstest.MapFile{Data: []byte("new")},
+	}
+
+	if err := Scaffold(templates, target, "myapp", true); err != nil {
+		t.Fatalf("Scaffold() with force error = %v", err)
+	}
+
+	data, err := os.ReadFile(existingPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(data) != "new" {
+		t.Fatalf("file.txt = %q, want %q", string(data), "new")
+	}
+}
+
+func TestScaffold_overwritesExistingAfterValidation(t *testing.T) {
+	target := t.TempDir()
+	existingPath := filepath.Join(target, "file.txt")
+	testutil.WriteFile(t, existingPath, "old")
+
+	templates := fstest.MapFS{
+		"file.txt": &fstest.MapFile{Data: []byte("new")},
+	}
+
+	// Without force, scaffold still overwrites since validation
+	// guarantees no conflicts. The force param is for explicit override.
+	if err := Scaffold(templates, target, "myapp", false); err != nil {
+		t.Fatalf("Scaffold() error = %v", err)
+	}
+
+	data, err := os.ReadFile(existingPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Without force we still write (validation has already cleared conflicts)
+	if string(data) != "new" {
+		t.Fatalf("file.txt = %q, want %q", string(data), "new")
+	}
+}
+
+func TestProjectNameFromDir(t *testing.T) {
+	dir := t.TempDir()
+	name := filepath.Base(dir)
+	got := ProjectNameFromDir(dir)
+	if got != name {
+		t.Fatalf("ProjectNameFromDir(%q) = %q, want %q", dir, got, name)
+	}
+}
+
+func TestProjectNameFromDir_dot(t *testing.T) {
+	got := ProjectNameFromDir(".")
+	cwd, _ := os.Getwd()
+	want := filepath.Base(cwd)
+	if got != want {
+		t.Fatalf("ProjectNameFromDir(\".\") = %q, want %q", got, want)
+	}
+}
+
+func TestInterpolate(t *testing.T) {
+	tests := []struct {
+		input string
+		name  string
+		want  string
+	}{
+		{input: "# {{PROJECT_NAME}}", name: "myapp", want: "# myapp"},
+		{input: "v{{RELEASE_NUMBER}}", name: "myapp", want: "v1"},
+		{input: "{{PROJECT_NAME}} v{{RELEASE_NUMBER}}", name: "foo", want: "foo v1"},
+		{input: "no variables", name: "myapp", want: "no variables"},
+	}
+
+	for _, tt := range tests {
+		got := interpolate(tt.input, tt.name)
+		if got != tt.want {
+			t.Errorf("interpolate(%q, %q) = %q, want %q", tt.input, tt.name, got, tt.want)
+		}
+	}
+}

package/internal/init/template_freshness_test.go

@@ -0,0 +1,56 @@
+package init
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestProjectTemplatesUseCurrentWorkflow(t *testing.T) {
+	root := filepath.Join("..", "..")
+	agents := readTemplate(t, root, "templates", "project", "AGENTS.md")
+	router := readTemplate(t, root, "templates", "project", ".savepoint", "router.md")
+	auditSkill := readTemplate(t, root, "templates", "project", "agent-skills", "savepoint-audit", "SKILL.md")
+
+	assertNotContains(t, agents, "`phase` (build/test/audit)")
+	assertNotContains(t, agents, "npm run build && npm run test")
+	assertContains(t, agents, "`stage` (build/test/audit): **required** when `status: in_progress`")
+	assertContains(t, agents, "make build && make test")
+
+	assertNotContains(t, router, ".savepoint/audit/{E##-epic}/snapshot.md")
+	assertNotContains(t, router, ".savepoint/audit/{release}/{E##-epic}/proposals.md")
+	assertNotContains(t, router, ".savepoint/audit/{E##-epic}/proposals.md")
+	assertContains(t, router, ".savepoint/releases/{release}/epics/{E##-epic}/E##-Audit.md")
+	assertContains(t, router, "`## Proposed Changes` — admin/apply metadata")
+	assertContains(t, agents, "During audit apply/close, update the same `E##-Audit.md` visible sections")
+	assertContains(t, auditSkill, "Update `E##-Audit.md` visible sections")
+	assertContains(t, auditSkill, "Updated audit findings")
+}
+
+func readTemplate(t *testing.T, root string, parts ...string) string {
+	t.Helper()
+
+	path := filepath.Join(append([]string{root}, parts...)...)
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read template %s: %v", path, err)
+	}
+	return string(data)
+}
+
+func assertContains(t *testing.T, content, want string) {
+	t.Helper()
+
+	if !strings.Contains(content, want) {
+		t.Fatalf("template missing %q", want)
+	}
+}
+
+func assertNotContains(t *testing.T, content, stale string) {
+	t.Helper()
+
+	if strings.Contains(content, stale) {
+		t.Fatalf("template contains stale text %q", stale)
+	}
+}

package/internal/init/validate.go

@@ -0,0 +1,85 @@
+package init
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+var (
+	ErrTargetMissing    = errors.New("target directory does not exist")
+	ErrNotADirectory    = errors.New("target is not a directory")
+	ErrPermissionDenied = errors.New("permission denied")
+	ErrAlreadyInit      = errors.New("target already contains .savepoint directory")
+	ErrConflict         = errors.New("target has conflicting files")
+)
+
+var conflictingFiles = []string{
+	"AGENTS.md",
+	"agent-skills",
+}
+
+type ValidationError struct {
+	Type    error
+	Message string
+}
+
+func (e *ValidationError) Error() string { return e.Message }
+func (e *ValidationError) Unwrap() error { return e.Type }
+
+func ValidateTarget(path string, force bool) error {
+	abs, err := filepath.Abs(path)
+	if err != nil {
+		return &ValidationError{Type: ErrPermissionDenied, Message: fmt.Sprintf("cannot resolve path %q: permission denied", path)}
+	}
+
+	info, err := os.Stat(abs)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return &ValidationError{Type: ErrTargetMissing, Message: fmt.Sprintf("target directory %q does not exist", path)}
+		}
+		if os.IsPermission(err) {
+			return &ValidationError{Type: ErrPermissionDenied, Message: fmt.Sprintf("permission denied accessing %q", path)}
+		}
+		return &ValidationError{Type: ErrPermissionDenied, Message: fmt.Sprintf("cannot access %q: %v", path, err)}
+	}
+
+	if !info.IsDir() {
+		return &ValidationError{Type: ErrNotADirectory, Message: fmt.Sprintf("target %q is not a directory", path)}
+	}
+
+	if err := checkWritable(abs); err != nil {
+		return err
+	}
+
+	savepointDir := filepath.Join(abs, ".savepoint")
+	if _, err := os.Stat(savepointDir); err == nil {
+		if !force {
+			return &ValidationError{Type: ErrAlreadyInit, Message: fmt.Sprintf("target %q already contains a .savepoint directory (use --force to overwrite)", path)}
+		}
+	}
+
+	if !force {
+		for _, name := range conflictingFiles {
+			conflictPath := filepath.Join(abs, name)
+			if _, err := os.Stat(conflictPath); err == nil {
+				return &ValidationError{Type: ErrConflict, Message: fmt.Sprintf("target %q has conflicting file %q (use --force to overwrite)", path, name)}
+			}
+		}
+	}
+
+	return nil
+}
+
+func checkWritable(dir string) error {
+	testFile := filepath.Join(dir, ".savepoint-write-test")
+	if err := os.WriteFile(testFile, []byte{}, 0644); err != nil {
+		if os.IsPermission(err) {
+			return &ValidationError{Type: ErrPermissionDenied, Message: fmt.Sprintf("target directory %q is not writable", dir)}
+		}
+		return &ValidationError{Type: ErrPermissionDenied, Message: fmt.Sprintf("cannot write to %q: %v", dir, err)}
+	}
+	os.Remove(testFile)
+	return nil
+}

package/internal/init/validate_test.go

@@ -0,0 +1,141 @@
+package init
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/opencode/savepoint/internal/testutil"
+)
+
+func TestValidateTarget_missing(t *testing.T) {
+	err := ValidateTarget(filepath.Join(t.TempDir(), "nonexistent"), false)
+	if err == nil {
+		t.Fatal("ValidateTarget() expected error for missing directory")
+	}
+	if !errors.Is(err, ErrTargetMissing) {
+		t.Fatalf("ValidateTarget() error type = %v, want ErrTargetMissing", err)
+	}
+}
+
+func TestValidateTarget_notADirectory(t *testing.T) {
+	dir := t.TempDir()
+	filePath := filepath.Join(dir, "file")
+	testutil.WriteFile(t, filePath, "content")
+
+	err := ValidateTarget(filePath, false)
+	if err == nil {
+		t.Fatal("ValidateTarget() expected error for non-directory")
+	}
+	if !errors.Is(err, ErrNotADirectory) {
+		t.Fatalf("ValidateTarget() error type = %v, want ErrNotADirectory", err)
+	}
+}
+
+func TestValidateTarget_empty(t *testing.T) {
+	dir := t.TempDir()
+
+	err := ValidateTarget(dir, false)
+	if err != nil {
+		t.Fatalf("ValidateTarget() error = %v, want nil for empty directory", err)
+	}
+}
+
+func TestValidateTarget_hasCompatibleFiles(t *testing.T) {
+	dir := t.TempDir()
+	for _, name := range []string{"package.json", ".git", "README.md"} {
+		testutil.WriteFile(t, filepath.Join(dir, name), "")
+	}
+
+	err := ValidateTarget(dir, false)
+	if err != nil {
+		t.Fatalf("ValidateTarget() error = %v, want nil for compatible files", err)
+	}
+}
+
+func TestValidateTarget_existingSavepoint(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("ValidateTarget() expected error for existing .savepoint")
+	}
+	if !errors.Is(err, ErrAlreadyInit) {
+		t.Fatalf("ValidateTarget() error type = %v, want ErrAlreadyInit", err)
+	}
+}
+
+func TestValidateTarget_existingSavepointWithForce(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, true)
+	if err != nil {
+		t.Fatalf("ValidateTarget() with --force error = %v, want nil", err)
+	}
+}
+
+func TestValidateTarget_conflictingFile(t *testing.T) {
+	dir := t.TempDir()
+	testutil.WriteFile(t, filepath.Join(dir, "AGENTS.md"), "existing")
+
+	err := ValidateTarget(dir, false)
+	if err == nil {
+		t.Fatal("ValidateTarget() expected error for conflicting AGENTS.md")
+	}
+	if !errors.Is(err, ErrConflict) {
+		t.Fatalf("ValidateTarget() error type = %v, want ErrConflict", err)
+	}
+}
+
+func TestValidateTarget_conflictingFileWithForce(t *testing.T) {
+	dir := t.TempDir()
+	testutil.WriteFile(t, filepath.Join(dir, "AGENTS.md"), "existing")
+
+	err := ValidateTarget(dir, true)
+	if err != nil {
+		t.Fatalf("ValidateTarget() with --force error = %v, want nil", err)
+	}
+}
+
+func TestValidateTarget_conflictingAgentSkillsDirectory(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "agent-skills"), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	err := ValidateTarget(dir, false)
+	if err == nil {
+		t.Fatal("ValidateTarget() expected error for conflicting agent-skills directory")
+	}
+	if !errors.Is(err, ErrConflict) {
+		t.Fatalf("ValidateTarget() error type = %v, want ErrConflict", err)
+	}
+}
+
+func TestValidateTarget_conflictingAgentSkillsDirectoryWithForce(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "agent-skills"), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	err := ValidateTarget(dir, true)
+	if err != nil {
+		t.Fatalf("ValidateTarget() with --force error = %v, want nil", err)
+	}
+}
+
+func TestValidateTarget_emptyStringResolvesToDot(t *testing.T) {
+	err := ValidateTarget("", false)
+	if err != nil {
+		t.Fatalf("ValidateTarget(\"\") error = %v, want nil (resolves to cwd)", err)
+	}
+}

package/internal/init/write.go

@@ -0,0 +1,73 @@
+package init
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func AtomicWrite(target string, content []byte) error {
+	dir := filepath.Dir(target)
+	tmp, err := os.CreateTemp(dir, ".tmp-*.write")
+	if err != nil {
+		return fmt.Errorf("create temp file: %w", err)
+	}
+	tmpName := tmp.Name()
+
+	success := false
+	defer func() {
+		if !success {
+			tmp.Close()
+			os.Remove(tmpName)
+		}
+	}()
+
+	if _, err := tmp.Write(content); err != nil {
+		return fmt.Errorf("write temp file: %w", err)
+	}
+
+	if err := tmp.Sync(); err != nil {
+		return fmt.Errorf("sync temp file: %w", err)
+	}
+
+	if err := tmp.Close(); err != nil {
+		return fmt.Errorf("close temp file: %w", err)
+	}
+
+	if err := replaceFile(tmpName, target); err != nil {
+		return fmt.Errorf("replace target with temp file: %w", err)
+	}
+
+	success = true
+	return nil
+}
+
+func replaceFile(tmpName, target string) error {
+	if err := os.Rename(tmpName, target); err == nil {
+		return nil
+	}
+
+	src, err := os.Open(tmpName)
+	if err != nil {
+		return fmt.Errorf("open temp file: %w", err)
+	}
+	defer src.Close()
+
+	dst, err := os.OpenFile(target, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	if err != nil {
+		return fmt.Errorf("create target file: %w", err)
+	}
+	defer dst.Close()
+
+	if _, err := io.Copy(dst, src); err != nil {
+		return fmt.Errorf("copy content: %w", err)
+	}
+	if err := dst.Sync(); err != nil {
+		return fmt.Errorf("sync target: %w", err)
+	}
+	if err := os.Remove(tmpName); err != nil {
+		return fmt.Errorf("remove temp file: %w", err)
+	}
+	return nil
+}