feat: add --rebase flag to send command

Author: omarkohl

cmd/send.go

@@ -33,6 +33,7 @@ func init() {
 	sendCmd.Flags().BoolP("draft", "d", false, "Create PRs as drafts")
 	sendCmd.Flags().BoolP("existing", "x", false, "Only update PRs that already exist (skip new ones)")
 	sendCmd.Flags().Bool("no-stack", false, "Send only the tip of each stack as a single PR")
+	sendCmd.Flags().Bool("rebase", false, "Rebase the stack onto the base branch before sending")
 }
 
 // sendOpts holds configuration for the send pipeline.
@@ -46,6 +47,7 @@ type sendOpts struct {
 	draft          bool
 	existing       bool
 	noStack        bool
+	rebase         bool
 	reviewers      []string
 	revsets        []string
 }
@@ -83,6 +85,7 @@ func runSend(cmd *cobra.Command, args []string) error {
 	draft, _ := cmd.Flags().GetBool("draft")
 	existing, _ := cmd.Flags().GetBool("existing")
 	noStack, _ := cmd.Flags().GetBool("no-stack")
+	rebase, _ := cmd.Flags().GetBool("rebase")
 	w := cmd.OutOrStdout()
 
 	revsets := args
@@ -159,6 +162,7 @@ func runSend(cmd *cobra.Command, args []string) error {
 		draft:          draft,
 		existing:       existing,
 		noStack:        noStack,
+		rebase:         rebase,
 		reviewers:      reviewers,
 		revsets:        revsets,
 	}, w)
@@ -179,6 +183,14 @@ func executeSend(runner jj.Runner, client gh.Service, opts sendOpts, w io.Writer
 		}
 	}
 
+	// Rebase onto base branch if requested.
+	if opts.rebase {
+		_, _ = fmt.Fprintf(w, "Rebasing onto %s...\n", opts.base)
+		if err := runner.Rebase(opts.revsets, opts.base); err != nil {
+			return fmt.Errorf("rebasing onto %s: %w", opts.base, err)
+		}
+	}
+
 	repoFullName := client.Owner() + "/" + client.Repo()
 
 	// 2. Resolve stacks.

cmd/send_integration_test.go

@@ -802,6 +802,80 @@ func TestIntegration_SendNoStack(t *testing.T) {
 	}
 }
 
+func TestIntegration_SendRebase(t *testing.T) {
+	checkJJ(t)
+
+	mock := newMockService()
+	repoDir, _ := initTestRepoWithRemote(t)
+	spy := &spyRunner{Runner: jj.NewRunner(repoDir)}
+
+	// Create a change on top of main.
+	writeAndCommit(t, repoDir, "a.go", "package a", "feat: rebase test")
+
+	var buf bytes.Buffer
+	err := executeSend(spy, mock, sendOpts{
+		base:    "main",
+		remote:  "origin",
+		revsets: []string{"@-"},
+		rebase:  true,
+	}, &buf)
+	if err != nil {
+		t.Fatalf("send --rebase failed: %v\nOutput:\n%s", err, buf.String())
+	}
+
+	output := buf.String()
+	t.Logf("Output:\n%s", output)
+
+	// Verify rebase was called with the correct arguments.
+	if len(spy.rebaseCalls) != 1 {
+		t.Fatalf("expected 1 rebase call, got %d", len(spy.rebaseCalls))
+	}
+	rc := spy.rebaseCalls[0]
+	if len(rc.revsets) != 1 || rc.revsets[0] != "@-" {
+		t.Errorf("expected rebase revsets [@-], got %v", rc.revsets)
+	}
+	if rc.destination != "main" {
+		t.Errorf("expected rebase destination 'main', got %q", rc.destination)
+	}
+
+	// Output should mention rebasing.
+	if !strings.Contains(output, "Rebasing onto main") {
+		t.Errorf("expected 'Rebasing onto main' in output, got:\n%s", output)
+	}
+
+	// PR should still be created successfully.
+	mock.mu.Lock()
+	defer mock.mu.Unlock()
+	if len(mock.prs) != 1 {
+		t.Errorf("expected 1 PR, got %d", len(mock.prs))
+	}
+}
+
+func TestIntegration_SendNoRebaseByDefault(t *testing.T) {
+	checkJJ(t)
+
+	mock := newMockService()
+	repoDir, _ := initTestRepoWithRemote(t)
+	spy := &spyRunner{Runner: jj.NewRunner(repoDir)}
+
+	writeAndCommit(t, repoDir, "a.go", "package a", "feat: no rebase test")
+
+	var buf bytes.Buffer
+	err := executeSend(spy, mock, sendOpts{
+		base:    "main",
+		remote:  "origin",
+		revsets: []string{"@-"},
+	}, &buf)
+	if err != nil {
+		t.Fatalf("send failed: %v\nOutput:\n%s", err, buf.String())
+	}
+
+	// Rebase should NOT have been called.
+	if len(spy.rebaseCalls) != 0 {
+		t.Errorf("expected 0 rebase calls without --rebase, got %d", len(spy.rebaseCalls))
+	}
+}
+
 func TestIntegration_SendSkipsBehindBookmark(t *testing.T) {
 	checkJJ(t)
 
@@ -985,11 +1059,17 @@ func writeFile(t *testing.T, dir, filename, content string) {
 	}
 }
 
-// spyRunner wraps a real Runner and records remotes passed to GitFetch/GitPush.
+// spyRunner wraps a real Runner and records remotes passed to GitFetch/GitPush/Rebase.
 type spyRunner struct {
 	jj.Runner
 	fetchRemotes []string
 	pushRemote   string
+	rebaseCalls  []rebaseCall
+}
+
+type rebaseCall struct {
+	revsets     []string
+	destination string
 }
 
 func (s *spyRunner) GitFetch(remote string) error {
@@ -1002,6 +1082,11 @@ func (s *spyRunner) GitPush(bookmarks []string, allowNew bool, remote string) er
 	return s.Runner.GitPush(bookmarks, allowNew, remote)
 }
 
+func (s *spyRunner) Rebase(revsets []string, destination string) error {
+	s.rebaseCalls = append(s.rebaseCalls, rebaseCall{revsets: revsets, destination: destination})
+	return s.Runner.Rebase(revsets, destination)
+}
+
 // --- Test helpers ---
 
 func checkJJ(t *testing.T) {

docs/reference.md

@@ -20,6 +20,7 @@
 | `--draft` | `-d` | | Create PRs as drafts |
 | `--existing` | `-x` | | Only update PRs that already exist (skip new ones) |
 | `--no-stack` | | | Send only the tip of each stack as a single PR |
+| `--rebase` | | | Rebase the stack onto the base branch before sending |
 
 ## Revsets
 
@@ -44,6 +45,18 @@ branches to your fork.
 jip send --upstream upstream
 ```
 
+## Rebasing before send (`--rebase`)
+
+Use `--rebase` to rebase the stack onto the base branch before pushing. This
+ensures PRs don't contain stale diffs when the base branch has moved forward.
+
+```bash
+jip send --rebase
+```
+
+This is equivalent to running `jj rebase` manually before `jip send`, but
+saves a step.
+
 ## Single PR for a stack (`--no-stack`)
 
 By default, jip creates one PR per commit. Use `--no-stack` to bundle an

docs/workflows.md

@@ -125,6 +125,9 @@ jj rebase -o main
 
 # Update all PRs (jip posts comments showing what changed)
 jip s prm vu
+
+# Or combine rebase + send in one step
+jip s --rebase prm vu
 ```
 
 The reformat PR is already merged, so jip skips it. The bugfix PR now targets
@@ -140,6 +143,9 @@ jj git fetch
 jj rebase -o main
 # Update all existing (-x/--existing) PRs for changes that are descendants of main
 jip s -x main::
+
+# Or combine rebase + send in one step
+jip s -x --rebase main::
 ```
 
 Now only the feature PR remains, targeting `main` directly. The stack

internal/jj/runner.go

@@ -55,6 +55,9 @@ type Runner interface {
 
 	// Interdiff returns the diff between two revisions using jj interdiff --git.
 	Interdiff(from, to string) (string, error)
+
+	// Rebase rebases the given revsets onto the destination revision.
+	Rebase(revsets []string, destination string) error
 }
 
 // NewRunner creates a Runner that executes jj in the given repository directory.
@@ -166,6 +169,19 @@ func (r *realRunner) Interdiff(from, to string) (string, error) {
 	return string(out), nil
 }
 
+func (r *realRunner) Rebase(revsets []string, destination string) error {
+	args := []string{"rebase", "-R", r.repoDir, "-d", destination}
+	for _, rev := range revsets {
+		args = append(args, "-b", rev)
+	}
+	cmd := exec.Command("jj", args...)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return fmt.Errorf("jj rebase: %w\n%s", err, strings.TrimSpace(string(out)))
+	}
+	return nil
+}
+
 // ParseRemoteList parses the output of jj git remote list into a map
 // of remote name → URL.
 func ParseRemoteList(data []byte) map[string]string {