politely enable rerere and cache decline

Author: skarim

cmd/init.go

@@ -58,7 +58,7 @@ func runInit(cfg *config.Config, opts *initOptions) error {
 	trunk := opts.base
 
 	// Enable git rerere so conflict resolutions are remembered.
-	_ = git.EnableRerere()
+	ensureRerere(cfg)
 
 	if trunk == "" {
 		trunk, err = git.DefaultBranch()

cmd/init_test.go

@@ -140,15 +140,16 @@ func TestInit_PrefixStoredInStack(t *testing.T) {
 	}
 }
 
-func TestInit_EnablesRerere(t *testing.T) {
+func TestInit_RerereAlreadyEnabled(t *testing.T) {
 	gitDir := t.TempDir()
-	rerereCalled := false
+	enableRerereCalled := false
 	restore := git.SetOps(&git.MockOps{
 		GitDirFn:        func() (string, error) { return gitDir, nil },
 		DefaultBranchFn: func() (string, error) { return "main", nil },
 		CurrentBranchFn: func() (string, error) { return "main", nil },
+		IsRerereEnabledFn: func() (bool, error) { return true, nil },
 		EnableRerereFn: func() error {
-			rerereCalled = true
+			enableRerereCalled = true
 			return nil
 		},
 	})
@@ -158,8 +159,8 @@ func TestInit_EnablesRerere(t *testing.T) {
 	runInit(cfg, &initOptions{branches: []string{"b1"}})
 	collectOutput(cfg, outR, errR)
 
-	if !rerereCalled {
-		t.Error("expected EnableRerere to be called")
+	if enableRerereCalled {
+		t.Error("EnableRerere should not be called when rerere is already enabled")
 	}
 }
 

cmd/rebase.go

@@ -88,7 +88,7 @@ func runRebase(cfg *config.Config, opts *rebaseOptions) error {
 	currentBranch := result.CurrentBranch
 
 	// Enable git rerere so conflict resolutions are remembered.
-	_ = git.EnableRerere()
+	ensureRerere(cfg)
 
 	// Resolve remote for fetch and trunk comparison
 	remote, err := pickRemote(cfg, currentBranch)

cmd/sync.go

@@ -58,7 +58,7 @@ func runSync(cfg *config.Config, _ *syncOptions) error {
 
 	// --- Step 1: Fetch ---
 	// Enable git rerere so conflict resolutions are remembered.
-	_ = git.EnableRerere()
+	ensureRerere(cfg)
 
 	if err := git.Fetch(remote); err != nil {
 		cfg.Warningf("Failed to fetch %s: %v", remote, err)

cmd/utils.go

@@ -212,3 +212,35 @@ func activeBranchNames(s *stack.Stack) []string {
 	}
 	return names
 }
+
+// ensureRerere checks whether git rerere is enabled and, if not, prompts the
+// user for permission before enabling it.  If the user previously declined,
+// the prompt is suppressed.  In non-interactive sessions the function is a
+// no-op so commands can still run in CI/scripting.
+func ensureRerere(cfg *config.Config) {
+	enabled, err := git.IsRerereEnabled()
+	if err != nil || enabled {
+		return
+	}
+
+	declined, _ := git.IsRerereDeclined()
+	if declined {
+		return
+	}
+
+	if !cfg.IsInteractive() {
+		return
+	}
+
+	p := prompter.New(cfg.In, cfg.Out, cfg.Err)
+	ok, err := p.Confirm("Enable git rerere to remember conflict resolutions?", true)
+	if err != nil {
+		return
+	}
+
+	if ok {
+		_ = git.EnableRerere()
+	} else {
+		_ = git.SaveRerereDeclined()
+	}
+}

cmd/utils_test.go

@@ -0,0 +1,79 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/github/gh-stack/internal/config"
+	"github.com/github/gh-stack/internal/git"
+)
+
+func TestEnsureRerere_SkipsWhenAlreadyEnabled(t *testing.T) {
+	enableCalled := false
+	restore := git.SetOps(&git.MockOps{
+		IsRerereEnabledFn: func() (bool, error) { return true, nil },
+		EnableRerereFn: func() error {
+			enableCalled = true
+			return nil
+		},
+	})
+	defer restore()
+
+	cfg, outR, errR := config.NewTestConfig()
+	ensureRerere(cfg)
+	collectOutput(cfg, outR, errR)
+
+	if enableCalled {
+		t.Error("EnableRerere should not be called when already enabled")
+	}
+}
+
+func TestEnsureRerere_SkipsWhenDeclined(t *testing.T) {
+	enableCalled := false
+	restore := git.SetOps(&git.MockOps{
+		IsRerereEnabledFn:  func() (bool, error) { return false, nil },
+		IsRerereDeclinedFn: func() (bool, error) { return true, nil },
+		EnableRerereFn: func() error {
+			enableCalled = true
+			return nil
+		},
+	})
+	defer restore()
+
+	cfg, outR, errR := config.NewTestConfig()
+	ensureRerere(cfg)
+	collectOutput(cfg, outR, errR)
+
+	if enableCalled {
+		t.Error("EnableRerere should not be called when user previously declined")
+	}
+}
+
+func TestEnsureRerere_SkipsWhenNonInteractive(t *testing.T) {
+	enableCalled := false
+	declinedSaved := false
+	restore := git.SetOps(&git.MockOps{
+		IsRerereEnabledFn:  func() (bool, error) { return false, nil },
+		IsRerereDeclinedFn: func() (bool, error) { return false, nil },
+		EnableRerereFn: func() error {
+			enableCalled = true
+			return nil
+		},
+		SaveRerereDeclinedFn: func() error {
+			declinedSaved = true
+			return nil
+		},
+	})
+	defer restore()
+
+	// NewTestConfig is non-interactive (pipes, not a TTY).
+	cfg, outR, errR := config.NewTestConfig()
+	ensureRerere(cfg)
+	collectOutput(cfg, outR, errR)
+
+	if enableCalled {
+		t.Error("EnableRerere should not be called in non-interactive mode")
+	}
+	if declinedSaved {
+		t.Error("SaveRerereDeclined should not be called in non-interactive mode")
+	}
+}

internal/git/git.go

@@ -149,6 +149,21 @@ func EnableRerere() error {
 	return ops.EnableRerere()
 }
 
+// IsRerereEnabled returns whether rerere.enabled is set to "true" in git config.
+func IsRerereEnabled() (bool, error) {
+	return ops.IsRerereEnabled()
+}
+
+// IsRerereDeclined returns whether the user previously declined the rerere prompt.
+func IsRerereDeclined() (bool, error) {
+	return ops.IsRerereDeclined()
+}
+
+// SaveRerereDeclined records that the user declined the rerere prompt.
+func SaveRerereDeclined() error {
+	return ops.SaveRerereDeclined()
+}
+
 // RebaseOnto rebases a branch using the three-argument form:
 //
 //	git rebase --onto <newBase> <oldBase> <branch>

internal/git/gitops.go

@@ -27,6 +27,9 @@ type Ops interface {
 	ResolveRemote(branch string) (string, error)
 	Rebase(base string) error
 	EnableRerere() error
+	IsRerereEnabled() (bool, error)
+	IsRerereDeclined() (bool, error)
+	SaveRerereDeclined() error
 	RebaseOnto(newBase, oldBase, branch string) error
 	RebaseContinue() error
 	RebaseAbort() error
@@ -172,6 +175,27 @@ func (d *defaultOps) EnableRerere() error {
 	return runSilent("config", "rerere.autoupdate", "true")
 }
 
+func (d *defaultOps) IsRerereEnabled() (bool, error) {
+	out, err := run("config", "--get", "rerere.enabled")
+	if err != nil {
+		// Missing key — not enabled.
+		return false, nil
+	}
+	return strings.EqualFold(strings.TrimSpace(out), "true"), nil
+}
+
+func (d *defaultOps) IsRerereDeclined() (bool, error) {
+	out, err := run("config", "--get", "gh-stack.rerere-declined")
+	if err != nil {
+		return false, nil
+	}
+	return strings.EqualFold(strings.TrimSpace(out), "true"), nil
+}
+
+func (d *defaultOps) SaveRerereDeclined() error {
+	return runSilent("config", "gh-stack.rerere-declined", "true")
+}
+
 func (d *defaultOps) RebaseOnto(newBase, oldBase, branch string) error {
 	err := runSilent("rebase", "--onto", newBase, oldBase, branch)
 	if err == nil {

internal/git/mock_ops.go

@@ -15,6 +15,9 @@ type MockOps struct {
 	ResolveRemoteFn       func(string) (string, error)
 	RebaseFn              func(string) error
 	EnableRerereFn        func() error
+	IsRerereEnabledFn     func() (bool, error)
+	IsRerereDeclinedFn    func() (bool, error)
+	SaveRerereDeclinedFn  func() error
 	RebaseOntoFn          func(string, string, string) error
 	RebaseContinueFn      func() error
 	RebaseAbortFn         func() error
@@ -121,6 +124,27 @@ func (m *MockOps) EnableRerere() error {
 	return nil
 }
 
+func (m *MockOps) IsRerereEnabled() (bool, error) {
+	if m.IsRerereEnabledFn != nil {
+		return m.IsRerereEnabledFn()
+	}
+	return false, nil
+}
+
+func (m *MockOps) IsRerereDeclined() (bool, error) {
+	if m.IsRerereDeclinedFn != nil {
+		return m.IsRerereDeclinedFn()
+	}
+	return false, nil
+}
+
+func (m *MockOps) SaveRerereDeclined() error {
+	if m.SaveRerereDeclinedFn != nil {
+		return m.SaveRerereDeclinedFn()
+	}
+	return nil
+}
+
 func (m *MockOps) RebaseOnto(newBase, oldBase, branch string) error {
 	if m.RebaseOntoFn != nil {
 		return m.RebaseOntoFn(newBase, oldBase, branch)