From 8d3ae858c2ef8e2ab5f9d516a0340f545c8fb0e9 Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Fri, 22 May 2026 14:27:15 -0400 Subject: [PATCH 1/7] add insert branch operation to modify TUI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add `i` (insert below) and `I` (insert above) key bindings to the interactive modify view, allowing users to insert new empty branches into an existing stack. This follows Vim-inspired semantics where lowercase `i` inserts below the cursor and uppercase `I` inserts above. ## TUI behavior When the user presses `i` or `I`, the TUI enters an insert input mode (similar to rename mode) where they type a new branch name. The input is validated against git ref naming rules, local branch uniqueness, and in-stack name collisions. On confirm, a placeholder node is inserted at the correct position in the branch list with a green "✚ insert" annotation badge and green connector styling. Insert is a structure operation — it works alongside fold, rename, and drop, but is mutually exclusive with reorder (consistent with existing mode exclusivity rules). Undo (`z`) removes the inserted node cleanly. ## Apply engine At apply time (Step 2 in the pipeline, between renames and folds), the engine creates the new git branch at the parent branch's tip via `git.CreateBranch` and inserts a `BranchRef` into the stack metadata at the correct position. If the insertion changes the base of a branch that has an open PR, `affectsPRs` is set to trigger a required `gh stack submit` afterward. ## Header shortcut updates - Combined the fold shortcuts into a single line: `d/u - fold down/up` - Added insert shortcuts on their own line: `i/I - insert below/above` - Reordered fold references throughout to list "down" before "up" for consistency with the insert shortcut ordering ## Files changed - types.go: ActionInsertBelow/ActionInsertAbove types, IsInserted field, InsertedBranches in ApplyResult - model.go: key bindings, insert input mode, undo, mode exclusivity, annotation, styling, header shortcuts, effective-index tracking to prevent false reorder detection when inserts shift node positions - styles.go: green insert badge/branch/connector styles - status.go: insert counting in pending change summary - help.go: new "Insert below / above" section, reordered fold heading - apply.go: BuildPlan and ApplyPlan handle insert actions - modify.go: updated command description and success summary - README.md: updated keybindings table ## Test coverage - 16 new TUI tests: insert below/above, top/bottom edges, undo, mode exclusivity, merged branch guard, cancel/empty input, duplicate name validation, pending summary counting, annotation rendering, mixed operations with drop/fold, apply acceptance - 4 new apply tests: BuildPlan produces correct insert actions, ApplyPlan creates branches and updates stack metadata, insert at stack start uses trunk as parent, affectsPRs triggered when inserting before a branch with an open PR --- cmd/modify.go | 5 + internal/modify/apply.go | 136 ++++++++- internal/modify/apply_test.go | 230 +++++++++++++++ internal/tui/modifyview/help.go | 10 +- internal/tui/modifyview/model.go | 219 ++++++++++++++- internal/tui/modifyview/model_test.go | 384 ++++++++++++++++++++++++++ internal/tui/modifyview/status.go | 21 +- internal/tui/modifyview/styles.go | 17 +- internal/tui/modifyview/types.go | 26 +- internal/tui/shared/header.go | 4 +- 10 files changed, 1005 insertions(+), 47 deletions(-) diff --git a/cmd/modify.go b/cmd/modify.go index 3842e38..8da6e0a 100644 --- a/cmd/modify.go +++ b/cmd/modify.go @@ -29,6 +29,7 @@ func ModifyCmd(cfg *config.Config) *cobra.Command { Operations available: • Drop branches from the stack • Fold branches into adjacent branches + • Insert new branches into the stack • Reorder branches • Rename branches @@ -168,6 +169,10 @@ func printModifySuccess(cfg *config.Config, result *modifyview.ApplyResult) { cfg.Printf(" Renamed: %s → %s", r.OldName, r.NewName) } + for _, name := range result.InsertedBranches { + cfg.Printf(" Inserted: %s", name) + } + for _, d := range result.DroppedPRs { cfg.Printf(" Dropped: %s (PR #%d remains open — close with `%s`)", d.Branch, d.PRNumber, cfg.ColorCyan(fmt.Sprintf("gh pr close %d", d.PRNumber))) diff --git a/internal/modify/apply.go b/internal/modify/apply.go index a95e292..e239198 100644 --- a/internal/modify/apply.go +++ b/internal/modify/apply.go @@ -52,9 +52,18 @@ func BuildSnapshot(s *stack.Stack) (Snapshot, error) { func BuildPlan(nodes []modifyview.ModifyBranchNode) []Action { var plan []Action + // When computing move detection, skip inserted nodes since they + // shift the indices of existing nodes. + effectiveIdx := 0 for i, n := range nodes { - if n.PendingAction == nil && n.OriginalPosition == i && !n.Removed { - continue + if n.IsInserted { + // Inserted nodes always have a PendingAction — handle below + } else { + if n.PendingAction == nil && n.OriginalPosition == effectiveIdx && !n.Removed { + effectiveIdx++ + continue + } + effectiveIdx++ } if n.Removed { @@ -69,10 +78,14 @@ func BuildPlan(nodes []modifyview.ModifyBranchNode) []Action { if n.PendingAction.Type == modifyview.ActionRename { action.NewName = n.PendingAction.NewName } + if n.PendingAction.Type == modifyview.ActionInsertBelow || n.PendingAction.Type == modifyview.ActionInsertAbove { + action.NewName = n.PendingAction.NewName + action.NewPosition = i + } plan = append(plan, action) } - if n.OriginalPosition != i && n.PendingAction == nil { + if !n.IsInserted && n.OriginalPosition != i && n.PendingAction == nil { plan = append(plan, Action{ Type: "move", Branch: n.Ref.Branch, @@ -216,7 +229,116 @@ func ApplyPlan( } } - // Step 2: Folds — absorb one branch's commits into an adjacent branch. + // Step 2: Inserts — create new branches and add to stack metadata. + // Process in order so positions are stable. The node's position in the + // non-removed list determines the parent branch. + for _, n := range nodes { + if n.PendingAction == nil { + continue + } + if n.PendingAction.Type != modifyview.ActionInsertBelow && n.PendingAction.Type != modifyview.ActionInsertAbove { + continue + } + + newName := n.PendingAction.NewName + + // Determine the parent branch: find the position of this node among + // the non-removed, non-merged nodes in the apply-order list, then + // look at the branch just before it (toward trunk). + var parentBranch string + insertPos := -1 + + // Build the active branch order from the stack (as of now, after renames) + activeIdx := 0 + for _, b := range s.Branches { + if b.IsMerged() { + continue + } + if b.Branch == newName { + // already added in a previous iteration — skip + break + } + activeIdx++ + } + + // Determine where in s.Branches the new branch should go. + // Walk the non-removed nodes to find the relative position. + nonRemovedPos := 0 + for _, other := range nodes { + if other.Removed || other.Ref.IsMerged() { + continue + } + if other.Ref.Branch == newName { + insertPos = nonRemovedPos + break + } + nonRemovedPos++ + } + + if insertPos <= 0 { + parentBranch = s.Trunk.Branch + } else { + // Find the branch at insertPos-1 among active branches + activeCount := 0 + for _, b := range s.Branches { + if b.IsMerged() { + continue + } + if activeCount == insertPos-1 { + parentBranch = b.Branch + break + } + activeCount++ + } + if parentBranch == "" { + parentBranch = s.Trunk.Branch + } + } + + // Create the git branch at the parent's tip + if err := git.CreateBranch(newName, parentBranch); err != nil { + unwindErr := Unwind(cfg, gitDir, snapshot, stackIndex, sf, plan) + if unwindErr != nil { + return nil, nil, fmt.Errorf("creating branch %s failed (%v) and unwind failed (%v)", newName, err, unwindErr) + } + return nil, nil, fmt.Errorf("creating branch %s from %s: %w", newName, parentBranch, err) + } + + // Insert BranchRef into s.Branches at the correct position + newRef := stack.BranchRef{Branch: newName} + targetIdx := len(s.Branches) // default: append at end + if insertPos >= 0 { + // Map the active position back to s.Branches index + activeCount := 0 + for j, b := range s.Branches { + if b.IsMerged() { + continue + } + if activeCount == insertPos { + targetIdx = j + break + } + activeCount++ + } + } + s.Branches = append(s.Branches, stack.BranchRef{}) + copy(s.Branches[targetIdx+1:], s.Branches[targetIdx:]) + s.Branches[targetIdx] = newRef + + // Check if the branch above the insertion point has a PR — + // its base changes, so we need a submit + if targetIdx < len(s.Branches)-1 { + above := s.Branches[targetIdx+1] + if above.PullRequest != nil { + affectsPRs = true + } + } + + result.InsertedBranches = append(result.InsertedBranches, newName) + cfg.Successf("Inserted %s after %s", newName, parentBranch) + } + + // Step 3: Folds — absorb one branch's commits into an adjacent branch. // // Fold-down: cherry-pick the folded branch's commits onto the target below. // The target is below in the stack (closer to trunk), so it doesn't @@ -347,7 +469,7 @@ func ApplyPlan( } } - // Step 3: Drops — remove from stack metadata + // Step 4: Drops — remove from stack metadata // Process in reverse order to preserve indices for i := len(nodes) - 1; i >= 0; i-- { n := nodes[i] @@ -373,7 +495,7 @@ func ApplyPlan( cfg.Successf("Dropped %s from stack", dropBranch) } - // Step 4: Reorder — build the desired branch order from the remaining nodes + // Step 5: Reorder — build the desired branch order from the remaining nodes desiredOrder := make([]string, 0) for _, n := range nodes { if n.Removed { @@ -439,7 +561,7 @@ func ApplyPlan( s.Branches = newBranches } - // Step 5: Cascading rebase — rebase each active branch onto its new parent. + // Step 6: Cascading rebase — rebase each active branch onto its new parent. // Use the original parent tip SHA as the oldBase for --onto, so that only // the branch's own commits are replayed onto the new parent. for i, b := range s.Branches { diff --git a/internal/modify/apply_test.go b/internal/modify/apply_test.go index 9921424..4f654c3 100644 --- a/internal/modify/apply_test.go +++ b/internal/modify/apply_test.go @@ -1794,3 +1794,233 @@ func TestApplyPlan_Rename_ChecksOutNewName(t *testing.T) { // Should check out new-A, not A assert.Equal(t, "new-A", lastCheckout) } + +// ─── BuildPlan: Insert ────────────────────────────────────────────────────── + +func TestBuildPlan_Insert(t *testing.T) { + t.Run("insert below produces insert_below action", func(t *testing.T) { + nodes := []modifyview.ModifyBranchNode{ + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "A"}}, + OriginalPosition: 0, + }, + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "new-branch"}}, + OriginalPosition: -1, + IsInserted: true, + PendingAction: &modifyview.PendingAction{Type: modifyview.ActionInsertBelow, NewName: "new-branch"}, + }, + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "B"}}, + OriginalPosition: 1, + }, + } + plan := BuildPlan(nodes) + require.Len(t, plan, 1) + assert.Equal(t, "insert_below", plan[0].Type) + assert.Equal(t, "new-branch", plan[0].Branch) + assert.Equal(t, "new-branch", plan[0].NewName) + assert.Equal(t, 1, plan[0].NewPosition) + }) + + t.Run("insert above produces insert_above action", func(t *testing.T) { + nodes := []modifyview.ModifyBranchNode{ + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "new-branch"}}, + OriginalPosition: -1, + IsInserted: true, + PendingAction: &modifyview.PendingAction{Type: modifyview.ActionInsertAbove, NewName: "new-branch"}, + }, + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "A"}}, + OriginalPosition: 0, + }, + } + plan := BuildPlan(nodes) + require.Len(t, plan, 1) + assert.Equal(t, "insert_above", plan[0].Type) + assert.Equal(t, "new-branch", plan[0].NewName) + assert.Equal(t, 0, plan[0].NewPosition) + }) +} + +// ─── ApplyPlan: Insert ────────────────────────────────────────────────────── + +func TestApplyPlan_Insert(t *testing.T) { + s := stack.Stack{ + Trunk: stack.BranchRef{Branch: "main"}, + Branches: []stack.BranchRef{ + {Branch: "A"}, + {Branch: "B"}, + }, + } + + gitDir := t.TempDir() + sf := writeTestStackFile(t, gitDir, s) + + branchSHAs := map[string]string{ + "main": "sha-main", + "A": "sha-A", + "B": "sha-B", + } + + var createCalls []struct{ name, base string } + mock := newApplyMock(gitDir, branchSHAs) + mock.CreateBranchFn = func(name, base string) error { + createCalls = append(createCalls, struct{ name, base string }{name, base}) + return nil + } + + restore := git.SetOps(mock) + defer restore() + + cfg, _, _ := config.NewTestConfig() + defer cfg.Out.Close() + defer cfg.Err.Close() + + // Insert "new-branch" between A and B (at position 1 in stack order) + nodes := makeNodes(&sf.Stacks[0]) + insertNode := modifyview.ModifyBranchNode{ + BranchNode: stackview.BranchNode{ + Ref: stack.BranchRef{Branch: "new-branch"}, + IsLinear: true, + }, + PendingAction: &modifyview.PendingAction{Type: modifyview.ActionInsertBelow, NewName: "new-branch"}, + OriginalPosition: -1, + IsInserted: true, + } + // Insert between A(0) and B(1) + allNodes := []modifyview.ModifyBranchNode{nodes[0], insertNode, nodes[1]} + + result, conflict, err := ApplyPlan(cfg, gitDir, &sf.Stacks[0], sf, allNodes, "A", noopUpdateBaseSHAs) + require.NoError(t, err) + assert.Nil(t, conflict) + require.NotNil(t, result) + + // Branch should have been created + require.Len(t, createCalls, 1) + assert.Equal(t, "new-branch", createCalls[0].name) + assert.Equal(t, "A", createCalls[0].base) + + // Stack should now have 3 branches: A, new-branch, B + require.Len(t, sf.Stacks[0].Branches, 3) + assert.Equal(t, "A", sf.Stacks[0].Branches[0].Branch) + assert.Equal(t, "new-branch", sf.Stacks[0].Branches[1].Branch) + assert.Equal(t, "B", sf.Stacks[0].Branches[2].Branch) + + // new-branch should be in InsertedBranches + require.Len(t, result.InsertedBranches, 1) + assert.Equal(t, "new-branch", result.InsertedBranches[0]) +} + +func TestApplyPlan_InsertAtStart(t *testing.T) { + s := stack.Stack{ + Trunk: stack.BranchRef{Branch: "main"}, + Branches: []stack.BranchRef{ + {Branch: "A"}, + {Branch: "B"}, + }, + } + + gitDir := t.TempDir() + sf := writeTestStackFile(t, gitDir, s) + + branchSHAs := map[string]string{ + "main": "sha-main", + "A": "sha-A", + "B": "sha-B", + } + + var createCalls []struct{ name, base string } + mock := newApplyMock(gitDir, branchSHAs) + mock.CreateBranchFn = func(name, base string) error { + createCalls = append(createCalls, struct{ name, base string }{name, base}) + return nil + } + + restore := git.SetOps(mock) + defer restore() + + cfg, _, _ := config.NewTestConfig() + defer cfg.Out.Close() + defer cfg.Err.Close() + + // Insert "new-branch" at the start (before A) + nodes := makeNodes(&sf.Stacks[0]) + insertNode := modifyview.ModifyBranchNode{ + BranchNode: stackview.BranchNode{ + Ref: stack.BranchRef{Branch: "new-branch"}, + IsLinear: true, + }, + PendingAction: &modifyview.PendingAction{Type: modifyview.ActionInsertAbove, NewName: "new-branch"}, + OriginalPosition: -1, + IsInserted: true, + } + allNodes := []modifyview.ModifyBranchNode{insertNode, nodes[0], nodes[1]} + + result, conflict, err := ApplyPlan(cfg, gitDir, &sf.Stacks[0], sf, allNodes, "A", noopUpdateBaseSHAs) + require.NoError(t, err) + assert.Nil(t, conflict) + require.NotNil(t, result) + + // Branch should be created from trunk + require.Len(t, createCalls, 1) + assert.Equal(t, "new-branch", createCalls[0].name) + assert.Equal(t, "main", createCalls[0].base) + + // Stack should now have 3 branches: new-branch, A, B + require.Len(t, sf.Stacks[0].Branches, 3) + assert.Equal(t, "new-branch", sf.Stacks[0].Branches[0].Branch) + assert.Equal(t, "A", sf.Stacks[0].Branches[1].Branch) + assert.Equal(t, "B", sf.Stacks[0].Branches[2].Branch) +} + +func TestApplyPlan_InsertAffectsPRs(t *testing.T) { + s := stack.Stack{ + ID: "test-id", + Trunk: stack.BranchRef{Branch: "main"}, + Branches: []stack.BranchRef{ + {Branch: "A"}, + {Branch: "B", PullRequest: &stack.PullRequestRef{Number: 42}}, + }, + } + + gitDir := t.TempDir() + sf := writeTestStackFile(t, gitDir, s) + + branchSHAs := map[string]string{ + "main": "sha-main", + "A": "sha-A", + "B": "sha-B", + } + + mock := newApplyMock(gitDir, branchSHAs) + mock.CreateBranchFn = func(name, base string) error { return nil } + + restore := git.SetOps(mock) + defer restore() + + cfg, _, _ := config.NewTestConfig() + defer cfg.Out.Close() + defer cfg.Err.Close() + + // Insert between A and B — B has a PR, so base changes → affectsPRs + nodes := makeNodes(&sf.Stacks[0]) + insertNode := modifyview.ModifyBranchNode{ + BranchNode: stackview.BranchNode{ + Ref: stack.BranchRef{Branch: "new-branch"}, + IsLinear: true, + }, + PendingAction: &modifyview.PendingAction{Type: modifyview.ActionInsertBelow, NewName: "new-branch"}, + OriginalPosition: -1, + IsInserted: true, + } + allNodes := []modifyview.ModifyBranchNode{nodes[0], insertNode, nodes[1]} + + result, _, err := ApplyPlan(cfg, gitDir, &sf.Stacks[0], sf, allNodes, "A", noopUpdateBaseSHAs) + require.NoError(t, err) + require.NotNil(t, result) + + // Should need submit because insertion changes the base of a branch with PR + assert.True(t, result.NeedsSubmit, "inserting before a branch with a PR should trigger NeedsSubmit") +} diff --git a/internal/tui/modifyview/help.go b/internal/tui/modifyview/help.go index ad25db3..f43de88 100644 --- a/internal/tui/modifyview/help.go +++ b/internal/tui/modifyview/help.go @@ -13,7 +13,7 @@ func renderHelpOverlay(width, height int) string { title := helpTitleStyle.Render("Modify Stack") b.WriteString(title) b.WriteString("\n") - b.WriteString(helpDescStyle.Render("Restructure your stack by dropping, folding, renaming, or reordering branches.")) + b.WriteString(helpDescStyle.Render("Restructure your stack by dropping, folding, inserting, renaming, or reordering branches.")) b.WriteString("\n") sections := []struct { @@ -25,8 +25,12 @@ func renderHelpOverlay(width, height int) string { "Remove a branch and its commits from the stack.\nThe local branch is preserved; the PR stays open on GitHub.", }, { - "Fold up / down (u / d)", - "Merge a branch's commits into an adjacent branch.\nFold up absorbs into the branch above; fold down into the branch below.", + "Fold down / up (d / u)", + "Merge a branch's commits into an adjacent branch.\nFold down absorbs into the branch below; fold up into the branch above.", + }, + { + "Insert below / above (i / I)", + "Insert a new empty branch into the stack.\nLowercase i inserts below the cursor; uppercase I inserts above.", }, { "Rename (r)", diff --git a/internal/tui/modifyview/model.go b/internal/tui/modifyview/model.go index eff9e79..5d36bf0 100644 --- a/internal/tui/modifyview/model.go +++ b/internal/tui/modifyview/model.go @@ -11,6 +11,7 @@ import ( "github.com/github/gh-stack/internal/git" "github.com/github/gh-stack/internal/stack" "github.com/github/gh-stack/internal/tui/shared" + "github.com/github/gh-stack/internal/tui/stackview" ) // modifyKeyMap defines key bindings for the modify view. @@ -23,6 +24,8 @@ type modifyKeyMap struct { FoldDown key.Binding FoldUp key.Binding Rename key.Binding + InsertBelow key.Binding + InsertAbove key.Binding Undo key.Binding ToggleCommits key.Binding ToggleFiles key.Binding @@ -32,7 +35,7 @@ type modifyKeyMap struct { } func (k modifyKeyMap) ShortHelp() []key.Binding { - return []key.Binding{k.Up, k.Down, k.Drop, k.FoldDown, k.Rename, k.ToggleCommits, k.ToggleFiles, k.Apply, k.Help, k.Quit} + return []key.Binding{k.Up, k.Down, k.Drop, k.FoldDown, k.InsertBelow, k.Rename, k.ToggleCommits, k.ToggleFiles, k.Apply, k.Help, k.Quit} } func (k modifyKeyMap) FullHelp() [][]key.Binding { @@ -72,6 +75,14 @@ var modifyKeys = modifyKeyMap{ key.WithKeys("r"), key.WithHelp("r", "rename"), ), + InsertBelow: key.NewBinding( + key.WithKeys("i"), + key.WithHelp("i", "insert below"), + ), + InsertAbove: key.NewBinding( + key.WithKeys("I"), + key.WithHelp("I", "insert above"), + ), Undo: key.NewBinding( key.WithKeys("z"), key.WithHelp("z", "undo"), @@ -116,6 +127,11 @@ type Model struct { renameInput textinput.Model renameOriginal string // original branch name shown as label + // Insert mode + insertMode bool + insertDirection ActionType // ActionInsertBelow or ActionInsertAbove + insertInput textinput.Model + // Help overlay showHelp bool @@ -139,6 +155,9 @@ func New(nodes []ModifyBranchNode, trunk stack.BranchRef, version string) Model ti := textinput.New() ti.CharLimit = 100 + ii := textinput.New() + ii.CharLimit = 100 + // Default cursor to the current active branch, or first non-merged branch cursor := 0 found := false @@ -164,6 +183,7 @@ func New(nodes []ModifyBranchNode, trunk stack.BranchRef, version string) Model version: version, cursor: cursor, renameInput: ti, + insertInput: ii, } } @@ -210,6 +230,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) { if m.renameMode { return m.updateRename(msg) } + if m.insertMode { + return m.updateInsert(msg) + } return m.updateNormal(msg) case tea.MouseMsg: @@ -316,7 +339,94 @@ func (m Model) updateRename(msg tea.KeyMsg) (tea.Model, tea.Cmd) { } } -// updateNormal handles keys during normal (non-modal) interaction. +// updateInsert handles keys while in insert mode (typing a new branch name). +func (m Model) updateInsert(msg tea.KeyMsg) (tea.Model, tea.Cmd) { + switch msg.Type { + case tea.KeyEnter: + newName := strings.TrimSpace(m.insertInput.Value()) + if newName == "" { + m.insertMode = false + return m, nil + } + + // Validate: git ref name rules + if err := git.ValidateRefName(newName); err != nil { + m.statusMessage = fmt.Sprintf("Invalid branch name: %s", err) + m.statusIsError = true + return m, nil + } + + // Validate: not already used by another local branch + if git.BranchExists(newName) { + m.statusMessage = fmt.Sprintf("Branch %q already exists locally", newName) + m.statusIsError = true + return m, nil + } + + // Validate: not already used in this stack (by another node) + for _, other := range m.nodes { + checkName := other.Ref.Branch + if other.PendingAction != nil && other.PendingAction.Type == ActionRename { + checkName = other.PendingAction.NewName + } + if other.PendingAction != nil && (other.PendingAction.Type == ActionInsertBelow || other.PendingAction.Type == ActionInsertAbove) { + checkName = other.PendingAction.NewName + } + if checkName == newName { + m.statusMessage = fmt.Sprintf("Branch %q already used in this stack", newName) + m.statusIsError = true + return m, nil + } + } + + // Determine insertion position + insertIdx := m.cursor + if m.insertDirection == ActionInsertBelow { + insertIdx = m.cursor + 1 + } + // For InsertAbove, insertIdx stays at m.cursor (insert before cursor) + + // Create the new node + newNode := ModifyBranchNode{ + BranchNode: stackview.BranchNode{ + Ref: stack.BranchRef{Branch: newName}, + IsLinear: true, + }, + PendingAction: &PendingAction{ + Type: m.insertDirection, + NewName: newName, + }, + OriginalPosition: -1, // sentinel: this node has no original position + IsInserted: true, + } + + // Insert the node into the slice + m.nodes = append(m.nodes, ModifyBranchNode{}) + copy(m.nodes[insertIdx+1:], m.nodes[insertIdx:]) + m.nodes[insertIdx] = newNode + + // Record undo action + m.actionStack = append(m.actionStack, StagedAction{ + Type: m.insertDirection, + BranchName: newName, + }) + + // Move cursor to the newly inserted node + m.cursor = insertIdx + m.insertMode = false + m.ensureVisible() + return m, nil + + case tea.KeyEscape: + m.insertMode = false + return m, nil + + default: + var cmd tea.Cmd + m.insertInput, cmd = m.insertInput.Update(msg) + return m, cmd + } +} func (m Model) updateNormal(msg tea.KeyMsg) (tea.Model, tea.Cmd) { switch { case key.Matches(msg, modifyKeys.Quit): @@ -385,6 +495,24 @@ func (m Model) updateNormal(msg tea.KeyMsg) (tea.Model, tea.Cmd) { m.startRename() return m, nil + case key.Matches(msg, modifyKeys.InsertBelow): + if m.currentMode() == modeReorder { + m.statusMessage = "Cannot insert while branches are reordered — undo moves first" + m.statusIsError = true + return m, nil + } + m.startInsert(ActionInsertBelow) + return m, nil + + case key.Matches(msg, modifyKeys.InsertAbove): + if m.currentMode() == modeReorder { + m.statusMessage = "Cannot insert while branches are reordered — undo moves first" + m.statusIsError = true + return m, nil + } + m.startInsert(ActionInsertAbove) + return m, nil + case key.Matches(msg, modifyKeys.Undo): m.undoLast() return m, nil @@ -432,17 +560,28 @@ func (m *Model) currentMode() actionMode { hasReorder := false hasStructure := false - for i, n := range m.nodes { + for _, n := range m.nodes { if n.PendingAction != nil { switch n.PendingAction.Type { - case ActionDrop, ActionFoldDown, ActionFoldUp, ActionRename: + case ActionDrop, ActionFoldDown, ActionFoldUp, ActionRename, ActionInsertBelow, ActionInsertAbove: hasStructure = true } } - // Position change without explicit action = reorder - if !n.Ref.IsMerged() && n.OriginalPosition != i && n.PendingAction == nil { + } + + // Position change without explicit action = reorder. + // Skip inserted nodes — they don't have an original position and + // their presence shifts indices of other nodes. + effectiveIdx := 0 + for _, n := range m.nodes { + if n.IsInserted { + continue + } + if !n.Ref.IsMerged() && n.OriginalPosition != effectiveIdx && n.PendingAction == nil { hasReorder = true + break } + effectiveIdx++ } if hasReorder { @@ -712,6 +851,28 @@ func (m *Model) startRename() { m.renameInput.CursorEnd() } +// startInsert enters insert mode to type a new branch name. +func (m *Model) startInsert(direction ActionType) { + if m.cursor < 0 || m.cursor >= len(m.nodes) { + return + } + node := &m.nodes[m.cursor] + if node.Ref.IsMerged() { + m.statusMessage = "Cannot insert next to a merged branch" + m.statusIsError = true + return + } + if node.Removed { + return + } + + m.insertMode = true + m.insertDirection = direction + m.insertInput.SetValue("") + m.insertInput.Prompt = "" + m.insertInput.Focus() +} + // undoLast reverses the most recent action from the stack. func (m *Model) undoLast() { if len(m.actionStack) == 0 { @@ -775,21 +936,41 @@ func (m *Model) undoLast() { break } } + + case ActionInsertBelow, ActionInsertAbove: + // Remove the inserted node from the slice + for i := range m.nodes { + if m.nodes[i].IsInserted && m.nodes[i].Ref.Branch == action.BranchName { + m.nodes = append(m.nodes[:i], m.nodes[i+1:]...) + if m.cursor >= len(m.nodes) { + m.cursor = len(m.nodes) - 1 + } + if m.cursor < 0 { + m.cursor = 0 + } + break + } + } } } // tryApply validates and initiates apply. func (m Model) tryApply() (tea.Model, tea.Cmd) { hasPending := false - for i, n := range m.nodes { + effectiveIdx := 0 + for _, n := range m.nodes { if n.PendingAction != nil { hasPending = true break } - if !n.Removed && n.OriginalPosition != i { + if n.IsInserted { + continue + } + if !n.Removed && n.OriginalPosition != effectiveIdx { hasPending = true break } + effectiveIdx++ } if !hasPending { @@ -926,11 +1107,16 @@ func toNodeData(n ModifyBranchNode, currentIdx int) shared.BranchNodeData { data.BranchNameStyleOverride = &s data.ConnectorStyleOverride = &c data.ForceDashedConnector = true + case ActionInsertBelow, ActionInsertAbove: + s := insertBranchStyle + c := insertConnectorStyle + data.BranchNameStyleOverride = &s + data.ConnectorStyleOverride = &c } } // Moved branch: purple solid connector (no dash, no strikethrough) - if n.PendingAction == nil && !n.Ref.IsMerged() && n.OriginalPosition != currentIdx { + if n.PendingAction == nil && !n.Ref.IsMerged() && !n.IsInserted && n.OriginalPosition != currentIdx { c := movedConnectorStyle data.ConnectorStyleOverride = &c } @@ -954,12 +1140,14 @@ func nodeAnnotation(n ModifyBranchNode, currentIdx int) *shared.NodeAnnotation { return &shared.NodeAnnotation{Text: "↑ fold up", Style: foldBadge} case ActionRename: return &shared.NodeAnnotation{Text: "→ " + n.PendingAction.NewName, Style: renameBadge} + case ActionInsertBelow, ActionInsertAbove: + return &shared.NodeAnnotation{Text: "✚ insert", Style: insertBadge} case ActionMove: return &shared.NodeAnnotation{Text: "↕ moved", Style: moveBadge} } } // Show move annotation when position changed (even without explicit PendingAction) - if !n.Ref.IsMerged() && n.OriginalPosition != currentIdx { + if !n.Ref.IsMerged() && !n.IsInserted && n.OriginalPosition != currentIdx { delta := n.OriginalPosition - currentIdx // positive = moved up (toward top) direction := "up" layers := delta @@ -1036,6 +1224,13 @@ func (m Model) View() string { if m.renameMode { out.WriteString(renameBadge.Render(fmt.Sprintf("Rename: %s → ", m.renameOriginal))) out.WriteString(m.renameInput.View()) + } else if m.insertMode { + direction := "below" + if m.insertDirection == ActionInsertAbove { + direction = "above" + } + out.WriteString(insertBadge.Render(fmt.Sprintf("Insert %s: ", direction))) + out.WriteString(m.insertInput.View()) } else { out.WriteString(renderStatusLine(m.nodes, m.width)) } @@ -1088,8 +1283,8 @@ func (m Model) buildHeaderConfig() shared.HeaderConfig { // Left column // Right column {Key: "↑↓", Desc: "select branch"}, {Key: "x", Desc: "drop", Disabled: structureDisabled}, {Key: "f", Desc: "view files"}, {Key: "r", Desc: "rename", Disabled: structureDisabled}, - {Key: "c", Desc: "view commits"}, {Key: "u", Desc: "fold up", Disabled: structureDisabled}, - {Key: "?", Desc: "help"}, {Key: "d", Desc: "fold down", Disabled: structureDisabled}, + {Key: "c", Desc: "view commits"}, {Key: "i/I", Desc: "insert below/above", Disabled: structureDisabled}, + {Key: "?", Desc: "help"}, {Key: "d/u", Desc: "fold down/up", Disabled: structureDisabled}, {Key: "q/esc", Desc: "quit"}, {Key: "shift+↑↓", Desc: "reorder", Disabled: reorderDisabled}, {Key: "^S", Desc: "apply changes"}, {Key: "z", Desc: "undo"}, }, diff --git a/internal/tui/modifyview/model_test.go b/internal/tui/modifyview/model_test.go index 6afc13d..0c3eda5 100644 --- a/internal/tui/modifyview/model_test.go +++ b/internal/tui/modifyview/model_test.go @@ -774,3 +774,387 @@ func TestCursorNavigation_SkipsMergedBranches(t *testing.T) { m = sendKey(t, m, runeKey('k')) assert.Equal(t, 0, m.cursor, "up should skip merged branch") } + +// --- Insert tests --- + +// simulateInsert enters insert mode, types a branch name, and presses Enter. +func simulateInsert(t *testing.T, m Model, name string) Model { + t.Helper() + require.True(t, m.insertMode, "expected insert mode to be active") + for _, r := range name { + m = sendKey(t, m, runeKey(r)) + } + m = sendKey(t, m, tea.KeyMsg{Type: tea.KeyEnter}) + return m +} + +func TestInsertBelow(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + require.Equal(t, 0, m.cursor) // cursor on a + + // Press 'i' to insert below + m = sendKey(t, m, runeKey('i')) + require.True(t, m.insertMode, "should enter insert mode") + assert.Equal(t, ActionInsertBelow, m.insertDirection) + + // Type a branch name and confirm + m = simulateInsert(t, m, "new-branch") + require.False(t, m.insertMode, "should exit insert mode") + + // New node should be at index 1 (below cursor at 0) + require.Len(t, m.nodes, 4) + assert.Equal(t, "a", m.nodes[0].Ref.Branch) + assert.Equal(t, "new-branch", m.nodes[1].Ref.Branch) + assert.True(t, m.nodes[1].IsInserted) + assert.NotNil(t, m.nodes[1].PendingAction) + assert.Equal(t, ActionInsertBelow, m.nodes[1].PendingAction.Type) + assert.Equal(t, "new-branch", m.nodes[1].PendingAction.NewName) + assert.Equal(t, "b", m.nodes[2].Ref.Branch) + assert.Equal(t, "c", m.nodes[3].Ref.Branch) + + // Cursor should be on the new node + assert.Equal(t, 1, m.cursor) +} + +func TestInsertAbove(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + require.Equal(t, 1, m.cursor) // cursor on b + + // Press 'I' (shift+i) to insert above + m = sendKey(t, m, runeKey('I')) + require.True(t, m.insertMode, "should enter insert mode") + assert.Equal(t, ActionInsertAbove, m.insertDirection) + + // Type a branch name and confirm + m = simulateInsert(t, m, "above-b") + require.False(t, m.insertMode, "should exit insert mode") + + // New node should be at index 1 (above cursor which was at 1) + require.Len(t, m.nodes, 4) + assert.Equal(t, "a", m.nodes[0].Ref.Branch) + assert.Equal(t, "above-b", m.nodes[1].Ref.Branch) + assert.True(t, m.nodes[1].IsInserted) + assert.NotNil(t, m.nodes[1].PendingAction) + assert.Equal(t, ActionInsertAbove, m.nodes[1].PendingAction.Type) + assert.Equal(t, "b", m.nodes[2].Ref.Branch) + assert.Equal(t, "c", m.nodes[3].Ref.Branch) + + // Cursor should be on the new node + assert.Equal(t, 1, m.cursor) +} + +func TestInsertAtTop(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + require.Equal(t, 0, m.cursor) + + // Insert above the top — new node becomes index 0 + m = sendKey(t, m, runeKey('I')) + m = simulateInsert(t, m, "top") + + require.Len(t, m.nodes, 3) + assert.Equal(t, "top", m.nodes[0].Ref.Branch) + assert.True(t, m.nodes[0].IsInserted) + assert.Equal(t, "a", m.nodes[1].Ref.Branch) + assert.Equal(t, "b", m.nodes[2].Ref.Branch) + assert.Equal(t, 0, m.cursor) +} + +func TestInsertAtBottom(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + } + m := New(nodes, testTrunk, "1.0.0") + // Move cursor to bottom + m = sendKey(t, m, runeKey('j')) + // cursor already starts at 1 (b is current) + require.Equal(t, 1, m.cursor) + + // Insert below the bottom — new node appended + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "bottom") + + require.Len(t, m.nodes, 3) + assert.Equal(t, "a", m.nodes[0].Ref.Branch) + assert.Equal(t, "b", m.nodes[1].Ref.Branch) + assert.Equal(t, "bottom", m.nodes[2].Ref.Branch) + assert.True(t, m.nodes[2].IsInserted) + assert.Equal(t, 2, m.cursor) +} + +func TestUndoInsert(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert below a + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + require.Len(t, m.nodes, 4) + assert.Equal(t, 1, m.cursor) + + // Undo + m = sendKey(t, m, runeKey('z')) + require.Len(t, m.nodes, 3, "inserted node should be removed") + assert.Equal(t, "a", m.nodes[0].Ref.Branch) + assert.Equal(t, "b", m.nodes[1].Ref.Branch) + assert.Equal(t, "c", m.nodes[2].Ref.Branch) +} + +func TestInsertBlockedInReorderMode(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Reorder: move a down + m = sendKey(t, m, runeKey('J')) + assert.Equal(t, modeReorder, m.currentMode()) + + // Try insert below → should be blocked + m = sendKey(t, m, runeKey('i')) + assert.False(t, m.insertMode) + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "undo") + + // Try insert above → should be blocked + m = sendKey(t, m, runeKey('I')) + assert.False(t, m.insertMode) + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "undo") +} + +func TestReorderBlockedAfterInsert(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + assert.Equal(t, modeStructure, m.currentMode()) + + // Try reorder → should be blocked + m = sendKey(t, m, runeKey('J')) + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "undo") +} + +func TestInsertCannotInsertOnMergedBranch(t *testing.T) { + nodes := []ModifyBranchNode{ + makeMergedNode("merged", 0), + makeNode("active", true, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Force cursor to merged node + m.cursor = 0 + m = sendKey(t, m, runeKey('i')) + assert.False(t, m.insertMode) + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "merged") +} + +func TestInsertCancelledWithEscape(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Start insert + m = sendKey(t, m, runeKey('i')) + require.True(t, m.insertMode) + + // Cancel with Escape + m = sendKey(t, m, tea.KeyMsg{Type: tea.KeyEscape}) + assert.False(t, m.insertMode) + assert.Len(t, m.nodes, 2, "no node should be added on cancel") +} + +func TestInsertEmptyNameCancels(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Start insert, press Enter with empty input + m = sendKey(t, m, runeKey('i')) + require.True(t, m.insertMode) + m = sendKey(t, m, tea.KeyMsg{Type: tea.KeyEnter}) + assert.False(t, m.insertMode) + assert.Len(t, m.nodes, 2, "no node should be added on empty input") +} + +func TestInsertDuplicateNameBlocked(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Try to insert with existing branch name "b" + m = sendKey(t, m, runeKey('i')) + require.True(t, m.insertMode) + m = simulateInsert(t, m, "b") + // Should still be in insert mode with an error + assert.True(t, m.insertMode, "should stay in insert mode on validation error") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "already used") +} + +func TestInsertCountedInPendingSummary(t *testing.T) { + nodes := []ModifyBranchNode{ + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "new"}}, + OriginalPosition: -1, + IsInserted: true, + PendingAction: &PendingAction{Type: ActionInsertBelow, NewName: "new"}, + }, + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "b"}}, + OriginalPosition: 0, + }, + } + + result := pendingChangeSummary(nodes) + assert.Equal(t, "Pending: 1 insert", result) +} + +func TestInsertPluralInPendingSummary(t *testing.T) { + nodes := []ModifyBranchNode{ + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "new1"}}, + OriginalPosition: -1, + IsInserted: true, + PendingAction: &PendingAction{Type: ActionInsertBelow, NewName: "new1"}, + }, + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "b"}}, + OriginalPosition: 0, + }, + { + BranchNode: stackview.BranchNode{Ref: stack.BranchRef{Branch: "new2"}}, + OriginalPosition: -1, + IsInserted: true, + PendingAction: &PendingAction{Type: ActionInsertAbove, NewName: "new2"}, + }, + } + + result := pendingChangeSummary(nodes) + assert.Equal(t, "Pending: 2 inserts", result) +} + +func TestInsertMixedWithOtherActions(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Drop a + m = sendKey(t, m, runeKey('x')) + require.NotNil(t, m.nodes[0].PendingAction) + assert.Equal(t, ActionDrop, m.nodes[0].PendingAction.Type) + + // Move cursor to b and insert below it + m = sendKey(t, m, runeKey('j')) + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + + // Should now have 4 nodes: a(dropped), b, new-branch, c + require.Len(t, m.nodes, 4) + assert.Equal(t, modeStructure, m.currentMode()) + assert.Equal(t, ActionDrop, m.nodes[0].PendingAction.Type) + assert.Equal(t, "new-branch", m.nodes[2].Ref.Branch) + assert.True(t, m.nodes[2].IsInserted) +} + +func TestInsertOnRemovedBranchDoesNothing(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Drop a + m = sendKey(t, m, runeKey('x')) + require.True(t, m.nodes[0].Removed) + + // Force cursor back to removed node and try to insert + m.cursor = 0 + prevLen := len(m.nodes) + m = sendKey(t, m, runeKey('i')) + assert.False(t, m.insertMode, "should not enter insert mode on removed branch") + assert.Len(t, m.nodes, prevLen) +} + +func TestCurrentModeStructureAfterInsert(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + assert.Equal(t, modeNone, m.currentMode()) + + // Insert + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + assert.Equal(t, modeStructure, m.currentMode()) +} + +func TestApplyWithInsert(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert a branch + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + + // Apply should be accepted + m = sendKey(t, m, tea.KeyMsg{Type: tea.KeyCtrlS}) + assert.True(t, m.applyRequested) +} + +func TestInsertAnnotation(t *testing.T) { + node := ModifyBranchNode{ + BranchNode: stackview.BranchNode{ + Ref: stack.BranchRef{Branch: "new-branch"}, + }, + PendingAction: &PendingAction{Type: ActionInsertBelow, NewName: "new-branch"}, + OriginalPosition: -1, + IsInserted: true, + } + + annotation := nodeAnnotation(node, 0) + require.NotNil(t, annotation) + assert.Equal(t, "✚ insert", annotation.Text) +} diff --git a/internal/tui/modifyview/status.go b/internal/tui/modifyview/status.go index cb5d489..5f76c44 100644 --- a/internal/tui/modifyview/status.go +++ b/internal/tui/modifyview/status.go @@ -10,7 +10,7 @@ import ( // pendingChangeSummary returns a summary string of all pending changes. // E.g. "Pending: 1 drop, 1 fold, 2 moves, 1 rename" func pendingChangeSummary(nodes []ModifyBranchNode) string { - var drops, foldDowns, foldUps, moves, renames int + var drops, foldDowns, foldUps, moves, renames, inserts int for _, n := range nodes { if n.PendingAction == nil { @@ -27,17 +27,25 @@ func pendingChangeSummary(nodes []ModifyBranchNode) string { moves++ case ActionRename: renames++ + case ActionInsertBelow, ActionInsertAbove: + inserts++ } } - // Also count nodes that have moved from their original position - for i, n := range nodes { - if !n.Removed && n.PendingAction == nil && n.OriginalPosition != i { + // Also count nodes that have moved from their original position. + // Skip inserted nodes — they shift indices of other nodes. + effectiveIdx := 0 + for _, n := range nodes { + if n.IsInserted { + continue + } + if !n.Removed && n.PendingAction == nil && n.OriginalPosition != effectiveIdx { moves++ } + effectiveIdx++ } - if drops == 0 && foldDowns == 0 && foldUps == 0 && moves == 0 && renames == 0 { + if drops == 0 && foldDowns == 0 && foldUps == 0 && moves == 0 && renames == 0 && inserts == 0 { return "" } @@ -49,6 +57,9 @@ func pendingChangeSummary(nodes []ModifyBranchNode) string { if folds > 0 { parts = append(parts, fmt.Sprintf("%d %s", folds, pluralize(folds, "fold", "folds"))) } + if inserts > 0 { + parts = append(parts, fmt.Sprintf("%d %s", inserts, pluralize(inserts, "insert", "inserts"))) + } if moves > 0 { parts = append(parts, fmt.Sprintf("%d %s", moves, pluralize(moves, "move", "moves"))) } diff --git a/internal/tui/modifyview/styles.go b/internal/tui/modifyview/styles.go index 2c7b9d9..4435902 100644 --- a/internal/tui/modifyview/styles.go +++ b/internal/tui/modifyview/styles.go @@ -8,15 +8,18 @@ var ( foldBadge = lipgloss.NewStyle().Foreground(lipgloss.Color("3")) // yellow renameBadge = lipgloss.NewStyle().Foreground(lipgloss.Color("14")) // cyan moveBadge = lipgloss.NewStyle().Foreground(lipgloss.Color("5")) // magenta/purple + insertBadge = lipgloss.NewStyle().Foreground(lipgloss.Color("2")) // green - // Branch name overrides for drop/fold - dropBranchStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("1")).Strikethrough(true) // red strikethrough - foldBranchStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("3")).Strikethrough(true) // yellow strikethrough + // Branch name overrides for drop/fold/insert + dropBranchStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("1")).Strikethrough(true) // red strikethrough + foldBranchStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("3")).Strikethrough(true) // yellow strikethrough + insertBranchStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("2")) // green - // Connector color overrides for drop/fold/move - dropConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("1")) // red - foldConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("3")) // yellow - movedConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("5")) // magenta/purple + // Connector color overrides for drop/fold/move/insert + dropConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("1")) // red + foldConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("3")) // yellow + movedConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("5")) // magenta/purple + insertConnectorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("2")) // green // Status line styles statusBarStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("8")) diff --git a/internal/tui/modifyview/types.go b/internal/tui/modifyview/types.go index 4598c6b..2d8de63 100644 --- a/internal/tui/modifyview/types.go +++ b/internal/tui/modifyview/types.go @@ -8,11 +8,13 @@ import ( type ActionType string const ( - ActionDrop ActionType = "drop" - ActionFoldDown ActionType = "fold_down" - ActionFoldUp ActionType = "fold_up" - ActionMove ActionType = "move" - ActionRename ActionType = "rename" + ActionDrop ActionType = "drop" + ActionFoldDown ActionType = "fold_down" + ActionFoldUp ActionType = "fold_up" + ActionMove ActionType = "move" + ActionRename ActionType = "rename" + ActionInsertBelow ActionType = "insert_below" + ActionInsertAbove ActionType = "insert_above" ) // PendingAction represents a staged modification on a branch. @@ -39,16 +41,18 @@ type ModifyBranchNode struct { PendingAction *PendingAction OriginalPosition int Removed bool // true if this branch has been dropped or folded + IsInserted bool // true if this branch was inserted during modify (not yet in git) } // ApplyResult holds the outcome of applying modifications. type ApplyResult struct { - Success bool - DroppedPRs []DroppedPR - RenamedBranches []RenamedBranch - MovedBranches int - NeedsSubmit bool // true when the modify affected branches with PRs - Message string + Success bool + DroppedPRs []DroppedPR + RenamedBranches []RenamedBranch + InsertedBranches []string + MovedBranches int + NeedsSubmit bool // true when the modify affected branches with PRs + Message string } // DroppedPR records a PR that was dropped from the stack. diff --git a/internal/tui/shared/header.go b/internal/tui/shared/header.go index d686e3f..edec801 100644 --- a/internal/tui/shared/header.go +++ b/internal/tui/shared/header.go @@ -16,10 +16,10 @@ const MinHeightForHeader = 25 const MinWidthForShortcuts = 65 // MinWidthForHeader is the minimum width to show the header at all. -const MinWidthForHeader = 50 +const MinWidthForHeader = 53 // MinWidthForArt is the minimum width to show ASCII art in the header. -const MinWidthForArt = 88 +const MinWidthForArt = 96 // ShortcutEntry represents a keyboard shortcut for the header. type ShortcutEntry struct { From 1ad3e87f0e3a98799146375f2f73eed1dd97c595 Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Fri, 22 May 2026 14:54:06 -0400 Subject: [PATCH 2/7] update add error msg to direct users to modify for inserting branches --- cmd/add.go | 3 ++- cmd/add_test.go | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/cmd/add.go b/cmd/add.go index 8dcdffc..b27555b 100644 --- a/cmd/add.go +++ b/cmd/add.go @@ -85,7 +85,8 @@ func runAdd(cfg *config.Config, opts *addOptions, args []string) error { // idx < 0 means we're on the trunk — that's allowed (we'll create // a new branch from it). Only block if we're in the middle of the stack. if idx >= 0 && idx < len(s.Branches)-1 { - cfg.Errorf("can only add branches on top of the stack; run `%s` to switch to %q", cfg.ColorCyan("gh stack top"), s.Branches[len(s.Branches)-1].Branch) + cfg.Errorf("can only add branches to the top of the stack; run `%s` then `%s`", cfg.ColorCyan("gh stack top"), cfg.ColorCyan("gh stack add")) + cfg.Printf("Or to restructure your stack and insert a branch, use `%s`", cfg.ColorCyan("gh stack modify")) return ErrInvalidArgs } diff --git a/cmd/add_test.go b/cmd/add_test.go index b6f587f..8563cc1 100644 --- a/cmd/add_test.go +++ b/cmd/add_test.go @@ -78,6 +78,7 @@ func TestAdd_OnlyAllowedOnTopOfStack(t *testing.T) { output := collectOutput(cfg, outR, errR) assert.Contains(t, output, "top of the stack") + assert.Contains(t, output, "gh stack modify") } func TestAdd_MutuallyExclusiveFlags(t *testing.T) { From 75fb311b15a720ac8ca8bc7186122fe166fd0f32 Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Fri, 22 May 2026 17:54:39 -0400 Subject: [PATCH 3/7] docs updates --- README.md | 6 ++++-- .../assets/screenshots/modify-stack-tui.png | Bin 171392 -> 37454 bytes docs/src/content/docs/faq.md | 4 ++-- docs/src/content/docs/guides/modify.md | 14 +++++++++----- docs/src/content/docs/guides/ui.md | 2 +- docs/src/content/docs/guides/workflows.md | 4 +++- .../src/content/docs/introduction/overview.md | 3 ++- docs/src/content/docs/reference/cli.md | 6 ++++-- 8 files changed, 25 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 3131de0..bd7489f 100644 --- a/README.md +++ b/README.md @@ -245,7 +245,7 @@ Interactively restructure the current stack. gh stack modify [flags] ``` -Opens a terminal UI for restructuring a stack. You can rename, drop, reorder, and fold branches into adjacent ones. All the changes are staged during the preview and applied at once on save. +Opens a terminal UI for restructuring a stack. You can drop, fold, insert, rename, and reorder branches. All the changes are staged during the preview and applied at once on save. If the stack of PRs has been created on GitHub, run `gh stack submit` afterwards to push the changes and recreate the stack. @@ -259,6 +259,7 @@ If the stack of PRs has been created on GitHub, run `gh stack submit` afterwards - **Drop** (`x`): Remove a branch and its commits from the stack. Local branch and associated PR are preserved. - **Fold down** (`d`): Absorb a branch's commits into the branch below (toward trunk). Folded branch removed from stack. - **Fold up** (`u`): Absorb a branch's commits into the branch above (away from trunk). Folded branch removed from stack. +- **Insert** (`i`/`I`): Insert a new empty branch into the stack. `i` inserts below the cursor; `I` inserts above. - **Reorder** (`Shift+↑`/`Shift+↓`): Move a branch up (away from trunk) or down (toward trunk) in the stack. - **Rename** (`r`): Rename a branch locally and in the stack metadata. - **Undo** (`z`): Undo the last staged action. @@ -272,7 +273,8 @@ If the stack of PRs has been created on GitHub, run `gh stack submit` afterwards | `c` | View commits | | `x` | Drop branch | | `r` | Rename branch | -| `u/d` | Fold branch up/down | +| `i/I` | Insert branch below/above | +| `d/u` | Fold branch down/up | | `Shift+↑`/`Shift+↓` | Move branch up/down | | `z` | Undo last action | | `Ctrl+S` | Apply all changes | diff --git a/docs/src/assets/screenshots/modify-stack-tui.png b/docs/src/assets/screenshots/modify-stack-tui.png index 2c631c50436d5ba08f698c8225691b0394e295ce..b13b870f0a52c7cabb3e4a3b993699b8bb3a7b94 100644 GIT binary patch literal 37454 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 A#sB~S literal 171392 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 z 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 pulls down a stack, with all its branches, from GitHub to your local machine. The CLI is not required to use Stacked PRs — the underlying git operations are standard. But it makes the workflow simpler, and you can create Stacked PRs from the CLI instead of the UI. diff --git a/docs/src/content/docs/reference/cli.md b/docs/src/content/docs/reference/cli.md index 13a4569..ca0a143 100644 --- a/docs/src/content/docs/reference/cli.md +++ b/docs/src/content/docs/reference/cli.md @@ -192,6 +192,8 @@ The command checks these conditions before opening the TUI: | Drop | `x` | Remove branch and its commits from stack. Local branch and associated PR are preserved. | | Fold down | `d` | Absorb commits into branch below (toward trunk). Folded branch removed from stack. | | Fold up | `u` | Absorb commits into branch above (away from trunk). Folded branch removed from stack. | +| Insert below | `i` | Insert a new empty branch below the cursor (toward trunk). | +| Insert above | `I` | Insert a new empty branch above the cursor (away from trunk). | | Move down | `Shift+↓` | Reorder branch down (toward trunk) in the stack | | Move up | `Shift+↑` | Reorder branch up (away from trunk) in the stack | | Rename | `r` | Rename the branch (opens inline prompt) | @@ -199,7 +201,7 @@ The command checks these conditions before opening the TUI: **Apply phase:** -When you press `Ctrl+S`, the staged changes are applied by renaming branches, folding/dropping branches, and running a cascading rebase to create a linear commit history with the desired stack state. +When you press `Ctrl+S`, the staged changes are applied by renaming branches, inserting new branches, folding/dropping branches, and running a cascading rebase to create a linear commit history with the desired stack state. If a rebase conflict occurs, you can: - Resolve conflicts, stage files, and run `gh stack modify --continue` @@ -234,7 +236,7 @@ You must have a branch from the stack checked out locally. The command targets t Deletes the stack on GitHub first, if it exists, then removes it from local tracking. If the remote deletion fails, the local state is left untouched so you can retry. Use `--local` to skip the remote deletion and only remove local tracking. -This is useful when you need to restructure a stack — remove a branch, reorder branches, rename branches, or make other large changes. After unstacking, use `gh stack init` to re-create the stack with the desired structure — existing branches are adopted automatically. +This is useful when you need to restructure a stack — remove a branch, insert a branch, reorder branches, rename branches, or make other large changes. After unstacking, use `gh stack init` to re-create the stack with the desired structure — existing branches are adopted automatically. | Flag | Description | |------|-------------| From f854ce83356587a440db511e972266a2dd9104e0 Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Sat, 23 May 2026 12:29:10 -0400 Subject: [PATCH 4/7] fix insert branch bugs in modify TUI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fix three bugs with the insert branch feature in the modify TUI, and adjust rename behavior on inserted nodes. ## Bug 1: False "moved" annotations on existing branches After inserting a branch, all branches below the insertion point displayed "↕ moved 1 layer down" annotations. This happened because `nodeAnnotation` and `toNodeData` compared each node's `OriginalPosition` against its raw array index, which gets shifted when an inserted node is added to the slice. Fix: introduce an `effectiveIdx` parameter that counts only non-inserted nodes, so position comparisons reflect the original ordering. The View loop computes effective indices by incrementing only for non-inserted nodes and passes them to the rendering functions. ## Bug 2: Header branch count inflated by staged inserts The branch count in the header ("N branches") included inserted placeholder nodes, making it appear as though the stack had grown before changes were applied. Fix: `buildHeaderConfig` now excludes `IsInserted` nodes from the branch count. The count reflects only the original branches in the stack. ## Bug 3: Operations allowed on inserted placeholder nodes Inserted nodes could be folded into other branches, which makes no sense for a placeholder with no commits. Additionally, the "last branch" guard counted inserted nodes as active, allowing users to drop all original branches and bypass the empty-stack check. Fix: - `fold()` rejects inserted nodes with a descriptive error message. - `toggleDrop()` on an inserted node removes it entirely and pops the original insert action from the undo stack (clean cancellation rather than a separate undo entry). - All three "active branch" guards (`toggleDrop`, `fold`, `tryApply`) now exclude `IsInserted` nodes, ensuring at least one original branch always remains in the stack. ## Rename on inserted branches Instead of blocking renames on inserted nodes, pressing `r` now enters rename mode and updates the insert action's name in place. The node's `Ref.Branch` and `PendingAction.NewName` are both updated directly — no separate rename action is created in the undo stack. This lets users fix a typo without having to drop and re-insert. ## Tests added - `TestInsertDoesNotShowMovedAnnotation` — verifies no false move annotations appear on existing branches after an insert - `TestBranchCountExcludesInserts` — verifies header count stays stable after insert - `TestCannotFoldInsertedBranch` — verifies fold is blocked - `TestCannotRenameInsertedBranch` — verifies rename updates the insert name in place - `TestDropInsertedBranchRemovesIt` — verifies drop removes the node - `TestDropInsertedBranchCanBeUndone` — verifies drop pops the original insert from the undo stack - `TestCannotDropAllOriginalBranchesWithInsert` — verifies the empty-stack guard excludes inserted nodes --- internal/tui/modifyview/model.go | 102 +++++++++++--- internal/tui/modifyview/model_test.go | 190 ++++++++++++++++++++++++++ 2 files changed, 272 insertions(+), 20 deletions(-) diff --git a/internal/tui/modifyview/model.go b/internal/tui/modifyview/model.go index 5d36bf0..6bbfba8 100644 --- a/internal/tui/modifyview/model.go +++ b/internal/tui/modifyview/model.go @@ -313,6 +313,24 @@ func (m Model) updateRename(msg tea.KeyMsg) (tea.Model, tea.Cmd) { } } + // For inserted nodes, update the insert action's name directly + // rather than creating a separate rename action. + if node.IsInserted { + oldInsertName := node.Ref.Branch + node.Ref.Branch = newName + node.PendingAction.NewName = newName + // Update the matching undo stack entry + for i := len(m.actionStack) - 1; i >= 0; i-- { + a := &m.actionStack[i] + if (a.Type == ActionInsertBelow || a.Type == ActionInsertAbove) && a.BranchName == oldInsertName { + a.BranchName = newName + break + } + } + m.renameMode = false + return m, nil + } + // Record undo action m.actionStack = append(m.actionStack, StagedAction{ Type: ActionRename, @@ -443,7 +461,7 @@ func (m Model) updateNormal(msg tea.KeyMsg) (tea.Model, tea.Cmd) { case key.Matches(msg, modifyKeys.MoveUp): if m.currentMode() == modeStructure { - m.statusMessage = "Cannot reorder while drops, folds, or renames are staged — undo them first" + m.statusMessage = "Cannot reorder while drops, folds, inserts, or renames are staged — undo them first" m.statusIsError = true return m, nil } @@ -452,7 +470,7 @@ func (m Model) updateNormal(msg tea.KeyMsg) (tea.Model, tea.Cmd) { case key.Matches(msg, modifyKeys.MoveDown): if m.currentMode() == modeStructure { - m.statusMessage = "Cannot reorder while drops, folds, or renames are staged — undo them first" + m.statusMessage = "Cannot reorder while drops, folds, inserts, or renames are staged — undo them first" m.statusIsError = true return m, nil } @@ -664,6 +682,30 @@ func (m *Model) toggleDrop() { return } + // Dropping an inserted node removes it entirely (undo the insert). + // Pop the original insert action from the undo stack rather than + // pushing a new entry — this makes the drop behave as a direct + // cancellation of the insert. + if node.IsInserted { + branchName := node.Ref.Branch + m.nodes = append(m.nodes[:m.cursor], m.nodes[m.cursor+1:]...) + // Remove the matching insert action from the undo stack + for i := len(m.actionStack) - 1; i >= 0; i-- { + a := m.actionStack[i] + if (a.Type == ActionInsertBelow || a.Type == ActionInsertAbove) && a.BranchName == branchName { + m.actionStack = append(m.actionStack[:i], m.actionStack[i+1:]...) + break + } + } + if m.cursor >= len(m.nodes) { + m.cursor = len(m.nodes) - 1 + } + if m.cursor < 0 { + m.cursor = 0 + } + return + } + if node.PendingAction != nil && node.PendingAction.Type == ActionDrop { // Undo drop m.actionStack = append(m.actionStack, StagedAction{ @@ -708,13 +750,13 @@ func (m *Model) toggleDrop() { } } - // Check if this would remove the last active branch + // Check if this would remove the last active original branch active := 0 for j, other := range m.nodes { if j == m.cursor { continue // skip the branch we're about to drop } - if !other.Removed && !other.Ref.IsMerged() { + if !other.Removed && !other.Ref.IsMerged() && !other.IsInserted { active++ } } @@ -740,6 +782,11 @@ func (m *Model) fold(action ActionType) { return } node := &m.nodes[m.cursor] + if node.IsInserted { + m.statusMessage = "Cannot fold an inserted branch — drop it with x to remove" + m.statusIsError = true + return + } if node.Ref.IsMerged() { m.statusMessage = "Cannot fold a merged branch" m.statusIsError = true @@ -803,13 +850,13 @@ func (m *Model) fold(action ActionType) { } } - // Check if this would remove the last active branch + // Check if this would remove the last active original branch active := 0 for j, other := range m.nodes { if j == m.cursor { continue } - if !other.Removed && !other.Ref.IsMerged() { + if !other.Removed && !other.Ref.IsMerged() && !other.IsInserted { active++ } } @@ -979,10 +1026,10 @@ func (m Model) tryApply() (tea.Model, tea.Cmd) { return m, nil } - // Ensure at least one non-removed, non-merged branch remains + // Ensure at least one non-removed, non-merged, non-inserted branch remains active := 0 for _, n := range m.nodes { - if !n.Removed && !n.Ref.IsMerged() { + if !n.Removed && !n.Ref.IsMerged() && !n.IsInserted { active++ } } @@ -1013,7 +1060,7 @@ func (m *Model) ensureVisible() { } func (m Model) nodeLineCount(idx int) int { - return shared.NodeLineCount(toNodeData(m.nodes[idx], idx)) + return shared.NodeLineCount(toNodeData(m.nodes[idx], idx, idx)) } func (m Model) contentViewHeight() int { @@ -1043,7 +1090,7 @@ func (m *Model) clampScroll() { func (m Model) handleMouseClick(screenX, screenY int) (tea.Model, tea.Cmd) { nodes := make([]shared.BranchNodeData, len(m.nodes)) for i, n := range m.nodes { - nodes[i] = toNodeData(n, i) + nodes[i] = toNodeData(n, i, i) } result := shared.HandleClick(screenX, screenY, nodes, m.width, m.height, m.scrollOffset, shared.ShouldShowHeader(m.width, m.height), false) @@ -1077,8 +1124,9 @@ func (m Model) handleMouseClick(screenX, screenY int) (tea.Model, tea.Cmd) { // toNodeData converts a ModifyBranchNode to shared.BranchNodeData, // applying drop/fold/move visual overrides. currentIdx is the node's -// current position in the list, used to detect moves. -func toNodeData(n ModifyBranchNode, currentIdx int) shared.BranchNodeData { +// current position in the list. effectiveIdx is the position among +// non-inserted nodes (used for move detection). +func toNodeData(n ModifyBranchNode, currentIdx int, effectiveIdx int) shared.BranchNodeData { data := shared.BranchNodeData{ Ref: n.Ref, IsCurrent: n.IsCurrent, @@ -1116,7 +1164,7 @@ func toNodeData(n ModifyBranchNode, currentIdx int) shared.BranchNodeData { } // Moved branch: purple solid connector (no dash, no strikethrough) - if n.PendingAction == nil && !n.Ref.IsMerged() && !n.IsInserted && n.OriginalPosition != currentIdx { + if n.PendingAction == nil && !n.Ref.IsMerged() && !n.IsInserted && n.OriginalPosition != effectiveIdx { c := movedConnectorStyle data.ConnectorStyleOverride = &c } @@ -1125,8 +1173,9 @@ func toNodeData(n ModifyBranchNode, currentIdx int) shared.BranchNodeData { } // nodeAnnotation builds an optional annotation from the node's pending action -// or its position change. currentIdx is the node's current position in the list. -func nodeAnnotation(n ModifyBranchNode, currentIdx int) *shared.NodeAnnotation { +// or its position change. effectiveIdx is the node's position among non-inserted +// nodes, used for move detection. +func nodeAnnotation(n ModifyBranchNode, effectiveIdx int) *shared.NodeAnnotation { if n.Ref.IsMerged() { return &shared.NodeAnnotation{Text: "🔒", Style: shared.DimStyle} } @@ -1147,8 +1196,8 @@ func nodeAnnotation(n ModifyBranchNode, currentIdx int) *shared.NodeAnnotation { } } // Show move annotation when position changed (even without explicit PendingAction) - if !n.Ref.IsMerged() && !n.IsInserted && n.OriginalPosition != currentIdx { - delta := n.OriginalPosition - currentIdx // positive = moved up (toward top) + if !n.Ref.IsMerged() && !n.IsInserted && n.OriginalPosition != effectiveIdx { + delta := n.OriginalPosition - effectiveIdx // positive = moved up (toward top) direction := "up" layers := delta if delta < 0 { @@ -1184,10 +1233,17 @@ func (m Model) View() string { // Build the scrollable branch list content var b strings.Builder + effectiveIdx := 0 for i := 0; i < len(m.nodes); i++ { - nodeData := toNodeData(m.nodes[i], i) + ei := effectiveIdx + if m.nodes[i].IsInserted { + ei = -1 // inserted nodes have no effective position + } else { + effectiveIdx++ + } + nodeData := toNodeData(m.nodes[i], i, ei) isFocused := i == m.cursor - annotation := nodeAnnotation(m.nodes[i], i) + annotation := nodeAnnotation(m.nodes[i], ei) shared.RenderNode(&b, nodeData, isFocused, m.width, annotation) } shared.RenderTrunk(&b, m.trunk.Branch) @@ -1247,7 +1303,13 @@ func (m Model) buildHeaderConfig() shared.HeaderConfig { } } - branchCount := len(m.nodes) + // Count only original branches (exclude staged inserts) + branchCount := 0 + for _, n := range m.nodes { + if !n.IsInserted { + branchCount++ + } + } branchInfo := fmt.Sprintf("%d branches", branchCount) if branchCount == 1 { branchInfo = "1 branch" diff --git a/internal/tui/modifyview/model_test.go b/internal/tui/modifyview/model_test.go index 0c3eda5..a2f29bc 100644 --- a/internal/tui/modifyview/model_test.go +++ b/internal/tui/modifyview/model_test.go @@ -1158,3 +1158,193 @@ func TestInsertAnnotation(t *testing.T) { require.NotNil(t, annotation) assert.Equal(t, "✚ insert", annotation.Text) } + +// --- Bug fix tests: insert should not cause false "moved" annotations --- + +func TestInsertDoesNotShowMovedAnnotation(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert below b (cursor at 1) + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + + // Nodes are now: a(0), b(1), new-branch(inserted), c(2) + // Verify c does NOT have a "moved" annotation + require.Len(t, m.nodes, 4) + assert.Equal(t, "c", m.nodes[3].Ref.Branch) + + // Use effectiveIdx=2 for c (skipping the inserted node) + annotation := nodeAnnotation(m.nodes[3], 2) + assert.Nil(t, annotation, "c should not show a moved annotation after insert") + + // Also verify a and b have no annotation + assert.Nil(t, nodeAnnotation(m.nodes[0], 0), "a should have no annotation") + assert.Nil(t, nodeAnnotation(m.nodes[1], 1), "b should have no annotation") +} + +// --- Bug fix tests: header branch count excludes inserts --- + +func TestBranchCountExcludesInserts(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + m.width = 120 + m.height = 40 + + // Branch count should be 3 + cfg := m.buildHeaderConfig() + assert.Contains(t, cfg.InfoLines[1].Label, "3 branches") + + // Insert a branch + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + + // Branch count should still be 3 (not 4) + cfg = m.buildHeaderConfig() + assert.Contains(t, cfg.InfoLines[1].Label, "3 branches") +} + +// --- Bug fix tests: operations blocked on inserted nodes --- + +func TestCannotRenameInsertedBranch(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert a branch and cursor lands on it + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + require.Equal(t, 1, m.cursor) + require.True(t, m.nodes[1].IsInserted) + + // Rename the inserted branch — should update the insert name directly + m = sendKey(t, m, runeKey('r')) + require.True(t, m.renameMode, "should enter rename mode on inserted branch") + + // Clear existing text and type new name + m = sendKey(t, m, tea.KeyMsg{Type: tea.KeyCtrlU}) // clear line + for _, r := range "better-name" { + m = sendKey(t, m, runeKey(r)) + } + m = sendKey(t, m, tea.KeyMsg{Type: tea.KeyEnter}) + assert.False(t, m.renameMode) + + // The node's branch name and insert action should be updated + assert.Equal(t, "better-name", m.nodes[1].Ref.Branch) + assert.True(t, m.nodes[1].IsInserted, "should still be marked as inserted") + assert.Equal(t, ActionInsertBelow, m.nodes[1].PendingAction.Type, "action type should still be insert") + assert.Equal(t, "better-name", m.nodes[1].PendingAction.NewName) + + // No separate rename action in the undo stack — only the original insert + for _, a := range m.actionStack { + assert.NotEqual(t, ActionRename, a.Type, "should not have a rename action in undo stack") + } +} + +func TestCannotFoldInsertedBranch(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert a branch + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + require.True(t, m.nodes[1].IsInserted) + + // Try fold down → should be blocked + m = sendKey(t, m, runeKey('d')) + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "inserted") + + // Try fold up → should be blocked + m = sendKey(t, m, runeKey('u')) + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "inserted") +} + +func TestDropInsertedBranchRemovesIt(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert a branch below a + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + require.Len(t, m.nodes, 4) + require.True(t, m.nodes[1].IsInserted) + + // Drop (x) the inserted branch → should remove it entirely + m = sendKey(t, m, runeKey('x')) + assert.Len(t, m.nodes, 3, "inserted node should be removed") + assert.Equal(t, "a", m.nodes[0].Ref.Branch) + assert.Equal(t, "b", m.nodes[1].Ref.Branch) + assert.Equal(t, "c", m.nodes[2].Ref.Branch) +} + +func TestDropInsertedBranchCanBeUndone(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert, then drop it + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + require.Len(t, m.nodes, 3) + + m = sendKey(t, m, runeKey('x')) + require.Len(t, m.nodes, 2) + require.Empty(t, m.actionStack, "undo stack should be empty after dropping an insert") + + // Dropping an inserted branch cancels the insert — undo stack should + // no longer contain the insert action. Pressing z undoes whatever came + // before the insert (i.e., nothing), not the drop itself. + m = sendKey(t, m, runeKey('z')) + assert.Len(t, m.nodes, 2, "undo should not re-insert — the drop cancelled the insert") + assert.Equal(t, "Nothing to undo", m.statusMessage) +} + +func TestCannotDropAllOriginalBranchesWithInsert(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert a new branch + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + require.Len(t, m.nodes, 3) + + // Drop a + m.cursor = 0 + m = sendKey(t, m, runeKey('x')) + require.NotNil(t, m.nodes[0].PendingAction) + assert.Equal(t, ActionDrop, m.nodes[0].PendingAction.Type) + + // Move to b and try to drop it — should be refused since only + // the inserted branch would remain + m = sendKey(t, m, runeKey('j')) + m = sendKey(t, m, runeKey('j')) + require.Equal(t, "b", m.nodes[2].Ref.Branch) + m = sendKey(t, m, runeKey('x')) + assert.Nil(t, m.nodes[2].PendingAction, "should not be able to drop the last original branch") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "last branch") +} From 3fd7f59ca50fad4052be5be3f4a128c5d4e0cc8c Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Sat, 23 May 2026 12:46:34 -0400 Subject: [PATCH 5/7] ensure cannot fold into an inserted branch --- internal/tui/modifyview/model.go | 128 ++++++++++++++ internal/tui/modifyview/model_test.go | 242 ++++++++++++++++++++++++-- 2 files changed, 352 insertions(+), 18 deletions(-) diff --git a/internal/tui/modifyview/model.go b/internal/tui/modifyview/model.go index 6bbfba8..169e81b 100644 --- a/internal/tui/modifyview/model.go +++ b/internal/tui/modifyview/model.go @@ -718,6 +718,8 @@ func (m *Model) toggleDrop() { // Check if any other branch has a fold targeting this branch. // A fold-up targets the branch above (lower index), fold-down // targets the branch below (higher index). + // Also check if dropping this branch would cause a fold to + // retarget to an inserted branch. for i, other := range m.nodes { if other.PendingAction == nil || i == m.cursor { continue @@ -727,6 +729,25 @@ func (m *Model) toggleDrop() { for j := i - 1; j >= 0; j-- { if !m.nodes[j].Removed && !m.nodes[j].Ref.IsMerged() { if j == m.cursor { + // This branch is the current target. Check what the + // next target would be after dropping it. + nextTarget := -1 + for k := j - 1; k >= 0; k-- { + if !m.nodes[k].Removed && !m.nodes[k].Ref.IsMerged() { + nextTarget = k + break + } + } + if nextTarget < 0 { + m.statusMessage = fmt.Sprintf("Cannot drop: %s is folding into this branch", other.Ref.Branch) + m.statusIsError = true + return + } + if m.nodes[nextTarget].IsInserted { + m.statusMessage = fmt.Sprintf("Cannot drop: %s would fold into an inserted branch", other.Ref.Branch) + m.statusIsError = true + return + } m.statusMessage = fmt.Sprintf("Cannot drop: %s is folding into this branch", other.Ref.Branch) m.statusIsError = true return @@ -740,6 +761,25 @@ func (m *Model) toggleDrop() { for j := i + 1; j < len(m.nodes); j++ { if !m.nodes[j].Removed && !m.nodes[j].Ref.IsMerged() { if j == m.cursor { + // This branch is the current target. Check what the + // next target would be after dropping it. + nextTarget := -1 + for k := j + 1; k < len(m.nodes); k++ { + if !m.nodes[k].Removed && !m.nodes[k].Ref.IsMerged() { + nextTarget = k + break + } + } + if nextTarget < 0 { + m.statusMessage = fmt.Sprintf("Cannot drop: %s is folding into this branch", other.Ref.Branch) + m.statusIsError = true + return + } + if m.nodes[nextTarget].IsInserted { + m.statusMessage = fmt.Sprintf("Cannot drop: %s would fold into an inserted branch", other.Ref.Branch) + m.statusIsError = true + return + } m.statusMessage = fmt.Sprintf("Cannot drop: %s is folding into this branch", other.Ref.Branch) m.statusIsError = true return @@ -816,6 +856,38 @@ func (m *Model) fold(action ActionType) { return } + // Check if the current node is the target of another fold — folding + // a branch that is receiving commits from another fold is not allowed. + for i, other := range m.nodes { + if other.PendingAction == nil || i == m.cursor { + continue + } + if other.PendingAction.Type == ActionFoldUp { + for j := i - 1; j >= 0; j-- { + if !m.nodes[j].Removed && !m.nodes[j].Ref.IsMerged() { + if j == m.cursor { + m.statusMessage = fmt.Sprintf("Cannot fold: %s is folding into this branch", other.Ref.Branch) + m.statusIsError = true + return + } + break + } + } + } + if other.PendingAction.Type == ActionFoldDown { + for j := i + 1; j < len(m.nodes); j++ { + if !m.nodes[j].Removed && !m.nodes[j].Ref.IsMerged() { + if j == m.cursor { + m.statusMessage = fmt.Sprintf("Cannot fold: %s is folding into this branch", other.Ref.Branch) + m.statusIsError = true + return + } + break + } + } + } + } + // Find the target branch var targetIdx int var found bool @@ -834,6 +906,11 @@ func (m *Model) fold(action ActionType) { m.statusIsError = true return } + if m.nodes[targetIdx].IsInserted { + m.statusMessage = "Cannot fold into an inserted branch" + m.statusIsError = true + return + } } else { // Fold up: target is the previous non-removed, non-merged node away from trunk (lower index) for i := m.cursor - 1; i >= 0; i-- { @@ -848,6 +925,19 @@ func (m *Model) fold(action ActionType) { m.statusIsError = true return } + if m.nodes[targetIdx].IsInserted { + m.statusMessage = "Cannot fold into an inserted branch" + m.statusIsError = true + return + } + } + + // Check if the target is already folding (mutual fold / chain fold) + target := &m.nodes[targetIdx] + if target.PendingAction != nil && (target.PendingAction.Type == ActionFoldDown || target.PendingAction.Type == ActionFoldUp) { + m.statusMessage = fmt.Sprintf("Cannot fold: %s is already folding in the opposite direction", target.Ref.Branch) + m.statusIsError = true + return } // Check if this would remove the last active original branch @@ -913,6 +1003,44 @@ func (m *Model) startInsert(direction ActionType) { return } + // Compute where the node would be inserted + insertIdx := m.cursor + if direction == ActionInsertBelow { + insertIdx = m.cursor + 1 + } + + // Check if inserting here would place the new branch between a + // folding branch and its target, making it the new fold target. + for i, other := range m.nodes { + if other.PendingAction == nil { + continue + } + if other.PendingAction.Type == ActionFoldDown { + for j := i + 1; j < len(m.nodes); j++ { + if !m.nodes[j].Removed && !m.nodes[j].Ref.IsMerged() { + if insertIdx > i && insertIdx <= j { + m.statusMessage = fmt.Sprintf("Cannot insert here: %s is folding into %s", other.Ref.Branch, m.nodes[j].Ref.Branch) + m.statusIsError = true + return + } + break + } + } + } + if other.PendingAction.Type == ActionFoldUp { + for j := i - 1; j >= 0; j-- { + if !m.nodes[j].Removed && !m.nodes[j].Ref.IsMerged() { + if insertIdx > j && insertIdx <= i { + m.statusMessage = fmt.Sprintf("Cannot insert here: %s is folding into %s", other.Ref.Branch, m.nodes[j].Ref.Branch) + m.statusIsError = true + return + } + break + } + } + } + } + m.insertMode = true m.insertDirection = direction m.insertInput.SetValue("") diff --git a/internal/tui/modifyview/model_test.go b/internal/tui/modifyview/model_test.go index a2f29bc..81675ad 100644 --- a/internal/tui/modifyview/model_test.go +++ b/internal/tui/modifyview/model_test.go @@ -205,11 +205,10 @@ func TestCannotFoldLastBranch(t *testing.T) { // --- Mutual fold test --- -func TestMutualFoldBlocked(t *testing.T) { +func TestFoldTargetOfFoldBlocked(t *testing.T) { // With 3 nodes A(0), B(1), C(2): fold B down into C, then try - // to fold C up. Since B is removed the target search for fold-up - // skips B and finds A. The fold into A would leave only 1 active - // branch (A) so it IS allowed (active >= 1). Verify the behavior. + // to fold C up. C is the target of B's fold, so C should not + // be allowed to fold. nodes := []ModifyBranchNode{ makeNode("a", false, 0), makeNode("b", true, 1), @@ -227,21 +226,11 @@ func TestMutualFoldBlocked(t *testing.T) { m = sendKey(t, m, runeKey('j')) require.Equal(t, 2, m.cursor) - // Try fold C up — B is removed so target becomes A. - // With only 2 nodes removed (B, C), A is the only active → active=1 (passes guard). + // Try fold C up — C is the target of B's fold-down, so blocked m = sendKey(t, m, runeKey('u')) - require.NotNil(t, m.nodes[2].PendingAction, "C should fold up into A since B is skipped") - assert.Equal(t, ActionFoldUp, m.nodes[2].PendingAction.Type) - assert.True(t, m.nodes[2].Removed) - - // Verify only A remains active - active := 0 - for _, n := range m.nodes { - if !n.Removed { - active++ - } - } - assert.Equal(t, 1, active, "only A should remain active") + assert.Nil(t, m.nodes[2].PendingAction, "C should not fold because B is folding into it") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "folding into this branch") } // --- Mode exclusivity tests --- @@ -1348,3 +1337,220 @@ func TestCannotDropAllOriginalBranchesWithInsert(t *testing.T) { assert.True(t, m.statusIsError) assert.Contains(t, m.statusMessage, "last branch") } + +func TestCannotFoldIntoInsertedBranch(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", true, 0), + makeNode("b", false, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert below a + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + // nodes: a(0), new-branch(1, inserted), b(2), c(3) + require.True(t, m.nodes[1].IsInserted) + + // Move cursor to a and try fold down — target would be the inserted branch + m.cursor = 0 + m = sendKey(t, m, runeKey('d')) + assert.Nil(t, m.nodes[0].PendingAction, "should not fold into an inserted branch") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "inserted") +} + +func TestCannotFoldUpIntoInsertedBranch(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Insert above b (at index 1) + m = sendKey(t, m, runeKey('I')) + m = simulateInsert(t, m, "new-branch") + // nodes: a(0), new-branch(1, inserted), b(2), c(3) + require.True(t, m.nodes[1].IsInserted) + + // Move cursor to b and try fold up — target would be the inserted branch + m.cursor = 2 + m = sendKey(t, m, runeKey('u')) + assert.Nil(t, m.nodes[2].PendingAction, "should not fold up into an inserted branch") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "inserted") +} + +func TestDropBlockedWhenFoldWouldRetargetToInserted(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold a down into b + m.cursor = 0 + m = sendKey(t, m, runeKey('d')) + require.NotNil(t, m.nodes[0].PendingAction) + assert.Equal(t, ActionFoldDown, m.nodes[0].PendingAction.Type) + + // Insert between b and c + m.cursor = 1 + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + // nodes: a(0, fold-down), b(1), new-branch(2, inserted), c(3) + + // Try to drop b — fold-down on a currently targets b. + // If b is dropped, fold target shifts to new-branch (inserted) → block + m.cursor = 1 + m = sendKey(t, m, runeKey('x')) + assert.Nil(t, m.nodes[1].PendingAction, "drop should be blocked") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "fold") +} + +func TestCannotMutualFold(t *testing.T) { + // Scenario: a folds down into b, then try to fold b up. + // Since a is Removed after folding, b's fold-up target skips a. + // But b is the target of a's fold — so b should not be allowed to fold. + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold a down (target = b) + m.cursor = 0 + m = sendKey(t, m, runeKey('d')) + require.NotNil(t, m.nodes[0].PendingAction) + assert.Equal(t, ActionFoldDown, m.nodes[0].PendingAction.Type) + + // Move to b — b is the target of a's fold. + // Try to fold b up — should be blocked because a is folding into b. + m.cursor = 1 + m = sendKey(t, m, runeKey('u')) + assert.Nil(t, m.nodes[1].PendingAction, "should not fold a branch that is receiving a fold") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "folding into this branch") +} + +func TestCannotMutualFold_FourNodes(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", false, 1), + makeNode("c", true, 2), + makeNode("d", false, 3), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold c down into d + m.cursor = 2 + m = sendKey(t, m, runeKey('d')) + require.NotNil(t, m.nodes[2].PendingAction) + assert.Equal(t, ActionFoldDown, m.nodes[2].PendingAction.Type) + + // Now try fold d up — d is c's fold target, so d can't fold + m.cursor = 3 + m = sendKey(t, m, runeKey('u')) + assert.Nil(t, m.nodes[3].PendingAction, "should not fold a branch that is receiving a fold") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "folding into this branch") + + // But folding d down should still work (it's not mutual) + m = sendKey(t, m, runeKey('d')) + // d has no branch below, so this should fail with "No branch below" + assert.True(t, m.statusIsError) +} + +func TestCannotFoldTargetOfFold(t *testing.T) { + // b folds up into a, then try to fold a down — a is receiving b's fold + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold b up into a + m.cursor = 1 + m = sendKey(t, m, runeKey('u')) + require.NotNil(t, m.nodes[1].PendingAction) + assert.Equal(t, ActionFoldUp, m.nodes[1].PendingAction.Type) + + // Try to fold a down — a is b's fold target, should be blocked + m.cursor = 0 + m = sendKey(t, m, runeKey('d')) + assert.Nil(t, m.nodes[0].PendingAction, "should not fold a branch that is receiving a fold") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "folding into this branch") +} + +func TestInsertBlockedBetweenFoldDownAndTarget(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold a down into b + m.cursor = 0 + m = sendKey(t, m, runeKey('d')) + require.NotNil(t, m.nodes[0].PendingAction) + assert.Equal(t, ActionFoldDown, m.nodes[0].PendingAction.Type) + + // Try inserting above b (between a and b) — should be blocked immediately + m.cursor = 1 + m = sendKey(t, m, runeKey('I')) + assert.False(t, m.insertMode, "should not enter insert mode") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "folding") +} + +func TestInsertBlockedBetweenFoldUpAndTarget(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold b up into a + m.cursor = 1 + m = sendKey(t, m, runeKey('u')) + require.NotNil(t, m.nodes[1].PendingAction) + assert.Equal(t, ActionFoldUp, m.nodes[1].PendingAction.Type) + + // Try inserting below a (between a and b) — should be blocked immediately + m.cursor = 0 + m = sendKey(t, m, runeKey('i')) + assert.False(t, m.insertMode, "should not enter insert mode") + assert.True(t, m.statusIsError) + assert.Contains(t, m.statusMessage, "folding") +} + +func TestInsertAllowedOutsideFoldRange(t *testing.T) { + nodes := []ModifyBranchNode{ + makeNode("a", false, 0), + makeNode("b", true, 1), + makeNode("c", false, 2), + makeNode("d", false, 3), + } + m := New(nodes, testTrunk, "1.0.0") + + // Fold a down into b + m.cursor = 0 + m = sendKey(t, m, runeKey('d')) + require.NotNil(t, m.nodes[0].PendingAction) + + // Inserting below c (between c and d) should be fine — outside fold range + m.cursor = 2 + m = sendKey(t, m, runeKey('i')) + m = simulateInsert(t, m, "new-branch") + assert.False(t, m.insertMode, "should succeed") + assert.Len(t, m.nodes, 5) + assert.Equal(t, "new-branch", m.nodes[3].Ref.Branch) +} From 9cced6af07f847310c5cef022b698a6fa8239348 Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Sat, 23 May 2026 22:47:12 -0400 Subject: [PATCH 6/7] rm dead code --- internal/modify/apply.go | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/internal/modify/apply.go b/internal/modify/apply.go index e239198..c4ac714 100644 --- a/internal/modify/apply.go +++ b/internal/modify/apply.go @@ -248,19 +248,6 @@ func ApplyPlan( var parentBranch string insertPos := -1 - // Build the active branch order from the stack (as of now, after renames) - activeIdx := 0 - for _, b := range s.Branches { - if b.IsMerged() { - continue - } - if b.Branch == newName { - // already added in a previous iteration — skip - break - } - activeIdx++ - } - // Determine where in s.Branches the new branch should go. // Walk the non-removed nodes to find the relative position. nonRemovedPos := 0 From 64f0b96c865c6b8d216cf9d6656f93822133c872 Mon Sep 17 00:00:00 2001 From: Sameen Karim Date: Sat, 23 May 2026 22:48:47 -0400 Subject: [PATCH 7/7] delete inserted branches during abort --- internal/modify/apply.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/modify/apply.go b/internal/modify/apply.go index c4ac714..5acd31b 100644 --- a/internal/modify/apply.go +++ b/internal/modify/apply.go @@ -1005,9 +1005,9 @@ func Unwind(cfg *config.Config, gitDir string, snapshot Snapshot, stackIndex int } } - // Clean up branches created by renames during the partial apply + // Clean up branches created by renames or inserts during the partial apply for _, action := range plan { - if action.Type == "rename" && action.NewName != "" { + if action.NewName != "" && (action.Type == "rename" || action.Type == "insert_below" || action.Type == "insert_above") { if !snapshotNames[action.NewName] && git.BranchExists(action.NewName) { _ = git.DeleteBranch(action.NewName, true) }