Adds branch and worktree focus to Commit Graph

- Adds "Focus on Branch", "Focus on Worktree", and "Solo Branch" options to Commit Graph context menus
- Allows focusing the graph and minimap on a specific branch or worktree by right-clicking them in the side bar or a graph row
- Supports resolving working tree (WIP) rows to their corresponding branch so users can easily focus or solo the graph on that worktree's active branch
- Cleanly reorganizes and groups related command contributions in the context menus

Closes #5388

Author: eamodio

CHANGELOG.md

@@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/) and this p
 - Adds a working tree change count badge to the _Commit Graph_ view — mirrors the _Source Control_ view by showing the number of working tree changes on the GitLens panel tab, even while the panel is collapsed; controllable via the new `gitlens.graph.showWorkingTreeBadge` setting ([#5383](https://github.com/gitkraken/vscode-gitlens/issues/5383))
 - Adds an _Open in Integrated Terminal_ option for worktrees in the _Commit Graph_ and the _Worktrees_ view — opens the selected worktree's folder in the integrated terminal, matching the action already available for repositories and folders ([#5386](https://github.com/gitkraken/vscode-gitlens/issues/5386))
 - Adds a _Reveal in Explorer View_ option for working tree (WIP) files in the _Inspect_ and _Commit Graph_ views — right-click a staged, unstaged, or conflicted working file to reveal and select it in VS Code's Explorer view ([#5387](https://github.com/gitkraken/vscode-gitlens/issues/5387))
+- Adds _Focus on Branch_, _Focus on Worktree_, and _Solo Branch_ options to the _Commit Graph_ — right-click a branch or worktree in the side bar (or a graph row) to focus the graph and minimap on it, and right-click a working tree (WIP) row to focus or solo the graph on that worktree's branch ([#5388](https://github.com/gitkraken/vscode-gitlens/issues/5388))
 
 ### Changed
 

contributions.json

@@ -2605,6 +2605,35 @@
 				]
 			}
 		},
+		"gitlens.focusBranch:graph": {
+			"label": "Focus on Branch",
+			"menus": {
+				"webview/context": [
+					{
+						"when": "webviewItem =~ /gitlens:branch\\b/",
+						"group": "8_gitlens_actions",
+						"order": 7
+					}
+				]
+			}
+		},
+		"gitlens.focusWorktree:graph": {
+			"label": "Focus on Worktree",
+			"menus": {
+				"webview/context": [
+					{
+						"when": "webviewItem =~ /^gitlens:wip\\b/",
+						"group": "8_gitlens_actions",
+						"order": 7
+					},
+					{
+						"when": "webviewItem =~ /gitlens:worktree\\b(?=.*?\\b\\+branch\\b)/",
+						"group": "8_gitlens_actions",
+						"order": 7
+					}
+				]
+			}
+		},
 		"gitlens.getStarted": {
 			"label": "Get Started",
 			"commandPalette": "gitlens:walkthroughSupported",
@@ -4139,6 +4168,11 @@
 						"group": "8_gitlens_actions",
 						"order": 9
 					},
+					{
+						"when": "webviewItem =~ /^gitlens:wip\\b/",
+						"group": "8_gitlens_actions",
+						"order": 9
+					},
 					{
 						"when": "webviewItem =~ /gitlens:worktree\\b(?=.*?\\b\\+branch\\b)/",
 						"group": "8_gitlens_actions",

package.json

@@ -133,6 +133,8 @@ export type ContributedCommands =
 	| 'gitlens.fetch:views'
 	| 'gitlens.fetchRemote:graph'
 	| 'gitlens.fetchRepositories'
+	| 'gitlens.focusBranch:graph'
+	| 'gitlens.focusWorktree:graph'
 	| 'gitlens.getStarted'
 	| 'gitlens.ghpr.views.openOrCreateWorktree'
 	| 'gitlens.graph.addAuthor'

src/constants.commands.generated.ts

@@ -692,10 +692,17 @@ export class GraphApp extends SignalWatcher(LitElement) {
 		action: GraphShowAction;
 		target?: { sha: string; worktreePath: string; filePaths?: string[] };
 		commitMessage?: string;
+		scopeBranch?: { branchName: string; upstreamName?: string };
 	}): Promise<void> {
-		const { action, target, commitMessage } = pending;
+		const { action, target, commitMessage, scopeBranch } = pending;
 		if (action === 'scope-to-branch') {
-			await this.scopeToBranch();
+			// A target branch (from a Focus on Branch/Worktree command) scopes to it; otherwise scope
+			// to the current branch (the welcome-page / generic `scope-to-branch` entry point).
+			if (scopeBranch != null) {
+				await this.scopeToBranchByName(scopeBranch.branchName, scopeBranch.upstreamName);
+			} else {
+				await this.scopeToBranch();
+			}
 			return;
 		}
 
@@ -2167,9 +2174,16 @@ export class GraphApp extends SignalWatcher(LitElement) {
 		});
 	}
 
-	private async handleScopeToBranchFromHeader(
+	private handleScopeToBranchFromHeader(
 		e: CustomEvent<{ branchName: string; upstreamName?: string }>,
 	): Promise<void> {
+		return this.scopeToBranchByName(e.detail.branchName, e.detail.upstreamName);
+	}
+
+	/** Focuses (scopes) the graph onto an arbitrary branch by name. Shared by the header popover, the
+	 *  sidebar/overview events, and the Focus on Branch/Worktree context-menu commands (via the
+	 *  `scope-to-branch` action). */
+	private async scopeToBranchByName(branchName: string, upstreamName?: string): Promise<void> {
 		// Use the selected repo's actual path (the opened workspace's path). That's what the host
 		// passes as `this.repository.path` when building the graph's row index AND the
 		// `wipMetadataBySha` branchRefs, so any scope/lookup branchRef constructed here must use
@@ -2179,8 +2193,6 @@ export class GraphApp extends SignalWatcher(LitElement) {
 		const repoPath = this.fallbackRepoPath;
 		if (repoPath == null) return;
 
-		const { branchName, upstreamName } = e.detail;
-
 		// Prefer the overview path so the merge target is resolved consistently with the overview card.
 		const overview = this.graphState.overview;
 		const branch =

src/webviews/apps/plus/graph/graph-app.ts

@@ -1221,6 +1221,7 @@ export class GraphStateProvider extends StateProviderBase<State['webviewId'], Ap
 						action: msg.params.action,
 						target: msg.params.target,
 						commitMessage: msg.params.commitMessage,
+						scopeBranch: msg.params.scopeBranch,
 					},
 					...(msg.params.action !== 'scope-to-branch' ? { details: { ...this.details, visible: true } } : {}),
 				});

src/webviews/apps/plus/graph/stateProvider.ts

@@ -381,6 +381,7 @@ import type {
 	GraphRefType,
 	GraphRemoteContextValue,
 	GraphRepository,
+	GraphScopeBranch,
 	GraphScrollMarkerTypes,
 	GraphSearchResults,
 	GraphSelectedRows,
@@ -10274,20 +10275,44 @@ export class GraphWebviewProvider implements WebviewProvider<State, State, Graph
 	@command('gitlens.graph.soloBranch')
 	@command('gitlens.graph.soloTag')
 	@debug()
-	private soloReference(item?: GraphItemContext) {
-		if (!isGraphItemRefContext(item)) return;
+	private soloReference(item?: GraphItemContext): Promise<void> {
+		// Branch/tag/worktree leaves & rows carry a real ref with an id. WIP rows carry an
+		// uncommitted revision (no id) — fall through to resolve the worktree's branch.
+		if (isGraphItemRefContext(item)) {
+			const { ref } = item.webviewItemValue;
+			if (ref.id != null) {
+				this.soloByName(ref.repoPath, ref.name);
+				return Promise.resolve();
+			}
+		}
 
-		const { ref } = item.webviewItemValue;
-		if (ref.id == null) return;
+		return this.soloWipReference(item);
+	}
+
+	/** Solo the WIP row's worktree onto its current branch. The WIP context carries only an
+	 *  uncommitted revision + `worktreePath`, so resolve that worktree's branch and filter the
+	 *  graph (on its own repo) to it. */
+	private async soloWipReference(item?: GraphItemContext): Promise<void> {
+		if (!isGraphItemRefContext(item, 'revision')) return;
 
-		const repo = this.container.git.getRepository(ref.repoPath);
-		if (repo == null) return Promise.resolve();
+		const { worktreePath } = item.webviewItemValue;
+		if (worktreePath == null) return;
+
+		const branch = await this.container.git.getRepositoryService(worktreePath).branches.getBranch();
+		if (branch == null) return;
+
+		this.soloByName(this.repository?.path ?? worktreePath, branch.name);
+	}
+
+	private soloByName(repoPath: string, name: string): void {
+		const repo = this.container.git.getRepository(repoPath);
+		if (repo == null) return;
 
 		// Show the graph with a ref: search query to filter the graph to this branch
-		return void executeCommand<ShowInCommitGraphCommandArgs>('gitlens.showInCommitGraph', {
+		void executeCommand<ShowInCommitGraphCommandArgs>('gitlens.showInCommitGraph', {
 			repository: repo,
 			search: {
-				query: `ref:${ref.name}`,
+				query: `ref:${name}`,
 				filter: true,
 				matchAll: false,
 				matchCase: false,
@@ -10297,6 +10322,39 @@ export class GraphWebviewProvider implements WebviewProvider<State, State, Graph
 		});
 	}
 
+	// Two command ids, one handler — VS Code menu titles are static, so distinct ids let the menu
+	// read "Focus on Branch" on branch rows/leaves and "Focus on Worktree" on worktree/WIP rows.
+	@command('gitlens.focusBranch:graph')
+	@command('gitlens.focusWorktree:graph')
+	@debug()
+	private async focusReference(item?: GraphItemContext): Promise<void> {
+		const scopeBranch = await this.getScopeBranch(item);
+		if (scopeBranch == null) return;
+
+		// Invoked from a context menu inside the open graph (warm), so notify the webview directly to
+		// focus (scope) onto the branch — mirrors the `scope-to-branch` action the popover/overview use.
+		void this.host.notify(DidRequestGraphActionNotification, {
+			action: 'scope-to-branch',
+			scopeBranch: scopeBranch,
+		});
+	}
+
+	/** Resolves the branch to focus from a Focus context item. Branch leaves/rows and worktree
+	 *  leaves carry a branch ref directly; WIP rows carry only `worktreePath`, so resolve its
+	 *  current branch. */
+	private async getScopeBranch(item?: GraphItemContext): Promise<GraphScopeBranch | undefined> {
+		const ref = this.getGraphItemRef(item, 'branch');
+		if (ref != null) return { branchName: ref.name, upstreamName: ref.upstream?.name };
+
+		if (!isGraphItemRefContext(item, 'revision')) return undefined;
+
+		const { worktreePath } = item.webviewItemValue;
+		if (worktreePath == null) return undefined;
+
+		const branch = await this.container.git.getRepositoryService(worktreePath).branches.getBranch();
+		return branch != null ? { branchName: branch.name, upstreamName: branch.upstream?.name } : undefined;
+	}
+
 	@command('gitlens.switchToAnotherBranch:graph')
 	@debug()
 	private switchToAnother(item?: GraphItemContext | unknown) {

src/webviews/plus/graph/graphWebview.ts

@@ -193,6 +193,14 @@ export interface GraphActionTarget {
 	 *  entry points). Omitted means "resolve all conflicts". Ignored by other actions. */
 	filePaths?: string[];
 }
+
+/** Target branch for a `scope-to-branch` action. When present, the webview focuses (scopes) the
+ *  graph to this branch instead of the current branch — used by the Focus on Branch/Worktree
+ *  context-menu commands. */
+export interface GraphScopeBranch {
+	branchName: string;
+	upstreamName?: string;
+}
 /** Sub-visualization shown when `displayMode === 'visualizations'`.
  *  Adding a new visualization is a 4-step extension: extend this union, render its component in
  *  `gl-graph-visualizations`, persist any per-visualization config in `graph-app.persistStateNow`,
@@ -326,7 +334,12 @@ export interface State extends WebviewState<'gitlens.graph' | 'gitlens.views.gra
 		visible?: boolean;
 		position?: number;
 	};
-	pendingAction?: { action: GraphShowAction; target?: GraphActionTarget; commitMessage?: string };
+	pendingAction?: {
+		action: GraphShowAction;
+		target?: GraphActionTarget;
+		commitMessage?: string;
+		scopeBranch?: GraphScopeBranch;
+	};
 	/** Per-worktree commit drafts for this repo's WIP rows, keyed by worktree fsPath (== `repoPath`
 	 *  for the primary WIP, == the secondary worktree's fsPath for each secondary WIP row).
 	 *  Restored on WIP row selection; mutated via {@link UpdateWipDraftCommand}. */
@@ -1148,6 +1161,8 @@ export interface DidRequestGraphActionParams {
 	/** Optional seed value for the WIP details panel's commit message input. Currently used after
 	 *  Undo Commit to restore the undone commit's message into the box where the user will redo it. */
 	commitMessage?: string;
+	/** For `scope-to-branch`: the branch to focus the graph on. Absent = focus the current branch. */
+	scopeBranch?: GraphScopeBranch;
 }
 export const DidRequestGraphActionNotification = new IpcNotification<DidRequestGraphActionParams>(
 	scope,