@theia/scm 1.75.0-next.4 → 1.75.0-next.42

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

@@ -0,0 +1,148 @@
+// *****************************************************************************
+// 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 { Command, CommandHandler, CommandRegistry } from '@theia/core/lib/common/command';
+import { Disposable } from '@theia/core/lib/common/disposable';
+import { ScmHistoryGraphContribution, ScmHistoryGraphCommands } from './scm-history-graph-contribution';
+import { ScmHistoryGraphModel, ScmHistoryViewMode } from './scm-history-graph-model';
+import { ScmHistoryProvider } from './scm-provider';
+
+disableJSDOM();
+
+interface ContributionInternals {
+    scmService: { selectedRepository: { provider: { historyProvider?: ScmHistoryProvider } } | undefined };
+    modelProvider: () => ScmHistoryGraphModel;
+    quickInputService: unknown;
+    scmContextKeys: unknown;
+}
+
+const ALL_COMMANDS = [
+    ScmHistoryGraphCommands.REFRESH,
+    ScmHistoryGraphCommands.PICK_HISTORY_ITEM_REFS,
+    ScmHistoryGraphCommands.REVEAL_CURRENT_HISTORY_ITEM,
+    ScmHistoryGraphCommands.SET_LIST_VIEW_MODE,
+    ScmHistoryGraphCommands.SET_TREE_VIEW_MODE,
+];
+
+function createContribution(historyProvider: ScmHistoryProvider | undefined, currentRefInFilter = true): {
+    handlers: Map<string, CommandHandler>;
+    modelResolved(): boolean;
+    revealCount(): number;
+    viewMode(): ScmHistoryViewMode;
+} {
+    const contribution = new ScmHistoryGraphContribution();
+    let resolved = false;
+    let reveals = 0;
+    let viewMode: ScmHistoryViewMode = 'list';
+    const internals = contribution as unknown as ContributionInternals;
+    internals.scmService = {
+        selectedRepository: historyProvider ? { provider: { historyProvider } } : undefined,
+    };
+    internals.modelProvider = () => {
+        resolved = true;
+        return {
+            historyItemRefFilter: undefined,
+            revealCurrentHistoryItem: async () => { reveals++; return undefined; },
+            get viewMode(): ScmHistoryViewMode { return viewMode; },
+            setViewMode: (mode: ScmHistoryViewMode) => { viewMode = mode; },
+        } as unknown as ScmHistoryGraphModel;
+    };
+    internals.quickInputService = {};
+    internals.scmContextKeys = {
+        scmCurrentHistoryItemRefInFilter: { get: () => currentRefInFilter },
+    };
+
+    const handlers = new Map<string, CommandHandler>();
+    const registry = {
+        registerCommand: (command: Command, handler: CommandHandler): Disposable => {
+            handlers.set(command.id, handler);
+            return Disposable.NULL;
+        },
+    } as unknown as CommandRegistry;
+    contribution.registerCommands(registry);
+    return { handlers, modelResolved: () => resolved, revealCount: () => reveals, viewMode: () => viewMode };
+}
+
+describe('ScmHistoryGraphContribution', () => {
+
+    it('does not resolve the graph model for enablement and visibility checks', () => {
+        const { handlers, modelResolved } = createContribution({} as ScmHistoryProvider);
+        for (const command of ALL_COMMANDS) {
+            const handler = handlers.get(command.id)!;
+            expect(handler.isEnabled!()).to.be.true;
+            expect(handler.isVisible!()).to.be.true;
+        }
+        expect(modelResolved()).to.be.false;
+    });
+
+    it('disables the commands when the selected repository has no history provider', () => {
+        const { handlers, modelResolved } = createContribution(undefined);
+        for (const command of ALL_COMMANDS) {
+            const handler = handlers.get(command.id)!;
+            expect(handler.isEnabled!()).to.be.false;
+            expect(handler.isVisible!()).to.be.false;
+        }
+        expect(modelResolved()).to.be.false;
+    });
+
+    it('disables revealing the current history item when the filter excludes the current ref', () => {
+        const { handlers } = createContribution({} as ScmHistoryProvider, false);
+        const handler = handlers.get(ScmHistoryGraphCommands.REVEAL_CURRENT_HISTORY_ITEM.id)!;
+        expect(handler.isEnabled!()).to.be.false;
+    });
+
+    it('keeps revealing the current history item visible when the filter excludes the current ref', () => {
+        const { handlers } = createContribution({} as ScmHistoryProvider, false);
+        const handler = handlers.get(ScmHistoryGraphCommands.REVEAL_CURRENT_HISTORY_ITEM.id)!;
+        expect(handler.isVisible!()).to.be.true;
+    });
+
+    it('asks the model to reveal the current history item when executed', async () => {
+        const { handlers, revealCount } = createContribution({} as ScmHistoryProvider);
+        await handlers.get(ScmHistoryGraphCommands.REVEAL_CURRENT_HISTORY_ITEM.id)!.execute();
+        expect(revealCount()).to.equal(1);
+    });
+
+    it('switches the model to the tree view mode', async () => {
+        const { handlers, viewMode } = createContribution({} as ScmHistoryProvider);
+        await handlers.get(ScmHistoryGraphCommands.SET_TREE_VIEW_MODE.id)!.execute();
+        expect(viewMode()).to.equal('tree');
+    });
+
+    it('switches the model back to the list view mode', async () => {
+        const { handlers, viewMode } = createContribution({} as ScmHistoryProvider);
+        await handlers.get(ScmHistoryGraphCommands.SET_TREE_VIEW_MODE.id)!.execute();
+        await handlers.get(ScmHistoryGraphCommands.SET_LIST_VIEW_MODE.id)!.execute();
+        expect(viewMode()).to.equal('list');
+    });
+
+    it('toggles the view mode command matching the current view mode', async () => {
+        const { handlers } = createContribution({} as ScmHistoryProvider);
+        const list = handlers.get(ScmHistoryGraphCommands.SET_LIST_VIEW_MODE.id)!;
+        const tree = handlers.get(ScmHistoryGraphCommands.SET_TREE_VIEW_MODE.id)!;
+        expect(list.isToggled!()).to.be.true;
+        expect(tree.isToggled!()).to.be.false;
+
+        await tree.execute();
+
+        expect(list.isToggled!()).to.be.false;
+        expect(tree.isToggled!()).to.be.true;
+    });
+});

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

@@ -0,0 +1,273 @@
+// *****************************************************************************
+// 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 { injectable, inject, named, optional } from '@theia/core/shared/inversify';
+import { ILogger } from '@theia/core';
+import { Command, CommandContribution, CommandRegistry } from '@theia/core/lib/common/command';
+import { MenuContribution, MenuModelRegistry } from '@theia/core/lib/common/menu';
+import { nls } from '@theia/core/lib/common/nls';
+import { CancellationTokenSource } from '@theia/core/lib/common/cancellation';
+import { QuickInputService } from '@theia/core/lib/browser';
+import { QuickPickItem, QuickPickSeparator } from '@theia/core/lib/common/quick-pick-service';
+import { codicon } from '@theia/core/lib/browser/widgets/widget';
+import { ScmHistoryGraphModel, ScmHistoryGraphModelProvider } from './scm-history-graph-model';
+import { ScmService } from './scm-service';
+import { ScmContextKeyService } from './scm-context-key-service';
+import { ScmHistoryItemRef, ScmHistoryProvider } from './scm-provider';
+import { SCM_HISTORY_TITLE_MENU } from './scm-history-graph-widget';
+import { getRefBadgeClass } from './scm-history-graph-helpers';
+
+export namespace ScmHistoryGraphCommands {
+    export const REFRESH = Command.toDefaultLocalizedCommand({
+        id: 'scmHistoryGraph.refresh',
+        category: 'Source Control',
+        label: 'Refresh',
+        iconClass: codicon('refresh')
+    });
+    export const PICK_HISTORY_ITEM_REFS = Command.toLocalizedCommand({
+        id: 'scmHistoryGraph.pickHistoryItemRefs',
+        category: 'Source Control',
+        label: 'Pick History Item Reference...',
+        iconClass: codicon('git-branch')
+    }, 'theia/scm/pickHistoryItemRefs');
+    export const REVEAL_CURRENT_HISTORY_ITEM = Command.toDefaultLocalizedCommand({
+        id: 'scmHistoryGraph.revealCurrentHistoryItem',
+        category: 'Source Control',
+        label: 'Go to Current History Item',
+        iconClass: codicon('target')
+    });
+    export const SET_LIST_VIEW_MODE = Command.toDefaultLocalizedCommand({
+        id: 'scmHistoryGraph.setListViewMode',
+        category: 'Source Control',
+        label: 'View as List'
+    });
+    export const SET_TREE_VIEW_MODE = Command.toDefaultLocalizedCommand({
+        id: 'scmHistoryGraph.setTreeViewMode',
+        category: 'Source Control',
+        label: 'View as Tree'
+    });
+}
+
+type RefPickItem = QuickPickItem & { refId?: string; auto?: boolean };
+
+/**
+ * Contributes the native toolbar actions of the SCM history graph: the
+ * history item reference filter picker (VS Code's "Auto" dropdown) and the
+ * refresh action. Extension actions (e.g. fetch/pull/push from vscode.git)
+ * are contributed separately via the `scm/history/title` menu.
+ */
+@injectable()
+export class ScmHistoryGraphContribution implements CommandContribution, MenuContribution {
+
+    @inject(ScmService) protected readonly scmService: ScmService;
+    @inject(ScmHistoryGraphModelProvider) protected readonly modelProvider: ScmHistoryGraphModelProvider;
+    @inject(QuickInputService) @optional() protected readonly quickInputService: QuickInputService;
+    @inject(ILogger) @named('scm:ScmHistoryGraphContribution') protected readonly logger: ILogger;
+    @inject(ScmContextKeyService) protected readonly scmContextKeys: ScmContextKeyService;
+
+    /**
+     * The graph model, resolved lazily: instantiating it starts loading
+     * history, so it must only be resolved when a graph command actually
+     * runs or the graph toolbar renders (the widget has created the model
+     * by then). In particular, `isEnabled`/`isVisible` are also queried by
+     * the command palette and therefore consult the `ScmService` instead.
+     */
+    protected get model(): ScmHistoryGraphModel {
+        return this.modelProvider();
+    }
+
+    protected get historyProvider(): ScmHistoryProvider | undefined {
+        return this.scmService.selectedRepository?.provider.historyProvider;
+    }
+
+    registerCommands(commands: CommandRegistry): void {
+        commands.registerCommand(ScmHistoryGraphCommands.REFRESH, {
+            isEnabled: () => !!this.historyProvider,
+            isVisible: () => !!this.historyProvider,
+            execute: () => this.model.refresh()
+        });
+        commands.registerCommand(ScmHistoryGraphCommands.PICK_HISTORY_ITEM_REFS, {
+            isEnabled: () => !!this.historyProvider && !!this.quickInputService,
+            isVisible: () => !!this.historyProvider,
+            isToggled: () => !!this.model.historyItemRefFilter,
+            execute: () => this.pickHistoryItemRefs()
+        });
+        commands.registerCommand(ScmHistoryGraphCommands.REVEAL_CURRENT_HISTORY_ITEM, {
+            // There is nothing to reveal while the filter excludes the current ref,
+            // mirroring VS Code's precondition for this action.
+            isEnabled: () => !!this.historyProvider && this.scmContextKeys.scmCurrentHistoryItemRefInFilter.get() === true,
+            isVisible: () => !!this.historyProvider,
+            execute: () => this.model.revealCurrentHistoryItem()
+        });
+        commands.registerCommand(ScmHistoryGraphCommands.SET_LIST_VIEW_MODE, {
+            isEnabled: () => !!this.historyProvider,
+            isVisible: () => !!this.historyProvider,
+            isToggled: () => this.model.viewMode === 'list',
+            execute: () => this.model.setViewMode('list')
+        });
+        commands.registerCommand(ScmHistoryGraphCommands.SET_TREE_VIEW_MODE, {
+            isEnabled: () => !!this.historyProvider,
+            isVisible: () => !!this.historyProvider,
+            isToggled: () => this.model.viewMode === 'tree',
+            execute: () => this.model.setViewMode('tree')
+        });
+    }
+
+    registerMenus(menus: MenuModelRegistry): void {
+        // Extension actions from vscode.git sit at order 900-902; the picker
+        // goes before them and refresh last, matching VS Code's graph toolbar.
+        menus.registerMenuAction([...SCM_HISTORY_TITLE_MENU, 'navigation'], {
+            commandId: ScmHistoryGraphCommands.PICK_HISTORY_ITEM_REFS.id,
+            order: '100'
+        });
+        menus.registerMenuAction([...SCM_HISTORY_TITLE_MENU, 'navigation'], {
+            commandId: ScmHistoryGraphCommands.REVEAL_CURRENT_HISTORY_ITEM.id,
+            order: '200'
+        });
+        menus.registerMenuAction([...SCM_HISTORY_TITLE_MENU, 'navigation'], {
+            commandId: ScmHistoryGraphCommands.REFRESH.id,
+            order: '999'
+        });
+        // Groups other than 'navigation' are rendered in the toolbar's overflow menu,
+        // which is where VS Code places the view mode toggles as well.
+        menus.registerMenuAction([...SCM_HISTORY_TITLE_MENU, '9_viewmode'], {
+            commandId: ScmHistoryGraphCommands.SET_LIST_VIEW_MODE.id,
+            order: '1'
+        });
+        menus.registerMenuAction([...SCM_HISTORY_TITLE_MENU, '9_viewmode'], {
+            commandId: ScmHistoryGraphCommands.SET_TREE_VIEW_MODE.id,
+            order: '2'
+        });
+    }
+
+    protected async pickHistoryItemRefs(): Promise<void> {
+        if (!this.quickInputService) {
+            return;
+        }
+        const model = this.model;
+        const provider = model.provider;
+        if (!provider) {
+            return;
+        }
+        const picker = this.quickInputService.createQuickPick<RefPickItem>();
+        const cts = new CancellationTokenSource();
+        try {
+            picker.placeholder = nls.localize('theia/scm/pickHistoryItemRefsPlaceholder', 'Select one or more history item references');
+            picker.canSelectMany = true;
+            picker.matchOnDescription = true;
+            // Show the picker right away and populate it once the refs arrive,
+            // so that a slow ref lookup surfaces as a busy picker instead of a
+            // command that appears to do nothing.
+            picker.busy = true;
+
+            const selection = await new Promise<readonly RefPickItem[] | undefined>(resolve => {
+                picker.onDidAccept(() => {
+                    resolve(picker.selectedItems);
+                    picker.hide();
+                });
+                // Also cancels a still-running ref lookup when the picker is dismissed.
+                picker.onDidHide(() => {
+                    cts.cancel();
+                    resolve(undefined);
+                });
+                picker.show();
+
+                provider.provideHistoryItemRefs(undefined, cts.token).then(refs => {
+                    if (cts.token.isCancellationRequested) {
+                        return;
+                    }
+                    const currentFilter = model.historyItemRefFilter;
+                    const items = this.createRefPickItems(refs ?? [], provider);
+                    picker.items = items;
+                    picker.selectedItems = items.filter((item): item is RefPickItem => !QuickPickSeparator.is(item)
+                        && (currentFilter ? !!item.refId && currentFilter.includes(item.refId) : item.auto === true));
+
+                    // "Auto" is exclusive: checking it unchecks everything else and vice versa
+                    let lastSelection: readonly RefPickItem[] = picker.selectedItems;
+                    picker.onDidChangeSelection(newSelection => {
+                        const autoNow = newSelection.some(item => item.auto);
+                        if (autoNow && newSelection.length > 1) {
+                            const autoBefore = lastSelection.some(item => item.auto);
+                            picker.selectedItems = autoBefore ? newSelection.filter(item => !item.auto) : newSelection.filter(item => item.auto);
+                        }
+                        lastSelection = picker.selectedItems;
+                    });
+                    picker.busy = false;
+                }, err => {
+                    if (!cts.token.isCancellationRequested) {
+                        this.logger.error('Failed to load history item refs', err);
+                    }
+                    picker.hide();
+                });
+            });
+
+            if (!selection) {
+                return;
+            }
+            // The selected repository may have changed while the picker was open;
+            // the picked refs belong to the old provider and must not be applied
+            // to the new one.
+            if (model.provider !== provider) {
+                return;
+            }
+            const refIds = selection.filter(item => item.refId !== undefined).map(item => item.refId!);
+            const auto = selection.some(item => item.auto) || refIds.length === 0;
+            model.setHistoryItemRefFilter(auto ? undefined : refIds);
+        } finally {
+            picker.dispose();
+            cts.dispose();
+        }
+    }
+
+    protected createRefPickItems(refs: readonly ScmHistoryItemRef[], provider: ScmHistoryProvider): (RefPickItem | QuickPickSeparator)[] {
+        const autoRefs = [provider.currentHistoryItemRef, provider.currentHistoryItemRemoteRef, provider.currentHistoryItemBaseRef]
+            .filter((ref): ref is ScmHistoryItemRef => !!ref);
+        const items: (RefPickItem | QuickPickSeparator)[] = [{
+            label: nls.localizeByDefault('Auto'),
+            description: autoRefs.map(ref => ref.name).join(', '),
+            auto: true
+        }];
+
+        const groups: { label: string; badgeClass: string }[] = [
+            { label: nls.localize('theia/scm/refPickerBranches', 'branches'), badgeClass: 'head' },
+            { label: nls.localize('theia/scm/refPickerRemoteBranches', 'remote branches'), badgeClass: 'remote' },
+            { label: nls.localize('theia/scm/refPickerTags', 'tags'), badgeClass: 'tag' }
+        ];
+        const grouped = new Set<ScmHistoryItemRef>();
+        for (const group of groups) {
+            const groupRefs = refs.filter(ref => getRefBadgeClass(ref) === group.badgeClass);
+            if (groupRefs.length > 0) {
+                groupRefs.forEach(ref => grouped.add(ref));
+                items.push({ type: 'separator', label: group.label });
+                items.push(...groupRefs.map(ref => this.toRefPickItem(ref)));
+            }
+        }
+        const remaining = refs.filter(ref => !grouped.has(ref));
+        if (remaining.length > 0) {
+            items.push({ type: 'separator' });
+            items.push(...remaining.map(ref => this.toRefPickItem(ref)));
+        }
+        return items;
+    }
+
+    protected toRefPickItem(ref: ScmHistoryItemRef): RefPickItem {
+        return {
+            label: ref.name,
+            description: ref.description,
+            refId: ref.id
+        };
+    }
+}

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

@@ -0,0 +1,193 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import {
+    buildChangeTreeRows, ChangeTreeFileRow, ChangeTreeRow, filterRefsForBadges, getFileName, getRefBadgePresentation, getRefColorIndex
+} from './scm-history-graph-helpers';
+import { ScmHistoryItemChange, ScmHistoryItemRef, ScmHistoryProvider } from './scm-provider';
+
+describe('getRefColorIndex', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main' };
+    const remoteRef: ScmHistoryItemRef = { id: 'refs/remotes/origin/main', name: 'origin/main' };
+    const baseRef: ScmHistoryItemRef = { id: 'refs/remotes/origin/develop', name: 'origin/develop' };
+    const otherRef: ScmHistoryItemRef = { id: 'refs/heads/feature', name: 'feature' };
+
+    const provider = {
+        currentHistoryItemRef: mainRef,
+        currentHistoryItemRemoteRef: remoteRef,
+        currentHistoryItemBaseRef: baseRef,
+    } as ScmHistoryProvider;
+
+    it('returns 0 for the current history item ref', () => {
+        expect(getRefColorIndex(mainRef, provider)).to.equal(0);
+    });
+
+    it('returns 1 for the current remote ref', () => {
+        expect(getRefColorIndex(remoteRef, provider)).to.equal(1);
+    });
+
+    it('returns 2 for the current base ref', () => {
+        expect(getRefColorIndex(baseRef, provider)).to.equal(2);
+    });
+
+    it('returns undefined for any other ref', () => {
+        expect(getRefColorIndex(otherRef, provider)).to.be.undefined;
+    });
+
+    it('returns undefined without a provider', () => {
+        expect(getRefColorIndex(mainRef, undefined)).to.be.undefined;
+    });
+});
+
+describe('getRefBadgePresentation', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main' };
+    const remoteRef: ScmHistoryItemRef = { id: 'refs/remotes/origin/main', name: 'origin/main' };
+
+    const provider = {
+        currentHistoryItemRef: mainRef,
+        currentHistoryItemRemoteRef: remoteRef,
+    } as ScmHistoryProvider;
+
+    it('prefers the codicon icon transferred from the provider', () => {
+        const ref: ScmHistoryItemRef = { ...mainRef, icon: 'codicon codicon-target' };
+        expect(getRefBadgePresentation(ref, undefined).iconClass).to.equal('codicon-target');
+    });
+
+    it('falls back to the target icon for the current ref', () => {
+        expect(getRefBadgePresentation(mainRef, provider).iconClass).to.equal('codicon-target');
+    });
+
+    it('falls back to category icons for remote, tag, and other local refs', () => {
+        expect(getRefBadgePresentation(remoteRef, provider).iconClass).to.equal('codicon-cloud');
+        expect(getRefBadgePresentation({ id: 'refs/tags/v1', name: 'v1' }, provider).iconClass).to.equal('codicon-tag');
+        expect(getRefBadgePresentation({ id: 'refs/heads/feature', name: 'feature' }, provider).iconClass).to.equal('codicon-git-branch');
+    });
+
+    it('carries the ref color index', () => {
+        expect(getRefBadgePresentation(mainRef, provider).colorIndex).to.equal(0);
+        expect(getRefBadgePresentation(remoteRef, provider).colorIndex).to.equal(1);
+        expect(getRefBadgePresentation({ id: 'refs/heads/feature', name: 'feature' }, provider).colorIndex).to.be.undefined;
+    });
+});
+
+describe('filterRefsForBadges', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main' };
+    const remoteRef: ScmHistoryItemRef = { id: 'refs/remotes/origin/main', name: 'origin/main' };
+    const featureRef: ScmHistoryItemRef = { id: 'refs/heads/feature', name: 'feature' };
+    const refs = [mainRef, remoteRef, featureRef];
+
+    const provider = {
+        currentHistoryItemRef: mainRef,
+        currentHistoryItemRemoteRef: remoteRef,
+    } as ScmHistoryProvider;
+
+    it("returns all refs in 'all' mode", () => {
+        expect(filterRefsForBadges(refs, provider, 'all')).to.deep.equal(refs);
+    });
+
+    it("keeps only the refs used as a filter in 'filter' mode", () => {
+        expect(filterRefsForBadges(refs, provider, 'filter')).to.deep.equal([mainRef, remoteRef]);
+    });
+
+    it("returns all refs in 'filter' mode when no provider is available", () => {
+        expect(filterRefsForBadges(refs, undefined, 'filter')).to.deep.equal(refs);
+    });
+
+    it("keeps only the explicitly picked refs in 'filter' mode with an explicit filter", () => {
+        expect(filterRefsForBadges(refs, provider, 'filter', ['refs/heads/feature'])).to.deep.equal([featureRef]);
+    });
+
+    it("ignores an explicit filter in 'all' mode", () => {
+        expect(filterRefsForBadges(refs, provider, 'all', ['refs/heads/feature'])).to.deep.equal(refs);
+    });
+});
+
+describe('buildChangeTreeRows', () => {
+
+    const rootUri = 'file:///repo';
+
+    function change(path: string): ScmHistoryItemChange {
+        return { uri: `${rootUri}/${path}`, modifiedUri: `${rootUri}/${path}` };
+    }
+
+    /** Renders the rows as indented lines, so the expectations read like a tree. */
+    function describeRows(rows: readonly ChangeTreeRow[]): string[] {
+        return rows.map(row => `${'  '.repeat(row.depth)}${row.type === 'folder' ? row.label + '/' : getFileName(row.path)}`);
+    }
+
+    it('keeps files at the root at depth 0', () => {
+        const rows = buildChangeTreeRows([change('a.ts'), change('b.ts')], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['a.ts', 'b.ts']);
+    });
+
+    it('groups files under their folder', () => {
+        const rows = buildChangeTreeRows([change('src/a.ts'), change('src/b.ts')], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['src/', '  a.ts', '  b.ts']);
+    });
+
+    it('compacts folder chains that hold a single child folder', () => {
+        const rows = buildChangeTreeRows([change('src/browser/a.ts')], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['src/browser/', '  a.ts']);
+    });
+
+    it('stops compacting where a folder chain branches', () => {
+        const rows = buildChangeTreeRows([change('src/browser/a.ts'), change('src/node/b.ts')], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['src/', '  browser/', '    a.ts', '  node/', '    b.ts']);
+    });
+
+    it('does not compact a folder that also holds files', () => {
+        const rows = buildChangeTreeRows([change('src/a.ts'), change('src/browser/b.ts')], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['src/', '  browser/', '    b.ts', '  a.ts']);
+    });
+
+    it('sorts folders before files, each alphabetically', () => {
+        const rows = buildChangeTreeRows([change('z.ts'), change('a.ts'), change('src/b.ts')], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['src/', '  b.ts', 'a.ts', 'z.ts']);
+    });
+
+    it('hides the descendants of a collapsed folder', () => {
+        const rows = buildChangeTreeRows([change('src/a.ts'), change('b.ts')], rootUri, new Set(['src']));
+        expect(describeRows(rows)).to.deep.equal(['src/', 'b.ts']);
+    });
+
+    it('addresses a compacted folder by its full path', () => {
+        const rows = buildChangeTreeRows([change('src/browser/a.ts')], rootUri, new Set(['src/browser']));
+        expect(describeRows(rows)).to.deep.equal(['src/browser/']);
+    });
+
+    it('carries the original change on each file row', () => {
+        const first = change('src/a.ts');
+        const rows = buildChangeTreeRows([first], rootUri, new Set());
+        expect(rows[1].type).to.equal('file');
+        expect((rows[1] as ChangeTreeFileRow).change).to.equal(first);
+    });
+
+    it('keeps the index of the change in the original list, so row keys stay stable', () => {
+        const rows = buildChangeTreeRows([change('z.ts'), change('src/a.ts')], rootUri, new Set());
+        // Sorted as: src/, src/a.ts (index 1), z.ts (index 0).
+        expect(rows.filter(row => row.type === 'file').map(row => (row as ChangeTreeFileRow).index)).to.deep.equal([1, 0]);
+    });
+
+    it('falls back to the full path when the change is outside the repository root', () => {
+        const outside: ScmHistoryItemChange = { uri: 'file:///elsewhere/x.ts', modifiedUri: 'file:///elsewhere/x.ts' };
+        const rows = buildChangeTreeRows([outside], rootUri, new Set());
+        expect(describeRows(rows)).to.deep.equal(['elsewhere/', '  x.ts']);
+    });
+});