Adds AI recompse branch actions to Branch Views

Introduces AI-powered branch actions ("Recompose" and "Explain")
directly into the branches view, enabling context menu options when
branches are recomposable or have unpushed commits. Refactors and
centralizes branch recomposability detection to ensure consistent logic
across graph and views, improving maintainability and user experience.
Enhances discoverability and workflow integration for AI-assisted Git
operations.

(#4443)

Author: sergeibbb

contributions.json

@@ -36,6 +36,19 @@
 				]
 			}
 		},
+		"gitlens.ai.aiRebaseBranch:views": {
+			"label": "AI Recompose Branch Commits (Preview)",
+			"icon": "$(sparkle)",
+			"menus": {
+				"view/item/context": [
+					{
+						"when": "viewItem =~ /gitlens:branch\\b(?=.*?\\b\\+recomposable\\b)/ && !listMultiSelection && !gitlens:readonly && !gitlens:untrusted && gitlens:gk:organization:ai:enabled",
+						"group": "1_gitlens_actions",
+						"order": 6
+					}
+				]
+			}
+		},
 		"gitlens.ai.aiRebaseUnpushed:graph": {
 			"label": "AI Recompose Unpushed Commits (Preview)",
 			"icon": "$(sparkle)",
@@ -49,6 +62,19 @@
 				]
 			}
 		},
+		"gitlens.ai.aiRebaseUnpushed:views": {
+			"label": "AI Recompose Unpushed Commits (Preview)",
+			"icon": "$(sparkle)",
+			"menus": {
+				"view/item/context": [
+					{
+						"when": "viewItem =~ /gitlens:branch\\b(?=.*?\\b\\+ahead\\b)/ && !listMultiSelection && !gitlens:readonly && !gitlens:untrusted && gitlens:gk:organization:ai:enabled",
+						"group": "1_gitlens_actions",
+						"order": 7
+					}
+				]
+			}
+		},
 		"gitlens.ai.explainBranch": {
 			"label": "Explain Branch Changes (Preview)...",
 			"commandPalette": "gitlens:enabled && !gitlens:readonly && !gitlens:untrusted && gitlens:gk:organization:ai:enabled"

package.json

@@ -6194,11 +6194,21 @@
 				"title": "AI Recompose Branch Commits (Preview)",
 				"icon": "$(sparkle)"
 			},
+			{
+				"command": "gitlens.ai.aiRebaseBranch:views",
+				"title": "AI Recompose Branch Commits (Preview)",
+				"icon": "$(sparkle)"
+			},
 			{
 				"command": "gitlens.ai.aiRebaseUnpushed:graph",
 				"title": "AI Recompose Unpushed Commits (Preview)",
 				"icon": "$(sparkle)"
 			},
+			{
+				"command": "gitlens.ai.aiRebaseUnpushed:views",
+				"title": "AI Recompose Unpushed Commits (Preview)",
+				"icon": "$(sparkle)"
+			},
 			{
 				"command": "gitlens.ai.explainBranch",
 				"title": "Explain Branch Changes (Preview)...",
@@ -11028,10 +11038,18 @@
 					"command": "gitlens.ai.aiRebaseBranch:graph",
 					"when": "false"
 				},
+				{
+					"command": "gitlens.ai.aiRebaseBranch:views",
+					"when": "false"
+				},
 				{
 					"command": "gitlens.ai.aiRebaseUnpushed:graph",
 					"when": "false"
 				},
+				{
+					"command": "gitlens.ai.aiRebaseUnpushed:views",
+					"when": "false"
+				},
 				{
 					"command": "gitlens.ai.explainBranch",
 					"when": "gitlens:enabled && !gitlens:readonly && !gitlens:untrusted && gitlens:gk:organization:ai:enabled"
@@ -17428,6 +17446,16 @@
 					"when": "viewItem =~ /gitlens:branch\\b(?=.*?\\b\\+(remote|tracking)\\b)(?!.*?\\b\\+closed\\b)/ && !listMultiSelection && !gitlens:readonly && !gitlens:untrusted && !gitlens:hasVirtualFolders && gitlens:repos:withRemotes",
 					"group": "1_gitlens_actions@3"
 				},
+				{
+					"command": "gitlens.ai.aiRebaseBranch:views",
+					"when": "viewItem =~ /gitlens:branch\\b(?=.*?\\b\\+recomposable\\b)/ && !listMultiSelection && !gitlens:readonly && !gitlens:untrusted && gitlens:gk:organization:ai:enabled",
+					"group": "1_gitlens_actions@6"
+				},
+				{
+					"command": "gitlens.ai.aiRebaseUnpushed:views",
+					"when": "viewItem =~ /gitlens:branch\\b(?=.*?\\b\\+ahead\\b)/ && !listMultiSelection && !gitlens:readonly && !gitlens:untrusted && gitlens:gk:organization:ai:enabled",
+					"group": "1_gitlens_actions@7"
+				},
 				{
 					"command": "gitlens.views.mergeBranchInto",
 					"when": "viewItem =~ /gitlens:branch\\b(?!.*?\\b\\+current\\b)(?!.*?\\b\\+closed\\b)/ && !listMultiSelection && !gitlens:readonly && !gitlens:untrusted && !gitlens:hasVirtualFolders",

src/constants.commands.generated.ts

@@ -5,7 +5,9 @@ export type ContributedCommands =
 	| ContributedKeybindingCommands
 	| ContributedPaletteCommands
 	| 'gitlens.ai.aiRebaseBranch:graph'
+	| 'gitlens.ai.aiRebaseBranch:views'
 	| 'gitlens.ai.aiRebaseUnpushed:graph'
+	| 'gitlens.ai.aiRebaseUnpushed:views'
 	| 'gitlens.ai.explainBranch:graph'
 	| 'gitlens.ai.explainBranch:views'
 	| 'gitlens.ai.explainCommit:graph'

src/env/node/git/sub-providers/graph.ts

@@ -30,7 +30,7 @@ import {
 } from '../../../../git/parsers/logParser';
 import type { GitGraphSearch, GitGraphSearchResultData, GitGraphSearchResults } from '../../../../git/search';
 import { getSearchQueryComparisonKey, parseSearchQueryCommand } from '../../../../git/search';
-import { getDefaultBranchName, isBranchStarred } from '../../../../git/utils/-webview/branch.utils';
+import { getBranchMergeBaseAndCommonCommit, isBranchStarred } from '../../../../git/utils/-webview/branch.utils';
 import { getRemoteIconUri } from '../../../../git/utils/-webview/icons';
 import { groupWorktreesByBranch } from '../../../../git/utils/-webview/worktree.utils';
 import {
@@ -349,7 +349,10 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 							branchId = branch?.id ?? getBranchId(repoPath, false, tip);
 
 							// Check if branch has commits that can be recomposed and get merge base
-							const mergeBase = await this.getMergeBase(branch, repoPath);
+							const mergeBaseResult =
+								branch && (await getBranchMergeBaseAndCommonCommit(this.container, branch));
+							const isRecomposable = Boolean(mergeBaseResult && mergeBaseResult.commit !== branch?.sha);
+							const mergeBase = isRecomposable ? mergeBaseResult : undefined;
 
 							context = {
 								webviewItem: `gitlens:branch${head ? '+current' : ''}${
@@ -625,74 +628,6 @@ export class GraphGitSubProvider implements GitGraphSubProvider {
 		return getCommitsForGraphCore.call(this, defaultLimit, selectSha, undefined, cancellation);
 	}
 
-	private async getMergeBase(
-		branch: GitBranch | undefined,
-		repoPath: string,
-	): Promise<{ commit: string; branch: string; remote: boolean } | undefined> {
-		if (!branch || branch.remote) return undefined;
-
-		try {
-			const upstreamName = branch.upstream?.name;
-			const svc = this.container.git.getRepositoryService(repoPath);
-
-			// Get stored merge target configurations
-			const [targetBranchResult, mergeBaseResult, defaultBranchResult] = await Promise.allSettled([
-				svc.branches.getStoredMergeTargetBranchName?.(branch.name),
-				svc.branches.getBaseBranchName?.(branch.name),
-				getDefaultBranchName(this.container, branch.repoPath, branch.name),
-			]);
-			const targetBranch = getSettledValue(targetBranchResult);
-			const validTargetBranch = targetBranch && targetBranch !== upstreamName ? targetBranch : undefined;
-			const mergeBase = getSettledValue(mergeBaseResult) || getSettledValue(defaultBranchResult);
-			const validMergeBase = mergeBase && mergeBase !== upstreamName ? mergeBase : undefined;
-
-			// Select target with most recent common commit (closest to branch tip)
-			const validTargets = [validTargetBranch, validMergeBase];
-			const recentMergeBase = await this.selectMostRecentMergeBase(branch.name, validTargets, svc);
-
-			const isRecomposable = Boolean(recentMergeBase && recentMergeBase.commit !== branch.sha);
-			return isRecomposable ? recentMergeBase : undefined;
-		} catch {
-			// If we can't determine, assume not recomposable
-			return undefined;
-		}
-	}
-
-	private async selectMostRecentMergeBase(
-		branchName: string,
-		targets: (string | undefined)[],
-		svc: ReturnType<typeof this.container.git.getRepositoryService>,
-	): Promise<{ commit: string; branch: string; remote: boolean } | undefined> {
-		const isString = (t: string | undefined): t is string => Boolean(t);
-		const mergeBaseResults = await Promise.allSettled(
-			targets.filter(isString).map(async target => {
-				const commit = await svc.refs.getMergeBase(branchName, target);
-				return {
-					commit: commit,
-					branch: target,
-				};
-			}),
-		);
-		const mergeBases = mergeBaseResults
-			.map(result => getSettledValue(result))
-			.filter((r): r is { commit: string; branch: string; remote: boolean } => isString(r?.commit));
-
-		if (mergeBases.length === 0) return undefined;
-
-		let mostRecentMergeBase = mergeBases[0];
-		for (let i = 1; i < mergeBases.length; i++) {
-			const isCurrentMoreRecent = await svc.commits.isAncestorOf(
-				mostRecentMergeBase?.commit,
-				mergeBases[i].commit,
-			);
-			if (isCurrentMoreRecent) {
-				mostRecentMergeBase = mergeBases[i];
-			}
-		}
-
-		return mostRecentMergeBase;
-	}
-
 	@log<GraphGitSubProvider['searchGraph']>({
 		args: {
 			1: s =>

src/git/utils/-webview/branch.utils.ts

@@ -201,3 +201,85 @@ export function getStarredBranchIds(container: Container): Set<string> {
 
 	return new Set(Object.keys(starred).filter(branchId => starred[branchId] === true));
 }
+
+/**
+ * Gets the merge base for a branch by checking stored merge target configurations.
+ *
+ * Among two type of base branches targetBranch, mergeBaseBranch we select one that:
+ * - is defined
+ * - is not the upstream branch (because the upstream is not a valid base and we have another way to search base commit with the upstream)
+ * - has the most recent common commit
+ *
+ * if mergeBase is not defined we try to use defaultBranch
+ *
+ * This function consolidates the common logic used in both graph.ts and branchNode.ts
+ * for determining if a branch is recomposable.
+ */
+export async function getBranchMergeBaseAndCommonCommit(
+	container: Container,
+	branch: GitBranch,
+	// options?: GetBranchMergeBaseOptions,
+): Promise<{ commit: string; branch: string } | undefined> {
+	if (branch.remote) return undefined;
+
+	const isString = Boolean as unknown as (t: string | undefined) => t is string;
+
+	try {
+		const svc = container.git.getRepositoryService(branch.repoPath);
+		const upstreamName = branch.upstream?.name;
+
+		// Get stored merge target configurations
+		const [targetBranchResult, mergeBaseResult, defaultBranchResult] = await Promise.allSettled([
+			svc.branches.getStoredMergeTargetBranchName?.(branch.name),
+			svc.branches.getBaseBranchName?.(branch.name),
+			getDefaultBranchName(container, branch.repoPath, branch.name),
+		]);
+		const targetBranch = getSettledValue(targetBranchResult);
+		const validTargetBranch = targetBranch && targetBranch !== upstreamName ? targetBranch : undefined;
+		const mergeBase = getSettledValue(mergeBaseResult) || getSettledValue(defaultBranchResult);
+		const validMergeBase = mergeBase && mergeBase !== upstreamName ? mergeBase : undefined;
+		const validTargets = [validTargetBranch, validMergeBase].filter(isString);
+		if (validTargets.length === 0) return undefined;
+
+		return await selectMostRecentMergeBase(branch.name, validTargets, svc);
+	} catch {
+		// If we can't determine, assume not recomposable
+		return undefined;
+	}
+}
+
+/**
+ * Selects the most recent merge base from multiple target branches.
+ *
+ * It gets the merge base for each target, then uses isAncestorOf() to find which one is newest.
+ */
+async function selectMostRecentMergeBase(
+	branchName: string,
+	targets: string[],
+	svc: ReturnType<typeof Container.prototype.git.getRepositoryService>,
+): Promise<{ commit: string; branch: string } | undefined> {
+	const mergeBaseResults = await Promise.allSettled(
+		targets.map(async target => {
+			const commit = await svc.refs.getMergeBase(branchName, target);
+			return {
+				commit: commit,
+				branch: target,
+			};
+		}),
+	);
+	const mergeBases = mergeBaseResults
+		.map(result => getSettledValue(result))
+		.filter((r): r is { commit: string; branch: string } => r?.commit != null);
+
+	if (mergeBases.length === 0) return undefined;
+
+	let mostRecentMergeBase = mergeBases[0];
+	for (let i = 1; i < mergeBases.length; i++) {
+		const isCurrentMoreRecent = await svc.commits.isAncestorOf(mostRecentMergeBase?.commit, mergeBases[i].commit);
+		if (isCurrentMoreRecent) {
+			mostRecentMergeBase = mergeBases[i];
+		}
+	}
+
+	return mostRecentMergeBase;
+}

src/views/nodes/branchNode.ts

@@ -82,6 +82,7 @@ export class BranchNode
 		// Specifies that the node is shown as a root
 		public readonly root: boolean,
 		options?: Partial<Options>,
+		public readonly mergeBase?: { commit: string; branch: string; remote: boolean },
 	) {
 		super('branch', uri, view, parent);
 
@@ -393,6 +394,7 @@ export class BranchNode
 			useBaseNameOnly: !(this.view.config.branches?.layout !== 'tree' || this.compacted || this.avoidCompacting),
 			worktree: this.worktree,
 			worktreesByBranch: this.context.worktreesByBranch,
+			isRecomposable: Boolean(this.mergeBase),
 		});
 
 		// TODO@axosoft-ramint Temporary workaround, remove when our git commands work on closed repos.
@@ -518,6 +520,7 @@ export async function getBranchNodeParts(
 		useBaseNameOnly: boolean;
 		worktree?: GitWorktree;
 		worktreesByBranch?: Map<string, GitWorktree>;
+		isRecomposable?: boolean;
 	},
 ): Promise<{
 	label: string;
@@ -717,6 +720,10 @@ export async function getBranchNodeParts(
 		iconPath = getBranchIconPath(container, branch);
 	}
 
+	if (options?.isRecomposable) {
+		contextValue += '+recomposable';
+	}
+
 	return {
 		label: label,
 		description: description,

src/views/nodes/branchesNode.ts

@@ -2,6 +2,7 @@ import { ThemeIcon, TreeItem, TreeItemCollapsibleState } from 'vscode';
 import { GitUri } from '../../git/gitUri';
 import type { GitBranch } from '../../git/models/branch';
 import type { Repository } from '../../git/models/repository';
+import { getBranchMergeBaseAndCommonCommit } from '../../git/utils/-webview/branch.utils';
 import { getOpenedWorktreesByBranch } from '../../git/utils/-webview/worktree.utils';
 import { getLocalBranchUpstreamNames } from '../../git/utils/branch.utils';
 import { makeHierarchical } from '../../system/array';
@@ -65,11 +66,22 @@ export class BranchesNode extends CacheableChildrenViewNode<'branches', ViewsWit
 				localUpstreamNames = await getLocalBranchUpstreamNames(branches);
 			}
 
+			// Create a map of branch names to their remote status for efficient lookup
+			const branchRemoteMap = new Map<string, boolean>();
+			for await (const branch of branches.values()) {
+				branchRemoteMap.set(branch.name, branch.remote);
+			}
+
 			const branchNodes: BranchNode[] = [];
 
 			for await (const branch of branches.values()) {
 				if (branch.remote && localUpstreamNames?.has(branch.name)) continue;
 
+				const mergeBaseResult =
+					branch && (await getBranchMergeBaseAndCommonCommit(this.view.container, branch));
+				const isRecomposable = Boolean(mergeBaseResult && mergeBaseResult.commit !== branch?.sha);
+				const mergeBase = isRecomposable ? mergeBaseResult : undefined;
+
 				branchNodes.push(
 					new BranchNode(
 						GitUri.fromRepoPath(this.uri.repoPath!, branch.ref),
@@ -85,6 +97,10 @@ export class BranchesNode extends CacheableChildrenViewNode<'branches', ViewsWit
 									: this.view.config.showBranchComparison,
 							showStashes: this.view.config.showStashes,
 						},
+						mergeBase && {
+							...mergeBase,
+							remote: branchRemoteMap.get(mergeBase.branch) ?? false,
+						},
 					),
 				);
 			}