From 3a2cf73bcd792fa3f4abd84fda46c0274eb57564 Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Thu, 12 Sep 2024 16:30:44 +0200
Subject: [PATCH 01/12] BaseBranch: Determine whether the base diverged

Determine whether the local target has diverged from the remote,
and return some information about that
---
 apps/desktop/src/lib/baseBranch/baseBranch.ts |  3 ++
 crates/gitbutler-branch-actions/src/base.rs   | 36 +++++++++++++++++++
 2 files changed, 39 insertions(+)

diff --git a/apps/desktop/src/lib/baseBranch/baseBranch.ts b/apps/desktop/src/lib/baseBranch/baseBranch.ts
index cf54c6c7f..f66ec5203 100644
--- a/apps/desktop/src/lib/baseBranch/baseBranch.ts
+++ b/apps/desktop/src/lib/baseBranch/baseBranch.ts
@@ -17,6 +17,9 @@ export class BaseBranch {
 	@Type(() => Commit)
 	recentCommits!: Commit[];
 	lastFetchedMs?: number;
+	diverged!: boolean;
+	divergedAhead!: string[];
+	divergedBehind!: string[];
 
 	actualPushRemoteName(): string {
 		return this.pushRemoteName || this.remoteName;
diff --git a/crates/gitbutler-branch-actions/src/base.rs b/crates/gitbutler-branch-actions/src/base.rs
index 18d5c034b..262ccc3b1 100644
--- a/crates/gitbutler-branch-actions/src/base.rs
+++ b/crates/gitbutler-branch-actions/src/base.rs
@@ -39,6 +39,11 @@ pub struct BaseBranch {
     pub upstream_commits: Vec<RemoteCommit>,
     pub recent_commits: Vec<RemoteCommit>,
     pub last_fetched_ms: Option<u128>,
+    pub diverged: bool,
+    #[serde(with = "gitbutler_serde::oid_vec")]
+    pub diverged_ahead: Vec<git2::Oid>,
+    #[serde(with = "gitbutler_serde::oid_vec")]
+    pub diverged_behind: Vec<git2::Oid>,
 }
 
 pub(crate) fn get_base_branch_data(ctx: &CommandContext) -> Result<BaseBranch> {
@@ -558,6 +563,34 @@ pub(crate) fn target_to_base_branch(ctx: &CommandContext, target: &Target) -> Re
     let commit = branch.get().peel_to_commit()?;
     let oid = commit.id();
 
+    // determined if the base branch is behind it's upstream
+    let fork_point = repo.merge_base(target.sha, oid).context(format!(
+        "failed to find merge base between {} and {}",
+        target.sha, oid
+    ))?;
+
+    let diverged = fork_point != target.sha;
+
+    let diverged_ahead = if diverged {
+        repo.log(target.sha, LogUntil::Commit(fork_point))
+            .context("failed to get diverged ahead commits")?
+            .iter()
+            .map(|commit| commit.id())
+            .collect::<Vec<git2::Oid>>()
+    } else {
+        Vec::new()
+    };
+
+    let diverged_behind = if diverged {
+        repo.log(oid, LogUntil::Commit(fork_point))
+            .context("failed to get diverged behind commits")?
+            .iter()
+            .map(|commit| commit.id())
+            .collect::<Vec<git2::Oid>>()
+    } else {
+        Vec::new()
+    };
+
     // gather a list of commits between oid and target.sha
     let upstream_commits = repo
         .log(oid, LogUntil::Commit(target.sha))
@@ -604,6 +637,9 @@ pub(crate) fn target_to_base_branch(ctx: &CommandContext, target: &Target) -> Re
             .map(FetchResult::timestamp)
             .copied()
             .map(|t| t.duration_since(time::UNIX_EPOCH).unwrap().as_millis()),
+        diverged,
+        diverged_ahead,
+        diverged_behind,
     };
     Ok(base)
 }

From 19acb8f22c09587923eca69e02fa08f4dbd0e06f Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Fri, 13 Sep 2024 12:32:03 +0200
Subject: [PATCH 02/12] Array utils: group items by condition

---
 apps/desktop/src/lib/utils/array.ts | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/apps/desktop/src/lib/utils/array.ts b/apps/desktop/src/lib/utils/array.ts
index b6107df6f..70b6b28c3 100644
--- a/apps/desktop/src/lib/utils/array.ts
+++ b/apps/desktop/src/lib/utils/array.ts
@@ -1,6 +1,8 @@
+type Predicate<T> = (item: T) => boolean;
+
 type ItemsSatisfyResult = 'all' | 'some' | 'none';
 
-export function itemsSatisfy<T>(arr: T[], predicate: (item: T) => boolean): ItemsSatisfyResult {
+export function itemsSatisfy<T>(arr: T[], predicate: Predicate<T>): ItemsSatisfyResult {
 	let satisfyCount = 0;
 	let offenseCount = 0;
 	for (const item of arr) {
@@ -29,6 +31,23 @@ export function chunk<T>(arr: T[], size: number) {
 	);
 }
 
-export function unique<T>(arr: T[]): T[] {
-	return Array.from(new Set(arr));
+interface GroupByResult<T> {
+	satisfied: T[];
+	rest: T[];
+}
+
+export function groupByCondition<T>(arr: T[], predicate: Predicate<T>): GroupByResult<T> {
+	const satisfied: T[] = [];
+	const rest: T[] = [];
+
+	for (const item of arr) {
+		if (predicate(item)) {
+			satisfied.push(item);
+			continue;
+		}
+
+		rest.push(item);
+	}
+
+	return { satisfied, rest };
 }

From 2be4aaac2d858a64d046803c10a54a5bfa61fedc Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Fri, 13 Sep 2024 14:16:58 +0200
Subject: [PATCH 03/12] Display the divergent state in the app

If the local target has diverged from the remote target, display that to the user as a warning

Only show either the divergence warning or upstream count
BaseBranch: Use runes

BaseBranch: Display the branch graph

In order to make it a bit clearer what the divergence state of the base branch is. reuse the line graphs to display it

BaseBranch divergence: Add a confirmation modal
---
 .../src/lib/commit/CommitAction.svelte        |   9 +-
 apps/desktop/src/lib/commit/CommitList.svelte |  10 +-
 .../src/lib/components/BaseBranch.svelte      | 269 ++++++++++++++++--
 .../lib/components/UpdateBaseButton.svelte    |   3 +-
 .../src/lib/navigation/TargetCard.svelte      |  10 +-
 .../ui/src/lib/commitLines/lineManager.ts     |   6 +
 6 files changed, 266 insertions(+), 41 deletions(-)

diff --git a/apps/desktop/src/lib/commit/CommitAction.svelte b/apps/desktop/src/lib/commit/CommitAction.svelte
index 74a49ea73..fdc900b17 100644
--- a/apps/desktop/src/lib/commit/CommitAction.svelte
+++ b/apps/desktop/src/lib/commit/CommitAction.svelte
@@ -4,11 +4,12 @@
 
 	interface Props {
 		bottomBorder?: boolean;
+		backgroundColor?: boolean;
 		lines: Snippet;
 		action: Snippet;
 	}
 
-	const { bottomBorder = true, lines, action }: Props = $props();
+	const { bottomBorder = true, backgroundColor = true, lines, action }: Props = $props();
 
 	let isNotInViewport = $state(false);
 </script>
@@ -18,6 +19,7 @@
 	class:not-in-viewport={!isNotInViewport}
 	class:sticky-z-index={!isNotInViewport}
 	class:bottom-border={bottomBorder}
+	class:background-color={backgroundColor}
 	use:intersectionObserver={{
 		callback: (entry) => {
 			if (entry?.isIntersecting) {
@@ -46,12 +48,15 @@
 		position: relative;
 		display: flex;
 
-		background-color: var(--clr-bg-2);
 		overflow: hidden;
 
 		transition: border-top var(--transition-fast);
 	}
 
+	.background-color {
+		background-color: var(--clr-bg-2);
+	}
+
 	.action {
 		display: flex;
 		flex-direction: column;
diff --git a/apps/desktop/src/lib/commit/CommitList.svelte b/apps/desktop/src/lib/commit/CommitList.svelte
index deccdd4b8..6db6deafd 100644
--- a/apps/desktop/src/lib/commit/CommitList.svelte
+++ b/apps/desktop/src/lib/commit/CommitList.svelte
@@ -18,7 +18,7 @@
 	import { Commit, DetailedCommit, VirtualBranch } from '$lib/vbranches/types';
 	import Button from '@gitbutler/ui/Button.svelte';
 	import LineGroup from '@gitbutler/ui/commitLines/LineGroup.svelte';
-	import { LineManagerFactory } from '@gitbutler/ui/commitLines/lineManager';
+	import { LineManagerFactory, LineSpacer } from '@gitbutler/ui/commitLines/lineManager';
 	import type { Snippet } from 'svelte';
 	import { goto } from '$app/navigation';
 
@@ -52,14 +52,6 @@
 	const reorderDropzoneManagerFactory = getContext(ReorderDropzoneManagerFactory);
 	const gitHost = getGitHost();
 
-	// TODO: Why does eslint-svelte-plugin complain about enum?
-	// eslint-disable-next-line svelte/valid-compile
-	enum LineSpacer {
-		Remote = 'remote-spacer',
-		Local = 'local-spacer',
-		LocalAndRemote = 'local-and-remote-spacer'
-	}
-
 	const mappedRemoteCommits = $derived(
 		remoteCommits.length > 0
 			? [...remoteCommits.map(transformAnyCommit), { id: LineSpacer.Remote }]
diff --git a/apps/desktop/src/lib/components/BaseBranch.svelte b/apps/desktop/src/lib/components/BaseBranch.svelte
index 1fe91d35d..f5a7bfb79 100644
--- a/apps/desktop/src/lib/components/BaseBranch.svelte
+++ b/apps/desktop/src/lib/components/BaseBranch.svelte
@@ -1,41 +1,111 @@
 <script lang="ts">
 	import IntegrateUpstreamModal from './IntegrateUpstreamModal.svelte';
-	import Spacer from '../shared/Spacer.svelte';
 	import { Project } from '$lib/backend/projects';
+	import CommitAction from '$lib/commit/CommitAction.svelte';
 	import CommitCard from '$lib/commit/CommitCard.svelte';
+	import { transformAnyCommit } from '$lib/commitLines/transformers';
 	import { projectMergeUpstreamWarningDismissed } from '$lib/config/config';
 	import { getGitHost } from '$lib/gitHost/interface/gitHost';
 	import { ModeService } from '$lib/modes/service';
 	import { showInfo } from '$lib/notifications/toasts';
+	import InfoMessage from '$lib/shared/InfoMessage.svelte';
+	import { groupByCondition } from '$lib/utils/array';
 	import { getContext } from '$lib/utils/context';
 	import { BranchController } from '$lib/vbranches/branchController';
 	import Button from '@gitbutler/ui/Button.svelte';
 	import Checkbox from '@gitbutler/ui/Checkbox.svelte';
 	import Modal from '@gitbutler/ui/Modal.svelte';
-	import Tooltip from '@gitbutler/ui/Tooltip.svelte';
+	import LineGroup from '@gitbutler/ui/commitLines/LineGroup.svelte';
+	import { LineManagerFactory, LineSpacer } from '@gitbutler/ui/commitLines/lineManager';
 	import type { BaseBranch } from '$lib/baseBranch/baseBranch';
 
-	export let base: BaseBranch;
+	const resetBranchTo = {
+		remote: {
+			title: 'Reset to remote',
+			header:
+				'You are about to reset the target branch to the remote branch. This will lose all the changes ahead of the remote branch.',
+			tooltip:
+				'Resets the target branch to the upstream branch. Will lose all the changes ahead of the upstream branch.',
+			color: 'warning',
+			action: updateBaseBranch
+		},
+		local: {
+			title: 'Reset to local',
+			header:
+				'You are about to reset the target branch to the local branch. This will lose all the remote changes not in the local branch.',
+			tooltip:
+				'Resets the upstream branch to the local target branch. Will lose all the remote changes not in the local branch.',
+			color: 'pop',
+			action: updateBaseBranch
+		}
+	} as const;
+
+	type ResetActionType = keyof typeof resetBranchTo;
+
+	interface Props {
+		base: BaseBranch;
+	}
+
+	const { base }: Props = $props();
 
 	const branchController = getContext(BranchController);
 	const modeService = getContext(ModeService);
 	const gitHost = getGitHost();
 	const project = getContext(Project);
+	const lineManagerFactory = getContext(LineManagerFactory);
 
-	const mode = modeService.mode;
-
-	const mergeUpstreamWarningDismissed = projectMergeUpstreamWarningDismissed(
-		branchController.projectId
+	const mode = $derived(modeService.mode);
+	const mergeUpstreamWarningDismissed = $derived(
+		projectMergeUpstreamWarningDismissed(branchController.projectId)
 	);
 
-	let updateTargetModal: Modal;
-	let integrateUpstreamModal: IntegrateUpstreamModal | undefined;
-	let mergeUpstreamWarningDismissedCheckbox = false;
+	let updateTargetModal = $state<Modal>();
+	let confirmResetModal = $state<Modal>();
+	let resetActionType = $state<ResetActionType | undefined>(undefined);
+	let mergeUpstreamWarningDismissedCheckbox = $state<boolean>(false);
+	let integrateUpstreamModal = $state<IntegrateUpstreamModal | undefined>();
 
-	$: multiple = base ? base.upstreamCommits.length > 1 || base.upstreamCommits.length === 0 : false;
+	const { satisfied: commitsAhead, rest: localAndRemoteCommits } = $derived(
+		groupByCondition(base.recentCommits, (c) => base.divergedAhead.includes(c.id))
+	);
+
+	const multiple = $derived(
+		base ? base.upstreamCommits.length > 1 || base.upstreamCommits.length === 0 : false
+	);
+
+	const mappedRemoteCommits = $derived(
+		base.upstreamCommits.length > 0
+			? [...base.upstreamCommits.map(transformAnyCommit), { id: LineSpacer.Remote }]
+			: []
+	);
+
+	const mappedLocalCommits = $derived.by(() => {
+		if (!base.diverged) return [];
+		return commitsAhead.length > 0
+			? [...commitsAhead.map(transformAnyCommit), { id: LineSpacer.Local }]
+			: [];
+	});
+
+	const mappedLocalAndRemoteCommits = $derived.by(() => {
+		return localAndRemoteCommits.length > 0
+			? [...localAndRemoteCommits.map(transformAnyCommit), { id: LineSpacer.LocalAndRemote }]
+			: [];
+	});
+
+	const lineManager = $derived(
+		lineManagerFactory.build(
+			{
+				remoteCommits: mappedRemoteCommits,
+				localCommits: mappedLocalCommits,
+				localAndRemoteCommits: mappedLocalAndRemoteCommits,
+				integratedCommits: []
+			},
+			true
+		)
+	);
 
 	async function updateBaseBranch() {
-		let infoText = await branchController.updateBaseBranch();
+		const infoText = await branchController.updateBaseBranch();
 		if (infoText) {
 			showInfo('Stashed conflicting branches', infoText);
 		}
@@ -48,20 +118,45 @@
 			if (mergeUpstreamWarningDismissedCheckbox) {
 				updateBaseBranch();
 			} else {
-				updateTargetModal.show();
+				updateTargetModal?.show();
 			}
 		}
 	}
+
+	function confirmResetBranch(type: ResetActionType) {
+		resetActionType = type;
+		confirmResetModal?.show();
+	}
 </script>
 
-<div class="wrapper">
-	<div class="info-text text-13">
-		There {multiple ? 'are' : 'is'}
-		{base.upstreamCommits.length} unmerged upstream
-		{multiple ? 'commits' : 'commit'}
+{#if base.diverged}
+	<div class="message-wrapper">
+		<InfoMessage style="warning" filled outlined={false}>
+			<svelte:fragment slot="content">
+				Your target branch has diverged from upstream.
+				<br />
+				Target branch is
+				<b>
+					{`ahead by ${base.divergedAhead.length}`}
+				</b>
+				commits and
+				<b>
+					{`behind by ${base.divergedBehind.length}`}
+				</b>
+				commits
+			</svelte:fragment>
+		</InfoMessage>
 	</div>
+{/if}
+
+{#if !base.diverged && base.upstreamCommits.length > 0}
+	<div class="header-wrapper">
+		<div class="info-text text-13">
+			There {multiple ? 'are' : 'is'}
+			{base.upstreamCommits.length} unmerged upstream
+			{multiple ? 'commits' : 'commit'}
+		</div>
 
-	{#if base.upstreamCommits?.length > 0}
 		<IntegrateUpstreamModal bind:this={integrateUpstreamModal} />
 		<Button
 			style="pop"
@@ -73,6 +168,12 @@
 		>
 			Merge into common base
 		</Button>
+	</div>
+{/if}
+
+<div class="wrapper">
+	<!-- UPSTREAM COMMITS -->
+	{#if base.upstreamCommits?.length > 0}
 		<div>
 			{#each base.upstreamCommits as commit, index}
 				<CommitCard
@@ -82,25 +183,88 @@
 					isUnapplied={true}
 					commitUrl={$gitHost?.commitUrl(commit.id)}
 					type="remote"
-				/>
+				>
+					{#snippet lines(topHeightPx)}
+						<LineGroup lineGroup={lineManager.get(commit.id)} {topHeightPx} />
+					{/snippet}
+				</CommitCard>
 			{/each}
 		</div>
-		<Spacer margin={2} />
+
+		{#if base.diverged}
+			<CommitAction backgroundColor={false}>
+				{#snippet lines()}
+					<LineGroup lineGroup={lineManager.get(LineSpacer.Remote)} topHeightPx={0} />
+				{/snippet}
+				{#snippet action()}
+					<Button
+						style={resetBranchTo.remote.color}
+						icon="warning"
+						kind="solid"
+						tooltip={resetBranchTo.remote.tooltip}
+						disabled={$mode?.type !== 'OpenWorkspace'}
+						onclick={() => confirmResetBranch('remote')}
+					>
+						{resetBranchTo.remote.title}
+					</Button>
+				{/snippet}
+			</CommitAction>
+		{/if}
 	{/if}
 
+	<!-- DIVERGED (LOCAL) COMMITS -->
+	{#if commitsAhead.length > 0}
+		<div>
+			{#each commitsAhead as commit, index}
+				<CommitCard
+					{commit}
+					first={index === 0}
+					last={index === commitsAhead.length - 1}
+					isUnapplied={true}
+					commitUrl={$gitHost?.commitUrl(commit.id)}
+					type="local"
+				>
+					{#snippet lines(topHeightPx)}
+						<LineGroup lineGroup={lineManager.get(commit.id)} {topHeightPx} />
+					{/snippet}
+				</CommitCard>
+			{/each}
+		</div>
+
+		<CommitAction backgroundColor={false}>
+			{#snippet lines()}
+				<LineGroup lineGroup={lineManager.get(LineSpacer.Local)} topHeightPx={0} />
+			{/snippet}
+			{#snippet action()}
+				<Button
+					style={resetBranchTo.local.color}
+					icon="warning"
+					kind="solid"
+					tooltip={resetBranchTo.local.tooltip}
+					disabled={$mode?.type !== 'OpenWorkspace'}
+					onclick={() => confirmResetBranch('local')}
+				>
+					{resetBranchTo.local.title}
+				</Button>
+			{/snippet}
+		</CommitAction>
+	{/if}
+
+	<!-- LOCAL AND REMOTE COMMITS -->
 	<div>
-		<Tooltip text="Current base for virtual branches.">
-			<h1 class="text-13 info-text text-bold">Local</h1>
-		</Tooltip>
-		{#each base.recentCommits as commit, index}
+		{#each localAndRemoteCommits as commit, index}
 			<CommitCard
 				{commit}
 				first={index === 0}
-				last={index === base.recentCommits.length - 1}
+				last={index === localAndRemoteCommits.length - 1}
 				isUnapplied={true}
 				commitUrl={$gitHost?.commitUrl(commit.id)}
 				type="localAndRemote"
-			/>
+			>
+				{#snippet lines(topHeightPx)}
+					<LineGroup lineGroup={lineManager.get(commit.id)} {topHeightPx} />
+				{/snippet}
+			</CommitCard>
 		{/each}
 	</div>
 </div>
@@ -146,12 +310,61 @@
 	{/snippet}
 </Modal>
 
+{#if resetActionType}
+	<Modal
+		width="small"
+		title={resetBranchTo[resetActionType].title}
+		bind:this={confirmResetModal}
+		onSubmit={(close) => {
+			if (resetActionType) {
+				resetBranchTo[resetActionType].action();
+			}
+			close();
+		}}
+	>
+		<div class="modal-content">
+			<p class="text-12">
+				{#if resetActionType === 'remote'}
+					{base.divergedAhead.length > 1
+						? `You will lose the ${base.divergedAhead.length} local commits ahead of the remote branch.`
+						: 'You will lose the local commit ahead of the remote branch.'}
+				{:else}
+					You will force-push the local branch to the remote branch.
+					<br />
+					{base.divergedBehind.length > 1
+						? `The ${base.divergedBehind.length} changes in the remote branch will be lost.`
+						: 'The change in the remote branch will be lost.'}
+				{/if}
+			</p>
+		</div>
+
+		{#snippet controls(close)}
+			{#if resetActionType}
+				<Button style="ghost" outline onclick={close}>Cancel</Button>
+				<Button style="error" kind="solid" type="submit" icon="warning"
+					>{resetBranchTo[resetActionType].title}</Button
+				>
+			{/if}
+		{/snippet}
+	</Modal>
+{/if}
+
 <style>
-	.wrapper {
+	.header-wrapper {
 		display: flex;
 		flex-direction: column;
 		gap: 16px;
 	}
+	.message-wrapper {
+		display: flex;
+		flex-direction: column;
+		margin-bottom: 20px;
+		gap: 16px;
+	}
+	.wrapper {
+		display: flex;
+		flex-direction: column;
+	}
 
 	.info-text {
 		opacity: 0.5;
diff --git a/apps/desktop/src/lib/components/UpdateBaseButton.svelte b/apps/desktop/src/lib/components/UpdateBaseButton.svelte
index 5859e2556..d18a458f2 100644
--- a/apps/desktop/src/lib/components/UpdateBaseButton.svelte
+++ b/apps/desktop/src/lib/components/UpdateBaseButton.svelte
@@ -15,7 +15,8 @@
 
 	const displayButton = $derived.by(() => {
 		const hasUpstreamCommits = ($base?.upstreamCommits?.length ?? 0) > 0;
-		return hasUpstreamCommits;
+		const diverged = $base?.diverged ?? true;
+		return hasUpstreamCommits && !diverged;
 	});
 
 	let modal = $state<IntegrateUpstreamModal>();
diff --git a/apps/desktop/src/lib/navigation/TargetCard.svelte b/apps/desktop/src/lib/navigation/TargetCard.svelte
index 68a5ef6bc..33e7bf724 100644
--- a/apps/desktop/src/lib/navigation/TargetCard.svelte
+++ b/apps/desktop/src/lib/navigation/TargetCard.svelte
@@ -17,6 +17,7 @@
 
 	const base = baseBranchService.base;
 	$: selected = $page.url.href.endsWith('/base');
+	$: baseBranchDiverged = !!$base?.diverged;
 </script>
 
 <DomainButton
@@ -41,11 +42,18 @@
 				<Tooltip text="The branch your Workspace branches are based on and merge into.">
 					<span class="text-14 text-semibold trunk-label">Target</span>
 				</Tooltip>
-				{#if ($base?.behind || 0) > 0}
+				{#if ($base?.behind || 0) > 0 && !baseBranchDiverged}
 					<Tooltip text="Unmerged upstream commits">
 						<Badge label={$base?.behind || 0} />
 					</Tooltip>
 				{/if}
+				{#if baseBranchDiverged}
+					<Tooltip text="Your branch has diverged from the target branch">
+						<div>
+							<Icon name="warning" color="warning" />
+						</div>
+					</Tooltip>
+				{/if}
 				<SyncButton />
 			</div>
 			<div class="base-branch-label">
diff --git a/packages/ui/src/lib/commitLines/lineManager.ts b/packages/ui/src/lib/commitLines/lineManager.ts
index dd57986f0..2e7a61c39 100644
--- a/packages/ui/src/lib/commitLines/lineManager.ts
+++ b/packages/ui/src/lib/commitLines/lineManager.ts
@@ -1,5 +1,11 @@
 import type { CommitData, LineGroupData, LineData, Color } from '$lib/commitLines/types';
 
+export enum LineSpacer {
+	Remote = 'remote-spacer',
+	Local = 'local-spacer',
+	LocalAndRemote = 'local-and-remote-spacer'
+}
+
 interface Commits {
 	remoteCommits: CommitData[];
 	localCommits: CommitData[];

From 9060a4287c9c0feb6a5353e9f49242b2a7fc8537 Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Fri, 13 Sep 2024 15:39:28 +0200
Subject: [PATCH 04/12] Ability to push the base branch

If needed, the base branch can be pushed or force pushed
---
 .../src/lib/baseBranch/baseBranchService.ts   | 21 +++++++++++++++++++
 .../gitbutler-branch-actions/src/actions.rs   |  5 +++++
 crates/gitbutler-branch-actions/src/base.rs   |  7 +++++++
 crates/gitbutler-branch-actions/src/lib.rs    |  2 +-
 crates/gitbutler-tauri/src/main.rs            |  1 +
 .../gitbutler-tauri/src/virtual_branches.rs   | 14 +++++++++++++
 6 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/apps/desktop/src/lib/baseBranch/baseBranchService.ts b/apps/desktop/src/lib/baseBranch/baseBranchService.ts
index 220fec1dd..cdd796a81 100644
--- a/apps/desktop/src/lib/baseBranch/baseBranchService.ts
+++ b/apps/desktop/src/lib/baseBranch/baseBranchService.ts
@@ -67,6 +67,27 @@ export class BaseBranchService {
 		});
 		await this.fetchFromRemotes();
 	}
+
+	async push(withForce?: boolean) {
+		this.loading.set(true);
+		try {
+			await invoke<void>('push_base_branch', {
+				projectId: this.projectId,
+				withForce
+			});
+		} catch (err: any) {
+			if (err.code === Code.DefaultTargetNotFound) {
+				// Swallow this error since user should be taken to project setup page
+				return;
+			} else if (err.code === Code.ProjectsGitAuth) {
+				showError('Failed to authenticate', err);
+			} else {
+				showError('Failed to push', err);
+			}
+			console.error(err);
+		}
+		await this.fetchFromRemotes();
+	}
 }
 
 export async function getRemoteBranches(
diff --git a/crates/gitbutler-branch-actions/src/actions.rs b/crates/gitbutler-branch-actions/src/actions.rs
index f8b4a13d4..568aba5c0 100644
--- a/crates/gitbutler-branch-actions/src/actions.rs
+++ b/crates/gitbutler-branch-actions/src/actions.rs
@@ -158,6 +158,11 @@ pub fn set_target_push_remote(project: &Project, push_remote: &str) -> Result<()
     base::set_target_push_remote(&ctx, push_remote)
 }
 
+pub fn push_base_branch(project: &Project, with_force: bool) -> Result<()> {
+    let ctx = CommandContext::open(project)?;
+    base::push(&ctx, with_force)
+}
+
 pub fn integrate_upstream_commits(project: &Project, branch_id: BranchId) -> Result<()> {
     let ctx = open_with_verify(project)?;
     assure_open_workspace_mode(&ctx)
diff --git a/crates/gitbutler-branch-actions/src/base.rs b/crates/gitbutler-branch-actions/src/base.rs
index 262ccc3b1..7e81de9c6 100644
--- a/crates/gitbutler-branch-actions/src/base.rs
+++ b/crates/gitbutler-branch-actions/src/base.rs
@@ -647,3 +647,10 @@ pub(crate) fn target_to_base_branch(ctx: &CommandContext, target: &Target) -> Re
 fn default_target(base_path: &Path) -> Result<Target> {
     VirtualBranchesHandle::new(base_path).get_default_target()
 }
+
+pub(crate) fn push(ctx: &CommandContext, with_force: bool) -> Result<()> {
+    ctx.assure_resolved()?;
+    let target = default_target(&ctx.project().gb_dir())?;
+    let _ = ctx.push(target.sha, &target.branch, with_force, None, None);
+    Ok(())
+}
diff --git a/crates/gitbutler-branch-actions/src/lib.rs b/crates/gitbutler-branch-actions/src/lib.rs
index f09e27ad2..417bf1a92 100644
--- a/crates/gitbutler-branch-actions/src/lib.rs
+++ b/crates/gitbutler-branch-actions/src/lib.rs
@@ -8,7 +8,7 @@ pub use actions::{
     get_uncommited_files_reusable, insert_blank_commit, integrate_upstream,
     integrate_upstream_commits, list_local_branches, list_remote_commit_files,
     list_virtual_branches, list_virtual_branches_cached, move_commit, move_commit_file,
-    push_virtual_branch, reorder_commit, reset_files, reset_virtual_branch,
+    push_base_branch, push_virtual_branch, reorder_commit, reset_files, reset_virtual_branch,
     save_and_unapply_virutal_branch, set_base_branch, set_target_push_remote, squash,
     unapply_ownership, unapply_without_saving_virtual_branch, undo_commit, update_base_branch,
     update_branch_order, update_commit_message, update_virtual_branch,
diff --git a/crates/gitbutler-tauri/src/main.rs b/crates/gitbutler-tauri/src/main.rs
index 840b774ec..3de1b2d2d 100644
--- a/crates/gitbutler-tauri/src/main.rs
+++ b/crates/gitbutler-tauri/src/main.rs
@@ -159,6 +159,7 @@ fn main() {
                     virtual_branches::commands::get_base_branch_data,
                     virtual_branches::commands::set_base_branch,
                     virtual_branches::commands::update_base_branch,
+                    virtual_branches::commands::push_base_branch,
                     virtual_branches::commands::integrate_upstream_commits,
                     virtual_branches::commands::update_virtual_branch,
                     virtual_branches::commands::update_branch_order,
diff --git a/crates/gitbutler-tauri/src/virtual_branches.rs b/crates/gitbutler-tauri/src/virtual_branches.rs
index 2f8611f93..928f553f3 100644
--- a/crates/gitbutler-tauri/src/virtual_branches.rs
+++ b/crates/gitbutler-tauri/src/virtual_branches.rs
@@ -174,6 +174,20 @@ pub mod commands {
         Ok(unapplied_branches)
     }
 
+    #[tauri::command(async)]
+    #[instrument(skip(projects, windows), err(Debug))]
+    pub fn push_base_branch(
+        windows: State<'_, WindowState>,
+        projects: State<'_, projects::Controller>,
+        project_id: ProjectId,
+        with_force: bool,
+    ) -> Result<(), Error> {
+        let project = projects.get(project_id)?;
+        gitbutler_branch_actions::push_base_branch(&project, with_force)?;
+        emit_vbranches(&windows, project_id);
+        Ok(())
+    }
+
     #[tauri::command(async)]
     #[instrument(skip(projects, windows), err(Debug))]
     pub fn update_virtual_branch(

From 78d40a7493e1800140180578b21bff16bca7cb98 Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Mon, 16 Sep 2024 17:44:54 +0200
Subject: [PATCH 05/12] BaseBranch: Don't be scary when pushing

Only display the warnings and confirmation modals when actual changes can get lost (resting to local or remote).
Otherwise, display less scary notifications and let the user push if needed

Merge remote-tracking branch 'origin/master' into base-branch-improvements
---
 .../src/lib/components/BaseBranch.svelte      | 135 +++++++++++++-----
 .../src/lib/navigation/TargetCard.svelte      |  11 +-
 apps/desktop/src/lib/utils/array.ts           |   4 +
 3 files changed, 113 insertions(+), 37 deletions(-)

diff --git a/apps/desktop/src/lib/components/BaseBranch.svelte b/apps/desktop/src/lib/components/BaseBranch.svelte
index f5a7bfb79..d233c51ff 100644
--- a/apps/desktop/src/lib/components/BaseBranch.svelte
+++ b/apps/desktop/src/lib/components/BaseBranch.svelte
@@ -1,6 +1,7 @@
 <script lang="ts">
 	import IntegrateUpstreamModal from './IntegrateUpstreamModal.svelte';
 	import { Project } from '$lib/backend/projects';
+	import { BaseBranchService } from '$lib/baseBranch/baseBranchService';
 	import CommitAction from '$lib/commit/CommitAction.svelte';
 	import CommitCard from '$lib/commit/CommitCard.svelte';
 	import { transformAnyCommit } from '$lib/commitLines/transformers';
@@ -17,6 +18,7 @@
 	import Modal from '@gitbutler/ui/Modal.svelte';
 	import LineGroup from '@gitbutler/ui/commitLines/LineGroup.svelte';
 	import { LineManagerFactory, LineSpacer } from '@gitbutler/ui/commitLines/lineManager';
+	import { tick } from 'svelte';
 	import type { BaseBranch } from '$lib/baseBranch/baseBranch';
 
 	const resetBranchTo = {
@@ -36,7 +38,7 @@
 			tooltip:
 				'Resets the upstream branch to the local target branch. Will lose all the remote changes not in the local branch.',
 			color: 'pop',
-			action: updateBaseBranch
+			action: async () => await pushBaseBranch()
 		}
 	} as const;
 
@@ -48,6 +50,7 @@
 
 	const { base }: Props = $props();
 
+	const baseBranchService = getContext(BaseBranchService);
 	const branchController = getContext(BranchController);
 	const modeService = getContext(ModeService);
 	const gitHost = getGitHost();
@@ -59,20 +62,25 @@
 		projectMergeUpstreamWarningDismissed(branchController.projectId)
 	);
 
+	let baseBranchIsUpdating = $state<boolean>(false);
 	let updateTargetModal = $state<Modal>();
 	let confirmResetModal = $state<Modal>();
 	let resetActionType = $state<ResetActionType | undefined>(undefined);
 	let mergeUpstreamWarningDismissedCheckbox = $state<boolean>(false);
 	let integrateUpstreamModal = $state<IntegrateUpstreamModal | undefined>();
 
-	const { satisfied: commitsAhead, rest: localAndRemoteCommits } = $derived(
-		groupByCondition(base.recentCommits, (c) => base.divergedAhead.includes(c.id))
-	);
-
 	const multiple = $derived(
 		base ? base.upstreamCommits.length > 1 || base.upstreamCommits.length === 0 : false
 	);
 
+	const onlyLocalAhead = $derived(
+		base.diverged && base.divergedBehind.length === 0 && base.divergedAhead.length > 0
+	);
+
+	const { satisfied: commitsAhead, rest: localAndRemoteCommits } = $derived(
+		groupByCondition(base.recentCommits, (c) => base.divergedAhead.includes(c.id))
+	);
+
 	const mappedRemoteCommits = $derived(
 		base.upstreamCommits.length > 0
 			? [...base.upstreamCommits.map(transformAnyCommit), { id: LineSpacer.Remote }]
@@ -105,10 +113,13 @@
 	);
 
 	async function updateBaseBranch() {
+		baseBranchIsUpdating = true;
 		const infoText = await branchController.updateBaseBranch();
 		if (infoText) {
 			showInfo('Stashed conflicting branches', infoText);
 		}
+		await tick();
+		baseBranchIsUpdating = false;
 	}
 
 	function mergeUpstream() {
@@ -123,29 +134,49 @@
 		}
 	}
 
-	function confirmResetBranch(type: ResetActionType) {
+	async function pushBaseBranch() {
+		baseBranchIsUpdating = true;
+		await baseBranchService.push(!onlyLocalAhead);
+		await tick();
+		baseBranchIsUpdating = false;
+	}
+
+	async function confirmResetBranch(type: ResetActionType) {
 		resetActionType = type;
+		await tick();
 		confirmResetModal?.show();
 	}
 </script>
 
 {#if base.diverged}
 	<div class="message-wrapper">
-		<InfoMessage style="warning" filled outlined={false}>
-			<svelte:fragment slot="content">
-				Your target branch has diverged from upstream.
-				<br />
-				Target branch is
-				<b>
-					{`ahead by ${base.divergedAhead.length}`}
-				</b>
-				commits and
-				<b>
-					{`behind by ${base.divergedBehind.length}`}
-				</b>
-				commits
-			</svelte:fragment>
-		</InfoMessage>
+		{#if !onlyLocalAhead}
+			<InfoMessage style="warning" filled outlined={false}>
+				<svelte:fragment slot="content">
+					Your local target branch has diverged from upstream.
+					<br />
+					Target branch is
+					<b>
+						{`ahead by ${base.divergedAhead.length}`}
+					</b>
+					commits and
+					<b>
+						{`behind by ${base.divergedBehind.length}`}
+					</b>
+					commits
+				</svelte:fragment>
+			</InfoMessage>
+		{:else}
+			<InfoMessage style="neutral" filled outlined={false}>
+				<svelte:fragment slot="content">
+					Your local target branch is
+					<b>
+						{`ahead by ${base.divergedAhead.length}`}
+					</b>
+					commits
+				</svelte:fragment>
+			</InfoMessage>
+		{/if}
 	</div>
 {/if}
 
@@ -202,8 +233,9 @@
 						icon="warning"
 						kind="solid"
 						tooltip={resetBranchTo.remote.tooltip}
-						disabled={$mode?.type !== 'OpenWorkspace'}
-						onclick={() => confirmResetBranch('remote')}
+						loading={baseBranchIsUpdating}
+						disabled={$mode?.type !== 'OpenWorkspace' || baseBranchIsUpdating}
+						onclick={async () => await confirmResetBranch('remote')}
 					>
 						{resetBranchTo.remote.title}
 					</Button>
@@ -236,16 +268,43 @@
 				<LineGroup lineGroup={lineManager.get(LineSpacer.Local)} topHeightPx={0} />
 			{/snippet}
 			{#snippet action()}
-				<Button
-					style={resetBranchTo.local.color}
-					icon="warning"
-					kind="solid"
-					tooltip={resetBranchTo.local.tooltip}
-					disabled={$mode?.type !== 'OpenWorkspace'}
-					onclick={() => confirmResetBranch('local')}
-				>
-					{resetBranchTo.local.title}
-				</Button>
+				<div class="local-actions-wrapper">
+					<Button
+						wide
+						style={resetBranchTo.local.color}
+						icon={onlyLocalAhead ? undefined : 'warning'}
+						kind="solid"
+						tooltip={onlyLocalAhead
+							? 'Push your local changes to upstream'
+							: resetBranchTo.local.tooltip}
+						loading={baseBranchIsUpdating}
+						disabled={$mode?.type !== 'OpenWorkspace' || baseBranchIsUpdating}
+						onclick={async () => {
+							if (onlyLocalAhead) {
+								await pushBaseBranch();
+								return;
+							}
+							await confirmResetBranch('local');
+						}}
+					>
+						{onlyLocalAhead ? 'Push' : resetBranchTo.local.title}
+					</Button>
+
+					{#if onlyLocalAhead}
+						<Button
+							wide
+							style={resetBranchTo.remote.color}
+							icon="warning"
+							kind="solid"
+							tooltip={resetBranchTo.remote.tooltip}
+							loading={baseBranchIsUpdating}
+							disabled={$mode?.type !== 'OpenWorkspace' || baseBranchIsUpdating}
+							onclick={async () => await confirmResetBranch('remote')}
+						>
+							{resetBranchTo.remote.title}
+						</Button>
+					{/if}
+				</div>
 			{/snippet}
 		</CommitAction>
 	{/if}
@@ -331,9 +390,10 @@
 				{:else}
 					You will force-push the local branch to the remote branch.
 					<br />
+					<br />
 					{base.divergedBehind.length > 1
-						? `The ${base.divergedBehind.length} changes in the remote branch will be lost.`
-						: 'The change in the remote branch will be lost.'}
+						? `The ${base.divergedBehind.length} commits in the remote branch will be lost.`
+						: 'The commit in the remote branch will be lost.'}
 				{/if}
 			</p>
 		</div>
@@ -370,6 +430,11 @@
 		opacity: 0.5;
 	}
 
+	.local-actions-wrapper {
+		display: flex;
+		width: 100%;
+		gap: 8px;
+	}
 	.modal-content {
 		display: flex;
 		flex-direction: column;
diff --git a/apps/desktop/src/lib/navigation/TargetCard.svelte b/apps/desktop/src/lib/navigation/TargetCard.svelte
index 33e7bf724..f8c435d2b 100644
--- a/apps/desktop/src/lib/navigation/TargetCard.svelte
+++ b/apps/desktop/src/lib/navigation/TargetCard.svelte
@@ -18,6 +18,10 @@
 	const base = baseBranchService.base;
 	$: selected = $page.url.href.endsWith('/base');
 	$: baseBranchDiverged = !!$base?.diverged;
+	$: baseBranchAheadOnly = baseBranchDiverged && !!$base?.divergedBehind?.length === false;
+	$: divergenceTooltip = baseBranchAheadOnly
+		? 'Your local target branch is ahead of its upstream'
+		: 'Your local target branch has diverged from its upstream';
 </script>
 
 <DomainButton
@@ -48,9 +52,12 @@
 					</Tooltip>
 				{/if}
 				{#if baseBranchDiverged}
-					<Tooltip text="Your branch has diverged from the target branch">
+					<Tooltip text={divergenceTooltip}>
 						<div>
-							<Icon name="warning" color="warning" />
+							<Icon
+								name={baseBranchAheadOnly ? 'info' : 'warning'}
+								color={baseBranchAheadOnly ? undefined : 'warning'}
+							/>
 						</div>
 					</Tooltip>
 				{/if}
diff --git a/apps/desktop/src/lib/utils/array.ts b/apps/desktop/src/lib/utils/array.ts
index 70b6b28c3..8cdbddc8a 100644
--- a/apps/desktop/src/lib/utils/array.ts
+++ b/apps/desktop/src/lib/utils/array.ts
@@ -51,3 +51,7 @@ export function groupByCondition<T>(arr: T[], predicate: Predicate<T>): GroupByR
 
 	return { satisfied, rest };
 }
+
+export function unique<T>(arr: T[]): T[] {
+	return Array.from(new Set(arr));
+}

From e4cd357b8aa38c033eab3096a11eddb12a66df7e Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Tue, 24 Sep 2024 15:18:47 +0200
Subject: [PATCH 06/12] BaseBranch: Handle the button actions correctly

Depending on which action the user chooses, and whether they've set certain flags, act accordingly
---
 .../src/lib/components/BaseBranch.svelte      | 183 ++++++++++--------
 1 file changed, 100 insertions(+), 83 deletions(-)

diff --git a/apps/desktop/src/lib/components/BaseBranch.svelte b/apps/desktop/src/lib/components/BaseBranch.svelte
index d233c51ff..2526c9d51 100644
--- a/apps/desktop/src/lib/components/BaseBranch.svelte
+++ b/apps/desktop/src/lib/components/BaseBranch.svelte
@@ -21,35 +21,38 @@
 	import { tick } from 'svelte';
 	import type { BaseBranch } from '$lib/baseBranch/baseBranch';
 
-	const resetBranchTo = {
-		remote: {
-			title: 'Reset to remote',
-			header:
-				'You are about to reset the target branch to the remote branch. This will lose all the changes ahead of the remote branch.',
-			tooltip:
-				'Resets the target branch to the upstream branch. Will lose all the changes ahead of the upstream branch.',
-			color: 'warning',
-			action: updateBaseBranch
-		},
-		local: {
-			title: 'Reset to local',
-			header:
-				'You are about to reset the target branch to the local branch. This will lose all the remote changes not in the local branch.',
-			tooltip:
-				'Resets the upstream branch to the local target branch. Will lose all the remote changes not in the local branch.',
-			color: 'pop',
-			action: async () => await pushBaseBranch()
-		}
-	} as const;
-
-	type ResetActionType = keyof typeof resetBranchTo;
-
 	interface Props {
 		base: BaseBranch;
 	}
 
 	const { base }: Props = $props();
 
+	const resetBaseTo = {
+		local: {
+			title: 'Push local changes',
+			header:
+				'You are about to reset the upstream target branch to the local branch. This will lose all the remote changes not in the local branch.',
+			content: 'You will force-push your local changes to the remote branch.',
+			tooltip:
+				'Resets the upstream branch to the local target branch. Will lose all the remote changes not in the local branch.',
+			color: 'pop',
+			handler: handlePushLocalChanges,
+			action: pushBaseBranch
+		},
+		remote: {
+			title: 'Discard local changes',
+			header:
+				'You are about to reset the target branch to the remote branch. This will lose all the changes ahead of the remote branch.',
+			content: 'You are about to hard reset your local base branch to the remote branch',
+			tooltip: `Choose how to integrate the commits from ${base.branchName} into the base of all applied virtual branches`,
+			color: 'warning',
+			handler: handleMergeUpstream,
+			action: updateBaseBranch
+		}
+	} as const;
+
+	type ResetBaseStrategy = keyof typeof resetBaseTo;
+
 	const baseBranchService = getContext(BaseBranchService);
 	const branchController = getContext(BranchController);
 	const modeService = getContext(ModeService);
@@ -64,10 +67,12 @@
 
 	let baseBranchIsUpdating = $state<boolean>(false);
 	let updateTargetModal = $state<Modal>();
+	let resetBaseStrategy = $state<ResetBaseStrategy | undefined>(undefined);
 	let confirmResetModal = $state<Modal>();
-	let resetActionType = $state<ResetActionType | undefined>(undefined);
+	const confirmResetModalOpen = $derived(!!confirmResetModal?.imports.open);
+	let integrateUpstreamModal = $state<IntegrateUpstreamModal>();
+	const integrateUpstreamModalOpen = $derived(!!integrateUpstreamModal?.imports.open);
 	let mergeUpstreamWarningDismissedCheckbox = $state<boolean>(false);
-	let integrateUpstreamModal = $state<IntegrateUpstreamModal | undefined>();
 
 	const multiple = $derived(
 		base ? base.upstreamCommits.length > 1 || base.upstreamCommits.length === 0 : false
@@ -122,30 +127,45 @@
 		baseBranchIsUpdating = false;
 	}
 
-	function mergeUpstream() {
-		if (project.succeedingRebases) {
+	async function handleMergeUpstream() {
+		if (project.succeedingRebases && !onlyLocalAhead) {
 			integrateUpstreamModal?.show();
-		} else {
-			if (mergeUpstreamWarningDismissedCheckbox) {
-				updateBaseBranch();
-			} else {
-				updateTargetModal?.show();
-			}
+			return;
 		}
+
+		if (base.diverged) {
+			await confirmResetBranch('remote');
+			return;
+		}
+
+		if ($mergeUpstreamWarningDismissed) {
+			updateBaseBranch();
+			return;
+		}
+		updateTargetModal?.show();
 	}
 
 	async function pushBaseBranch() {
 		baseBranchIsUpdating = true;
 		await baseBranchService.push(!onlyLocalAhead);
 		await tick();
+		await baseBranchService.refresh();
 		baseBranchIsUpdating = false;
 	}
 
-	async function confirmResetBranch(type: ResetActionType) {
-		resetActionType = type;
+	async function confirmResetBranch(strategy: ResetBaseStrategy) {
+		resetBaseStrategy = strategy;
 		await tick();
 		confirmResetModal?.show();
 	}
+
+	async function handlePushLocalChanges() {
+		if (onlyLocalAhead) {
+			await pushBaseBranch();
+			return;
+		}
+		await confirmResetBranch('local');
+	}
 </script>
 
 {#if base.diverged}
@@ -188,14 +208,13 @@
 			{multiple ? 'commits' : 'commit'}
 		</div>
 
-		<IntegrateUpstreamModal bind:this={integrateUpstreamModal} />
 		<Button
 			style="pop"
 			kind="solid"
 			tooltip={`Merges the commits from ${base.branchName} into the base of all applied virtual branches`}
-			disabled={$mode?.type !== 'OpenWorkspace' || integrateUpstreamModal?.imports.open}
-			loading={integrateUpstreamModal?.imports.open}
-			onclick={mergeUpstream}
+			disabled={$mode?.type !== 'OpenWorkspace' || integrateUpstreamModalOpen}
+			loading={integrateUpstreamModalOpen}
+			onclick={handleMergeUpstream}
 		>
 			Merge into common base
 		</Button>
@@ -229,15 +248,18 @@
 				{/snippet}
 				{#snippet action()}
 					<Button
-						style={resetBranchTo.remote.color}
+						wide
 						icon="warning"
 						kind="solid"
-						tooltip={resetBranchTo.remote.tooltip}
-						loading={baseBranchIsUpdating}
-						disabled={$mode?.type !== 'OpenWorkspace' || baseBranchIsUpdating}
-						onclick={async () => await confirmResetBranch('remote')}
+						style={resetBaseTo.remote.color}
+						tooltip={resetBaseTo.remote.tooltip}
+						loading={baseBranchIsUpdating || integrateUpstreamModalOpen}
+						disabled={$mode?.type !== 'OpenWorkspace' ||
+							baseBranchIsUpdating ||
+							integrateUpstreamModalOpen}
+						onclick={resetBaseTo.remote.handler}
 					>
-						{resetBranchTo.remote.title}
+						Integrate upstream changes
 					</Button>
 				{/snippet}
 			</CommitAction>
@@ -271,37 +293,33 @@
 				<div class="local-actions-wrapper">
 					<Button
 						wide
-						style={resetBranchTo.local.color}
+						style={resetBaseTo.local.color}
 						icon={onlyLocalAhead ? undefined : 'warning'}
 						kind="solid"
 						tooltip={onlyLocalAhead
 							? 'Push your local changes to upstream'
-							: resetBranchTo.local.tooltip}
-						loading={baseBranchIsUpdating}
-						disabled={$mode?.type !== 'OpenWorkspace' || baseBranchIsUpdating}
-						onclick={async () => {
-							if (onlyLocalAhead) {
-								await pushBaseBranch();
-								return;
-							}
-							await confirmResetBranch('local');
-						}}
+							: resetBaseTo.local.tooltip}
+						loading={baseBranchIsUpdating || confirmResetModalOpen}
+						disabled={$mode?.type !== 'OpenWorkspace' ||
+							baseBranchIsUpdating ||
+							confirmResetModalOpen}
+						onclick={resetBaseTo.local.handler}
 					>
-						{onlyLocalAhead ? 'Push' : resetBranchTo.local.title}
+						{onlyLocalAhead ? 'Push' : resetBaseTo.local.title}
 					</Button>
 
 					{#if onlyLocalAhead}
 						<Button
 							wide
-							style={resetBranchTo.remote.color}
+							style="error"
 							icon="warning"
 							kind="solid"
-							tooltip={resetBranchTo.remote.tooltip}
-							loading={baseBranchIsUpdating}
-							disabled={$mode?.type !== 'OpenWorkspace' || baseBranchIsUpdating}
-							onclick={async () => await confirmResetBranch('remote')}
+							tooltip="Discard your local changes"
+							disabled={$mode?.type !== 'OpenWorkspace' || integrateUpstreamModalOpen}
+							loading={integrateUpstreamModalOpen}
+							onclick={handleMergeUpstream}
 						>
-							{resetBranchTo.remote.title}
+							Discard local changes
 						</Button>
 					{/if}
 				</div>
@@ -369,46 +387,44 @@
 	{/snippet}
 </Modal>
 
-{#if resetActionType}
+{#if resetBaseStrategy}
 	<Modal
 		width="small"
-		title={resetBranchTo[resetActionType].title}
+		title={resetBaseTo[resetBaseStrategy].title}
 		bind:this={confirmResetModal}
-		onSubmit={(close) => {
-			if (resetActionType) {
-				resetBranchTo[resetActionType].action();
-			}
+		onSubmit={async (close) => {
+			if (resetBaseStrategy) await resetBaseTo[resetBaseStrategy].action();
 			close();
 		}}
 	>
 		<div class="modal-content">
 			<p class="text-12">
-				{#if resetActionType === 'remote'}
-					{base.divergedAhead.length > 1
-						? `You will lose the ${base.divergedAhead.length} local commits ahead of the remote branch.`
-						: 'You will lose the local commit ahead of the remote branch.'}
-				{:else}
-					You will force-push the local branch to the remote branch.
-					<br />
-					<br />
+				{resetBaseTo[resetBaseStrategy].content}
+				<br />
+				<br />
+				{#if resetBaseStrategy === 'local'}
 					{base.divergedBehind.length > 1
 						? `The ${base.divergedBehind.length} commits in the remote branch will be lost.`
 						: 'The commit in the remote branch will be lost.'}
+				{:else if resetBaseStrategy === 'remote'}
+					{base.divergedAhead.length > 1
+						? `The ${base.divergedAhead.length} commits in the local branch will be lost.`
+						: 'The commit in the local branch will be lost.'}
 				{/if}
 			</p>
 		</div>
 
 		{#snippet controls(close)}
-			{#if resetActionType}
-				<Button style="ghost" outline onclick={close}>Cancel</Button>
-				<Button style="error" kind="solid" type="submit" icon="warning"
-					>{resetBranchTo[resetActionType].title}</Button
-				>
-			{/if}
+			<Button style="ghost" outline onclick={close}>Cancel</Button>
+			<Button style="error" kind="solid" type="submit" icon="warning"
+				>{resetBaseTo[resetBaseStrategy!].title}</Button
+			>
 		{/snippet}
 	</Modal>
 {/if}
 
+<IntegrateUpstreamModal bind:this={integrateUpstreamModal} />
+
 <style>
 	.header-wrapper {
 		display: flex;
@@ -435,6 +451,7 @@
 		width: 100%;
 		gap: 8px;
 	}
+
 	.modal-content {
 		display: flex;
 		flex-direction: column;

From 20910252270b4b8813971b5424e08632f746912d Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Tue, 24 Sep 2024 17:16:26 +0200
Subject: [PATCH 07/12] Resolve upstream integration

Add a method to determine which should be the new base branch target commit ID based on what resolution approach is selected
---
 .../components/IntegrateUpstreamModal.svelte  | 49 +++++++++++++++++--
 .../vbranches/upstreamIntegrationService.ts   | 11 ++++-
 .../gitbutler-branch-actions/src/actions.rs   | 21 +++++++-
 crates/gitbutler-branch-actions/src/lib.rs    |  8 +--
 .../src/upstream_integration.rs               | 41 ++++++++++++++++
 crates/gitbutler-tauri/src/main.rs            |  1 +
 .../gitbutler-tauri/src/virtual_branches.rs   | 19 ++++++-
 7 files changed, 137 insertions(+), 13 deletions(-)

diff --git a/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte b/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
index 0a1d82ff3..6de80eb23 100644
--- a/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
+++ b/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
@@ -10,6 +10,7 @@
 		getResolutionApproach,
 		sortStatusInfo,
 		UpstreamIntegrationService,
+		type BaseBranchResolutionApproach,
 		type BranchStatusesWithBranches,
 		type BranchStatusInfo,
 		type Resolution
@@ -39,6 +40,8 @@
 	let results = $state(new SvelteMap<string, Resolution>());
 	let statuses = $state<BranchStatusInfo[]>([]);
 	let expanded = $state<boolean>(false);
+	let baseResolutionApproach = $state<BaseBranchResolutionApproach>('hardReset');
+	let targetId = $state<string | undefined>(undefined);
 
 	$effect(() => {
 		if ($branchStatuses?.type !== 'updatesRequired') {
@@ -68,6 +71,17 @@
 		statuses = statusesTmp;
 	});
 
+	$effect(() => {
+		if (targetId) {
+			branchStatuses = upstreamIntegrationService.upstreamStatuses(targetId);
+		}
+	});
+
+	async function handleBaseResolutionSelection(resolution: BaseBranchResolutionApproach) {
+		baseResolutionApproach = resolution;
+		targetId = await upstreamIntegrationService.resolveUpstreamIntegration(resolution);
+	}
+
 	async function integrate() {
 		integratingUpstream = 'loading';
 		await tick();
@@ -144,6 +158,34 @@
 					{/if}
 				</div>
 			{/if}
+
+			{#if $base?.diverged}
+				<div class="branch-status">
+					<div class="description">
+						<h5 class="text-16">{$base.branchName ?? 'Unknown'}</h5>
+						<p>Diverged</p>
+					</div>
+
+					<div class="action">
+						<Select
+							value={baseResolutionApproach}
+							onselect={handleBaseResolutionSelection}
+							options={[
+								{ label: 'Rebase', value: 'rebase' },
+								{ label: 'Merge', value: 'merge' },
+								{ label: 'Hard reset', value: 'hardReset' }
+							]}
+						>
+							{#snippet itemSnippet({ item, highlighted })}
+								<SelectItem selected={highlighted} {highlighted}>
+									{item.label}
+								</SelectItem>
+							{/snippet}
+						</Select>
+					</div>
+				</div>
+			{/if}
+
 			{#if statuses.length > 0}
 				<div class="statuses">
 					{#each statuses as { branch, status }}
@@ -168,11 +210,8 @@
 										onselect={(value) => {
 											const result = results.get(branch.id)!;
 
-											results.set(branch.id, {
-												...result,
-												approach: { type: value as 'rebase' | 'merge' | 'unapply' }
-											});
-										}}
+										results.set(branch.id, {...result, approach: { type: value }})
+									}}
 										options={[
 											{ label: 'Rebase', value: 'rebase' },
 											{ label: 'Merge', value: 'merge' },
diff --git a/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts b/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts
index 2f8ab47e4..79b50e278 100644
--- a/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts
+++ b/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts
@@ -37,6 +37,8 @@ export type Resolution = {
 	approach: ResolutionApproach;
 };
 
+export type BaseBranchResolutionApproach = 'rebase' | 'merge' | 'hardReset';
+
 export function getResolutionApproach(statusInfo: BranchStatusInfo): ResolutionApproach {
 	if (statusInfo.status.type === 'fullyIntegrated') {
 		return { type: 'delete' };
@@ -79,7 +81,7 @@ export class UpstreamIntegrationService {
 		private virtualBranchService: VirtualBranchService
 	) {}
 
-	upstreamStatuses(): Readable<BranchStatusesWithBranches | undefined> {
+	upstreamStatuses(_targetId?: string): Readable<BranchStatusesWithBranches | undefined> {
 		const branchStatuses = readable<BranchStatusesResponse | undefined>(undefined, (set) => {
 			invoke<BranchStatusesResponse>('upstream_integration_statuses', {
 				projectId: this.project.id
@@ -116,4 +118,11 @@ export class UpstreamIntegrationService {
 	async integrateUpstream(resolutions: Resolution[]) {
 		return await invoke('integrate_upstream', { projectId: this.project.id, resolutions });
 	}
+
+	async resolveUpstreamIntegration(type: BaseBranchResolutionApproach) {
+		return await invoke<string>('resolve_upstream_integration', {
+			projectId: this.project.id,
+			resolutionApproach: { type }
+		});
+	}
 }
diff --git a/crates/gitbutler-branch-actions/src/actions.rs b/crates/gitbutler-branch-actions/src/actions.rs
index 568aba5c0..f2bcf243e 100644
--- a/crates/gitbutler-branch-actions/src/actions.rs
+++ b/crates/gitbutler-branch-actions/src/actions.rs
@@ -1,5 +1,9 @@
 use super::r#virtual as vbranch;
-use crate::upstream_integration::{self, BranchStatuses, Resolution, UpstreamIntegrationContext};
+use crate::move_commits;
+use crate::reorder_commits;
+use crate::upstream_integration::{
+    self, BaseBranchResolutionApproach, BranchStatuses, Resolution, UpstreamIntegrationContext,
+};
 use crate::{
     base,
     base::BaseBranch,
@@ -9,7 +13,6 @@ use crate::{
     remote::{RemoteBranch, RemoteBranchData, RemoteCommit},
     VirtualBranchesExt,
 };
-use crate::{move_commits, reorder_commits};
 use anyhow::{Context, Result};
 use gitbutler_branch::{BranchCreateRequest, BranchId, BranchOwnershipClaims, BranchUpdateRequest};
 use gitbutler_command_context::CommandContext;
@@ -544,6 +547,20 @@ pub fn integrate_upstream(project: &Project, resolutions: &[Resolution]) -> Resu
     )
 }
 
+pub fn resolve_upstream_integration(
+    project: &Project,
+    resolution_approach: BaseBranchResolutionApproach,
+) -> Result<git2::Oid> {
+    let command_context = CommandContext::open(project)?;
+    let mut guard = project.exclusive_worktree_access();
+
+    upstream_integration::resolve_upstream_integration(
+        &command_context,
+        resolution_approach,
+        guard.write_permission(),
+    )
+}
+
 pub(crate) fn open_with_verify(project: &Project) -> Result<CommandContext> {
     let ctx = CommandContext::open(project)?;
     let mut guard = project.exclusive_worktree_access();
diff --git a/crates/gitbutler-branch-actions/src/lib.rs b/crates/gitbutler-branch-actions/src/lib.rs
index 417bf1a92..49b8e3cd6 100644
--- a/crates/gitbutler-branch-actions/src/lib.rs
+++ b/crates/gitbutler-branch-actions/src/lib.rs
@@ -9,10 +9,10 @@ pub use actions::{
     integrate_upstream_commits, list_local_branches, list_remote_commit_files,
     list_virtual_branches, list_virtual_branches_cached, move_commit, move_commit_file,
     push_base_branch, push_virtual_branch, reorder_commit, reset_files, reset_virtual_branch,
-    save_and_unapply_virutal_branch, set_base_branch, set_target_push_remote, squash,
-    unapply_ownership, unapply_without_saving_virtual_branch, undo_commit, update_base_branch,
-    update_branch_order, update_commit_message, update_virtual_branch,
-    upstream_integration_statuses,
+    resolve_upstream_integration, save_and_unapply_virutal_branch, set_base_branch,
+    set_target_push_remote, squash, unapply_ownership, unapply_without_saving_virtual_branch,
+    undo_commit, update_base_branch, update_branch_order, update_commit_message,
+    update_virtual_branch, upstream_integration_statuses,
 };
 
 mod r#virtual;
diff --git a/crates/gitbutler-branch-actions/src/upstream_integration.rs b/crates/gitbutler-branch-actions/src/upstream_integration.rs
index 1714cbe81..6055acd20 100644
--- a/crates/gitbutler-branch-actions/src/upstream_integration.rs
+++ b/crates/gitbutler-branch-actions/src/upstream_integration.rs
@@ -32,6 +32,14 @@ pub enum BranchStatuses {
     UpdatesRequired(Vec<(BranchId, BranchStatus)>),
 }
 
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[serde(tag = "type", content = "subject", rename_all = "camelCase")]
+pub enum BaseBranchResolutionApproach {
+    Rebase,
+    Merge,
+    HardReset,
+}
+
 #[derive(Serialize, Deserialize, PartialEq, Debug)]
 #[serde(tag = "type", content = "subject", rename_all = "camelCase")]
 enum ResolutionApproach {
@@ -313,6 +321,39 @@ pub(crate) fn integrate_upstream(
     Ok(())
 }
 
+pub(crate) fn resolve_upstream_integration(
+    command_context: &CommandContext,
+    resolution_approach: BaseBranchResolutionApproach,
+    permission: &mut WorktreeWritePermission,
+) -> Result<git2::Oid> {
+    let context = UpstreamIntegrationContext::open(command_context, permission)?;
+    let repo = command_context.repository();
+    let new_target_id = context.new_target.id();
+    let old_target_id = context.old_target.id();
+    let fork_point = repo.merge_base(old_target_id, new_target_id)?;
+
+    match resolution_approach {
+        BaseBranchResolutionApproach::HardReset => Ok(new_target_id),
+        BaseBranchResolutionApproach::Merge => {
+            let new_head = gitbutler_merge_commits(
+                repo,
+                context.old_target,
+                context.new_target,
+                &context.target_branch_name,
+                &context.target_branch_name,
+            )?;
+
+            Ok(new_head.id())
+        }
+        BaseBranchResolutionApproach::Rebase => {
+            let commits = repo.l(old_target_id, LogUntil::Commit(fork_point))?;
+            let new_head = cherry_rebase_group(repo, new_target_id, &commits, true)?;
+
+            Ok(new_head)
+        }
+    }
+}
+
 fn compute_resolutions(
     context: &UpstreamIntegrationContext,
     resolutions: &[Resolution],
diff --git a/crates/gitbutler-tauri/src/main.rs b/crates/gitbutler-tauri/src/main.rs
index 3de1b2d2d..9dbccb79b 100644
--- a/crates/gitbutler-tauri/src/main.rs
+++ b/crates/gitbutler-tauri/src/main.rs
@@ -188,6 +188,7 @@ fn main() {
                     virtual_branches::commands::normalize_branch_name,
                     virtual_branches::commands::upstream_integration_statuses,
                     virtual_branches::commands::integrate_upstream,
+                    virtual_branches::commands::resolve_upstream_integration,
                     virtual_branches::commands::find_commit,
                     stack::create_series,
                     stack::remove_series,
diff --git a/crates/gitbutler-tauri/src/virtual_branches.rs b/crates/gitbutler-tauri/src/virtual_branches.rs
index 928f553f3..5a5a2a950 100644
--- a/crates/gitbutler-tauri/src/virtual_branches.rs
+++ b/crates/gitbutler-tauri/src/virtual_branches.rs
@@ -4,7 +4,9 @@ pub mod commands {
         BranchCreateRequest, BranchId, BranchOwnershipClaims, BranchUpdateRequest,
     };
     use gitbutler_branch_actions::internal::PushResult;
-    use gitbutler_branch_actions::upstream_integration::{BranchStatuses, Resolution};
+    use gitbutler_branch_actions::upstream_integration::{
+        BaseBranchResolutionApproach, BranchStatuses, Resolution,
+    };
     use gitbutler_branch_actions::{
         BaseBranch, BranchListing, BranchListingDetails, BranchListingFilter, RemoteBranch,
         RemoteBranchData, RemoteBranchFile, RemoteCommit, VirtualBranches,
@@ -597,6 +599,21 @@ pub mod commands {
         Ok(())
     }
 
+    #[tauri::command(async)]
+    #[instrument(skip(projects), err(Debug))]
+    pub fn resolve_upstream_integration(
+        projects: State<'_, projects::Controller>,
+        project_id: ProjectId,
+        resolution_approach: BaseBranchResolutionApproach,
+    ) -> Result<String, Error> {
+        let project = projects.get(project_id)?;
+
+        let new_target_id =
+            gitbutler_branch_actions::resolve_upstream_integration(&project, resolution_approach)?;
+        let commit_id = git2::Oid::to_string(&new_target_id);
+        Ok(commit_id)
+    }
+
     pub(crate) fn emit_vbranches(windows: &WindowState, project_id: projects::ProjectId) {
         if let Err(error) = windows.post(gitbutler_watcher::Action::CalculateVirtualBranches(
             project_id,

From 1368d87ed00fe44742ba6441cd7d6b217d056eff Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Wed, 25 Sep 2024 14:05:04 +0200
Subject: [PATCH 08/12] Base branch divergence resolution

Allow the user to choose how to resolve the base-branch divergence
---
 .../components/IntegrateUpstreamModal.svelte  | 29 +++++++++----
 .../vbranches/upstreamIntegrationService.ts   | 30 ++++++++++++--
 .../gitbutler-branch-actions/src/actions.rs   | 21 ++++++++--
 .../src/upstream_integration.rs               | 41 ++++++++++++++++---
 .../gitbutler-tauri/src/virtual_branches.rs   | 16 ++++++--
 5 files changed, 113 insertions(+), 24 deletions(-)

diff --git a/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte b/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
index 6de80eb23..9193c18a6 100644
--- a/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
+++ b/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
@@ -7,6 +7,7 @@
 	import SelectItem from '$lib/select/SelectItem.svelte';
 	import { getContext } from '$lib/utils/context';
 	import {
+		getBaseBrancheResolution,
 		getResolutionApproach,
 		sortStatusInfo,
 		UpstreamIntegrationService,
@@ -41,7 +42,7 @@
 	let statuses = $state<BranchStatusInfo[]>([]);
 	let expanded = $state<boolean>(false);
 	let baseResolutionApproach = $state<BaseBranchResolutionApproach>('hardReset');
-	let targetId = $state<string | undefined>(undefined);
+	let targetCommitOid = $state<string | undefined>(undefined);
 
 	$effect(() => {
 		if ($branchStatuses?.type !== 'updatesRequired') {
@@ -71,21 +72,35 @@
 		statuses = statusesTmp;
 	});
 
+	// Re-fetch upstream statuses if the target commit oid changes
 	$effect(() => {
-		if (targetId) {
-			branchStatuses = upstreamIntegrationService.upstreamStatuses(targetId);
+		if (targetCommitOid) {
+			branchStatuses = upstreamIntegrationService.upstreamStatuses(targetCommitOid);
 		}
 	});
 
-	async function handleBaseResolutionSelection(resolution: BaseBranchResolutionApproach) {
+	// Resolve the target commit oid if the base branch diverged and the the resolution
+	// approach is changed
+	$effect(() => {
+		if ($base?.diverged) {
+			upstreamIntegrationService.resolveUpstreamIntegration(baseResolutionApproach).then((Oid) => {
+				targetCommitOid = Oid;
+			});
+		}
+	});
+
+	function handleBaseResolutionSelection(resolution: BaseBranchResolutionApproach) {
 		baseResolutionApproach = resolution;
-		targetId = await upstreamIntegrationService.resolveUpstreamIntegration(resolution);
 	}
 
 	async function integrate() {
 		integratingUpstream = 'loading';
 		await tick();
-		await upstreamIntegrationService.integrateUpstream(Array.from(results.values()));
+		const baseResolution = getBaseBrancheResolution(targetCommitOid, baseResolutionApproach);
+		await upstreamIntegrationService.integrateUpstream(
+			Array.from(results.values()),
+			baseResolution
+		);
 		await baseBranchService.refresh();
 		integratingUpstream = 'completed';
 
@@ -172,7 +187,7 @@
 							onselect={handleBaseResolutionSelection}
 							options={[
 								{ label: 'Rebase', value: 'rebase' },
-								{ label: 'Merge', value: 'merge' },
+								// { label: 'Merge', value: 'merge' }, hide merging for now
 								{ label: 'Hard reset', value: 'hardReset' }
 							]}
 						>
diff --git a/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts b/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts
index 79b50e278..3b75a18e3 100644
--- a/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts
+++ b/apps/desktop/src/lib/vbranches/upstreamIntegrationService.ts
@@ -39,6 +39,23 @@ export type Resolution = {
 
 export type BaseBranchResolutionApproach = 'rebase' | 'merge' | 'hardReset';
 
+export type BaseBranchResolution = {
+	targetCommitOid: string;
+	approach: { type: BaseBranchResolutionApproach };
+};
+
+export function getBaseBrancheResolution(
+	targetCommitOid: string | undefined,
+	approach: BaseBranchResolutionApproach
+): BaseBranchResolution | undefined {
+	if (!targetCommitOid) return;
+
+	return {
+		targetCommitOid,
+		approach: { type: approach }
+	};
+}
+
 export function getResolutionApproach(statusInfo: BranchStatusInfo): ResolutionApproach {
 	if (statusInfo.status.type === 'fullyIntegrated') {
 		return { type: 'delete' };
@@ -81,10 +98,11 @@ export class UpstreamIntegrationService {
 		private virtualBranchService: VirtualBranchService
 	) {}
 
-	upstreamStatuses(_targetId?: string): Readable<BranchStatusesWithBranches | undefined> {
+	upstreamStatuses(targetCommitOid?: string): Readable<BranchStatusesWithBranches | undefined> {
 		const branchStatuses = readable<BranchStatusesResponse | undefined>(undefined, (set) => {
 			invoke<BranchStatusesResponse>('upstream_integration_statuses', {
-				projectId: this.project.id
+				projectId: this.project.id,
+				targetCommitOid
 			}).then(set);
 		});
 
@@ -115,8 +133,12 @@ export class UpstreamIntegrationService {
 		return branchStatusesWithBranches;
 	}
 
-	async integrateUpstream(resolutions: Resolution[]) {
-		return await invoke('integrate_upstream', { projectId: this.project.id, resolutions });
+	async integrateUpstream(resolutions: Resolution[], baseBranchResolution?: BaseBranchResolution) {
+		return await invoke('integrate_upstream', {
+			projectId: this.project.id,
+			resolutions,
+			baseBranchResolution
+		});
 	}
 
 	async resolveUpstreamIntegration(type: BaseBranchResolutionApproach) {
diff --git a/crates/gitbutler-branch-actions/src/actions.rs b/crates/gitbutler-branch-actions/src/actions.rs
index f2bcf243e..c807d4831 100644
--- a/crates/gitbutler-branch-actions/src/actions.rs
+++ b/crates/gitbutler-branch-actions/src/actions.rs
@@ -2,7 +2,8 @@ use super::r#virtual as vbranch;
 use crate::move_commits;
 use crate::reorder_commits;
 use crate::upstream_integration::{
-    self, BaseBranchResolutionApproach, BranchStatuses, Resolution, UpstreamIntegrationContext,
+    self, BaseBranchResolution, BaseBranchResolutionApproach, BranchStatuses, Resolution,
+    UpstreamIntegrationContext,
 };
 use crate::{
     base,
@@ -522,16 +523,27 @@ pub fn get_uncommited_files_reusable(project: &Project) -> Result<DiffByPathMap>
     crate::branch::get_uncommited_files_raw(&context, guard.read_permission())
 }
 
-pub fn upstream_integration_statuses(project: &Project) -> Result<BranchStatuses> {
+pub fn upstream_integration_statuses(
+    project: &Project,
+    target_commit_oid: Option<git2::Oid>,
+) -> Result<BranchStatuses> {
     let command_context = CommandContext::open(project)?;
     let mut guard = project.exclusive_worktree_access();
 
-    let context = UpstreamIntegrationContext::open(&command_context, guard.write_permission())?;
+    let context = UpstreamIntegrationContext::open(
+        &command_context,
+        target_commit_oid,
+        guard.write_permission(),
+    )?;
 
     upstream_integration::upstream_integration_statuses(&context)
 }
 
-pub fn integrate_upstream(project: &Project, resolutions: &[Resolution]) -> Result<()> {
+pub fn integrate_upstream(
+    project: &Project,
+    resolutions: &[Resolution],
+    base_branch_resolution: Option<BaseBranchResolution>,
+) -> Result<()> {
     let command_context = CommandContext::open(project)?;
     let mut guard = project.exclusive_worktree_access();
 
@@ -543,6 +555,7 @@ pub fn integrate_upstream(project: &Project, resolutions: &[Resolution]) -> Resu
     upstream_integration::integrate_upstream(
         &command_context,
         resolutions,
+        base_branch_resolution,
         guard.write_permission(),
     )
 }
diff --git a/crates/gitbutler-branch-actions/src/upstream_integration.rs b/crates/gitbutler-branch-actions/src/upstream_integration.rs
index 6055acd20..0631b9e6f 100644
--- a/crates/gitbutler-branch-actions/src/upstream_integration.rs
+++ b/crates/gitbutler-branch-actions/src/upstream_integration.rs
@@ -49,6 +49,14 @@ enum ResolutionApproach {
     Delete,
 }
 
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct BaseBranchResolution {
+    #[serde(with = "gitbutler_serde::oid")]
+    target_commit_oid: git2::Oid,
+    approach: BaseBranchResolutionApproach,
+}
+
 impl BranchStatus {
     fn resolution_acceptable(&self, approach: &ResolutionApproach) -> bool {
         match self {
@@ -91,6 +99,7 @@ pub struct UpstreamIntegrationContext<'a> {
 impl<'a> UpstreamIntegrationContext<'a> {
     pub(crate) fn open(
         command_context: &'a CommandContext,
+        target_commit_oid: Option<git2::Oid>,
         permission: &'a mut WorktreeWritePermission,
     ) -> Result<Self> {
         let virtual_branches_handle = command_context.project().virtual_branches();
@@ -99,7 +108,12 @@ impl<'a> UpstreamIntegrationContext<'a> {
         let target_branch = repository
             .find_branch_by_refname(&target.branch.clone().into())?
             .ok_or(anyhow!("Branch not found"))?;
-        let new_target = target_branch.get().peel_to_commit()?;
+
+        let new_target = target_commit_oid.map_or_else(
+            || target_branch.get().peel_to_commit(),
+            |oid| repository.find_commit(oid),
+        )?;
+
         let old_target = repository.find_commit(target.sha)?;
         let virtual_branches_in_workspace = virtual_branches_handle.list_branches_in_workspace()?;
 
@@ -211,9 +225,14 @@ pub fn upstream_integration_statuses(
 pub(crate) fn integrate_upstream(
     command_context: &CommandContext,
     resolutions: &[Resolution],
+    base_branch_resolution: Option<BaseBranchResolution>,
     permission: &mut WorktreeWritePermission,
 ) -> Result<()> {
-    let context = UpstreamIntegrationContext::open(command_context, permission)?;
+    let (target_commit_oid, base_branch_resolution_approach) = base_branch_resolution
+        .map(|r| (Some(r.target_commit_oid), Some(r.approach)))
+        .unwrap_or((None, None));
+
+    let context = UpstreamIntegrationContext::open(command_context, target_commit_oid, permission)?;
     let virtual_branches_state = VirtualBranchesHandle::new(command_context.project().gb_dir());
     let default_target = virtual_branches_state.get_default_target()?;
 
@@ -258,7 +277,8 @@ pub(crate) fn integrate_upstream(
         }
     }
 
-    let integration_results = compute_resolutions(&context, resolutions)?;
+    let integration_results =
+        compute_resolutions(&context, resolutions, base_branch_resolution_approach)?;
 
     {
         // We preform the updates in stages. If deleting or unapplying fails, we
@@ -326,7 +346,7 @@ pub(crate) fn resolve_upstream_integration(
     resolution_approach: BaseBranchResolutionApproach,
     permission: &mut WorktreeWritePermission,
 ) -> Result<git2::Oid> {
-    let context = UpstreamIntegrationContext::open(command_context, permission)?;
+    let context = UpstreamIntegrationContext::open(command_context, None, permission)?;
     let repo = command_context.repository();
     let new_target_id = context.new_target.id();
     let old_target_id = context.old_target.id();
@@ -357,10 +377,12 @@ pub(crate) fn resolve_upstream_integration(
 fn compute_resolutions(
     context: &UpstreamIntegrationContext,
     resolutions: &[Resolution],
+    base_branch_resolution_approach: Option<BaseBranchResolutionApproach>,
 ) -> Result<Vec<(BranchId, IntegrationResult)>> {
     let UpstreamIntegrationContext {
         repository,
         new_target,
+        old_target,
         virtual_branches_in_workspace,
         target_branch_name,
         ..
@@ -443,9 +465,17 @@ fn compute_resolutions(
                     // Rebase the commits, then try rebasing the tree. If
                     // the tree ends up conflicted, commit the tree.
 
+                    // If the base branch needs to resolve its divergence
+                    // pick only the commits that are ahead of the old target head
+                    let lower_bound = if base_branch_resolution_approach.is_some() {
+                        old_target.id()
+                    } else {
+                        new_target.id()
+                    };
+
                     // Rebase virtual branches' commits
                     let virtual_branch_commits =
-                        repository.l(virtual_branch.head, LogUntil::Commit(new_target.id()))?;
+                        repository.l(virtual_branch.head, LogUntil::Commit(lower_bound))?;
 
                     let new_head = cherry_rebase_group(
                         repository,
@@ -636,6 +666,7 @@ mod test {
                 branch_tree: branch.tree,
                 approach: ResolutionApproach::Rebase,
             }],
+            None,
         )
         .unwrap();
 
diff --git a/crates/gitbutler-tauri/src/virtual_branches.rs b/crates/gitbutler-tauri/src/virtual_branches.rs
index 5a5a2a950..120d322d2 100644
--- a/crates/gitbutler-tauri/src/virtual_branches.rs
+++ b/crates/gitbutler-tauri/src/virtual_branches.rs
@@ -5,7 +5,7 @@ pub mod commands {
     };
     use gitbutler_branch_actions::internal::PushResult;
     use gitbutler_branch_actions::upstream_integration::{
-        BaseBranchResolutionApproach, BranchStatuses, Resolution,
+        BaseBranchResolution, BaseBranchResolutionApproach, BranchStatuses, Resolution,
     };
     use gitbutler_branch_actions::{
         BaseBranch, BranchListing, BranchListingDetails, BranchListingFilter, RemoteBranch,
@@ -575,10 +575,14 @@ pub mod commands {
     pub fn upstream_integration_statuses(
         projects: State<'_, projects::Controller>,
         project_id: ProjectId,
+        target_commit_oid: Option<String>,
     ) -> Result<BranchStatuses, Error> {
         let project = projects.get(project_id)?;
+        let commit_oid = target_commit_oid
+            .map(|commit_id| git2::Oid::from_str(&commit_id).map_err(|e| anyhow!(e)))
+            .transpose()?;
         Ok(gitbutler_branch_actions::upstream_integration_statuses(
-            &project,
+            &project, commit_oid,
         )?)
     }
 
@@ -589,10 +593,14 @@ pub mod commands {
         projects: State<'_, projects::Controller>,
         project_id: ProjectId,
         resolutions: Vec<Resolution>,
+        base_branch_resolution: Option<BaseBranchResolution>,
     ) -> Result<(), Error> {
         let project = projects.get(project_id)?;
-
-        gitbutler_branch_actions::integrate_upstream(&project, &resolutions)?;
+        gitbutler_branch_actions::integrate_upstream(
+            &project,
+            &resolutions,
+            base_branch_resolution,
+        )?;
 
         emit_vbranches(&windows, project_id);
 

From 9834627a20c400e65d0f8f7a73690dba5b4feff0 Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Wed, 25 Sep 2024 14:34:10 +0200
Subject: [PATCH 09/12] Base: Propagate the conflicting status to the commits

---
 apps/desktop/src/lib/baseBranch/baseBranch.ts     |  1 +
 apps/desktop/src/lib/commit/CommitCard.svelte     |  2 +-
 apps/desktop/src/lib/components/BaseBranch.svelte | 14 ++++++++++----
 apps/desktop/src/lib/vbranches/types.ts           |  1 +
 crates/gitbutler-branch-actions/src/base.rs       |  5 +++++
 crates/gitbutler-branch-actions/src/remote.rs     |  2 ++
 6 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/apps/desktop/src/lib/baseBranch/baseBranch.ts b/apps/desktop/src/lib/baseBranch/baseBranch.ts
index f66ec5203..901b6ab6b 100644
--- a/apps/desktop/src/lib/baseBranch/baseBranch.ts
+++ b/apps/desktop/src/lib/baseBranch/baseBranch.ts
@@ -17,6 +17,7 @@ export class BaseBranch {
 	@Type(() => Commit)
 	recentCommits!: Commit[];
 	lastFetchedMs?: number;
+	conflicted!: boolean;
 	diverged!: boolean;
 	divergedAhead!: string[];
 	divergedBehind!: string[];
diff --git a/apps/desktop/src/lib/commit/CommitCard.svelte b/apps/desktop/src/lib/commit/CommitCard.svelte
index bb1ac0969..87cb4e396 100644
--- a/apps/desktop/src/lib/commit/CommitCard.svelte
+++ b/apps/desktop/src/lib/commit/CommitCard.svelte
@@ -142,7 +142,7 @@
 		modeService!.enterEditMode(commit.id, branch!.refname);
 	}
 
-	$: conflicted = commit instanceof DetailedCommit && commit.conflicted;
+	$: conflicted = commit.conflicted;
 </script>
 
 <Modal bind:this={commitMessageModal} width="small" onSubmit={submitCommitMessageModal}>
diff --git a/apps/desktop/src/lib/components/BaseBranch.svelte b/apps/desktop/src/lib/components/BaseBranch.svelte
index 2526c9d51..936362165 100644
--- a/apps/desktop/src/lib/components/BaseBranch.svelte
+++ b/apps/desktop/src/lib/components/BaseBranch.svelte
@@ -66,6 +66,7 @@
 	);
 
 	let baseBranchIsUpdating = $state<boolean>(false);
+	const baseBranchConflicted = $derived(base.conflicted);
 	let updateTargetModal = $state<Modal>();
 	let resetBaseStrategy = $state<ResetBaseStrategy | undefined>(undefined);
 	let confirmResetModal = $state<Modal>();
@@ -74,6 +75,12 @@
 	const integrateUpstreamModalOpen = $derived(!!integrateUpstreamModal?.imports.open);
 	let mergeUpstreamWarningDismissedCheckbox = $state<boolean>(false);
 
+	const pushButtonTooltip = $derived.by(() => {
+		if (onlyLocalAhead) return 'Push your local changes to upstream';
+		if (base.conflicted) return 'Cannot push while there are conflicts';
+		return resetBaseTo.local.tooltip;
+	});
+
 	const multiple = $derived(
 		base ? base.upstreamCommits.length > 1 || base.upstreamCommits.length === 0 : false
 	);
@@ -296,13 +303,12 @@
 						style={resetBaseTo.local.color}
 						icon={onlyLocalAhead ? undefined : 'warning'}
 						kind="solid"
-						tooltip={onlyLocalAhead
-							? 'Push your local changes to upstream'
-							: resetBaseTo.local.tooltip}
+						tooltip={pushButtonTooltip}
 						loading={baseBranchIsUpdating || confirmResetModalOpen}
 						disabled={$mode?.type !== 'OpenWorkspace' ||
 							baseBranchIsUpdating ||
-							confirmResetModalOpen}
+							confirmResetModalOpen ||
+							baseBranchConflicted}
 						onclick={resetBaseTo.local.handler}
 					>
 						{onlyLocalAhead ? 'Push' : resetBaseTo.local.title}
diff --git a/apps/desktop/src/lib/vbranches/types.ts b/apps/desktop/src/lib/vbranches/types.ts
index df559ac0a..1a13c5840 100644
--- a/apps/desktop/src/lib/vbranches/types.ts
+++ b/apps/desktop/src/lib/vbranches/types.ts
@@ -228,6 +228,7 @@ export class Commit {
 	changeId!: string;
 	isSigned!: boolean;
 	parentIds!: string[];
+	conflicted!: boolean;
 
 	prev?: Commit;
 	next?: Commit;
diff --git a/crates/gitbutler-branch-actions/src/base.rs b/crates/gitbutler-branch-actions/src/base.rs
index 7e81de9c6..5e011163b 100644
--- a/crates/gitbutler-branch-actions/src/base.rs
+++ b/crates/gitbutler-branch-actions/src/base.rs
@@ -39,6 +39,7 @@ pub struct BaseBranch {
     pub upstream_commits: Vec<RemoteCommit>,
     pub recent_commits: Vec<RemoteCommit>,
     pub last_fetched_ms: Option<u128>,
+    pub conflicted: bool,
     pub diverged: bool,
     #[serde(with = "gitbutler_serde::oid_vec")]
     pub diverged_ahead: Vec<git2::Oid>,
@@ -607,6 +608,9 @@ pub(crate) fn target_to_base_branch(ctx: &CommandContext, target: &Target) -> Re
         .map(commit_to_remote_commit)
         .collect::<Vec<_>>();
 
+    // we assume that only local commits can be conflicted
+    let conflicted = recent_commits.iter().any(|commit| commit.conflicted);
+
     // there has got to be a better way to do this.
     let push_remote_url = match target.push_remote_name {
         Some(ref name) => match repo.find_remote(name) {
@@ -637,6 +641,7 @@ pub(crate) fn target_to_base_branch(ctx: &CommandContext, target: &Target) -> Re
             .map(FetchResult::timestamp)
             .copied()
             .map(|t| t.duration_since(time::UNIX_EPOCH).unwrap().as_millis()),
+        conflicted,
         diverged,
         diverged_ahead,
         diverged_behind,
diff --git a/crates/gitbutler-branch-actions/src/remote.rs b/crates/gitbutler-branch-actions/src/remote.rs
index b5b120929..92274d969 100644
--- a/crates/gitbutler-branch-actions/src/remote.rs
+++ b/crates/gitbutler-branch-actions/src/remote.rs
@@ -55,6 +55,7 @@ pub struct RemoteCommit {
     pub change_id: Option<String>,
     #[serde(with = "gitbutler_serde::oid_vec")]
     pub parent_ids: Vec<git2::Oid>,
+    pub conflicted: bool,
 }
 
 /// Return information on all local branches, while skipping gitbutler-specific branches in `refs/heads`.
@@ -206,6 +207,7 @@ pub(crate) fn commit_to_remote_commit(commit: &git2::Commit) -> RemoteCommit {
         author: commit.author().into(),
         change_id: commit.change_id(),
         parent_ids,
+        conflicted: commit.is_conflicted(),
     }
 }
 

From adf33ac445c70d1851dcbbdea4069a4cb0151a7f Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Mon, 30 Sep 2024 16:26:19 +0200
Subject: [PATCH 10/12] Upstream integration: Add some tests related to
 divergence resolution

Add tests regarding resolving divergence of the base branch with upstream
---
 .../src/upstream_integration.rs               | 377 ++++++++++++++++++
 1 file changed, 377 insertions(+)

diff --git a/crates/gitbutler-branch-actions/src/upstream_integration.rs b/crates/gitbutler-branch-actions/src/upstream_integration.rs
index 0631b9e6f..95a852b41 100644
--- a/crates/gitbutler-branch-actions/src/upstream_integration.rs
+++ b/crates/gitbutler-branch-actions/src/upstream_integration.rs
@@ -686,6 +686,383 @@ mod test {
         assert_eq!(head_tree.id(), tree)
     }
 
+    #[test]
+    fn test_conflicted_head_branch_resolve_divergence_hard_reset() {
+        let test_repository = TestingRepository::open();
+        let initial_commit = test_repository.commit_tree(None, &[("foo.txt", "bar")]);
+        let old_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "baz")]);
+        let branch_head = test_repository.commit_tree(Some(&old_target), &[("foo.txt", "fux")]);
+        // new target diverged from old target
+        let new_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "qux")]);
+
+        let branch = make_branch(branch_head.id(), branch_head.tree_id());
+
+        let context = UpstreamIntegrationContext {
+            _permission: None,
+            old_target,
+            new_target: new_target.clone(),
+            repository: &test_repository.repository,
+            virtual_branches_in_workspace: vec![branch.clone()],
+            target_branch_name: "main".to_string(),
+        };
+
+        assert_eq!(
+            upstream_integration_statuses(&context).unwrap(),
+            BranchStatuses::UpdatesRequired(vec![(
+                branch.id,
+                BranchStatus::Conflicted {
+                    potentially_conflicted_uncommited_changes: false
+                }
+            )]),
+        );
+
+        let updates = compute_resolutions(
+            &context,
+            &[Resolution {
+                branch_id: branch.id,
+                branch_tree: branch.tree,
+                approach: ResolutionApproach::Rebase,
+            }],
+            Some(BaseBranchResolutionApproach::HardReset),
+        )
+        .unwrap();
+
+        assert_eq!(updates.len(), 1);
+        let IntegrationResult::UpdatedObjects { head, tree } = updates[0].1 else {
+            panic!("Should be variant UpdatedObjects")
+        };
+
+        let head_commit = test_repository.repository.find_commit(head).unwrap();
+        assert_eq!(head_commit.parent(0).unwrap().id(), new_target.id());
+        assert!(head_commit.is_conflicted());
+
+        let head_tree = test_repository
+            .repository
+            .find_real_tree(&head_commit, Default::default())
+            .unwrap();
+        assert_eq!(head_tree.id(), tree)
+    }
+
+    #[test]
+    fn test_unconflicted_head_branch_resolve_divergence_hard_reset() {
+        let test_repository = TestingRepository::open();
+        let initial_commit = test_repository.commit_tree(None, &[("foo.txt", "bar")]);
+        let old_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "baz")]);
+        let branch_head =
+            test_repository.commit_tree(Some(&old_target), &[("bar.txt", "no problem")]);
+        // new target diverged from old target
+        let new_target =
+            test_repository.commit_tree(Some(&initial_commit), &[("other.txt", "qux")]);
+
+        let branch = make_branch(branch_head.id(), branch_head.tree_id());
+
+        let context = UpstreamIntegrationContext {
+            _permission: None,
+            old_target,
+            new_target: new_target.clone(),
+            repository: &test_repository.repository,
+            virtual_branches_in_workspace: vec![branch.clone()],
+            target_branch_name: "main".to_string(),
+        };
+
+        assert_eq!(
+            upstream_integration_statuses(&context).unwrap(),
+            BranchStatuses::UpdatesRequired(vec![(branch.id, BranchStatus::SaflyUpdatable)]),
+        );
+
+        let updates = compute_resolutions(
+            &context,
+            &[Resolution {
+                branch_id: branch.id,
+                branch_tree: branch.tree,
+                approach: ResolutionApproach::Rebase,
+            }],
+            Some(BaseBranchResolutionApproach::HardReset),
+        )
+        .unwrap();
+
+        assert_eq!(updates.len(), 1);
+        let IntegrationResult::UpdatedObjects { head, tree } = updates[0].1 else {
+            panic!("Should be variant UpdatedObjects")
+        };
+
+        let head_commit = test_repository.repository.find_commit(head).unwrap();
+        assert_eq!(head_commit.parent(0).unwrap().id(), new_target.id());
+        assert!(!head_commit.is_conflicted());
+
+        let head_tree = test_repository
+            .repository
+            .find_real_tree(&head_commit, Default::default())
+            .unwrap();
+        assert_eq!(head_tree.id(), tree)
+    }
+
+    #[test]
+    fn test_conflicted_head_branch_resolve_divergence_rebase() {
+        let test_repository = TestingRepository::open();
+        let initial_commit = test_repository.commit_tree(None, &[("foo.txt", "bar")]);
+        let old_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "baz")]);
+        let branch_head = test_repository.commit_tree(Some(&old_target), &[("foo.txt", "fux")]);
+        // new target diverged from old target
+        let new_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "qux")]);
+
+        let branch = make_branch(branch_head.id(), branch_head.tree_id());
+
+        let commits_to_rebase = test_repository
+            .repository
+            .l(old_target.id(), LogUntil::Commit(initial_commit.id()))
+            .unwrap();
+        let head_after_rebase = cherry_rebase_group(
+            &test_repository.repository,
+            new_target.id(),
+            &commits_to_rebase,
+            true,
+        )
+        .unwrap();
+
+        let context = UpstreamIntegrationContext {
+            _permission: None,
+            old_target,
+            new_target: test_repository
+                .repository
+                .find_commit(head_after_rebase)
+                .unwrap(),
+            repository: &test_repository.repository,
+            virtual_branches_in_workspace: vec![branch.clone()],
+            target_branch_name: "main".to_string(),
+        };
+
+        assert_eq!(
+            upstream_integration_statuses(&context).unwrap(),
+            BranchStatuses::UpdatesRequired(vec![(
+                branch.id,
+                BranchStatus::Conflicted {
+                    potentially_conflicted_uncommited_changes: false
+                }
+            )]),
+        );
+
+        let updates = compute_resolutions(
+            &context,
+            &[Resolution {
+                branch_id: branch.id,
+                branch_tree: branch.tree,
+                approach: ResolutionApproach::Rebase,
+            }],
+            Some(BaseBranchResolutionApproach::Rebase),
+        )
+        .unwrap();
+
+        assert_eq!(updates.len(), 1);
+        let IntegrationResult::UpdatedObjects { head, tree } = updates[0].1 else {
+            panic!("Should be variant UpdatedObjects")
+        };
+
+        let head_commit = test_repository.repository.find_commit(head).unwrap();
+        assert_eq!(head_commit.parent(0).unwrap().id(), head_after_rebase);
+        assert!(head_commit.is_conflicted());
+
+        let head_tree = test_repository
+            .repository
+            .find_real_tree(&head_commit, Default::default())
+            .unwrap();
+        assert_eq!(head_tree.id(), tree)
+    }
+
+    #[test]
+    fn test_unconflicted_head_branch_resolve_divergence_rebase() {
+        let test_repository = TestingRepository::open();
+        let initial_commit = test_repository.commit_tree(None, &[("foo.txt", "bar")]);
+        let old_target = test_repository.commit_tree(Some(&initial_commit), &[("bar.txt", "baz")]);
+        let branch_head = test_repository.commit_tree(Some(&old_target), &[("bar.txt", "fux")]);
+        // new target diverged from old target
+        let new_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "qux")]);
+
+        let branch = make_branch(branch_head.id(), branch_head.tree_id());
+
+        let commits_to_rebase = test_repository
+            .repository
+            .l(old_target.id(), LogUntil::Commit(initial_commit.id()))
+            .unwrap();
+        let head_after_rebase = cherry_rebase_group(
+            &test_repository.repository,
+            new_target.id(),
+            &commits_to_rebase,
+            true,
+        )
+        .unwrap();
+
+        let context = UpstreamIntegrationContext {
+            _permission: None,
+            old_target,
+            new_target: test_repository
+                .repository
+                .find_commit(head_after_rebase)
+                .unwrap(),
+            repository: &test_repository.repository,
+            virtual_branches_in_workspace: vec![branch.clone()],
+            target_branch_name: "main".to_string(),
+        };
+
+        assert_eq!(
+            upstream_integration_statuses(&context).unwrap(),
+            BranchStatuses::UpdatesRequired(vec![(branch.id, BranchStatus::SaflyUpdatable)]),
+        );
+
+        let updates = compute_resolutions(
+            &context,
+            &[Resolution {
+                branch_id: branch.id,
+                branch_tree: branch.tree,
+                approach: ResolutionApproach::Rebase,
+            }],
+            Some(BaseBranchResolutionApproach::Rebase),
+        )
+        .unwrap();
+
+        assert_eq!(updates.len(), 1);
+        let IntegrationResult::UpdatedObjects { head, tree } = updates[0].1 else {
+            panic!("Should be variant UpdatedObjects")
+        };
+
+        let head_commit = test_repository.repository.find_commit(head).unwrap();
+        assert_eq!(head_commit.parent(0).unwrap().id(), head_after_rebase);
+        assert!(!head_commit.is_conflicted());
+
+        let head_tree = test_repository
+            .repository
+            .find_real_tree(&head_commit, Default::default())
+            .unwrap();
+        assert_eq!(head_tree.id(), tree)
+    }
+
+    #[test]
+    fn test_conflicted_head_branch_resolve_divergence_merge() {
+        let test_repository = TestingRepository::open();
+        let initial_commit = test_repository.commit_tree(None, &[("foo.txt", "bar")]);
+        let old_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "baz")]);
+        let branch_head = test_repository.commit_tree(Some(&old_target), &[("foo.txt", "fux")]);
+        // new target diverged from old target
+        let new_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "qux")]);
+
+        let branch = make_branch(branch_head.id(), branch_head.tree_id());
+
+        let merge_commit = gitbutler_merge_commits(
+            &test_repository.repository,
+            old_target.clone(),
+            new_target,
+            "main",
+            "main",
+        )
+        .unwrap();
+
+        let context = UpstreamIntegrationContext {
+            _permission: None,
+            old_target,
+            new_target: merge_commit.clone(),
+            repository: &test_repository.repository,
+            virtual_branches_in_workspace: vec![branch.clone()],
+            target_branch_name: "main".to_string(),
+        };
+
+        assert_eq!(
+            upstream_integration_statuses(&context).unwrap(),
+            BranchStatuses::UpdatesRequired(vec![(
+                branch.id,
+                BranchStatus::Conflicted {
+                    potentially_conflicted_uncommited_changes: false
+                }
+            )]),
+        );
+
+        let updates = compute_resolutions(
+            &context,
+            &[Resolution {
+                branch_id: branch.id,
+                branch_tree: branch.tree,
+                approach: ResolutionApproach::Rebase,
+            }],
+            Some(BaseBranchResolutionApproach::Merge),
+        )
+        .unwrap();
+
+        assert_eq!(updates.len(), 1);
+        let IntegrationResult::UpdatedObjects { head, tree } = updates[0].1 else {
+            panic!("Should be variant UpdatedObjects")
+        };
+
+        let head_commit = test_repository.repository.find_commit(head).unwrap();
+        assert_eq!(head_commit.parent(0).unwrap().id(), merge_commit.id());
+        assert!(head_commit.is_conflicted());
+
+        let head_tree = test_repository
+            .repository
+            .find_real_tree(&head_commit, Default::default())
+            .unwrap();
+        assert_eq!(head_tree.id(), tree)
+    }
+
+    #[test]
+    fn test_unconflicted_head_branch_resolve_divergence_merge() {
+        let test_repository = TestingRepository::open();
+        let initial_commit = test_repository.commit_tree(None, &[("foo.txt", "bar")]);
+        let old_target = test_repository.commit_tree(Some(&initial_commit), &[("bar.txt", "baz")]);
+        let branch_head = test_repository.commit_tree(Some(&old_target), &[("bar.txt", "fux")]);
+        // new target diverged from old target
+        let new_target = test_repository.commit_tree(Some(&initial_commit), &[("foo.txt", "qux")]);
+
+        let branch = make_branch(branch_head.id(), branch_head.tree_id());
+
+        let merge_commit = gitbutler_merge_commits(
+            &test_repository.repository,
+            old_target.clone(),
+            new_target,
+            "main",
+            "main",
+        )
+        .unwrap();
+
+        let context = UpstreamIntegrationContext {
+            _permission: None,
+            old_target,
+            new_target: merge_commit.clone(),
+            repository: &test_repository.repository,
+            virtual_branches_in_workspace: vec![branch.clone()],
+            target_branch_name: "main".to_string(),
+        };
+
+        assert_eq!(
+            upstream_integration_statuses(&context).unwrap(),
+            BranchStatuses::UpdatesRequired(vec![(branch.id, BranchStatus::SaflyUpdatable)]),
+        );
+
+        let updates = compute_resolutions(
+            &context,
+            &[Resolution {
+                branch_id: branch.id,
+                branch_tree: branch.tree,
+                approach: ResolutionApproach::Rebase,
+            }],
+            Some(BaseBranchResolutionApproach::Merge),
+        )
+        .unwrap();
+
+        assert_eq!(updates.len(), 1);
+        let IntegrationResult::UpdatedObjects { head, tree } = updates[0].1 else {
+            panic!("Should be variant UpdatedObjects")
+        };
+
+        let head_commit = test_repository.repository.find_commit(head).unwrap();
+        assert_eq!(head_commit.parent(0).unwrap().id(), merge_commit.id());
+        assert!(!head_commit.is_conflicted());
+
+        let head_tree = test_repository
+            .repository
+            .find_real_tree(&head_commit, Default::default())
+            .unwrap();
+        assert_eq!(head_tree.id(), tree)
+    }
+
     #[test]
     fn test_conflicted_tree_branch() {
         let test_repository = TestingRepository::open();

From d8b2bee18c1a4cd4758f04c38a7a40ec934c0fbc Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Fri, 4 Oct 2024 10:35:17 +0200
Subject: [PATCH 11/12] fix: Lint errors

---
 apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte | 4 ++--
 .../virtual_branches/create_virtual_branch_from_branch.rs     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte b/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
index 9193c18a6..aea250ac9 100644
--- a/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
+++ b/apps/desktop/src/lib/components/IntegrateUpstreamModal.svelte
@@ -225,8 +225,8 @@
 										onselect={(value) => {
 											const result = results.get(branch.id)!;
 
-										results.set(branch.id, {...result, approach: { type: value }})
-									}}
+											results.set(branch.id, { ...result, approach: { type: value } });
+										}}
 										options={[
 											{ label: 'Rebase', value: 'rebase' },
 											{ label: 'Merge', value: 'merge' },
diff --git a/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs b/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs
index 296c2b545..a64f11541 100644
--- a/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs
+++ b/crates/gitbutler-branch-actions/tests/virtual_branches/create_virtual_branch_from_branch.rs
@@ -436,7 +436,7 @@ mod conflict_cases {
             )
             .unwrap();
 
-        gitbutler_branch_actions::integrate_upstream(&project, &[]).unwrap();
+        gitbutler_branch_actions::integrate_upstream(&project, &[], None).unwrap();
 
         // Apply B
 
@@ -535,7 +535,7 @@ mod conflict_cases {
             )
             .unwrap();
 
-        gitbutler_branch_actions::integrate_upstream(&project, &[]).unwrap();
+        gitbutler_branch_actions::integrate_upstream(&project, &[], None).unwrap();
 
         // Apply B
 

From 265d957fb375797a91249db8f3bfe6c5d9381902 Mon Sep 17 00:00:00 2001
From: estib <stron@me.com>
Date: Fri, 4 Oct 2024 18:28:27 +0200
Subject: [PATCH 12/12] Base branch: Use graph ahead behind

---
 crates/gitbutler-branch-actions/src/base.rs | 40 +++++++++------------
 1 file changed, 16 insertions(+), 24 deletions(-)

diff --git a/crates/gitbutler-branch-actions/src/base.rs b/crates/gitbutler-branch-actions/src/base.rs
index 5e011163b..c742d6149 100644
--- a/crates/gitbutler-branch-actions/src/base.rs
+++ b/crates/gitbutler-branch-actions/src/base.rs
@@ -564,33 +564,25 @@ pub(crate) fn target_to_base_branch(ctx: &CommandContext, target: &Target) -> Re
     let commit = branch.get().peel_to_commit()?;
     let oid = commit.id();
 
-    // determined if the base branch is behind it's upstream
-    let fork_point = repo.merge_base(target.sha, oid).context(format!(
-        "failed to find merge base between {} and {}",
-        target.sha, oid
-    ))?;
+    // determine if the base branch is behind it's upstream
+    let (number_commits_ahead, number_commits_behind) = repo.graph_ahead_behind(target.sha, oid)?;
 
-    let diverged = fork_point != target.sha;
+    let diverged_ahead = repo
+        .log(target.sha, LogUntil::Take(number_commits_ahead))
+        .context("failed to get fork point")?
+        .iter()
+        .map(|commit| commit.id())
+        .collect::<Vec<_>>();
 
-    let diverged_ahead = if diverged {
-        repo.log(target.sha, LogUntil::Commit(fork_point))
-            .context("failed to get diverged ahead commits")?
-            .iter()
-            .map(|commit| commit.id())
-            .collect::<Vec<git2::Oid>>()
-    } else {
-        Vec::new()
-    };
+    let diverged_behind = repo
+        .log(oid, LogUntil::Take(number_commits_behind))
+        .context("failed to get fork point")?
+        .iter()
+        .map(|commit| commit.id())
+        .collect::<Vec<_>>();
 
-    let diverged_behind = if diverged {
-        repo.log(oid, LogUntil::Commit(fork_point))
-            .context("failed to get diverged behind commits")?
-            .iter()
-            .map(|commit| commit.id())
-            .collect::<Vec<git2::Oid>>()
-    } else {
-        Vec::new()
-    };
+    // if there are commits ahead of the base branch consider it diverged
+    let diverged = !diverged_ahead.is_empty();
 
     // gather a list of commits between oid and target.sha
     let upstream_commits = repo