Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

refactor(gitwork): split baseline resolution out of RecordBaseline (#448)

fx-kurumi2da46d8d6ab8
diff --git a/internal/gitwork/baseline_resolve_test.go b/internal/gitwork/baseline_resolve_test.go
new file mode 100644
index 00000000..86c15c03
--- /dev/null
+++ b/internal/gitwork/baseline_resolve_test.go
@@ -0,0 +1,62 @@
+package gitwork
+
+import (
+ "strings"
+ "testing"
+)
+
+func TestResolveCommitSHARejectsMultiLineRef(t *testing.T) {
+ _, checkout := workBranchFixture(t)
+ for _, ref := range []string{"main\n", "main\rHEAD"} {
+ if _, err := resolveCommitSHA(checkout, ref); err == nil || !strings.Contains(err.Error(), "invalid ref") {
+ t.Fatalf("%q: err = %v, want invalid ref", ref, err)
+ }
+ }
+}
+
+func TestResolveCommitSHAResolvesCommit(t *testing.T) {
+ _, checkout := workBranchFixture(t)
+ got, err := resolveCommitSHA(checkout, "HEAD")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if want := workBranchGit(t, checkout, "rev-parse", "HEAD"); got != want {
+ t.Fatalf("sha = %q, want %q", got, want)
+ }
+}
+
+func TestResolveBaselineSHAFallbackOrder(t *testing.T) {
+ _, checkout := workBranchFixture(t)
+ originMain := workBranchGit(t, checkout, "rev-parse", "origin/main")
+ for _, base := range []string{"", " ", "missing-branch"} {
+ got, err := resolveBaselineSHA(checkout, base)
+ if err != nil {
+ t.Fatalf("%q: %v", base, err)
+ }
+ if got != originMain {
+ t.Fatalf("%q: sha = %q, want origin/main %q", base, got, originMain)
+ }
+ }
+}
+
+func TestResolveBaselineSHAFallsBackToHEAD(t *testing.T) {
+ workspace := t.TempDir()
+ workBranchGit(t, workspace, "init", "-q", "-b", "trunk")
+ workBranchGit(t, workspace, "-c", "user.name=t", "-c", "[email protected]", "commit", "-q", "--allow-empty", "-m", "init")
+ got, err := resolveBaselineSHA(workspace, "trunk")
+ if err != nil {
+ t.Fatal(err)
+ }
+ if want := workBranchGit(t, workspace, "rev-parse", "HEAD"); got != want {
+ t.Fatalf("sha = %q, want HEAD %q", got, want)
+ }
+}
+
+func TestResolveBaselineSHAReportsLastCandidateError(t *testing.T) {
+ workspace := t.TempDir()
+ workBranchGit(t, workspace, "init", "-q", "-b", "master")
+ _, err := resolveBaselineSHA(workspace, "master")
+ if err == nil || !strings.Contains(err.Error(), "HEAD") {
+ t.Fatalf("err = %v, want HEAD diagnostic", err)
+ }
+}
diff --git a/internal/gitwork/patch.go b/internal/gitwork/patch.go
index c79e1c36..69a051f3 100644
--- a/internal/gitwork/patch.go
+++ b/internal/gitwork/patch.go
@@ -46,37 +46,7 @@ func RecordBaseline(workspace, baseBranch string) error {
} else if !os.IsNotExist(err) {
return err
}
- var sha []byte
- // The ref travels on stdin so a branch name never reaches git's argument list.
- resolve := func(ref string) ([]byte, error) {
- if strings.ContainsAny(ref, "\r\n") {
- return nil, fmt.Errorf("invalid ref %q", ref)
- }
- cmd := exec.Command("git", "cat-file", "--batch-check=%(objectname)")
- cmd.Dir = workspace
- cmd.Stdin = strings.NewReader(ref + "^{commit}\n")
- out, err := cmd.CombinedOutput()
- if err != nil {
- return nil, fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))
- }
- sha := strings.TrimSpace(string(out))
- if !isObjectID(sha) {
- return nil, fmt.Errorf("resolve %s: %s", ref, sha)
- }
- return []byte(sha), nil
- }
- if ref := strings.TrimSpace(baseBranch); ref != "" {
- sha, err = resolve("origin/" + ref)
- }
- if err != nil || len(bytes.TrimSpace(sha)) == 0 {
- sha, err = resolve("origin/master")
- }
- if err != nil {
- sha, err = resolve("origin/main")
- }
- if err != nil {
- sha, err = resolve("HEAD")
- }
+ sha, err := resolveBaselineSHA(workspace, baseBranch)
if err != nil {
return fmt.Errorf("resolve repository baseline: %w", err)
}
@@ -89,7 +59,7 @@ func RecordBaseline(workspace, baseBranch string) error {
if err != nil {
return fmt.Errorf("record repository baseline: %w", err)
}
- _, err = file.WriteString(strings.TrimSpace(string(sha)))
+ _, err = file.WriteString(sha)
closeErr := file.Close()
if err != nil {
return fmt.Errorf("record repository baseline: %w", err)
@@ -100,6 +70,45 @@ func RecordBaseline(workspace, baseBranch string) error {
return nil
}
+// resolveBaselineSHA picks the first resolvable baseline candidate:
+// origin/<baseBranch> (when set), origin/master, origin/main, then HEAD.
+// When none resolves, the error of the last candidate is returned.
+func resolveBaselineSHA(workspace, baseBranch string) (string, error) {
+ var refs []string
+ if ref := strings.TrimSpace(baseBranch); ref != "" {
+ refs = append(refs, "origin/"+ref)
+ }
+ refs = append(refs, "origin/master", "origin/main", "HEAD")
+ var err error
+ for _, ref := range refs {
+ var sha string
+ if sha, err = resolveCommitSHA(workspace, ref); err == nil {
+ return sha, nil
+ }
+ }
+ return "", err
+}
+
+// resolveCommitSHA resolves ref to a commit object ID. The ref travels on
+// stdin so a branch name never reaches git's argument list.
+func resolveCommitSHA(workspace, ref string) (string, error) {
+ if strings.ContainsAny(ref, "\r\n") {
+ return "", fmt.Errorf("invalid ref %q", ref)
+ }
+ cmd := exec.Command("git", "cat-file", "--batch-check=%(objectname)")
+ cmd.Dir = workspace
+ cmd.Stdin = strings.NewReader(ref + "^{commit}\n")
+ out, err := cmd.CombinedOutput()
+ if err != nil {
+ return "", fmt.Errorf("%w: %s", err, strings.TrimSpace(string(out)))
+ }
+ sha := strings.TrimSpace(string(out))
+ if !isObjectID(sha) {
+ return "", fmt.Errorf("resolve %s: %s", ref, sha)
+ }
+ return sha, nil
+}
+
// PatchInventory lists workspace changes against the nearest current
// baseline (usually origin/integrate or origin/<base>). A run shares one git
// workspace across nodes, so the next node reads the files there; the