# Add relay-only replicate engine mode

`f377186`→[main](/content/gh/entireio/git-sync/commits/main/index.html)· Soph·3mo ago·7 files·+692 added/-20 removed

## Sessions

be84133ec5bbView transcript

## Changes

7

- internal

- planner

- Mplanner.go+99

- Mplanner_test.go+64

- Mrelay.go+38

- strategy/replicate

- Areplicate.go+106

- Areplicate_test.go+118

- syncer

- Mintegration_test.go+99/-7

- Msyncer.go+168/-13

```go
160 unmodified lines
```

```go

// BuildReplicationPlans generates overwrite-oriented plans for replication mode.
// Divergent refs are updated directly rather than blocked.
func BuildReplicationPlans(
	desired map[plumbing.ReferenceName]DesiredRef,
	targetRefs map[plumbing.ReferenceName]plumbing.Hash,
	managed map[plumbing.ReferenceName]ManagedTarget,
	cfg PlanConfig,
) ([]BranchPlan, error) {
	managed = copyManagedTargets(managed)
	if cfg.Prune {
		for targetRef := range targetRefs {
			if _, ok := managed[targetRef]; ok {
				continue
			}
			switch {
			case targetRef.IsTag() && cfg.IncludeTags:
				managed[targetRef] = ManagedTarget{Kind: RefKindTag, Label: targetRef.Short()}
			case targetRef.IsBranch() && len(cfg.Mappings) == 0 && len(cfg.Branches) == 0:
				managed[targetRef] = ManagedTarget{Kind: RefKindBranch, Label: targetRef.Short()}
			}
		}
	}

targetNames := make([]plumbing.ReferenceName, 0, len(managed))
	for name := range managed {
		targetNames = append(targetNames, name)
	}
	sort.Slice(targetNames, func(i, j int) bool { return targetNames[i] < targetNames[j] })

plans := make([]BranchPlan, 0, len(targetNames))
	for _, targetRef := range targetNames {
		info := managed[targetRef]
		want, existsInDesired := desired[targetRef]
		targetHash, existsOnTarget := targetRefs[targetRef]

if !existsInDesired {
			if cfg.Prune && existsOnTarget {
				plans = append(plans, BranchPlan{
					Branch:     info.Label,
					TargetRef:  targetRef,
					TargetHash: targetHash,
					Kind:       info.Kind,
					Action:     ActionDelete,
					Reason:     fmt.Sprintf("%s -> <deleted>", ShortHash(targetHash)),
				})
			}
			continue
		}

plans = append(plans, PlanReplicationRef(want, targetHash, existsOnTarget))
	}

sort.Slice(plans, func(i, j int) bool {
		return plans[i].TargetRef.String() < plans[j].TargetRef.String()
	})
	return plans, nil
}
```