@theia/scm 1.71.0-next.8 → 1.71.0

package/src/browser/scm-context-key-service.ts

@@ -28,6 +28,11 @@ export class ScmContextKeyService {
         return this._scmProvider;
     }
 
+    protected _scmProviderContext: ContextKey<string | undefined>;
+    get scmProviderContext(): ContextKey<string | undefined> {
+        return this._scmProviderContext;
+    }
+
     protected _scmResourceGroup: ContextKey<string | undefined>;
     get scmResourceGroup(): ContextKey<string | undefined> {
         return this._scmResourceGroup;
@@ -43,12 +48,31 @@ export class ScmContextKeyService {
         return this._scmProviderCount;
     }
 
+    protected _scmHistoryItemRef: ContextKey<string | undefined>;
+    get scmHistoryItemRef(): ContextKey<string | undefined> {
+        return this._scmHistoryItemRef;
+    }
+
+    protected _scmCurrentHistoryItemRefHasRemote: ContextKey<boolean>;
+    get scmCurrentHistoryItemRefHasRemote(): ContextKey<boolean> {
+        return this._scmCurrentHistoryItemRefHasRemote;
+    }
+
+    protected _scmCurrentHistoryItemRefHasBase: ContextKey<boolean>;
+    get scmCurrentHistoryItemRefHasBase(): ContextKey<boolean> {
+        return this._scmCurrentHistoryItemRefHasBase;
+    }
+
     @postConstruct()
     protected init(): void {
         this._scmProvider = this.contextKeyService.createKey<string | undefined>('scmProvider', undefined);
+        this._scmProviderContext = this.contextKeyService.createKey<string | undefined>('scmProviderContext', undefined);
         this._scmResourceGroup = this.contextKeyService.createKey<string | undefined>('scmResourceGroup', undefined);
         this._scmResourceGroupState = this.contextKeyService.createKey<string | undefined>('scmResourceGroupState', undefined);
         this._scmProviderCount = this.contextKeyService.createKey<number>('scm.providerCount', 0);
+        this._scmHistoryItemRef = this.contextKeyService.createKey<string | undefined>('scmHistoryItemRef', undefined);
+        this._scmCurrentHistoryItemRefHasRemote = this.contextKeyService.createKey<boolean>('scmCurrentHistoryItemRefHasRemote', false);
+        this._scmCurrentHistoryItemRefHasBase = this.contextKeyService.createKey<boolean>('scmCurrentHistoryItemRefHasBase', false);
     }
 
     match(expression: string | undefined): boolean {

package/src/browser/scm-contribution.ts

@@ -411,6 +411,147 @@ export class ScmContribution extends AbstractViewContribution<ScmWidget> impleme
      */
     registerColors(colors: ColorRegistry): void {
         colors.register(
+            // SCM Graph lane colors (matching VS Code's scm.graph.* color IDs)
+            {
+                id: 'scmGraph.historyItemHoverDefaultLabelForeground',
+                defaults: {
+                    dark: '#0078d4',
+                    light: '#0078d4',
+                    hcDark: '#0078d4',
+                    hcLight: '#0078d4'
+                },
+                description: 'Default foreground color for history item labels in the SCM history graph on hover.'
+            },
+            {
+                id: 'scmGraph.historyItemHoverAdditionsForeground',
+                defaults: {
+                    dark: '#81b88b',
+                    light: '#388a34',
+                    hcDark: '#81b88b',
+                    hcLight: '#388a34'
+                },
+                description: 'Foreground color for additions in the SCM history graph on hover.'
+            },
+            {
+                id: 'scmGraph.historyItemHoverDeletionsForeground',
+                defaults: {
+                    dark: '#c74e39',
+                    light: '#a1260d',
+                    hcDark: '#c74e39',
+                    hcLight: '#a1260d'
+                },
+                description: 'Foreground color for deletions in the SCM history graph on hover.'
+            },
+            {
+                id: 'scmGraph.historyItemHoverLabelForeground',
+                defaults: {
+                    dark: '#e2e2e2',
+                    light: '#3b3b3b',
+                    hcDark: '#ffffff',
+                    hcLight: '#000000'
+                },
+                description: 'Foreground color for labels in the SCM history graph on hover.'
+            },
+            {
+                id: 'scmGraph.historyItemRefForeground',
+                defaults: {
+                    dark: '#ffffff',
+                    light: '#ffffff',
+                    hcDark: '#ffffff',
+                    hcLight: '#ffffff'
+                },
+                description: 'Foreground color for ref badge labels in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.historyItemRefColor',
+                defaults: {
+                    dark: '#0078d4',
+                    light: '#0078d4',
+                    hcDark: '#0078d4',
+                    hcLight: '#0078d4'
+                },
+                description: 'Color for ref labels in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.historyItemRemoteRefColor',
+                defaults: {
+                    dark: '#b267e6',
+                    light: '#8b009b',
+                    hcDark: '#b267e6',
+                    hcLight: '#8b009b'
+                },
+                description: 'Color for remote ref labels in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.historyItemTagRefColor',
+                defaults: {
+                    dark: '#d7ba7d',
+                    light: '#8d6914',
+                    hcDark: '#d7ba7d',
+                    hcLight: '#8d6914'
+                },
+                description: 'Color for tag ref labels in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.historyItemBaseRefColor',
+                defaults: {
+                    dark: '#a1260d',
+                    light: '#a1260d',
+                    hcDark: '#a1260d',
+                    hcLight: '#a1260d'
+                },
+                description: 'Color for base ref labels in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.foreground1',
+                defaults: {
+                    dark: '#ffb000',
+                    light: '#ffb000',
+                    hcDark: '#ffb000',
+                    hcLight: '#ffb000'
+                },
+                description: 'Foreground color 1 for additional lanes in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.foreground2',
+                defaults: {
+                    dark: '#dc267f',
+                    light: '#dc267f',
+                    hcDark: '#dc267f',
+                    hcLight: '#dc267f'
+                },
+                description: 'Foreground color 2 for additional lanes in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.foreground3',
+                defaults: {
+                    dark: '#994f00',
+                    light: '#994f00',
+                    hcDark: '#994f00',
+                    hcLight: '#994f00'
+                },
+                description: 'Foreground color 3 for additional lanes in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.foreground4',
+                defaults: {
+                    dark: '#40b0a6',
+                    light: '#40b0a6',
+                    hcDark: '#40b0a6',
+                    hcLight: '#40b0a6'
+                },
+                description: 'Foreground color 4 for additional lanes in the SCM history graph.'
+            },
+            {
+                id: 'scmGraph.foreground5',
+                defaults: {
+                    dark: '#b66dff',
+                    light: '#b66dff',
+                    hcDark: '#b66dff',
+                    hcLight: '#b66dff'
+                },
+                description: 'Foreground color 5 for additional lanes in the SCM history graph.'
+            },
             {
                 id: ScmColors.editorGutterModifiedBackground, defaults: {
                     dark: '#1B81A8',
@@ -482,6 +623,22 @@ export class ScmContribution extends AbstractViewContribution<ScmWidget> impleme
                     hcDark: Color.transparent(ScmColors.editorGutterDeletedBackground, 0.6),
                     hcLight: Color.transparent(ScmColors.editorGutterDeletedBackground, 0.6)
                 }, description: 'Overview ruler marker color for deleted content.'
+            },
+            {
+                id: 'scmGraph.historyItemHoverAdditionsForeground', defaults: {
+                    dark: '#81B88B',
+                    light: '#587C0C',
+                    hcDark: '#A1E3AD',
+                    hcLight: '#374E06'
+                }, description: 'History item hover additions foreground color.'
+            },
+            {
+                id: 'scmGraph.historyItemHoverDeletionsForeground', defaults: {
+                    dark: '#C74E39',
+                    light: '#AD0707',
+                    hcDark: '#C74E39',
+                    hcLight: '#AD0707'
+                }, description: 'History item hover deletions foreground color.'
             }
         );
     }

package/src/browser/scm-frontend-module.ts

@@ -45,6 +45,8 @@ import { LabelProviderContribution } from '@theia/core/lib/browser/label-provide
 import { bindScmPreferences } from '../common/scm-preferences';
 import { bindMergeEditor } from './merge-editor/merge-editor-module';
 import { ScmRepositoriesWidget } from './scm-repositories-widget';
+import { ScmHistoryGraphWidget } from './scm-history-graph-widget';
+import { ScmHistoryGraphModel } from './scm-history-graph-model';
 
 export default new ContainerModule(bind => {
     bind(ScmContextKeyService).toSelf().inSingletonScope();
@@ -88,6 +90,13 @@ export default new ContainerModule(bind => {
         createWidget: () => container.get(ScmRepositoriesWidget)
     })).inSingletonScope();
 
+    bind(ScmHistoryGraphModel).toSelf().inSingletonScope();
+    bind(ScmHistoryGraphWidget).toSelf();
+    bind(WidgetFactory).toDynamicValue(({ container }) => ({
+        id: ScmHistoryGraphWidget.ID,
+        createWidget: () => container.get(ScmHistoryGraphWidget)
+    })).inSingletonScope();
+
     bind(WidgetFactory).toDynamicValue(({ container }) => ({
         id: SCM_VIEW_CONTAINER_ID,
         createWidget: async () => {
@@ -110,6 +119,12 @@ export default new ContainerModule(bind => {
                 canHide: false,
                 initiallyCollapsed: false
             });
+            const graphWidget = await widgetManager.getOrCreateWidget(ScmHistoryGraphWidget.ID);
+            viewContainer.addWidget(graphWidget, {
+                order: 2,
+                canHide: true,
+                initiallyCollapsed: true
+            });
             return viewContainer;
         }
     })).inSingletonScope();

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

@@ -0,0 +1,175 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH 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 { ScmHistoryItemRef, ScmHistoryItemChange } from './scm-provider';
+
+/**
+ * Returns the CSS color variable for the given lane index.
+ * Uses Theia's `--theia-scmGraph-*` variables, mirroring the VS Code
+ * scm graph color scheme:
+ *   lane 0 (current ref)  → historyItemRefColor
+ *   lane 1 (remote ref)   → historyItemRemoteRefColor
+ *   lane 2 (base ref)     → historyItemBaseRefColor
+ *   lane 3–7              → foreground1–5
+ */
+export function laneColor(index: number): string {
+    switch (index % 8) {
+        case 0: return 'var(--theia-scmGraph-historyItemRefColor)';
+        case 1: return 'var(--theia-scmGraph-historyItemRemoteRefColor)';
+        case 2: return 'var(--theia-scmGraph-historyItemBaseRefColor)';
+        case 3: return 'var(--theia-scmGraph-foreground1)';
+        case 4: return 'var(--theia-scmGraph-foreground2)';
+        case 5: return 'var(--theia-scmGraph-foreground3)';
+        case 6: return 'var(--theia-scmGraph-foreground4)';
+        default: return 'var(--theia-scmGraph-foreground5)';
+    }
+}
+
+export function getChangeStatus(change: ScmHistoryItemChange): string {
+    if (!change.originalUri) {
+        return 'A';
+    }
+    if (!change.modifiedUri) {
+        return 'D';
+    }
+    if (change.renameUri) {
+        return 'R';
+    }
+    return 'M';
+}
+
+export function getFileName(uri: string): string {
+    const parts = uri.split('/');
+    return parts[parts.length - 1] || uri;
+}
+
+export function getFilePath(uri: string): string {
+    try {
+        const u = new URL(uri);
+        return u.pathname;
+    } catch {
+        return uri;
+    }
+}
+
+/**
+ * Returns the repo-relative path of the given URI, stripping the rootUri prefix.
+ * Falls back to the full path if rootUri is unavailable or doesn't match.
+ */
+export function getRepoRelativePath(uri: string, rootUri: string | undefined): string {
+    const fullPath = getFilePath(uri);
+    if (!rootUri) {
+        return fullPath;
+    }
+    const rootPath = getFilePath(rootUri);
+    // Normalize: ensure rootPath ends with '/'
+    const rootPrefix = rootPath.endsWith('/') ? rootPath : rootPath + '/';
+    if (fullPath.startsWith(rootPrefix)) {
+        return fullPath.slice(rootPrefix.length);
+    }
+    return fullPath;
+}
+
+export function getRefBadgeClass(ref: ScmHistoryItemRef): string {
+    const cat = (ref.category ?? '').toLowerCase();
+    if (cat === 'heads' || cat === 'head' || ref.id.startsWith('refs/heads/')) {
+        return 'head';
+    }
+    if (cat === 'remotes' || cat === 'remote' || ref.id.startsWith('refs/remotes/')) {
+        return 'remote';
+    }
+    if (cat === 'tags' || cat === 'tag' || ref.id.startsWith('refs/tags/')) {
+        return 'tag';
+    }
+    if (cat === 'base') {
+        return 'base';
+    }
+    return 'head';
+}
+
+export function isTagRef(ref: ScmHistoryItemRef): boolean {
+    const cat = (ref.category ?? '').toLowerCase();
+    if (cat === 'tags' || cat === 'tag') {
+        return true;
+    }
+    // Fall back to checking the ref id prefix (e.g. 'refs/tags/v1.0')
+    return ref.id.startsWith('refs/tags/');
+}
+
+export function isRemoteRef(ref: ScmHistoryItemRef): boolean {
+    const cat = (ref.category ?? '').toLowerCase();
+    if (cat === 'remotes' || cat === 'remote') {
+        return true;
+    }
+    // Fall back to checking the ref id prefix (e.g. 'refs/remotes/origin/main')
+    return ref.id.startsWith('refs/remotes/');
+}
+
+/**
+ * Extracts the local branch name from a remote ref name like "origin/master" → "master".
+ * Falls back to the full name if no slash is found.
+ */
+export function getLocalNameFromRemote(remoteName: string): string {
+    const slashIdx = remoteName.indexOf('/');
+    return slashIdx >= 0 ? remoteName.slice(slashIdx + 1) : remoteName;
+}
+
+export interface DeduplicatedRef {
+    ref: ScmHistoryItemRef;
+    /** True when both a local and a remote ref for this branch exist on this commit. */
+    hasBoth: boolean;
+}
+
+/**
+ * Deduplicates refs: when a local branch (e.g. "master") and a remote branch
+ * (e.g. "origin/master") both appear, collapse them into one entry with `hasBoth=true`.
+ * Tags and other ref types are passed through unchanged.
+ */
+export function deduplicateRefs(refs: readonly ScmHistoryItemRef[]): DeduplicatedRef[] {
+    const localNames = new Set<string>();
+    for (const ref of refs) {
+        if (!isRemoteRef(ref) && !isTagRef(ref)) {
+            localNames.add(ref.name.toLowerCase());
+        }
+    }
+
+    const result: DeduplicatedRef[] = [];
+    const suppressedRemotes = new Set<string>();
+
+    // First pass: identify remote refs that have a matching local branch
+    for (const ref of refs) {
+        if (isRemoteRef(ref)) {
+            const localName = getLocalNameFromRemote(ref.name).toLowerCase();
+            if (localNames.has(localName)) {
+                suppressedRemotes.add(ref.id);
+            }
+        }
+    }
+
+    // Second pass: emit all refs except suppressed remote ones;
+    // mark local branches that have a matching remote with hasBoth=true
+    for (const ref of refs) {
+        if (suppressedRemotes.has(ref.id)) {
+            continue;
+        }
+        const hasBoth = !isRemoteRef(ref) && !isTagRef(ref)
+            ? refs.some(r => isRemoteRef(r) && getLocalNameFromRemote(r.name).toLowerCase() === ref.name.toLowerCase())
+            : false;
+        result.push({ ref, hasBoth });
+    }
+
+    return result;
+}