Merge pull request #6 from entireio/soph/branch-optimizations

Trunk-aware batched bootstrap planning

Author: Soph

internal/gitproto/fetch.go

@@ -88,12 +88,15 @@ func (s *RefService) FetchPack(
 }
 
 // FetchCommitGraph fetches only the commit graph (tree:0 filter) for a ref.
-// Requires v2 with filter support.
+// Requires v2 with filter support. Optional haves let the source skip commits
+// already reachable from those hashes, which is valuable when planning later
+// branches that share history with an already-planned trunk.
 func (s *RefService) FetchCommitGraph(
 	ctx context.Context,
 	store storer.Storer,
 	conn *Conn,
 	ref DesiredRef,
+	haves []plumbing.Hash,
 ) error {
 	if s.Protocol != "v2" {
 		return errors.New("commit graph fetch requires protocol v2")
@@ -102,13 +105,19 @@ func (s *RefService) FetchCommitGraph(
 		return errors.New("source does not advertise fetch filter support")
 	}
 
-	cmdArgs := []string{
+	sortedHaves := SortedUniqueHashes(haves)
+	cmdArgs := make([]string, 0, 4+len(sortedHaves))
+	cmdArgs = append(cmdArgs,
 		"ofs-delta",
 		"no-progress",
 		"filter tree:0",
-		"want " + ref.SourceHash.String(),
-		"done",
+		"want "+ref.SourceHash.String(),
+	)
+	for _, h := range sortedHaves {
+		cmdArgs = append(cmdArgs, "have "+h.String())
 	}
+	cmdArgs = append(cmdArgs, "done")
+
 	body, err := EncodeCommand("fetch", s.V2Caps.RequestCapabilities(), cmdArgs)
 	if err != nil {
 		return err

internal/gitproto/fetch_test.go

@@ -20,6 +20,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+const refsHeadsMain = "refs/heads/main"
+
 func TestCapabilities(t *testing.T) {
 	// v2 protocol
 	v2Caps := &V2Capabilities{
@@ -221,28 +223,52 @@ func TestDecodeV2LSRefs(t *testing.T) {
 		FormatPktLine("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb refs/heads/dev\n") +
 		"0000" // flush
 
-	refs, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
+	refs, head, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
 	if err != nil {
 		t.Fatalf("decodeV2LSRefs: %v", err)
 	}
 	if len(refs) != 2 {
 		t.Fatalf("expected 2 refs, got %d", len(refs))
 	}
-	if refs[0].Name().String() != "refs/heads/main" {
-		t.Errorf("refs[0].Name() = %q, want %q", refs[0].Name(), "refs/heads/main")
+	if refs[0].Name().String() != refsHeadsMain {
+		t.Errorf("refs[0].Name() = %q, want %q", refs[0].Name(), refsHeadsMain)
 	}
 	if refs[0].Hash().String() != "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" {
 		t.Errorf("refs[0].Hash() = %q", refs[0].Hash())
 	}
 	if refs[1].Name().String() != "refs/heads/dev" {
 		t.Errorf("refs[1].Name() = %q, want %q", refs[1].Name(), "refs/heads/dev")
 	}
+	if head != "" {
+		t.Errorf("head target = %q, want empty (no HEAD advertised)", head)
+	}
+}
+
+func TestDecodeV2LSRefsHeadSymref(t *testing.T) {
+	wire := "" +
+		FormatPktLine("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa HEAD symref-target:refs/heads/main\n") +
+		FormatPktLine("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa refs/heads/main\n") +
+		"0000"
+	refs, head, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
+	if err != nil {
+		t.Fatalf("decodeV2LSRefs: %v", err)
+	}
+	// HEAD is consumed for its symref target and not emitted as a ref.
+	if len(refs) != 1 {
+		t.Fatalf("expected 1 ref (HEAD filtered), got %d", len(refs))
+	}
+	if refs[0].Name().String() != refsHeadsMain {
+		t.Errorf("refs[0].Name() = %q, want refs/heads/main", refs[0].Name())
+	}
+	if head.String() != refsHeadsMain {
+		t.Errorf("head target = %q, want refs/heads/main", head)
+	}
 }
 
 func TestDecodeV2LSRefsMalformed(t *testing.T) {
 	// Line with only one field (no refname).
 	wire := FormatPktLine("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n") + "0000"
-	_, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
+	_, _, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
 	if err == nil {
 		t.Fatal("expected error for malformed ls-refs line, got nil")
 	}
@@ -251,7 +277,7 @@ func TestDecodeV2LSRefsMalformed(t *testing.T) {
 func TestDecodeV2LSRefsEmpty(t *testing.T) {
 	// Empty response (just flush).
 	wire := "0000"
-	refs, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
+	refs, _, err := decodeV2LSRefs(bytes.NewReader([]byte(wire)))
 	if err != nil {
 		t.Fatalf("decodeV2LSRefs: %v", err)
 	}
@@ -287,7 +313,7 @@ func TestFetchPackUnsupportedProtocol(t *testing.T) {
 
 func TestFetchCommitGraphRequiresV2(t *testing.T) {
 	rs := &RefService{Protocol: "v1"}
-	err := rs.FetchCommitGraph(t.Context(), nil, nil, DesiredRef{})
+	err := rs.FetchCommitGraph(t.Context(), nil, nil, DesiredRef{}, nil)
 	if err == nil {
 		t.Fatal("expected error for non-v2 protocol")
 	}
@@ -300,7 +326,7 @@ func TestFetchCommitGraphRequiresFilter(t *testing.T) {
 		},
 	}
 	rs := &RefService{Protocol: "v2", V2Caps: caps}
-	err := rs.FetchCommitGraph(t.Context(), nil, nil, DesiredRef{})
+	err := rs.FetchCommitGraph(t.Context(), nil, nil, DesiredRef{}, nil)
 	if err == nil {
 		t.Fatal("expected error when filter not supported")
 	}

internal/gitproto/refs.go

@@ -12,6 +12,7 @@ import (
 	"github.com/go-git/go-git/v6/plumbing"
 	"github.com/go-git/go-git/v6/plumbing/format/pktline"
 	"github.com/go-git/go-git/v6/plumbing/protocol/packp"
+	"github.com/go-git/go-git/v6/plumbing/protocol/packp/capability"
 	"github.com/go-git/go-git/v6/plumbing/transport"
 )
 
@@ -21,6 +22,10 @@ type RefService struct {
 	Protocol string // "v1" or "v2"
 	V1Adv    *packp.AdvRefs
 	V2Caps   *V2Capabilities
+	// HeadTarget is the branch that HEAD points to on the source, when
+	// advertised as a symref. Empty for detached HEAD or when the source
+	// does not advertise symref information.
+	HeadTarget plumbing.ReferenceName
 	// Verbose, when true, streams source-side sideband progress ("Counting
 	// objects", "Compressing objects", ...) to stderr and asks the source
 	// upload-pack to emit progress by not sending the no-progress option.
@@ -36,7 +41,7 @@ func ListSourceRefs(ctx context.Context, conn *Conn, protocolMode string, refPre
 		if err != nil {
 			return nil, nil, err
 		}
-		return refs, &RefService{Protocol: "v1", V1Adv: adv}, nil
+		return refs, &RefService{Protocol: "v1", V1Adv: adv, HeadTarget: headTargetFromAdv(adv)}, nil
 
 	case "auto", "v2":
 		data, err := RequestInfoRefs(ctx, conn, transport.UploadPackService, "version=2")
@@ -47,11 +52,11 @@ func ListSourceRefs(ctx context.Context, conn *Conn, protocolMode string, refPre
 			if !caps.Supports("ls-refs") || !caps.Supports("fetch") {
 				return nil, nil, errors.New("source does not advertise required protocol v2 commands")
 			}
-			refs, err := listSourceRefsV2(ctx, conn, caps, refPrefixes)
+			refs, headTarget, err := listSourceRefsV2(ctx, conn, caps, refPrefixes)
 			if err != nil {
 				return nil, nil, err
 			}
-			return refs, &RefService{Protocol: "v2", V2Caps: caps}, nil
+			return refs, &RefService{Protocol: "v2", V2Caps: caps, HeadTarget: headTarget}, nil
 		}
 		if protocolMode == "v2" {
 			return nil, nil, errors.New("source did not negotiate protocol v2")
@@ -65,7 +70,7 @@ func ListSourceRefs(ctx context.Context, conn *Conn, protocolMode string, refPre
 		if err != nil {
 			return nil, nil, err
 		}
-		return refs, &RefService{Protocol: "v1", V1Adv: adv}, nil
+		return refs, &RefService{Protocol: "v1", V1Adv: adv, HeadTarget: headTargetFromAdv(adv)}, nil
 
 	default:
 		return nil, nil, fmt.Errorf("unsupported protocol mode %q", protocolMode)
@@ -136,46 +141,81 @@ func listSourceRefsV1(ctx context.Context, conn *Conn) (*packp.AdvRefs, []*plumb
 	return adv, refs, nil
 }
 
-func listSourceRefsV2(ctx context.Context, conn *Conn, caps *V2Capabilities, prefixes []string) ([]*plumbing.Reference, error) {
-	args := []string{"peel"}
+func listSourceRefsV2(ctx context.Context, conn *Conn, caps *V2Capabilities, prefixes []string) ([]*plumbing.Reference, plumbing.ReferenceName, error) {
+	// Always include "HEAD" so the server returns the symref-target attribute
+	// for HEAD. Without this, callers that pass only "refs/heads/" or
+	// "refs/tags/" prefixes filter HEAD out of the response and lose the
+	// default-branch hint that bootstrap planning uses as a trunk cutoff.
+	args := []string{"peel", "symrefs", "ref-prefix HEAD"}
 	for _, prefix := range prefixes {
 		args = append(args, "ref-prefix "+prefix)
 	}
 	body, err := EncodeCommand("ls-refs", caps.RequestCapabilities(), args)
 	if err != nil {
-		return nil, err
+		return nil, "", err
 	}
 	data, err := PostRPC(ctx, conn, transport.UploadPackService, body, true, "upload-pack ls-refs")
 	if err != nil {
-		return nil, err
+		return nil, "", err
 	}
 	return decodeV2LSRefs(bytes.NewReader(data))
 }
 
-func decodeV2LSRefs(r *bytes.Reader) ([]*plumbing.Reference, error) {
+func decodeV2LSRefs(r *bytes.Reader) ([]*plumbing.Reference, plumbing.ReferenceName, error) {
 	reader := NewPacketReader(r)
 	var refs []*plumbing.Reference
+	var headTarget plumbing.ReferenceName
 	for {
 		kind, payload, err := reader.ReadPacket()
 		if err != nil {
-			return nil, err
+			return nil, "", err
 		}
 		if kind == PacketFlush {
-			return refs, nil
+			return refs, headTarget, nil
 		}
 		if kind != PacketData {
-			return nil, fmt.Errorf("unexpected packet type %v in ls-refs response", kind)
+			return nil, "", fmt.Errorf("unexpected packet type %v in ls-refs response", kind)
 		}
 		fields := strings.Fields(strings.TrimSpace(string(payload)))
 		if len(fields) < 2 {
-			return nil, fmt.Errorf("malformed ls-refs response line %q", payload)
+			return nil, "", fmt.Errorf("malformed ls-refs response line %q", payload)
 		}
 		hash := plumbing.NewHash(fields[0])
 		name := plumbing.ReferenceName(fields[1])
+		if name == plumbing.HEAD {
+			// HEAD is surfaced via headTarget only; not appended to the ref
+			// slice because it is a symbolic ref, matching v1 behavior where
+			// symrefs are filtered out by downstream RefHashMap.
+			for _, attr := range fields[2:] {
+				if target, ok := strings.CutPrefix(attr, "symref-target:"); ok {
+					headTarget = plumbing.ReferenceName(target)
+					break
+				}
+			}
+			continue
+		}
 		refs = append(refs, plumbing.NewHashReference(name, hash))
 	}
 }
 
+// headTargetFromAdv extracts the branch HEAD points to from v1 advertised
+// capabilities. Returns empty when HEAD is detached or no symref is advertised.
+func headTargetFromAdv(adv *packp.AdvRefs) plumbing.ReferenceName {
+	if adv == nil || adv.Capabilities == nil {
+		return ""
+	}
+	for _, value := range adv.Capabilities.Get(capability.SymRef) {
+		parts := strings.SplitN(value, ":", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		if plumbing.ReferenceName(parts[0]) == plumbing.HEAD {
+			return plumbing.ReferenceName(parts[1])
+		}
+	}
+	return ""
+}
+
 func decodeV1AdvRefs(data []byte) (*packp.AdvRefs, error) {
 	rd := bufio.NewReader(bytes.NewReader(data))
 	consumedSmartHeader, err := consumeSmartInfoRefsHeader(rd)

internal/gitproto/refs_test.go

@@ -43,6 +43,30 @@ func TestRefHashMap(t *testing.T) {
 	}
 }
 
+func TestHeadTargetFromAdv(t *testing.T) {
+	// nil returns empty.
+	if got := headTargetFromAdv(nil); got != "" {
+		t.Errorf("headTargetFromAdv(nil) = %q, want empty", got)
+	}
+
+	adv := packp.NewAdvRefs()
+	if err := adv.Capabilities.Add(capability.SymRef, "HEAD:refs/heads/main"); err != nil {
+		t.Fatalf("Capabilities.Add: %v", err)
+	}
+	if got := headTargetFromAdv(adv); got.String() != "refs/heads/main" {
+		t.Errorf("headTargetFromAdv = %q, want refs/heads/main", got)
+	}
+
+	// Symref pointing at something other than HEAD is ignored.
+	adv = packp.NewAdvRefs()
+	if err := adv.Capabilities.Add(capability.SymRef, "refs/remotes/origin/HEAD:refs/heads/main"); err != nil {
+		t.Fatalf("Capabilities.Add: %v", err)
+	}
+	if got := headTargetFromAdv(adv); got != "" {
+		t.Errorf("headTargetFromAdv ignored non-HEAD symref = %q, want empty", got)
+	}
+}
+
 func TestAdvRefsCaps(t *testing.T) {
 	// nil AdvRefs should return nil.
 	if got := AdvRefsCaps(nil); got != nil {

internal/planner/checkpoint.go

@@ -20,6 +20,21 @@ type BootstrapBatch struct {
 // FirstParentChain walks the first-parent chain from tip back to root,
 // returning the chain in root-to-tip order.
 func FirstParentChain(store storer.EncodedObjectStorer, tip plumbing.Hash) ([]plumbing.Hash, error) {
+	return FirstParentChainStoppingAt(store, tip, nil)
+}
+
+// FirstParentChainStoppingAt walks the first-parent chain from tip back to
+// root, stopping early when a commit's hash is in stopAt. Returns the chain
+// in root-to-tip order, excluding any stopAt commits. When tip itself is in
+// stopAt, the returned chain is empty. A nil stopAt behaves like the plain
+// FirstParentChain walk.
+//
+// This supports trunk-aware planning: once trunk's ancestry is known, other
+// branches only need their divergence chain.
+func FirstParentChainStoppingAt(store storer.EncodedObjectStorer, tip plumbing.Hash, stopAt map[plumbing.Hash]struct{}) ([]plumbing.Hash, error) {
+	if _, stop := stopAt[tip]; stop {
+		return nil, nil
+	}
 	commit, err := object.GetCommit(store, tip)
 	if err != nil {
 		return nil, fmt.Errorf("load tip commit %s: %w", tip, err)
@@ -30,7 +45,11 @@ func FirstParentChain(store storer.EncodedObjectStorer, tip plumbing.Hash) ([]pl
 		if len(commit.ParentHashes) == 0 {
 			break
 		}
-		commit, err = object.GetCommit(store, commit.ParentHashes[0])
+		parent := commit.ParentHashes[0]
+		if _, stop := stopAt[parent]; stop {
+			break
+		}
+		commit, err = object.GetCommit(store, parent)
 		if err != nil {
 			return nil, fmt.Errorf("load parent commit %s: %w", commit.ParentHashes[0], err)
 		}