@codingame/monaco-vscode-scm-service-override 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/contrib/scm/browser/scmViewPane.js

@@ -14,11 +14,11 @@ import { IContextMenuService, IContextViewService } from 'vscode/vscode/vs/platf
 import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
 import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
 import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
-import { MenuId, MenuRegistry, registerAction2, MenuItemAction, Action2, IMenuService } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { MenuId, MenuRegistry, registerAction2, MenuItemAction, IMenuService, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { Action, Separator, ActionRunner } from 'vscode/vscode/vs/base/common/actions';
 import { ActionBar } from 'vscode/vscode/vs/base/browser/ui/actionbar/actionbar';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
-import { connectPrimaryMenuToInlineActionBar, getActionViewItemProvider, isSCMRepository, isSCMResourceGroup, isSCMResourceNode, isSCMHistoryItemChangeNode, isSCMInput, isSCMActionButton, isSCMResource, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMHistoryItemChangeTreeElement, toDiffEditorArguments, collectContextMenuActions, isSCMViewService, isSCMViewSeparator } from './util.js';
+import { connectPrimaryMenuToInlineActionBar, connectPrimaryMenu, getActionViewItemProvider, isSCMRepository, isSCMResourceGroup, isSCMResourceNode, isSCMHistoryItemChangeNode, isSCMInput, isSCMActionButton, isSCMResource, isSCMHistoryItemGroupTreeElement, isSCMHistoryItemTreeElement, isSCMHistoryItemChangeTreeElement, toDiffEditorArguments, collectContextMenuActions, isSCMViewService, isSCMViewSeparator } from './util.js';
 import { WorkbenchCompressibleAsyncDataTree } from 'vscode/vscode/vs/platform/list/browser/listService';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
 import { disposableTimeout, ThrottledDelayer, Sequencer, Throttler } from 'vscode/vscode/vs/base/common/async';
@@ -46,7 +46,7 @@ import { format, compare } from 'vscode/vscode/vs/base/common/strings';
 import { SuggestController } from 'vscode/vscode/vs/editor/contrib/suggest/browser/suggestController';
 import { SnippetController2 } from 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
 import { ServiceCollection } from 'vscode/vscode/vs/platform/instantiation/common/serviceCollection';
-import { ModesHoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
+import { HoverController } from 'vscode/vscode/vs/editor/contrib/hover/browser/hover';
 import { ColorDetector } from 'vscode/vscode/vs/editor/contrib/colorPicker/browser/colorDetector';
 import { LinkDetector } from 'vscode/vscode/vs/editor/contrib/links/browser/links';
 import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
@@ -56,11 +56,11 @@ import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
 import { DEFAULT_FONT_FAMILY } from 'vscode/vscode/vs/workbench/browser/style';
 import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
 import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
-import { RepositoryRenderer } from './scmRepositoryRenderer.js';
+import { RepositoryRenderer, RepositoryActionRunner } from './scmRepositoryRenderer.js';
 import { ColorScheme } from 'vscode/vscode/vs/platform/theme/common/theme';
 import { API_OPEN_EDITOR_COMMAND_ID, API_OPEN_DIFF_EDITOR_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
 import { createActionViewItem, createAndFillInContextMenuActions, createAndFillInActionBarActions } from 'vscode/vscode/vs/platform/actions/browser/menuEntryActionViewItem';
-import { MarkdownRenderer, openLinkFromMarkdown } from 'vscode/vscode/vs/editor/contrib/markdownRenderer/browser/markdownRenderer';
+import { MarkdownRenderer, openLinkFromMarkdown } from 'vscode/vscode/vs/editor/browser/widget/markdownRenderer/browser/markdownRenderer';
 import { ButtonWithDropdown, Button } from 'vscode/vscode/vs/base/browser/ui/button/button';
 import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
 import { RepositoryContextKeys } from './scmViewService.js';
@@ -75,6 +75,7 @@ import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { fillEditorsDragData } from 'vscode/vscode/vs/workbench/browser/dnd';
 import { CodeDataTransfers } from 'vscode/vscode/vs/platform/dnd/browser/dnd';
 import { FormatOnType } from 'vscode/vscode/vs/editor/contrib/format/browser/formatActions';
+import { EditorOptions } from 'vscode/vscode/vs/editor/common/config/editorOptions';
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
 import { EditOperation } from 'vscode/vscode/vs/editor/common/core/editOperation';
 import { stripIcons } from 'vscode/vscode/vs/base/common/iconLabels';
@@ -85,7 +86,7 @@ import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellati
 import { DropdownWithPrimaryActionViewItem } from 'vscode/vscode/vs/platform/actions/browser/dropdownWithPrimaryActionViewItem';
 import { clamp } from 'vscode/vscode/vs/base/common/numbers';
 
-var ActionButtonRenderer_1, InputRenderer_1, ResourceGroupRenderer_1, ResourceRenderer_1, HistoryItemRenderer_1, HistoryItemChangeRenderer_1, SCMInputWidget_1;
+var ActionButtonRenderer_1, InputRenderer_1, ResourceGroupRenderer_1, ResourceRenderer_1, HistoryItemGroupRenderer_1, HistoryItemRenderer_1, HistoryItemChangeRenderer_1, SCMInputWidget_1;
 registerColor('scm.historyItemAdditionsForeground', {
     dark: 'gitDecoration.addedResourceForeground',
     light: 'gitDecoration.addedResourceForeground',
@@ -221,10 +222,10 @@ class SCMTreeDragAndDrop {
         }
         return String(elements.length);
     }
-    onDragOver(data, targetElement, targetIndex, originalEvent) {
+    onDragOver(data, targetElement, targetIndex, targetSector, originalEvent) {
         return true;
     }
-    drop(data, targetElement, targetIndex, originalEvent) { }
+    drop(data, targetElement, targetIndex, targetSector, originalEvent) { }
     static getResourcesFromDragAndDropData(data) {
         const uris = [];
         for (const element of [...(data.context ?? []), ...data.elements]) {
@@ -302,8 +303,7 @@ let InputRenderer = class InputRenderer {
             templateData.elementDisposables.add(templateData.inputWidget.onDidChangeContentHeight(onDidChangeContentHeight));
             onDidChangeContentHeight();
         };
-        const timeout = disposableTimeout(startListeningContentHeightChange, 0);
-        templateData.elementDisposables.add(timeout);
+        disposableTimeout(startListeningContentHeightChange, 0, templateData.elementDisposables);
         const layoutEditor = () => templateData.inputWidget.layout();
         templateData.elementDisposables.add(this.outerLayout.onDidChange(layoutEditor));
         layoutEditor();
@@ -595,17 +595,46 @@ ResourceRenderer = ResourceRenderer_1 = ( __decorate([
     ( __param(5, ISCMViewService)),
     ( __param(6, IThemeService))
 ], ResourceRenderer));
-class HistoryItemGroupRenderer {
+class HistoryItemGroupActionRunner extends ActionRunner {
+    runAction(action, context) {
+        if (!(action instanceof MenuItemAction)) {
+            return super.runAction(action, context);
+        }
+        return action.run(context.repository.provider, context.id);
+    }
+}
+let HistoryItemGroupRenderer = class HistoryItemGroupRenderer {
+    static { HistoryItemGroupRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'history-item-group'; }
-    get templateId() { return HistoryItemGroupRenderer.TEMPLATE_ID; }
+    get templateId() { return HistoryItemGroupRenderer_1.TEMPLATE_ID; }
+    constructor(actionRunner, contextKeyService, contextMenuService, keybindingService, menuService, scmViewService, telemetryService) {
+        this.actionRunner = actionRunner;
+        this.contextKeyService = contextKeyService;
+        this.contextMenuService = contextMenuService;
+        this.keybindingService = keybindingService;
+        this.menuService = menuService;
+        this.scmViewService = scmViewService;
+        this.telemetryService = telemetryService;
+    }
     renderTemplate(container) {
         container.parentElement.parentElement.querySelector('.monaco-tl-twistie').classList.add('force-twistie');
         const element = append(container, $('.history-item-group'));
         const label = ( new IconLabel(element, { supportIcons: true }));
         const iconContainer = prepend(label.element, $('.icon-container'));
+        const templateDisposables = ( new DisposableStore());
+        const toolBar = ( new WorkbenchToolBar(
+            append(element, $('.actions')),
+            { actionRunner: this.actionRunner, menuOptions: { shouldForwardArgs: true } },
+            this.menuService,
+            this.contextKeyService,
+            this.contextMenuService,
+            this.keybindingService,
+            this.telemetryService
+        ));
+        templateDisposables.add(toolBar);
         const countContainer = append(element, $('.count'));
         const count = ( new CountBadge(countContainer, {}, defaultCountBadgeStyles));
-        return { iconContainer, label, count, disposables: ( new DisposableStore()) };
+        return { iconContainer, label, toolBar, count, elementDisposables: ( new DisposableStore()), templateDisposables };
     }
     renderElement(node, index, templateData, height) {
         const historyItemGroup = node.element;
@@ -615,19 +644,65 @@ class HistoryItemGroupRenderer {
         }
         templateData.label.setLabel(historyItemGroup.label, historyItemGroup.description, { title: historyItemGroup.ariaLabel });
         templateData.count.setCount(historyItemGroup.count ?? 0);
+        const repositoryMenus = this.scmViewService.menus.getRepositoryMenus(historyItemGroup.repository.provider);
+        const historyProviderMenu = repositoryMenus.historyProviderMenu;
+        if (historyProviderMenu) {
+            const menuId = historyItemGroup.direction === 'incoming' ? MenuId.SCMIncomingChanges : MenuId.SCMOutgoingChanges;
+            const menu = historyItemGroup.direction === 'incoming' ? historyProviderMenu.incomingHistoryItemGroupMenu : historyProviderMenu.outgoingHistoryItemGroupMenu;
+            templateData.elementDisposables.add(connectPrimaryMenu(menu, (primary, secondary) => {
+                templateData.toolBar.setActions(primary, secondary, [menuId]);
+            }));
+            templateData.toolBar.context = historyItemGroup;
+        }
+        else {
+            templateData.toolBar.setActions([], []);
+            templateData.toolBar.context = undefined;
+        }
     }
     renderCompressedElements(node, index, templateData, height) {
         throw new Error('Should never happen since node is incompressible');
     }
+    disposeElement(node, index, templateData, height) {
+        templateData.elementDisposables.clear();
+    }
     disposeTemplate(templateData) {
-        templateData.disposables.dispose();
+        templateData.elementDisposables.dispose();
+        templateData.templateDisposables.dispose();
+    }
+};
+HistoryItemGroupRenderer = HistoryItemGroupRenderer_1 = ( __decorate([
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, IMenuService)),
+    ( __param(5, ISCMViewService)),
+    ( __param(6, ITelemetryService))
+], HistoryItemGroupRenderer));
+class HistoryItemActionRunner extends ActionRunner {
+    async runAction(action, context) {
+        if (!(action instanceof MenuItemAction)) {
+            return super.runAction(action, context);
+        }
+        const args = [];
+        args.push(context.historyItemGroup.repository.provider);
+        args.push({
+            id: context.id,
+            parentIds: context.parentIds,
+            label: context.label,
+            description: context.description,
+            icon: context.icon,
+            timestamp: context.timestamp,
+            statistics: context.statistics,
+        });
+        await action.run(...args);
     }
 }
 let HistoryItemRenderer = class HistoryItemRenderer {
     static { HistoryItemRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'history-item'; }
     get templateId() { return HistoryItemRenderer_1.TEMPLATE_ID; }
-    constructor(actionViewItemProvider, scmViewService) {
+    constructor(actionRunner, actionViewItemProvider, scmViewService) {
+        this.actionRunner = actionRunner;
         this.actionViewItemProvider = actionViewItemProvider;
         this.scmViewService = scmViewService;
     }
@@ -638,7 +713,10 @@ let HistoryItemRenderer = class HistoryItemRenderer {
         const iconContainer = prepend(iconLabel.element, $('.icon-container'));
         const disposables = ( new DisposableStore());
         const actionsContainer = append(element, $('.actions'));
-        const actionBar = ( new ActionBar(actionsContainer, { actionViewItemProvider: this.actionViewItemProvider }));
+        const actionBar = ( new ActionBar(
+            actionsContainer,
+            { actionRunner: this.actionRunner, actionViewItemProvider: this.actionViewItemProvider }
+        ));
         disposables.add(actionBar);
         const statsContainer = append(element, $('.stats-container'));
         const filesLabel = append(statsContainer, $('.files-label'));
@@ -657,7 +735,8 @@ let HistoryItemRenderer = class HistoryItemRenderer {
         templateData.actionBar.context = historyItem;
         const menus = this.scmViewService.menus.getRepositoryMenus(historyItem.historyItemGroup.repository.provider);
         if (menus.historyProviderMenu) {
-            templateData.elementDisposables.add(connectPrimaryMenuToInlineActionBar(menus.historyProviderMenu.getHistoryItemMenu(historyItem), templateData.actionBar));
+            const historyItemMenu = menus.historyProviderMenu.getHistoryItemMenu(historyItem);
+            templateData.elementDisposables.add(connectPrimaryMenuToInlineActionBar(historyItemMenu, templateData.actionBar));
         }
         this.renderStatistics(node, index, templateData, height);
     }
@@ -730,7 +809,7 @@ let HistoryItemRenderer = class HistoryItemRenderer {
     }
 };
 HistoryItemRenderer = HistoryItemRenderer_1 = ( __decorate([
-    ( __param(1, ISCMViewService))
+    ( __param(2, ISCMViewService))
 ], HistoryItemRenderer));
 let HistoryItemChangeRenderer = class HistoryItemChangeRenderer {
     static { HistoryItemChangeRenderer_1 = this; }
@@ -851,15 +930,9 @@ class SCMTreeCompressionDelegate {
 }
 class SCMTreeFilter {
     filter(element) {
-        if (ResourceTree.isResourceNode(element)) {
-            return true;
-        }
-        else if (isSCMResourceGroup(element)) {
+        if (isSCMResourceGroup(element)) {
             return element.resources.length > 0 || !element.hideWhenEmpty;
         }
-        else if (isSCMViewSeparator(element)) {
-            return true;
-        }
         else {
             return true;
         }
@@ -889,23 +962,14 @@ class SCMTreeSorter {
         else if (isSCMActionButton(other)) {
             return 1;
         }
-        if (isSCMViewSeparator(one)) {
-            if (!isSCMHistoryItemGroupTreeElement(other) && !isSCMResourceGroup(other)) {
-                throw new Error('Invalid comparison');
-            }
-            return 0;
-        }
         if (isSCMResourceGroup(one)) {
-            if (!isSCMResourceGroup(other)) {
-                throw new Error('Invalid comparison');
-            }
-            return 0;
+            return isSCMResourceGroup(other) ? 0 : -1;
+        }
+        if (isSCMViewSeparator(one)) {
+            return isSCMResourceGroup(other) ? 1 : -1;
         }
         if (isSCMHistoryItemGroupTreeElement(one)) {
-            if (!isSCMHistoryItemGroupTreeElement(other) && !isSCMResourceGroup(other) && !isSCMViewSeparator(other)) {
-                throw new Error('Invalid comparison');
-            }
-            return 0;
+            return isSCMHistoryItemGroupTreeElement(other) ? 0 : 1;
         }
         if (isSCMHistoryItemTreeElement(one)) {
             if (!isSCMHistoryItemTreeElement(other)) {
@@ -1029,7 +1093,7 @@ function getSCMResourceId(element) {
     else if (isSCMHistoryItemTreeElement(element)) {
         const historyItemGroup = element.historyItemGroup;
         const provider = historyItemGroup.repository.provider;
-        return `historyItem:${provider.id}/${historyItemGroup.id}/${element.id}`;
+        return `historyItem:${provider.id}/${historyItemGroup.id}/${element.id}/${element.parentIds.join(',')}`;
     }
     else if (isSCMHistoryItemChangeTreeElement(element)) {
         const historyItem = element.historyItem;
@@ -1240,9 +1304,9 @@ RepositoryVisibilityActionController = ( __decorate([
     ( __param(2, ISCMService))
 ], RepositoryVisibilityActionController));
 class SetListViewModeAction extends ViewAction {
-    constructor(menu = {}) {
+    constructor(id = 'workbench.scm.action.setListViewMode', menu = {}) {
         super({
-            id: 'workbench.scm.action.setListViewMode',
+            id,
             title: ( localizeWithPath(
                 'vs/workbench/contrib/scm/browser/scmViewPane',
                 'setListViewMode',
@@ -1261,7 +1325,7 @@ class SetListViewModeAction extends ViewAction {
 }
 class SetListViewModeNavigationAction extends SetListViewModeAction {
     constructor() {
-        super({
+        super('workbench.scm.action.setListViewModeNavigation', {
             id: MenuId.SCMTitle,
             when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.RepositoryCount.notEqualsTo(0)), ( ContextKeys.SCMViewMode.isEqualTo("tree" )))),
             group: 'navigation',
@@ -1270,9 +1334,9 @@ class SetListViewModeNavigationAction extends SetListViewModeAction {
     }
 }
 class SetTreeViewModeAction extends ViewAction {
-    constructor(menu = {}) {
+    constructor(id = 'workbench.scm.action.setTreeViewMode', menu = {}) {
         super({
-            id: 'workbench.scm.action.setTreeViewMode',
+            id,
             title: ( localizeWithPath(
                 'vs/workbench/contrib/scm/browser/scmViewPane',
                 'setTreeViewMode',
@@ -1291,7 +1355,7 @@ class SetTreeViewModeAction extends ViewAction {
 }
 class SetTreeViewModeNavigationAction extends SetTreeViewModeAction {
     constructor() {
-        super({
+        super('workbench.scm.action.setTreeViewModeNavigation', {
             id: MenuId.SCMTitle,
             when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', VIEW_PANE_ID)), ( ContextKeys.RepositoryCount.notEqualsTo(0)), ( ContextKeys.SCMViewMode.isEqualTo("list" )))),
             group: 'navigation',
@@ -1454,74 +1518,22 @@ class ExpandAllRepositoriesAction extends ViewAction {
 }
 registerAction2(CollapseAllRepositoriesAction);
 registerAction2(ExpandAllRepositoriesAction);
-class HistoryItemViewChangesAction extends Action2 {
-    constructor() {
-        super({
-            id: `workbench.scm.action.historyItemViewChanges`,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/scm/browser/scmViewPane',
-                'historyItemViewChanges',
-                "View Changes"
-            )),
-            icon: Codicon.diffMultiple,
-            f1: false,
-            menu: {
-                id: MenuId.SCMHistoryItem,
-                group: 'inline',
-                when: ( ContextKeyExpr.has('config.multiDiffEditor.experimental.enabled')),
-            }
-        });
-    }
-    async run(accessor, historyItem) {
-        const commandService = accessor.get(ICommandService);
-        const historyProvider = historyItem.historyItemGroup.repository.provider.historyProvider;
-        if (!historyProvider) {
-            return;
-        }
-        const historyItemChanges = await historyProvider.provideHistoryItemChanges(historyItem.id);
-        if (!historyItemChanges || historyItemChanges.length === 0) {
-            return;
-        }
-        let [originalRef, modifiedRef] = historyItem.id.includes('..')
-            ? ( historyItem.id.split('..').map(id => id.substring(0, 8))) : [undefined, historyItem.id.substring(0, 8)];
-        if (!originalRef) {
-            originalRef = historyItem.parentIds.length > 0 ? historyItem.parentIds[0].substring(0, 8) : `${modifiedRef}^`;
-        }
-        const title = ( localizeWithPath(
-            'vs/workbench/contrib/scm/browser/scmViewPane',
-            'historyItemChangesTitle',
-            "Changes ({0} ↔ {1})",
-            originalRef,
-            modifiedRef
-        ));
-        const args = ( historyItemChanges.map(change => [change.uri, change.originalUri, change.modifiedUri]));
-        return commandService.executeCommand('_workbench.changes', title, args);
-    }
-}
-registerAction2(HistoryItemViewChangesAction);
-const SCMInputContextKeys = {
-    ActionCount: ( new RawContextKey('scmInputActionCount', 0)),
-    ActionIsEnabled: ( new RawContextKey('scmInputActionIsEnabled', false)),
-    ActionIsRunning: ( new RawContextKey('scmInputActionIsRunning', false)),
-};
 let SCMInputWidgetActionRunner = class SCMInputWidgetActionRunner extends ActionRunner {
-    constructor(input, contextKeyService, storageService) {
+    get runningActions() { return this._runningActions; }
+    constructor(input, storageService) {
         super();
         this.input = input;
         this.storageService = storageService;
         this._runningActions = ( new Set());
-        this._ctxIsActionRunning = SCMInputContextKeys.ActionIsRunning.bindTo(contextKeyService);
     }
     async runAction(action) {
         try {
-            if (this._ctxIsActionRunning.get() === true) {
+            if (this.runningActions.size !== 0) {
                 this._cts?.cancel();
                 if (action.id === "scm.input.cancelAction" ) {
                     return;
                 }
             }
-            this._runningActions.add(action);
-            this._ctxIsActionRunning.set(true);
             const context = [];
             for (const group of this.input.repository.provider.groups) {
                 context.push({
@@ -1529,34 +1541,39 @@ let SCMInputWidgetActionRunner = class SCMInputWidgetActionRunner extends Action
                     resources: [...( group.resources.map(r => r.sourceUri))]
                 });
             }
+            this._runningActions.add(action);
             this._cts = ( new CancellationTokenSource());
             await action.run(...[this.input.repository.provider.rootUri, context, this._cts.token]);
         }
         finally {
             this._runningActions.delete(action);
             if (this._runningActions.size === 0) {
-                this.storageService.store('scm.input.lastActionId', action.id, 0 , 0 );
-                this._ctxIsActionRunning.set(false);
+                this.storageService.store("scm.input.lastActionId" , action.id, 0 , 0 );
             }
         }
     }
 };
 SCMInputWidgetActionRunner = ( __decorate([
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IStorageService))
+    ( __param(1, IStorageService))
 ], SCMInputWidgetActionRunner));
 let SCMInputWidgetToolbar = class SCMInputWidgetToolbar extends WorkbenchToolBar {
     get dropdownActions() { return this._dropdownActions; }
-    constructor(container, input, menuId, options, menuService, contextKeyService, contextMenuService, commandService, keybindingService, storageService, telemetryService) {
-        super(container, { resetMenu: menuId, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
+    get dropdownAction() { return this._dropdownAction; }
+    constructor(container, options, menuService, contextKeyService, contextMenuService, commandService, keybindingService, storageService, telemetryService) {
+        super(container, { resetMenu: MenuId.SCMInputBox, ...options }, menuService, contextKeyService, contextMenuService, keybindingService, telemetryService);
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.storageService = storageService;
         this._dropdownActions = [];
-        const contextKeyServiceWithOverlay = contextKeyService.createOverlay([
-            ['scmProvider', input.repository.provider.contextValue],
-            ['scmProviderRootUri', input.repository.provider.rootUri?.toString()],
-            ['scmProviderHasRootUri', !!input.repository.provider.rootUri]
-        ]);
-        const menu = this._store.add(menuService.createMenu(menuId, contextKeyServiceWithOverlay, { emitEventsForSubmenuChanges: true }));
-        const cancelAction = ( new MenuItemAction({
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.repositoryDisposables = ( new DisposableStore());
+        this._dropdownAction = ( new Action('scmInputMoreActions', ( localizeWithPath(
+            'vs/workbench/contrib/scm/browser/scmViewPane',
+            'scmInputMoreActions',
+            "More Actions..."
+        )), 'codicon-chevron-down'));
+        this._cancelAction = ( new MenuItemAction({
             id: "scm.input.cancelAction" ,
             title: ( localizeWithPath(
                 'vs/workbench/contrib/scm/browser/scmViewPane',
@@ -1565,48 +1582,145 @@ let SCMInputWidgetToolbar = class SCMInputWidgetToolbar extends WorkbenchToolBar
             )),
             icon: Codicon.debugStop,
         }, undefined, undefined, undefined, contextKeyService, commandService));
-        this._ctxActionCount = SCMInputContextKeys.ActionCount.bindTo(contextKeyService);
+    }
+    setInput(input) {
+        this.repositoryDisposables.clear();
+        const contextKeyService = this.contextKeyService.createOverlay([
+            ['scmProvider', input.repository.provider.contextValue],
+            ['scmProviderRootUri', input.repository.provider.rootUri?.toString()],
+            ['scmProviderHasRootUri', !!input.repository.provider.rootUri]
+        ]);
+        const menu = this.repositoryDisposables.add(this.menuService.createMenu(MenuId.SCMInputBox, contextKeyService, { emitEventsForSubmenuChanges: true }));
+        const isEnabled = () => {
+            return ( input.repository.provider.groups.some(g => g.resources.length > 0));
+        };
         const updateToolbar = () => {
             const actions = [];
-            createAndFillInActionBarActions(menu, options?.menuOptions, actions);
-            let primaryAction = undefined;
-            if (contextKeyService.getContextKeyValue(SCMInputContextKeys.ActionIsRunning.key) === true) {
-                primaryAction = cancelAction;
+            createAndFillInActionBarActions(menu, { shouldForwardArgs: true }, actions);
+            for (const action of actions) {
+                action.enabled = isEnabled();
             }
-            else if (actions.length === 1) {
+            this._dropdownAction.enabled = isEnabled();
+            let primaryAction = undefined;
+            if (actions.length === 1) {
                 primaryAction = actions[0];
             }
             else if (actions.length > 1) {
-                const lastActionId = storageService.get('scm.input.lastActionId', 0 , '');
+                const lastActionId = this.storageService.get("scm.input.lastActionId" , 0 , '');
                 primaryAction = actions.find(a => a.id === lastActionId) ?? actions[0];
             }
-            if (primaryAction &&
-                primaryAction.id !== "scm.input.cancelAction"  &&
-                contextKeyService.getContextKeyValue(SCMInputContextKeys.ActionIsEnabled.key) === false) {
-                primaryAction.enabled = false;
-            }
-            this._ctxActionCount.set(actions.length);
             this._dropdownActions = actions.length === 1 ? [] : actions;
-            container.classList.toggle('has-no-actions', actions.length === 0);
             super.setActions(primaryAction ? [primaryAction] : [], []);
+            this._onDidChange.fire();
         };
-        this._store.add(menu.onDidChange(() => updateToolbar()));
-        const ctxKeys = ( new Set(
-            [SCMInputContextKeys.ActionIsEnabled.key, SCMInputContextKeys.ActionIsRunning.key]
-        ));
-        this._store.add(Event.filter(contextKeyService.onDidChangeContext, e => e.affectsSome(ctxKeys))(() => updateToolbar()));
-        setTimeout(() => updateToolbar(), 0);
+        this.repositoryDisposables.add(menu.onDidChange(() => updateToolbar()));
+        this.repositoryDisposables.add(input.repository.provider.onDidChangeResources(() => updateToolbar()));
+        this.repositoryDisposables.add(this.storageService.onDidChangeValue(0 , "scm.input.lastActionId" , this.repositoryDisposables)(() => updateToolbar()));
+        this.actionRunner = ( new SCMInputWidgetActionRunner(input, this.storageService));
+        this.repositoryDisposables.add(this.actionRunner.onWillRun(e => {
+            if (this.actionRunner.runningActions.size === 0) {
+                super.setActions([this._cancelAction], []);
+                this._onDidChange.fire();
+            }
+        }));
+        this.repositoryDisposables.add(this.actionRunner.onDidRun(e => {
+            if (this.actionRunner.runningActions.size === 0) {
+                updateToolbar();
+            }
+        }));
+        updateToolbar();
     }
 };
 SCMInputWidgetToolbar = ( __decorate([
-    ( __param(4, IMenuService)),
-    ( __param(5, IContextKeyService)),
-    ( __param(6, IContextMenuService)),
-    ( __param(7, ICommandService)),
-    ( __param(8, IKeybindingService)),
-    ( __param(9, IStorageService)),
-    ( __param(10, ITelemetryService))
+    ( __param(2, IMenuService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IContextMenuService)),
+    ( __param(5, ICommandService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, ITelemetryService))
 ], SCMInputWidgetToolbar));
+class SCMInputWidgetEditorOptions {
+    constructor(overflowWidgetsDomNode, configurationService) {
+        this.overflowWidgetsDomNode = overflowWidgetsDomNode;
+        this.configurationService = configurationService;
+        this._onDidChange = ( new Emitter());
+        this.onDidChange = this._onDidChange.event;
+        this.defaultInputFontFamily = DEFAULT_FONT_FAMILY;
+        this._disposables = ( new DisposableStore());
+        const onDidChangeConfiguration = Event.filter(this.configurationService.onDidChangeConfiguration, e => {
+            return e.affectsConfiguration('editor.accessibilitySupport') ||
+                e.affectsConfiguration('editor.cursorBlinking') ||
+                e.affectsConfiguration('editor.fontFamily') ||
+                e.affectsConfiguration('editor.rulers') ||
+                e.affectsConfiguration('editor.wordWrap') ||
+                e.affectsConfiguration('scm.inputFontFamily') ||
+                e.affectsConfiguration('scm.inputFontSize');
+        }, this._disposables);
+        this._disposables.add(onDidChangeConfiguration(() => this._onDidChange.fire()));
+    }
+    getEditorConstructionOptions() {
+        const fontFamily = this._getEditorFontFamily();
+        const fontSize = this._getEditorFontSize();
+        const lineHeight = this._getEditorLineHeight(fontSize);
+        return {
+            ...getSimpleEditorOptions(this.configurationService),
+            ...this._getEditorLanguageConfiguration(),
+            cursorWidth: 1,
+            dragAndDrop: true,
+            dropIntoEditor: { enabled: true },
+            fontFamily: fontFamily,
+            fontSize: fontSize,
+            formatOnType: true,
+            lineDecorationsWidth: 6,
+            lineHeight: lineHeight,
+            overflowWidgetsDomNode: this.overflowWidgetsDomNode,
+            padding: { top: 2, bottom: 2 },
+            quickSuggestions: false,
+            renderWhitespace: 'none',
+            scrollbar: {
+                alwaysConsumeMouseWheel: false,
+                vertical: 'hidden'
+            },
+            wrappingIndent: 'none',
+            wrappingStrategy: 'advanced',
+        };
+    }
+    getEditorOptions() {
+        const fontFamily = this._getEditorFontFamily();
+        const fontSize = this._getEditorFontSize();
+        const lineHeight = this._getEditorLineHeight(fontSize);
+        const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
+        const cursorBlinking = this.configurationService.getValue('editor.cursorBlinking');
+        return { ...this._getEditorLanguageConfiguration(), accessibilitySupport, cursorBlinking, fontFamily, fontSize, lineHeight };
+    }
+    _getEditorFontFamily() {
+        const inputFontFamily = this.configurationService.getValue('scm.inputFontFamily').trim();
+        if (inputFontFamily.toLowerCase() === 'editor') {
+            return this.configurationService.getValue('editor.fontFamily').trim();
+        }
+        if (inputFontFamily.length !== 0 && inputFontFamily.toLowerCase() !== 'default') {
+            return inputFontFamily;
+        }
+        return this.defaultInputFontFamily;
+    }
+    _getEditorFontSize() {
+        return this.configurationService.getValue('scm.inputFontSize');
+    }
+    _getEditorLanguageConfiguration() {
+        const rulersConfig = this.configurationService.inspect('editor.rulers', { overrideIdentifier: 'scminput' });
+        const rulers = rulersConfig.overrideIdentifiers?.includes('scminput') ? EditorOptions.rulers.validate(rulersConfig.value) : [];
+        const wordWrapConfig = this.configurationService.inspect('editor.wordWrap', { overrideIdentifier: 'scminput' });
+        const wordWrap = wordWrapConfig.overrideIdentifiers?.includes('scminput') ? EditorOptions.wordWrap.validate(wordWrapConfig.value) : 'on';
+        return { rulers, wordWrap };
+    }
+    _getEditorLineHeight(fontSize) {
+        return Math.round(fontSize * 1.5);
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+}
 let SCMInputWidget = class SCMInputWidget {
     static { SCMInputWidget_1 = this; }
     static { this.ValidationTimeouts = {
@@ -1712,28 +1826,7 @@ let SCMInputWidget = class SCMInputWidget {
         };
         this.repositoryDisposables.add(input.onDidChangeEnablement(enabled => updateEnablement(enabled)));
         updateEnablement(input.enabled);
-        const onDidChangeActionButton = () => {
-            this.actionBar.clear();
-            const actionCount = this.toolbarContextKeyService.getContextKeyValue(SCMInputContextKeys.ActionCount.key) ?? 0;
-            if (input.actionButton && actionCount === 0) {
-                const action = ( new Action(
-                    input.actionButton.command.id,
-                    input.actionButton.command.title,
-                    ThemeIcon.isThemeIcon(input.actionButton.icon) ? ThemeIcon.asClassName(input.actionButton.icon) : undefined,
-                    input.actionButton.enabled,
-                    () => this.commandService.executeCommand(input.actionButton.command.id, ...(input.actionButton.command.arguments || []))
-                ));
-                this.actionBar.push(action, { icon: true, label: false });
-            }
-            this.layout();
-        };
-        const ctxKeys = ( new Set([SCMInputContextKeys.ActionCount.key]));
-        this.repositoryDisposables.add(Event.filter(this.toolbarContextKeyService.onDidChangeContext, e => e.affectsSome(ctxKeys))(onDidChangeActionButton, this));
-        this.repositoryDisposables.add(input.onDidChangeActionButton(onDidChangeActionButton, this));
-        this.repositoryDisposables.add(this.scmService.onDidChangeInputValueProviders(onDidChangeActionButton, this));
-        this.repositoryDisposables.add(Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.showInputActionButton'))(onDidChangeActionButton, this));
-        onDidChangeActionButton();
-        this.createToolbar(input);
+        this.toolbar.setInput(input);
     }
     get selections() {
         return this.inputEditor.getSelections();
@@ -1743,34 +1836,6 @@ let SCMInputWidget = class SCMInputWidget {
             this.inputEditor.setSelections(selections);
         }
     }
-    createToolbar(input) {
-        const services = ( new ServiceCollection([IContextKeyService, this.toolbarContextKeyService]));
-        const instantiationService2 = this.instantiationService.createChild(services);
-        const ctxIsActionEnabled = SCMInputContextKeys.ActionIsEnabled.bindTo(this.toolbarContextKeyService);
-        this.repositoryDisposables.add(input.repository.provider.onDidChangeResources(() => ctxIsActionEnabled.set(( input.repository.provider.groups.some(r => r.resources.length > 0)))));
-        ctxIsActionEnabled.set(( input.repository.provider.groups.some(r => r.resources.length > 0)));
-        const actionRunner = instantiationService2.createInstance(SCMInputWidgetActionRunner, input);
-        this.repositoryDisposables.add(actionRunner);
-        const toolbar = instantiationService2.createInstance(SCMInputWidgetToolbar, this.toolbarContainer, input, MenuId.SCMInputBox, {
-            actionRunner,
-            actionViewItemProvider: action => {
-                if (action instanceof MenuItemAction && toolbar.dropdownActions.length > 1) {
-                    const scmInputActionIsEnabled = this.toolbarContextKeyService.getContextKeyValue('scmInputActionIsEnabled') === true;
-                    const dropdownAction = ( new Action('scmInputMoreActions', ( localizeWithPath(
-                        'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'scmInputMoreActions',
-                        'More Actions...'
-                    )), 'codicon-chevron-down', scmInputActionIsEnabled));
-                    return instantiationService2.createInstance(DropdownWithPrimaryActionViewItem, action, dropdownAction, toolbar.dropdownActions, '', this.contextMenuService, { actionRunner });
-                }
-                return createActionViewItem(instantiationService2, action);
-            },
-            menuOptions: {
-                shouldForwardArgs: true
-            }
-        });
-        this.repositoryDisposables.add(toolbar);
-    }
     setValidation(validation, options) {
         if (this._validationTimer) {
             clearTimeout(this._validationTimer);
@@ -1785,20 +1850,16 @@ let SCMInputWidget = class SCMInputWidget {
             this._validationTimer = setTimeout(() => this.setValidation(undefined), SCMInputWidget_1.ValidationTimeouts[validation.type]);
         }
     }
-    constructor(container, overflowWidgetsDomNode, contextKeyService, modelService, textModelService, keybindingService, configurationService, instantiationService, scmService, scmViewService, contextViewService, openerService, contextMenuService, commandService) {
-        this.contextKeyService = contextKeyService;
+    constructor(container, overflowWidgetsDomNode, contextKeyService, modelService, textModelService, keybindingService, configurationService, instantiationService, scmViewService, contextViewService, openerService, contextMenuService) {
         this.modelService = modelService;
         this.textModelService = textModelService;
         this.keybindingService = keybindingService;
         this.configurationService = configurationService;
         this.instantiationService = instantiationService;
-        this.scmService = scmService;
         this.scmViewService = scmViewService;
         this.contextViewService = contextViewService;
         this.openerService = openerService;
         this.contextMenuService = contextMenuService;
-        this.commandService = commandService;
-        this.defaultInputFontFamily = DEFAULT_FONT_FAMILY;
         this.disposables = ( new DisposableStore());
         this.repositoryDisposables = ( new DisposableStore());
         this.validationDisposable = Disposable.None;
@@ -1809,34 +1870,13 @@ let SCMInputWidget = class SCMInputWidget {
         this.editorContainer = append(this.element, $('.scm-editor-container'));
         this.placeholderTextContainer = append(this.editorContainer, $('.scm-editor-placeholder'));
         this.toolbarContainer = append(this.element, $('.scm-editor-toolbar'));
-        const fontFamily = this.getInputEditorFontFamily();
-        const fontSize = this.getInputEditorFontSize();
-        const lineHeight = this.computeLineHeight(fontSize);
-        this.setPlaceholderFontStyles(fontFamily, fontSize, lineHeight);
-        this.toolbarContextKeyService = this.contextKeyService.createScoped(this.toolbarContainer);
-        const contextKeyService2 = contextKeyService.createScoped(this.element);
-        this.repositoryIdContextKey = contextKeyService2.createKey('scmRepository', undefined);
-        const editorOptions = {
-            ...getSimpleEditorOptions(configurationService),
-            lineDecorationsWidth: 6,
-            dragAndDrop: true,
-            cursorWidth: 1,
-            fontSize: fontSize,
-            lineHeight: lineHeight,
-            fontFamily: fontFamily,
-            wrappingStrategy: 'advanced',
-            wrappingIndent: 'none',
-            padding: { top: 2, bottom: 2 },
-            quickSuggestions: false,
-            scrollbar: {
-                alwaysConsumeMouseWheel: false,
-                vertical: 'hidden'
-            },
-            overflowWidgetsDomNode,
-            formatOnType: true,
-            renderWhitespace: 'none',
-            dropIntoEditor: { enabled: true }
-        };
+        this.contextKeyService = contextKeyService.createScoped(this.element);
+        this.repositoryIdContextKey = this.contextKeyService.createKey('scmRepository', undefined);
+        this.inputEditorOptions = ( new SCMInputWidgetEditorOptions(overflowWidgetsDomNode, this.configurationService));
+        this.disposables.add(this.inputEditorOptions.onDidChange(this.onDidChangeEditorOptions, this));
+        this.disposables.add(this.inputEditorOptions);
+        const editorConstructionOptions = this.inputEditorOptions.getEditorConstructionOptions();
+        this.setPlaceholderFontStyles(editorConstructionOptions.fontFamily, editorConstructionOptions.fontSize, editorConstructionOptions.lineHeight);
         const codeEditorWidgetOptions = {
             isSimpleWidget: true,
             contributions: EditorExtensionsRegistry.getSomeEditorContributions([
@@ -1847,7 +1887,7 @@ let SCMInputWidget = class SCMInputWidget {
                 LinkDetector.ID,
                 MenuPreventer.ID,
                 MessageController.ID,
-                ModesHoverController.ID,
+                HoverController.ID,
                 SelectionClipboardContributionID,
                 SnippetController2.ID,
                 SuggestController.ID,
@@ -1856,9 +1896,9 @@ let SCMInputWidget = class SCMInputWidget {
                 FormatOnType.ID
             ])
         };
-        const services = ( new ServiceCollection([IContextKeyService, contextKeyService2]));
+        const services = ( new ServiceCollection([IContextKeyService, this.contextKeyService]));
         const instantiationService2 = instantiationService.createChild(services);
-        this.inputEditor = instantiationService2.createInstance(CodeEditorWidget, this.editorContainer, editorOptions, codeEditorWidgetOptions);
+        this.inputEditor = instantiationService2.createInstance(CodeEditorWidget, this.editorContainer, editorConstructionOptions, codeEditorWidgetOptions);
         this.disposables.add(this.inputEditor);
         this.disposables.add(this.inputEditor.onDidFocusEditorText(() => {
             if (this.input?.repository) {
@@ -1875,8 +1915,8 @@ let SCMInputWidget = class SCMInputWidget {
                 }
             }, 0);
         }));
-        const firstLineKey = contextKeyService2.createKey('scmInputIsInFirstPosition', false);
-        const lastLineKey = contextKeyService2.createKey('scmInputIsInLastPosition', false);
+        const firstLineKey = this.contextKeyService.createKey('scmInputIsInFirstPosition', false);
+        const lastLineKey = this.contextKeyService.createKey('scmInputIsInLastPosition', false);
         this.disposables.add(this.inputEditor.onDidChangeCursorPosition(({ position }) => {
             const viewModel = this.inputEditor._getViewModel();
             const lastLineNumber = viewModel.getLineCount();
@@ -1888,44 +1928,32 @@ let SCMInputWidget = class SCMInputWidget {
         this.disposables.add(this.inputEditor.onDidScrollChange(e => {
             this.toolbarContainer.classList.toggle('scroll-decoration', e.scrollTop > 0);
         }));
-        const relevantSettings = [
-            'scm.inputFontFamily',
-            'editor.fontFamily',
-            'scm.inputFontSize',
-            'editor.accessibilitySupport',
-            'editor.cursorBlinking'
-        ];
-        const onRelevantSettingChanged = Event.filter(this.configurationService.onDidChangeConfiguration, (e) => {
-            for (const setting of relevantSettings) {
-                if (e.affectsConfiguration(setting)) {
-                    return true;
+        Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.showInputActionButton'))(() => this.layout(), this, this.disposables);
+        this.onDidChangeContentHeight = Event.signal(Event.filter(this.inputEditor.onDidContentSizeChange, e => e.contentHeightChanged, this.disposables));
+        this.toolbar = instantiationService2.createInstance(SCMInputWidgetToolbar, this.toolbarContainer, {
+            actionViewItemProvider: action => {
+                if (action instanceof MenuItemAction && this.toolbar.dropdownActions.length > 1) {
+                    return instantiationService.createInstance(DropdownWithPrimaryActionViewItem, action, this.toolbar.dropdownAction, this.toolbar.dropdownActions, '', this.contextMenuService, { actionRunner: this.toolbar.actionRunner });
                 }
+                return createActionViewItem(instantiationService, action);
+            },
+            menuOptions: {
+                shouldForwardArgs: true
             }
-            return false;
-        }, this.disposables);
-        this.disposables.add(onRelevantSettingChanged(() => {
-            const fontFamily = this.getInputEditorFontFamily();
-            const fontSize = this.getInputEditorFontSize();
-            const lineHeight = this.computeLineHeight(fontSize);
-            const accessibilitySupport = this.configurationService.getValue('editor.accessibilitySupport');
-            const cursorBlinking = this.configurationService.getValue('editor.cursorBlinking');
-            this.inputEditor.updateOptions({
-                fontFamily: fontFamily,
-                fontSize: fontSize,
-                lineHeight: lineHeight,
-                accessibilitySupport,
-                cursorBlinking
-            });
-            this.setPlaceholderFontStyles(fontFamily, fontSize, lineHeight);
-        }));
-        this.onDidChangeContentHeight = Event.signal(Event.filter(this.inputEditor.onDidContentSizeChange, e => e.contentHeightChanged, this.disposables));
-        this.actionBar = ( new ActionBar(this.toolbarContainer));
-        this.disposables.add(this.actionBar);
+        });
+        this.disposables.add(this.toolbar.onDidChange(() => this.layout()));
+        this.disposables.add(this.toolbar);
     }
     getContentHeight() {
-        const editorContentHeight = this.inputEditor.getContentHeight();
-        const editorContextHeightMax = this.getInputEditorMaxHeight();
-        return Math.min(editorContentHeight, editorContextHeightMax);
+        const lineHeight = this.inputEditor.getOption(66 );
+        const { top, bottom } = this.inputEditor.getOption(83 );
+        const inputMinLinesConfig = this.configurationService.getValue('scm.inputMinLineCount');
+        const inputMinLines = typeof inputMinLinesConfig === 'number' ? clamp(inputMinLinesConfig, 1, 50) : 1;
+        const editorMinHeight = inputMinLines * lineHeight + top + bottom;
+        const inputMaxLinesConfig = this.configurationService.getValue('scm.inputMaxLineCount');
+        const inputMaxLines = typeof inputMaxLinesConfig === 'number' ? clamp(inputMaxLinesConfig, 1, 50) : 10;
+        const editorMaxHeight = inputMaxLines * lineHeight + top + bottom;
+        return clamp(this.inputEditor.getContentHeight(), editorMinHeight, editorMaxHeight);
     }
     layout() {
         const editorHeight = this.getContentHeight();
@@ -1939,8 +1967,8 @@ let SCMInputWidget = class SCMInputWidget {
         this.inputEditor.layout(dimension);
         this.placeholderTextContainer.style.width = `${dimension.width}px`;
         this.renderValidation();
-        this.actionBar.domNode.classList.toggle('hidden', this.actionBar.isEmpty());
-        this.toolbarContainer.classList.toggle('hidden', this.configurationService.getValue('scm.showInputActionButton') === false);
+        const showInputActionButton = this.configurationService.getValue('scm.showInputActionButton') === true;
+        this.toolbarContainer.classList.toggle('hidden', !showInputActionButton || this.toolbar?.isEmpty() === true);
         if (this.shouldFocusAfterLayout) {
             this.shouldFocusAfterLayout = false;
             this.focus();
@@ -1958,6 +1986,11 @@ let SCMInputWidget = class SCMInputWidget {
     hasFocus() {
         return this.inputEditor.hasTextFocus();
     }
+    onDidChangeEditorOptions() {
+        const editorOptions = this.inputEditorOptions.getEditorOptions();
+        this.inputEditor.updateOptions(editorOptions);
+        this.setPlaceholderFontStyles(editorOptions.fontFamily, editorOptions.fontSize, editorOptions.lineHeight);
+    }
     renderValidation() {
         this.clearValidation();
         this.element.classList.toggle('validation-info', this.validation?.type === 2 );
@@ -2027,40 +2060,14 @@ let SCMInputWidget = class SCMInputWidget {
             anchorAlignment: 0
         });
     }
-    getInputEditorFontFamily() {
-        const inputFontFamily = this.configurationService.getValue('scm.inputFontFamily').trim();
-        if (inputFontFamily.toLowerCase() === 'editor') {
-            return this.configurationService.getValue('editor.fontFamily').trim();
-        }
-        if (inputFontFamily.length !== 0 && inputFontFamily.toLowerCase() !== 'default') {
-            return inputFontFamily;
-        }
-        return this.defaultInputFontFamily;
-    }
-    getInputEditorFontSize() {
-        return this.configurationService.getValue('scm.inputFontSize');
-    }
-    getInputEditorMaxLines() {
-        const inputMaxLines = this.configurationService.getValue('scm.inputMaxLines');
-        return typeof inputMaxLines === 'number' ? clamp(inputMaxLines, 1, 50) : 10;
-    }
-    getInputEditorMaxHeight() {
-        const maxLines = this.getInputEditorMaxLines();
-        const fontSize = this.getInputEditorFontSize();
-        const lineHeight = this.computeLineHeight(fontSize);
-        const { top, bottom } = this.inputEditor.getOption(83 );
-        return maxLines * lineHeight + top + bottom;
-    }
     getToolbarWidth() {
         const showInputActionButton = this.configurationService.getValue('scm.showInputActionButton');
-        const actionCount = this.toolbarContextKeyService.getContextKeyValue(SCMInputContextKeys.ActionCount.key) ?? 0;
-        if (!showInputActionButton || (this.actionBar.isEmpty() && actionCount === 0)) {
+        if (!this.toolbar || !showInputActionButton || this.toolbar?.isEmpty() === true) {
             return 0;
         }
-        return 26;
-    }
-    computeLineHeight(fontSize) {
-        return Math.round(fontSize * 1.5);
+        return this.toolbar.dropdownActions.length === 0 ?
+            26  :
+            39 ;
     }
     setPlaceholderFontStyles(fontFamily, fontSize, lineHeight) {
         this.placeholderTextContainer.style.fontFamily = fontFamily;
@@ -2085,12 +2092,10 @@ SCMInputWidget = SCMInputWidget_1 = ( __decorate([
     ( __param(5, IKeybindingService)),
     ( __param(6, IConfigurationService)),
     ( __param(7, IInstantiationService)),
-    ( __param(8, ISCMService)),
-    ( __param(9, ISCMViewService)),
-    ( __param(10, IContextViewService)),
-    ( __param(11, IOpenerService)),
-    ( __param(12, IContextMenuService)),
-    ( __param(13, ICommandService))
+    ( __param(8, ISCMViewService)),
+    ( __param(9, IContextViewService)),
+    ( __param(10, IOpenerService)),
+    ( __param(11, IContextMenuService))
 ], SCMInputWidget));
 let SCMViewPane = class SCMViewPane extends ViewPane {
     get viewMode() { return this._viewMode; }
@@ -2120,10 +2125,6 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
             this.storageService.store(`scm.viewSortKey`, sortKey, 1 , 0 );
         }
     }
-    get showActionButton() { return this._showActionButton; }
-    get alwaysShowRepositories() { return this._alwaysShowRepositories; }
-    get showIncomingChanges() { return this._showIncomingChanges ?? 'never'; }
-    get showOutgoingChanges() { return this._showOutgoingChanges ?? 'never'; }
     constructor(options, commandService, editorService, menuService, scmService, scmViewService, storageService, uriIdentityService, keybindingService, themeService, contextMenuService, instantiationService, viewDescriptorService, configurationService, contextKeyService, openerService, telemetryService) {
         super({ ...options, titleMenuId: MenuId.SCMTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
         this.commandService = commandService;
@@ -2137,8 +2138,6 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         this.onDidChangeViewMode = this._onDidChangeViewMode.event;
         this._onDidChangeViewSortKey = ( new Emitter());
         this.onDidChangeViewSortKey = this._onDidChangeViewSortKey.event;
-        this._showActionButton = false;
-        this._alwaysShowRepositories = false;
         this.items = ( new DisposableMap());
         this.visibilityDisposables = ( new DisposableStore());
         this.treeOperationSequencer = ( new Sequencer());
@@ -2211,24 +2210,16 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         this.onDidChangeBodyVisibility(async (visible) => {
             if (visible) {
                 await this.tree.setInput(this.scmViewService, viewState);
-                const onDidChangeConfiguration = (e) => {
-                    if (!e ||
-                        e.affectsConfiguration('scm.showActionButton') ||
-                        e.affectsConfiguration('scm.alwaysShowRepositories') ||
-                        e.affectsConfiguration('scm.showIncomingChanges') ||
-                        e.affectsConfiguration('scm.showOutgoingChanges')) {
-                        this._showActionButton = this.configurationService.getValue('scm.showActionButton');
-                        this._alwaysShowRepositories = this.configurationService.getValue('scm.alwaysShowRepositories');
-                        this._showIncomingChanges = this.configurationService.getValue('scm.showIncomingChanges');
-                        this._showOutgoingChanges = this.configurationService.getValue('scm.showOutgoingChanges');
-                        if (e?.affectsConfiguration('scm.alwaysShowRepositories')) {
-                            this.updateActions();
-                        }
-                        this.updateChildren();
-                    }
-                };
-                this.configurationService.onDidChangeConfiguration(onDidChangeConfiguration, this, this.visibilityDisposables);
-                onDidChangeConfiguration();
+                Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.alwaysShowRepositories'), this.visibilityDisposables)(() => {
+                    this.updateActions();
+                    this.updateChildren();
+                }, this, this.visibilityDisposables);
+                Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.inputMinLineCount') ||
+                    e.affectsConfiguration('scm.inputMaxLineCount') ||
+                    e.affectsConfiguration('scm.showActionButton') ||
+                    e.affectsConfiguration('scm.showChangesSummary') ||
+                    e.affectsConfiguration('scm.showIncomingChanges') ||
+                    e.affectsConfiguration('scm.showOutgoingChanges'), this.visibilityDisposables)(() => this.updateChildren(), this, this.visibilityDisposables);
                 this.editorService.onDidActiveEditorChange(this.onDidActiveEditorChange, this, this.visibilityDisposables);
                 this.scmViewService.onDidChangeVisibleRepositories(this.onDidChangeVisibleRepositories, this, this.visibilityDisposables);
                 this.onDidChangeVisibleRepositories({ added: this.scmViewService.visibleRepositories, removed: Iterable.empty() });
@@ -2254,19 +2245,25 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         this.actionButtonRenderer = this.instantiationService.createInstance(ActionButtonRenderer);
         this.listLabels = this.instantiationService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
         this.disposables.add(this.listLabels);
-        const actionRunner = ( new RepositoryPaneActionRunner(() => this.getSelectedResources()));
-        actionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
-        this.disposables.add(actionRunner);
-        const treeDataSource = this.instantiationService.createInstance(SCMTreeDataSource, () => this.viewMode, () => this.alwaysShowRepositories, () => this.showActionButton, () => this.showIncomingChanges, () => this.showOutgoingChanges);
+        const resourceActionRunner = ( new RepositoryPaneActionRunner(() => this.getSelectedResources()));
+        resourceActionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
+        this.disposables.add(resourceActionRunner);
+        const historyItemGroupActionRunner = ( new HistoryItemGroupActionRunner());
+        historyItemGroupActionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
+        this.disposables.add(historyItemGroupActionRunner);
+        const historyItemActionRunner = ( new HistoryItemActionRunner());
+        historyItemActionRunner.onWillRun(() => this.tree.domFocus(), this, this.disposables);
+        this.disposables.add(historyItemActionRunner);
+        const treeDataSource = this.instantiationService.createInstance(SCMTreeDataSource, () => this.viewMode);
         this.disposables.add(treeDataSource);
         this.tree = this.instantiationService.createInstance(WorkbenchCompressibleAsyncDataTree, 'SCM Tree Repo', container, ( new ListDelegate(this.inputRenderer)), ( new SCMTreeCompressionDelegate()), [
             this.inputRenderer,
             this.actionButtonRenderer,
-            this.instantiationService.createInstance(RepositoryRenderer, getActionViewItemProvider(this.instantiationService)),
+            this.instantiationService.createInstance(RepositoryRenderer, MenuId.SCMTitle, getActionViewItemProvider(this.instantiationService)),
             this.instantiationService.createInstance(ResourceGroupRenderer, getActionViewItemProvider(this.instantiationService)),
-            this.instantiationService.createInstance(ResourceRenderer, () => this.viewMode, this.listLabels, getActionViewItemProvider(this.instantiationService), actionRunner),
-            this.instantiationService.createInstance(HistoryItemGroupRenderer),
-            this.instantiationService.createInstance(HistoryItemRenderer, getActionViewItemProvider(this.instantiationService)),
+            this.instantiationService.createInstance(ResourceRenderer, () => this.viewMode, this.listLabels, getActionViewItemProvider(this.instantiationService), resourceActionRunner),
+            this.instantiationService.createInstance(HistoryItemGroupRenderer, historyItemGroupActionRunner),
+            this.instantiationService.createInstance(HistoryItemRenderer, historyItemActionRunner, getActionViewItemProvider(this.instantiationService)),
             this.instantiationService.createInstance(HistoryItemChangeRenderer, () => this.viewMode, this.listLabels),
             this.instantiationService.createInstance(SeparatorRenderer)
         ], treeDataSource, {
@@ -2386,6 +2383,14 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         if (!uri) {
             return;
         }
+        if (( this.tree.getFocus().some(
+            e => isSCMResource(e) && this.uriIdentityService.extUri.isEqual(e.sourceUri, uri)
+        )) &&
+            ( this.tree.getSelection().some(
+                e => isSCMResource(e) && this.uriIdentityService.extUri.isEqual(e.sourceUri, uri)
+            ))) {
+            return;
+        }
         this.revealResourceThrottler.queue(() => this.treeOperationSequencer.queue(async () => {
             for (const repository of this.scmViewService.visibleRepositories) {
                 const item = this.items.get(repository);
@@ -2411,7 +2416,6 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         for (const repository of added) {
             const repositoryDisposables = ( new DisposableStore());
             repositoryDisposables.add(repository.provider.onDidChange(() => this.updateChildren(repository)));
-            repositoryDisposables.add(repository.input.onDidChangeActionButton(() => this.updateChildren(repository)));
             repositoryDisposables.add(repository.input.onDidChangeVisibility(() => this.updateChildren(repository)));
             repositoryDisposables.add(repository.provider.onDidChangeResourceGroups(() => this.updateChildren(repository)));
             if (repository.provider.historyProvider) {
@@ -2461,7 +2465,7 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         let actions = [];
         if (isSCMRepository(element)) {
             const menus = this.scmViewService.menus.getRepositoryMenus(element.provider);
-            const menu = menus.repositoryMenu;
+            const menu = menus.repositoryContextMenu;
             context = element.provider;
             actions = collectContextMenuActions(menu);
         }
@@ -2488,7 +2492,9 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
                 actions = collectContextMenuActions(menu);
             }
         }
-        const actionRunner = ( new RepositoryPaneActionRunner(() => this.getSelectedResources()));
+        const actionRunner = isSCMRepository(element) ?
+            ( new RepositoryActionRunner(() => this.getSelectedRepositories())) :
+            ( new RepositoryPaneActionRunner(() => this.getSelectedResources()));
         actionRunner.onWillRun(() => this.tree.domFocus());
         this.contextMenuService.showContextMenu({
             getAnchor: () => e.anchor,
@@ -2497,6 +2503,11 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
             actionRunner
         });
     }
+    getSelectedRepositories() {
+        const focusedRepositories = this.tree.getFocus().filter(r => !!r && isSCMRepository(r));
+        const selectedRepositories = this.tree.getSelection().filter(r => !!r && isSCMRepository(r));
+        return Array.from(( new Set([...focusedRepositories, ...selectedRepositories])));
+    }
     getSelectedResources() {
         return this.tree.getSelection()
             .filter(r => !!r && !isSCMResourceGroup(r));
@@ -2546,7 +2557,9 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         }
     }
     storeTreeViewState() {
-        this.storageService.store('scm.viewState2', JSON.stringify(this.tree.getViewState()), 1 , 1 );
+        if (this.tree) {
+            this.storageService.store('scm.viewState2', JSON.stringify(this.tree.getViewState()), 1 , 1 );
+        }
     }
     updateChildren(element) {
         this.updateChildrenThrottler.queue(() => this.treeOperationSequencer.queue(async () => {
@@ -2571,7 +2584,8 @@ let SCMViewPane = class SCMViewPane extends ViewPane {
         this.treeContainer.classList.toggle('hide-arrows', this.viewMode === "tree"  && theme.hidesExplorerArrows === true);
     }
     updateScmProviderContextKeys() {
-        if (!this.alwaysShowRepositories && this.items.size === 1) {
+        const alwaysShowRepositories = this.configurationService.getValue('scm.alwaysShowRepositories');
+        if (!alwaysShowRepositories && this.items.size === 1) {
             const provider = Iterable.first(( this.items.keys())).provider;
             this.scmProviderContextKey.set(provider.contextValue);
             this.scmProviderRootUriContextKey.set(provider.rootUri?.toString());
@@ -2655,17 +2669,16 @@ SCMViewPane = ( __decorate([
     ( __param(16, ITelemetryService))
 ], SCMViewPane));
 let SCMTreeDataSource = class SCMTreeDataSource {
-    constructor(viewMode, alwaysShowRepositories, showActionButton, showIncomingChanges, showOutgoingChanges, scmViewService, uriIdentityService) {
+    constructor(viewMode, configurationService, scmViewService, uriIdentityService) {
         this.viewMode = viewMode;
-        this.alwaysShowRepositories = alwaysShowRepositories;
-        this.showActionButton = showActionButton;
-        this.showIncomingChanges = showIncomingChanges;
-        this.showOutgoingChanges = showOutgoingChanges;
+        this.configurationService = configurationService;
         this.scmViewService = scmViewService;
         this.uriIdentityService = uriIdentityService;
         this.historyProviderCache = ( new Map());
         this.repositoryDisposables = ( new DisposableMap());
         this.disposables = ( new DisposableStore());
+        const onDidChangeConfiguration = Event.filter(this.configurationService.onDidChangeConfiguration, e => e.affectsConfiguration('scm.showChangesSummary'), this.disposables);
+        this.disposables.add(onDidChangeConfiguration(() => this.historyProviderCache.clear()));
         this.scmViewService.onDidChangeVisibleRepositories(this.onDidChangeVisibleRepositories, this, this.disposables);
         this.onDidChangeVisibleRepositories({ added: this.scmViewService.visibleRepositories, removed: Iterable.empty() });
     }
@@ -2708,8 +2721,8 @@ let SCMTreeDataSource = class SCMTreeDataSource {
         }
     }
     async getChildren(inputOrElement) {
+        const { alwaysShowRepositories, showActionButton } = this.getConfiguration();
         const repositoryCount = this.scmViewService.visibleRepositories.length;
-        const alwaysShowRepositories = this.alwaysShowRepositories();
         if (isSCMViewService(inputOrElement) && (repositoryCount > 1 || alwaysShowRepositories)) {
             return this.scmViewService.visibleRepositories;
         }
@@ -2718,7 +2731,6 @@ let SCMTreeDataSource = class SCMTreeDataSource {
             inputOrElement = isSCMRepository(inputOrElement) ? inputOrElement : this.scmViewService.visibleRepositories[0];
             const actionButton = inputOrElement.provider.actionButton;
             const resourceGroups = inputOrElement.provider.groups;
-            const showActionButton = this.showActionButton();
             if (inputOrElement.input.visible) {
                 children.push(inputOrElement.input);
             }
@@ -2735,20 +2747,43 @@ let SCMTreeDataSource = class SCMTreeDataSource {
             }
             const historyItemGroups = await this.getHistoryItemGroups(inputOrElement);
             if (historyItemGroups.length > 0) {
-                children.push({
-                    label: ( localizeWithPath(
+                let label = ( localizeWithPath(
+                    'vs/workbench/contrib/scm/browser/scmViewPane',
+                    'syncSeparatorHeader',
+                    "Incoming/Outgoing"
+                ));
+                let ariaLabel = ( localizeWithPath(
+                    'vs/workbench/contrib/scm/browser/scmViewPane',
+                    'syncSeparatorHeaderAriaLabel',
+                    "Incoming and outgoing changes"
+                ));
+                const incomingHistoryItems = historyItemGroups.find(g => g.direction === 'incoming');
+                const outgoingHistoryItems = historyItemGroups.find(g => g.direction === 'outgoing');
+                if (incomingHistoryItems && !outgoingHistoryItems) {
+                    label = ( localizeWithPath(
                         'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'syncSeparatorHeader',
-                        "Incoming/Outgoing"
-                    )),
-                    ariaLabel: ( localizeWithPath(
+                        'syncIncomingSeparatorHeader',
+                        "Incoming"
+                    ));
+                    ariaLabel = ( localizeWithPath(
                         'vs/workbench/contrib/scm/browser/scmViewPane',
-                        'syncSeparatorHeaderAriaLabel',
-                        "Incoming and outgoing changes"
-                    )),
-                    repository: inputOrElement,
-                    type: 'separator'
-                });
+                        'syncIncomingSeparatorHeaderAriaLabel',
+                        "Incoming changes"
+                    ));
+                }
+                else if (!incomingHistoryItems && outgoingHistoryItems) {
+                    label = ( localizeWithPath(
+                        'vs/workbench/contrib/scm/browser/scmViewPane',
+                        'syncOutgoingSeparatorHeader',
+                        "Outgoing"
+                    ));
+                    ariaLabel = ( localizeWithPath(
+                        'vs/workbench/contrib/scm/browser/scmViewPane',
+                        'syncOutgoingSeparatorHeaderAriaLabel',
+                        "Outgoing changes"
+                    ));
+                }
+                children.push({ label, ariaLabel, repository: inputOrElement, type: 'separator' });
             }
             children.push(...historyItemGroups);
             return children;
@@ -2781,52 +2816,70 @@ let SCMTreeDataSource = class SCMTreeDataSource {
         return [];
     }
     async getHistoryItemGroups(element) {
+        const { showIncomingChanges, showOutgoingChanges } = this.getConfiguration();
         const scmProvider = element.provider;
         const historyProvider = scmProvider.historyProvider;
         const currentHistoryItemGroup = historyProvider?.currentHistoryItemGroup;
-        if (!historyProvider || !currentHistoryItemGroup || (this.showIncomingChanges() === 'never' && this.showOutgoingChanges() === 'never')) {
+        if (!historyProvider || !currentHistoryItemGroup || (showIncomingChanges === 'never' && showOutgoingChanges === 'never')) {
             return [];
         }
         const children = [];
         const historyProviderCacheEntry = this.getHistoryProviderCacheEntry(element);
-        let historyItemGroupDetails = historyProviderCacheEntry?.historyItemGroupDetails;
-        if (!historyItemGroupDetails) {
-            historyItemGroupDetails = await historyProvider.resolveHistoryItemGroupDetails(currentHistoryItemGroup);
-            this.historyProviderCache.set(element, {
-                ...historyProviderCacheEntry,
-                historyItemGroupDetails
-            });
-        }
-        if (historyItemGroupDetails?.incoming &&
-            (this.showIncomingChanges() === 'always' ||
-                (this.showIncomingChanges() === 'auto' && (historyItemGroupDetails.incoming.count ?? 0) > 0))) {
-            children.push({
-                ...historyItemGroupDetails.incoming,
+        let incomingHistoryItemGroup = historyProviderCacheEntry?.incomingHistoryItemGroup;
+        let outgoingHistoryItemGroup = historyProviderCacheEntry?.outgoingHistoryItemGroup;
+        if (!incomingHistoryItemGroup || !outgoingHistoryItemGroup) {
+            const ancestor = await historyProvider.resolveHistoryItemGroupCommonAncestor(currentHistoryItemGroup.id, currentHistoryItemGroup.base?.id);
+            if (!ancestor) {
+                return [];
+            }
+            incomingHistoryItemGroup = currentHistoryItemGroup.base ? {
+                id: currentHistoryItemGroup.base.id,
+                label: currentHistoryItemGroup.base.label,
                 ariaLabel: ( localizeWithPath(
                     'vs/workbench/contrib/scm/browser/scmViewPane',
                     'incomingChangesAriaLabel',
                     "Incoming changes from {0}",
-                    historyItemGroupDetails.incoming.label
+                    currentHistoryItemGroup.base.label
                 )),
+                icon: Codicon.arrowCircleDown,
+                direction: 'incoming',
+                ancestor: ancestor.id,
+                count: ancestor.behind,
                 repository: element,
                 type: 'historyItemGroup'
-            });
-        }
-        if (historyItemGroupDetails?.outgoing &&
-            (this.showOutgoingChanges() === 'always' ||
-                (this.showOutgoingChanges() === 'auto' && (historyItemGroupDetails.outgoing.count ?? 0) > 0))) {
-            children.push({
-                ...historyItemGroupDetails.outgoing,
+            } : undefined;
+            outgoingHistoryItemGroup = {
+                id: currentHistoryItemGroup.id,
+                label: currentHistoryItemGroup.label,
                 ariaLabel: ( localizeWithPath(
                     'vs/workbench/contrib/scm/browser/scmViewPane',
                     'outgoingChangesAriaLabel',
-                    "Outgoing changes from {0}",
-                    historyItemGroupDetails.outgoing.label
+                    "Outgoing changes to {0}",
+                    currentHistoryItemGroup.label
                 )),
+                icon: Codicon.arrowCircleUp,
+                direction: 'outgoing',
+                ancestor: ancestor.id,
+                count: ancestor.ahead,
                 repository: element,
                 type: 'historyItemGroup'
+            };
+            this.historyProviderCache.set(element, {
+                ...historyProviderCacheEntry,
+                incomingHistoryItemGroup,
+                outgoingHistoryItemGroup
             });
         }
+        if (incomingHistoryItemGroup &&
+            (showIncomingChanges === 'always' ||
+                (showIncomingChanges === 'auto' && (incomingHistoryItemGroup.count ?? 0) > 0))) {
+            children.push(incomingHistoryItemGroup);
+        }
+        if (outgoingHistoryItemGroup &&
+            (showOutgoingChanges === 'always' ||
+                (showOutgoingChanges === 'auto' && (outgoingHistoryItemGroup.count ?? 0) > 0))) {
+            children.push(outgoingHistoryItemGroup);
+        }
         return children;
     }
     async getHistoryItems(element) {
@@ -2837,19 +2890,39 @@ let SCMTreeDataSource = class SCMTreeDataSource {
         }
         const historyProviderCacheEntry = this.getHistoryProviderCacheEntry(repository);
         const historyItemsMap = historyProviderCacheEntry.historyItems;
-        let historyItems = historyProviderCacheEntry.historyItems.get(element.id);
-        if (!historyItems) {
-            historyItems = (await historyProvider.provideHistoryItems(element.id, { limit: { id: element.ancestor } })) ?? [];
+        let historyItemsElement = historyProviderCacheEntry.historyItems.get(element.id);
+        if (!historyItemsElement) {
+            const historyItems = (await historyProvider.provideHistoryItems(element.id, { limit: { id: element.ancestor } })) ?? [];
+            const { showChangesSummary } = this.getConfiguration();
+            const allChanges = showChangesSummary && historyItems.length >= 2 ?
+                await historyProvider.provideHistoryItemSummary(historyItems[0].id, element.ancestor) : undefined;
+            historyItemsElement = [allChanges, historyItems];
             this.historyProviderCache.set(repository, {
                 ...historyProviderCacheEntry,
-                historyItems: historyItemsMap.set(element.id, historyItems)
+                historyItems: historyItemsMap.set(element.id, historyItemsElement)
             });
         }
-        return ( historyItems.map(historyItem => ({
+        const children = [];
+        if (historyItemsElement[0]) {
+            children.push({
+                ...historyItemsElement[0],
+                icon: historyItemsElement[0].icon ?? Codicon.files,
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/scm/browser/scmViewPane',
+                    'allChanges',
+                    "All Changes"
+                )),
+                historyItemGroup: element,
+                type: 'allChanges'
+            });
+        }
+        children.push(...( historyItemsElement[1]
+            .map(historyItem => ({
             ...historyItem,
             historyItemGroup: element,
             type: 'historyItem'
-        })));
+        }))));
+        return children;
     }
     async getHistoryItemChanges(element) {
         const repository = element.historyItemGroup.repository;
@@ -2859,12 +2932,14 @@ let SCMTreeDataSource = class SCMTreeDataSource {
         }
         const historyProviderCacheEntry = this.getHistoryProviderCacheEntry(repository);
         const historyItemChangesMap = historyProviderCacheEntry.historyItemChanges;
-        let historyItemChanges = historyItemChangesMap.get(element.id);
+        const historyItemParentId = element.parentIds.length > 0 ? element.parentIds[0] : undefined;
+        let historyItemChanges = historyItemChangesMap.get(`${element.id}/${historyItemParentId}`);
         if (!historyItemChanges) {
-            historyItemChanges = (await historyProvider.provideHistoryItemChanges(element.id)) ?? [];
+            const historyItemParentId = element.parentIds.length > 0 ? element.parentIds[0] : undefined;
+            historyItemChanges = (await historyProvider.provideHistoryItemChanges(element.id, historyItemParentId)) ?? [];
             this.historyProviderCache.set(repository, {
                 ...historyProviderCacheEntry,
-                historyItemChanges: historyItemChangesMap.set(element.id, historyItemChanges)
+                historyItemChanges: historyItemChangesMap.set(`${element.id}/${historyItemParentId}`, historyItemChanges)
             });
         }
         if (this.viewMode() === "list" ) {
@@ -2922,6 +2997,15 @@ let SCMTreeDataSource = class SCMTreeDataSource {
             throw new Error('Unexpected call to getParent');
         }
     }
+    getConfiguration() {
+        return {
+            alwaysShowRepositories: this.configurationService.getValue('scm.alwaysShowRepositories'),
+            showActionButton: this.configurationService.getValue('scm.showActionButton'),
+            showChangesSummary: this.configurationService.getValue('scm.showChangesSummary'),
+            showIncomingChanges: this.configurationService.getValue('scm.showIncomingChanges'),
+            showOutgoingChanges: this.configurationService.getValue('scm.showOutgoingChanges')
+        };
+    }
     onDidChangeVisibleRepositories({ added, removed }) {
         for (const repository of added) {
             const repositoryDisposables = ( new DisposableStore());
@@ -2937,7 +3021,8 @@ let SCMTreeDataSource = class SCMTreeDataSource {
     }
     getHistoryProviderCacheEntry(repository) {
         return this.historyProviderCache.get(repository) ?? {
-            historyItemGroupDetails: undefined,
+            incomingHistoryItemGroup: undefined,
+            outgoingHistoryItemGroup: undefined,
             historyItems: ( new Map()),
             historyItemChanges: ( new Map())
         };
@@ -2948,8 +3033,9 @@ let SCMTreeDataSource = class SCMTreeDataSource {
     }
 };
 SCMTreeDataSource = ( __decorate([
-    ( __param(5, ISCMViewService)),
-    ( __param(6, IUriIdentityService))
+    ( __param(1, IConfigurationService)),
+    ( __param(2, ISCMViewService)),
+    ( __param(3, IUriIdentityService))
 ], SCMTreeDataSource));
 class SCMActionButton {
     constructor(container, contextMenuService, commandService, notificationService) {