savepoint 1.0.1 → 1.0.3

package/agent_skills_test.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestBundledSavepointSkillsHaveDiscoveryFrontmatter(t *testing.T) {
+	assertSavepointSkillsHaveFrontmatter(t, filepath.Join("agent-skills"))
+	assertSavepointSkillsHaveFrontmatter(t, filepath.Join("templates", "project", "agent-skills"))
+}
+
+func TestProjectAgentGuideIncludesLocalSkillFallback(t *testing.T) {
+	path := filepath.Join("templates", "project", "AGENTS.md")
+	content, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("ReadFile(%q) error = %v", path, err)
+	}
+
+	want := "If the agent says the skill is not found, read `agent-skills/{skill}/SKILL.md` directly"
+	if !strings.Contains(string(content), want) {
+		t.Fatalf("%s missing local skill fallback instruction", path)
+	}
+}
+
+func TestScaffoldedSavepointSkillsMatchBundledSkills(t *testing.T) {
+	root := filepath.Join("agent-skills")
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatalf("ReadDir(%q) error = %v", root, err)
+	}
+
+	for _, entry := range entries {
+		if !entry.IsDir() || !strings.HasPrefix(entry.Name(), "savepoint-") {
+			continue
+		}
+
+		sourcePath := filepath.Join(root, entry.Name(), "SKILL.md")
+		scaffoldPath := filepath.Join("templates", "project", "agent-skills", entry.Name(), "SKILL.md")
+		source, err := os.ReadFile(sourcePath)
+		if err != nil {
+			t.Fatalf("ReadFile(%q) error = %v", sourcePath, err)
+		}
+		scaffold, err := os.ReadFile(scaffoldPath)
+		if err != nil {
+			t.Fatalf("ReadFile(%q) error = %v", scaffoldPath, err)
+		}
+		if string(scaffold) != string(source) {
+			t.Fatalf("%s does not match %s", scaffoldPath, sourcePath)
+		}
+	}
+}
+
+func assertSavepointSkillsHaveFrontmatter(t *testing.T, root string) {
+	t.Helper()
+
+	entries, err := os.ReadDir(root)
+	if err != nil {
+		t.Fatalf("ReadDir(%q) error = %v", root, err)
+	}
+
+	var found int
+	for _, entry := range entries {
+		if !entry.IsDir() || !strings.HasPrefix(entry.Name(), "savepoint-") {
+			continue
+		}
+		found++
+		path := filepath.Join(root, entry.Name(), "SKILL.md")
+		content, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatalf("ReadFile(%q) error = %v", path, err)
+		}
+
+		text := string(content)
+		if !strings.HasPrefix(text, "---\n") {
+			t.Fatalf("%s missing YAML frontmatter", path)
+		}
+		if !strings.Contains(text, "name: "+entry.Name()) {
+			t.Fatalf("%s frontmatter name does not match directory", path)
+		}
+		if !strings.Contains(text, "description:") {
+			t.Fatalf("%s missing frontmatter description", path)
+		}
+	}
+
+	if found == 0 {
+		t.Fatalf("%s contains %d savepoint skills, want at least 1", root, found)
+	}
+}

package/cmd/board.go

@@ -0,0 +1,59 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"io"
+)
+
+const boardUsage = "Usage: board [--release <release>] [--epic <epic>]"
+
+type BoardOptions struct {
+	Release string
+	Epic    string
+}
+
+type BoardRunner func(BoardOptions) error
+
+func RunBoard(ctx context.Context, args []string, stdout io.Writer, runner BoardRunner) error {
+	options, help, err := ParseBoardArgs(args)
+	if help {
+		_, writeErr := fmt.Fprintln(stdout, boardUsage)
+		return writeErr
+	}
+	if err != nil {
+		return err
+	}
+	return runner(options)
+}
+
+func ParseBoardArgs(args []string) (BoardOptions, bool, error) {
+	var options BoardOptions
+
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch arg {
+		case "--help":
+			return BoardOptions{}, true, nil
+		case "--release":
+			i++
+			if i >= len(args) {
+				return BoardOptions{}, false, fmt.Errorf("--release requires a value")
+			}
+			options.Release = args[i]
+		case "--epic":
+			i++
+			if i >= len(args) {
+				return BoardOptions{}, false, fmt.Errorf("--epic requires a value")
+			}
+			options.Epic = args[i]
+		default:
+			if len(arg) > 0 && arg[0] == '-' {
+				return BoardOptions{}, false, fmt.Errorf("unknown board flag %q", arg)
+			}
+			return BoardOptions{}, false, fmt.Errorf("board takes no positional arguments, got %q", arg)
+		}
+	}
+
+	return options, false, nil
+}

package/cmd/board_test.go

@@ -0,0 +1,137 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestRunBoardHelp(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	err := RunBoard(context.Background(), []string{"--help"}, &stdout, func(BoardOptions) error {
+		called = true
+		return nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunBoard() error = %v", err)
+	}
+	if called {
+		t.Fatal("RunBoard() called runner for help")
+	}
+	if !strings.Contains(stdout.String(), "board [--release <release>] [--epic <epic>]") {
+		t.Fatalf("help output = %q", stdout.String())
+	}
+}
+
+func TestRunBoardNoArgs(t *testing.T) {
+	got := runBoardOptions(t, nil)
+
+	if got.Release != "" {
+		t.Fatalf("Release = %q, want empty", got.Release)
+	}
+	if got.Epic != "" {
+		t.Fatalf("Epic = %q, want empty", got.Epic)
+	}
+}
+
+func TestRunBoardRelease(t *testing.T) {
+	got := runBoardOptions(t, []string{"--release", "v1"})
+
+	if got.Release != "v1" {
+		t.Fatalf("Release = %q, want v1", got.Release)
+	}
+}
+
+func TestRunBoardEpic(t *testing.T) {
+	got := runBoardOptions(t, []string{"--epic", "E03"})
+
+	if got.Epic != "E03" {
+		t.Fatalf("Epic = %q, want E03", got.Epic)
+	}
+}
+
+func TestRunBoardReleaseAndEpic(t *testing.T) {
+	got := runBoardOptions(t, []string{"--release", "v1", "--epic", "E03"})
+
+	if got.Release != "v1" {
+		t.Fatalf("Release = %q, want v1", got.Release)
+	}
+	if got.Epic != "E03" {
+		t.Fatalf("Epic = %q, want E03", got.Epic)
+	}
+}
+
+func TestRunBoardRejectsUnknownFlag(t *testing.T) {
+	var stdout bytes.Buffer
+
+	err := RunBoard(context.Background(), []string{"--bogus"}, &stdout, func(BoardOptions) error {
+		return nil
+	})
+
+	if err == nil {
+		t.Fatal("RunBoard() error = nil, want unknown flag error")
+	}
+	if !strings.Contains(err.Error(), "unknown board flag") {
+		t.Fatalf("error = %q, want unknown flag", err.Error())
+	}
+}
+
+func TestRunBoardRejectsPositionalArgs(t *testing.T) {
+	var stdout bytes.Buffer
+
+	err := RunBoard(context.Background(), []string{"extra"}, &stdout, func(BoardOptions) error {
+		return nil
+	})
+
+	if err == nil {
+		t.Fatal("RunBoard() error = nil, want positional arg error")
+	}
+}
+
+func TestRunBoardReleaseMissingValue(t *testing.T) {
+	var stdout bytes.Buffer
+
+	err := RunBoard(context.Background(), []string{"--release"}, &stdout, func(BoardOptions) error {
+		return nil
+	})
+
+	if err == nil {
+		t.Fatal("RunBoard() error = nil, want missing value error")
+	}
+	if !strings.Contains(err.Error(), "--release requires a value") {
+		t.Fatalf("error = %q", err.Error())
+	}
+}
+
+func TestRunBoardReturnsRunnerError(t *testing.T) {
+	want := errors.New("runner failed")
+	var stdout bytes.Buffer
+
+	err := RunBoard(context.Background(), nil, &stdout, func(BoardOptions) error {
+		return want
+	})
+
+	if !errors.Is(err, want) {
+		t.Fatalf("RunBoard() error = %v, want %v", err, want)
+	}
+}
+
+func runBoardOptions(t *testing.T, args []string) BoardOptions {
+	t.Helper()
+
+	var stdout bytes.Buffer
+	var got BoardOptions
+	err := RunBoard(context.Background(), args, &stdout, func(options BoardOptions) error {
+		got = options
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("RunBoard() error = %v", err)
+	}
+	return got
+}

package/cmd/doctor.go

@@ -0,0 +1,53 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"io"
+)
+
+const doctorUsage = "Usage: doctor [--epic <epic>]"
+
+type DoctorOptions struct {
+	Epic string
+}
+
+// DoctorRunner receives parsed options and returns an exit code: 0=clean, 1=problems, 2=internal error.
+type DoctorRunner func(DoctorOptions) (int, error)
+
+func RunDoctor(ctx context.Context, args []string, stdout io.Writer, runner DoctorRunner) (int, error) {
+	options, help, err := ParseDoctorArgs(args)
+	if help {
+		_, writeErr := fmt.Fprintln(stdout, doctorUsage)
+		return 0, writeErr
+	}
+	if err != nil {
+		return 2, err
+	}
+	return runner(options)
+}
+
+func ParseDoctorArgs(args []string) (DoctorOptions, bool, error) {
+	var options DoctorOptions
+
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch arg {
+		case "--help":
+			return DoctorOptions{}, true, nil
+		case "--epic":
+			i++
+			if i >= len(args) {
+				return DoctorOptions{}, false, fmt.Errorf("--epic requires a value")
+			}
+			options.Epic = args[i]
+		default:
+			if len(arg) > 0 && arg[0] == '-' {
+				return DoctorOptions{}, false, fmt.Errorf("unknown doctor flag %q", arg)
+			}
+			return DoctorOptions{}, false, fmt.Errorf("doctor takes no positional arguments, got %q", arg)
+		}
+	}
+
+	return options, false, nil
+}

package/cmd/doctor_test.go

@@ -0,0 +1,146 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+)
+
+func TestRunDoctorHelp(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	code, err := RunDoctor(context.Background(), []string{"--help"}, &stdout, func(DoctorOptions) (int, error) {
+		called = true
+		return 0, nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if called {
+		t.Fatal("RunDoctor() called runner for help")
+	}
+	if code != 0 {
+		t.Fatalf("RunDoctor() code = %d, want 0", code)
+	}
+	if !strings.Contains(stdout.String(), "doctor [--epic <epic>]") {
+		t.Fatalf("help output = %q", stdout.String())
+	}
+}
+
+func TestRunDoctorNoArgs(t *testing.T) {
+	got := runDoctorOptions(t, nil)
+
+	if got.Epic != "" {
+		t.Fatalf("Epic = %q, want empty", got.Epic)
+	}
+}
+
+func TestRunDoctorEpic(t *testing.T) {
+	got := runDoctorOptions(t, []string{"--epic", "E03"})
+
+	if got.Epic != "E03" {
+		t.Fatalf("Epic = %q, want E03", got.Epic)
+	}
+}
+
+func TestRunDoctorEpicMissingValue(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), []string{"--epic"}, &stdout, func(DoctorOptions) (int, error) {
+		return 0, nil
+	})
+
+	if err == nil {
+		t.Fatal("RunDoctor() error = nil, want missing value error")
+	}
+	if !strings.Contains(err.Error(), "--epic requires a value") {
+		t.Fatalf("error = %q", err.Error())
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func TestRunDoctorRejectsUnknownFlag(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), []string{"--bogus"}, &stdout, func(DoctorOptions) (int, error) {
+		return 0, nil
+	})
+
+	if err == nil {
+		t.Fatal("RunDoctor() error = nil, want unknown flag error")
+	}
+	if !strings.Contains(err.Error(), "unknown doctor flag") {
+		t.Fatalf("error = %q", err.Error())
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func TestRunDoctorRejectsPositionalArgs(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), []string{"extra"}, &stdout, func(DoctorOptions) (int, error) {
+		return 0, nil
+	})
+
+	if err == nil {
+		t.Fatal("RunDoctor() error = nil, want positional arg error")
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func TestRunDoctorExitCode1(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), nil, &stdout, func(DoctorOptions) (int, error) {
+		return 1, nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if code != 1 {
+		t.Fatalf("code = %d, want 1", code)
+	}
+}
+
+func TestRunDoctorExitCode2(t *testing.T) {
+	var stdout bytes.Buffer
+
+	code, err := RunDoctor(context.Background(), nil, &stdout, func(DoctorOptions) (int, error) {
+		return 2, nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if code != 2 {
+		t.Fatalf("code = %d, want 2", code)
+	}
+}
+
+func runDoctorOptions(t *testing.T, args []string) DoctorOptions {
+	t.Helper()
+
+	var stdout bytes.Buffer
+	var got DoctorOptions
+	code, err := RunDoctor(context.Background(), args, &stdout, func(options DoctorOptions) (int, error) {
+		got = options
+		return 0, nil
+	})
+	if err != nil {
+		t.Fatalf("RunDoctor() error = %v", err)
+	}
+	if code != 0 {
+		t.Fatalf("RunDoctor() code = %d, want 0", code)
+	}
+	return got
+}

package/cmd/init.go

@@ -0,0 +1,63 @@
+package cmd
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+)
+
+const initUsage = "Usage: init [dir] [--force] [--install]"
+
+type InitOptions struct {
+	Dir     string
+	Force   bool
+	Install bool
+}
+
+type InitRunner func(context.Context, InitOptions) error
+
+var ErrInitNotImplemented = errors.New("init scaffold is not implemented yet")
+
+func RunInit(ctx context.Context, args []string, stdout io.Writer, runner InitRunner) error {
+	options, help, err := ParseInitArgs(args)
+	if help {
+		_, writeErr := fmt.Fprintln(stdout, initUsage)
+		return writeErr
+	}
+	if err != nil {
+		return err
+	}
+	return runner(ctx, options)
+}
+
+func ParseInitArgs(args []string) (InitOptions, bool, error) {
+	options := InitOptions{Dir: "."}
+	var dirSet bool
+
+	for _, arg := range args {
+		switch arg {
+		case "--help":
+			return InitOptions{}, true, nil
+		case "--force":
+			options.Force = true
+		case "--install":
+			options.Install = true
+		default:
+			if len(arg) > 0 && arg[0] == '-' {
+				return InitOptions{}, false, fmt.Errorf("unknown init flag %q", arg)
+			}
+			if dirSet {
+				return InitOptions{}, false, fmt.Errorf("init accepts at most one directory")
+			}
+			options.Dir = arg
+			dirSet = true
+		}
+	}
+
+	return options, false, nil
+}
+
+func InitNotImplemented(context.Context, InitOptions) error {
+	return ErrInitNotImplemented
+}

package/cmd/init_test.go

@@ -0,0 +1,104 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestRunInitHelp(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	err := RunInit(context.Background(), []string{"--help"}, &stdout, func(context.Context, InitOptions) error {
+		called = true
+		return nil
+	})
+
+	if err != nil {
+		t.Fatalf("RunInit() error = %v", err)
+	}
+	if called {
+		t.Fatal("RunInit() called runner for help")
+	}
+	if !strings.Contains(stdout.String(), "Usage: init [dir] [--force] [--install]") {
+		t.Fatalf("help output = %q", stdout.String())
+	}
+}
+
+func TestRunInitDefaultsToCurrentDirectory(t *testing.T) {
+	got := runInitOptions(t, nil)
+
+	if got.Dir != "." {
+		t.Fatalf("Dir = %q, want .", got.Dir)
+	}
+}
+
+func TestRunInitUsesSpecifiedDirectory(t *testing.T) {
+	got := runInitOptions(t, []string{"example"})
+
+	if got.Dir != "example" {
+		t.Fatalf("Dir = %q, want example", got.Dir)
+	}
+}
+
+func TestRunInitParsesForceAndInstall(t *testing.T) {
+	got := runInitOptions(t, []string{"example", "--force", "--install"})
+
+	if !got.Force {
+		t.Fatal("Force = false, want true")
+	}
+	if !got.Install {
+		t.Fatal("Install = false, want true")
+	}
+}
+
+func TestRunInitRejectsUnknownFlags(t *testing.T) {
+	var stdout bytes.Buffer
+	called := false
+
+	err := RunInit(context.Background(), []string{"--bogus"}, &stdout, func(context.Context, InitOptions) error {
+		called = true
+		return nil
+	})
+
+	if err == nil {
+		t.Fatal("RunInit() error = nil, want unknown flag error")
+	}
+	if called {
+		t.Fatal("RunInit() called runner after invalid args")
+	}
+	if !strings.Contains(err.Error(), "unknown init flag") {
+		t.Fatalf("error = %q, want unknown flag", err.Error())
+	}
+}
+
+func TestRunInitReturnsRunnerError(t *testing.T) {
+	want := errors.New("runner failed")
+	var stdout bytes.Buffer
+
+	err := RunInit(context.Background(), nil, &stdout, func(context.Context, InitOptions) error {
+		return want
+	})
+
+	if !errors.Is(err, want) {
+		t.Fatalf("RunInit() error = %v, want %v", err, want)
+	}
+}
+
+func runInitOptions(t *testing.T, args []string) InitOptions {
+	t.Helper()
+
+	var stdout bytes.Buffer
+	var got InitOptions
+	err := RunInit(context.Background(), args, &stdout, func(_ context.Context, options InitOptions) error {
+		got = options
+		return nil
+	})
+	if err != nil {
+		t.Fatalf("RunInit() error = %v", err)
+	}
+	return got
+}