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

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

@@ -47,8 +47,14 @@ export interface GraphEdge {
 export interface GraphRow {
     /** Lane index where the commit node is rendered. */
     readonly lane: number;
-    /** Color index for the commit node dot. */
+    /** Color index for the commit node dot and the lane segment below it. */
     readonly color: number;
+    /**
+     * Color index for the lane segment above the commit node. Differs from
+     * `color` when this commit's ref color overrides the color inherited from
+     * the chain above (e.g. the current branch tip below remote-only commits).
+     */
+    readonly topColor: number;
     /** Edges crossing or originating on this row. */
     readonly edges: readonly GraphEdge[];
     /**
@@ -71,11 +77,29 @@ export interface GraphRow {
 interface MutableGraphRow {
     lane: number;
     color: number;
+    topColor: number;
     edges: GraphEdge[];
     hasContinuation: boolean;
     hasTopLine: boolean;
 }
 
+export interface GraphCommitInput {
+    id: string;
+    parentIds?: readonly string[];
+    /**
+     * Ref-based color index resolved from the commit's references
+     * (0 = current ref, 1 = remote ref, 2 = base ref). When set, it colors
+     * this row and propagates down the first-parent chain, mirroring
+     * VS Code's scm graph color map.
+     */
+    colorIndex?: number;
+}
+
+/** First color index of the default rotation (`scmGraph.foreground1`). */
+const DEFAULT_COLOR_FIRST = 3;
+/** Number of default rotation colors (`scmGraph.foreground1-5`). */
+const DEFAULT_COLOR_COUNT = 5;
+
 /**
  * Compute graph rows for an ordered list of commits (topological order,
  * newest first). Each commit must supply its own `id` and `parentIds`.
@@ -84,14 +108,22 @@ interface MutableGraphRow {
  * @returns One `GraphRow` per commit in the same order.
  */
 export function computeGraphRows(
-    commits: ReadonlyArray<{ id: string; parentIds?: readonly string[] }>
+    commits: ReadonlyArray<GraphCommitInput>
 ): GraphRow[] {
     // lanes[i] = id of commit that "owns" lane i (i.e. we are waiting for this
     // commit to appear in the list so we can close the lane).
     const lanes: (string | undefined)[] = [];
-    // laneColors[i] = the color index permanently assigned to lane i
+    // laneColors[i] = the color index currently assigned to lane i
     const laneColors: (number | undefined)[] = [];
 
+    // Default lane colors rotate through foreground1-5, like VS Code's
+    // color registry; indices 0-2 are reserved for ref-based colors.
+    let rotation = -1;
+    const nextDefaultColor = (): number => {
+        rotation = (rotation + 1) % DEFAULT_COLOR_COUNT;
+        return DEFAULT_COLOR_FIRST + rotation;
+    };
+
     const rows: MutableGraphRow[] = [];
 
     for (const commit of commits) {
@@ -106,10 +138,15 @@ export function computeGraphRows(
             // Not yet tracked → open a new lane
             myLane = firstFreeLane(lanes);
             lanes[myLane] = commit.id;
-            laneColors[myLane] = myLane % 8;
+            laneColors[myLane] = commit.colorIndex ?? nextDefaultColor();
         }
 
-        const myColor = laneColors[myLane] ?? myLane % 8;
+        // The segment above the commit keeps the color inherited from the
+        // chain above; the commit's own ref color (if any) takes over from
+        // this row downward.
+        const topColor = laneColors[myLane] ?? DEFAULT_COLOR_FIRST;
+        const myColor = commit.colorIndex ?? topColor;
+        laneColors[myLane] = myColor;
 
         // Collect any duplicate lane occupants: other lanes that were kept
         // alive pointing at this same commit (sibling branch tips whose lane
@@ -120,7 +157,7 @@ export function computeGraphRows(
         if (hasTopLine) {
             for (let li = 0; li < lanes.length; li++) {
                 if (lanes[li] === commit.id && li !== myLane) {
-                    duplicateLanes.push({ lane: li, color: laneColors[li] ?? li % 8 });
+                    duplicateLanes.push({ lane: li, color: laneColors[li] ?? DEFAULT_COLOR_FIRST });
                     lanes[li] = undefined;
                     laneColors[li] = undefined;
                 }
@@ -170,7 +207,7 @@ export function computeGraphRows(
                     // Additional parents get new lanes — branch-out
                     const newLane = firstFreeLane(lanes);
                     lanes[newLane] = pid;
-                    laneColors[newLane] = newLane % 8;
+                    laneColors[newLane] = nextDefaultColor();
                     parentLanes.push(newLane);
                     parentIsExisting.push(false);
                 }
@@ -206,7 +243,7 @@ export function computeGraphRows(
             if (!occupant || occupant === commit.id) {
                 continue;
             }
-            const color = laneColors[li] ?? li % 8;
+            const color = laneColors[li] ?? DEFAULT_COLOR_FIRST;
             edges.push({ fromLane: li, toLane: li, color, type: 'pass-through' });
         }
 
@@ -225,11 +262,11 @@ export function computeGraphRows(
             if (isExisting) {
                 // Merge-in: an existing lane at the top of the row curves into
                 // the commit position at mid-row.
-                const color = laneColors[toLane] ?? toLane % 8;
+                const color = laneColors[toLane] ?? DEFAULT_COLOR_FIRST;
                 edges.push({ fromLane: toLane, toLane: myLane, color, type: 'merge-in' });
             } else {
                 // Branch-out: the commit spawns a new lane below mid-row.
-                const color = laneColors[toLane] ?? toLane % 8;
+                const color = laneColors[toLane] ?? DEFAULT_COLOR_FIRST;
                 edges.push({ fromLane: myLane, toLane, color, type: 'branch-out' });
             }
         }
@@ -245,7 +282,7 @@ export function computeGraphRows(
         // at the parent) so it persists as a pass-through to the parent row.
         const hasContinuation = parentIds.length > 0 && (parentLanes[0] === myLane || lanes[myLane] === parentIds[0]);
 
-        rows.push({ lane: myLane, color: myColor, edges, hasContinuation, hasTopLine });
+        rows.push({ lane: myLane, color: myColor, topColor, edges, hasContinuation, hasTopLine });
     }
 
     return rows;

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

@@ -17,20 +17,21 @@
 import { expect } from 'chai';
 import { Emitter } from '@theia/core/lib/common/event';
 import { ScmHistoryGraphModel, PAGE_SIZE } from './scm-history-graph-model';
-import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryItemChange, ScmHistoryOptions, ScmHistoryProvider } from './scm-provider';
+import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryItemRefsChangeEvent, ScmHistoryItemChange, ScmHistoryOptions, ScmHistoryProvider } from './scm-provider';
 import { ScmRepository } from './scm-repository';
 
 class StubHistoryProvider implements ScmHistoryProvider {
-    readonly currentHistoryItemRef: ScmHistoryItemRef | undefined;
-    readonly currentHistoryItemRemoteRef: ScmHistoryItemRef | undefined;
-    readonly currentHistoryItemBaseRef: ScmHistoryItemRef | undefined;
+    currentHistoryItemRef: ScmHistoryItemRef | undefined;
+    currentHistoryItemRemoteRef: ScmHistoryItemRef | undefined;
+    currentHistoryItemBaseRef: ScmHistoryItemRef | undefined;
 
     readonly onDidChangeCurrentHistoryItemRefs = new Emitter<void>().event;
-    readonly onDidChangeHistoryItemRefs = new Emitter<{
-        readonly added: readonly ScmHistoryItemRef[];
-        readonly removed: readonly ScmHistoryItemRef[];
-        readonly modified: readonly ScmHistoryItemRef[];
-    }>().event;
+    protected readonly onDidChangeHistoryItemRefsEmitter = new Emitter<ScmHistoryItemRefsChangeEvent>();
+    readonly onDidChangeHistoryItemRefs = this.onDidChangeHistoryItemRefsEmitter.event;
+
+    fireHistoryItemRefsChanged(event: ScmHistoryItemRefsChangeEvent): void {
+        this.onDidChangeHistoryItemRefsEmitter.fire(event);
+    }
 
     /** Pages this provider will return on consecutive calls (FIFO). */
     pages: ScmHistoryItem[][] = [];
@@ -75,30 +76,46 @@ function makeItems(start: number, count: number): ScmHistoryItem[] {
 /**
  * Instantiates the model with a stub provider, bypassing inversify and the
  * SCM service so tests can drive pagination directly via loadPage().
+ * When `wireRepository` is set, the provider is instead wired through a stub
+ * selected repository and refresh(), so provider event subscriptions are live.
  */
-function createModel(provider: ScmHistoryProvider): { model: ScmHistoryGraphModel; loadPage(): Promise<void> } {
+function createModel(
+    provider: ScmHistoryProvider,
+    preferences: Record<string, unknown> = {},
+    wireRepository = false
+): { model: ScmHistoryGraphModel; loadPage(): Promise<void>; firePreferenceChanged(preferenceName: string): void } {
     const model = new ScmHistoryGraphModel();
     const internals = model as unknown as {
         scmService: {
             onDidChangeSelectedRepository: Emitter<ScmRepository | undefined>['event'];
             selectedRepository: ScmRepository | undefined;
         };
+        scmPreferences: Record<string, unknown>;
         _provider: ScmHistoryProvider | undefined;
         init(): void;
         loadPage(): Promise<void>;
     };
+    const preferenceEmitter = new Emitter<{ preferenceName: string }>();
     internals.scmService = {
         onDidChangeSelectedRepository: new Emitter<ScmRepository | undefined>().event,
-        selectedRepository: undefined,
+        selectedRepository: wireRepository ? { provider: { historyProvider: provider } } as unknown as ScmRepository : undefined,
     };
+    internals.scmPreferences = Object.assign(preferences, { onPreferenceChanged: preferenceEmitter.event });
     internals.init();
-    internals._provider = provider;
+    if (!wireRepository) {
+        internals._provider = provider;
+    }
     return {
         model,
         loadPage: () => internals.loadPage(),
+        firePreferenceChanged: preferenceName => preferenceEmitter.fire({ preferenceName }),
     };
 }
 
+async function nextTick(): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, 0));
+}
+
 describe('ScmHistoryGraphModel - pagination', () => {
 
     it('hasMore is true when a full page returns', async () => {
@@ -169,3 +186,221 @@ describe('ScmHistoryGraphModel - pagination', () => {
         expect(model.entries).to.have.length(PAGE_SIZE, 'should not grow when all items are duplicates');
     });
 });
+
+describe('ScmHistoryGraphModel - page size preference', () => {
+
+    it('requests the configured page size and paginates by it', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { model, loadPage } = createModel(provider, { 'scm.graph.pageSize': 10 });
+
+        await loadPage();
+
+        expect(provider.receivedOptions[0].limit).to.equal(10);
+        expect(model.entries).to.have.length(10);
+        expect(model.hasMore).to.be.true;
+    });
+
+    it('falls back to the default page size without a preference value', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10)];
+        const { loadPage } = createModel(provider);
+
+        await loadPage();
+
+        expect(provider.receivedOptions[0].limit).to.equal(PAGE_SIZE);
+    });
+
+    it('reloads from the start when scm.graph.pageSize changes', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 10), makeItems(1, 5)];
+        const preferences: Record<string, unknown> = { 'scm.graph.pageSize': 10 };
+        const { loadPage, firePreferenceChanged } = createModel(provider, preferences);
+
+        await loadPage();
+        expect(provider.receivedOptions[0].limit).to.equal(10);
+
+        preferences['scm.graph.pageSize'] = 5;
+        firePreferenceChanged('scm.graph.pageSize');
+        await nextTick();
+
+        expect(provider.receivedOptions[1].limit).to.equal(5);
+        expect(provider.receivedOptions[1].skip).to.equal(0);
+    });
+});
+
+describe('ScmHistoryGraphModel - history item ref filter', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision: 'c1' };
+
+    function createFilterProvider(): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = mainRef;
+        provider.pages = [makeItems(1, 3), makeItems(1, 3), makeItems(1, 3)];
+        return provider;
+    }
+
+    it('is in auto mode by default: current ref revisions are requested and the current ref is in the filter', async () => {
+        const provider = createFilterProvider();
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(provider.receivedOptions[0].historyItemRefs).to.deep.equal(['c1']);
+        expect(model.historyItemRefFilter).to.be.undefined;
+        expect(model.isCurrentRefInFilter()).to.be.true;
+    });
+
+    it('passes the picked ref ids to the provider and reloads', async () => {
+        const provider = createFilterProvider();
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        expect(provider.receivedOptions[0].historyItemRefs).to.deep.equal(['refs/heads/feature']);
+        expect(model.historyItemRefFilter).to.deep.equal(['refs/heads/feature']);
+    });
+
+    it('reports whether the current ref is part of the filter', async () => {
+        const provider = createFilterProvider();
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        expect(model.isCurrentRefInFilter()).to.be.false;
+        model.setHistoryItemRefFilter(['refs/heads/feature', 'refs/heads/main']);
+        await nextTick();
+        expect(model.isCurrentRefInFilter()).to.be.true;
+    });
+
+    it('returns to auto mode when the filter is cleared', async () => {
+        const provider = createFilterProvider();
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        model.setHistoryItemRefFilter(undefined);
+        await nextTick();
+        expect(model.historyItemRefFilter).to.be.undefined;
+        expect(provider.receivedOptions[1].historyItemRefs).to.deep.equal(['c1']);
+    });
+
+    it('does not apply ref role colors to refs excluded by the filter', async () => {
+        const provider = createFilterProvider();
+        provider.pages = [[
+            { id: 'c1', subject: 'head', parentIds: ['c2'], references: [mainRef] },
+            { id: 'c2', subject: 'base', parentIds: [] },
+        ]];
+        const { model } = createModel(provider);
+        model.setHistoryItemRefFilter(['refs/heads/feature']);
+        await nextTick();
+        expect(model.entries[0].graphRow.color).to.not.equal(0);
+    });
+});
+
+describe('ScmHistoryGraphModel - ref filter pruning', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision: 'c1' };
+    const featureRef: ScmHistoryItemRef = { id: 'refs/heads/feature', name: 'feature', revision: 'c5' };
+
+    function createWiredProvider(): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = mainRef;
+        return provider;
+    }
+
+    it('drops a removed ref from the filter and keeps the remaining ones', async () => {
+        const provider = createWiredProvider();
+        const { model } = createModel(provider, {}, true);
+        model.setHistoryItemRefFilter([featureRef.id, mainRef.id]);
+        await nextTick();
+
+        provider.fireHistoryItemRefsChanged({ added: [], removed: [featureRef], modified: [] });
+        await nextTick();
+
+        expect(model.historyItemRefFilter).to.deep.equal([mainRef.id]);
+        const last = provider.receivedOptions[provider.receivedOptions.length - 1];
+        expect(last.historyItemRefs).to.deep.equal([mainRef.id]);
+    });
+
+    it('falls back to auto mode when all filtered refs are removed', async () => {
+        const provider = createWiredProvider();
+        const { model } = createModel(provider, {}, true);
+        model.setHistoryItemRefFilter([featureRef.id]);
+        await nextTick();
+
+        provider.fireHistoryItemRefsChanged({ added: [], removed: [featureRef], modified: [] });
+        await nextTick();
+
+        expect(model.historyItemRefFilter).to.be.undefined;
+        const last = provider.receivedOptions[provider.receivedOptions.length - 1];
+        expect(last.historyItemRefs).to.deep.equal(['c1']);
+    });
+
+    it('keeps the filter when unrelated refs are removed', async () => {
+        const provider = createWiredProvider();
+        const { model } = createModel(provider, {}, true);
+        model.setHistoryItemRefFilter([mainRef.id]);
+        await nextTick();
+
+        provider.fireHistoryItemRefsChanged({ added: [], removed: [featureRef], modified: [] });
+        await nextTick();
+
+        expect(model.historyItemRefFilter).to.deep.equal([mainRef.id]);
+    });
+});
+
+describe('ScmHistoryGraphModel - ref colors and current item', () => {
+
+    const mainRef: ScmHistoryItemRef = { id: 'refs/heads/main', name: 'main', revision: 'c2' };
+    const originMainRef: ScmHistoryItemRef = { id: 'refs/remotes/origin/main', name: 'origin/main', revision: 'c1' };
+
+    /** Remote is one commit ahead: c1 (origin/main) → c2 (main = HEAD) → c3. */
+    function createBehindProvider(): StubHistoryProvider {
+        const provider = new StubHistoryProvider();
+        provider.currentHistoryItemRef = mainRef;
+        provider.currentHistoryItemRemoteRef = originMainRef;
+        provider.pages = [[
+            { id: 'c1', subject: 'remote only', parentIds: ['c2'], references: [originMainRef] },
+            { id: 'c2', subject: 'local head', parentIds: ['c3'], references: [mainRef] },
+            { id: 'c3', subject: 'base', parentIds: [] },
+        ]];
+        return provider;
+    }
+
+    it('colors the remote ref tip with the remote ref color', async () => {
+        const { model, loadPage } = createModel(createBehindProvider());
+        await loadPage();
+        expect(model.entries[0].graphRow.color).to.equal(1);
+    });
+
+    it('colors the current ref chain with the current ref color', async () => {
+        const { model, loadPage } = createModel(createBehindProvider());
+        await loadPage();
+        expect(model.entries[1].graphRow.color).to.equal(0);
+        expect(model.entries[2].graphRow.color).to.equal(0);
+    });
+
+    it('prefers the current ref color when a commit carries both local and remote refs', async () => {
+        const provider = new StubHistoryProvider();
+        const syncedMain: ScmHistoryItemRef = { ...mainRef, revision: 'c1' };
+        const syncedRemote: ScmHistoryItemRef = { ...originMainRef, revision: 'c1' };
+        provider.currentHistoryItemRef = syncedMain;
+        provider.currentHistoryItemRemoteRef = syncedRemote;
+        provider.pages = [[
+            { id: 'c1', subject: 'in sync', parentIds: [], references: [syncedRemote, syncedMain] },
+        ]];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(model.entries[0].graphRow.color).to.equal(0);
+    });
+
+    it('marks only the entry at the current ref revision as current', async () => {
+        const { model, loadPage } = createModel(createBehindProvider());
+        await loadPage();
+        expect(model.entries.map(e => e.isCurrent)).to.deep.equal([false, true, false]);
+    });
+
+    it('marks no entry as current when the provider has no current ref', async () => {
+        const provider = new StubHistoryProvider();
+        provider.pages = [makeItems(1, 3)];
+        const { model, loadPage } = createModel(provider);
+        await loadPage();
+        expect(model.entries.every(e => !e.isCurrent)).to.be.true;
+    });
+});

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

@@ -14,25 +14,44 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { injectable, inject, postConstruct, named } from '@theia/core/shared/inversify';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { Emitter } from '@theia/core/lib/common/event';
 import { CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { ScmService } from './scm-service';
-import { ScmHistoryItem, ScmHistoryProvider, ScmHistoryOptions } from './scm-provider';
+import { ScmHistoryItem, ScmHistoryItemRef, ScmHistoryProvider, ScmHistoryOptions } from './scm-provider';
 import { computeGraphRows, GraphRow } from './scm-history-graph-lanes';
+import { ILogger } from '@theia/core';
+import { getRefColorIndex } from './scm-history-graph-helpers';
+import { ScmPreferences } from '../common/scm-preferences';
 
 export const PAGE_SIZE = 50;
 
+export const ScmHistoryGraphModelProvider = Symbol('ScmHistoryGraphModelProvider');
+/**
+ * Resolves the {@link ScmHistoryGraphModel} singleton on first use. The model
+ * starts loading history and subscribing to provider events as soon as it is
+ * instantiated, so clients that may not need it (e.g. command contributions
+ * instantiated at application start) must inject this provider instead of the
+ * model itself.
+ */
+export type ScmHistoryGraphModelProvider = () => ScmHistoryGraphModel;
+
 export interface HistoryGraphEntry {
     readonly item: ScmHistoryItem;
     readonly graphRow: GraphRow;
+    /** True when this item is the commit the current history item ref points at (HEAD). */
+    readonly isCurrent: boolean;
 }
 
 @injectable()
 export class ScmHistoryGraphModel {
 
     @inject(ScmService) protected readonly scmService: ScmService;
+    @inject(ScmPreferences) protected readonly scmPreferences: ScmPreferences;
+
+    @inject(ILogger) @named('scm:ScmHistoryGraphModel')
+    protected readonly logger: ILogger;
 
     protected readonly toDispose = new DisposableCollection();
     protected readonly toDisposeOnProviderChange = new DisposableCollection();
@@ -42,6 +61,8 @@ export class ScmHistoryGraphModel {
     protected _loading = false;
     protected _hasAttemptedLoad = false;
     protected _provider: ScmHistoryProvider | undefined;
+    /** Explicitly picked ref ids to filter the graph by; `undefined` = auto (current/remote/base). */
+    protected _historyItemRefFilter: string[] | undefined;
 
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
@@ -54,6 +75,11 @@ export class ScmHistoryGraphModel {
             Disposable.create(() => this.toDisposeOnProviderChange.dispose()),
             this.onDidChangeEmitter,
             this.scmService.onDidChangeSelectedRepository(() => this.refresh()),
+            this.scmPreferences.onPreferenceChanged(e => {
+                if (e.preferenceName === 'scm.graph.pageSize') {
+                    this.reload();
+                }
+            }),
         ]);
         this.refresh();
     }
@@ -67,6 +93,32 @@ export class ScmHistoryGraphModel {
         return this._provider;
     }
 
+    /** The explicitly picked ref ids filtering the graph, or `undefined` in auto mode. */
+    get historyItemRefFilter(): readonly string[] | undefined {
+        return this._historyItemRefFilter;
+    }
+
+    /**
+     * Sets the ref ids to filter the graph by (`undefined` returns to auto
+     * mode) and reloads the graph.
+     */
+    setHistoryItemRefFilter(refIds: readonly string[] | undefined): void {
+        this._historyItemRefFilter = refIds && refIds.length > 0 ? [...refIds] : undefined;
+        this.reload();
+    }
+
+    /**
+     * Whether the current history item ref is part of the graph's filter.
+     * Always true in auto mode, which includes the current ref.
+     */
+    isCurrentRefInFilter(): boolean {
+        if (!this._historyItemRefFilter) {
+            return true;
+        }
+        const currentId = this._provider?.currentHistoryItemRef?.id;
+        return currentId !== undefined && this._historyItemRefFilter.includes(currentId);
+    }
+
     get entries(): readonly HistoryGraphEntry[] {
         return this._entries;
     }
@@ -89,13 +141,14 @@ export class ScmHistoryGraphModel {
     }
 
     refresh(): void {
-        this.cancelSource.cancel();
-        this.cancelSource = new CancellationTokenSource();
-
         this.toDisposeOnProviderChange.dispose();
 
         const repo = this.scmService.selectedRepository;
         const hp = repo?.provider.historyProvider;
+        if (hp !== this._provider) {
+            // The repository changed — a filter picked for the old provider does not apply.
+            this._historyItemRefFilter = undefined;
+        }
         this._provider = hp;
 
         if (this._provider) {
@@ -103,7 +156,10 @@ export class ScmHistoryGraphModel {
                 this._provider.onDidChangeCurrentHistoryItemRefs(() => this.refresh())
             );
             this.toDisposeOnProviderChange.push(
-                this._provider.onDidChangeHistoryItemRefs(() => this.refresh())
+                this._provider.onDidChangeHistoryItemRefs(e => {
+                    this.pruneHistoryItemRefFilter(e.removed);
+                    this.refresh();
+                })
             );
         } else if (repo) {
             // historyProvider is not yet available; listen for provider changes
@@ -113,6 +169,31 @@ export class ScmHistoryGraphModel {
             );
         }
 
+        this.reload();
+    }
+
+    /**
+     * Drops refs that no longer exist from the explicit filter, so that
+     * deleting or renaming a filtered ref does not leave the graph stuck
+     * requesting history for it. When the last filtered ref is removed,
+     * the filter falls back to auto mode.
+     */
+    protected pruneHistoryItemRefFilter(removed: readonly ScmHistoryItemRef[]): void {
+        if (!this._historyItemRefFilter || removed.length === 0) {
+            return;
+        }
+        const removedIds = new Set(removed.map(ref => ref.id));
+        const remaining = this._historyItemRefFilter.filter(id => !removedIds.has(id));
+        if (remaining.length !== this._historyItemRefFilter.length) {
+            this._historyItemRefFilter = remaining.length > 0 ? remaining : undefined;
+        }
+    }
+
+    /** Clears the loaded entries and loads the first page again from the current provider. */
+    protected reload(): void {
+        this.cancelSource.cancel();
+        this.cancelSource = new CancellationTokenSource();
+
         this._entries = [];
         this._hasMore = false;
 
@@ -141,10 +222,11 @@ export class ScmHistoryGraphModel {
 
         const token = this.cancelSource.token;
         try {
+            const pageSize = this.pageSize;
             const historyItemRefs = this.getCurrentHistoryItemRefs();
             const options: ScmHistoryOptions = {
                 skip: this._entries.length,
-                limit: PAGE_SIZE,
+                limit: pageSize,
                 historyItemRefs: historyItemRefs.length > 0 ? historyItemRefs : undefined,
             };
             const items = await this._provider.provideHistoryItems(options, token);
@@ -154,7 +236,7 @@ export class ScmHistoryGraphModel {
             }
 
             const fetchedItems: ScmHistoryItem[] = items ?? [];
-            this._hasMore = fetchedItems.length >= PAGE_SIZE;
+            this._hasMore = fetchedItems.length >= pageSize;
 
             // Filter out any items already loaded so the graph does not show duplicates.
             const existingIds = new Set(this._entries.map(e => e.item.id));
@@ -164,15 +246,18 @@ export class ScmHistoryGraphModel {
             const graphRows = computeGraphRows(allItems.map(i => ({
                 id: i.id,
                 parentIds: i.parentIds,
+                colorIndex: this.resolveColorIndex(i),
             })));
 
+            const currentRevision = this._provider.currentHistoryItemRef?.revision;
             this._entries = allItems.map((item, idx) => ({
                 item,
                 graphRow: graphRows[idx],
+                isCurrent: currentRevision !== undefined && item.id === currentRevision,
             }));
         } catch (err) {
             if (!token.isCancellationRequested) {
-                console.error('ScmHistoryGraphModel: failed to load history', err);
+                this.logger.error('Failed to load history', err);
             }
         } finally {
             if (!token.isCancellationRequested) {
@@ -183,12 +268,40 @@ export class ScmHistoryGraphModel {
         }
     }
 
+    /** The configured page size (`scm.graph.pageSize`). */
+    protected get pageSize(): number {
+        return this.scmPreferences['scm.graph.pageSize'] ?? PAGE_SIZE;
+    }
+
     /**
-     * Returns the revisions of the current branch ref, its remote tracking ref,
-     * and the merge-base ref to pass to `provideHistoryItems`. Providers walk
-     * history starting from these revisions.
+     * Resolves the ref-based color index of an item from its references,
+     * preferring current (0) over remote (1) over base (2). Refs excluded by
+     * an explicit filter get no role color, mirroring VS Code's color map.
+     */
+    protected resolveColorIndex(item: ScmHistoryItem): number | undefined {
+        let result: number | undefined;
+        for (const ref of item.references ?? []) {
+            if (this._historyItemRefFilter && !this._historyItemRefFilter.includes(ref.id)) {
+                continue;
+            }
+            const index = getRefColorIndex(ref, this._provider);
+            if (index !== undefined && (result === undefined || index < result)) {
+                result = index;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Returns the refs to pass to `provideHistoryItems`: the explicitly picked
+     * ref ids when a filter is active, otherwise (auto mode) the revisions of
+     * the current branch ref, its remote tracking ref, and the merge-base ref.
+     * Providers walk history starting from these refs.
      */
     protected getCurrentHistoryItemRefs(): string[] {
+        if (this._historyItemRefFilter) {
+            return [...this._historyItemRefFilter];
+        }
         if (!this._provider) {
             return [];
         }