savepoint 1.0.4 → 1.0.6

package/internal/board/watch.go

@@ -1,136 +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
-				}
-				debugf("watcher: event %s", event)
-				watchCreatedDir(w, event)
-				timer := time.NewTimer(100 * time.Millisecond)
-			drain:
-				for {
-					select {
-					case event, ok := <-w.Events:
-						if !ok {
-							timer.Stop()
-							return nil
-						}
-						debugf("watcher: event %s", event)
-						watchCreatedDir(w, event)
-					case <-timer.C:
-						break drain
-					}
-				}
-				debugf("watcher: emitting fileChangeMsg")
-				return fileChangeMsg{}
-			case _, ok := <-w.Errors:
-				if !ok {
-					return nil
-				}
-			}
-		}
-	}
-}
-
-func reloadTasks(root string, deps ModelDependencies) tea.Cmd {
-	return func() tea.Msg {
-		debugf("reload: starting task reload from %q", root)
-		tasks, releases, releaseEpics, epicStatuses, err := loadBoardData(root, deps.Discoverer, deps.Parser)
-		if err != nil {
-			debugf("reload: error: %v", err)
-			return errorMsg{message: "reload failed: " + err.Error()}
-		}
-		debugf("reload: loaded %d tasks", len(tasks))
-		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,249 +0,0 @@
-package main
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-)
-
-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"},
-	{os: "windows", arch: "amd64"},
-	{os: "windows", 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-windows|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-windows":
-		return buildMatching("windows")
-	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 executableName(goos string) string {
-	if goos == "windows" {
-		return "savepoint.exe"
-	}
-	return "savepoint"
-}
-
-func buildTarget(target target) error {
-	output := filepath.Join("dist", target.os+"-"+target.arch, executableName(target.os))
-	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
-	}
-	var archives []string
-	for _, target := range targets {
-		name := "savepoint-" + version() + "-" + target.os + "-" + target.arch + ".tar.gz"
-		source := filepath.Join("dist", target.os+"-"+target.arch, executableName(target.os))
-		archive := filepath.Join("dist", name)
-		if err := writeTarGz(archive, source, executableName(target.os)); err != nil {
-			return err
-		}
-		archives = append(archives, archive)
-	}
-	return writeChecksums(filepath.Join("dist", "checksums.txt"), archives)
-}
-
-func writeChecksums(dest string, archives []string) error {
-	var lines strings.Builder
-	for _, path := range archives {
-		f, err := os.Open(path)
-		if err != nil {
-			return fmt.Errorf("checksum open %s: %w", path, err)
-		}
-		h := sha256.New()
-		if _, err := io.Copy(h, f); err != nil {
-			f.Close()
-			return fmt.Errorf("checksum read %s: %w", path, err)
-		}
-		f.Close()
-		lines.WriteString(hex.EncodeToString(h.Sum(nil)))
-		lines.WriteString("  ")
-		lines.WriteString(filepath.Base(path))
-		lines.WriteString("\n")
-	}
-	if err := os.WriteFile(dest, []byte(lines.String()), 0o644); err != nil {
-		return fmt.Errorf("write checksums: %w", 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,224 +0,0 @@
-package main
-
-import (
-	"archive/tar"
-	"compress/gzip"
-	"crypto/sha256"
-	"encoding/hex"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"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 TestWriteChecksums(t *testing.T) {
-	dir := t.TempDir()
-
-	content := []byte("fake archive content")
-	archive := filepath.Join(dir, "savepoint-v1.0.0-linux-amd64.tar.gz")
-	if err := os.WriteFile(archive, content, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	dest := filepath.Join(dir, "checksums.txt")
-	if err := writeChecksums(dest, []string{archive}); err != nil {
-		t.Fatalf("writeChecksums: %v", err)
-	}
-
-	got, err := os.ReadFile(dest)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	h := sha256.Sum256(content)
-	wantHash := hex.EncodeToString(h[:])
-	wantLine := wantHash + "  savepoint-v1.0.0-linux-amd64.tar.gz"
-
-	lines := strings.Split(strings.TrimSpace(string(got)), "\n")
-	if len(lines) != 1 {
-		t.Fatalf("expected 1 line, got %d", len(lines))
-	}
-	if lines[0] != wantLine {
-		t.Errorf("line = %q, want %q", lines[0], wantLine)
-	}
-}
-
-func TestWriteChecksums_multiple(t *testing.T) {
-	dir := t.TempDir()
-
-	names := []string{"a.tar.gz", "b.tar.gz"}
-	var paths []string
-	for _, name := range names {
-		p := filepath.Join(dir, name)
-		if err := os.WriteFile(p, []byte(name), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		paths = append(paths, p)
-	}
-
-	dest := filepath.Join(dir, "checksums.txt")
-	if err := writeChecksums(dest, paths); err != nil {
-		t.Fatalf("writeChecksums: %v", err)
-	}
-
-	got, err := os.ReadFile(dest)
-	if err != nil {
-		t.Fatal(err)
-	}
-	lines := strings.Split(strings.TrimSpace(string(got)), "\n")
-	if len(lines) != 2 {
-		t.Fatalf("expected 2 lines, got %d: %s", len(lines), got)
-	}
-	for i, name := range names {
-		h := sha256.Sum256([]byte(name))
-		want := hex.EncodeToString(h[:]) + "  " + name
-		if lines[i] != want {
-			t.Errorf("line[%d] = %q, want %q", i, lines[i], want)
-		}
-	}
-}
-
-func TestWriteChecksums_missingFile(t *testing.T) {
-	dir := t.TempDir()
-	dest := filepath.Join(dir, "checksums.txt")
-	err := writeChecksums(dest, []string{filepath.Join(dir, "nonexistent.tar.gz")})
-	if err == nil {
-		t.Error("expected error for missing archive, got nil")
-	}
-}
-
-func TestTargets_includesWindows(t *testing.T) {
-	var gotAMD64, gotARM64 bool
-	for _, tgt := range targets {
-		if tgt.os != "windows" {
-			continue
-		}
-		switch tgt.arch {
-		case "amd64":
-			gotAMD64 = true
-		case "arm64":
-			gotARM64 = true
-		}
-	}
-	if !gotAMD64 {
-		t.Error("targets missing windows/amd64")
-	}
-	if !gotARM64 {
-		t.Error("targets missing windows/arm64")
-	}
-}
-
-func TestTargets_preservesLinuxDarwin(t *testing.T) {
-	want := map[string]bool{
-		"linux/amd64":  false,
-		"linux/arm64":  false,
-		"darwin/amd64": false,
-		"darwin/arm64": false,
-	}
-	for _, tgt := range targets {
-		key := tgt.os + "/" + tgt.arch
-		if _, ok := want[key]; ok {
-			want[key] = true
-		}
-	}
-	for key, found := range want {
-		if !found {
-			t.Errorf("targets missing %s", key)
-		}
-	}
-}
-
-func TestExecutableName(t *testing.T) {
-	if got := executableName("windows"); got != "savepoint.exe" {
-		t.Errorf("executableName(windows) = %q, want savepoint.exe", got)
-	}
-	if got := executableName("linux"); got != "savepoint" {
-		t.Errorf("executableName(linux) = %q, want savepoint", got)
-	}
-	if got := executableName("darwin"); got != "savepoint" {
-		t.Errorf("executableName(darwin) = %q, want savepoint", got)
-	}
-}
-
-func TestWriteTarGzPreservesWindowsExecutableName(t *testing.T) {
-	dir := t.TempDir()
-	source := filepath.Join(dir, "savepoint.exe")
-	if err := os.WriteFile(source, []byte("binary"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	archive := filepath.Join(dir, "savepoint-windows-amd64.tar.gz")
-	if err := writeTarGz(archive, source, executableName("windows")); err != nil {
-		t.Fatalf("writeTarGz: %v", err)
-	}
-
-	f, err := os.Open(archive)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	gz, err := gzip.NewReader(f)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer gz.Close()
-
-	tr := tar.NewReader(gz)
-	header, err := tr.Next()
-	if err != nil {
-		t.Fatal(err)
-	}
-	if header.Name != "savepoint.exe" {
-		t.Fatalf("archive member = %q, want savepoint.exe", header.Name)
-	}
-
-	content, err := io.ReadAll(tr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(content) != "binary" {
-		t.Fatalf("archive content = %q, want binary", content)
-	}
-}
-
-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
-}