enable git rerere

Author: skarim

cmd/init.go

@@ -53,6 +53,10 @@ func runInit(cfg *config.Config, opts *initOptions) error {
 
 	// Determine trunk branch
 	trunk := opts.base
+
+	// Enable git rerere so conflict resolutions are remembered.
+	_ = git.EnableRerere()
+
 	if trunk == "" {
 		trunk, err = git.DefaultBranch()
 		if err != nil {

cmd/rebase.go

@@ -111,6 +111,10 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 	}
 
 	cfg.Printf("Fetching origin ...")
+
+	// Enable git rerere so conflict resolutions are remembered.
+	_ = git.EnableRerere()
+
 	if err := git.Fetch("origin"); err != nil {
 		cfg.Warningf("Failed to fetch origin: %v", err)
 	} else {
@@ -227,11 +231,22 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 		} else {
 			cfg.Printf("Rebasing %s onto %s ...", br.Branch, base)
 
-			if err := git.CheckoutBranch(br.Branch); err != nil {
-				return fmt.Errorf("checking out %s: %w", br.Branch, err)
+			var rebaseErr error
+			if absIdx > 0 {
+				// Use --onto to replay only this branch's unique commits.
+				// Without --onto, git may try to replay commits shared with
+				// the parent, causing duplicate-patch conflicts when the
+				// parent's rebase rewrote those commits.
+				rebaseErr = git.RebaseOnto(base, originalRefs[base], br.Branch)
+			} else {
+				if err := git.CheckoutBranch(br.Branch); err != nil {
+					return fmt.Errorf("checking out %s: %w", br.Branch, err)
+				}
+				// Use regular rebase for the first branch.
+				rebaseErr = git.Rebase(base)
 			}
 
-			if err := git.Rebase(base); err != nil {
+			if rebaseErr != nil {
 				cfg.Warningf("Rebasing %s onto %s ... conflict", br.Branch, base)
 
 				remaining := make([]string, 0)
@@ -410,12 +425,19 @@ func continueRebase(cfg *config.Config, gitDir string) error {
 		} else {
 			cfg.Printf("Rebasing %s onto %s ...", branchName, base)
 
-			if err := git.CheckoutBranch(branchName); err != nil {
-				cfg.Errorf("checking out %s: %s", branchName, err)
-				return nil
+			var rebaseErr error
+			if idx > 0 {
+				// Use --onto to replay only this branch's unique commits.
+				rebaseErr = git.RebaseOnto(base, state.OriginalRefs[base], branchName)
+			} else {
+				if err := git.CheckoutBranch(branchName); err != nil {
+					cfg.Errorf("checking out %s: %s", branchName, err)
+					return nil
+				}
+				rebaseErr = git.Rebase(base)
 			}
 
-			if err := git.Rebase(base); err != nil {
+			if rebaseErr != nil {
 				remainIdx := -1
 				for ri, rb := range state.RemainingBranches {
 					if rb == branchName {

cmd/sync.go

@@ -74,6 +74,10 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 
 	// --- Step 1: Fetch ---
 	cfg.Printf("Fetching origin ...")
+
+	// Enable git rerere so conflict resolutions are remembered.
+	_ = git.EnableRerere()
+
 	if err := git.Fetch("origin"); err != nil {
 		cfg.Warningf("Failed to fetch origin: %v", err)
 	} else {
@@ -188,13 +192,20 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 				cfg.Successf("Rebased %s onto %s (squash-merge detected)", br.Branch, newBase)
 				ontoOldBase = originalRefs[br.Branch]
 			} else {
-				if err := git.CheckoutBranch(br.Branch); err != nil {
-					cfg.Errorf("Failed to checkout %s: %v", br.Branch, err)
-					conflicted = true
-					break
+				var rebaseErr error
+				if i > 0 {
+					// Use --onto to replay only this branch's unique commits.
+					rebaseErr = git.RebaseOnto(base, originalRefs[base], br.Branch)
+				} else {
+					if err := git.CheckoutBranch(br.Branch); err != nil {
+						cfg.Errorf("Failed to checkout %s: %v", br.Branch, err)
+						conflicted = true
+						break
+					}
+					rebaseErr = git.Rebase(base)
 				}
 
-				if err := git.Rebase(base); err != nil {
+				if rebaseErr != nil {
 					// Conflict detected — abort and restore everything
 					if git.IsRebaseInProgress() {
 						_ = git.RebaseAbort()

internal/git/git.go

@@ -106,8 +106,23 @@ func Push(remote string, branches []string, force, atomic bool) error {
 }
 
 // Rebase rebases the current branch onto the given base.
+// If rerere resolves all conflicts automatically, the rebase continues
+// without user intervention.
 func Rebase(base string) error {
-	return runSilent("rebase", base)
+	err := runSilent("rebase", base)
+	if err == nil {
+		return nil
+	}
+	return tryAutoResolveRebase(err)
+}
+
+// EnableRerere enables git rerere (reuse recorded resolution) and
+// rerere.autoupdate (auto-stage resolved files) for the repository.
+func EnableRerere() error {
+	if err := runSilent("config", "rerere.enabled", "true"); err != nil {
+		return err
+	}
+	return runSilent("config", "rerere.autoupdate", "true")
 }
 
 // RebaseOnto rebases a branch using the three-argument form:
@@ -117,19 +132,59 @@ func Rebase(base string) error {
 // This replays commits after oldBase from branch onto newBase. It is used
 // when a prior branch was squash-merged and the normal rebase cannot detect
 // which commits have already been applied.
+// If rerere resolves all conflicts automatically, the rebase continues
+// without user intervention.
 func RebaseOnto(newBase, oldBase, branch string) error {
-	return runSilent("rebase", "--onto", newBase, oldBase, branch)
+	err := runSilent("rebase", "--onto", newBase, oldBase, branch)
+	if err == nil {
+		return nil
+	}
+	return tryAutoResolveRebase(err)
 }
 
 // RebaseContinue continues an in-progress rebase.
 // It sets GIT_EDITOR=true to prevent git from opening an interactive editor
 // for the commit message, which would cause the command to hang.
+// If rerere resolves subsequent conflicts automatically, the rebase continues
+// without user intervention.
 func RebaseContinue() error {
+	err := rebaseContinueOnce()
+	if err == nil {
+		return nil
+	}
+	return tryAutoResolveRebase(err)
+}
+
+// rebaseContinueOnce runs a single git rebase --continue without auto-resolve.
+func rebaseContinueOnce() error {
 	cmd := exec.Command("git", "rebase", "--continue")
 	cmd.Env = append(os.Environ(), "GIT_EDITOR=true")
 	return cmd.Run()
 }
 
+// tryAutoResolveRebase checks whether rerere has resolved all conflicts
+// from a failed rebase. If so, it auto-continues the rebase (potentially
+// multiple times for multi-commit rebases). Returns originalErr if any
+// conflicts remain that need manual resolution.
+func tryAutoResolveRebase(originalErr error) error {
+	for i := 0; i < 1000; i++ {
+		if !IsRebaseInProgress() {
+			return nil
+		}
+		conflicts, _ := ConflictedFiles()
+		if len(conflicts) > 0 {
+			return originalErr
+		}
+		// Rerere resolved all conflicts — auto-continue.
+		if rebaseContinueOnce() == nil {
+			return nil
+		}
+		// Continue hit another conflicting commit; loop to check
+		// if rerere resolved that one too.
+	}
+	return originalErr
+}
+
 // RebaseAbort aborts an in-progress rebase.
 func RebaseAbort() error {
 	return runSilent("rebase", "--abort")