@codingame/monaco-vscode-api 13.1.7 → 14.0.1

package/vscode/src/vs/workbench/contrib/chat/browser/chat.d.ts

@@ -0,0 +1,136 @@
+import { Event } from "../../../../base/common/event.js";
+import { URI } from "../../../../base/common/uri.js";
+import { ICodeEditor } from "../../../../editor/browser/editorBrowser.js";
+import { Selection } from "../../../../editor/common/core/selection.js";
+import { MenuId } from "../../../../platform/actions/common/actions.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IViewDescriptorService } from "../../../common/views.service.js";
+import { IWorkbenchLayoutService } from "../../../services/layout/browser/layoutService.service.js";
+import { IViewsService } from "../../../services/views/common/viewsService.service.js";
+import { ChatAgentLocation, IChatAgentCommand, IChatAgentData } from "../common/chatAgents.js";
+import { IChatResponseModel } from "../common/chatModel.js";
+import { IParsedChatRequest } from "../common/chatParserTypes.js";
+import { IChatRequestViewModel, IChatResponseViewModel, IChatViewModel } from "../common/chatViewModel.js";
+import { ChatAttachmentModel } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chatAttachmentModel";
+import { ChatInputPart } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chatInputPart";
+import { IChatViewState, IChatWidgetContrib } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/chatWidget";
+import { ICodeBlockActionContext } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/codeBlockPart";
+export declare function showChatView(viewsService: IViewsService): Promise<IChatWidget | undefined>;
+export declare function showEditsView(viewsService: IViewsService): Promise<IChatWidget | undefined>;
+export declare function preferCopilotEditsView(viewsService: IViewsService): boolean;
+export declare function showCopilotView(viewsService: IViewsService, layoutService: IWorkbenchLayoutService): Promise<IChatWidget | undefined>;
+export declare function ensureSideBarChatViewSize(viewDescriptorService: IViewDescriptorService, layoutService: IWorkbenchLayoutService, viewsService: IViewsService): void;
+export interface IQuickChatOpenOptions {
+    query: string;
+    isPartialQuery?: boolean;
+    selection?: Selection;
+}
+export interface IChatCodeBlockInfo {
+    readonly ownerMarkdownPartId: string;
+    readonly codeBlockIndex: number;
+    readonly element: ChatTreeItem;
+    readonly uri: URI | undefined;
+    readonly uriPromise: Promise<URI | undefined>;
+    codemapperUri: URI | undefined;
+    readonly isStreaming: boolean;
+    focus(): void;
+    getContent(): string;
+}
+export interface IChatFileTreeInfo {
+    treeDataId: string;
+    treeIndex: number;
+    focus(): void;
+}
+export type ChatTreeItem = IChatRequestViewModel | IChatResponseViewModel;
+export interface IChatListItemRendererOptions {
+    readonly renderStyle?: "compact" | "minimal";
+    readonly noHeader?: boolean;
+    readonly noPadding?: boolean;
+    readonly editableCodeBlock?: boolean;
+    readonly renderCodeBlockPills?: boolean;
+    readonly renderDetectedCommandsWithRequest?: boolean;
+    readonly renderTextEditsAsSummary?: (uri: URI) => boolean;
+}
+export interface IChatWidgetViewOptions {
+    autoScroll?: boolean;
+    renderInputOnTop?: boolean;
+    renderFollowups?: boolean;
+    renderStyle?: "compact" | "minimal";
+    supportsFileReferences?: boolean;
+    supportsAdditionalParticipants?: boolean;
+    filter?: (item: ChatTreeItem) => boolean;
+    rendererOptions?: IChatListItemRendererOptions;
+    menus?: {
+        executeToolbar?: MenuId;
+        inputSideToolbar?: MenuId;
+        telemetrySource?: string;
+    };
+    defaultElementHeight?: number;
+    editorOverflowWidgetsDomNode?: HTMLElement;
+    enableImplicitContext?: boolean;
+    enableWorkingSet?: "explicit" | "implicit";
+}
+export interface IChatViewViewContext {
+    viewId: string;
+}
+export interface IChatResourceViewContext {
+    isQuickChat?: boolean;
+}
+export type IChatWidgetViewContext = IChatViewViewContext | IChatResourceViewContext | {};
+export interface IChatAcceptInputOptions {
+    noCommandDetection?: boolean;
+    isVoiceInput?: boolean;
+}
+export interface IChatWidget {
+    readonly onDidChangeViewModel: Event<void>;
+    readonly onDidAcceptInput: Event<void>;
+    readonly onDidHide: Event<void>;
+    readonly onDidSubmitAgent: Event<{
+        agent: IChatAgentData;
+        slashCommand?: IChatAgentCommand;
+    }>;
+    readonly onDidChangeAgent: Event<{
+        agent: IChatAgentData;
+        slashCommand?: IChatAgentCommand;
+    }>;
+    readonly onDidChangeParsedInput: Event<void>;
+    readonly location: ChatAgentLocation;
+    readonly viewContext: IChatWidgetViewContext;
+    readonly viewModel: IChatViewModel | undefined;
+    readonly inputEditor: ICodeEditor;
+    readonly supportsFileReferences: boolean;
+    readonly parsedInput: IParsedChatRequest;
+    lastSelectedAgent: IChatAgentData | undefined;
+    readonly scopedContextKeyService: IContextKeyService;
+    readonly input: ChatInputPart;
+    readonly attachmentModel: ChatAttachmentModel;
+    getContrib<T extends IChatWidgetContrib>(id: string): T | undefined;
+    reveal(item: ChatTreeItem): void;
+    focus(item: ChatTreeItem): void;
+    getSibling(item: ChatTreeItem, type: "next" | "previous"): ChatTreeItem | undefined;
+    getFocus(): ChatTreeItem | undefined;
+    setInput(query?: string): void;
+    getInput(): string;
+    refreshParsedInput(): void;
+    logInputHistory(): void;
+    acceptInput(query?: string, options?: IChatAcceptInputOptions): Promise<IChatResponseModel | undefined>;
+    rerunLastRequest(): Promise<void>;
+    acceptInputWithPrefix(prefix: string): void;
+    setInputPlaceholder(placeholder: string): void;
+    resetInputPlaceholder(): void;
+    focusLastMessage(): void;
+    focusInput(): void;
+    hasInputFocus(): boolean;
+    getCodeBlockInfoForEditor(uri: URI): IChatCodeBlockInfo | undefined;
+    getCodeBlockInfosForResponse(response: IChatResponseViewModel): IChatCodeBlockInfo[];
+    getFileTreeInfosForResponse(response: IChatResponseViewModel): IChatFileTreeInfo[];
+    getLastFocusedFileTreeForResponse(response: IChatResponseViewModel): IChatFileTreeInfo | undefined;
+    clear(): void;
+    getViewState(): IChatViewState;
+    togglePaused(): void;
+}
+export interface ICodeBlockActionContextProvider {
+    getCodeBlockContext(editor?: ICodeEditor): ICodeBlockActionContext | undefined;
+}
+export declare const ChatViewId = "workbench.panel.chat.view.copilot";
+export declare const EditsViewId = "workbench.panel.chat.view.edits";

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

@@ -0,0 +1,51 @@
+
+import { ViewContainerLocation } from '../../../common/views.js';
+import { Parts } from '../../../services/layout/browser/layoutService.js';
+import { CHAT_PROVIDER_ID } from '../common/chatParticipantContribTypes.js';
+
+async function showChatView(viewsService) {
+    return (await viewsService.openView(ChatViewId))?.widget;
+}
+async function showEditsView(viewsService) {
+    return (await viewsService.openView(EditsViewId))?.widget;
+}
+function preferCopilotEditsView(viewsService) {
+    if (viewsService.getFocusedView()?.id === ChatViewId || !!viewsService.getActiveViewWithId(ChatViewId)) {
+        return false;
+    }
+    return !!viewsService.getActiveViewWithId(EditsViewId);
+}
+function showCopilotView(viewsService, layoutService) {
+    if (layoutService.activeContainer !== layoutService.mainContainer) {
+        layoutService.mainContainer.focus();
+    }
+    if (preferCopilotEditsView(viewsService)) {
+        return showEditsView(viewsService);
+    }
+    else {
+        return showChatView(viewsService);
+    }
+}
+function ensureSideBarChatViewSize(viewDescriptorService, layoutService, viewsService) {
+    const viewId = preferCopilotEditsView(viewsService) ? EditsViewId : ChatViewId;
+    const location = viewDescriptorService.getViewLocationById(viewId);
+    if (location === ViewContainerLocation.Panel) {
+        return;
+    }
+    const viewPart = location === ViewContainerLocation.Sidebar ? Parts.SIDEBAR_PART : Parts.AUXILIARYBAR_PART;
+    const partSize = layoutService.getSize(viewPart);
+    let adjustedChatWidth;
+    if (partSize.width < 400 && layoutService.mainContainerDimension.width > 1200) {
+        adjustedChatWidth = 400;
+    }
+    else if (partSize.width < 300) {
+        adjustedChatWidth = 300;
+    }
+    if (typeof adjustedChatWidth === 'number') {
+        layoutService.setSize(viewPart, { width: adjustedChatWidth, height: partSize.height });
+    }
+}
+const ChatViewId = `workbench.panel.chat.view.${CHAT_PROVIDER_ID}`;
+const EditsViewId = 'workbench.panel.chat.view.edits';
+
+export { ChatViewId, EditsViewId, ensureSideBarChatViewSize, preferCopilotEditsView, showChatView, showCopilotView, showEditsView };

package/vscode/src/vs/workbench/contrib/chat/browser/chat.service.d.ts

@@ -1,9 +1,9 @@
 import { Event } from "../../../../base/common/event.js";
+import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
 import { ChatAgentLocation } from "../common/chatAgents.js";
-import { IChatWidget, type ICodeBlockActionContextProvider, type IQuickChatOpenOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat";
-import { IChatResponseViewModel } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
-import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IChatResponseViewModel } from "../common/chatViewModel.js";
+import { IChatWidget, type ICodeBlockActionContextProvider, type IQuickChatOpenOptions } from "./chat.js";
 export declare const IChatWidgetService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetService>;
 export interface IChatWidgetService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/chatContentParts.d.ts

@@ -1,6 +1,6 @@
 import { IDisposable } from "../../../../../base/common/lifecycle.js";
-import { ChatTreeItem } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat";
-import { IChatRendererContent } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { ChatTreeItem } from "../chat.js";
+import { IChatRendererContent } from "../../common/chatViewModel.js";
 export interface IChatContentPart extends IDisposable {
     domNode: HTMLElement;
     hasSameContent(other: IChatRendererContent, followingContent: IChatRendererContent[], element: ChatTreeItem): boolean;

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service.d.ts

@@ -0,0 +1,8 @@
+import { IDisposable } from "../../../../../base/common/lifecycle.js";
+import { InlineAnchorWidget } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/chatInlineAnchorWidget";
+export declare const IChatMarkdownAnchorService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatMarkdownAnchorService>;
+export interface IChatMarkdownAnchorService {
+    readonly _serviceBrand: undefined;
+    readonly lastFocusedAnchor: InlineAnchorWidget | undefined;
+    register(widget: InlineAnchorWidget): IDisposable;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IChatMarkdownAnchorService = ( createDecorator('chatMarkdownAnchorService'));
+
+export { IChatMarkdownAnchorService };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditing.d.ts

@@ -0,0 +1,4 @@
+import { ICodeEditor } from "../../../../../editor/browser/editorBrowser.js";
+import { ServicesAccessor } from "../../../../../platform/instantiation/common/instantiation.js";
+import { IModifiedFileEntry } from "../../common/chatEditingService.js";
+export declare function isDiffEditorForEntry(accessor: ServicesAccessor, entry: IModifiedFileEntry, editor: ICodeEditor): boolean;

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

@@ -0,0 +1,15 @@
+
+import { isEqual } from '../../../../../base/common/resources.js';
+import { findDiffEditorContainingCodeEditor } from '../../../../../editor/browser/widget/diffEditor/commands.js';
+
+function isDiffEditorForEntry(accessor, entry, editor) {
+    const diffEditor = findDiffEditorContainingCodeEditor(accessor, editor);
+    if (!diffEditor) {
+        return false;
+    }
+    const originalModel = diffEditor.getOriginalEditor().getModel();
+    const modifiedModel = diffEditor.getModifiedEditor().getModel();
+    return isEqual(originalModel?.uri, entry.originalURI) && isEqual(modifiedModel?.uri, entry.modifiedURI);
+}
+
+export { isDiffEditorForEntry };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorActions.d.ts

@@ -0,0 +1,23 @@
+import { ICodeEditor } from "../../../../editor/browser/editorBrowser.js";
+import { EditorAction2, ServicesAccessor } from "../../../../editor/browser/editorExtensions.js";
+import { Action2 } from "../../../../platform/actions/common/actions.js";
+declare abstract class AcceptDiscardAction extends Action2 {
+    readonly accept: boolean;
+    constructor(id: string, accept: boolean);
+    run(accessor: ServicesAccessor): void;
+}
+export declare class AcceptAction extends AcceptDiscardAction {
+    static readonly ID = "chatEditor.action.accept";
+    constructor();
+}
+export declare class RejectAction extends AcceptDiscardAction {
+    static readonly ID = "chatEditor.action.reject";
+    constructor();
+}
+export declare class ReviewChangesAction extends EditorAction2 {
+    constructor();
+    runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor): void;
+}
+export declare function registerChatEditorActions(): void;
+export declare const navigationBearingFakeActionId = "chatEditor.navigation.bearings";
+export {};

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorActions.js

@@ -0,0 +1,309 @@
+
+import { isDiffEditor, isCodeEditor } from '../../../../editor/browser/editorBrowser.js';
+import { localize2, localize } from '../../../../nls.js';
+import { EditorAction2 } from '../../../../editor/browser/editorExtensions.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Action2, MenuId, registerAction2, MenuRegistry } from '../../../../platform/actions/common/actions.js';
+import { KeybindingWeight } from '../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../base/common/keyCodes.js';
+import { CHAT_CATEGORY } from './actions/chatActions.js';
+import { ctxReviewModeEnabled, ctxHasEditorModification, ChatEditorController } from './chatEditorController.js';
+import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';
+import { EditorContextKeys } from '../../../../editor/common/editorContextKeys.js';
+import { ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.service.js';
+import { hasUndecidedChatEditingResourceContextKey } from '../common/chatEditingService.js';
+import { IChatEditingService } from '../common/chatEditingService.service.js';
+import { ChatContextKeys } from '../common/chatContextKeys.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { Range } from '../../../../editor/common/core/range.js';
+import { getNotebookEditorFromEditorPane } from '../../notebook/browser/notebookBrowser.js';
+import { ctxNotebookHasEditorModification } from '../../notebook/browser/contrib/chatEdit/notebookChatEditContext.js';
+
+class NavigateAction extends Action2 {
+    constructor(next) {
+        super({
+            id: next
+                ? 'chatEditor.action.navigateNext'
+                : 'chatEditor.action.navigatePrevious',
+            title: next
+                ? ( localize2(4505, 'Go to Next Chat Edit'))
+                : ( localize2(4506, 'Go to Previous Chat Edit')),
+            category: CHAT_CATEGORY,
+            icon: next ? Codicon.arrowDown : Codicon.arrowUp,
+            keybinding: {
+                primary: next
+                    ? KeyMod$1.Alt | KeyCode.F5
+                    : KeyMod$1.Alt | KeyMod$1.Shift | KeyCode.F5,
+                weight: KeybindingWeight.WorkbenchContrib,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.or(ctxHasEditorModification, ctxNotebookHasEditorModification)), EditorContextKeys.focus)),
+            },
+            f1: true,
+            menu: {
+                id: MenuId.ChatEditingEditorContent,
+                group: 'navigate',
+                order: !next ? 2 : 3,
+                when: ctxReviewModeEnabled
+            }
+        });
+        this.next = next;
+    }
+    async run(accessor) {
+        const chatEditingService = accessor.get(IChatEditingService);
+        const editorService = accessor.get(IEditorService);
+        let editor = editorService.activeTextEditorControl;
+        if (isDiffEditor(editor)) {
+            editor = editor.getModifiedEditor();
+        }
+        if (!isCodeEditor(editor) || !editor.hasModel()) {
+            return;
+        }
+        const ctrl = ChatEditorController.get(editor);
+        if (!ctrl) {
+            return;
+        }
+        const session = chatEditingService.editingSessionsObs.get()
+            .find(candidate => candidate.getEntry(editor.getModel().uri));
+        if (!session) {
+            return;
+        }
+        const done = this.next
+            ? ctrl.revealNext(true)
+            : ctrl.revealPrevious(true);
+        if (done) {
+            return;
+        }
+        const entries = session.entries.get();
+        const idx = entries.findIndex(e => isEqual(e.modifiedURI, editor.getModel().uri));
+        if (idx < 0) {
+            return;
+        }
+        const newIdx = (idx + (this.next ? 1 : -1) + entries.length) % entries.length;
+        if (idx === newIdx) {
+            if (this.next) {
+                ctrl.revealNext(false);
+            }
+            else {
+                ctrl.revealPrevious(false);
+            }
+            return;
+        }
+        const entry = entries[newIdx];
+        const change = entry.diffInfo.get().changes.at(this.next ? 0 : -1);
+        const newEditorPane = await editorService.openEditor({
+            resource: entry.modifiedURI,
+            options: {
+                selection: change && Range.fromPositions({ lineNumber: change.modified.startLineNumber, column: 1 }),
+                revealIfOpened: false,
+                revealIfVisible: false,
+            }
+        }, ACTIVE_GROUP);
+        const newEditor = newEditorPane?.getControl();
+        if (isCodeEditor(newEditor)) {
+            ChatEditorController.get(newEditor)?.initNavigation();
+        }
+    }
+}
+class AcceptDiscardAction extends Action2 {
+    constructor(id, accept) {
+        super({
+            id,
+            title: accept
+                ? ( localize2(4507, 'Accept Chat Edit'))
+                : ( localize2(4508, 'Discard Chat Edit')),
+            shortTitle: accept
+                ? ( localize2(4509, 'Accept'))
+                : ( localize2(4510, 'Discard')),
+            category: CHAT_CATEGORY,
+            precondition: ( ContextKeyExpr.and(ctxHasEditorModification, hasUndecidedChatEditingResourceContextKey)),
+            icon: accept
+                ? Codicon.check
+                : Codicon.discard,
+            f1: true,
+            keybinding: {
+                when: EditorContextKeys.focus,
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: accept
+                    ? KeyMod$1.CtrlCmd | KeyCode.Enter
+                    : KeyMod$1.CtrlCmd | KeyCode.Backspace
+            },
+            menu: {
+                id: MenuId.ChatEditingEditorContent,
+                group: 'a_resolve',
+                order: accept ? 0 : 1,
+                when: !accept ? ctxReviewModeEnabled : undefined
+            }
+        });
+        this.accept = accept;
+    }
+    run(accessor) {
+        const chatEditingService = accessor.get(IChatEditingService);
+        const editorService = accessor.get(IEditorService);
+        let uri = getNotebookEditorFromEditorPane(editorService.activeEditorPane)?.textModel?.uri;
+        if (!uri) {
+            let editor = editorService.activeTextEditorControl;
+            if (isDiffEditor(editor)) {
+                editor = editor.getModifiedEditor();
+            }
+            uri = isCodeEditor(editor) && editor.hasModel()
+                ? editor.getModel().uri
+                : undefined;
+        }
+        if (!uri) {
+            return;
+        }
+        const session = chatEditingService.editingSessionsObs.get()
+            .find(candidate => candidate.getEntry(uri));
+        if (!session) {
+            return;
+        }
+        if (this.accept) {
+            session.accept(uri);
+        }
+        else {
+            session.reject(uri);
+        }
+    }
+}
+class AcceptAction extends AcceptDiscardAction {
+    static { this.ID = 'chatEditor.action.accept'; }
+    constructor() {
+        super(AcceptAction.ID, true);
+    }
+}
+class RejectAction extends AcceptDiscardAction {
+    static { this.ID = 'chatEditor.action.reject'; }
+    constructor() {
+        super(RejectAction.ID, false);
+    }
+}
+class RejectHunkAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'chatEditor.action.undoHunk',
+            title: ( localize2(4511, 'Discard this Change')),
+            category: CHAT_CATEGORY,
+            precondition: ( ContextKeyExpr.and(ctxHasEditorModification, ( ChatContextKeys.requestInProgress.negate()), hasUndecidedChatEditingResourceContextKey)),
+            icon: Codicon.discard,
+            f1: true,
+            keybinding: {
+                when: EditorContextKeys.focus,
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Backspace
+            },
+            menu: {
+                id: MenuId.ChatEditingEditorHunk,
+                order: 1
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, ...args) {
+        ChatEditorController.get(editor)?.rejectNearestChange(args[0]);
+    }
+}
+class AcceptHunkAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'chatEditor.action.acceptHunk',
+            title: ( localize2(4512, 'Accept this Change')),
+            category: CHAT_CATEGORY,
+            precondition: ( ContextKeyExpr.and(ctxHasEditorModification, ( ChatContextKeys.requestInProgress.negate()), hasUndecidedChatEditingResourceContextKey)),
+            icon: Codicon.check,
+            f1: true,
+            keybinding: {
+                when: EditorContextKeys.focus,
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Enter
+            },
+            menu: {
+                id: MenuId.ChatEditingEditorHunk,
+                order: 0
+            }
+        });
+    }
+    runEditorCommand(_accessor, editor, ...args) {
+        ChatEditorController.get(editor)?.acceptNearestChange(args[0]);
+    }
+}
+class OpenDiffAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'chatEditor.action.diffHunk',
+            title: ( localize2(4513, 'Toggle Diff Editor')),
+            category: CHAT_CATEGORY,
+            toggled: {
+                condition: EditorContextKeys.inDiffEditor,
+                icon: Codicon.goToFile,
+            },
+            precondition: ( ContextKeyExpr.and(ctxHasEditorModification, ( ChatContextKeys.requestInProgress.negate()), hasUndecidedChatEditingResourceContextKey)),
+            icon: Codicon.diffSingle,
+            keybinding: {
+                when: EditorContextKeys.focus,
+                weight: KeybindingWeight.WorkbenchContrib,
+                primary: KeyMod$1.Alt | KeyMod$1.Shift | KeyCode.F7,
+            },
+            menu: [{
+                    id: MenuId.ChatEditingEditorHunk,
+                    order: 10
+                }, {
+                    id: MenuId.ChatEditingEditorContent,
+                    group: 'a_resolve',
+                    order: 2,
+                    when: ctxReviewModeEnabled
+                }]
+        });
+    }
+    runEditorCommand(_accessor, editor, ...args) {
+        ChatEditorController.get(editor)?.toggleDiff(args[0]);
+    }
+}
+class ReviewChangesAction extends EditorAction2 {
+    constructor() {
+        super({
+            id: 'chatEditor.action.reviewChanges',
+            title: ( localize2(4514, "Review")),
+            menu: [{
+                    id: MenuId.ChatEditingEditorContent,
+                    group: 'a_resolve',
+                    order: 3,
+                    when: ( ctxReviewModeEnabled.negate()),
+                }]
+        });
+    }
+    runEditorCommand(accessor, editor) {
+        const chatEditingService = accessor.get(IChatEditingService);
+        if (!editor.hasModel()) {
+            return;
+        }
+        const session = chatEditingService.editingSessionsObs.get().find(session => session.getEntry(editor.getModel().uri));
+        const entry = session?.getEntry(editor.getModel().uri);
+        entry?.enableReviewModeUntilSettled();
+    }
+}
+function registerChatEditorActions() {
+    registerAction2(class NextAction extends NavigateAction {
+        constructor() { super(true); }
+    });
+    registerAction2(class PrevAction extends NavigateAction {
+        constructor() { super(false); }
+    });
+    registerAction2(ReviewChangesAction);
+    registerAction2(AcceptAction);
+    registerAction2(AcceptHunkAction);
+    registerAction2(RejectAction);
+    registerAction2(RejectHunkAction);
+    registerAction2(OpenDiffAction);
+    MenuRegistry.appendMenuItem(MenuId.ChatEditingEditorContent, {
+        command: {
+            id: navigationBearingFakeActionId,
+            title: ( localize(4515, "Navigation Status")),
+            precondition: ( ContextKeyExpr.false()),
+        },
+        group: 'navigate',
+        order: -1,
+        when: ctxReviewModeEnabled,
+    });
+}
+const navigationBearingFakeActionId = 'chatEditor.navigation.bearings';
+
+export { AcceptAction, RejectAction, ReviewChangesAction, navigationBearingFakeActionId, registerChatEditorActions };

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditorController.d.ts

@@ -0,0 +1,81 @@
+import { Disposable } from "../../../../base/common/lifecycle.js";
+import { IObservable } from "../../../../base/common/observable.js";
+import { ICodeEditor, IOverlayWidget, IOverlayWidgetPosition } from "../../../../editor/browser/editorBrowser.js";
+import { IEditorContribution } from "../../../../editor/common/editorCommon.js";
+import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { IModifiedFileEntry } from "../common/chatEditingService.js";
+import { IChatEditingService } from "../common/chatEditingService.service.js";
+import { IInstantiationService } from "../../../../platform/instantiation/common/instantiation.js";
+import { IEditorService } from "../../../services/editor/common/editorService.service.js";
+import { DetailedLineRangeMapping } from "../../../../editor/common/diff/rangeMapping.js";
+import { IChatAgentService } from "../common/chatAgents.service.js";
+import { IChatService } from "../common/chatService.service.js";
+export declare const ctxIsGlobalEditingSession: RawContextKey<boolean>;
+export declare const ctxHasEditorModification: RawContextKey<boolean>;
+export declare const ctxHasRequestInProgress: RawContextKey<boolean>;
+export declare const ctxReviewModeEnabled: RawContextKey<boolean>;
+export declare class ChatEditorController extends Disposable implements IEditorContribution {
+    private readonly _editor;
+    private readonly _chatEditingService;
+    private readonly _instantiationService;
+    private readonly _chatAgentService;
+    private readonly _editorService;
+    static readonly ID = "editor.contrib.chatEditorController";
+    private static _diffLineDecorationData;
+    private readonly _diffLineDecorations;
+    private readonly _diffVisualDecorations;
+    private readonly _diffHunksRenderStore;
+    private readonly _diffHunkWidgets;
+    private _viewZones;
+    private readonly _overlayCtrl;
+    private readonly _ctxIsGlobalEditsSession;
+    private readonly _ctxHasEditorModification;
+    private readonly _ctxRequestInProgress;
+    private readonly _ctxReviewModelEnabled;
+    static get(editor: ICodeEditor): ChatEditorController | null;
+    private readonly _currentEntryIndex;
+    readonly currentEntryIndex: IObservable<number | undefined>;
+    private readonly _currentChangeIndex;
+    readonly currentChangeIndex: IObservable<number | undefined>;
+    private _scrollLock;
+    constructor(_editor: ICodeEditor, _chatEditingService: IChatEditingService, _instantiationService: IInstantiationService, _chatAgentService: IChatAgentService, _editorService: IEditorService, contextKeyService: IContextKeyService, chatService: IChatService);
+    dispose(): void;
+    private _clear;
+    private _clearDiffRendering;
+    private _updateDiffRendering;
+    private _updateDiffLineDecorations;
+    unlockScroll(): void;
+    initNavigation(): void;
+    revealNext(strict?: boolean): boolean;
+    revealPrevious(strict?: boolean): boolean;
+    private _reveal;
+    private _findClosestWidget;
+    rejectNearestChange(closestWidget: DiffHunkWidget | undefined): void;
+    acceptNearestChange(closestWidget: DiffHunkWidget | undefined): void;
+    toggleDiff(widget: DiffHunkWidget | undefined): Promise<void>;
+}
+declare class DiffHunkWidget implements IOverlayWidget {
+    readonly entry: IModifiedFileEntry;
+    private readonly _change;
+    private readonly _versionId;
+    private readonly _editor;
+    private readonly _lineDelta;
+    private static _idPool;
+    private readonly _id;
+    private readonly _domNode;
+    private readonly _store;
+    private _position;
+    private _lastStartLineNumber;
+    constructor(entry: IModifiedFileEntry, _change: DetailedLineRangeMapping, _versionId: number, _editor: ICodeEditor, _lineDelta: number, instaService: IInstantiationService);
+    dispose(): void;
+    getId(): string;
+    layout(startLineNumber: number): void;
+    toggle(show: boolean): void;
+    getDomNode(): HTMLElement;
+    getPosition(): IOverlayWidgetPosition | null;
+    getStartLineNumber(): number | undefined;
+    reject(): void;
+    accept(): void;
+}
+export {};