savepoint 1.0.3 → 1.0.4

package/internal/board/view_test.go

@@ -1,6 +1,7 @@
 package board
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 
@@ -301,6 +302,67 @@ func TestRenderNextActivityLine_truncatesAtNarrowWidth(t *testing.T) {
 	}
 }
 
+func BenchmarkCalculateLayout_narrow(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(60, 24)
+	}
+}
+
+func BenchmarkCalculateLayout_standard(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(80, 24)
+	}
+}
+
+func BenchmarkCalculateLayout_wide(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(120, 24)
+	}
+}
+
+func BenchmarkCalculateLayout_extraWide(b *testing.B) {
+	b.ReportAllocs()
+	for b.Loop() {
+		CalculateLayout(220, 50)
+	}
+}
+
+func BenchmarkView_empty(b *testing.B) {
+	m := NewModel(nil, "v1", "E03")
+	m.Width = 120
+	m.Height = 40
+	b.ReportAllocs()
+	for b.Loop() {
+		m.View()
+	}
+}
+
+func BenchmarkView_withTasks(b *testing.B) {
+	tasks := make([]data.Task, 15)
+	stages := []data.ProgressStage{data.StageBuild, data.StageTest, data.StageAudit}
+	cols := []data.ColumnType{data.ColumnPlanned, data.ColumnInProgress, data.ColumnDone}
+	for i := range tasks {
+		tasks[i] = data.Task{
+			ID:      fmt.Sprintf("E06-layout/T%03d-task-slug", i+1),
+			Title:   fmt.Sprintf("Task %d with a reasonable title length", i+1),
+			Column:  cols[i%3],
+			Stage:   stages[i%3],
+			Release: "v1.1",
+			Epic:    "E06-layout",
+		}
+	}
+	m := NewModel(tasks, "v1.1", "E06")
+	m.Width = 120
+	m.Height = 40
+	b.ReportAllocs()
+	for b.Loop() {
+		m.View()
+	}
+}
+
 func TestView_narrowShowsSingleColumn(t *testing.T) {
 	m := NewModel(nil, "v1", "E03")
 	m.Width = 60

package/internal/board/watch.go

@@ -52,6 +52,7 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 				if !ok {
 					return nil
 				}
+				debugf("watcher: event %s", event)
 				watchCreatedDir(w, event)
 				timer := time.NewTimer(100 * time.Millisecond)
 			drain:
@@ -62,11 +63,13 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 							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 {
@@ -79,10 +82,13 @@ func watchFiles(w *fsnotify.Watcher) tea.Cmd {
 
 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}
 	}

package/internal/buildtool/main.go

@@ -3,15 +3,17 @@ package main
 import (
 	"archive/tar"
 	"compress/gzip"
+	"crypto/sha256"
+	"encoding/hex"
 	"errors"
 	"flag"
 	"fmt"
 	"io"
 	"os"
 	"os/exec"
-	"strings"
 	"path/filepath"
 	"runtime"
+	"strings"
 )
 
 type target struct {
@@ -24,6 +26,8 @@ var targets = []target{
 	{os: "linux", arch: "arm64"},
 	{os: "darwin", arch: "amd64"},
 	{os: "darwin", arch: "arm64"},
+	{os: "windows", arch: "amd64"},
+	{os: "windows", arch: "arm64"},
 }
 
 var versionOverride string
@@ -42,7 +46,7 @@ func run(args []string) error {
 		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>")
+		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) {
@@ -54,6 +58,8 @@ func run(args []string) error {
 		return buildMatching("linux")
 	case "build-darwin":
 		return buildMatching("darwin")
+	case "build-windows":
+		return buildMatching("windows")
 	case "build-all":
 		return buildAll()
 	case "dist":
@@ -99,8 +105,15 @@ func buildAll() error {
 	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, "savepoint")
+	output := filepath.Join("dist", target.os+"-"+target.arch, executableName(target.os))
 	return runGoBuild(output, target.os, target.arch)
 }
 
@@ -123,13 +136,39 @@ 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, "savepoint")
+		source := filepath.Join("dist", target.os+"-"+target.arch, executableName(target.os))
 		archive := filepath.Join("dist", name)
-		if err := writeTarGz(archive, source, "savepoint"); err != nil {
+		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
 }
@@ -208,4 +247,3 @@ func localExecutable() string {
 	}
 	return "savepoint"
 }
-

package/internal/buildtool/main_test.go

@@ -1,8 +1,15 @@
 package main
 
 import (
+	"archive/tar"
+	"compress/gzip"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
 	"os"
+	"path/filepath"
 	"runtime"
+	"strings"
 	"testing"
 )
 
@@ -32,6 +39,177 @@ func TestVersion_fallback(t *testing.T) {
 	}
 }
 
+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" {

package/internal/data/fuzz_test.go

@@ -0,0 +1,75 @@
+package data
+
+import (
+	"testing"
+)
+
+func FuzzExtractFrontmatter(f *testing.F) {
+	seeds := []string{
+		"---\nid: E01/T001\nstatus: planned\n---\nbody",
+		"---\n---\n",
+		"---\n\n---\n",
+		"---\nid: test\n---",
+		"",
+		"# no frontmatter",
+		"---\nid: [broken\n---\n",
+		"---\nname: héllo wörld\n---\n",
+		"---\nid: test\nstatus: in_progress\nphase: build\n---\nbody content",
+		"---\r\nid: test\r\n---\r\nbody",
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, content string) {
+		_, _ = extractFrontmatter(content)
+	})
+}
+
+func FuzzParseFrontmatter(f *testing.F) {
+	seeds := []string{
+		"---\nid: E01/T001\nstatus: planned\n---\nbody",
+		"---\n---\n",
+		"---\nid: [broken\n---\n",
+		"---\nname: héllo\n---\n",
+		"",
+		"no frontmatter",
+		"---\ntags: [a, b, c]\n---\n",
+		"---\nnested:\n  key: val\n---\n",
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, content string) {
+		p := NewParser()
+		_, _ = p.ParseFrontmatter(content)
+	})
+}
+
+func FuzzSplitFrontmatterBody(f *testing.F) {
+	seeds := []string{
+		"---\nid: E01/T001\nstatus: planned\n---\nbody",
+		"---\n---\n",
+		"---\nkey: value\n---",
+		"",
+		"# no frontmatter",
+		"---\nid: test\nstatus: in_progress\n---\n\n## Section\n\nContent.",
+		"---\nid: test\n---\n\nbody with unicode: 日本語",
+	}
+	for _, s := range seeds {
+		f.Add(s)
+	}
+	f.Fuzz(func(t *testing.T, content string) {
+		yamlStr, body, err := SplitFrontmatterBody(content)
+		if err != nil {
+			return
+		}
+		reconstructed := "---\n" + yamlStr + "\n---" + body
+		_, body2, err2 := SplitFrontmatterBody(reconstructed)
+		if err2 != nil {
+			t.Errorf("round-trip SplitFrontmatterBody failed on reconstructed: %v", err2)
+		}
+		if body2 != body {
+			t.Errorf("round-trip body mismatch: got %q, want %q", body2, body)
+		}
+	})
+}

package/internal/data/parser.go

@@ -88,9 +88,10 @@ type taskFrontmatter struct {
 	Progress    Progress      `yaml:"progress"`
 }
 
-// normalizeLineEndings replaces Windows line endings with Unix line endings.
+// normalizeLineEndings replaces Windows (CRLF) and legacy Mac (CR) line endings with LF.
 func normalizeLineEndings(s string) string {
-	return strings.ReplaceAll(s, "\r\n", "\n")
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+	return strings.ReplaceAll(s, "\r", "\n")
 }
 
 func extractFrontmatter(content string) (string, error) {

package/internal/data/testdata/fuzz/FuzzSplitFrontmatterBody/68eb66b0fe91e7e3

@@ -0,0 +1,2 @@
+go test fuzz v1
+string("---\n\n---\r\r\n")

package/internal/data/write.go

@@ -40,17 +40,20 @@ func UpdateLastAudited(path, value string) error {
 // SplitFrontmatterBody splits content into frontmatter YAML and body.
 func SplitFrontmatterBody(content string) (yamlStr string, body string, err error) {
 	normalized := normalizeLineEndings(content)
-	raw, err := extractFrontmatter(normalized)
-	if err != nil {
-		return "", "", err
+	if !strings.HasPrefix(normalized, "---\n") {
+		return "", "", ErrNoFrontmatter
+	}
+	end := strings.Index(normalized[4:], "\n---")
+	if end == -1 {
+		return "", "", ErrNoClosingFrontmatter
 	}
-	delimLen := 4
-	bodyStart := delimLen + len(raw) + delimLen
+	yamlStr = strings.TrimSpace(normalized[4 : 4+end])
+	bodyStart := 4 + end + 4 // "---\n" + yaml + "\n---"
 	body = ""
 	if bodyStart < len(normalized) {
 		body = normalized[bodyStart:]
 	}
-	return raw, body, nil
+	return yamlStr, body, nil
 }
 
 func updateFrontmatterField(path, key, value string) error {

package/main.go

@@ -22,19 +22,24 @@ var projectTemplates embed.FS
 var version = "dev"
 
 func main() {
-	if len(os.Args) > 1 {
-		switch os.Args[1] {
+	args, debug := stripDebugFlag(os.Args[1:])
+	if debug || os.Getenv("SAVEPOINT_DEBUG") != "" {
+		board.SetDebug(true)
+	}
+
+	if len(args) > 0 {
+		switch args[0] {
 		case "--version":
 			fmt.Println(version)
 			os.Exit(0)
 		case "init":
-			if err := cmd.RunInit(context.Background(), os.Args[2:], os.Stdout, initRunner); err != nil {
+			if err := cmd.RunInit(context.Background(), args[1:], 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 {
+			if err := cmd.RunBoard(context.Background(), args[1:], os.Stdout, func(opts cmd.BoardOptions) error {
 				return board.RunWithFilters(opts.Release, opts.Epic)
 			}); err != nil {
 				fmt.Fprintln(os.Stderr, err)
@@ -42,7 +47,7 @@ func main() {
 			}
 			os.Exit(0)
 		case "doctor":
-			code, err := cmd.RunDoctor(context.Background(), os.Args[2:], os.Stdout, func(opts cmd.DoctorOptions) (int, error) {
+			code, err := cmd.RunDoctor(context.Background(), args[1:], os.Stdout, func(opts cmd.DoctorOptions) (int, error) {
 				return runDoctorChecks(opts)
 			})
 			if err != nil {
@@ -56,6 +61,20 @@ func main() {
 	}
 }
 
+// stripDebugFlag removes --debug from args and reports whether it was present.
+func stripDebugFlag(args []string) ([]string, bool) {
+	out := make([]string, 0, len(args))
+	found := false
+	for _, a := range args {
+		if a == "--debug" {
+			found = true
+		} else {
+			out = append(out, a)
+		}
+	}
+	return out, found
+}
+
 func runDoctorChecks(opts cmd.DoctorOptions) (int, error) {
 	discover := data.NewDiscover()
 	root, err := discover.FindSavepointRoot(".")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "savepoint",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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",