feat: merge from remote tracking branch in Update from Default Branch

Instead of merging the local default branch (e.g. `main`), merge the
remote tracking branch (e.g. `origin/main`) after fetching. This avoids
altering local branches as a side effect of the update operation.

Changes:
- Fetch without fast-forwarding local branches before merging
- Find and merge the remote tracking branch instead of the local one
- Update the menu label to show the remote ref (e.g. "Update from origin/main")

Follow-up to PR #111 as suggested by @pol-rivero.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: guplem

app/src/lib/stores/app-store.ts

@@ -2590,9 +2590,16 @@ export class AppStore extends TypedBaseStore<IAppState> {
 
     let contributionTargetDefaultBranch: string | undefined
     if (selectedRepository instanceof Repository) {
+      const targetBranch = findContributionTargetDefaultBranch(
+        selectedRepository,
+        branchesState
+      )
+      // Show the remote tracking branch name (e.g. "origin/main") in the
+      // menu label, since we merge from the remote ref, not the local one.
       contributionTargetDefaultBranch =
-        findContributionTargetDefaultBranch(selectedRepository, branchesState)
-          ?.name ?? undefined
+        targetBranch !== null
+          ? targetBranch.upstream ?? targetBranch.name
+          : undefined
     }
 
     // From the menu, we'll offer to force-push whenever it's possible, regardless
@@ -5377,6 +5384,27 @@ export class AppStore extends TypedBaseStore<IAppState> {
     })
   }
 
+  /**
+   * Fetch all relevant remotes without fast-forwarding local branches.
+   *
+   * This updates remote tracking refs (e.g. origin/main) but leaves local
+   * branches untouched. Useful when you only need to merge from a remote
+   * ref without altering the local branch state.
+   */
+  public _fetchWithoutFastForward(
+    repository: Repository,
+    fetchType: FetchType
+  ): Promise<void> {
+    return this.withRefreshedGitHubRepository(repository, repository => {
+      return this.performFetch(
+        repository,
+        fetchType,
+        undefined,
+        true
+      )
+    })
+  }
+
   /**
    * Fetch a particular remote in a repository.
    *
@@ -5403,7 +5431,8 @@ export class AppStore extends TypedBaseStore<IAppState> {
   private async performFetch(
     repository: Repository,
     fetchType: FetchType,
-    remotes?: IRemote[]
+    remotes?: IRemote[],
+    skipFastForward?: boolean
   ): Promise<void> {
     await this.withPushPullFetch(repository, async () => {
       const gitStore = this.gitStoreCache.get(repository)
@@ -5434,14 +5463,16 @@ export class AppStore extends TypedBaseStore<IAppState> {
           ? 'Refreshing Repository'
           : 'Refreshing repository'
 
-        this.updatePushPullFetchProgress(repository, {
-          kind: 'generic',
-          title: refreshTitle,
-          description: 'Fast-forwarding branches',
-          value: fetchWeight,
-        })
+        if (!skipFastForward) {
+          this.updatePushPullFetchProgress(repository, {
+            kind: 'generic',
+            title: refreshTitle,
+            description: 'Fast-forwarding branches',
+            value: fetchWeight,
+          })
 
-        await this.fastForwardBranches(repository)
+          await this.fastForwardBranches(repository)
+        }
 
         this.updatePushPullFetchProgress(repository, {
           kind: 'generic',

app/src/ui/app.tsx

@@ -33,7 +33,7 @@ import {
   getNonForkGitHubRepository,
   isRepositoryWithGitHubRepository,
 } from '../models/repository'
-import { Branch } from '../models/branch'
+import { Branch, BranchType } from '../models/branch'
 import { PreferencesTab } from '../models/preferences'
 import { findItemByAccessKey, itemIsSelectable } from '../models/app-menu'
 import { Account, isDotComAccount } from '../models/account'
@@ -635,7 +635,7 @@ export class App extends React.Component<IAppProps, IAppState> {
     updateStore.checkForUpdates(inBackground, skipGuidCheck)
   }
 
-  private updateBranchWithContributionTargetBranch() {
+  private async updateBranchWithContributionTargetBranch() {
     const { selectedState } = this.state
     if (
       selectedState == null ||
@@ -654,20 +654,61 @@ export class App extends React.Component<IAppProps, IAppState> {
       return
     }
 
+    // Fetch from the remote to update the remote tracking ref (e.g.
+    // origin/main) without fast-forwarding local branches.
+    await this.props.dispatcher.fetchWithoutFastForward(
+      repository,
+      FetchType.UserInitiatedTask
+    )
+
+    // Merge the remote tracking branch (e.g. origin/main) instead of the
+    // local branch, so that the local default branch is not altered as a
+    // side effect.
+    const branchToMerge = this.getRemoteTrackingBranch(
+      contributionTargetDefaultBranch,
+      state.branchesState.allBranches
+    )
+
     this.props.dispatcher.initializeMergeOperation(
       repository,
       false,
-      contributionTargetDefaultBranch
+      branchToMerge
     )
 
     const { mergeStatus } = state.compareState
     this.props.dispatcher.mergeBranch(
       repository,
-      contributionTargetDefaultBranch,
+      branchToMerge,
       mergeStatus
     )
   }
 
+  /**
+   * Returns the remote tracking branch for a given branch if available.
+   * For remote branches, returns the branch itself.
+   * For local branches, finds the corresponding remote branch in allBranches.
+   * Falls back to the original branch if no remote tracking branch is found.
+   */
+  private getRemoteTrackingBranch(
+    branch: Branch,
+    allBranches: ReadonlyArray<Branch>
+  ): Branch {
+    if (branch.type === BranchType.Remote) {
+      return branch
+    }
+
+    const upstream = branch.upstream
+    if (upstream === null) {
+      return branch
+    }
+
+    return (
+      allBranches.find(
+        b => b.type === BranchType.Remote && b.name === upstream
+      ) ?? branch
+    )
+  }
+
   private mergeBranch(isSquash: boolean = false) {
     const selectedState = this.state.selectedState
     if (

app/src/ui/dispatcher/dispatcher.ts

@@ -747,6 +747,17 @@ export class Dispatcher {
     return this.appStore._fetch(repository, fetchType)
   }
 
+  /**
+   * Fetch all refs without fast-forwarding local branches.
+   * Updates remote tracking refs only, leaving local branches untouched.
+   */
+  public fetchWithoutFastForward(
+    repository: Repository,
+    fetchType: FetchType
+  ): Promise<void> {
+    return this.appStore._fetchWithoutFastForward(repository, fetchType)
+  }
+
   /** Publish the repository to GitHub with the given properties. */
   public publishRepository(
     repository: Repository,