@codingame/monaco-vscode-workbench-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/contrib/changes/browser/changesViewActions.js

@@ -0,0 +1,509 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isDiffEditor, isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Categories } from '@codingame/monaco-vscode-api/vscode/vs/platform/action/common/actionCommonCategories';
+import { Action2, registerAction2, MenuId, MenuRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { bindContextKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { SET_DIFF_VIEW_MODE_INLINE, SET_DIFF_VIEW_MODE_SIDE_BY_SIDE, SET_DIFF_VIEW_MODE_AUTOMATIC, DIFF_VIEW_MODE_INLINE_TEMPORARY, TOGGLE_DIFF_SIDE_BY_SIDE } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/diffEditorCommands';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IsSessionsWindowContext, ActiveEditorContext, TextCompareEditorActiveContext, IsAuxiliaryWindowContext, IsTopRightEditorGroupContext, MainEditorAreaVisibleContext, AuxiliaryBarVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
+import { readTransientState, writeTransientState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/codeEditor/browser/toggleWordWrap';
+import { TEXT_FILE_EDITOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { OpenMultiDiffEditorLayoutDebugAction } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/actions';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { MultiDiffEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditor';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { SinglePaneDiffEditorInputActiveContext, SinglePaneLayoutEnabledContext, CustomViewVisibleContext, SessionIsCreatedContext, SessionHasChangesContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { logChangesViewViewModeChange } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { OPEN_PULL_REQUEST_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/common/types';
+import { CHANGES_VIEW_ID, ActiveSessionContextKeys, ChangesContextKeys, ChangesViewMode, SESSIONS_CHANGES_OPEN_SINGLE_FILE_DIFF_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changes';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+import { SESSIONS_EDITOR_WORD_WRAP_SETTING, SESSIONS_DIFF_EDITOR_WORD_WRAP_SETTING, SessionsDiffViewModeContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/editor/common/diffEditorOptionsService';
+import { IDiffEditorOptionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/editor/common/diffEditorOptionsService.service';
+import { CHANGES_HEADER_ACTIONS_ID } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/changesView';
+import { SessionChangesEditor } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditor';
+import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
+
+const openChangesViewActionOptions = {
+    id: "workbench.action.agentSessions.openChangesView",
+    title: ( localize2(3409, "Changes")),
+    icon: Codicon.diffMultiple,
+    f1: false
+};
+class OpenChangesViewAction extends Action2 {
+    static {
+        this.ID = openChangesViewActionOptions.id;
+    }
+    constructor() {
+        super(openChangesViewActionOptions);
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        await viewsService.openView(CHANGES_VIEW_ID, true);
+    }
+}
+registerAction2(OpenChangesViewAction);
+let ChangesViewActionsContribution = class ChangesViewActionsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.changesViewActions";
+    }
+    constructor(contextKeyService, sessionsService, changesViewService, editorService) {
+        super();
+        this._register(
+            bindContextKey(ActiveSessionContextKeys.HasChanges, contextKeyService, reader => {
+                const activeSession = sessionsService.activeSession.read(reader);
+                if (!activeSession) {
+                    return false;
+                }
+                const changes = activeSession.changes.read(reader);
+                return changes.length > 0;
+            })
+        );
+        this._register(bindContextKey(ChangesContextKeys.ViewMode, contextKeyService, reader => {
+            return changesViewService.viewModeObs.read(reader);
+        }));
+        const activeEditor = observableFromEvent(
+            this,
+            editorService.onDidActiveEditorChange,
+            () => editorService.activeEditor
+        );
+        this._register(bindContextKey(
+            SinglePaneDiffEditorInputActiveContext,
+            contextKeyService,
+            reader => activeEditor.read(reader) instanceof DiffEditorInput
+        ));
+    }
+};
+ChangesViewActionsContribution = ( __decorate([( __param(0, IContextKeyService)), ( __param(1, ISessionsService)), ( __param(2, IChangesViewService)), ( __param(3, IEditorService))], ChangesViewActionsContribution));
+registerWorkbenchContribution2(
+    ChangesViewActionsContribution.ID,
+    ChangesViewActionsContribution,
+    WorkbenchPhase.AfterRestored
+);
+class OpenPullRequestAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.openPullRequest";
+    }
+    constructor() {
+        super({
+            id: OpenPullRequestAction.ID,
+            title: ( localize2(3410, "Open Pull Request")),
+            icon: Codicon.gitPullRequest,
+            f1: false,
+            menu: {
+                id: MenuId.AgentsChangesToolbar,
+                group: "navigation",
+                order: 9,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ActiveSessionContextKeys.HasPullRequest))
+            }
+        });
+    }
+    async run(accessor) {
+        const commandService = accessor.get(ICommandService);
+        const sessionsService = accessor.get(ISessionsService);
+        const activeSession = sessionsService.activeSession.get();
+        if (!activeSession) {
+            return;
+        }
+        await commandService.executeCommand(OPEN_PULL_REQUEST_ACTION_ID, activeSession);
+    }
+}
+registerAction2(OpenPullRequestAction);
+const agentsChangesEditorActive = ( ContextKeyExpr.and(IsSessionsWindowContext, ( ActiveEditorContext.isEqualTo(SessionChangesEditor.ID))));
+const singlePaneFileDiffEditorActive = ( ContextKeyExpr.and(
+    IsSessionsWindowContext,
+    SinglePaneDiffEditorInputActiveContext,
+    SinglePaneLayoutEnabledContext
+));
+const agentsTextDiffEditorActive = ( ContextKeyExpr.and(IsSessionsWindowContext, TextCompareEditorActiveContext));
+const agentsMultiDiffEditorActive = ( ContextKeyExpr.and(IsSessionsWindowContext, ( ActiveEditorContext.isEqualTo(MultiDiffEditor.ID))));
+const agentsTextEditorActive = ( ContextKeyExpr.and(IsSessionsWindowContext, ( ActiveEditorContext.isEqualTo(TEXT_FILE_EDITOR_ID))));
+const agentsDiffEditorActive = ( ContextKeyExpr.or(
+    agentsChangesEditorActive,
+    agentsTextDiffEditorActive,
+    agentsMultiDiffEditorActive
+));
+const agentsMultiDiffEditorsActive = ( ContextKeyExpr.or(agentsChangesEditorActive, agentsMultiDiffEditorActive));
+const singlePaneChangesEditorActive = ( ContextKeyExpr.and(agentsChangesEditorActive, SinglePaneLayoutEnabledContext));
+const singlePaneTextDiffEditorActive = ( ContextKeyExpr.and(agentsTextDiffEditorActive, SinglePaneLayoutEnabledContext));
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: OpenMultiDiffEditorLayoutDebugAction.ID,
+        title: OpenMultiDiffEditorLayoutDebugAction.TITLE,
+        category: Categories.Developer
+    },
+    when: singlePaneChangesEditorActive
+});
+const singlePaneChangesEditorTitle = ( ContextKeyExpr.and(singlePaneChangesEditorActive, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext));
+const singlePaneChangesEditorTitleVisible = ( ContextKeyExpr.and(singlePaneChangesEditorTitle, MainEditorAreaVisibleContext));
+const singlePaneDiffEditorTitle = ( ContextKeyExpr.and(( ContextKeyExpr.or(singlePaneChangesEditorActive, singlePaneFileDiffEditorActive)), ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext));
+const singlePaneTextDiffEditorTitle = ( ContextKeyExpr.and(singlePaneTextDiffEditorActive, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext));
+const singlePaneMultiDiffEditorTitle = ( ContextKeyExpr.and(
+    agentsMultiDiffEditorActive,
+    SinglePaneLayoutEnabledContext,
+    ( IsAuxiliaryWindowContext.toNegated()),
+    IsTopRightEditorGroupContext
+));
+const singlePaneTextEditorTitle = ( ContextKeyExpr.and(agentsTextEditorActive, SinglePaneLayoutEnabledContext, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext));
+const singlePaneDiffEditorTitleVisible = ( ContextKeyExpr.and(( ContextKeyExpr.or(
+    singlePaneChangesEditorTitle,
+    singlePaneTextDiffEditorTitle,
+    singlePaneMultiDiffEditorTitle
+)), MainEditorAreaVisibleContext));
+const singlePaneMultiDiffEditorTitleVisible = ( ContextKeyExpr.and(( ContextKeyExpr.or(singlePaneChangesEditorTitle, singlePaneMultiDiffEditorTitle)), MainEditorAreaVisibleContext));
+const singlePaneTextEditorTitleVisible = ( ContextKeyExpr.and(singlePaneTextEditorTitle, MainEditorAreaVisibleContext));
+function wordWrapToggled(settingId) {
+    return ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${settingId}`, "on")), ( ContextKeyExpr.and(( ContextKeyExpr.equals(`config.${settingId}`, "inherit")), ( ContextKeyExpr.notEquals("config.editor.wordWrap", "off"))))));
+}
+class ToggleSessionsEditorWordWrapAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.toggleEditorWordWrap";
+    }
+    constructor() {
+        super({
+            id: ToggleSessionsEditorWordWrapAction.ID,
+            title: ( localize2(3411, "Word Wrap")),
+            f1: false,
+            menu: [{
+                id: Menus.SessionsEditorTitle,
+                group: "1_diff",
+                order: 20,
+                when: singlePaneTextEditorTitleVisible
+            }, {
+                id: MenuId.EditorTitle,
+                group: "1_diff",
+                order: 20,
+                when: ( ContextKeyExpr.and(agentsTextEditorActive, ( SinglePaneLayoutEnabledContext.negate())))
+            }],
+            toggled: wordWrapToggled(SESSIONS_EDITOR_WORD_WRAP_SETTING)
+        });
+    }
+    async run(accessor, context) {
+        await toggleSessionsWordWrap(accessor, "editor", context);
+    }
+}
+class ToggleSessionsDiffEditorWordWrapAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.toggleDiffEditorWordWrap";
+    }
+    constructor() {
+        super({
+            id: ToggleSessionsDiffEditorWordWrapAction.ID,
+            title: ( localize2(3412, "Word Wrap")),
+            f1: false,
+            menu: [{
+                id: Menus.SessionsEditorTitle,
+                group: "1_diff",
+                order: 20,
+                when: singlePaneMultiDiffEditorTitleVisible
+            }, {
+                id: MenuId.EditorTitle,
+                group: "1_diff",
+                order: 20,
+                when: ( ContextKeyExpr.and(agentsMultiDiffEditorsActive, ( SinglePaneLayoutEnabledContext.negate())))
+            }],
+            toggled: wordWrapToggled(SESSIONS_DIFF_EDITOR_WORD_WRAP_SETTING)
+        });
+    }
+    async run(accessor, context) {
+        await toggleSessionsWordWrap(accessor, "diffEditor", context);
+    }
+}
+async function toggleSessionsWordWrap(accessor, target, context) {
+    const codeEditorService = accessor.get(ICodeEditorService);
+    const optionsService = accessor.get(IDiffEditorOptionsService);
+    const editorService = accessor.get(IEditorService);
+    const activeEditorPane = context ? accessor.get(IEditorGroupsService).getGroup(context.groupId)?.activeEditorPane : editorService.activeEditorPane;
+    const activeControl = activeEditorPane?.getControl();
+    const diffEditor = target === "diffEditor" && isDiffEditor(activeControl) ? activeControl : null;
+    const codeEditor = target === "editor" && isCodeEditor(activeControl) ? activeControl : diffEditor?.getModifiedEditor() ?? null;
+    const wordWrap = target === "editor" ? optionsService.editorWordWrap.get() : optionsService.diffEditorWordWrap.get();
+    const inheritedWordWrap = accessor.get(IConfigurationService).getValue("editor.wordWrap");
+    const isWordWrapEnabled = wordWrap === "on" || wordWrap === "inherit" && inheritedWordWrap !== "off";
+    const editors = codeEditor ? diffEditor ? [diffEditor.getOriginalEditor(), diffEditor.getModifiedEditor()] : [codeEditor] : [];
+    const nextWordWrap = isWordWrapEnabled ? "off" : "on";
+    if (target === "editor") {
+        await optionsService.setEditorWordWrap(nextWordWrap);
+    } else {
+        await optionsService.setDiffEditorWordWrap(nextWordWrap);
+    }
+    let didClearTransientState = false;
+    for (const editor of editors) {
+        const model = editor.getModel();
+        if (model && readTransientState(model, codeEditorService)) {
+            writeTransientState(model, null, codeEditorService);
+            didClearTransientState = true;
+        }
+    }
+    if (didClearTransientState) {
+        diffEditor?.updateOptions({});
+    }
+}
+registerAction2(ToggleSessionsEditorWordWrapAction);
+registerAction2(ToggleSessionsDiffEditorWordWrapAction);
+class ChangesHeaderActionsAction extends Action2 {
+    constructor() {
+        super({
+            id: CHANGES_HEADER_ACTIONS_ID,
+            title: ( localize2(3413, "Changes Actions")),
+            f1: false,
+            menu: {
+                id: Menus.TitleBarSessionMenu,
+                group: "navigation",
+                order: 5,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( IsAuxiliaryWindowContext.toNegated()), ( CustomViewVisibleContext.negate()), SinglePaneLayoutEnabledContext, SessionIsCreatedContext, SessionHasChangesContext))
+            }
+        });
+    }
+    async run() {}
+}
+registerAction2(ChangesHeaderActionsAction);
+class SetChangesListViewModeAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.setChangesListViewMode";
+    }
+    constructor() {
+        super({
+            id: SetChangesListViewModeAction.ID,
+            title: ( localize2(3414, "View as List")),
+            icon: Codicon.listFlat,
+            f1: false,
+            menu: {
+                id: Menus.SessionsEditorTitle,
+                group: "2_viewMode",
+                order: 20,
+                when: ( ContextKeyExpr.and(singlePaneDiffEditorTitle, AuxiliaryBarVisibleContext, ( ChangesContextKeys.ViewMode.isEqualTo(ChangesViewMode.Tree))))
+            }
+        });
+    }
+    run(accessor) {
+        logChangesViewViewModeChange(accessor.get(ITelemetryService), ChangesViewMode.List);
+        accessor.get(IChangesViewService).setViewMode(ChangesViewMode.List);
+    }
+}
+registerAction2(SetChangesListViewModeAction);
+class SetChangesTreeViewModeAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.setChangesTreeViewMode";
+    }
+    constructor() {
+        super({
+            id: SetChangesTreeViewModeAction.ID,
+            title: ( localize2(3415, "View as Tree")),
+            icon: Codicon.listTree,
+            f1: false,
+            menu: {
+                id: Menus.SessionsEditorTitle,
+                group: "2_viewMode",
+                order: 20,
+                when: ( ContextKeyExpr.and(singlePaneDiffEditorTitle, AuxiliaryBarVisibleContext, ( ChangesContextKeys.ViewMode.isEqualTo(ChangesViewMode.List))))
+            }
+        });
+    }
+    run(accessor) {
+        logChangesViewViewModeChange(accessor.get(ITelemetryService), ChangesViewMode.Tree);
+        accessor.get(IChangesViewService).setViewMode(ChangesViewMode.Tree);
+    }
+}
+registerAction2(SetChangesTreeViewModeAction);
+class CollapseAllSessionChangesDiffsAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.collapseAllDiffs";
+    }
+    constructor() {
+        super({
+            id: CollapseAllSessionChangesDiffsAction.ID,
+            title: ( localize2(3416, "Collapse All Diffs")),
+            icon: Codicon.collapseAll,
+            f1: false,
+            menu: {
+                id: Menus.SessionsEditorHeaderLayout,
+                group: "secondary/1_diff",
+                order: 10,
+                when: ( ContextKeyExpr.and(
+                    singlePaneChangesEditorTitleVisible,
+                    ContextKeyExpr.not("multiDiffEditorAllCollapsed")
+                ))
+            }
+        });
+    }
+    run(accessor) {
+        const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+        if (activeEditorPane instanceof SessionChangesEditor) {
+            activeEditorPane.collapseAllDiffs();
+        }
+    }
+}
+registerAction2(CollapseAllSessionChangesDiffsAction);
+class ExpandAllSessionChangesDiffsAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.expandAllDiffs";
+    }
+    constructor() {
+        super({
+            id: ExpandAllSessionChangesDiffsAction.ID,
+            title: ( localize2(3417, "Expand All Diffs")),
+            icon: Codicon.expandAll,
+            f1: false,
+            menu: {
+                id: Menus.SessionsEditorHeaderLayout,
+                group: "secondary/1_diff",
+                order: 10,
+                when: ( ContextKeyExpr.and(singlePaneChangesEditorActive, ( IsAuxiliaryWindowContext.toNegated()), IsTopRightEditorGroupContext, MainEditorAreaVisibleContext, ( ContextKeyExpr.has("multiDiffEditorAllCollapsed"))))
+            }
+        });
+    }
+    run(accessor) {
+        const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+        if (activeEditorPane instanceof SessionChangesEditor) {
+            activeEditorPane.expandAllDiffs();
+        }
+    }
+}
+registerAction2(ExpandAllSessionChangesDiffsAction);
+MenuRegistry.appendMenuItem(Menus.SessionsEditorHeaderLayout, {
+    submenu: Menus.SessionsDiffEditorView,
+    title: ( localize(3418, "Diff View")),
+    group: "secondary/1_diff",
+    order: 20,
+    when: singlePaneDiffEditorTitleVisible
+});
+MenuRegistry.appendMenuItem(MenuId.EditorTitle, {
+    submenu: Menus.SessionsDiffEditorView,
+    title: ( localize(3418, "Diff View")),
+    group: "1_diff",
+    order: 10,
+    when: ( ContextKeyExpr.and(agentsDiffEditorActive, ( SinglePaneLayoutEnabledContext.negate())))
+});
+MenuRegistry.appendMenuItem(Menus.SessionsDiffEditorView, {
+    command: {
+        id: SET_DIFF_VIEW_MODE_INLINE,
+        title: ( localize(3419, "Inline")),
+        toggled: ( SessionsDiffViewModeContext.isEqualTo("inline"))
+    },
+    group: "1_view",
+    order: 1
+});
+MenuRegistry.appendMenuItem(Menus.SessionsDiffEditorView, {
+    command: {
+        id: SET_DIFF_VIEW_MODE_SIDE_BY_SIDE,
+        title: ( localize(3420, "Side by Side")),
+        toggled: ( SessionsDiffViewModeContext.isEqualTo("sideBySide"))
+    },
+    group: "1_view",
+    order: 2
+});
+for (const [title, when] of [[( localize(3421, "Automatic (Currently Side by Side)")), EditorContextKeys.diffEditorAutomaticRenderSideBySide], [( localize(3422, "Automatic (Currently Inline)")), ( EditorContextKeys.diffEditorAutomaticRenderSideBySide.toNegated())]]) {
+    MenuRegistry.appendMenuItem(Menus.SessionsDiffEditorView, {
+        command: {
+            id: SET_DIFF_VIEW_MODE_AUTOMATIC,
+            title,
+            toggled: ( ContextKeyExpr.and(( SessionsDiffViewModeContext.isEqualTo("automatic")), ( EditorContextKeys.diffEditorTemporaryInlineMode.toNegated())))
+        },
+        group: "1_view",
+        order: 3,
+        when
+    });
+}
+MenuRegistry.appendMenuItem(Menus.SessionsDiffEditorView, {
+    command: {
+        id: DIFF_VIEW_MODE_INLINE_TEMPORARY,
+        title: ( localize(3423, "Inline (Temporary)")),
+        toggled: EditorContextKeys.diffEditorTemporaryInlineMode,
+        precondition: ( ContextKeyExpr.false())
+    },
+    group: "1_view",
+    order: 4,
+    when: EditorContextKeys.diffEditorTemporaryInlineMode
+});
+MenuRegistry.appendMenuItem(MenuId.CommandPalette, {
+    command: {
+        id: TOGGLE_DIFF_SIDE_BY_SIDE,
+        title: ( localize2(3424, "Toggle Preferred Diff View")),
+        category: ( localize2(3425, "Changes"))
+    },
+    when: agentsDiffEditorActive
+});
+class OpenChangesAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.openChanges";
+    }
+    constructor() {
+        super({
+            id: OpenChangesAction.ID,
+            title: ( localize2(3426, "Open Changes")),
+            icon: Codicon.gitCompare,
+            f1: false
+        });
+    }
+    async run(accessor, _sessionResource, _ref, ...resources) {
+        const editorService = accessor.get(IEditorService);
+        const changesViewService = accessor.get(IChangesViewService);
+        const sessionChanges = changesViewService.activeSessionChangesObs.get();
+        const changes = sessionChanges?.filter(change => ( resources.some(resource => isEqual(change.modifiedUri ?? change.originalUri, resource)))) ?? [];
+        await Promise.all(changes.map(change => editorService.openEditor({
+            original: {
+                resource: change.originalUri
+            },
+            modified: {
+                resource: change.modifiedUri
+            }
+        })));
+    }
+}
+registerAction2(OpenChangesAction);
+const openSingleFileDiffEnabled = ( ContextKeyExpr.equals(`config.${SESSIONS_CHANGES_OPEN_SINGLE_FILE_DIFF_SETTING}`, true));
+class OpenFileAction extends Action2 {
+    static {
+        this.ID = "workbench.action.agentSessions.openFile";
+    }
+    constructor() {
+        super({
+            id: OpenFileAction.ID,
+            title: ( localize2(3427, "Open File")),
+            icon: Codicon.goToFile,
+            f1: false,
+            menu: [
+            {
+                id: MenuId.AgentsChangeInlineToolbar,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( ChangesContextKeys.ChangeKind.isEqualTo("file")), openSingleFileDiffEnabled))
+            },
+            {
+                id: MenuId.AgentsChangeInlineToolbar,
+                group: "navigation",
+                order: 1,
+                alt: {
+                    id: OpenChangesAction.ID,
+                    title: ( localize2(3426, "Open Changes")),
+                    icon: Codicon.gitCompare
+                },
+                when: ( ContextKeyExpr.and(IsSessionsWindowContext, ( ChangesContextKeys.ChangeKind.isEqualTo("file")), ( openSingleFileDiffEnabled.negate())))
+            }]
+        });
+    }
+    async run(accessor, _sessionResource, _ref, ...resources) {
+        const editorService = accessor.get(IEditorService);
+        await Promise.all(resources.map(resource => editorService.openEditor({
+            resource
+        })));
+    }
+}
+registerAction2(OpenFileAction);

package/vscode/src/vs/sessions/contrib/changes/browser/changesetReviewActions.d.ts

@@ -0,0 +1,6 @@
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+export declare class ChangesetReviewAction extends Action2 {
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): void;
+}

package/vscode/src/vs/sessions/contrib/changes/browser/changesetReviewActions.js

@@ -0,0 +1,58 @@
+
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, MenuId, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IChangesViewService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/common/changesViewService.service';
+import { getChangesEditorFileStats } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/changesEditorLabels';
+import { SessionChangesFileResourceContext } from './changesMultiDiffSourceResolver.js';
+import { ChangesetReviewSupportContext, ChangesetReviewedFilesContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/changesViewService';
+import { CHANGESET_REVIEW_ACTION_ID, SessionChangesEditor } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/changes/browser/sessionChangesEditor';
+
+class ChangesetReviewAction extends Action2 {
+    constructor() {
+        super({
+            id: CHANGESET_REVIEW_ACTION_ID,
+            title: ( localize(3428, "Viewed")),
+            f1: false,
+            toggled: {
+                condition: ContextKeyExpr.in(SessionChangesFileResourceContext.key, ChangesetReviewedFilesContext.key)
+            },
+            menu: {
+                id: MenuId.MultiDiffEditorFileToolbar,
+                when: ( ContextKeyExpr.and(( ChangesetReviewSupportContext.isEqualTo(true)), ( ContextKeyExpr.equals("resourceScheme", "changes-multi-diff-source")))),
+                group: "navigation",
+                order: 100
+            }
+        });
+    }
+    run(accessor, ...args) {
+        const resource = args[0];
+        if (!(resource instanceof URI)) {
+            return;
+        }
+        const changesViewService = accessor.get(IChangesViewService);
+        if (changesViewService.activeSessionChangesetObs.get()?.capabilities?.review !== true) {
+            return;
+        }
+        const activeSessionChanges = changesViewService.activeSessionChangesObs.get();
+        if (!getChangesEditorFileStats(resource, activeSessionChanges)) {
+            return;
+        }
+        const activeEditorPane = accessor.get(IEditorService).activeEditorPane;
+        const reviewedFiles = activeSessionChanges.filter(change => change.reviewed).map(change => change.modifiedUri?.toString() ?? change.originalUri?.toString()).filter(uri => uri !== undefined);
+        const review = !reviewedFiles.includes(( resource.toString()));
+        if (activeEditorPane instanceof SessionChangesEditor) {
+            if (review) {
+                activeEditorPane.collapse(resource);
+            } else {
+                activeEditorPane.expand(resource);
+            }
+        }
+        changesViewService.setChangesetFilesReviewState([resource], review);
+    }
+}
+registerAction2(ChangesetReviewAction);
+
+export { ChangesetReviewAction };

package/vscode/src/vs/sessions/contrib/changes/browser/media/changesActions.css

@@ -0,0 +1,11 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.monaco-action-bar .action-item.changes-commit-action .action-label {
+	align-items: center;
+	gap: var(--vscode-spacing-size40);
+	font-size: var(--vscode-fontSize-label1);
+	line-height: 16px;
+}

package/vscode/src/vs/sessions/contrib/changes/browser/sessionSyncChanges.d.ts

@@ -0,0 +1,24 @@
+import { ActionViewItem, IActionViewItemOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems";
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IActionViewItemService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ISessionContext } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service";
+import { ISessionsPartService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsPartService.service";
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+export declare class SessionSyncChangesActionViewItem extends ActionViewItem {
+    private readonly sessionContext;
+    private readonly sessionsPartService;
+    private _running;
+    private _countsLabel;
+    private _tooltip;
+    private _icon;
+    constructor(action: IAction, options: IActionViewItemOptions, sessionContext: ISessionContext, sessionsPartService: ISessionsPartService);
+    protected getTooltip(): string | undefined;
+    protected updateLabel(): void;
+    dispose(): void;
+}
+export declare class SessionSyncChangesContribution extends Disposable implements IWorkbenchContribution {
+    static readonly ID = "workbench.contrib.sessions.syncChanges";
+    constructor(sessionsService: ISessionsService, actionViewItemService: IActionViewItemService);
+}