devrites 7.2.8 → 7.3.1

package/engine/internal/parallel/cli.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 )
@@ -79,18 +80,27 @@ func cmdSelect(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	capN := 0
 	sawCap := false
 	fromPlan := false
+	workspaces := ""
+	sawWorkspaces, sawInput := false, false
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
-		case "--root", "--slug":
+		case "--root", "--slug", "--workspaces":
 			if i+1 >= len(args) {
 				fmt.Fprintln(stderr, usageSelect)
 				return ExitUsage
 			}
 			i++
-			if args[i-1] == "--root" {
+			switch args[i-1] {
+			case "--root":
 				root = args[i]
-			} else {
+			case "--slug":
 				slug = args[i]
+			case "--workspaces":
+				if sawWorkspaces {
+					fmt.Fprintln(stderr, "parallel select: duplicate --workspaces")
+					return ExitUsage
+				}
+				workspaces, sawWorkspaces = args[i], true
 			}
 		case "--cap":
 			if i+1 >= len(args) {
@@ -116,28 +126,90 @@ func cmdSelect(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 				return ExitUsage
 			}
 			jsonPath = args[i]
+			if sawInput {
+				fmt.Fprintln(stderr, "parallel select: multiple JSON inputs")
+				return ExitUsage
+			}
+			sawInput = true
 		}
 	}
-	if !sawCap {
+	if !sawCap || capN < 1 || capN > MaxParallelSlices {
 		fmt.Fprintln(stderr, usageSelect)
 		return ExitUsage
 	}
+	if sawWorkspaces && (!fromPlan || root == "" || slug == "" || sawInput) {
+		fmt.Fprintln(stderr, "parallel select: --workspaces requires --from-plan, --root and --slug and takes no JSON input")
+		return ExitUsage
+	}
 	var slices []SlicePaths
 	if fromPlan {
-		if slug == "" || jsonPath != "-" {
+		if slug == "" || sawInput {
 			fmt.Fprintln(stderr, "parallel select: --from-plan needs --slug and takes no JSON input")
 			return ExitUsage
 		}
-		if PlanReady == nil {
-			fmt.Fprintln(stderr, "parallel select: --from-plan is unavailable in this build")
-			return ExitBlocked
-		}
-		ready, err := PlanReady(root, slug)
-		if err != nil {
-			fmt.Fprintf(stderr, "parallel select: %v\n", err)
-			return ExitBlocked
+		if sawWorkspaces {
+			order := []string{slug}
+			seen := make(map[string]bool)
+			if err := validateSlug(slug); err != nil {
+				fmt.Fprintf(stderr, "parallel select: %v\n", err)
+				return ExitUsage
+			}
+			for _, target := range strings.Split(workspaces, ",") {
+				if err := validateSlug(target); err != nil || seen[target] {
+					fmt.Fprintf(stderr, "parallel select: invalid or duplicate workspace %q\n", target)
+					return ExitUsage
+				}
+				seen[target] = true
+				if target != slug {
+					order = append(order, target)
+				}
+			}
+			if _, err := controllerLease(root, slug); err != nil {
+				fmt.Fprintf(stderr, "parallel select: %v\n", err)
+				return ExitBlocked
+			}
+			if WorkspaceReady == nil {
+				fmt.Fprintln(stderr, "parallel select: --workspaces is unavailable in this build")
+				return ExitBlocked
+			}
+			for _, target := range order {
+				ready, notices, err := WorkspaceReady(root, slug, target)
+				for _, notice := range notices {
+					fmt.Fprintf(stderr, "parallel select: workspace %s: %s\n", target, notice)
+				}
+				if err == nil {
+					ready, err = normalizeSlices(slug, ready, root)
+				}
+				if err == nil {
+					for _, sp := range ready {
+						source := sp.Workspace
+						if source == "" {
+							source = slug
+						}
+						if source != target {
+							err = fmt.Errorf("candidate source %s does not match requested workspace", source)
+							break
+						}
+					}
+				}
+				if err != nil {
+					fmt.Fprintf(stderr, "parallel select: workspace %s: %v\n", target, err)
+					continue
+				}
+				slices = append(slices, ready...)
+			}
+		} else {
+			if PlanReady == nil {
+				fmt.Fprintln(stderr, "parallel select: --from-plan is unavailable in this build")
+				return ExitBlocked
+			}
+			ready, err := PlanReady(root, slug)
+			if err != nil {
+				fmt.Fprintf(stderr, "parallel select: %v\n", err)
+				return ExitBlocked
+			}
+			slices = ready
 		}
-		slices = ready
 	} else {
 		data, err := readJSONInput(jsonPath, stdin)
 		if err != nil {
@@ -161,26 +233,6 @@ func cmdSelect(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	return ExitOK
 }
 
-// runningLease returns slug's lease when it is still in flight
-// (running|integrate-failed), or nil when there is none to seed from.
-func runningLease(root, slug string) (*Lease, error) {
-	path, err := LeasePath(root, slug)
-	if err != nil {
-		return nil, err
-	}
-	lease, err := ReadLease(path)
-	if os.IsNotExist(err) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	if lease.Status != StatusRunning && lease.Status != StatusIntegrateFailed {
-		return nil, nil
-	}
-	return lease, nil
-}
-
 func runParallel(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 	if len(args) == 0 {
 		fmt.Fprintln(stderr, parallelUsage())
@@ -200,6 +252,8 @@ func runParallel(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return cmdIntegrate(rest, stdout, stderr)
 	case "cleanup":
 		return cmdCleanup(rest, stdout, stderr)
+	case "prune":
+		return cmdPrune(rest, stdout, stderr)
 	case "status":
 		return cmdStatus(rest, stdout, stderr)
 	case "lease-write":
@@ -220,35 +274,37 @@ func runParallel(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 }
 
 const (
-	usageCreate       = "usage: parallel create --root --slug --batch --base --json"
-	usageAdd          = "usage: parallel add --root --slug --json <json-file>|-"
+	usageCreate       = "usage: parallel create --root --slug --batch --base --json [--cap <1-10>]"
+	usageAdd          = "usage: parallel add --root --slug --json <json-file>|- [--cap <1-10>]"
 	usageRecordGreen  = "usage: parallel record-green --root --slug --slice --commit"
 	usageAbort        = "usage: parallel abort --root --slug"
 	usageIntegrate    = "usage: parallel integrate --root --slug [--apply-to-control [--slice <id>]]"
 	usageCleanup      = "usage: parallel cleanup --root --slug [--force]"
+	usagePrune        = "usage: parallel prune --root --slug"
 	usageStatus       = "usage: parallel status --root --slug"
 	usageLeaseWrite   = "usage: parallel lease-write --root --slug --json"
 	usageLeaseRead    = "usage: parallel lease-read --root --slug [--field name]"
 	usageLeaseClear   = "usage: parallel lease-clear --root --slug"
 	usagePathDisjoint = "usage: check path-disjoint [--root <dir>] [<json-file>|-]"
-	usageSelect       = "usage: parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [--from-plan | <json-file>|-]"
+	usageSelect       = "usage: parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [--from-plan [--workspaces <slugs>] | <json-file>|-]"
 )
 
 func parallelUsage() string {
 	return strings.TrimSpace(`usage: parallel <subcommand> [options]
 
 Subcommands:
-  create          --root --slug --batch --base --json
-  add             --root --slug --json
+  create          --root --slug --batch --base --json [--cap <1-10>]
+  add             --root --slug --json [--cap <1-10>]
   record-green    --root --slug --slice --commit
   abort           --root --slug
   integrate       --root --slug [--apply-to-control [--slice <id>]]
   cleanup         --root --slug [--force]
+  prune           --root --slug
   status          --root --slug
   lease-write     --root --slug --json
   lease-read      --root --slug [--field name]
   lease-clear     --root --slug
-  select          --cap <1-10> [--root] [--slug] [--from-plan | <json-file>|-]
+  select          --cap <1-10> [--root] [--slug] [--from-plan [--workspaces <slugs>] | <json-file>|-]
 
 Exit codes: 0 ok, 2 usage, 3 blocked`)
 }
@@ -269,6 +325,8 @@ func CommandUsage(name string) string {
 		return usageIntegrate
 	case "cleanup":
 		return usageCleanup
+	case "prune":
+		return usagePrune
 	case "status":
 		return usageStatus
 	case "lease-write":
@@ -288,7 +346,8 @@ func CommandUsage(name string) string {
 
 type flagSet struct {
 	Root, Slug, Batch, Base, Slice, Commit, JSON, Field, Session string
-	ApplyToControl, Force, Help                                  bool
+	ApplyToControl, Force, Help, HasCapacity                     bool
+	Capacity                                                     int
 }
 
 func parseFlags(args []string, stderr io.Writer) (flagSet, []string, int) {
@@ -359,6 +418,17 @@ func parseFlags(args []string, stderr io.Writer) (flagSet, []string, int) {
 				return f, nil, ExitUsage
 			}
 			f.Session = v
+		case "--cap":
+			v, ok := need(a)
+			if !ok {
+				return f, nil, ExitUsage
+			}
+			n, err := strconv.Atoi(v)
+			if err != nil || n < 1 || n > MaxParallelSlices || f.HasCapacity {
+				fmt.Fprintf(stderr, "parallel: --cap must be one integer from 1-%d\n", MaxParallelSlices)
+				return f, nil, ExitUsage
+			}
+			f.Capacity, f.HasCapacity = n, true
 		case "--apply-to-control":
 			f.ApplyToControl = true
 		case "--force":
@@ -386,6 +456,10 @@ func parseFlagsOrHelp(args []string, stdout, stderr io.Writer, usage string) (fl
 		fmt.Fprintln(stdout, usage)
 		return f, ExitOK, true
 	}
+	if f.HasCapacity && usage != usageCreate && usage != usageAdd {
+		fmt.Fprintln(stderr, "parallel: --cap is only supported by create and add")
+		return f, ExitUsage, true
+	}
 	return f, ExitOK, false
 }
 
@@ -450,12 +524,13 @@ func cmdCreate(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		return ExitBlocked
 	}
 	lease, err := Create(CreateOpts{
-		Root:    f.Root,
-		Slug:    f.Slug,
-		BatchID: f.Batch,
-		BaseSHA: f.Base,
-		Session: f.Session,
-		Slices:  slices,
+		Root:     f.Root,
+		Slug:     f.Slug,
+		BatchID:  f.Batch,
+		BaseSHA:  f.Base,
+		Session:  f.Session,
+		Slices:   slices,
+		Capacity: f.Capacity,
 	})
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel create: %v\n", err)
@@ -490,11 +565,15 @@ func cmdAdd(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "parallel add: %v\n", err)
 		return ExitBlocked
 	}
-	lease, err := Add(AddOpts{Root: f.Root, Slug: f.Slug, Slices: slices})
+	lease, err := Add(AddOpts{Root: f.Root, Slug: f.Slug, Slices: slices, Capacity: f.Capacity})
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel add: %v\n", err)
 		return ExitBlocked
 	}
+	if len(slices) == 0 {
+		fmt.Fprintf(stdout, "capacity: %d; batch=%s active=%d\n", leaseCapacity(lease), lease.BatchID, len(activeSlices(lease)))
+		return ExitOK
+	}
 	fmt.Fprintf(stdout, "added: %d worktrees; batch=%s active=%d base=%s\n",
 		len(slices), lease.BatchID, len(activeSlices(lease)), lease.Slices[len(lease.Slices)-1].BaseSHA)
 	return ExitOK
@@ -620,6 +699,29 @@ func cmdCleanup(args []string, stdout, stderr io.Writer) int {
 	return ExitOK
 }
 
+func cmdPrune(args []string, stdout, stderr io.Writer) int {
+	f, code, done := parseFlagsOrHelp(args, stdout, stderr, usagePrune)
+	if done {
+		return code
+	}
+	if code := requireRootSlug(f, stderr); code != ExitOK {
+		return code
+	}
+	if code := rejectUnsupportedFlags(f, stderr, false, false); code != ExitOK {
+		return code
+	}
+	removed, err := Prune(f.Root, f.Slug)
+	for _, path := range removed {
+		fmt.Fprintf(stdout, "pruned: %s\n", path)
+	}
+	if err != nil {
+		fmt.Fprintf(stderr, "parallel prune: %v\n", err)
+		return ExitBlocked
+	}
+	fmt.Fprintln(stdout, "prune: done; branches and lease retained")
+	return ExitOK
+}
+
 func cmdStatus(args []string, stdout, stderr io.Writer) int {
 	f, code, done := parseFlagsOrHelp(args, stdout, stderr, usageStatus)
 	if done {
@@ -673,7 +775,40 @@ func cmdLeaseWrite(args []string, stdin io.Reader, stdout, stderr io.Writer) int
 		fmt.Fprintf(stderr, "parallel lease-write: %v\n", err)
 		return ExitUsage
 	}
-	err = withLeaseLock(f.Root, f.Slug, func() error { return WriteLease(path, &lease) })
+	err = withLeaseLock(f.Root, f.Slug, func() error {
+		found, err := controllerLease(f.Root, f.Slug)
+		if err != nil {
+			return err
+		}
+		var current *Lease
+		if found != nil {
+			current = found.lease
+			if lease.BatchID != current.BatchID || lease.BaseSHA != current.BaseSHA || expectedControl(&lease) != expectedControl(current) {
+				return fmt.Errorf("lease-write cannot replace retained batch or control tip; cleanup the current controller explicitly")
+			}
+			if lease.Capacity == 0 {
+				lease.Capacity = current.Capacity
+			}
+		}
+		if err := normalizeLease(&lease, f.Slug); err != nil {
+			return err
+		}
+		if err := protectRawLease(current, &lease); err != nil {
+			return err
+		}
+		if current != nil {
+			if err := ensureControllerIdentity(f.Root, current); err != nil {
+				return err
+			}
+			if current.PendingLanding != nil {
+				return nil
+			}
+		}
+		if err := validateLeaseSources(filepath.Join(f.Root, ".devrites"), &lease); err != nil {
+			return err
+		}
+		return WriteLease(path, &lease)
+	})
 	if err != nil {
 		fmt.Fprintf(stderr, "parallel lease-write: %v\n", err)
 		return ExitBlocked
@@ -703,6 +838,10 @@ func cmdLeaseRead(args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintf(stderr, "parallel lease-read: %v\n", err)
 		return ExitBlocked
 	}
+	if err := normalizeLease(lease, f.Slug); err != nil {
+		fmt.Fprintf(stderr, "parallel lease-read: %v\n", err)
+		return ExitBlocked
+	}
 	switch f.Field {
 	case "", "yaml", "md":
 		text, err := EmitLeaseMarkdown(lease)
@@ -726,6 +865,8 @@ func cmdLeaseRead(args []string, stdout, stderr io.Writer) int {
 		fmt.Fprintln(stdout, lease.BatchID)
 	case "n":
 		fmt.Fprintln(stdout, lease.N)
+	case "capacity":
+		fmt.Fprintln(stdout, leaseCapacity(lease))
 	default:
 		fmt.Fprintf(stderr, "parallel lease-read: unknown field %q\n", f.Field)
 		return ExitUsage

package/engine/internal/parallel/git.go

@@ -192,12 +192,30 @@ func deleteBranch(repo, branch string) error {
 	if err != nil || !exists {
 		return err
 	}
-	_, err = git(repo, "branch", "-D", branch)
+	tip, err := revParse(repo, "refs/heads/"+branch)
+	if err != nil {
+		return err
+	}
+	return deleteBranchAt(repo, branch, tip)
+}
+
+// Bind deletion to the observed tip without bypassing checked-out branch safety.
+func deleteBranchAt(repo, branch, tip string) error {
+	worktrees, err := git(repo, "worktree", "list", "--porcelain", "-z")
+	if err != nil {
+		return err
+	}
+	for _, field := range strings.Split(worktrees, "\x00") {
+		if field == "branch refs/heads/"+branch {
+			return fmt.Errorf("branch %s remains checked out in a registered worktree", branch)
+		}
+	}
+	_, err = git(repo, "update-ref", "-d", "refs/heads/"+branch, tip)
 	return err
 }
 
 func worktreeAdd(repo, path, branch, startPoint string) error {
-	_, err := git(repo, "worktree", "add", "-b", branch, path, startPoint)
+	_, err := git(repo, "worktree", "add", "-b", branch, resolvedPath(path), startPoint)
 	return err
 }
 
@@ -208,27 +226,27 @@ func AddDetachedWorktree(repo, path, rev string) error {
 	return err
 }
 
-// RemoveWorktree force-removes a worktree, falling back to delete plus prune.
-func RemoveWorktree(repo, path string) error { return worktreeRemove(repo, path) }
+// RemoveWorktree force-removes a caller-owned throwaway worktree. A Git
+// refusal never grants permission to recursively delete its remaining data.
+func RemoveWorktree(repo, path string) error {
+	_, err := git(repo, "worktree", "remove", "--force", resolvedPath(path))
+	return err
+}
 
 func worktreeRemove(repo, path string) error {
-	_, err := git(repo, "worktree", "remove", "--force", path)
-	if err != nil {
-		_ = os.RemoveAll(path)
-		_, _ = git(repo, "worktree", "prune")
-	}
+	_, err := git(repo, "worktree", "remove", resolvedPath(path))
 	return err
 }
 
 // registeredWorktrees returns the symlink-resolved paths git lists as
 // worktrees of repo: the only authoritative record of what worktree add made.
 func registeredWorktrees(repo string) (map[string]bool, error) {
-	out, err := git(repo, "worktree", "list", "--porcelain")
+	out, err := git(repo, "worktree", "list", "--porcelain", "-z")
 	if err != nil {
 		return nil, err
 	}
 	set := map[string]bool{}
-	for _, line := range strings.Split(out, "\n") {
+	for _, line := range strings.Split(out, "\x00") {
 		if p, ok := strings.CutPrefix(line, "worktree "); ok {
 			set[resolvedPath(p)] = true
 		}
@@ -240,10 +258,25 @@ func registeredWorktrees(repo string) (map[string]bool, error) {
 func RegisteredWorktrees(repo string) (map[string]bool, error) { return registeredWorktrees(repo) }
 
 func resolvedPath(p string) string {
-	if r, err := filepath.EvalSymlinks(p); err == nil {
-		return r
+	if abs, err := filepath.Abs(p); err == nil {
+		p = abs
+	}
+	original := filepath.Clean(p)
+	prefix, suffix := original, ""
+	for {
+		if resolved, err := filepath.EvalSymlinks(prefix); err == nil {
+			return filepath.Join(resolved, suffix)
+		} else if !os.IsNotExist(err) {
+			return original
+		}
+		parent := filepath.Dir(prefix)
+		if parent == prefix {
+			return original
+		}
+		// Missing leaves must retain their existing ancestors' canonical identity.
+		suffix = filepath.Join(filepath.Base(prefix), suffix)
+		prefix = parent
 	}
-	return filepath.Clean(p)
 }
 
 // createdWorktree reports whether p is a registered worktree. A path that is