@codingame/monaco-vscode-chat-service-override 18.4.0 → 19.0.0

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

@@ -0,0 +1,61 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { DetailedLineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
+import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { ITextModel, ITextSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
+import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
+import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { ModifiedFileEntryState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { IChatResponseModel } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+export declare class ChatEditingTextModelChangeService extends Disposable {
+    private readonly originalModel;
+    private readonly modifiedModel;
+    private readonly state;
+    private readonly _editorWorkerService;
+    private readonly _accessibilitySignalService;
+    private static readonly _lastEditDecorationOptions;
+    private static readonly _pendingEditDecorationOptions;
+    private static readonly _atomicEditDecorationOptions;
+    private _isEditFromUs;
+    get isEditFromUs(): boolean;
+    private _allEditsAreFromUs;
+    get allEditsAreFromUs(): boolean;
+    private _diffOperation;
+    private _diffOperationIds;
+    private readonly _diffInfo;
+    get diffInfo(): IObservable<{
+        originalModel: ITextModel;
+        modifiedModel: ITextModel;
+        keep: (changes: DetailedLineRangeMapping) => Promise<boolean>;
+        undo: (changes: DetailedLineRangeMapping) => Promise<boolean>;
+        identical: boolean;
+        quitEarly: boolean;
+        changes: readonly DetailedLineRangeMapping[];
+        moves: readonly import("@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/linesDiffComputer").MovedText[];
+    }>;
+    private readonly _editDecorationClear;
+    private _editDecorations;
+    private readonly _didAcceptOrRejectAllHunks;
+    readonly onDidAcceptOrRejectAllHunks: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ModifiedFileEntryState.Accepted | ModifiedFileEntryState.Rejected>;
+    private readonly _didUserEditModel;
+    readonly onDidUserEditModel: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _originalToModifiedEdit;
+    constructor(originalModel: ITextModel, modifiedModel: ITextModel, state: IObservable<ModifiedFileEntryState>, _editorWorkerService: IEditorWorkerService, _accessibilitySignalService: IAccessibilitySignalService);
+    clearCurrentEditLineDecoration(): void;
+    areOriginalAndModifiedIdentical(): Promise<boolean>;
+    acceptAgentEdits(resource: URI, textEdits: (TextEdit | ICellEditOperation)[], isLastEdits: boolean, responseModel: IChatResponseModel): Promise<{
+        rewriteRatio: number;
+        maxLineNumber: number;
+    }>;
+    private _applyEdits;
+    keep(): void;
+    undo(): void;
+    resetDocumentValues(newOriginal: string | ITextSnapshot | undefined, newModified: string | undefined): Promise<void>;
+    private _mirrorEdits;
+    private _keepHunk;
+    private _undoHunk;
+    private _updateDiffInfoSeq;
+    private _updateDiffInfo;
+}

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

@@ -0,0 +1,332 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { addDisposableListener, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { assert } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { RunOnceScheduler, DeferredPromise, timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, toDisposable } 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 { themeColorFromId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
+import { StringEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/edits/stringEdit';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { nullDocumentDiff } from '../../../../../editor/common/diff/documentDiffProvider.js';
+import { TextEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { OverviewRulerLane, MinimapPosition } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+import { offsetEditFromContentChanges, offsetEditToEditOperations, offsetEditFromLineRangeMapping } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelStringEdit';
+import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
+import { EditReasons } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditReason';
+import { AccessibilitySignal } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { IAccessibilitySignalService } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
+import { editorSelectionBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { pendingRewriteMinimap } from './chatEditingModifiedFileEntry.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+
+var ChatEditingTextModelChangeService_1;
+let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService extends Disposable {
+    static { ChatEditingTextModelChangeService_1 = this; }
+    static { this._lastEditDecorationOptions = ModelDecorationOptions.register({
+        isWholeLine: true,
+        description: 'chat-last-edit',
+        className: 'chat-editing-last-edit-line',
+        marginClassName: 'chat-editing-last-edit',
+        overviewRuler: {
+            position: OverviewRulerLane.Full,
+            color: themeColorFromId(editorSelectionBackground)
+        },
+    }); }
+    static { this._pendingEditDecorationOptions = ModelDecorationOptions.register({
+        isWholeLine: true,
+        description: 'chat-pending-edit',
+        className: 'chat-editing-pending-edit',
+        minimap: {
+            position: MinimapPosition.Inline,
+            color: themeColorFromId(pendingRewriteMinimap)
+        }
+    }); }
+    static { this._atomicEditDecorationOptions = ModelDecorationOptions.register({
+        isWholeLine: true,
+        description: 'chat-atomic-edit',
+        className: 'chat-editing-atomic-edit',
+        minimap: {
+            position: MinimapPosition.Inline,
+            color: themeColorFromId(pendingRewriteMinimap)
+        }
+    }); }
+    get isEditFromUs() {
+        return this._isEditFromUs;
+    }
+    get allEditsAreFromUs() {
+        return this._allEditsAreFromUs;
+    }
+    get diffInfo() {
+        return ( this._diffInfo.map(value => {
+            return {
+                ...value,
+                originalModel: this.originalModel,
+                modifiedModel: this.modifiedModel,
+                keep: changes => this._keepHunk(changes),
+                undo: changes => this._undoHunk(changes)
+            };
+        }));
+    }
+    constructor(originalModel, modifiedModel, state, _editorWorkerService, _accessibilitySignalService) {
+        super();
+        this.originalModel = originalModel;
+        this.modifiedModel = modifiedModel;
+        this.state = state;
+        this._editorWorkerService = _editorWorkerService;
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._isEditFromUs = false;
+        this._allEditsAreFromUs = true;
+        this._diffOperationIds = 0;
+        this._diffInfo = observableValue(this, nullDocumentDiff);
+        this._editDecorationClear = this._register(( new RunOnceScheduler(
+            () => { this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, []); },
+            500
+        )));
+        this._editDecorations = [];
+        this._didAcceptOrRejectAllHunks = this._register(( new Emitter()));
+        this.onDidAcceptOrRejectAllHunks = this._didAcceptOrRejectAllHunks.event;
+        this._didUserEditModel = this._register(( new Emitter()));
+        this.onDidUserEditModel = this._didUserEditModel.event;
+        this._originalToModifiedEdit = StringEdit.empty;
+        this._register(this.modifiedModel.onDidChangeContent(e => {
+            this._mirrorEdits(e);
+        }));
+        this._register(toDisposable(() => {
+            this.clearCurrentEditLineDecoration();
+        }));
+    }
+    clearCurrentEditLineDecoration() {
+        this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, []);
+    }
+    async areOriginalAndModifiedIdentical() {
+        const diff = await this._diffOperation;
+        return diff ? diff.identical : false;
+    }
+    async acceptAgentEdits(resource, textEdits, isLastEdits, responseModel) {
+        assertType(textEdits.every(TextEdit.isTextEdit), 'INVALID args, can only handle text edits');
+        assert(isEqual(resource, this.modifiedModel.uri), ' INVALID args, can only edit THIS document');
+        const isAtomicEdits = textEdits.length > 0 && isLastEdits;
+        let maxLineNumber = 0;
+        let rewriteRatio = 0;
+        const modelId = responseModel.session.getRequests().at(-1)?.modelId;
+        const reason = EditReasons.chatApplyEdits({ modelId: modelId });
+        if (isAtomicEdits) {
+            const minimalEdits = (await this._editorWorkerService.computeMoreMinimalEdits(this.modifiedModel.uri, textEdits)) ?? textEdits;
+            const ops = ( minimalEdits.map(TextEdit.asEditOperation));
+            const undoEdits = this._applyEdits(ops, reason);
+            if (undoEdits.length > 0) {
+                let range;
+                for (let i = 0; i < undoEdits.length; i++) {
+                    const op = undoEdits[i];
+                    if (!range) {
+                        range = Range.lift(op.range);
+                    }
+                    else {
+                        range = Range.plusRange(range, op.range);
+                    }
+                }
+                if (range) {
+                    const defer = ( new DeferredPromise());
+                    const listener = addDisposableListener(getWindow(undefined), 'animationend', e => {
+                        if (e.animationName === 'kf-chat-editing-atomic-edit') {
+                            defer.complete();
+                            listener.dispose();
+                        }
+                    });
+                    this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, [{
+                            options: ChatEditingTextModelChangeService_1._atomicEditDecorationOptions,
+                            range
+                        }]);
+                    await Promise.any([defer.p, timeout(500)]);
+                    listener.dispose();
+                }
+            }
+        }
+        else {
+            const ops = ( textEdits.map(TextEdit.asEditOperation));
+            const undoEdits = this._applyEdits(ops, reason);
+            maxLineNumber = undoEdits.reduce((max, op) => Math.max(max, op.range.startLineNumber), 0);
+            rewriteRatio = Math.min(1, maxLineNumber / this.modifiedModel.getLineCount());
+            const newDecorations = [
+                {
+                    options: ChatEditingTextModelChangeService_1._pendingEditDecorationOptions,
+                    range: ( new Range(maxLineNumber + 1, 1, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER))
+                }
+            ];
+            if (maxLineNumber > 0) {
+                newDecorations.push({
+                    options: ChatEditingTextModelChangeService_1._lastEditDecorationOptions,
+                    range: ( new Range(maxLineNumber, 1, maxLineNumber, Number.MAX_SAFE_INTEGER))
+                });
+            }
+            this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, newDecorations);
+        }
+        if (isLastEdits) {
+            this._updateDiffInfoSeq();
+            this._editDecorationClear.schedule();
+        }
+        return { rewriteRatio, maxLineNumber };
+    }
+    _applyEdits(edits, reason) {
+        if (!reason) {
+            reason = EditReasons.chatApplyEdits({ modelId: undefined });
+        }
+        try {
+            this._isEditFromUs = true;
+            let result = [];
+            this.modifiedModel.pushEditOperations(null, edits, (undoEdits) => {
+                result = undoEdits;
+                return null;
+            }, undefined, reason);
+            return result;
+        }
+        finally {
+            this._isEditFromUs = false;
+        }
+    }
+    keep() {
+        this.originalModel.setValue(this.modifiedModel.createSnapshot());
+        this._diffInfo.set(nullDocumentDiff, undefined);
+        this._originalToModifiedEdit = StringEdit.empty;
+    }
+    undo() {
+        this.modifiedModel.pushStackElement();
+        this._applyEdits([(EditOperation.replace(this.modifiedModel.getFullModelRange(), this.originalModel.getValue()))]);
+        this.modifiedModel.pushStackElement();
+        this._originalToModifiedEdit = StringEdit.empty;
+        this._diffInfo.set(nullDocumentDiff, undefined);
+    }
+    async resetDocumentValues(newOriginal, newModified) {
+        let didChange = false;
+        if (newOriginal !== undefined) {
+            this.originalModel.setValue(newOriginal);
+            didChange = true;
+        }
+        if (newModified !== undefined && this.modifiedModel.getValue() !== newModified) {
+            this.modifiedModel.pushStackElement();
+            this._applyEdits([(EditOperation.replace(this.modifiedModel.getFullModelRange(), newModified))]);
+            this.modifiedModel.pushStackElement();
+            didChange = true;
+        }
+        if (didChange) {
+            await this._updateDiffInfoSeq();
+        }
+    }
+    _mirrorEdits(event) {
+        const edit = offsetEditFromContentChanges(event.changes);
+        if (this._isEditFromUs) {
+            const e_sum = this._originalToModifiedEdit;
+            const e_ai = edit;
+            this._originalToModifiedEdit = e_sum.compose(e_ai);
+        }
+        else {
+            const e_ai = this._originalToModifiedEdit;
+            const e_user = edit;
+            const e_user_r = e_user.tryRebase(e_ai.inverse(this.originalModel.getValue()), true);
+            if (e_user_r === undefined) {
+                this._originalToModifiedEdit = e_ai.compose(e_user);
+            }
+            else {
+                const edits = offsetEditToEditOperations(e_user_r, this.originalModel);
+                this.originalModel.applyEdits(edits);
+                this._originalToModifiedEdit = e_ai.tryRebase(e_user_r);
+            }
+            this._allEditsAreFromUs = false;
+            this._updateDiffInfoSeq();
+            this._didUserEditModel.fire();
+        }
+    }
+    async _keepHunk(change) {
+        if (!this._diffInfo.get().changes.includes(change)) {
+            return false;
+        }
+        const edits = [];
+        for (const edit of change.innerChanges ?? []) {
+            const newText = this.modifiedModel.getValueInRange(edit.modifiedRange);
+            edits.push(EditOperation.replace(edit.originalRange, newText));
+        }
+        this.originalModel.pushEditOperations(null, edits, _ => null);
+        await this._updateDiffInfoSeq();
+        if (this._diffInfo.get().identical) {
+            this._didAcceptOrRejectAllHunks.fire(ModifiedFileEntryState.Accepted);
+        }
+        this._accessibilitySignalService.playSignal(AccessibilitySignal.editsKept, { allowManyInParallel: true });
+        return true;
+    }
+    async _undoHunk(change) {
+        if (!this._diffInfo.get().changes.includes(change)) {
+            return false;
+        }
+        const edits = [];
+        for (const edit of change.innerChanges ?? []) {
+            const newText = this.originalModel.getValueInRange(edit.originalRange);
+            edits.push(EditOperation.replace(edit.modifiedRange, newText));
+        }
+        this.modifiedModel.pushEditOperations(null, edits, _ => null);
+        await this._updateDiffInfoSeq();
+        if (this._diffInfo.get().identical) {
+            this._didAcceptOrRejectAllHunks.fire(ModifiedFileEntryState.Rejected);
+        }
+        this._accessibilitySignalService.playSignal(AccessibilitySignal.editsUndone, { allowManyInParallel: true });
+        return true;
+    }
+    async _updateDiffInfoSeq() {
+        const myDiffOperationId = ++this._diffOperationIds;
+        await Promise.resolve(this._diffOperation);
+        if (this._diffOperationIds === myDiffOperationId) {
+            const thisDiffOperation = this._updateDiffInfo();
+            this._diffOperation = thisDiffOperation;
+            await thisDiffOperation;
+        }
+    }
+    async _updateDiffInfo() {
+        if (this.originalModel.isDisposed() || this.modifiedModel.isDisposed() || this._store.isDisposed) {
+            return undefined;
+        }
+        if (this.state.get() !== ModifiedFileEntryState.Modified) {
+            this._diffInfo.set(nullDocumentDiff, undefined);
+            this._originalToModifiedEdit = StringEdit.empty;
+            return nullDocumentDiff;
+        }
+        const docVersionNow = this.modifiedModel.getVersionId();
+        const snapshotVersionNow = this.originalModel.getVersionId();
+        const diff = await this._editorWorkerService.computeDiff(this.originalModel.uri, this.modifiedModel.uri, {
+            ignoreTrimWhitespace: false,
+            computeMoves: false,
+            maxComputationTimeMs: 3000
+        }, 'advanced');
+        if (this.originalModel.isDisposed() || this.modifiedModel.isDisposed() || this._store.isDisposed) {
+            return undefined;
+        }
+        if (this.modifiedModel.getVersionId() === docVersionNow && this.originalModel.getVersionId() === snapshotVersionNow) {
+            const diff2 = diff ?? nullDocumentDiff;
+            this._diffInfo.set(diff2, undefined);
+            this._originalToModifiedEdit = offsetEditFromLineRangeMapping(this.originalModel, this.modifiedModel, diff2.changes);
+            return diff2;
+        }
+        return undefined;
+    }
+};
+ChatEditingTextModelChangeService = ChatEditingTextModelChangeService_1 = ( __decorate([
+    ( __param(3, IEditorWorkerService)),
+    ( __param(4, IAccessibilitySignalService))
+], ChatEditingTextModelChangeService));
+
+export { ChatEditingTextModelChangeService };

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

@@ -3,7 +3,6 @@ import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
 import { chatEditingSnapshotScheme } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
-import { ChatEditingSession } from './chatEditingSession.js';
 
 var ChatEditingTextModelContentProvider_1;
 let ChatEditingTextModelContentProvider = class ChatEditingTextModelContentProvider {
@@ -56,7 +55,7 @@ let ChatEditingSnapshotTextModelContentProvider = class ChatEditingSnapshotTextM
         }
         const data = JSON.parse(resource.query);
         const session = this._chatEditingService.getEditingSession(data.sessionId);
-        if (!(session instanceof ChatEditingSession) || !data.requestId) {
+        if (!session || !data.requestId) {
             return null;
         }
         return session.getSnapshotModel(data.requestId, data.undoStop || undefined, resource);

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

@@ -1,8 +1,7 @@
 import { INotebookEditorModelResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
 import { INotebookLoggingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
 import { INotebookEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
-import { IEditSessionEntryDiff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
-import { ISnapshotEntry } from "../chatEditingModifiedFileEntry.js";
+import { IEditSessionEntryDiff, ISnapshotEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
 export declare class ChatEditingModifiedNotebookDiff {
     private readonly original;
     private readonly modified;

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

@@ -2,7 +2,7 @@
 import { VSBuffer, encodeBase64, decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { SnapshotContext } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
+import { SnapshotContext } from '@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
 import { NotebookCellTextModel } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
 import { NotebookSetting, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 

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

@@ -0,0 +1,13 @@
+import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
+export declare class ChatEditingNewNotebookContentEdits {
+    private readonly notebook;
+    private readonly _notebookService;
+    private readonly textEdits;
+    constructor(notebook: NotebookTextModel, _notebookService: INotebookService);
+    acceptTextEdits(edits: TextEdit[]): void;
+    generateEdits(): Promise<ICellEditOperation[]>;
+    private generateContent;
+}

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

@@ -0,0 +1,69 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+
+let ChatEditingNewNotebookContentEdits = class ChatEditingNewNotebookContentEdits {
+    constructor(notebook, _notebookService) {
+        this.notebook = notebook;
+        this._notebookService = _notebookService;
+        this.textEdits = [];
+    }
+    acceptTextEdits(edits) {
+        if (edits.length) {
+            this.textEdits.push(...edits);
+        }
+    }
+    async generateEdits() {
+        if (this.notebook.cells.length) {
+            console.error(`Notebook edits not generated as notebook already has cells`);
+            return [];
+        }
+        const content = this.generateContent();
+        if (!content) {
+            return [];
+        }
+        const notebookEdits = [];
+        try {
+            const { serializer } = await this._notebookService.withNotebookDataProvider(this.notebook.viewType);
+            const data = await serializer.dataToNotebook(VSBuffer.fromString(content));
+            for (let i = 0; i < data.cells.length; i++) {
+                notebookEdits.push({
+                    editType: CellEditType.Replace,
+                    index: i,
+                    count: 0,
+                    cells: [data.cells[i]]
+                });
+            }
+        }
+        catch (ex) {
+            console.error(`Failed to generate notebook edits from text edits ${content}`, ex);
+            return [];
+        }
+        return notebookEdits;
+    }
+    generateContent() {
+        try {
+            return applyTextEdits(this.textEdits);
+        }
+        catch (ex) {
+            console.error('Failed to generate content from text edits', ex);
+            return '';
+        }
+    }
+};
+ChatEditingNewNotebookContentEdits = ( __decorate([
+    ( __param(1, INotebookService))
+], ChatEditingNewNotebookContentEdits));
+function applyTextEdits(edits) {
+    let output = '';
+    for (const edit of edits) {
+        output = output.slice(0, edit.range.startColumn)
+            + edit.text
+            + output.slice(edit.range.endColumn);
+    }
+    return output;
+}
+
+export { ChatEditingNewNotebookContentEdits };

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

@@ -1,57 +1,36 @@
-import { DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { ITransaction, IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { ObservableDisposable } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/base/common/observableDisposable";
+import { Disposable, DisposableStore } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IDocumentDiff } from "../../../../../../editor/common/diff/documentDiffProvider.js";
 import { DetailedLineRangeMapping } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping";
 import { TextEdit } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages";
 import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
-import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service";
-import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
 import { NotebookCellTextModel } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel";
 import { ModifiedFileEntryState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
-import { IChatResponseModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModel";
-export declare class ChatEditingNotebookCellEntry extends ObservableDisposable {
+import { IChatResponseModel } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+export declare class ChatEditingNotebookCellEntry extends Disposable {
     readonly notebookUri: URI;
     readonly cell: NotebookCellTextModel;
     private readonly modifiedModel;
     private readonly originalModel;
-    private readonly _editorWorkerService;
     private readonly notebookEditorService;
-    private static readonly _lastEditDecorationOptions;
-    private static readonly _pendingEditDecorationOptions;
-    private _edit;
-    private _isEditFromUs;
+    private readonly instantiationService;
+    get isDisposed(): boolean;
     get isEditFromUs(): boolean;
-    private _allEditsAreFromUs;
     get allEditsAreFromUs(): boolean;
-    private _diffOperation;
-    private _diffOperationIds;
-    private readonly _diffInfo;
     get diffInfo(): IObservable<IDocumentDiff>;
     private readonly _maxModifiedLineNumber;
     readonly maxModifiedLineNumber: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<number, void>;
-    private readonly _editDecorationClear;
-    private _editDecorations;
-    private readonly _diffTrimWhitespace;
     protected readonly _stateObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<ModifiedFileEntryState, void>;
     readonly state: IObservable<ModifiedFileEntryState>;
-    protected readonly _isCurrentlyBeingModifiedByObs: import("@codingame/monaco-vscode-api/vscode/vs/base/common/observable").ISettableObservable<IChatResponseModel | undefined, void>;
-    readonly isCurrentlyBeingModifiedBy: IObservable<IChatResponseModel | undefined>;
     private readonly initialContent;
-    constructor(notebookUri: URI, cell: NotebookCellTextModel, modifiedModel: ITextModel, originalModel: ITextModel, disposables: DisposableStore, configService: IConfigurationService, _editorWorkerService: IEditorWorkerService, notebookEditorService: INotebookEditorService);
+    private readonly _textModelChangeService;
+    constructor(notebookUri: URI, cell: NotebookCellTextModel, modifiedModel: ITextModel, originalModel: ITextModel, disposables: DisposableStore, notebookEditorService: INotebookEditorService, instantiationService: IInstantiationService);
     clearCurrentEditLineDecoration(): void;
-    private _mirrorEdits;
-    acceptAgentEdits(textEdits: TextEdit[], isLastEdits: boolean, responseModel: IChatResponseModel): void;
-    scheduleEditDecorations(): void;
+    acceptAgentEdits(textEdits: TextEdit[], isLastEdits: boolean, responseModel: IChatResponseModel): Promise<void>;
     revertMarkdownPreviewState(): void;
-    protected _resetEditsState(tx: ITransaction): void;
     keep(change: DetailedLineRangeMapping): Promise<boolean>;
-    private _acceptHunk;
     undo(change: DetailedLineRangeMapping): Promise<boolean>;
-    private _rejectHunk;
-    private _applyEdits;
-    private _updateDiffInfoSeq;
-    private _updateDiffInfo;
 }