savepoint 1.0.3 → 1.0.6

package/internal/board/watch.go

@@ -1,130 +0,0 @@
-package board
-
-import (
-	"os"
-	"path/filepath"
-	"time"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/fsnotify/fsnotify"
-	"github.com/opencode/savepoint/internal/data"
-)
-
-type fileChangeMsg struct{}
-type reloadMsg struct {
-	tasks        []data.Task
-	releases     []string
-	releaseEpics map[string][]string
-	epicStatuses map[string]string
-	routerState  *data.RouterState
-}
-
-type routerWriteMsg struct {
-	message string
-	state   *data.RouterState
-	taskID  string
-}
-
-type taskWriteMsg struct {
-	prefix string
-	next   data.Task
-	err    error
-}
-
-type epicDetailMsg struct {
-	content string
-}
-
-type auditContentMsg struct {
-	content string
-}
-
-type errorMsg struct {
-	message string
-}
-
-// watchFiles blocks until a file event arrives, debounces for 100ms, emits fileChangeMsg.
-func watchFiles(w *fsnotify.Watcher) tea.Cmd {
-	return func() tea.Msg {
-		for {
-			select {
-			case event, ok := <-w.Events:
-				if !ok {
-					return nil
-				}
-				watchCreatedDir(w, event)
-				timer := time.NewTimer(100 * time.Millisecond)
-			drain:
-				for {
-					select {
-					case event, ok := <-w.Events:
-						if !ok {
-							timer.Stop()
-							return nil
-						}
-						watchCreatedDir(w, event)
-					case <-timer.C:
-						break drain
-					}
-				}
-				return fileChangeMsg{}
-			case _, ok := <-w.Errors:
-				if !ok {
-					return nil
-				}
-			}
-		}
-	}
-}
-
-func reloadTasks(root string, deps ModelDependencies) tea.Cmd {
-	return func() tea.Msg {
-		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
-		if err != nil {
-			return errorMsg{message: "reload failed: " + err.Error()}
-		}
-		routerState, _ := readRouterState(root, deps.RouterReader)
-		return reloadMsg{tasks: tasks, releases: releases, releaseEpics: releaseEpics, epicStatuses: epicStatuses, routerState: routerState}
-	}
-}
-
-// newWatcher watches the savepoint root (for router.md) and all releases subdirs.
-func newWatcher(root string) (*fsnotify.Watcher, error) {
-	w, err := fsnotify.NewWatcher()
-	if err != nil {
-		return nil, err
-	}
-	if err := w.Add(root); err != nil {
-		w.Close()
-		return nil, err
-	}
-	releasesPath := filepath.Join(root, "releases")
-	if err := addDirsRecursive(w, releasesPath); err != nil {
-		w.Close()
-		return nil, err
-	}
-	return w, nil
-}
-
-func watchCreatedDir(w *fsnotify.Watcher, event fsnotify.Event) {
-	if !event.Has(fsnotify.Create) {
-		return
-	}
-	info, err := os.Stat(event.Name)
-	if err != nil || !info.IsDir() {
-		return
-	}
-	_ = addDirsRecursive(w, event.Name)
-}
-
-func addDirsRecursive(w *fsnotify.Watcher, root string) error {
-	return filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
-		if err != nil {
-			return nil // skip unreadable dirs
-		}
-		if d.IsDir() {
-			return w.Add(path)
-		}
-		return nil
-	})
-}

package/internal/buildtool/main.go

@@ -1,211 +0,0 @@
-package main
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"strings"
-	"path/filepath"
-	"runtime"
-)
-
-type target struct {
-	os   string
-	arch string
-}
-
-var targets = []target{
-	{os: "linux", arch: "amd64"},
-	{os: "linux", arch: "arm64"},
-	{os: "darwin", arch: "amd64"},
-	{os: "darwin", arch: "arm64"},
-}
-
-var versionOverride string
-
-func main() {
-	if err := run(os.Args[1:]); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-func run(args []string) error {
-	flags := flag.NewFlagSet("buildtool", flag.ContinueOnError)
-	flags.StringVar(&versionOverride, "version", "", "version to inject into the binary")
-	if err := flags.Parse(args); err != nil {
-		return err
-	}
-	if flags.NArg() != 1 {
-		return errors.New("usage: go run ./internal/buildtool [-version vX.Y.Z] <build|clean|build-linux|build-darwin|build-all|dist|smoke-test>")
-	}
-
-	switch flags.Arg(0) {
-	case "build":
-		return buildLocal()
-	case "clean":
-		return clean()
-	case "build-linux":
-		return buildMatching("linux")
-	case "build-darwin":
-		return buildMatching("darwin")
-	case "build-all":
-		return buildAll()
-	case "dist":
-		return dist()
-	case "smoke-test":
-		return smokeTest()
-	default:
-		return fmt.Errorf("unknown build target %q", flags.Arg(0))
-	}
-}
-
-func buildLocal() error {
-	return runGoBuild(localExecutable(), runtime.GOOS, runtime.GOARCH)
-}
-
-func clean() error {
-	for _, path := range []string{"savepoint", "savepoint.exe", "dist"} {
-		if err := os.RemoveAll(path); err != nil {
-			return fmt.Errorf("clean %s: %w", path, err)
-		}
-	}
-	return nil
-}
-
-func buildMatching(goos string) error {
-	for _, target := range targets {
-		if target.os != goos {
-			continue
-		}
-		if err := buildTarget(target); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func buildAll() error {
-	for _, target := range targets {
-		if err := buildTarget(target); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func buildTarget(target target) error {
-	output := filepath.Join("dist", target.os+"-"+target.arch, "savepoint")
-	return runGoBuild(output, target.os, target.arch)
-}
-
-func runGoBuild(output, goos, goarch string) error {
-	if err := os.MkdirAll(filepath.Dir(output), 0o755); err != nil && filepath.Dir(output) != "." {
-		return fmt.Errorf("create output dir: %w", err)
-	}
-
-	cmd := exec.Command("go", "build", "-ldflags", "-X main.version="+version(), "-o", output, "main.go")
-	cmd.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("build %s/%s: %w", goos, goarch, err)
-	}
-	return nil
-}
-
-func dist() error {
-	if err := buildAll(); err != nil {
-		return err
-	}
-	for _, target := range targets {
-		name := "savepoint-" + version() + "-" + target.os + "-" + target.arch + ".tar.gz"
-		source := filepath.Join("dist", target.os+"-"+target.arch, "savepoint")
-		archive := filepath.Join("dist", name)
-		if err := writeTarGz(archive, source, "savepoint"); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func writeTarGz(archivePath, sourcePath, archiveName string) error {
-	source, err := os.Open(sourcePath)
-	if err != nil {
-		return fmt.Errorf("open artifact source: %w", err)
-	}
-	defer source.Close()
-
-	info, err := source.Stat()
-	if err != nil {
-		return fmt.Errorf("stat artifact source: %w", err)
-	}
-
-	archive, err := os.Create(archivePath)
-	if err != nil {
-		return fmt.Errorf("create archive: %w", err)
-	}
-	defer archive.Close()
-
-	gzipWriter := gzip.NewWriter(archive)
-	defer gzipWriter.Close()
-
-	tarWriter := tar.NewWriter(gzipWriter)
-	defer tarWriter.Close()
-
-	header, err := tar.FileInfoHeader(info, "")
-	if err != nil {
-		return fmt.Errorf("create archive header: %w", err)
-	}
-	header.Name = archiveName
-	if err := tarWriter.WriteHeader(header); err != nil {
-		return fmt.Errorf("write archive header: %w", err)
-	}
-	if _, err := io.Copy(tarWriter, source); err != nil {
-		return fmt.Errorf("write archive content: %w", err)
-	}
-	return nil
-}
-
-func smokeTest() error {
-	if err := buildLocal(); err != nil {
-		return err
-	}
-	cmd := exec.Command("."+string(os.PathSeparator)+localExecutable(), "--version")
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("smoke test: %w", err)
-	}
-	fmt.Println("smoke test passed")
-	return nil
-}
-
-func version() string {
-	if versionOverride != "" {
-		return versionOverride
-	}
-	if value := os.Getenv("VERSION"); value != "" {
-		return value
-	}
-
-	cmd := exec.Command("git", "describe", "--tags", "--abbrev=0")
-	output, err := cmd.Output()
-	if err == nil && len(output) > 0 {
-		return strings.TrimSpace(string(output))
-	}
-	return "v0.0.0"
-}
-
-func localExecutable() string {
-	if runtime.GOOS == "windows" {
-		return "savepoint.exe"
-	}
-	return "savepoint"
-}
-

package/internal/buildtool/main_test.go

@@ -1,46 +0,0 @@
-package main
-
-import (
-	"os"
-	"runtime"
-	"testing"
-)
-
-func TestVersion_override(t *testing.T) {
-	versionOverride = "v1.2.3"
-	defer func() { versionOverride = "" }()
-	if got := version(); got != "v1.2.3" {
-		t.Errorf("version() = %q, want %q", got, "v1.2.3")
-	}
-}
-
-func TestVersion_env(t *testing.T) {
-	versionOverride = ""
-	os.Setenv("VERSION", "v2.0.0-env")
-	defer os.Unsetenv("VERSION")
-	if got := version(); got != "v2.0.0-env" {
-		t.Errorf("version() = %q, want %q", got, "v2.0.0-env")
-	}
-}
-
-func TestVersion_fallback(t *testing.T) {
-	versionOverride = ""
-	os.Unsetenv("VERSION")
-	got := version()
-	if got == "" {
-		t.Error("version() returned empty string")
-	}
-}
-
-func TestLocalExecutable(t *testing.T) {
-	got := localExecutable()
-	if runtime.GOOS == "windows" {
-		if got != "savepoint.exe" {
-			t.Errorf("localExecutable() = %q, want %q", got, "savepoint.exe")
-		}
-	} else {
-		if got != "savepoint" {
-			t.Errorf("localExecutable() = %q, want %q", got, "savepoint")
-		}
-	}
-}

package/internal/data/config.go

@@ -1,101 +0,0 @@
-package data
-
-import (
-	"fmt"
-	"os"
-
-	"gopkg.in/yaml.v3"
-)
-
-type Theme struct {
-	BG       string            `yaml:"bg"`
-	Surface  string            `yaml:"surface"`
-	Surface2 string            `yaml:"surface_2"`
-	Border   string            `yaml:"border"`
-	Text     string            `yaml:"text"`
-	Accents  map[string]string `yaml:"accents"`
-}
-
-type QualityGates struct {
-	Lint           *string `yaml:"lint"`
-	Typecheck      *string `yaml:"typecheck"`
-	Test           *string `yaml:"test"`
-	BlockOnFailure bool    `yaml:"block_on_failure"`
-	Timeout        string  `yaml:"gate_timeout"`
-}
-
-type Config struct {
-	Theme         Theme         `yaml:"theme"`
-	QualityGates  QualityGates  `yaml:"quality_gates"`
-}
-
-var defaultTheme = Theme{
-	BG:       "#1a1b26",
-	Surface:  "#24283b",
-	Surface2: "#414868",
-	Border:   "#565f89",
-	Text:     "#c0caf5",
-	Accents: map[string]string{
-		"planned":     "#7aa2f7",
-		"in_progress": "#bb9af7",
-		"done":        "#9ece6a",
-		"blocked":     "#f7768e",
-		"epic":        "#2ac3de",
-	},
-}
-
-var defaultConfig = Config{
-	Theme: defaultTheme,
-}
-
-type ConfigReader struct{}
-
-func NewConfigReader() *ConfigReader {
-	return &ConfigReader{}
-}
-
-func (r *ConfigReader) Read(path string) (*Config, error) {
-	data, err := os.ReadFile(path)
-	if os.IsNotExist(err) {
-		return &defaultConfig, nil
-	}
-	if err != nil {
-		return nil, fmt.Errorf("failed to read config: %w", err)
-	}
-
-	var config Config
-	if err := yaml.Unmarshal(data, &config); err != nil {
-		return nil, fmt.Errorf("failed to parse config YAML: %w", err)
-	}
-
-	config.Theme = fillThemeDefaults(config.Theme)
-
-	return &config, nil
-}
-
-func fillThemeDefaults(theme Theme) Theme {
-	if theme.BG == "" {
-		theme.BG = defaultTheme.BG
-	}
-	if theme.Surface == "" {
-		theme.Surface = defaultTheme.Surface
-	}
-	if theme.Surface2 == "" {
-		theme.Surface2 = defaultTheme.Surface2
-	}
-	if theme.Border == "" {
-		theme.Border = defaultTheme.Border
-	}
-	if theme.Text == "" {
-		theme.Text = defaultTheme.Text
-	}
-	if theme.Accents == nil {
-		theme.Accents = make(map[string]string)
-	}
-	for k, v := range defaultTheme.Accents {
-		if _, ok := theme.Accents[k]; !ok {
-			theme.Accents[k] = v
-		}
-	}
-	return theme
-}

package/internal/data/config_test.go

@@ -1,122 +0,0 @@
-package data
-
-import (
-	"os"
-	"testing"
-)
-
-func TestConfigReaderDefault(t *testing.T) {
-	r := NewConfigReader()
-	config, err := r.Read("nonexistent.yml")
-	if err != nil {
-		t.Fatalf("Read() error = %v", err)
-	}
-
-	if config.Theme.BG != defaultTheme.BG {
-		t.Errorf("Theme.BG = %v, want %v", config.Theme.BG, defaultTheme.BG)
-	}
-}
-
-func TestConfigReaderRead(t *testing.T) {
-	content := `theme:
-  bg: "#000000"
-  surface: "#111111"
-  text: "#ffffff"
-  accents:
-    planned: "#222222"
-`
-	tmpfile, err := os.CreateTemp("", "config-*.yml")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(tmpfile.Name())
-
-	if _, err := tmpfile.Write([]byte(content)); err != nil {
-		t.Fatal(err)
-	}
-	tmpfile.Close()
-
-	r := NewConfigReader()
-	config, err := r.Read(tmpfile.Name())
-	if err != nil {
-		t.Fatalf("Read() error = %v", err)
-	}
-
-	if config.Theme.BG != "#000000" {
-		t.Errorf("Theme.BG = %v, want #000000", config.Theme.BG)
-	}
-	if config.Theme.Surface2 != defaultTheme.Surface2 {
-		t.Errorf("Theme.Surface2 = %v, want default %v", config.Theme.Surface2, defaultTheme.Surface2)
-	}
-	if config.Theme.Accents["planned"] != "#222222" {
-		t.Errorf("Theme.Accents[planned] = %v, want #222222", config.Theme.Accents["planned"])
-	}
-}
-
-func TestFillThemeDefaults_PartialAccents(t *testing.T) {
-	theme := Theme{
-		BG:      "#000000",
-		Accents: map[string]string{"planned": "#ff0000"},
-	}
-	result := fillThemeDefaults(theme)
-	if result.Accents["planned"] != "#ff0000" {
-		t.Errorf("Accents[planned] = %v, want #ff0000 (user value preserved)", result.Accents["planned"])
-	}
-	if result.Accents["in_progress"] != defaultTheme.Accents["in_progress"] {
-		t.Errorf("Accents[in_progress] = %v, want default %v", result.Accents["in_progress"], defaultTheme.Accents["in_progress"])
-	}
-	if result.Accents["done"] != defaultTheme.Accents["done"] {
-		t.Errorf("Accents[done] = %v, want default %v", result.Accents["done"], defaultTheme.Accents["done"])
-	}
-	if result.Accents["blocked"] != defaultTheme.Accents["blocked"] {
-		t.Errorf("Accents[blocked] = %v, want default %v", result.Accents["blocked"], defaultTheme.Accents["blocked"])
-	}
-	if result.Accents["epic"] != defaultTheme.Accents["epic"] {
-		t.Errorf("Accents[epic] = %v, want default %v", result.Accents["epic"], defaultTheme.Accents["epic"])
-	}
-}
-
-func TestFillThemeDefaults_NilAccents(t *testing.T) {
-	theme := Theme{
-		BG:      "#000000",
-		Accents: nil,
-	}
-	result := fillThemeDefaults(theme)
-	for k, v := range defaultTheme.Accents {
-		if result.Accents[k] != v {
-			t.Errorf("Accents[%s] = %v, want default %v", k, result.Accents[k], v)
-		}
-	}
-}
-
-func TestFillThemeDefaults_EmptyAccents(t *testing.T) {
-	theme := Theme{
-		BG:      "#000000",
-		Accents: map[string]string{},
-	}
-	result := fillThemeDefaults(theme)
-	for k, v := range defaultTheme.Accents {
-		if result.Accents[k] != v {
-			t.Errorf("Accents[%s] = %v, want default %v", k, result.Accents[k], v)
-		}
-	}
-}
-
-func TestConfigReaderMalformedYAML(t *testing.T) {
-	tmpfile, err := os.CreateTemp("", "config-*.yml")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(tmpfile.Name())
-
-	if _, err := tmpfile.Write([]byte("theme: [broken")); err != nil {
-		t.Fatal(err)
-	}
-	tmpfile.Close()
-
-	r := NewConfigReader()
-	_, err = r.Read(tmpfile.Name())
-	if err == nil {
-		t.Fatal("Read() expected malformed YAML error")
-	}
-}