@theia/scm 1.75.0-next.3 → 1.75.0-next.35

package/src/browser/scm-history-graph-tooltip.spec.ts

@@ -0,0 +1,254 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { MarkdownRenderer } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
+import { MarkdownString, MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering/markdown-string';
+import { OpenerService } from '@theia/core/lib/browser/opener-service';
+import { markMarkdownLinksWired } from '@theia/core/lib/browser/markdown-rendering/markdown-link-handler';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import URI from '@theia/core/lib/common/uri';
+import { ScmHistoryItem } from './scm-provider';
+import { HistoryGraphEntry } from './scm-history-graph-model';
+import { buildHtmlTooltip, buildProviderTooltip, HistoryTooltipActions } from './scm-history-graph-tooltip';
+
+disableJSDOM();
+
+function makeEntry(item: Partial<ScmHistoryItem>): HistoryGraphEntry {
+    return {
+        item: {
+            id: '1a56ba96fdc9b6df3a230df7b44e22e5785e3abd',
+            subject: 'fix something',
+            parentIds: [],
+            ...item,
+        },
+        graphRow: { lane: 0, color: 0, topColor: 0, edges: [], hasContinuation: false, hasTopLine: false },
+        isCurrent: false,
+    };
+}
+
+const markdownRenderer = {
+    render: () => ({ element: document.createElement('div'), dispose: () => { } })
+} as unknown as MarkdownRenderer;
+
+describe('buildHtmlTooltip', () => {
+    let restoreJSDOM: () => void;
+
+    before(() => {
+        restoreJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        restoreJSDOM();
+    });
+
+    it('renders the author as a bold mailto link when the email is known', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe', authorEmail: 'jane@example.com', timestamp: 1000 }), markdownRenderer);
+        const link = tooltip.querySelector('a[href="mailto:jane@example.com"]');
+        expect(link, 'mailto link').to.not.be.null;
+        expect(link!.textContent).to.contain('Jane Doe');
+        expect(link!.querySelector('strong'), 'bold author').to.not.be.null;
+    });
+
+    it('renders a plain bold author when no email is known', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe', timestamp: 1000 }), markdownRenderer);
+        expect(tooltip.querySelector('a[href^="mailto:"]')).to.be.null;
+        const strong = tooltip.querySelector('.scm-history-tooltip-header strong');
+        expect(strong).to.not.be.null;
+        expect(strong!.textContent).to.equal('Jane Doe');
+    });
+
+    it('renders the author avatar image when authorIcon is a URL', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe', authorIcon: 'https://avatars.example.com/u/1' }), markdownRenderer);
+        const img = tooltip.querySelector('img.scm-history-tooltip-avatar') as HTMLImageElement;
+        expect(img, 'avatar image').to.not.be.null;
+        expect(img.src).to.equal('https://avatars.example.com/u/1');
+    });
+
+    it('falls back to the account icon without an avatar', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ author: 'Jane Doe' }), markdownRenderer);
+        expect(tooltip.querySelector('img.scm-history-tooltip-avatar')).to.be.null;
+        expect(tooltip.querySelector('.scm-history-tooltip-header .codicon-account')).to.not.be.null;
+    });
+
+    it('renders an Open Commit action with the short hash', () => {
+        let opened = 0;
+        const actions: HistoryTooltipActions = { openCommit: () => { opened++; } };
+        const tooltip = buildHtmlTooltip(makeEntry({ displayId: '1a56ba9' }), markdownRenderer, undefined, actions);
+        const action = tooltip.querySelector('[title="Open Commit"]') as HTMLElement;
+        expect(action, 'open commit action').to.not.be.null;
+        expect(action.textContent).to.contain('1a56ba9');
+        action.click();
+        expect(opened).to.equal(1);
+    });
+
+    it('renders a Copy Commit Hash action', () => {
+        let copied = 0;
+        const actions: HistoryTooltipActions = { copyCommitHash: () => { copied++; } };
+        const tooltip = buildHtmlTooltip(makeEntry({}), markdownRenderer, undefined, actions);
+        const action = tooltip.querySelector('[title="Copy Commit Hash"]') as HTMLElement;
+        expect(action, 'copy hash action').to.not.be.null;
+        action.click();
+        expect(copied).to.equal(1);
+    });
+
+    it('shows the short hash as plain text when no actions are given', () => {
+        const tooltip = buildHtmlTooltip(makeEntry({ displayId: '1a56ba9' }), markdownRenderer);
+        expect(tooltip.querySelector('[title="Open Commit"]')).to.be.null;
+        expect(tooltip.querySelector('[title="Copy Commit Hash"]')).to.be.null;
+        expect(tooltip.textContent).to.contain('1a56ba9');
+    });
+});
+
+describe('buildProviderTooltip', () => {
+    let restoreJSDOM: () => void;
+    let opened: string[];
+    let toDispose: DisposableCollection;
+
+    /** Renders the markdown value as HTML, so that the wiring of the resulting links can be asserted. */
+    const htmlRenderer = {
+        render: (markdown: MarkdownString) => {
+            const element = document.createElement('div');
+            element.innerHTML = markdown.value;
+            return { element, dispose: () => { } };
+        }
+    } as unknown as MarkdownRenderer;
+
+    const openerService = {
+        getOpener: (uri: URI) => Promise.resolve({
+            canHandle: () => 1,
+            open: () => {
+                // decoded, as `HttpOpenHandler` does when opening the target externally
+                opened.push(uri.toString(true));
+                return Promise.resolve(undefined);
+            }
+        })
+    } as unknown as OpenerService;
+
+    /** Clicks the anchor and waits for the asynchronous opener lookup to settle. */
+    async function click(tooltip: HTMLElement, selector: string): Promise<void> {
+        const anchor = tooltip.querySelector(selector) as HTMLElement;
+        expect(anchor, selector).to.not.be.null;
+        anchor.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+    }
+
+    before(() => {
+        restoreJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        restoreJSDOM();
+    });
+
+    beforeEach(() => {
+        opened = [];
+        toDispose = new DisposableCollection();
+    });
+
+    afterEach(() => {
+        toDispose.dispose();
+    });
+
+    it('renders each section in order', () => {
+        const tooltip = buildProviderTooltip(
+            [new MarkdownStringImpl('<span>first</span>'), new MarkdownStringImpl('<span>second</span>')],
+            htmlRenderer, openerService, toDispose)!;
+        expect(tooltip, 'tooltip').to.not.be.undefined;
+        expect(tooltip.textContent).to.equal('firstsecond');
+    });
+
+    // `vscode.git` ends its author and statistics sections with a horizontal rule of its own,
+    // so adding separators here would render every boundary as a double line.
+    it('adds no separators of its own between sections', () => {
+        const tooltip = buildProviderTooltip(
+            [new MarkdownStringImpl('<span>first</span><hr>'), new MarkdownStringImpl('<span>second</span>')],
+            htmlRenderer, openerService, toDispose)!;
+        expect(tooltip.querySelectorAll('hr').length, 'rules').to.equal(1);
+    });
+
+    it('renders a plain string tooltip', () => {
+        const tooltip = buildProviderTooltip('just text', htmlRenderer, openerService, toDispose)!;
+        expect(tooltip, 'tooltip').to.not.be.undefined;
+        expect(tooltip.textContent).to.equal('just text');
+    });
+
+    it('returns undefined when the provider supplies no usable content', () => {
+        expect(buildProviderTooltip('   ', htmlRenderer, openerService, toDispose)).to.be.undefined;
+        expect(buildProviderTooltip([], htmlRenderer, openerService, toDispose)).to.be.undefined;
+    });
+
+    it('routes an author mailto link through the opener service', async () => {
+        const tooltip = buildProviderTooltip(
+            new MarkdownStringImpl('<a href="mailto:jane@example.com">Jane Doe</a>'), htmlRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="mailto:"]');
+        expect(opened).to.deep.equal(['mailto:jane@example.com']);
+    });
+
+    it('executes a command link that the section trusts', async () => {
+        const section = new MarkdownStringImpl('<a href="command:git.viewCommit">Open Commit</a>');
+        section.isTrusted = { enabledCommands: ['git.viewCommit'] };
+        const tooltip = buildProviderTooltip(section, htmlRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="command:"]');
+        expect(opened).to.deep.equal(['command:git.viewCommit']);
+    });
+
+    it('blocks a command link that the section does not trust', async () => {
+        const section = new MarkdownStringImpl('<a href="command:git.viewCommit">Open Commit</a>');
+        section.isTrusted = { enabledCommands: ['git.copyContentToClipboard'] };
+        const tooltip = buildProviderTooltip(section, htmlRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="command:"]');
+        expect(opened).to.be.empty;
+    });
+
+    it('does not open a link twice when the renderer already wired it', async () => {
+        // The Monaco-based renderer used at runtime routes link activation through the opener
+        // service itself, so wiring a second handler on top would open every link twice.
+        const wiringRenderer = {
+            render: (markdown: MarkdownString) => {
+                const element = document.createElement('div');
+                element.innerHTML = markdown.value;
+                markMarkdownLinksWired(element);
+                element.addEventListener('click', event => {
+                    event.preventDefault();
+                    opened.push((event.target as HTMLElement).getAttribute('href')!);
+                });
+                return { element, dispose: () => { } };
+            }
+        } as unknown as MarkdownRenderer;
+
+        const section = new MarkdownStringImpl('<a href="command:git.viewCommit">Open Commit</a>');
+        section.isTrusted = { enabledCommands: ['git.viewCommit'] };
+        const tooltip = buildProviderTooltip(section, wiringRenderer, openerService, toDispose)!;
+        await click(tooltip, 'a[href^="command:"]');
+        expect(opened).to.deep.equal(['command:git.viewCommit']);
+    });
+
+    it('does not let one section authorize another section\'s commands', async () => {
+        const untrusted = new MarkdownStringImpl('<a id="untrusted" href="command:git.viewCommit">Open Commit</a>');
+        const trusted = new MarkdownStringImpl('<a id="trusted" href="command:git.copyContentToClipboard">Copy</a>');
+        trusted.isTrusted = { enabledCommands: ['git.copyContentToClipboard'] };
+        const tooltip = buildProviderTooltip([untrusted, trusted], htmlRenderer, openerService, toDispose)!;
+
+        await click(tooltip, 'a#untrusted');
+        expect(opened, 'untrusted section').to.be.empty;
+        await click(tooltip, 'a#trusted');
+        expect(opened, 'trusted section').to.deep.equal(['command:git.copyContentToClipboard']);
+    });
+});

package/src/browser/scm-history-graph-tooltip.ts

@@ -15,12 +15,15 @@
 // *****************************************************************************
 
 import { MarkdownRenderer } from '@theia/core/lib/browser/markdown-rendering/markdown-renderer';
-import { MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering/markdown-string';
+import { wireMarkdownLinkHandler } from '@theia/core/lib/browser/markdown-rendering/markdown-link-handler';
+import { MarkdownString, MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering/markdown-string';
+import { OpenerService } from '@theia/core/lib/browser/opener-service';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import { codicon } from '@theia/core/lib/browser/widgets/widget';
 import { nls } from '@theia/core/lib/common/nls';
-import { ScmHistoryItemRef } from './scm-provider';
+import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryProvider } from './scm-provider';
 import { HistoryGraphEntry } from './scm-history-graph-model';
-import { laneColor, getRefBadgeClass, deduplicateRefs, isTagRef, isRemoteRef } from './scm-history-graph-helpers';
+import { laneColor, getRefBadgeClass, getRefBadgePresentation, deduplicateRefs, isTagRef, isRemoteRef } from './scm-history-graph-helpers';
 
 export function formatRelativeTime(ms: number): string {
     const now = Date.now();
@@ -75,6 +78,100 @@ export function createHoverHr(): HTMLElement {
     return document.createElement('hr');
 }
 
+export interface HistoryTooltipActions {
+    /** Invoked when the user clicks the commit hash (mirrors VS Code's "Open Commit" hover command). */
+    openCommit?: () => void;
+    /** Invoked when the user clicks the copy action (mirrors VS Code's "Copy Commit Hash" hover command). */
+    copyCommitHash?: () => void;
+}
+
+/**
+ * Renders the hover content supplied by the history provider, if any.
+ *
+ * Providers own their hover: `vscode.git`, for example, sends the same content as the blame
+ * editor decoration hover, including the author `mailto:` link and the "Open Commit",
+ * "Copy Commit Hash" and remote (e.g. "Open on GitHub") command links. Rendering it verbatim
+ * keeps those actions working without the graph having to know any provider-specific command.
+ *
+ * Each section is rendered and wired separately so that a section only authorizes the commands
+ * declared in its own {@link MarkdownString.isTrusted}. Sections are rendered as given, without
+ * separators of our own: a provider that owns its hover also owns how its sections are delimited,
+ * and `vscode.git` for one already ends them with a horizontal rule.
+ *
+ * @returns the rendered element, or `undefined` if the provider supplied no usable content.
+ */
+export function buildProviderTooltip(
+    tooltip: string | MarkdownString | readonly MarkdownString[],
+    markdownRenderer: MarkdownRenderer,
+    openerService: OpenerService,
+    disposables: DisposableCollection
+): HTMLElement | undefined {
+    const sections = (typeof tooltip === 'string' ? [new MarkdownStringImpl(tooltip)] : Array.isArray(tooltip) ? tooltip : [tooltip as MarkdownString])
+        .filter(section => section.value.trim().length > 0);
+    if (sections.length === 0) {
+        return undefined;
+    }
+
+    const container = document.createElement('div');
+    container.className = 'scm-history-tooltip';
+    for (const section of sections) {
+        const rendered = markdownRenderer.render(section);
+        disposables.push(rendered);
+        disposables.push(wireMarkdownLinkHandler(rendered.element, section, openerService));
+        container.appendChild(rendered.element);
+    }
+    return container;
+}
+
+/**
+ * Appends the author part of the tooltip header: the avatar image (or account
+ * icon) followed by the bold author name, linked via `mailto:` when the email
+ * is known — the same structure as the git blame editor decoration hover.
+ */
+function appendAuthor(container: HTMLElement, item: ScmHistoryItem): void {
+    if (item.authorIcon && (item.authorIcon.startsWith('http://') || item.authorIcon.startsWith('https://'))) {
+        const avatar = document.createElement('img');
+        avatar.className = 'scm-history-tooltip-avatar';
+        avatar.src = item.authorIcon;
+        container.appendChild(avatar);
+    } else {
+        const icon = document.createElement('i');
+        icon.className = codicon('account') + ' icon-inline';
+        container.appendChild(icon);
+    }
+    container.appendChild(document.createTextNode(' '));
+
+    const name = document.createElement('strong');
+    name.textContent = item.author!;
+    if (item.authorEmail) {
+        const link = document.createElement('a');
+        link.href = `mailto:${item.authorEmail}`;
+        link.appendChild(name);
+        container.appendChild(link);
+    } else {
+        container.appendChild(name);
+    }
+}
+
+/** Creates a clickable tooltip action (icon + optional label). */
+function createTooltipAction(title: string, iconName: string, label: string | undefined, onClick: () => void): HTMLElement {
+    const action = document.createElement('a');
+    action.className = 'scm-history-tooltip-action';
+    action.title = title;
+    action.setAttribute('role', 'button');
+    const icon = document.createElement('i');
+    icon.className = codicon(iconName) + ' icon-inline';
+    action.appendChild(icon);
+    if (label) {
+        action.appendChild(document.createTextNode(` ${label}`));
+    }
+    action.onclick = e => {
+        e.preventDefault();
+        onClick();
+    };
+    return action;
+}
+
 /** Creates a ref badge element for the HTML tooltip. */
 export function buildTooltipRefBadge(
     ref: ScmHistoryItemRef,
@@ -100,28 +197,32 @@ export function buildTooltipRefBadge(
     return badge;
 }
 
-export function buildHtmlTooltip(entry: HistoryGraphEntry, markdownRenderer: MarkdownRenderer): HTMLElement {
+export function buildHtmlTooltip(
+    entry: HistoryGraphEntry,
+    markdownRenderer: MarkdownRenderer,
+    provider?: ScmHistoryProvider,
+    actions?: HistoryTooltipActions
+): HTMLElement {
     const { item } = entry;
     const badgeColor = laneColor(entry.graphRow.color);
     const container = document.createElement('div');
     container.className = 'scm-history-tooltip';
 
-    // Header
+    // Header - avatar/account icon, bold author (mailto link), relative + absolute date,
+    // matching the git blame editor decoration hover
     if (item.author || item.timestamp !== undefined) {
         const header = document.createElement('div');
         header.className = 'scm-history-tooltip-header';
-        header.style.fontWeight = 'bold';
-        header.style.marginBottom = '4px';
 
         if (item.author) {
-            appendIconText(header, 'account', item.author);
+            appendAuthor(header, item);
         }
         if (item.timestamp !== undefined) {
             if (item.author) {
-                header.appendChild(document.createTextNode('\u00a0\u00a0'));
+                header.appendChild(document.createTextNode(',\u00a0'));
             }
             const timeSpan = document.createElement('span');
-            appendIconText(timeSpan, 'clock', `${formatRelativeTime(item.timestamp)} (${formatAbsoluteDate(item.timestamp)})`);
+            appendIconText(timeSpan, 'history', `${formatRelativeTime(item.timestamp)} (${formatAbsoluteDate(item.timestamp)})`);
             header.appendChild(timeSpan);
         }
 
@@ -170,8 +271,10 @@ export function buildHtmlTooltip(entry: HistoryGraphEntry, markdownRenderer: Mar
     }
 
     // Refs + hash
+    const shortHash = item.displayId ?? item.id.substring(0, 7);
+    const hasActions = !!(actions?.openCommit || actions?.copyCommitHash);
     const hasRefs = item.references && item.references.length > 0;
-    if (hasRefs || item.displayId) {
+    if (hasRefs || (!hasActions && item.displayId)) {
         container.appendChild(createHoverHr());
 
         const refsRow = document.createElement('div');
@@ -184,23 +287,18 @@ export function buildHtmlTooltip(entry: HistoryGraphEntry, markdownRenderer: Mar
         if (hasRefs) {
             const deduplicated = deduplicateRefs(item.references!);
             for (const { ref, hasBoth } of deduplicated) {
-                const isTag = isTagRef(ref);
-                const isRemote = isRemoteRef(ref);
-
-                if (isTag) {
-                    refsRow.appendChild(buildTooltipRefBadge(ref, 'codicon-tag', true, badgeColor));
-                } else if (isRemote) {
-                    refsRow.appendChild(buildTooltipRefBadge(ref, 'codicon-cloud', true, badgeColor));
-                } else {
-                    refsRow.appendChild(buildTooltipRefBadge(ref, 'codicon-git-branch', true, badgeColor));
-                    if (hasBoth) {
-                        refsRow.appendChild(buildTooltipRefBadge(ref, 'codicon-cloud', false, badgeColor, 'scm-history-ref-badge-cloud'));
-                    }
+                // Current/remote/base refs are colored by role, others by the row's lane color
+                const { iconClass, colorIndex } = getRefBadgePresentation(ref, provider);
+                const bgColor = colorIndex !== undefined ? laneColor(colorIndex) : badgeColor;
+
+                refsRow.appendChild(buildTooltipRefBadge(ref, iconClass, true, bgColor));
+                if (!isTagRef(ref) && !isRemoteRef(ref) && hasBoth) {
+                    refsRow.appendChild(buildTooltipRefBadge(ref, 'codicon-cloud', false, bgColor, 'scm-history-ref-badge-cloud'));
                 }
             }
         }
 
-        if (item.displayId) {
+        if (!hasActions && item.displayId) {
             const hash = document.createElement('code');
             hash.textContent = item.displayId;
             refsRow.appendChild(hash);
@@ -209,5 +307,27 @@ export function buildHtmlTooltip(entry: HistoryGraphEntry, markdownRenderer: Mar
         container.appendChild(refsRow);
     }
 
+    // Actions — commit hash and copy, matching the git blame hover's command links
+    if (hasActions) {
+        container.appendChild(createHoverHr());
+
+        const actionsRow = document.createElement('div');
+        actionsRow.className = 'scm-history-tooltip-actions';
+
+        if (actions?.openCommit) {
+            actionsRow.appendChild(createTooltipAction(
+                nls.localize('theia/scm/openCommit', 'Open Commit'), 'git-commit', shortHash, actions.openCommit));
+        }
+        if (actions?.copyCommitHash) {
+            if (actions.openCommit) {
+                actionsRow.appendChild(document.createTextNode('  '));
+            }
+            actionsRow.appendChild(createTooltipAction(
+                nls.localize('theia/scm/copyCommitHash', 'Copy Commit Hash'), 'copy', undefined, actions.copyCommitHash));
+        }
+
+        container.appendChild(actionsRow);
+    }
+
     return container;
 }

package/src/browser/scm-history-graph-widget.spec.ts

@@ -0,0 +1,112 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { ContextKey, ContextKeyServiceDummyImpl, ContextKeyValue } from '@theia/core/lib/browser/context-key-service';
+import { ScmContextKeyService } from './scm-context-key-service';
+import { ScmHistoryGraphWidget } from './scm-history-graph-widget';
+import { ScmHistoryProvider } from './scm-provider';
+
+disableJSDOM();
+
+class MockContextKeyService extends ContextKeyServiceDummyImpl {
+    override createKey<T extends ContextKeyValue>(key: string, defaultValue: T | undefined): ContextKey<T> {
+        let value: T | undefined = defaultValue;
+        return {
+            set: (v: T | undefined) => { value = v; },
+            reset: () => { value = defaultValue; },
+            get: () => value
+        };
+    }
+}
+
+function createScmContextKeyService(): ScmContextKeyService {
+    const service = new ScmContextKeyService();
+    (service as unknown as { contextKeyService: MockContextKeyService }).contextKeyService = new MockContextKeyService();
+    (service as unknown as { init(): void }).init();
+    return service;
+}
+
+describe('ScmHistoryGraphWidget context keys', () => {
+    let restoreJSDOM: () => void;
+    let widget: ScmHistoryGraphWidget;
+    let scmContextKeys: ScmContextKeyService;
+    let provider: Partial<ScmHistoryProvider> | undefined;
+    let currentRefInFilter: boolean;
+
+    beforeEach(() => {
+        restoreJSDOM = enableJSDOM();
+        scmContextKeys = createScmContextKeyService();
+        currentRefInFilter = true;
+        widget = new ScmHistoryGraphWidget();
+        const raw = widget as unknown as Record<string, unknown>;
+        raw.scmContextKeys = scmContextKeys;
+        Object.defineProperty(raw, 'model', {
+            get: () => ({ provider, isCurrentRefInFilter: () => currentRefInFilter })
+        });
+    });
+
+    afterEach(() => {
+        restoreJSDOM();
+    });
+
+    function updateContextKeys(): void {
+        (widget as unknown as { updateContextKeys(): void }).updateContextKeys();
+    }
+
+    it('should set scmCurrentHistoryItemRefInFilter when the provider has a current ref', () => {
+        provider = {
+            currentHistoryItemRef: { id: 'refs/heads/main', name: 'main' }
+        };
+        updateContextKeys();
+        expect(scmContextKeys.scmCurrentHistoryItemRefInFilter.get()).to.equal(true);
+    });
+
+    it('should clear scmCurrentHistoryItemRefInFilter when the provider has no current ref', () => {
+        scmContextKeys.scmCurrentHistoryItemRefInFilter.set(true);
+        provider = {};
+        updateContextKeys();
+        expect(scmContextKeys.scmCurrentHistoryItemRefInFilter.get()).to.equal(false);
+    });
+
+    it('should clear scmCurrentHistoryItemRefInFilter when there is no provider', () => {
+        scmContextKeys.scmCurrentHistoryItemRefInFilter.set(true);
+        provider = undefined;
+        updateContextKeys();
+        expect(scmContextKeys.scmCurrentHistoryItemRefInFilter.get()).to.equal(false);
+    });
+
+    it('should clear scmCurrentHistoryItemRefInFilter when the filter excludes the current ref', () => {
+        provider = {
+            currentHistoryItemRef: { id: 'refs/heads/main', name: 'main' }
+        };
+        currentRefInFilter = false;
+        updateContextKeys();
+        expect(scmContextKeys.scmCurrentHistoryItemRefInFilter.get()).to.equal(false);
+    });
+
+    it('should set scmCurrentHistoryItemRefHasRemote when the provider has a remote ref', () => {
+        provider = {
+            currentHistoryItemRef: { id: 'refs/heads/main', name: 'main' },
+            currentHistoryItemRemoteRef: { id: 'refs/remotes/origin/main', name: 'origin/main' }
+        };
+        updateContextKeys();
+        expect(scmContextKeys.scmCurrentHistoryItemRefHasRemote.get()).to.equal(true);
+    });
+});