fix(notifications): clean up control flow and fix PR/Issue action confirmations

internal/tui/components/notificationssection/DESIGN.md

@@ -300,6 +300,22 @@ Similarly, when viewing an Issue notification, Issue-specific keybindings are av
 
 The `?` help display dynamically updates to show the applicable keybindings based on what type of notification content is being viewed.
 
+#### Confirmation Prompts for Destructive Actions
+
+When viewing a PR or Issue notification, destructive actions (close, reopen, merge, etc.) require confirmation before execution. This uses a footer-based confirmation mechanism separate from the section-level confirmation used in PR/Issue views:
+
+1. User presses action key (e.g., `x` for close)
+2. Footer displays: "Are you sure you want to close PR #123? (y/N)"
+3. User presses `y`, `Y`, or `Enter` to confirm, any other key cancels
+4. Action executes via the `tasks` package (same as PR/Issue views)
+
+This design is necessary because:
+- The notification section doesn't understand PR/Issue-specific actions
+- PR/Issue data is stored in `notificationView`, not in the section
+- Actions operate on the notification's subject PR/Issue, not the notification itself
+
+The `pendingNotificationAction` field in the Model tracks the pending action (e.g., "pr_close", "issue_reopen") until confirmed or cancelled.
+
 ## Configuration
 
 ### Search Section

internal/tui/components/notificationview/notificationview.go

@@ -38,6 +38,12 @@ func (m *Model) SetWidth(width int) {
 	m.width = width
 }
 
+func (m *Model) ResetSubject() {
+	m.subjectPR = nil
+	m.subjectIssue = nil
+	m.subjectId = ""
+}
+
 func (m *Model) SetSubjectPR(pr *prrow.Data, notificationId string) {
 	m.subjectPR = pr
 	m.subjectIssue = nil

internal/tui/components/prrow/prrow.go

@@ -185,7 +185,7 @@ func (pr *PullRequest) renderExtendedTitle(isSelected bool) string {
 		baseStyle = baseStyle.Foreground(pr.Ctx.Theme.SecondaryText).Background(pr.Ctx.Theme.SelectedBackground)
 	}
 
-	author := baseStyle.Bold(true).Foreground(pr.Ctx.Theme.FaintText).Render(fmt.Sprintf("@%s",
+	author := baseStyle.Bold(true).Render(fmt.Sprintf("@%s",
 		pr.Data.Primary.GetAuthor(pr.Ctx.Theme, pr.ShowAuthorIcon)))
 	top := lipgloss.JoinHorizontal(lipgloss.Top, pr.Data.Primary.Repository.NameWithOwner,
 		fmt.Sprintf(" #%d by %s", pr.Data.Primary.Number, author))

internal/tui/ui.go

@@ -3,6 +3,7 @@ package tui
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"reflect"
 	"runtime/debug"
 	"sort"
@@ -37,6 +38,7 @@ import (
 	"github.com/dlvhdr/gh-dash/v4/internal/tui/components/section"
 	"github.com/dlvhdr/gh-dash/v4/internal/tui/components/sidebar"
 	"github.com/dlvhdr/gh-dash/v4/internal/tui/components/tabs"
+	"github.com/dlvhdr/gh-dash/v4/internal/tui/components/tasks"
 	"github.com/dlvhdr/gh-dash/v4/internal/tui/constants"
 	"github.com/dlvhdr/gh-dash/v4/internal/tui/context"
 	"github.com/dlvhdr/gh-dash/v4/internal/tui/keys"
@@ -60,6 +62,12 @@ type Model struct {
 	ctx              *context.ProgramContext
 	taskSpinner      spinner.Model
 	tasks            map[string]context.Task
+
+	// Pending confirmation action for notification PR/Issue (close, merge, etc.)
+	// This is separate from section confirmation because PR/Issue actions in
+	// notification view need to be executed on the notification's subject PR/Issue,
+	// not on the notification section itself.
+	pendingNotificationAction string // "pr_close", "pr_merge", "issue_close", etc.
 }
 
 func NewModel(location config.Location) Model {
@@ -204,6 +212,17 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, nil
 		}
 
+		// Handle notification PR/Issue action confirmation
+		if m.pendingNotificationAction != "" {
+			if msg.String() == "y" || msg.String() == "Y" || msg.Type == tea.KeyEnter {
+				cmd = m.executeNotificationAction()
+			}
+			// Any other key cancels the confirmation
+			m.pendingNotificationAction = ""
+			m.footer.SetLeftSection("")
+			return m, cmd
+		}
+
 		switch {
 		case m.isUserDefinedKeybinding(msg):
 			cmd = m.executeKeybinding(msg.String())
@@ -488,9 +507,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 			// PR keybindings when viewing a PR notification
 			case m.notificationView.GetSubjectPR() != nil:
-				var prCmd tea.Cmd
-				m.prView, prCmd = m.prView.Update(msg)
-
+				// Check for PR actions first (before updating prView)
 				if !m.prView.IsTextInputBoxFocused() {
 					action := prview.MsgToAction(msg)
 					if action != nil {
@@ -509,30 +526,37 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 						case prview.PRActionDiff:
 							if pr := m.notificationView.GetSubjectPR(); pr != nil {
-								cmd = common.DiffPR(pr.GetNumber(), pr.GetRepoNameWithOwner(), m.ctx.Config.GetFullScreenDiffPagerEnv())
+								cmd = common.DiffPR(pr.GetNumber(), pr.GetRepoNameWithOwner(),
+									m.ctx.Config.GetFullScreenDiffPagerEnv())
 							}
 							return m, cmd
 
 						case prview.PRActionCheckout:
 							if pr := m.notificationView.GetSubjectPR(); pr != nil {
-								cmd, _ = notificationssection.CheckoutPR(m.ctx, pr.GetNumber(), pr.GetRepoNameWithOwner())
+								cmd, _ = notificationssection.CheckoutPR(
+									m.ctx, pr.GetNumber(), pr.GetRepoNameWithOwner())
 							}
 							return m, cmd
 
 						case prview.PRActionClose:
-							return m, m.promptConfirmation(currSection, "close")
+							cmd = m.promptConfirmationForNotificationPR("close")
+							return m, cmd
 
 						case prview.PRActionReady:
-							return m, m.promptConfirmation(currSection, "ready")
+							cmd = m.promptConfirmationForNotificationPR("ready")
+							return m, cmd
 
 						case prview.PRActionReopen:
-							return m, m.promptConfirmation(currSection, "reopen")
+							cmd = m.promptConfirmationForNotificationPR("reopen")
+							return m, cmd
 
 						case prview.PRActionMerge:
-							return m, m.promptConfirmation(currSection, "merge")
+							cmd = m.promptConfirmationForNotificationPR("merge")
+							return m, cmd
 
 						case prview.PRActionUpdate:
-							return m, m.promptConfirmation(currSection, "update")
+							cmd = m.promptConfirmationForNotificationPR("update")
+							return m, cmd
 
 						case prview.PRActionSummaryViewMore:
 							m.prView.SetSummaryViewMore()
@@ -542,8 +566,9 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					}
 				}
 
-				// Always sync and return after updating prView - needed for tab navigation
-				// which updates carousel state but doesn't return a command
+				// No action matched - update prView for navigation (tab switching, scrolling)
+				var prCmd tea.Cmd
+				m.prView, prCmd = m.prView.Update(msg)
 				m.syncSidebar()
 				return m, prCmd
 
@@ -568,37 +593,32 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 						return m, m.openSidebarForInput(m.issueSidebar.SetIsCommenting)
 
 					case issueview.IssueActionClose:
-						return m, m.promptConfirmation(currSection, "close")
+						cmd = m.promptConfirmationForNotificationIssue("close")
+						return m, cmd
 
 					case issueview.IssueActionReopen:
-						return m, m.promptConfirmation(currSection, "reopen")
+						cmd = m.promptConfirmationForNotificationIssue("reopen")
+						return m, cmd
 					}
 				}
 
-				if issueCmd != nil {
-					m.syncSidebar()
-					return m, issueCmd
-				}
+				// Sync sidebar and return issueCmd for navigation
+				m.syncSidebar()
+				return m, issueCmd
 
-			// Notification-specific keybindings
+			// Notification-specific keybindings (when not viewing PR/Issue content)
 			case key.Matches(msg, keys.NotificationKeys.View):
-				// View notification content and mark as read
 				cmds = append(cmds, m.loadNotificationContent())
 
 			case key.Matches(msg, keys.NotificationKeys.MarkAsDone):
-				// Already handled in the section's Update method
 				cmd = m.updateSection(currSection.GetId(), currSection.GetType(), msg)
 				return m, cmd
 
 			case key.Matches(msg, keys.NotificationKeys.MarkAllAsDone):
-				if currSection != nil {
-					currSection.SetPromptConfirmationAction("done_all")
-					cmd = currSection.SetIsPromptConfirmationShown(true)
-				}
+				cmd = m.promptConfirmation(currSection, "done_all")
 				return m, cmd
 
 			case key.Matches(msg, keys.NotificationKeys.Open):
-				// Handled in the section's Update method
 				cmd = m.updateSection(currSection.GetId(), currSection.GetType(), msg)
 				return m, cmd
 
@@ -929,6 +949,7 @@ func (m *Model) onViewedRowChanged() tea.Cmd {
 	sidebarCmd := m.syncSidebar()
 	enrichCmd := m.prView.EnrichCurrRow()
 	m.sidebar.ScrollToTop()
+	m.notificationView.ResetSubject()
 	return tea.Batch(sidebarCmd, enrichCmd)
 }
 
@@ -1315,7 +1336,8 @@ func (m *Model) setCurrentViewSections(newSections []section.Section) {
 
 	// Handle notifications view with search section like PRs/Issues
 	if m.ctx.View == config.NotificationsView {
-		missingSearchSection := len(newSections) == 0 || (len(newSections) > 0 && newSections[0].GetId() != 0)
+		missingSearchSection := len(newSections) == 0 ||
+			(len(newSections) > 0 && newSections[0].GetId() != 0)
 		s := make([]section.Section, 0)
 		if missingSearchSection {
 			// Check if we have an existing search section to preserve
@@ -1553,3 +1575,154 @@ func (m *Model) doUpdateFooterAtInterval() tea.Cmd {
 		},
 	)
 }
+
+// promptConfirmationForNotificationPR shows a confirmation prompt for PR actions
+// when viewing a PR from a notification. This is separate from section-based
+// confirmation because the notification section doesn't know about PR actions.
+func (m *Model) promptConfirmationForNotificationPR(action string) tea.Cmd {
+	pr := m.notificationView.GetSubjectPR()
+	if pr == nil {
+		return nil
+	}
+
+	m.pendingNotificationAction = "pr_" + action
+
+	// Show confirmation in footer
+	actionDisplay := action
+	if action == "ready" {
+		actionDisplay = "mark as ready"
+	}
+	prompt := fmt.Sprintf("Are you sure you want to %s PR #%d? (y/N)", actionDisplay, pr.GetNumber())
+	m.footer.SetLeftSection(m.ctx.Styles.ListViewPort.PagerStyle.Render(prompt))
+
+	return nil
+}
+
+// promptConfirmationForNotificationIssue shows a confirmation prompt for Issue actions
+// when viewing an Issue from a notification.
+func (m *Model) promptConfirmationForNotificationIssue(action string) tea.Cmd {
+	issue := m.notificationView.GetSubjectIssue()
+	if issue == nil {
+		return nil
+	}
+
+	m.pendingNotificationAction = "issue_" + action
+
+	// Show confirmation in footer
+	prompt := fmt.Sprintf("Are you sure you want to %s Issue #%d? (y/N)", action, issue.Number)
+	m.footer.SetLeftSection(m.ctx.Styles.ListViewPort.PagerStyle.Render(prompt))
+
+	return nil
+}
+
+// executeNotificationAction executes the pending PR/Issue action after user confirmation
+func (m *Model) executeNotificationAction() tea.Cmd {
+	action := m.pendingNotificationAction
+	if action == "" {
+		return nil
+	}
+
+	// Create a section identifier for the notification section
+	currSection := m.getCurrSection()
+	sid := tasks.SectionIdentifier{Id: 0, Type: notificationssection.SectionType}
+	if currSection != nil {
+		sid.Id = currSection.GetId()
+	}
+
+	switch action {
+	case "pr_close":
+		if pr := m.notificationView.GetSubjectPR(); pr != nil {
+			return tasks.ClosePR(m.ctx, sid, pr)
+		}
+	case "pr_reopen":
+		if pr := m.notificationView.GetSubjectPR(); pr != nil {
+			return tasks.ReopenPR(m.ctx, sid, pr)
+		}
+	case "pr_ready":
+		if pr := m.notificationView.GetSubjectPR(); pr != nil {
+			return tasks.PRReady(m.ctx, sid, pr)
+		}
+	case "pr_merge":
+		if pr := m.notificationView.GetSubjectPR(); pr != nil {
+			return tasks.MergePR(m.ctx, sid, pr)
+		}
+	case "pr_update":
+		if pr := m.notificationView.GetSubjectPR(); pr != nil {
+			return tasks.UpdatePR(m.ctx, sid, pr)
+		}
+	case "issue_close":
+		if issue := m.notificationView.GetSubjectIssue(); issue != nil {
+			return m.closeIssue(sid, issue)
+		}
+	case "issue_reopen":
+		if issue := m.notificationView.GetSubjectIssue(); issue != nil {
+			return m.reopenIssue(sid, issue)
+		}
+	}
+
+	return nil
+}
+
+// closeIssue executes the close action for an Issue using gh CLI
+func (m *Model) closeIssue(sid tasks.SectionIdentifier, issue *data.IssueData) tea.Cmd {
+	issueNumber := issue.Number
+	repoName := issue.GetRepoNameWithOwner()
+	taskId := fmt.Sprintf("issue_close_%d", issueNumber)
+	task := context.Task{
+		Id:           taskId,
+		StartText:    fmt.Sprintf("Closing Issue #%d", issueNumber),
+		FinishedText: fmt.Sprintf("Issue #%d has been closed", issueNumber),
+		State:        context.TaskStart,
+		Error:        nil,
+	}
+	startCmd := m.ctx.StartTask(task)
+	return tea.Batch(startCmd, func() tea.Msg {
+		c := exec.Command(
+			"gh",
+			"issue",
+			"close",
+			fmt.Sprint(issueNumber),
+			"-R",
+			repoName,
+		)
+		err := c.Run()
+		return constants.TaskFinishedMsg{
+			TaskId:      taskId,
+			SectionId:   sid.Id,
+			SectionType: sid.Type,
+			Err:         err,
+		}
+	})
+}
+
+// reopenIssue executes the reopen action for an Issue using gh CLI
+func (m *Model) reopenIssue(sid tasks.SectionIdentifier, issue *data.IssueData) tea.Cmd {
+	issueNumber := issue.Number
+	repoName := issue.GetRepoNameWithOwner()
+	taskId := fmt.Sprintf("issue_reopen_%d", issueNumber)
+	task := context.Task{
+		Id:           taskId,
+		StartText:    fmt.Sprintf("Reopening Issue #%d", issueNumber),
+		FinishedText: fmt.Sprintf("Issue #%d has been reopened", issueNumber),
+		State:        context.TaskStart,
+		Error:        nil,
+	}
+	startCmd := m.ctx.StartTask(task)
+	return tea.Batch(startCmd, func() tea.Msg {
+		c := exec.Command(
+			"gh",
+			"issue",
+			"reopen",
+			fmt.Sprint(issueNumber),
+			"-R",
+			repoName,
+		)
+		err := c.Run()
+		return constants.TaskFinishedMsg{
+			TaskId:      taskId,
+			SectionId:   sid.Id,
+			SectionType: sid.Type,
+			Err:         err,
+		}
+	})
+}