@codingame/monaco-vscode-katex-common 24.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingActions.js

@@ -0,0 +1,721 @@
+
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isCodeEditor } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser';
+import { Position } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/position';
+import { EditorContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/editorContextKeys';
+import { isLocation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { ILanguageFeaturesService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/languageFeatures.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { localize2, localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, registerAction2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+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 { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { isChatViewTitleActionContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatActions';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { chatEditingWidgetFileStateContextKey, ModifiedFileEntryState, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, chatEditingResourceContextKey, decidedChatEditingResourceContextKey, applyingChatEditsFailedContextKey, hasUndecidedChatEditingResourceContextKey, hasAppliedChatEditsContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { isRequestVM, isResponseVM, isChatTreeItem } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { ChatAgentLocation, ChatConfiguration, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+
+class EditingSessionAction extends Action2 {
+    constructor(opts) {
+        super({
+            category: CHAT_CATEGORY,
+            ...opts
+        });
+    }
+    run(accessor, ...args) {
+        const context = getEditingSessionContext(accessor, args);
+        if (!context || !context.editingSession) {
+            return;
+        }
+        return this.runEditingSessionAction(accessor, context.editingSession, context.chatWidget, ...args);
+    }
+}
+function getEditingSessionContext(accessor, args) {
+    const arg0 = args.at(0);
+    const context = isChatViewTitleActionContext(arg0) ? arg0 : undefined;
+    const chatWidgetService = accessor.get(IChatWidgetService);
+    const chatEditingService = accessor.get(IChatEditingService);
+    let chatWidget = context ? chatWidgetService.getWidgetBySessionResource(context.sessionResource) : undefined;
+    if (!chatWidget) {
+        chatWidget = chatWidgetService.lastFocusedWidget ?? chatWidgetService.getWidgetsByLocations(ChatAgentLocation.Chat).find(w => w.supportsChangingModes);
+    }
+    if (!chatWidget?.viewModel) {
+        return;
+    }
+    const editingSession = chatEditingService.getEditingSession(chatWidget.viewModel.model.sessionResource);
+    return { editingSession, chatWidget };
+}
+class WorkingSetAction extends EditingSessionAction {
+    runEditingSessionAction(accessor, editingSession, chatWidget, ...args) {
+        const uris = [];
+        if (URI.isUri(args[0])) {
+            uris.push(args[0]);
+        }
+        else if (chatWidget) {
+            uris.push(...chatWidget.input.selectedElements);
+        }
+        if (!uris.length) {
+            return;
+        }
+        return this.runWorkingSetAction(accessor, editingSession, chatWidget, ...uris);
+    }
+}
+registerAction2(class OpenFileInDiffAction extends WorkingSetAction {
+    constructor() {
+        super({
+            id: 'chatEditing.openFileInDiff',
+            title: ( localize2(5186, 'Open Changes in Diff Editor')),
+            icon: Codicon.diffSingle,
+            menu: [{
+                    id: MenuId.ChatEditingWidgetModifiedFilesToolbar,
+                    when: ( ContextKeyExpr.equals(chatEditingWidgetFileStateContextKey.key, ModifiedFileEntryState.Modified)),
+                    order: 2,
+                    group: 'navigation'
+                }],
+        });
+    }
+    async runWorkingSetAction(accessor, currentEditingSession, _chatWidget, ...uris) {
+        const editorService = accessor.get(IEditorService);
+        for (const uri of uris) {
+            let pane = editorService.activeEditorPane;
+            if (!pane) {
+                pane = await editorService.openEditor({ resource: uri });
+            }
+            if (!pane) {
+                return;
+            }
+            const editedFile = currentEditingSession.getEntry(uri);
+            editedFile?.getEditorIntegration(pane).toggleDiff(undefined, true);
+        }
+    }
+});
+registerAction2(class AcceptAction extends WorkingSetAction {
+    constructor() {
+        super({
+            id: 'chatEditing.acceptFile',
+            title: ( localize2(5187, 'Keep')),
+            icon: Codicon.check,
+            menu: [{
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('resourceScheme', CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME)), ContextKeyExpr.notIn(chatEditingResourceContextKey.key, decidedChatEditingResourceContextKey.key))),
+                    id: MenuId.MultiDiffEditorFileToolbar,
+                    order: 0,
+                    group: 'navigation',
+                }, {
+                    id: MenuId.ChatEditingWidgetModifiedFilesToolbar,
+                    when: ( ContextKeyExpr.equals(chatEditingWidgetFileStateContextKey.key, ModifiedFileEntryState.Modified)),
+                    order: 0,
+                    group: 'navigation'
+                }],
+        });
+    }
+    async runWorkingSetAction(accessor, currentEditingSession, chatWidget, ...uris) {
+        await currentEditingSession.accept(...uris);
+    }
+});
+registerAction2(class DiscardAction extends WorkingSetAction {
+    constructor() {
+        super({
+            id: 'chatEditing.discardFile',
+            title: ( localize2(5188, 'Undo')),
+            icon: Codicon.discard,
+            menu: [{
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('resourceScheme', CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME)), ContextKeyExpr.notIn(chatEditingResourceContextKey.key, decidedChatEditingResourceContextKey.key))),
+                    id: MenuId.MultiDiffEditorFileToolbar,
+                    order: 2,
+                    group: 'navigation',
+                }, {
+                    id: MenuId.ChatEditingWidgetModifiedFilesToolbar,
+                    when: ( ContextKeyExpr.equals(chatEditingWidgetFileStateContextKey.key, ModifiedFileEntryState.Modified)),
+                    order: 1,
+                    group: 'navigation'
+                }],
+        });
+    }
+    async runWorkingSetAction(accessor, currentEditingSession, chatWidget, ...uris) {
+        await currentEditingSession.reject(...uris);
+    }
+});
+class ChatEditingAcceptAllAction extends EditingSessionAction {
+    constructor() {
+        super({
+            id: 'chatEditing.acceptAllFiles',
+            title: ( localize(5189, 'Keep')),
+            icon: Codicon.check,
+            tooltip: ( localize(5190, 'Keep All Edits')),
+            precondition: hasUndecidedChatEditingResourceContextKey,
+            keybinding: {
+                primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                when: ( ContextKeyExpr.and(hasUndecidedChatEditingResourceContextKey, ChatContextKeys.inChatInput)),
+                weight: KeybindingWeight.WorkbenchContrib,
+            },
+            menu: [
+                {
+                    id: MenuId.ChatEditingWidgetToolbar,
+                    group: 'navigation',
+                    order: 0,
+                    when: ( ContextKeyExpr.and(( applyingChatEditsFailedContextKey.negate()), ( ContextKeyExpr.and(hasUndecidedChatEditingResourceContextKey))))
+                }
+            ]
+        });
+    }
+    async runEditingSessionAction(accessor, editingSession, chatWidget, ...args) {
+        await editingSession.accept();
+    }
+}
+registerAction2(ChatEditingAcceptAllAction);
+class ChatEditingDiscardAllAction extends EditingSessionAction {
+    constructor() {
+        super({
+            id: 'chatEditing.discardAllFiles',
+            title: ( localize(5191, 'Undo')),
+            icon: Codicon.discard,
+            tooltip: ( localize(5192, 'Undo All Edits')),
+            precondition: hasUndecidedChatEditingResourceContextKey,
+            menu: [
+                {
+                    id: MenuId.ChatEditingWidgetToolbar,
+                    group: 'navigation',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(( applyingChatEditsFailedContextKey.negate()), hasUndecidedChatEditingResourceContextKey))
+                }
+            ],
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    hasUndecidedChatEditingResourceContextKey,
+                    ChatContextKeys.inChatInput,
+                    ( ChatContextKeys.inputHasText.negate())
+                )),
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod.CtrlCmd | KeyCode.Backspace,
+            },
+        });
+    }
+    async runEditingSessionAction(accessor, editingSession, chatWidget, ...args) {
+        await discardAllEditsWithConfirmation(accessor, editingSession);
+    }
+}
+registerAction2(ChatEditingDiscardAllAction);
+async function discardAllEditsWithConfirmation(accessor, currentEditingSession) {
+    const dialogService = accessor.get(IDialogService);
+    const entries = currentEditingSession.entries.get();
+    if (entries.length > 0) {
+        const confirmation = await dialogService.confirm({
+            title: ( localize(5193, "Undo all edits?")),
+            message: entries.length === 1
+                ? ( localize(
+                5194,
+                "This will undo changes made in {0}. Do you want to proceed?",
+                basename(entries[0].modifiedURI)
+            ))
+                : ( localize(
+                5195,
+                "This will undo changes made in {0} files. Do you want to proceed?",
+                entries.length
+            )),
+            primaryButton: ( localize(5196, "Yes")),
+            type: 'info'
+        });
+        if (!confirmation.confirmed) {
+            return false;
+        }
+    }
+    await currentEditingSession.reject();
+    return true;
+}
+class ChatEditingShowChangesAction extends EditingSessionAction {
+    static { this.ID = 'chatEditing.viewChanges'; }
+    static { this.LABEL = ( localize(5197, 'View All Edits')); }
+    constructor() {
+        super({
+            id: ChatEditingShowChangesAction.ID,
+            title: { value: ChatEditingShowChangesAction.LABEL, original: ChatEditingShowChangesAction.LABEL },
+            tooltip: ChatEditingShowChangesAction.LABEL,
+            f1: true,
+            icon: Codicon.diffMultiple,
+            precondition: hasUndecidedChatEditingResourceContextKey,
+            menu: [
+                {
+                    id: MenuId.ChatEditingWidgetToolbar,
+                    group: 'navigation',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(( applyingChatEditsFailedContextKey.negate()), ( ContextKeyExpr.and(hasAppliedChatEditsContextKey, hasUndecidedChatEditingResourceContextKey))))
+                }
+            ],
+        });
+    }
+    async runEditingSessionAction(accessor, editingSession, chatWidget, ...args) {
+        await editingSession.show();
+    }
+}
+registerAction2(ChatEditingShowChangesAction);
+class ViewAllSessionChangesAction extends Action2 {
+    static { this.ID = 'chatEditing.viewAllSessionChanges'; }
+    constructor() {
+        super({
+            id: ViewAllSessionChangesAction.ID,
+            title: ( localize2(5198, 'View All Changes')),
+            icon: Codicon.diffMultiple,
+            category: CHAT_CATEGORY,
+            precondition: ChatContextKeys.hasAgentSessionChanges,
+            menu: [
+                {
+                    id: MenuId.ChatEditingSessionChangesToolbar,
+                    group: 'navigation',
+                    order: 10,
+                    when: ChatContextKeys.hasAgentSessionChanges
+                }
+            ],
+        });
+    }
+    async run(accessor, sessionResource) {
+        const agentSessionsService = accessor.get(IAgentSessionsService);
+        const commandService = accessor.get(ICommandService);
+        if (!URI.isUri(sessionResource)) {
+            return;
+        }
+        const session = agentSessionsService.getSession(sessionResource);
+        const changes = session?.changes;
+        if (!(changes instanceof Array)) {
+            return;
+        }
+        const resources = ( changes
+            .filter(d => d.originalUri)
+            .map(d => ({ originalUri: d.originalUri, modifiedUri: d.modifiedUri })));
+        if (resources.length > 0) {
+            await commandService.executeCommand('_workbench.openMultiDiffEditor', {
+                multiDiffSourceUri: sessionResource.with({ scheme: sessionResource.scheme + '-worktree-changes' }),
+                title: ( localize(5199, 'All Session Changes')),
+                resources,
+            });
+        }
+    }
+}
+registerAction2(ViewAllSessionChangesAction);
+async function restoreSnapshotWithConfirmation(accessor, item) {
+    const configurationService = accessor.get(IConfigurationService);
+    const dialogService = accessor.get(IDialogService);
+    const chatWidgetService = accessor.get(IChatWidgetService);
+    const widget = chatWidgetService.getWidgetBySessionResource(item.sessionResource);
+    const chatService = accessor.get(IChatService);
+    const chatModel = chatService.getSession(item.sessionResource);
+    if (!chatModel) {
+        return;
+    }
+    const session = chatModel.editingSession;
+    if (!session) {
+        return;
+    }
+    const requestId = isRequestVM(item) ? item.id :
+        isResponseVM(item) ? item.requestId : undefined;
+    if (requestId) {
+        const chatRequests = chatModel.getRequests();
+        const itemIndex = chatRequests.findIndex(request => request.id === requestId);
+        const editsToUndo = chatRequests.length - itemIndex;
+        const requestsToRemove = chatRequests.slice(itemIndex);
+        const requestIdsToRemove = ( new Set(( requestsToRemove.map(request => request.id))));
+        const entriesModifiedInRequestsToRemove = session.entries.get().filter((entry) => ( requestIdsToRemove.has(entry.lastModifyingRequestId))) ?? [];
+        const shouldPrompt = entriesModifiedInRequestsToRemove.length > 0 && configurationService.getValue('chat.editing.confirmEditRequestRemoval') === true;
+        let message;
+        if (editsToUndo === 1) {
+            if (entriesModifiedInRequestsToRemove.length === 1) {
+                message = ( localize(
+                    5200,
+                    "This will remove your last request and undo the edits made to {0}. Do you want to proceed?",
+                    basename(entriesModifiedInRequestsToRemove[0].modifiedURI)
+                ));
+            }
+            else {
+                message = ( localize(
+                    5201,
+                    "This will remove your last request and undo edits made to {0} files in your working set. Do you want to proceed?",
+                    entriesModifiedInRequestsToRemove.length
+                ));
+            }
+        }
+        else {
+            if (entriesModifiedInRequestsToRemove.length === 1) {
+                message = ( localize(
+                    5202,
+                    "This will remove all subsequent requests and undo edits made to {0}. Do you want to proceed?",
+                    basename(entriesModifiedInRequestsToRemove[0].modifiedURI)
+                ));
+            }
+            else {
+                message = ( localize(
+                    5203,
+                    "This will remove all subsequent requests and undo edits made to {0} files in your working set. Do you want to proceed?",
+                    entriesModifiedInRequestsToRemove.length
+                ));
+            }
+        }
+        const confirmation = shouldPrompt
+            ? await dialogService.confirm({
+                title: editsToUndo === 1
+                    ? ( localize(5204, "Do you want to undo your last edit?"))
+                    : ( localize(5205, "Do you want to undo {0} edits?", editsToUndo)),
+                message: message,
+                primaryButton: ( localize(5206, "Yes")),
+                checkbox: { label: ( localize(5207, "Don't ask again")), checked: false },
+                type: 'info'
+            })
+            : { confirmed: true };
+        if (!confirmation.confirmed) {
+            widget?.viewModel?.model.setCheckpoint(undefined);
+            return;
+        }
+        if (confirmation.checkboxChecked) {
+            await configurationService.updateValue('chat.editing.confirmEditRequestRemoval', false);
+        }
+        const snapshotRequestId = chatRequests[itemIndex].id;
+        await session.restoreSnapshot(snapshotRequestId, undefined);
+    }
+}
+registerAction2(class RemoveAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.undoEdits',
+            title: ( localize2(5208, "Undo Requests")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.discard,
+            keybinding: {
+                primary: KeyCode.Delete,
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyCode.Backspace,
+                },
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ( EditorContextKeys.textInputFocus.negate()))),
+                weight: KeybindingWeight.WorkbenchContrib,
+            },
+            menu: [
+                {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(( ( ContextKeyExpr.equals(`config.${ChatConfiguration.EditRequests}`, 'input')).negate()), ( ContextKeyExpr.equals(`config.${ChatConfiguration.CheckpointsEnabled}`, false)), ( ChatContextKeys.lockedToCodingAgent.negate()))),
+                }
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        let item = args[0];
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const configurationService = accessor.get(IConfigurationService);
+        const widget = (isChatTreeItem(item) && chatWidgetService.getWidgetBySessionResource(item.sessionResource)) || chatWidgetService.lastFocusedWidget;
+        if (!isResponseVM(item) && !isRequestVM(item)) {
+            item = widget?.getFocus();
+        }
+        if (!item) {
+            return;
+        }
+        await restoreSnapshotWithConfirmation(accessor, item);
+        if (isRequestVM(item) && configurationService.getValue('chat.undoRequests.restoreInput')) {
+            widget?.focusInput();
+            widget?.input.setValue(item.messageText, false);
+        }
+    }
+});
+registerAction2(class RestoreCheckpointAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.restoreCheckpoint',
+            title: ( localize2(5209, "Restore Checkpoint")),
+            tooltip: ( localize2(5210, "Restores workspace and chat to this point")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            keybinding: {
+                primary: KeyCode.Delete,
+                mac: {
+                    primary: KeyMod.CtrlCmd | KeyCode.Backspace,
+                },
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ( EditorContextKeys.textInputFocus.negate()))),
+                weight: KeybindingWeight.WorkbenchContrib,
+            },
+            menu: [
+                {
+                    id: MenuId.ChatMessageCheckpoint,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(ChatContextKeys.isRequest, ( ChatContextKeys.lockedToCodingAgent.negate())))
+                }
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        let item = args[0];
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = (isChatTreeItem(item) && chatWidgetService.getWidgetBySessionResource(item.sessionResource)) || chatWidgetService.lastFocusedWidget;
+        if (!isResponseVM(item) && !isRequestVM(item)) {
+            item = widget?.getFocus();
+        }
+        if (!item) {
+            return;
+        }
+        if (isRequestVM(item)) {
+            widget?.focusInput();
+            widget?.input.setValue(item.messageText, false);
+        }
+        widget?.viewModel?.model.setCheckpoint(item.id);
+        await restoreSnapshotWithConfirmation(accessor, item);
+    }
+});
+registerAction2(class RestoreLastCheckpoint extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.restoreLastCheckpoint',
+            title: ( localize2(5211, "Restore to Last Checkpoint")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.discard,
+            menu: [
+                {
+                    id: MenuId.ChatMessageFooter,
+                    group: 'navigation',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(
+                        ContextKeyExpr.in(ChatContextKeys.itemId.key, ChatContextKeys.lastItemId.key),
+                        ( ContextKeyExpr.equals(`config.${ChatConfiguration.CheckpointsEnabled}`, true)),
+                        ( ChatContextKeys.lockedToCodingAgent.negate())
+                    )),
+                }
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        let item = args[0];
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const chatService = accessor.get(IChatService);
+        const widget = (isChatTreeItem(item) && chatWidgetService.getWidgetBySessionResource(item.sessionResource)) || chatWidgetService.lastFocusedWidget;
+        if (!isResponseVM(item) && !isRequestVM(item)) {
+            item = widget?.getFocus();
+        }
+        if (!item) {
+            return;
+        }
+        const chatModel = chatService.getSession(item.sessionResource);
+        if (!chatModel) {
+            return;
+        }
+        const session = chatModel.editingSession;
+        if (!session) {
+            return;
+        }
+        await restoreSnapshotWithConfirmation(accessor, item);
+        if (isResponseVM(item)) {
+            widget?.viewModel?.model.setCheckpoint(item.requestId);
+            const request = chatModel.getRequests().find(request => request.id === item.requestId);
+            if (request) {
+                widget?.focusInput();
+                widget?.input.setValue(request.message.text, false);
+            }
+        }
+    }
+});
+registerAction2(class EditAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.chat.editRequests',
+            title: ( localize2(5212, "Edit Request")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            icon: Codicon.edit,
+            keybinding: {
+                primary: KeyCode.Enter,
+                when: ( ContextKeyExpr.and(ChatContextKeys.inChatSession, ( EditorContextKeys.textInputFocus.negate()))),
+                weight: KeybindingWeight.WorkbenchContrib,
+            },
+            menu: [
+                {
+                    id: MenuId.ChatMessageTitle,
+                    group: 'navigation',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${ChatConfiguration.EditRequests}`, 'hover')), ( ContextKeyExpr.equals(`config.${ChatConfiguration.EditRequests}`, 'input'))))))
+                }
+            ]
+        });
+    }
+    async run(accessor, ...args) {
+        let item = args[0];
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = (isChatTreeItem(item) && chatWidgetService.getWidgetBySessionResource(item.sessionResource)) || chatWidgetService.lastFocusedWidget;
+        if (!isResponseVM(item) && !isRequestVM(item)) {
+            item = widget?.getFocus();
+        }
+        if (!item) {
+            return;
+        }
+        if (isRequestVM(item)) {
+            widget?.startEditing(item.id);
+        }
+    }
+});
+registerAction2(class OpenWorkingSetHistoryAction extends Action2 {
+    static { this.id = 'chat.openFileUpdatedBySnapshot'; }
+    constructor() {
+        super({
+            id: OpenWorkingSetHistoryAction.id,
+            title: ( localize(5213, "Open File")),
+            menu: [{
+                    id: MenuId.ChatEditingCodeBlockContext,
+                    group: 'navigation',
+                    order: 0,
+                },]
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        if (!context?.sessionResource) {
+            return;
+        }
+        const editorService = accessor.get(IEditorService);
+        await editorService.openEditor({ resource: context.uri });
+    }
+});
+registerAction2(class OpenWorkingSetHistoryAction extends Action2 {
+    static { this.id = 'chat.openFileSnapshot'; }
+    constructor() {
+        super({
+            id: OpenWorkingSetHistoryAction.id,
+            title: ( localize(5214, "Open File Snapshot")),
+            menu: [{
+                    id: MenuId.ChatEditingCodeBlockContext,
+                    group: 'navigation',
+                    order: 1,
+                },]
+        });
+    }
+    async run(accessor, ...args) {
+        const context = args[0];
+        if (!context?.sessionResource) {
+            return;
+        }
+        const chatService = accessor.get(IChatService);
+        const chatEditingService = accessor.get(IChatEditingService);
+        const editorService = accessor.get(IEditorService);
+        const chatModel = chatService.getSession(context.sessionResource);
+        if (!chatModel) {
+            return;
+        }
+        const snapshot = chatEditingService.getEditingSession(chatModel.sessionResource)?.getSnapshotUri(context.requestId, context.uri, context.stopId);
+        if (snapshot) {
+            const editor = await editorService.openEditor({ resource: snapshot, label: ( localize(5215, '{0} (Snapshot)', basename(context.uri))), options: { activation: EditorActivation.ACTIVATE } });
+            if (isCodeEditor(editor)) {
+                editor.updateOptions({ readOnly: true });
+            }
+        }
+    }
+});
+registerAction2(class ResolveSymbolsContextAction extends EditingSessionAction {
+    constructor() {
+        super({
+            id: 'workbench.action.edits.addFilesFromReferences',
+            title: ( localize2(5216, "Add Files From References")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            menu: {
+                id: MenuId.ChatInputSymbolAttachmentContext,
+                group: 'navigation',
+                order: 1,
+                when: ( ContextKeyExpr.and(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Ask)), EditorContextKeys.hasReferenceProvider))
+            }
+        });
+    }
+    async runEditingSessionAction(accessor, editingSession, chatWidget, ...args) {
+        if (args.length === 0 || !isLocation(args[0])) {
+            return;
+        }
+        const textModelService = accessor.get(ITextModelService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const symbol = args[0];
+        const modelReference = await textModelService.createModelReference(symbol.uri);
+        const textModel = modelReference.object.textEditorModel;
+        if (!textModel) {
+            return;
+        }
+        const position = ( new Position(symbol.range.startLineNumber, symbol.range.startColumn));
+        const [references, definitions, implementations] = await Promise.all([
+            this.getReferences(position, textModel, languageFeaturesService),
+            this.getDefinitions(position, textModel, languageFeaturesService),
+            this.getImplementations(position, textModel, languageFeaturesService)
+        ]);
+        const attachments = [];
+        for (const reference of [...definitions, ...implementations, ...references]) {
+            attachments.push(chatWidget.attachmentModel.asFileVariableEntry(reference.uri));
+        }
+        chatWidget.attachmentModel.addContext(...attachments);
+    }
+    async getReferences(position, textModel, languageFeaturesService) {
+        const referenceProviders = languageFeaturesService.referenceProvider.all(textModel);
+        const references = await Promise.all(( referenceProviders.map(async (referenceProvider) => {
+            return (await referenceProvider.provideReferences(textModel, position, { includeDeclaration: true }, CancellationToken.None)) ?? [];
+        })));
+        return references.flat();
+    }
+    async getDefinitions(position, textModel, languageFeaturesService) {
+        const definitionProviders = languageFeaturesService.definitionProvider.all(textModel);
+        const definitions = await Promise.all(( definitionProviders.map(async (definitionProvider) => {
+            return (await definitionProvider.provideDefinition(textModel, position, CancellationToken.None)) ?? [];
+        })));
+        return definitions.flat();
+    }
+    async getImplementations(position, textModel, languageFeaturesService) {
+        const implementationProviders = languageFeaturesService.implementationProvider.all(textModel);
+        const implementations = await Promise.all(( implementationProviders.map(async (implementationProvider) => {
+            return (await implementationProvider.provideImplementation(textModel, position, CancellationToken.None)) ?? [];
+        })));
+        return implementations.flat();
+    }
+});
+class ViewPreviousEditsAction extends EditingSessionAction {
+    static { this.Id = 'chatEditing.viewPreviousEdits'; }
+    static { this.Label = ( localize(5217, 'View Previous Edits')); }
+    constructor() {
+        super({
+            id: ViewPreviousEditsAction.Id,
+            title: { value: ViewPreviousEditsAction.Label, original: ViewPreviousEditsAction.Label },
+            tooltip: ViewPreviousEditsAction.Label,
+            f1: true,
+            icon: Codicon.diffMultiple,
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( hasUndecidedChatEditingResourceContextKey.negate()))),
+            menu: [
+                {
+                    id: MenuId.ChatEditingWidgetToolbar,
+                    group: 'navigation',
+                    order: 4,
+                    when: ( ContextKeyExpr.and(( applyingChatEditsFailedContextKey.negate()), ( ContextKeyExpr.and(hasAppliedChatEditsContextKey, ( hasUndecidedChatEditingResourceContextKey.negate())))))
+                }
+            ],
+        });
+    }
+    async runEditingSessionAction(accessor, editingSession, chatWidget, ...args) {
+        await editingSession.show(true);
+    }
+}
+registerAction2(ViewPreviousEditsAction);
+CommandsRegistry.registerCommand('_chat.editSessions.accept', async (accessor, resources) => {
+    if (resources.length === 0) {
+        return;
+    }
+    const uris = ( resources.map(resource => URI.revive(resource)));
+    const chatEditingService = accessor.get(IChatEditingService);
+    for (const editingSession of chatEditingService.editingSessionsObs.get()) {
+        await editingSession.accept(...uris);
+    }
+});
+
+export { ChatEditingAcceptAllAction, ChatEditingDiscardAllAction, ChatEditingShowChangesAction, EditingSessionAction, ViewAllSessionChangesAction, ViewPreviousEditsAction, discardAllEditsWithConfirmation, getEditingSessionContext };