feat(git): context menu for branch actions with upstream

Branch picker previously emitted a single branchSelected signal,
forcing the caller to guess intent. This replaces that with explicit
signals and a per-item context menu so each action is unambiguous.

- Replace branchSelected with checkoutRequested, add setUpstreamRequested
- createBranchRequested gains setUpstream flag; GitController wires
  configBranchTracking automatically after CreateBranch succeeds
- Add SetUpstream and ConfigTracking op kinds; ConfigTracking failures
  are best-effort (non-fatal, same as NumstatStaged)
- detachedHead flag threaded through setBranches so the picker can
  reflect HEAD state correctly
- Status label moved above the segmented bar so it is always visible;
  gains hide/show lifecycle and a 2 s success-flash timer
- History busyChanged signal drives the shared status label so loading
  state is surfaced consistently alongside git op state
- switchBranch policy changed to SwitchAnyway on direct checkout to
  avoid silent no-ops when working tree is clean

Author: nullmastermind

src/git/BranchPickerPopup.cpp

@@ -18,19 +18,26 @@
 
 #include "BranchPickerPopup.h"
 
+#include <QCheckBox>
+#include <QDialog>
+#include <QDialogButtonBox>
+#include <QFormLayout>
 #include <QGuiApplication>
 #include <QKeyEvent>
+#include <QLabel>
 #include <QLineEdit>
 #include <QListView>
+#include <QMenu>
+#include <QPushButton>
 #include <QRegularExpression>
 #include <QScreen>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QVBoxLayout>
 
 namespace {
-constexpr int RoleKind = Qt::UserRole + 1;    // 0 = local, 1 = remote, 2 = create-current, 3 = create-default
-constexpr int RolePayload = Qt::UserRole + 2; // branch name or create base
+constexpr int RoleKind = Qt::UserRole + 1;    // 0 = local, 1 = remote
+constexpr int RolePayload = Qt::UserRole + 2; // branch name
 }
 
 QString BranchPickerPopup::sanitizeBranchName(const QString &raw)
@@ -72,16 +79,18 @@ BranchPickerPopup::BranchPickerPopup(QWidget *parent)
     setMinimumHeight(360);
 
     connect(m_filter, &QLineEdit::textChanged, this, &BranchPickerPopup::rebuild);
-    connect(m_list, &QAbstractItemView::activated, this, &BranchPickerPopup::onActivated);
+    connect(m_list, &QAbstractItemView::clicked, this, &BranchPickerPopup::onActivated);
 }
 
 void BranchPickerPopup::setBranches(const QStringList &local, const QStringList &remote,
-                                    const QString &current, const QString &defaultBranch)
+                                    const QString &current, const QString &defaultBranch,
+                                    bool detachedHead)
 {
     m_local = local;
     m_remote = remote;
     m_current = current;
     m_default = defaultBranch;
+    m_detachedHead = detachedHead;
     m_filter->clear();
     rebuild();
 }
@@ -112,6 +121,7 @@ void BranchPickerPopup::rebuild()
         auto f = it->font(); f.setBold(true); it->setFont(f);
         m_model->appendRow(it);
     };
+
     auto matches = [&](const QString &name) {
         return q.isEmpty() || name.toLower().contains(qLower);
     };
@@ -124,8 +134,8 @@ void BranchPickerPopup::rebuild()
         addHeader(tr("── Local ──"));
         for (const auto &b : locals) {
             QString display = b;
-            if (b == m_current) display = QStringLiteral("✓ ") + b;
-            else                display = QStringLiteral("   ") + b;
+            if (b == m_current) display = QStringLiteral("✓ ") + b + QStringLiteral("  ›");
+            else                display = QStringLiteral("   ") + b + QStringLiteral("  ›");
             auto *it = new QStandardItem(display);
             it->setData(0, RoleKind);
             it->setData(b, RolePayload);
@@ -139,42 +149,20 @@ void BranchPickerPopup::rebuild()
     if (!remotes.isEmpty()) {
         addHeader(tr("── Remote ──"));
         for (const auto &b : remotes) {
-            auto *it = new QStandardItem(QStringLiteral("   ") + b);
+            auto *it = new QStandardItem(QStringLiteral("   ") + b + QStringLiteral("  ›"));
             it->setData(1, RoleKind);
             it->setData(b, RolePayload);
             m_model->appendRow(it);
             sawAny = true;
         }
     }
 
-    // "Create branch from query" — only when query has no exact local match.
-    const QString sanitized = sanitizeBranchName(q);
-    if (!sanitized.isEmpty() && !m_local.contains(sanitized)) {
-        addHeader(tr("── Create ──"));
-        QString fromCurrent = m_current.isEmpty() ? m_default : m_current;
-        if (!fromCurrent.isEmpty()) {
-            auto *it = new QStandardItem(tr("+ Create \"%1\" from %2").arg(sanitized, fromCurrent));
-            it->setData(2, RoleKind);
-            it->setData(sanitized, RolePayload);
-            m_model->appendRow(it);
-            sawAny = true;
-        }
-        if (!m_default.isEmpty() && m_default != fromCurrent) {
-            auto *it = new QStandardItem(tr("+ Create \"%1\" from %2 (default)").arg(sanitized, m_default));
-            it->setData(3, RoleKind);
-            it->setData(sanitized, RolePayload);
-            m_model->appendRow(it);
-            sawAny = true;
-        }
-    }
-
     if (!sawAny) {
         auto *it = new QStandardItem(tr("No matches"));
         it->setEnabled(false);
         m_model->appendRow(it);
     }
 
-    // Auto-select first enabled item.
     for (int r = 0; r < m_model->rowCount(); ++r) {
         if (m_model->item(r)->isEnabled()) {
             m_list->setCurrentIndex(m_model->index(r, 0));
@@ -186,22 +174,95 @@ void BranchPickerPopup::rebuild()
 void BranchPickerPopup::onActivated(const QModelIndex &index)
 {
     if (!index.isValid()) return;
+    auto *it = m_model->itemFromIndex(index);
+    if (!it || !it->isEnabled()) return;
+    showItemMenu(index);
+}
+
+void BranchPickerPopup::showItemMenu(const QModelIndex &index)
+{
     auto *it = m_model->itemFromIndex(index);
     if (!it || !it->isEnabled()) return;
     const int kind = it->data(RoleKind).toInt();
     const QString payload = it->data(RolePayload).toString();
-    if (kind == 0) {
-        emit branchSelected(payload);
-        close();
-    } else if (kind == 1) {
-        emit branchSelected(payload);
-        close();
-    } else if (kind == 2) {
-        emit createBranchRequested(payload, m_current.isEmpty() ? m_default : m_current);
-        close();
-    } else if (kind == 3) {
-        emit createBranchRequested(payload, m_default);
-        close();
+    const bool isRemote = (kind == 1);
+    const bool isCurrent = (!isRemote && payload == m_current);
+
+    QMenu menu(this);
+
+    if (!isCurrent) {
+        QAction *aCheckout = menu.addAction(tr("&Checkout"));
+        connect(aCheckout, &QAction::triggered, this, [this, payload]() {
+            emit checkoutRequested(payload);
+            close();
+        });
+    }
+
+    QAction *aNewBranch = menu.addAction(tr("&New Branch…"));
+    connect(aNewBranch, &QAction::triggered, this, [this, payload]() {
+        showNewBranchDialog(payload);
+    });
+
+    if (isRemote && !m_detachedHead) {
+        QAction *aSetUpstream = menu.addAction(tr("&Set as Upstream"));
+        connect(aSetUpstream, &QAction::triggered, this, [this, payload]() {
+            emit setUpstreamRequested(payload);
+            close();
+        });
+    }
+
+    const QRect itemRect = m_list->visualRect(index);
+    const QPoint pos = m_list->mapToGlobal(itemRect.topRight());
+    menu.exec(pos);
+}
+
+void BranchPickerPopup::showNewBranchDialog(const QString &base)
+{
+    QDialog dlg(this);
+    dlg.setWindowTitle(tr("New Branch from %1").arg(base));
+    dlg.setMinimumWidth(320);
+
+    auto *layout = new QVBoxLayout(&dlg);
+
+    auto *nameEdit = new QLineEdit(&dlg);
+    nameEdit->setPlaceholderText(tr("Branch name"));
+
+    auto *previewLabel = new QLabel(&dlg);
+    previewLabel->setStyleSheet(QStringLiteral("color: gray; font-size: 11px;"));
+
+    auto *upstreamCheck = new QCheckBox(tr("Set upstream tracking"), &dlg);
+    upstreamCheck->setChecked(true);
+
+    auto *buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);
+    buttons->button(QDialogButtonBox::Ok)->setEnabled(false);
+
+    layout->addWidget(new QLabel(tr("Create new branch from <b>%1</b>:").arg(base), &dlg));
+    layout->addWidget(nameEdit);
+    layout->addWidget(previewLabel);
+    layout->addWidget(upstreamCheck);
+    layout->addWidget(buttons);
+
+    connect(nameEdit, &QLineEdit::textChanged, &dlg, [&](const QString &text) {
+        const QString sanitized = sanitizeBranchName(text);
+        if (sanitized.isEmpty()) {
+            previewLabel->clear();
+            buttons->button(QDialogButtonBox::Ok)->setEnabled(false);
+        } else {
+            previewLabel->setText(tr("→ %1").arg(sanitized));
+            buttons->button(QDialogButtonBox::Ok)->setEnabled(!m_local.contains(sanitized));
+        }
+    });
+    connect(buttons, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
+    connect(buttons, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
+
+    nameEdit->setFocus();
+
+    if (dlg.exec() == QDialog::Accepted) {
+        const QString name = sanitizeBranchName(nameEdit->text());
+        if (!name.isEmpty()) {
+            emit createBranchRequested(name, base, upstreamCheck->isChecked());
+            close();
+        }
     }
 }
 

src/git/BranchPickerPopup.h

@@ -35,16 +35,16 @@ class BranchPickerPopup : public QWidget
     void setBranches(const QStringList &local,
                      const QStringList &remote,
                      const QString &current,
-                     const QString &defaultBranch = QStringLiteral("main"));
+                     const QString &defaultBranch = QStringLiteral("main"),
+                     bool detachedHead = false);
     void popupAt(const QPoint &globalPos);
 
     static QString sanitizeBranchName(const QString &raw);
 
 signals:
-    // For local existing branch: name = "feature/x"
-    // For remote: name = "origin/main" — caller will translate to local checkout.
-    void branchSelected(const QString &name);
-    void createBranchRequested(const QString &name, const QString &base);
+    void checkoutRequested(const QString &name);
+    void createBranchRequested(const QString &name, const QString &base, bool setUpstream);
+    void setUpstreamRequested(const QString &remoteBranch);
 
 protected:
     bool eventFilter(QObject *o, QEvent *e) override;
@@ -54,13 +54,17 @@ private slots:
     void onActivated(const QModelIndex &index);
 
 private:
+    void showItemMenu(const QModelIndex &index);
+    void showNewBranchDialog(const QString &base);
+
     QLineEdit *m_filter;
     QListView *m_list;
     QStandardItemModel *m_model;
     QString m_current;
     QString m_default;
     QStringList m_local;
     QStringList m_remote;
+    bool m_detachedHead = false;
 };
 
 #endif // BRANCH_PICKER_POPUP_H

src/git/GitController.cpp

@@ -357,7 +357,7 @@ void GitController::switchBranch(const QString &name, BranchSwitchPolicy policy)
     enqueue(op);
 }
 
-void GitController::createBranch(const QString &name, const QString &base, bool checkout)
+void GitController::createBranch(const QString &name, const QString &base, bool checkout, bool setUpstream)
 {
     if (m_currentRepo.isEmpty() || name.isEmpty()) return;
     Op op;
@@ -369,9 +369,49 @@ void GitController::createBranch(const QString &name, const QString &base, bool
     if (!base.isEmpty()) op.argv.append(base);
     op.timeoutMs = kTimeoutNormal;
     op.humanName = tr_("Creating branch");
+    op.meta.insert(QStringLiteral("newBranch"), name);
+    op.meta.insert(QStringLiteral("base"), base);
+    op.meta.insert(QStringLiteral("setUpstream"), setUpstream);
     enqueue(op);
 }
 
+void GitController::setUpstream(const QString &remoteBranch)
+{
+    if (m_currentRepo.isEmpty() || m_currentBranch.isEmpty()) return;
+    Op op;
+    op.kind = OpKind::SetUpstream;
+    op.argv = { QStringLiteral("-C"), m_currentRepo,
+                QStringLiteral("branch"), QStringLiteral("--set-upstream-to"),
+                remoteBranch };
+    op.timeoutMs = kTimeoutShort;
+    op.humanName = tr_("Setting upstream");
+    enqueue(op);
+}
+
+void GitController::configBranchTracking(const QString &branchName, const QString &remote)
+{
+    if (m_currentRepo.isEmpty() || branchName.isEmpty() || remote.isEmpty()) return;
+    Op op;
+    op.kind = OpKind::ConfigTracking;
+    op.argv = { QStringLiteral("-C"), m_currentRepo,
+                QStringLiteral("config"),
+                QStringLiteral("branch.%1.remote").arg(branchName),
+                remote };
+    op.timeoutMs = kTimeoutShort;
+    op.humanName = tr_("Configuring tracking");
+    enqueue(op);
+
+    Op op2;
+    op2.kind = OpKind::ConfigTracking;
+    op2.argv = { QStringLiteral("-C"), m_currentRepo,
+                 QStringLiteral("config"),
+                 QStringLiteral("branch.%1.merge").arg(branchName),
+                 QStringLiteral("refs/heads/%1").arg(branchName) };
+    op2.timeoutMs = kTimeoutShort;
+    op2.humanName = tr_("Configuring tracking");
+    enqueue(op2);
+}
+
 void GitController::fetch(const QString &remote)
 {
     if (m_currentRepo.isEmpty()) return;
@@ -801,7 +841,7 @@ void GitController::onRunFinished(int exit, const QByteArray &out, const QByteAr
         // Numstat ops are best-effort — a failure (e.g. unborn HEAD edge cases,
         // missing object) shouldn't tip the controller into Error or block UI.
         if (kind == OpKind::NumstatStaged || kind == OpKind::NumstatUnstaged
-            || kind == OpKind::SubmoduleNumstat) {
+            || kind == OpKind::SubmoduleNumstat || kind == OpKind::ConfigTracking) {
             popAndAdvance();
             return;
         }
@@ -884,12 +924,33 @@ void GitController::onRunFinished(int exit, const QByteArray &out, const QByteAr
         case OpKind::Commit:
         case OpKind::SwitchBranch:
         case OpKind::CreateBranch:
+        case OpKind::SetUpstream:
+        case OpKind::ConfigTracking:
         case OpKind::Stash:
         case OpKind::Fetch:
         case OpKind::Pull:
         case OpKind::Push:
         case OpKind::ForcePush:
             if (kind == OpKind::Commit) emit commitSucceeded();
+            if (kind == OpKind::CreateBranch) {
+                const QString newBranch = m_current.meta.value(QStringLiteral("newBranch")).toString();
+                const QString base = m_current.meta.value(QStringLiteral("base")).toString();
+                const bool wantUpstream = m_current.meta.value(QStringLiteral("setUpstream")).toBool();
+                if (!newBranch.isEmpty() && wantUpstream) {
+                    QString remote = QStringLiteral("origin");
+                    for (const auto &r : m_remoteList) {
+                        if (base.startsWith(r + QLatin1Char('/'))) {
+                            remote = r;
+                            break;
+                        }
+                    }
+                    if (!m_remoteList.isEmpty()) {
+                        if (!m_remoteList.contains(remote))
+                            remote = m_remoteList.first();
+                        configBranchTracking(newBranch, remote);
+                    }
+                }
+            }
             if (kind == OpKind::Commit || kind == OpKind::Pull) {
                 // Commit and Pull move the current branch tip (the ref file
                 // content changes, e.g. .git/refs/heads/main). GitWatcher only

src/git/GitController.h

@@ -74,6 +74,7 @@ class GitController : public QObject
     bool isEmptyRepo() const { return m_empty; }
     bool hasRemote() const { return !m_remoteList.isEmpty(); }
     bool hasConflicts() const;
+    QString runningOperationName() const { return m_busy ? m_current.humanName : QString(); }
 
 public slots:
     void initialize();
@@ -85,7 +86,9 @@ public slots:
     void unstageAll();
     void commit(const QString &message, bool amend, bool signoff, bool trackedOnly);
     void switchBranch(const QString &name, BranchSwitchPolicy policy);
-    void createBranch(const QString &name, const QString &base, bool checkout);
+    void createBranch(const QString &name, const QString &base, bool checkout, bool setUpstream = true);
+    void setUpstream(const QString &remoteBranch);
+    void configBranchTracking(const QString &branchName, const QString &remote);
     void fetch(const QString &remote = {});
     void pull(bool rebase);
     void push(const QString &remote = {}, bool setUpstream = false);
@@ -148,7 +151,7 @@ public slots:
         CatFileBlob,
         Stage, Unstage, StageAll, UnstageAll,
         Commit,
-        SwitchBranch, CreateBranch, Stash,
+        SwitchBranch, CreateBranch, SetUpstream, ConfigTracking, Stash,
         Fetch, Pull, Push, ForcePush
     };
     struct Op {