Wire the single-screen submit TUI into gh stack submit

Launch the submit editor from `gh stack submit` in interactive terminals,
collecting per-branch PR drafts and applying them in a single batch. In
non-interactive terminals or with --auto, fall back to auto-generated
titles and skip the editor. Update the README and CLI reference to
describe the single-screen flow.

Author: skarim

README.md

@@ -372,11 +372,13 @@ Creates a Stacked PR for every branch in the stack, pushing branches to the remo
 
 After creating PRs, `submit` automatically creates a **Stack** on GitHub to link the PRs together. If the stack already exists on GitHub (e.g., from a previous submit), new PRs will be added to the top of the stack.
 
-When creating new PRs, you will be prompted to enter a title for each one. Press Enter to accept the default (branch name), or use `--auto` to skip prompting entirely.
+In an interactive terminal, `submit` opens a full-screen, mouse- and keyboard-driven editor on a single screen. Every branch without a PR is included by default — deselect any you don't want on the left panel (<kbd>Ctrl</kbd>+<kbd>X</kbd>). Because each PR builds on the branch below it, deselecting a branch also deselects the ones stacked above it, and re-including a branch re-includes the ones below it. Draft each PR's title, description (with a markdown preview and `$EDITOR` escape), and choose ready-for-review or draft on the right, then submit them all at once with <kbd>Ctrl</kbd>+<kbd>S</kbd>. Pass `--auto` (or run in CI) to skip the editor and use auto-generated titles.
+
+In the editor, new PRs default to ready for review; flip any PR to draft with the ready ↔ draft toggle. With `--auto`, new PRs are created as drafts unless you pass `--open`.
 
 | Flag | Description |
 |------|-------------|
-| `--auto` | Use auto-generated PR titles without prompting |
+| `--auto` | Skip the editor and use auto-generated PR titles |
 | `--open` | Mark new and existing PRs as ready for review |
 | `--remote <name>` | Remote to push to (defaults to auto-detected remote) |
 

cmd/submit.go

@@ -6,6 +6,7 @@ import (
 	"strconv"
 	"strings"
 
+	tea "github.com/charmbracelet/bubbletea"
 	"github.com/cli/go-gh/v2/pkg/api"
 	"github.com/cli/go-gh/v2/pkg/prompter"
 	"github.com/github/gh-stack/internal/config"
@@ -14,6 +15,7 @@ import (
 	"github.com/github/gh-stack/internal/modify"
 	"github.com/github/gh-stack/internal/pr"
 	"github.com/github/gh-stack/internal/stack"
+	"github.com/github/gh-stack/internal/tui/stackview"
 	"github.com/github/gh-stack/internal/tui/submitview"
 	"github.com/spf13/cobra"
 )
@@ -32,21 +34,27 @@ func SubmitCmd(cfg *config.Config) *cobra.Command {
 		Short: "Create a stack of PRs on GitHub",
 		Long: `Push all branches and create or update a stack of PRs on GitHub.
 
+In an interactive terminal, a single-screen editor opens. Every branch without a
+PR is included by default; deselect any you don't want with the checkbox or ^x,
+and draft each PR's title, description, and draft state, then submit them all at
+once with Ctrl+S. Pass --auto (or run in a non-interactive terminal) to skip the
+editor and use auto-generated titles.
+
 This command performs several steps:
   1. Pushes all branches to the remote
-  2. Creates new PRs for branches that don't have one
+  2. Creates new PRs for the included branches
   3. Updates base branches for existing PRs
   4. Creates or updates the stack on GitHub
 
-New PRs are created as drafts by default. Use --open to mark them as ready
-for review.`,
-		Example: `  # Push and create/update PRs (prompts for PR titles)
+In the editor, new PRs default to ready for review; toggle "Open as draft" per
+PR. With --auto, new PRs are created as drafts unless you pass --open.`,
+		Example: `  # Push and create/update PRs (opens the interactive editor)
   $ gh stack submit
 
-  # Use auto-generated PR titles without prompting
+  # Skip the editor and use auto-generated PR titles
   $ gh stack submit --auto
 
-  # Mark all PRs as ready for review
+  # Mark new and existing PRs as ready for review
   $ gh stack submit --open`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			return runSubmit(cfg, opts)
@@ -132,7 +140,7 @@ func runSubmit(cfg *config.Config, opts *submitOptions) error {
 	}
 
 	// Sync PR state to detect merged/queued PRs before pushing.
-	_ = syncStackPRs(cfg, s)
+	prDetails := syncStackPRs(cfg, s)
 
 	// Resolve remote for pushing
 	remote, err := pickRemote(cfg, currentBranch, opts.remote)
@@ -179,15 +187,28 @@ func runSubmit(cfg *config.Config, opts *submitOptions) error {
 		templateContent = pr.FindTemplate(repoRoot)
 	}
 
+	// In an interactive terminal, open the TUI so the user can pick which new
+	// branches become PRs and draft each PR's title, description, and draft
+	// state. The drafts feed the create path below. On the --auto /
+	// non-interactive path drafts stays nil and ensurePR/createPR fall back to
+	// auto-generated titles and bodies (today's behavior).
+	var drafts map[string]*submitview.PRDraft
+	if cfg.IsInteractive() && !opts.auto {
+		collected, cancelled, tuiErr := collectPRDrafts(cfg, s, currentBranch, prDetails, templateContent)
+		if tuiErr != nil {
+			cfg.Errorf("failed to run the submit editor: %s", tuiErr)
+			return ErrSilent
+		}
+		if cancelled {
+			cfg.Printf("Submit cancelled — no branches were pushed")
+			return nil
+		}
+		drafts = collected
+	}
+
 	// Push each branch and create/update its PR in stack order (bottom to top).
 	// Sequential pushing ensures each branch's base is up-to-date on the
 	// remote before the next branch is pushed, preventing race conditions.
-	//
-	// drafts carries per-PR overrides from the interactive editor. It is nil on
-	// the --auto / non-interactive path, in which case ensurePR/createPR fall
-	// back to auto-generated titles and bodies (today's behavior).
-	var drafts map[string]*submitview.PRDraft
-
 	cfg.Printf("Pushing to %s...", remote)
 	for i, b := range s.Branches {
 		if s.Branches[i].IsMerged() || s.Branches[i].IsQueued() {
@@ -229,6 +250,73 @@ func runSubmit(cfg *config.Config, opts *submitOptions) error {
 	return nil
 }
 
+// collectPRDrafts loads branch display data and runs the interactive submit TUI
+// so the user can choose which new branches become PRs and draft each one. It
+// returns the per-branch overrides, whether the user cancelled, and any error.
+// When the stack contains no branches without a PR, it skips the TUI and
+// returns nil drafts so the normal push/relink path runs.
+func collectPRDrafts(cfg *config.Config, s *stack.Stack, currentBranch string, prDetails map[string]*github.PRDetails, templateContent string) (map[string]*submitview.PRDraft, bool, error) {
+	fmt.Fprintf(cfg.Err, "Loading stack...")
+	viewNodes := stackview.LoadBranchNodes(cfg, s, currentBranch, prDetails)
+	fmt.Fprintf(cfg.Err, "\r\033[2K")
+
+	// Reverse so index 0 = top of stack (matches the visual order).
+	reversed := make([]stackview.BranchNode, len(viewNodes))
+	for i, n := range viewNodes {
+		reversed[len(viewNodes)-1-i] = n
+	}
+	nodes := submitview.NewSubmitNodes(reversed, templateContent)
+
+	// Nothing to create — skip the TUI and run the normal push/relink path.
+	if submitview.CountNew(nodes) == 0 {
+		return nil, false, nil
+	}
+
+	repoLabel := ""
+	if repo, err := cfg.Repo(); err == nil {
+		repoLabel = repo.Owner + "/" + repo.Name
+	}
+
+	model := submitview.New(submitview.Options{
+		Nodes:     nodes,
+		Trunk:     s.Trunk,
+		StackName: stackDisplayName(s),
+		RepoLabel: repoLabel,
+		Version:   Version,
+	})
+
+	p := tea.NewProgram(model, tea.WithAltScreen(), tea.WithMouseAllMotion())
+	final, err := p.Run()
+	if err != nil {
+		return nil, false, fmt.Errorf("running submit TUI: %w", err)
+	}
+
+	m, ok := final.(submitview.Model)
+	if !ok {
+		return nil, false, fmt.Errorf("unexpected model type %T", final)
+	}
+	if m.Cancelled() || !m.SubmitRequested() {
+		return nil, true, nil
+	}
+	return submitview.BuildDrafts(m.Nodes()), false, nil
+}
+
+// stackDisplayName returns a human-readable name for the stack, used in the TUI
+// header: the stack prefix, else the common branch-name prefix, else the
+// bottom-most branch.
+func stackDisplayName(s *stack.Stack) string {
+	if s.Prefix != "" {
+		return strings.TrimRight(s.Prefix, "/")
+	}
+	if p := submitview.CommonPrefix(s.BranchNames()); p != "" {
+		return strings.TrimRight(p, "/")
+	}
+	if len(s.Branches) > 0 {
+		return s.Branches[0].Branch
+	}
+	return s.Trunk.Branch
+}
+
 // ensurePR finds or creates a PR for the branch at index i, and updates
 // its base branch if needed. This is the single place where PR state is
 // reconciled during submit.
@@ -330,27 +418,12 @@ func createPR(cfg *config.Config, client github.ClientOps, s *stack.Stack, i int
 		body = generatePRBody(d.Body, "")
 		isDraft = d.Draft
 	} else {
-		// Auto / non-interactive default path.
+		// Auto / non-interactive default path: an auto-generated title and a
+		// body built from the branch's commits (the interactive title is
+		// drafted in the submit TUI instead).
 		var commitBody string
 		title, commitBody = defaultPRTitleBody(baseBranch, b.Branch)
-		originalTitle := title
-		if !opts.auto && cfg.IsInteractive() {
-			input, err := inputWithPrefill(cfg, fmt.Sprintf("Title for PR (branch %s):", b.Branch), title)
-			if err != nil {
-				if isInterruptError(err) {
-					return errInterrupt
-				}
-				// Non-interrupt error: keep the auto-generated title.
-			} else if input != "" {
-				title = input
-			}
-		}
-
-		prBody := commitBody
-		if title != originalTitle && commitBody != "" {
-			prBody = originalTitle + "\n\n" + commitBody
-		}
-		body = generatePRBody(prBody, templateContent)
+		body = generatePRBody(commitBody, templateContent)
 	}
 
 	newPR, createErr := client.CreatePR(baseBranch, b.Branch, title, body, isDraft)

cmd/submit_tui_test.go

@@ -0,0 +1,83 @@
+package cmd
+
+import (
+	"testing"
+
+	"github.com/github/gh-stack/internal/config"
+	"github.com/github/gh-stack/internal/git"
+	"github.com/github/gh-stack/internal/github"
+	"github.com/github/gh-stack/internal/stack"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStackDisplayName(t *testing.T) {
+	tests := []struct {
+		name string
+		s    *stack.Stack
+		want string
+	}{
+		{
+			name: "uses stack prefix",
+			s:    &stack.Stack{Prefix: "feat/", Trunk: stack.BranchRef{Branch: "main"}},
+			want: "feat",
+		},
+		{
+			name: "falls back to common branch prefix",
+			s: &stack.Stack{
+				Trunk:    stack.BranchRef{Branch: "main"},
+				Branches: []stack.BranchRef{{Branch: "feat/auth/a"}, {Branch: "feat/auth/b"}},
+			},
+			want: "feat/auth",
+		},
+		{
+			name: "single branch falls back to its name",
+			s: &stack.Stack{
+				Trunk:    stack.BranchRef{Branch: "main"},
+				Branches: []stack.BranchRef{{Branch: "solo"}},
+			},
+			want: "solo",
+		},
+		{
+			name: "no branches falls back to trunk",
+			s:    &stack.Stack{Trunk: stack.BranchRef{Branch: "main"}},
+			want: "main",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.want, stackDisplayName(tt.s))
+		})
+	}
+}
+
+// TestCollectPRDrafts_SkipsWhenNoNewBranches verifies the TUI is skipped (no
+// program launched) when every branch already has a PR, returning nil drafts so
+// the normal push/relink path runs.
+func TestCollectPRDrafts_SkipsWhenNoNewBranches(t *testing.T) {
+	s := &stack.Stack{
+		Trunk:    stack.BranchRef{Branch: "main"},
+		Branches: []stack.BranchRef{{Branch: "b1"}, {Branch: "b2"}},
+	}
+
+	mock := &git.MockOps{
+		RootDirFn:       func() (string, error) { return t.TempDir(), nil },
+		IsAncestorFn:    func(a, b string) (bool, error) { return true, nil },
+		MergeBaseFn:     func(a, b string) (string, error) { return a, nil },
+		LogRangeFn:      func(base, head string) ([]git.CommitInfo, error) { return []git.CommitInfo{{Subject: "c"}}, nil },
+		DiffStatFilesFn: func(base, head string) ([]git.FileDiffStat, error) { return nil, nil },
+	}
+	restore := git.SetOps(mock)
+	defer restore()
+
+	cfg, _, _ := config.NewTestConfig()
+	prDetails := map[string]*github.PRDetails{
+		"b1": {Number: 1, State: "OPEN"},
+		"b2": {Number: 2, State: "OPEN"},
+	}
+
+	drafts, cancelled, err := collectPRDrafts(cfg, s, "b1", prDetails, "")
+	require.NoError(t, err)
+	assert.False(t, cancelled)
+	assert.Nil(t, drafts, "no NEW branches means the TUI is skipped and drafts are nil")
+}

docs/src/content/docs/reference/cli.md

@@ -269,11 +269,18 @@ gh stack submit [flags]
 
 Creates a Stacked PR for every branch in the stack, pushing branches to the remote. After creating PRs, `submit` automatically creates a **Stack** on GitHub to link the PRs together. If the stack already exists on GitHub (e.g., from a previous submit), new PRs are added to the existing stack.
 
-When creating new PRs, you will be prompted to enter a title for each one. Press Enter to accept the default (branch name), or use `--auto` to skip prompting entirely. New PRs are created as **drafts by default**; use `--open` to create new PRs as ready for review and to mark existing PRs as ready for review.
+In an interactive terminal, `submit` opens a full-screen editor on a single screen:
+
+- **Left panel** — every branch without a PR is **included by default**; deselect any you don't want to submit with <kbd>Ctrl</kbd>+<kbd>X</kbd>. Because each PR builds on the branch below it, deselecting a branch also deselects the ones stacked above it, and re-including a branch re-includes the ones below it that it depends on. Branches that already have a PR (open, draft, queued, or merged) are shown for context but are locked; edit those on the web.
+- **Right panel** — for the focused branch, draft the title, description (pre-filled from your repo's PR template or commits, with a Glamour markdown preview and `$EDITOR` escape), and whether it opens ready for review or as a draft (a ready ↔ draft toggle). Focusing a locked branch shows a read-only card with a link to its PR (<kbd>o</kbd> to open in the browser).
+
+Press <kbd>Ctrl</kbd>+<kbd>S</kbd> to submit all included PRs at once. The editor supports both keyboard and mouse input. Pass `--auto` (or run in a non-interactive terminal, such as CI) to skip the editor and use auto-generated titles.
+
+In the editor, new PRs default to **ready for review**; flip any PR to **draft** with the ready ↔ draft toggle. With `--auto`, new PRs are created as **drafts** unless you pass `--open`.
 
 | Flag | Description |
 |------|-------------|
-| `--auto` | Use auto-generated PR titles without prompting |
+| `--auto` | Skip the editor and use auto-generated PR titles |
 | `--open` | Create new PRs as ready for review instead of drafts, and mark existing PRs as ready for review |
 | `--remote <name>` | Remote to push to (defaults to auto-detected remote) |