devrites 4.2.0 → 4.3.0

package/engine/internal/parallel/ops.go

@@ -0,0 +1,416 @@
+package parallel
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// CreateOpts configures parallel worktree creation.
+type CreateOpts struct {
+	Root    string
+	Slug    string
+	BatchID string
+	BaseSHA string
+	Session string
+	Slices  []SlicePaths
+}
+
+// Create path-disjoint-gates, creates <=3 worktrees from base, and writes a running lease.
+func Create(opts CreateOpts) (*Lease, error) {
+	if err := validateSlug(opts.Slug); err != nil {
+		return nil, err
+	}
+	if err := validateBatchID(opts.BatchID); err != nil {
+		return nil, err
+	}
+	if len(opts.Slices) < 2 || len(opts.Slices) > 3 {
+		return nil, fmt.Errorf("create requires 2 or 3 slices (got %d)", len(opts.Slices))
+	}
+	if _, err := CheckPathDisjoint(opts.Slices, opts.Root); err != nil {
+		return nil, err
+	}
+	base, err := revParse(opts.Root, opts.BaseSHA)
+	if err != nil {
+		return nil, fmt.Errorf("base sha: %w", err)
+	}
+	leasePath, err := LeasePath(opts.Root, opts.Slug)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := os.Stat(leasePath); err == nil {
+		return nil, fmt.Errorf("lease already exists: %s", leasePath)
+	}
+
+	session := opts.Session
+	if session == "" {
+		session = fmt.Sprintf("pid:%d", os.Getpid())
+	}
+
+	createdPaths := make([]string, 0, len(opts.Slices))
+	createdBranches := make([]string, 0, len(opts.Slices))
+	cleanupPartial := func() {
+		for _, p := range createdPaths {
+			_ = worktreeRemove(opts.Root, p)
+		}
+		for _, b := range createdBranches {
+			_ = deleteBranch(opts.Root, b)
+		}
+	}
+
+	slices := make([]LeaseSlice, 0, len(opts.Slices))
+	for _, sp := range opts.Slices {
+		if err := validateSliceID(sp.ID); err != nil {
+			cleanupPartial()
+			return nil, err
+		}
+		paths, err := validateSlicePaths(sp.Paths, fmt.Sprintf("slice %q", sp.ID), opts.Root)
+		if err != nil {
+			cleanupPartial()
+			return nil, err
+		}
+		branch := WorkerBranch(opts.Slug, opts.BatchID, sp.ID)
+		wt := WorkerWorktreePath(opts.Root, opts.BatchID, sp.ID)
+		if _, err := os.Stat(wt); err == nil {
+			cleanupPartial()
+			return nil, fmt.Errorf("worktree path already exists: %s", wt)
+		}
+		if err := os.MkdirAll(filepath.Dir(wt), 0o755); err != nil {
+			cleanupPartial()
+			return nil, err
+		}
+		if err := worktreeAdd(opts.Root, wt, branch, base); err != nil {
+			cleanupPartial()
+			return nil, fmt.Errorf("worktree add %s: %w", sp.ID, err)
+		}
+		createdPaths = append(createdPaths, wt)
+		createdBranches = append(createdBranches, branch)
+		slices = append(slices, LeaseSlice{
+			ID:           sp.ID,
+			Paths:        paths,
+			WorktreePath: wt,
+			Branch:       branch,
+			WrightStatus: WrightPending,
+		})
+	}
+
+	lease := &Lease{
+		BatchID:             opts.BatchID,
+		CreatedAt:           NowUTC(),
+		BaseSHA:             base,
+		N:                   len(slices),
+		Status:              StatusRunning,
+		ControlPIDOrSession: session,
+		Slices:              slices,
+	}
+	if err := WriteLease(leasePath, lease); err != nil {
+		cleanupPartial()
+		return nil, err
+	}
+	return lease, nil
+}
+
+// RecordGreen marks a slice green with its transfer commit.
+func RecordGreen(repoRoot, slug, sliceID, commit string) (*Lease, error) {
+	leasePath, err := LeasePath(repoRoot, slug)
+	if err != nil {
+		return nil, err
+	}
+	lease, err := ReadLease(leasePath)
+	if err != nil {
+		return nil, err
+	}
+	if lease.Status != StatusRunning {
+		return nil, fmt.Errorf("record-green requires status=running (have %s)", lease.Status)
+	}
+	sha, err := revParse(repoRoot, commit)
+	if err != nil {
+		return nil, fmt.Errorf("transfer commit: %w", err)
+	}
+	found := false
+	for i := range lease.Slices {
+		if lease.Slices[i].ID == sliceID {
+			lease.Slices[i].WrightStatus = WrightGreen
+			lease.Slices[i].TransferCommit = sha
+			found = true
+			break
+		}
+	}
+	if !found {
+		return nil, fmt.Errorf("slice not in lease: %s", sliceID)
+	}
+	if err := WriteLease(leasePath, lease); err != nil {
+		return nil, err
+	}
+	return lease, nil
+}
+
+// Abort marks the lease aborted and restores control tip to base_sha.
+func Abort(repoRoot, slug string, force bool) (*Lease, error) {
+	leasePath, err := LeasePath(repoRoot, slug)
+	if err != nil {
+		return nil, err
+	}
+	lease, err := ReadLease(leasePath)
+	if err != nil {
+		return nil, err
+	}
+	base, err := revParse(repoRoot, lease.BaseSHA)
+	if err != nil {
+		return nil, err
+	}
+	if err := ensureControlAtBase(repoRoot, base, force); err != nil {
+		return nil, err
+	}
+	lease.Status = StatusAborted
+	if err := WriteLease(leasePath, lease); err != nil {
+		return nil, err
+	}
+	return lease, nil
+}
+
+func ensureControlAtBase(repoRoot, base string, force bool) error {
+	head, err := headSHA(repoRoot)
+	if err != nil {
+		return err
+	}
+	if head == base {
+		return nil
+	}
+	dirty, err := porcelainDirty(repoRoot)
+	if err != nil {
+		return err
+	}
+	if dirty && !force {
+		return fmt.Errorf("control tree dirty; refuse reset to base (pass --force to override)")
+	}
+	if err := resetHard(repoRoot, base); err != nil {
+		return err
+	}
+	head, err = headSHA(repoRoot)
+	if err != nil {
+		return err
+	}
+	if head != base {
+		return fmt.Errorf("failed to leave control at base %s", base)
+	}
+	return nil
+}
+
+// IntegrateOpts configures staging integrate.
+type IntegrateOpts struct {
+	Root           string
+	Slug           string
+	ApplyToControl bool
+	Force          bool
+}
+
+// Integrate all-or-nothing applies sibling transfer commits onto a staging branch.
+func Integrate(opts IntegrateOpts) (tip string, lease *Lease, err error) {
+	leasePath, err := LeasePath(opts.Root, opts.Slug)
+	if err != nil {
+		return "", nil, err
+	}
+	lease, err = ReadLease(leasePath)
+	if err != nil {
+		return "", nil, err
+	}
+	if lease.Status != StatusRunning {
+		return "", nil, fmt.Errorf("integrate requires status=running (have %s)", lease.Status)
+	}
+	base, err := revParse(opts.Root, lease.BaseSHA)
+	if err != nil {
+		return "", nil, err
+	}
+	if err := ensureControlAtBase(opts.Root, base, opts.Force); err != nil {
+		return "", nil, err
+	}
+
+	for _, sl := range lease.Slices {
+		if sl.WrightStatus != WrightGreen {
+			return "", nil, fmt.Errorf("slice %s is not green", sl.ID)
+		}
+		if sl.TransferCommit == "" {
+			return "", nil, fmt.Errorf("slice %s missing transfer_commit", sl.ID)
+		}
+	}
+
+	ibranch := IntegrateBranchName(opts.Slug, lease.BatchID)
+	stageWT := filepath.Join(ScratchRoot(opts.Root), lease.BatchID, "integrate")
+	_ = os.RemoveAll(stageWT)
+	if exists, _ := branchExists(opts.Root, ibranch); exists {
+		_ = deleteBranch(opts.Root, ibranch)
+	}
+	if err := os.MkdirAll(filepath.Dir(stageWT), 0o755); err != nil {
+		return "", nil, err
+	}
+	if err := worktreeAdd(opts.Root, stageWT, ibranch, base); err != nil {
+		return "", nil, fmt.Errorf("staging worktree: %w", err)
+	}
+
+	fail := func(reason error) (string, *Lease, error) {
+		_ = worktreeRemove(opts.Root, stageWT)
+		_ = deleteBranch(opts.Root, ibranch)
+		_, _ = git(opts.Root, "worktree", "prune")
+		lease.Status = StatusIntegrateFailed
+		_ = WriteLease(leasePath, lease)
+		_ = ensureControlAtBase(opts.Root, base, true)
+		return "", lease, reason
+	}
+
+	for _, sl := range lease.Slices {
+		tc, err := revParse(opts.Root, sl.TransferCommit)
+		if err != nil {
+			return fail(fmt.Errorf("slice %s transfer: %w", sl.ID, err))
+		}
+		ok, err := isAncestor(opts.Root, base, tc)
+		if err != nil {
+			return fail(err)
+		}
+		if !ok {
+			return fail(fmt.Errorf("transfer_commit for %s is not a descendant of base", sl.ID))
+		}
+		got, err := diffNames(opts.Root, base, tc)
+		if err != nil {
+			return fail(err)
+		}
+		want := append([]string(nil), sl.Paths...)
+		sort.Strings(want)
+		sort.Strings(got)
+		if !pathListsEqual(want, got) {
+			return fail(fmt.Errorf("exact-path proof failed for slice %s: want=%v got=%v", sl.ID, want, got))
+		}
+		for _, p := range got {
+			if p == ".devrites" || strings.HasPrefix(p, ".devrites/") {
+				return fail(fmt.Errorf("path proof failed: .devrites path in transfer: %s", p))
+			}
+		}
+
+		stageHead, err := headSHA(stageWT)
+		if err != nil {
+			return fail(err)
+		}
+		canFF, err := isAncestor(opts.Root, stageHead, tc)
+		if err != nil {
+			return fail(err)
+		}
+		if canFF {
+			if err := mergeFFOnly(stageWT, tc); err != nil {
+				return fail(fmt.Errorf("ff-only integrate failed for slice %s: %w", sl.ID, err))
+			}
+		} else {
+			if err := cherryPickRange(stageWT, base, tc); err != nil {
+				cherryPickAbort(stageWT)
+				return fail(fmt.Errorf("cherry-pick replay failed for slice %s: %w", sl.ID, err))
+			}
+		}
+	}
+
+	tip, err = headSHA(stageWT)
+	if err != nil {
+		return fail(err)
+	}
+	_ = worktreeRemove(opts.Root, stageWT)
+	_, _ = git(opts.Root, "worktree", "prune")
+
+	if opts.ApplyToControl {
+		if err := mergeFFOnly(opts.Root, tip); err != nil {
+			return fail(fmt.Errorf("control fast-forward to integrate tip failed: %w", err))
+		}
+	} else if err := ensureControlAtBase(opts.Root, base, opts.Force); err != nil {
+		return fail(err)
+	}
+
+	lease.Status = StatusComplete
+	if err := WriteLease(leasePath, lease); err != nil {
+		return "", nil, err
+	}
+	return tip, lease, nil
+}
+
+func pathListsEqual(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// Cleanup removes worker worktrees/branches and clears the lease (complete or --force).
+func Cleanup(repoRoot, slug string, force bool) error {
+	leasePath, err := LeasePath(repoRoot, slug)
+	if err != nil {
+		return err
+	}
+	if _, err := os.Stat(leasePath); os.IsNotExist(err) {
+		return nil
+	}
+	lease, err := ReadLease(leasePath)
+	if err != nil {
+		return err
+	}
+	if lease.Status != StatusComplete && !force {
+		return fmt.Errorf("cleanup refuses status=%s without --force (abort keeps workers for diagnosis)", lease.Status)
+	}
+	for _, sl := range lease.Slices {
+		if sl.WorktreePath != "" {
+			_ = worktreeRemove(repoRoot, sl.WorktreePath)
+			_ = os.RemoveAll(sl.WorktreePath)
+		}
+		if sl.Branch != "" {
+			_ = deleteBranch(repoRoot, sl.Branch)
+		}
+	}
+	ibranch := IntegrateBranchName(slug, lease.BatchID)
+	_ = deleteBranch(repoRoot, ibranch)
+	_ = os.RemoveAll(filepath.Join(ScratchRoot(repoRoot), lease.BatchID))
+	_, _ = git(repoRoot, "worktree", "prune")
+	return ClearLease(leasePath)
+}
+
+// StatusReport returns a human-readable lease status.
+func StatusReport(repoRoot, slug string) (string, error) {
+	leasePath, err := LeasePath(repoRoot, slug)
+	if err != nil {
+		return "", err
+	}
+	if _, err := os.Stat(leasePath); os.IsNotExist(err) {
+		return fmt.Sprintf("status: no lease at %s\n", leasePath), nil
+	}
+	lease, err := ReadLease(leasePath)
+	if err != nil {
+		return "", err
+	}
+	var b strings.Builder
+	fmt.Fprintf(&b, "lease: %s\n", leasePath)
+	fmt.Fprintf(&b, "status: %s\n", lease.Status)
+	fmt.Fprintf(&b, "base_sha: %s\n", lease.BaseSHA)
+	for _, sl := range lease.Slices {
+		tc := sl.TransferCommit
+		if tc == "" {
+			tc = "-"
+		}
+		fmt.Fprintf(&b, "slice %s: wright=%s wt=%s branch=%s transfer=%s\n",
+			sl.ID, sl.WrightStatus, sl.WorktreePath, sl.Branch, tc)
+	}
+	if head, err := headSHA(repoRoot); err == nil {
+		fmt.Fprintf(&b, "control_HEAD: %s\n", head)
+	}
+	return b.String(), nil
+}
+
+// LeaseJSON returns indented lease JSON.
+func LeaseJSON(lease *Lease) (string, error) {
+	b, err := json.MarshalIndent(lease, "", "  ")
+	if err != nil {
+		return "", err
+	}
+	return string(b), nil
+}

package/engine/internal/parallel/parallel_test.go

@@ -0,0 +1,242 @@
+package parallel
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func gitOk(t *testing.T, dir string, args ...string) string {
+	t.Helper()
+	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
+	cmd.Env = append(os.Environ(),
+		"GIT_CONFIG_NOSYSTEM=1",
+		"GIT_TERMINAL_PROMPT=0",
+		"GIT_AUTHOR_NAME=DevRites Test",
+		"GIT_AUTHOR_EMAIL=devrites@example.invalid",
+		"GIT_COMMITTER_NAME=DevRites Test",
+		"GIT_COMMITTER_EMAIL=devrites@example.invalid",
+	)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %v: %v\n%s", args, err, out)
+	}
+	return strings.TrimSpace(string(out))
+}
+
+func setupRepo(t *testing.T) (repo, base string) {
+	t.Helper()
+	repo = t.TempDir()
+	gitOk(t, repo, "init")
+	gitOk(t, repo, "checkout", "-b", "main")
+	if err := os.MkdirAll(filepath.Join(repo, "src"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(repo, "src", "a.go"), []byte("package main\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(repo, "src", "b.go"), []byte("package main\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(repo, "README.md"), []byte("base\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, repo, "add", ".")
+	gitOk(t, repo, "commit", "-m", "base")
+	base = gitOk(t, repo, "rev-parse", "HEAD")
+	return repo, base
+}
+
+func TestLeaseRoundTrip(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "parallel-lease.md")
+	lease := &Lease{
+		BatchID:             "batch1",
+		CreatedAt:           "2026-08-23T00:00:00Z",
+		BaseSHA:             "abcdef1",
+		N:                   2,
+		Status:              StatusRunning,
+		ControlPIDOrSession: "test",
+		Slices: []LeaseSlice{
+			{ID: "slice-a", Paths: []string{"src/a.go"}, WorktreePath: "/tmp/a", Branch: "devrites/parallel/x/batch1/slice-a", WrightStatus: WrightPending},
+			{ID: "slice-b", Paths: []string{"src/b.go"}, WorktreePath: "/tmp/b", Branch: "devrites/parallel/x/batch1/slice-b", WrightStatus: WrightPending},
+		},
+	}
+	if err := WriteLease(path, lease); err != nil {
+		t.Fatal(err)
+	}
+	got, err := ReadLease(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.BatchID != "batch1" || got.Status != StatusRunning || len(got.Slices) != 2 {
+		t.Fatalf("unexpected lease: %#v", got)
+	}
+}
+
+func TestCreateAbortCleanup(t *testing.T) {
+	repo, base := setupRepo(t)
+	slug := "demo-feature"
+	batch := "batch1"
+	lease, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    slug,
+		BatchID: batch,
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/b.go"}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.Status != StatusRunning || lease.N != 2 {
+		t.Fatalf("lease=%#v", lease)
+	}
+	wtA := lease.Slices[0].WorktreePath
+	wtB := lease.Slices[1].WorktreePath
+	for _, wt := range []string{wtA, wtB} {
+		if _, err := os.Stat(wt); err != nil {
+			t.Fatalf("missing worktree %s: %v", wt, err)
+		}
+		if head := gitOk(t, wt, "rev-parse", "HEAD"); head != base {
+			t.Fatalf("worktree head %s want %s", head, base)
+		}
+	}
+	if head := gitOk(t, repo, "rev-parse", "HEAD"); head != base {
+		t.Fatalf("control moved after create: %s", head)
+	}
+
+	// Drift control tip, then abort should restore base.
+	if err := os.WriteFile(filepath.Join(repo, "README.md"), []byte("drift\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, repo, "add", "README.md")
+	gitOk(t, repo, "commit", "-m", "drift")
+	if _, err := Abort(repo, slug, true); err != nil {
+		t.Fatal(err)
+	}
+	if head := gitOk(t, repo, "rev-parse", "HEAD"); head != base {
+		t.Fatalf("abort left control at %s want %s", head, base)
+	}
+	leasePath, _ := LeasePath(repo, slug)
+	lease, err = ReadLease(leasePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.Status != StatusAborted {
+		t.Fatalf("status=%s", lease.Status)
+	}
+	if _, err := os.Stat(wtA); err != nil {
+		t.Fatalf("abort should preserve worktree: %v", err)
+	}
+
+	if err := Cleanup(repo, slug, true); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(wtA); !os.IsNotExist(err) {
+		t.Fatalf("cleanup should remove worktree A")
+	}
+	if _, err := os.Stat(leasePath); !os.IsNotExist(err) {
+		t.Fatalf("cleanup should clear lease")
+	}
+}
+
+func TestCreateRefusesOverlap(t *testing.T) {
+	repo, base := setupRepo(t)
+	_, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    "demo",
+		BatchID: "batch1",
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/a.go"}},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "overlap") {
+		t.Fatalf("expected overlap refusal, got %v", err)
+	}
+}
+
+func TestIntegrateDivergentSiblings(t *testing.T) {
+	repo, base := setupRepo(t)
+	slug := "demo-feature"
+	batch := "batch1"
+	lease, err := Create(CreateOpts{
+		Root:    repo,
+		Slug:    slug,
+		BatchID: batch,
+		BaseSHA: base,
+		Slices: []SlicePaths{
+			{ID: "slice-a", Paths: []string{"src/a.go"}},
+			{ID: "slice-b", Paths: []string{"src/b.go"}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	wtA := lease.Slices[0].WorktreePath
+	wtB := lease.Slices[1].WorktreePath
+
+	if err := os.WriteFile(filepath.Join(wtA, "src", "a.go"), []byte("package main\n\nfunc A() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, wtA, "add", "src/a.go")
+	gitOk(t, wtA, "commit", "-m", "slice-a green")
+	tcA := gitOk(t, wtA, "rev-parse", "HEAD")
+
+	if err := os.WriteFile(filepath.Join(wtB, "src", "b.go"), []byte("package main\n\nfunc B() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	gitOk(t, wtB, "add", "src/b.go")
+	gitOk(t, wtB, "commit", "-m", "slice-b green")
+	tcB := gitOk(t, wtB, "rev-parse", "HEAD")
+
+	if _, err := RecordGreen(repo, slug, "slice-a", tcA); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := RecordGreen(repo, slug, "slice-b", tcB); err != nil {
+		t.Fatal(err)
+	}
+
+	tip, lease, err := Integrate(IntegrateOpts{Root: repo, Slug: slug, ApplyToControl: true})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if lease.Status != StatusComplete {
+		t.Fatalf("status=%s", lease.Status)
+	}
+	if tip == "" || tip == base {
+		t.Fatalf("expected advanced tip, got %s", tip)
+	}
+	head := gitOk(t, repo, "rev-parse", "HEAD")
+	if head != tip {
+		t.Fatalf("control head %s want tip %s", head, tip)
+	}
+	a := mustRead(t, filepath.Join(repo, "src", "a.go"))
+	b := mustRead(t, filepath.Join(repo, "src", "b.go"))
+	if !strings.Contains(a, "func A") || !strings.Contains(b, "func B") {
+		t.Fatalf("integrated contents missing: a=%q b=%q", a, b)
+	}
+
+	if err := Cleanup(repo, slug, false); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(wtA); !os.IsNotExist(err) {
+		t.Fatalf("cleanup should remove workers")
+	}
+}
+
+func mustRead(t *testing.T, path string) string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(b)
+}