@codingame/monaco-vscode-chat-service-override 15.0.2 → 16.0.0

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

@@ -0,0 +1,831 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { streamToBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap, ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { LineRange } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/lineRange';
+import { OffsetEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/offsetEdit';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { nullDocumentDiff } from '../../../../../editor/common/diff/documentDiffProvider.js';
+import { RangeMapping, DetailedLineRangeMapping } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/rangeMapping';
+import '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { UndoRedoElementType } from '@codingame/monaco-vscode-api/vscode/vs/platform/undoRedo/common/undoRedo';
+import { IUndoRedoService } from '@codingame/monaco-vscode-api/vscode/vs/platform/undoRedo/common/undoRedo.service';
+import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IFilesConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService.service';
+import { SnapshotContext } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
+import { NotebookTextDiffEditor } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffEditor';
+import { getNotebookEditorFromEditorPane } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { CellEditType, NotebookCellsChangeType, NotebookSetting } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { computeDiff } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/common/notebookDiff';
+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 { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
+import { WorkingSetEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { AbstractChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
+import { getNotebookSnapshotFileURI, restoreSnapshot, createSnapshot, deserializeSnapshot, SnapshotComparer } from './notebook/chatEditingModifiedNotebookSnapshot.js';
+import { ChatEditingNotebookCellEntry } from './notebook/chatEditingNotebookCellEntry.js';
+import { ChatEditingNotebookDiffEditorIntegration, ChatEditingNotebookEditorIntegration } from './notebook/chatEditingNotebookEditorIntegration.js';
+import { ChatEditingNotebookFileSystemProvider } from './notebook/chatEditingNotebookFileSystemProvider.js';
+import { isTransientIPyNbExtensionEvent, adjustCellDiffAndOriginalModelBasedOnCellMovements, getCorrespondingOriginalCellIndex, adjustCellDiffAndOriginalModelBasedOnCellAddDelete, calculateNotebookRewriteRatio, adjustCellDiffForRevertingAnInsertedCell, adjustCellDiffForKeepingAnInsertedCell, adjustCellDiffForRevertingADeletedCell } from './notebook/helpers.js';
+import { countChanges, sortCellChanges } from './notebook/notebookCellChanges.js';
+import { observableValue, transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
+import { ObservablePromise } from '@codingame/monaco-vscode-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common/vscode/vs/base/common/observableInternal/promise';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
+
+var ChatEditingModifiedNotebookEntry_1;
+const SnapshotLanguageId = 'VSCodeChatNotebookSnapshotLanguage';
+let ChatEditingModifiedNotebookEntry = class ChatEditingModifiedNotebookEntry extends AbstractChatEditingModifiedFileEntry {
+    static { ChatEditingModifiedNotebookEntry_1 = this; }
+    static { this.NewModelCounter = 0; }
+    get isProcessingResponse() {
+        return this._isProcessingResponse;
+    }
+    get cellsDiffInfo() {
+        return this._cellsDiffInfo;
+    }
+    static async create(uri, _multiDiffEntryDelegate, telemetryInfo, chatKind, initialContent, instantiationService) {
+        return instantiationService.invokeFunction(async (accessor) => {
+            const notebookService = accessor.get(INotebookService);
+            const resolver = accessor.get(INotebookEditorModelResolverService);
+            const configurationServie = accessor.get(IConfigurationService);
+            const resourceRef = await resolver.resolve(uri);
+            const notebook = resourceRef.object.notebook;
+            const originalUri = getNotebookSnapshotFileURI(telemetryInfo.sessionId, telemetryInfo.requestId, generateUuid(), notebook.uri.scheme === Schemas.untitled ? `/${notebook.uri.path}` : notebook.uri.path, notebook.viewType);
+            const [options, buffer] = await Promise.all([
+                notebookService.withNotebookDataProvider(resourceRef.object.notebook.notebookType),
+                notebookService.createNotebookTextDocumentSnapshot(notebook.uri, SnapshotContext.Backup, CancellationToken.None).then(s => streamToBuffer(s))
+            ]);
+            const disposables = ( new DisposableStore());
+            disposables.add(ChatEditingNotebookFileSystemProvider.registerFile(originalUri, buffer));
+            const originalRef = await resolver.resolve(originalUri, notebook.viewType);
+            if (initialContent) {
+                restoreSnapshot(originalRef.object.notebook, initialContent);
+            }
+            else {
+                initialContent = createSnapshot(notebook, options.serializer.options, configurationServie);
+                restoreSnapshot(originalRef.object.notebook, initialContent);
+                const edits = [];
+                notebook.cells.forEach((cell, index) => {
+                    const internalId = generateCellHash(cell.uri);
+                    edits.push({ editType: CellEditType.PartialInternalMetadata, index, internalMetadata: { internalId } });
+                });
+                resourceRef.object.notebook.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+                originalRef.object.notebook.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+            }
+            const instance = instantiationService.createInstance(ChatEditingModifiedNotebookEntry_1, resourceRef, originalRef, _multiDiffEntryDelegate, options.serializer.options, telemetryInfo, chatKind, initialContent);
+            instance._register(disposables);
+            return instance;
+        });
+    }
+    static canHandleSnapshotContent(initialContent) {
+        if (!initialContent) {
+            return false;
+        }
+        try {
+            deserializeSnapshot(initialContent);
+            return true;
+        }
+        catch (ex) {
+            return false;
+        }
+    }
+    static canHandleSnapshot(snapshot) {
+        if (snapshot.languageId === SnapshotLanguageId && ChatEditingModifiedNotebookEntry_1.canHandleSnapshotContent(snapshot.current)) {
+            return true;
+        }
+        return false;
+    }
+    constructor(modifiedResourceRef, originalResourceRef, _multiDiffEntryDelegate, transientOptions, telemetryInfo, kind, initialContent, configurationService, fileConfigService, chatService, fileService, instantiationService, textModelService, modelService, undoRedoService, notebookEditorWorkerService, loggingService, notebookResolver) {
+        super(modifiedResourceRef.object.notebook.uri, telemetryInfo, kind, configurationService, fileConfigService, chatService, fileService, undoRedoService, instantiationService);
+        this.modifiedResourceRef = modifiedResourceRef;
+        this._multiDiffEntryDelegate = _multiDiffEntryDelegate;
+        this.transientOptions = transientOptions;
+        this.configurationService = configurationService;
+        this.textModelService = textModelService;
+        this.modelService = modelService;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.loggingService = loggingService;
+        this.notebookResolver = notebookResolver;
+        this._isProcessingResponse = observableValue('isProcessingResponse', false);
+        this._isEditFromUs = false;
+        this._allEditsAreFromUs = true;
+        this._changesCount = observableValue(this, 0);
+        this.changesCount = this._changesCount;
+        this.cellEntryMap = ( new ResourceMap());
+        this.modifiedToOriginalCell = ( new ResourceMap());
+        this._cellsDiffInfo = observableValue('diffInfo', []);
+        this.editedCells = ( new ResourceSet());
+        this.computeRequestId = 0;
+        this.cellTextModelMap = ( new ResourceMap());
+        this.initialContentComparer = ( new SnapshotComparer(initialContent));
+        this.modifiedModel = this._register(modifiedResourceRef).object.notebook;
+        this.originalModel = this._register(originalResourceRef).object.notebook;
+        this.originalURI = this.originalModel.uri;
+        this.initialContent = initialContent;
+        this.initializeModelsFromDiff();
+        this._register(this.modifiedModel.onDidChangeContent(this.mirrorNotebookEdits, this));
+    }
+    initializeModelsFromDiffImpl(cellsDiffInfo) {
+        this.cellEntryMap.forEach(entry => entry.dispose());
+        this.cellEntryMap.clear();
+        const diffs = ( cellsDiffInfo.map((cellDiff, i) => {
+            switch (cellDiff.type) {
+                case 'delete':
+                    return this.createDeleteCellDiffInfo(cellDiff.originalCellIndex);
+                case 'insert':
+                    return this.createInsertedCellDiffInfo(cellDiff.modifiedCellIndex);
+                default:
+                    return this.createModifiedCellDiffInfo(cellDiff.modifiedCellIndex, cellDiff.originalCellIndex);
+            }
+        }));
+        this._cellsDiffInfo.set(diffs, undefined);
+        this._changesCount.set(countChanges(diffs), undefined);
+    }
+    async initializeModelsFromDiff() {
+        const id = ++this.computeRequestId;
+        if (this._areOriginalAndModifiedIdenticalImpl()) {
+            const cellsDiffInfo = ( this.modifiedModel.cells.map((_, index) => {
+                return { type: 'unchanged', originalCellIndex: index, modifiedCellIndex: index };
+            }));
+            this.initializeModelsFromDiffImpl(cellsDiffInfo);
+            return;
+        }
+        const cellsDiffInfo = [];
+        try {
+            this._isProcessingResponse.set(true, undefined);
+            const notebookDiff = await this.notebookEditorWorkerService.computeDiff(this.originalURI, this.modifiedURI);
+            if (id !== this.computeRequestId) {
+                return;
+            }
+            const result = computeDiff(this.originalModel, this.modifiedModel, notebookDiff);
+            if (result.cellDiffInfo.length) {
+                cellsDiffInfo.push(...result.cellDiffInfo);
+            }
+        }
+        catch (ex) {
+            this.loggingService.error('Notebook Chat', 'Error computing diff:\n' + ex);
+        }
+        finally {
+            this._isProcessingResponse.set(false, undefined);
+        }
+        this.initializeModelsFromDiffImpl(cellsDiffInfo);
+    }
+    updateCellDiffInfo(cellsDiffInfo, transcation) {
+        this._cellsDiffInfo.set(sortCellChanges(cellsDiffInfo), transcation);
+        this._changesCount.set(countChanges(cellsDiffInfo), transcation);
+    }
+    mirrorNotebookEdits(e) {
+        if (this._isEditFromUs || ( Array.from(( this.cellEntryMap.values())).some(entry => entry.isEditFromUs))) {
+            return;
+        }
+        let didResetToOriginalContent = this.initialContentComparer.isEqual(this.modifiedModel);
+        const currentState = this._stateObs.get();
+        if (currentState === WorkingSetEntryState.Rejected) {
+            return;
+        }
+        if (currentState === WorkingSetEntryState.Modified && didResetToOriginalContent) {
+            this._stateObs.set(WorkingSetEntryState.Rejected, undefined);
+            this.updateCellDiffInfo([], undefined);
+            this.initializeModelsFromDiff();
+            return;
+        }
+        if (!e.rawEvents.length) {
+            return;
+        }
+        if (isTransientIPyNbExtensionEvent(this.modifiedModel.notebookType, e)) {
+            return;
+        }
+        this._allEditsAreFromUs = false;
+        for (const event of e.rawEvents.filter(event => event.kind !== NotebookCellsChangeType.ChangeCellContent)) {
+            switch (event.kind) {
+                case NotebookCellsChangeType.ChangeDocumentMetadata: {
+                    const edit = {
+                        editType: CellEditType.DocumentMetadata,
+                        metadata: this.modifiedModel.metadata
+                    };
+                    this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                    break;
+                }
+                case NotebookCellsChangeType.ModelChange: {
+                    let cellDiffs = sortCellChanges(this._cellsDiffInfo.get());
+                    this._applyEditsSync(() => {
+                        event.changes.forEach(change => {
+                            change[2].forEach((cell, i) => {
+                                if (cell.internalMetadata.internalId) {
+                                    return;
+                                }
+                                const index = change[0] + i;
+                                const internalId = generateCellHash(cell.uri);
+                                const edits = [{ editType: CellEditType.PartialInternalMetadata, index, internalMetadata: { internalId } }];
+                                this.modifiedModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+                                cell.internalMetadata ??= {};
+                                cell.internalMetadata.internalId = internalId;
+                            });
+                        });
+                    });
+                    event.changes.forEach(change => {
+                        cellDiffs = adjustCellDiffAndOriginalModelBasedOnCellAddDelete(change, cellDiffs, this.modifiedModel.cells.length, this.originalModel.cells.length, this.originalModel.applyEdits.bind(this.originalModel), this.createModifiedCellDiffInfo.bind(this));
+                    });
+                    this.updateCellDiffInfo(cellDiffs, undefined);
+                    this.disposeDeletedCellEntries();
+                    break;
+                }
+                case NotebookCellsChangeType.ChangeCellLanguage: {
+                    const index = getCorrespondingOriginalCellIndex(event.index, this._cellsDiffInfo.get());
+                    if (typeof index === 'number') {
+                        const edit = {
+                            editType: CellEditType.CellLanguage,
+                            index,
+                            language: event.language
+                        };
+                        this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                    }
+                    break;
+                }
+                case NotebookCellsChangeType.ChangeCellMetadata: {
+                    const index = getCorrespondingOriginalCellIndex(event.index, this._cellsDiffInfo.get());
+                    if (typeof index === 'number') {
+                        const edit = {
+                            editType: CellEditType.Metadata,
+                            index,
+                            metadata: event.metadata
+                        };
+                        this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                    }
+                    break;
+                }
+                case NotebookCellsChangeType.ChangeCellMime:
+                    break;
+                case NotebookCellsChangeType.ChangeCellInternalMetadata: {
+                    const index = getCorrespondingOriginalCellIndex(event.index, this._cellsDiffInfo.get());
+                    if (typeof index === 'number') {
+                        const edit = {
+                            editType: CellEditType.PartialInternalMetadata,
+                            index,
+                            internalMetadata: event.internalMetadata
+                        };
+                        this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                    }
+                    break;
+                }
+                case NotebookCellsChangeType.Output: {
+                    const index = getCorrespondingOriginalCellIndex(event.index, this._cellsDiffInfo.get());
+                    if (typeof index === 'number') {
+                        const edit = {
+                            editType: CellEditType.Output,
+                            index,
+                            append: event.append,
+                            outputs: event.outputs
+                        };
+                        this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                    }
+                    break;
+                }
+                case NotebookCellsChangeType.OutputItem: {
+                    const index = getCorrespondingOriginalCellIndex(event.index, this._cellsDiffInfo.get());
+                    if (typeof index === 'number') {
+                        const edit = {
+                            editType: CellEditType.OutputItems,
+                            outputId: event.outputId,
+                            append: event.append,
+                            items: event.outputItems
+                        };
+                        this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+                    }
+                    break;
+                }
+                case NotebookCellsChangeType.Move: {
+                    const result = adjustCellDiffAndOriginalModelBasedOnCellMovements(event, this._cellsDiffInfo.get().slice());
+                    if (result) {
+                        this.originalModel.applyEdits(result[1], true, undefined, () => undefined, undefined, false);
+                        this._cellsDiffInfo.set(result[0], undefined);
+                    }
+                    break;
+                }
+            }
+        }
+        didResetToOriginalContent = this.initialContentComparer.isEqual(this.modifiedModel);
+        if (currentState === WorkingSetEntryState.Modified && didResetToOriginalContent) {
+            this._stateObs.set(WorkingSetEntryState.Rejected, undefined);
+            this.updateCellDiffInfo([], undefined);
+            this.initializeModelsFromDiff();
+            return;
+        }
+    }
+    async _doAccept(tx) {
+        this.updateCellDiffInfo([], tx);
+        const snapshot = createSnapshot(this.modifiedModel, this.transientOptions, this.configurationService);
+        restoreSnapshot(this.originalModel, snapshot);
+        this.initializeModelsFromDiff();
+        await this._collapse(tx);
+        const config = this._fileConfigService.getAutoSaveConfiguration(this.modifiedURI);
+        if (this.modifiedModel.uri.scheme !== Schemas.untitled && (!config.autoSave || !this.notebookResolver.isDirty(this.modifiedURI))) {
+            await this._applyEdits(async () => {
+                try {
+                    await this.modifiedResourceRef.object.save({
+                        reason: SaveReason.EXPLICIT,
+                        force: true,
+                    });
+                }
+                catch {
+                }
+            });
+        }
+    }
+    async _doReject(tx) {
+        this.updateCellDiffInfo([], tx);
+        if (this.createdInRequestId === this._telemetryInfo.requestId) {
+            await this._applyEdits(async () => {
+                await this.modifiedResourceRef.object.revert({ soft: true });
+                await this._fileService.del(this.modifiedURI);
+            });
+            this._onDidDelete.fire();
+        }
+        else {
+            await this._applyEdits(async () => {
+                const snapshot = createSnapshot(this.originalModel, this.transientOptions, this.configurationService);
+                this.restoreSnapshotInModifiedModel(snapshot);
+                if (this._allEditsAreFromUs && Array.from(( this.cellEntryMap.values())).every(entry => entry.allEditsAreFromUs)) {
+                    await this.modifiedResourceRef.object.save({ reason: SaveReason.EXPLICIT, skipSaveParticipants: true });
+                }
+            });
+            this.initializeModelsFromDiff();
+            await this._collapse(tx);
+        }
+    }
+    async _collapse(transaction) {
+        this._multiDiffEntryDelegate.collapse(transaction);
+    }
+    _createEditorIntegration(editor) {
+        const notebookEditor = getNotebookEditorFromEditorPane(editor);
+        if (!notebookEditor && editor.getId() === NotebookTextDiffEditor.ID) {
+            const diffEditor = editor.getControl();
+            return this._instantiationService.createInstance(ChatEditingNotebookDiffEditorIntegration, diffEditor, this._cellsDiffInfo);
+        }
+        assertType(notebookEditor);
+        return this._instantiationService.createInstance(ChatEditingNotebookEditorIntegration, this, editor, this.modifiedModel, this.originalModel, this._cellsDiffInfo);
+    }
+    _resetEditsState(tx) {
+        super._resetEditsState(tx);
+        this.cellEntryMap.forEach(entry => !entry.disposed && entry.clearCurrentEditLineDecoration());
+    }
+    _createUndoRedoElement(response) {
+        const request = response.session.getRequests().find(req => req.id === response.requestId);
+        const label = request?.message.text ? ( localize(4688, "Chat Edit: '{0}'", request.message.text)) : ( localize(4689, "Chat Edit"));
+        const transientOptions = this.transientOptions;
+        const outputSizeLimit = this.configurationService.getValue(NotebookSetting.outputBackupSizeLimit) * 1024;
+        let initial = createSnapshot(this.modifiedModel, transientOptions, outputSizeLimit);
+        let last = '';
+        return {
+            type: UndoRedoElementType.Resource,
+            resource: this.modifiedURI,
+            label,
+            code: 'chat.edit',
+            confirmBeforeUndo: false,
+            undo: async () => {
+                last = createSnapshot(this.modifiedModel, transientOptions, outputSizeLimit);
+                restoreSnapshot(this.modifiedModel, initial);
+            },
+            redo: async () => {
+                initial = createSnapshot(this.modifiedModel, transientOptions, outputSizeLimit);
+                restoreSnapshot(this.modifiedModel, last);
+            }
+        };
+    }
+    async _areOriginalAndModifiedIdentical() {
+        return this._areOriginalAndModifiedIdenticalImpl();
+    }
+    _areOriginalAndModifiedIdenticalImpl() {
+        const snapshot = createSnapshot(this.originalModel, this.transientOptions, this.configurationService);
+        return ( new SnapshotComparer(snapshot)).isEqual(this.modifiedModel);
+    }
+    async acceptAgentEdits(resource, edits, isLastEdits, responseModel) {
+        const isCellUri = resource.scheme === Schemas.vscodeNotebookCell;
+        const cell = isCellUri && this.modifiedModel.cells.find(cell => isEqual(cell.uri, resource));
+        if (cell) {
+            const index = this.modifiedModel.cells.indexOf(cell);
+            const entry = this._cellsDiffInfo.get().slice().find(entry => entry.modifiedCellIndex === index);
+            if (!entry) {
+                console.error('Original cell model not found');
+                return;
+            }
+            this.getOrCreateModifiedTextFileEntryForCell(cell, await entry.modifiedModel.promise, await entry.originalModel.promise);
+        }
+        const finishPreviousCells = () => {
+            this.editedCells.forEach(uri => {
+                const cell = this.modifiedModel.cells.find(cell => isEqual(cell.uri, uri));
+                const cellEntry = cell && this.cellEntryMap.get(cell.uri);
+                cellEntry?.acceptAgentEdits([], true, responseModel);
+            });
+            this.editedCells.clear();
+        };
+        this._applyEditsSync(async () => {
+        });
+        if (isLastEdits) {
+            finishPreviousCells();
+        }
+        isLastEdits = !isCellUri && isLastEdits;
+        if (isLastEdits && this.newNotebookEditGenerator) {
+            const notebookEdits = await this.newNotebookEditGenerator.generateEdits();
+            this.newNotebookEditGenerator = undefined;
+            notebookEdits.forEach(edit => this.acceptNotebookEdit(edit));
+        }
+        transaction((tx) => {
+            if (!isLastEdits) {
+                this._stateObs.set(WorkingSetEntryState.Modified, tx);
+                this._isCurrentlyBeingModifiedByObs.set(responseModel, tx);
+                const newRewriteRation = Math.max(this._rewriteRatioObs.get(), calculateNotebookRewriteRatio(this._cellsDiffInfo.get(), this.originalModel, this.modifiedModel));
+                this._rewriteRatioObs.set(Math.min(1, newRewriteRation), tx);
+            }
+            else {
+                finishPreviousCells();
+                this.editedCells.clear();
+                this._resetEditsState(tx);
+                this._rewriteRatioObs.set(1, tx);
+            }
+        });
+    }
+    disposeDeletedCellEntries() {
+        const cellsUris = ( new ResourceSet(( this.modifiedModel.cells.map(cell => cell.uri))));
+        Array.from(( this.cellEntryMap.keys())).forEach(uri => {
+            if (( cellsUris.has(uri))) {
+                return;
+            }
+            this.cellEntryMap.get(uri)?.dispose();
+            this.cellEntryMap.delete(uri);
+        });
+    }
+    acceptNotebookEdit(edit) {
+        this.modifiedModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+        this.disposeDeletedCellEntries();
+        if (edit.editType !== CellEditType.Replace) {
+            return;
+        }
+        edit.cells.forEach((_, i) => {
+            const index = edit.index + i;
+            const cell = this.modifiedModel.cells[index];
+            if (cell.internalMetadata.internalId) {
+                return;
+            }
+            const internalId = generateCellHash(cell.uri);
+            const edits = [{ editType: CellEditType.PartialInternalMetadata, index, internalMetadata: { internalId } }];
+            this.modifiedModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
+        });
+        let diff = [];
+        if (edit.count === 0) {
+            diff = sortCellChanges(this._cellsDiffInfo.get());
+            diff.forEach(d => {
+                if (d.type !== 'delete' && d.modifiedCellIndex >= edit.index) {
+                    d.modifiedCellIndex += edit.cells.length;
+                }
+            });
+            const diffInsert = ( edit.cells.map((_, i) => this.createInsertedCellDiffInfo(edit.index + i)));
+            diff.splice(edit.index, 0, ...diffInsert);
+        }
+        else {
+            diff = ( sortCellChanges(this._cellsDiffInfo.get()).map((d) => {
+                if (d.type === 'unchanged' && d.modifiedCellIndex >= edit.index && d.modifiedCellIndex <= (edit.index + edit.count - 1)) {
+                    return this.createDeleteCellDiffInfo(d.originalCellIndex);
+                }
+                if (d.type !== 'delete' && d.modifiedCellIndex >= (edit.index + edit.count)) {
+                    d.modifiedCellIndex -= edit.count;
+                    return d;
+                }
+                return d;
+            }));
+        }
+        this.updateCellDiffInfo(diff, undefined);
+    }
+    computeStateAfterAcceptingRejectingChanges(accepted) {
+        const currentSnapshot = createSnapshot(this.modifiedModel, this.transientOptions, this.configurationService);
+        if (( new SnapshotComparer(currentSnapshot)).isEqual(this.originalModel)) {
+            const state = accepted ? WorkingSetEntryState.Accepted : WorkingSetEntryState.Rejected;
+            this._stateObs.set(state, undefined);
+        }
+    }
+    createModifiedCellDiffInfo(modifiedCellIndex, originalCellIndex) {
+        const modifiedCell = this.modifiedModel.cells[modifiedCellIndex];
+        const originalCell = this.originalModel.cells[originalCellIndex];
+        this.modifiedToOriginalCell.set(modifiedCell.uri, originalCell.uri);
+        const modifiedCellModelPromise = this.resolveCellModel(modifiedCell.uri);
+        const originalCellModelPromise = this.resolveCellModel(originalCell.uri);
+        Promise.all([modifiedCellModelPromise, originalCellModelPromise]).then(([modifiedCellModel, originalCellModel]) => {
+            this.getOrCreateModifiedTextFileEntryForCell(modifiedCell, modifiedCellModel, originalCellModel);
+        });
+        const diff = observableValue('diff', nullDocumentDiff);
+        const unchangedCell = {
+            type: 'unchanged',
+            modifiedCellIndex,
+            originalCellIndex,
+            keep: async (changes) => {
+                const [modifiedCellModel, originalCellModel] = await Promise.all([modifiedCellModelPromise, originalCellModelPromise]);
+                const entry = this.getOrCreateModifiedTextFileEntryForCell(modifiedCell, modifiedCellModel, originalCellModel);
+                return entry ? entry.keep(changes) : false;
+            },
+            undo: async (changes) => {
+                const [modifiedCellModel, originalCellModel] = await Promise.all([modifiedCellModelPromise, originalCellModelPromise]);
+                const entry = this.getOrCreateModifiedTextFileEntryForCell(modifiedCell, modifiedCellModel, originalCellModel);
+                return entry ? entry.undo(changes) : false;
+            },
+            modifiedModel: ( new ObservablePromise(modifiedCellModelPromise)),
+            originalModel: ( new ObservablePromise(originalCellModelPromise)),
+            diff
+        };
+        return unchangedCell;
+    }
+    createInsertedCellDiffInfo(modifiedCellIndex) {
+        const cell = this.modifiedModel.cells[modifiedCellIndex];
+        const lines = cell.getValue().split(/\r?\n/);
+        const originalRange = ( new Range(1, 0, 1, 0));
+        const modifiedRange = ( new Range(1, 0, lines.length, lines[lines.length - 1].length));
+        const innerChanges = ( new RangeMapping(originalRange, modifiedRange));
+        const changes = [( new DetailedLineRangeMapping(( new LineRange(1, 1)), ( new LineRange(1, lines.length)), [innerChanges]))];
+        const originalModelUri = this.modifiedModel.uri.with({ query: ( (ChatEditingModifiedNotebookEntry_1.NewModelCounter++).toString()), scheme: 'emptyCell' });
+        const originalModel = this.modelService.getModel(originalModelUri) || this._register(this.modelService.createModel('', null, originalModelUri));
+        this.modifiedToOriginalCell.set(cell.uri, originalModelUri);
+        const keep = async () => {
+            this._applyEditsSync(() => this.keepPreviouslyInsertedCell(cell));
+            this.computeStateAfterAcceptingRejectingChanges(true);
+            return true;
+        };
+        const undo = async () => {
+            this._applyEditsSync(() => this.undoPreviouslyInsertedCell(cell));
+            this.computeStateAfterAcceptingRejectingChanges(false);
+            return true;
+        };
+        this.resolveCellModel(cell.uri).then(modifiedModel => {
+            this.getOrCreateModifiedTextFileEntryForCell(cell, modifiedModel, originalModel);
+        });
+        return {
+            type: 'insert',
+            originalCellIndex: undefined,
+            modifiedCellIndex: modifiedCellIndex,
+            keep,
+            undo,
+            modifiedModel: ( new ObservablePromise(this.resolveCellModel(cell.uri))),
+            originalModel: ( new ObservablePromise(Promise.resolve(originalModel))),
+            diff: observableValue('deletedCellDiff', {
+                changes,
+                identical: false,
+                moves: [],
+                quitEarly: false,
+            })
+        };
+    }
+    createDeleteCellDiffInfo(originalCellIndex) {
+        const originalCell = this.originalModel.cells[originalCellIndex];
+        const lines = ( ( new Array(originalCell.textBuffer.getLineCount())).fill(0).map((_, i) => originalCell.textBuffer.getLineContent(i + 1)));
+        const originalRange = ( new Range(1, 0, lines.length, lines[lines.length - 1].length));
+        const modifiedRange = ( new Range(1, 0, 1, 0));
+        const innerChanges = ( new RangeMapping(modifiedRange, originalRange));
+        const changes = [( new DetailedLineRangeMapping(( new LineRange(1, lines.length)), ( new LineRange(1, 1)), [innerChanges]))];
+        const modifiedModelUri = this.modifiedModel.uri.with({ query: ( (ChatEditingModifiedNotebookEntry_1.NewModelCounter++).toString()), scheme: 'emptyCell' });
+        const modifiedModel = this.modelService.getModel(modifiedModelUri) || this._register(this.modelService.createModel('', null, modifiedModelUri));
+        const keep = async () => {
+            this._applyEditsSync(() => this.keepPreviouslyDeletedCell(this.originalModel.cells.indexOf(originalCell)));
+            this.computeStateAfterAcceptingRejectingChanges(true);
+            return true;
+        };
+        const undo = async () => {
+            this._applyEditsSync(() => this.undoPreviouslyDeletedCell(this.originalModel.cells.indexOf(originalCell), originalCell));
+            this.computeStateAfterAcceptingRejectingChanges(false);
+            return true;
+        };
+        return {
+            type: 'delete',
+            modifiedCellIndex: undefined,
+            originalCellIndex,
+            originalModel: ( new ObservablePromise(this.resolveCellModel(originalCell.uri))),
+            modifiedModel: ( new ObservablePromise(Promise.resolve(modifiedModel))),
+            keep,
+            undo,
+            diff: observableValue('cellDiff', {
+                changes,
+                identical: false,
+                moves: [],
+                quitEarly: false,
+            })
+        };
+    }
+    undoPreviouslyInsertedCell(cell) {
+        let diffs = [];
+        this._applyEditsSync(() => {
+            const index = this.modifiedModel.cells.indexOf(cell);
+            diffs = adjustCellDiffForRevertingAnInsertedCell(index, this._cellsDiffInfo.get(), this.modifiedModel.applyEdits.bind(this.modifiedModel));
+        });
+        this.disposeDeletedCellEntries();
+        this.updateCellDiffInfo(diffs, undefined);
+    }
+    keepPreviouslyInsertedCell(cell) {
+        const modifiedCellIndex = this.modifiedModel.cells.indexOf(cell);
+        if (modifiedCellIndex === -1) {
+            return;
+        }
+        const cellToInsert = {
+            cellKind: cell.cellKind,
+            language: cell.language,
+            metadata: cell.metadata,
+            outputs: cell.outputs,
+            source: cell.getValue(),
+            mime: cell.mime,
+            internalMetadata: {
+                internalId: cell.internalMetadata.internalId
+            }
+        };
+        this.cellEntryMap.get(cell.uri)?.dispose();
+        this.cellEntryMap.delete(cell.uri);
+        const cellDiffs = adjustCellDiffForKeepingAnInsertedCell(modifiedCellIndex, this._cellsDiffInfo.get().slice(), cellToInsert, this.originalModel.applyEdits.bind(this.originalModel), this.createModifiedCellDiffInfo.bind(this));
+        this.updateCellDiffInfo(cellDiffs, undefined);
+    }
+    undoPreviouslyDeletedCell(deletedOriginalIndex, originalCell) {
+        const cellToInsert = {
+            cellKind: originalCell.cellKind,
+            language: originalCell.language,
+            metadata: originalCell.metadata,
+            outputs: originalCell.outputs,
+            source: originalCell.getValue(),
+            mime: originalCell.mime,
+            internalMetadata: {
+                internalId: originalCell.internalMetadata.internalId
+            }
+        };
+        let cellDiffs = [];
+        this._applyEditsSync(() => {
+            cellDiffs = adjustCellDiffForRevertingADeletedCell(deletedOriginalIndex, this._cellsDiffInfo.get(), cellToInsert, this.modifiedModel.applyEdits.bind(this.modifiedModel), this.createModifiedCellDiffInfo.bind(this));
+        });
+        this.updateCellDiffInfo(cellDiffs, undefined);
+    }
+    keepPreviouslyDeletedCell(deletedOriginalIndex) {
+        const edit = { cells: [], count: 1, editType: CellEditType.Replace, index: deletedOriginalIndex, };
+        this.originalModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
+        const diffs = ( sortCellChanges(this._cellsDiffInfo.get())
+            .filter(d => !(d.type === 'delete' && d.originalCellIndex === deletedOriginalIndex))
+            .map(diff => {
+            if (diff.type !== 'insert' && diff.originalCellIndex > deletedOriginalIndex) {
+                return {
+                    ...diff,
+                    originalCellIndex: diff.originalCellIndex - 1,
+                };
+            }
+            return diff;
+        }));
+        this.updateCellDiffInfo(diffs, undefined);
+    }
+    async _applyEdits(operation) {
+        this._isEditFromUs = true;
+        try {
+            await operation();
+        }
+        finally {
+            this._isEditFromUs = false;
+        }
+    }
+    _applyEditsSync(operation) {
+        this._isEditFromUs = true;
+        try {
+            operation();
+        }
+        finally {
+            this._isEditFromUs = false;
+        }
+    }
+    createSnapshot(requestId, undoStop) {
+        return {
+            resource: this.modifiedURI,
+            languageId: SnapshotLanguageId,
+            snapshotUri: getNotebookSnapshotFileURI(this._telemetryInfo.sessionId, requestId, undoStop, this.modifiedURI.path, this.modifiedModel.viewType),
+            original: createSnapshot(this.originalModel, this.transientOptions, this.configurationService),
+            current: createSnapshot(this.modifiedModel, this.transientOptions, this.configurationService),
+            originalToCurrentEdit: OffsetEdit.empty,
+            state: this.state.get(),
+            telemetryInfo: this.telemetryInfo,
+        };
+    }
+    equalsSnapshot(snapshot) {
+        return !!snapshot &&
+            isEqual(this.modifiedURI, snapshot.resource) &&
+            this.state.get() === snapshot.state &&
+            ( new SnapshotComparer(snapshot.original)).isEqual(this.originalModel) &&
+            ( new SnapshotComparer(snapshot.current)).isEqual(this.modifiedModel);
+    }
+    restoreFromSnapshot(snapshot, restoreToDisk = true) {
+        this.updateCellDiffInfo([], undefined);
+        this._stateObs.set(snapshot.state, undefined);
+        restoreSnapshot(this.originalModel, snapshot.original);
+        if (restoreToDisk) {
+            this.restoreSnapshotInModifiedModel(snapshot.current);
+        }
+        this.initializeModelsFromDiff();
+    }
+    resetToInitialContent() {
+        this.updateCellDiffInfo([], undefined);
+        this.restoreSnapshotInModifiedModel(this.initialContent);
+        this.initializeModelsFromDiff();
+    }
+    restoreSnapshotInModifiedModel(snapshot) {
+        if (snapshot === createSnapshot(this.modifiedModel, this.transientOptions, this.configurationService)) {
+            return;
+        }
+        this._applyEditsSync(() => {
+            this.modifiedModel.pushStackElement();
+            restoreSnapshot(this.modifiedModel, snapshot);
+            this.modifiedModel.pushStackElement();
+        });
+    }
+    async resolveCellModel(cellURI) {
+        const cell = this.originalModel.cells.concat(this.modifiedModel.cells).find(cell => isEqual(cell.uri, cellURI));
+        if (!cell) {
+            throw ( new Error('Cell not found'));
+        }
+        const model = this.cellTextModelMap.get(cell.uri) || this._register(await this.textModelService.createModelReference(cell.uri)).object.textEditorModel;
+        this.cellTextModelMap.set(cell.uri, model);
+        return model;
+    }
+    getOrCreateModifiedTextFileEntryForCell(cell, modifiedCellModel, originalCellModel) {
+        let cellEntry = this.cellEntryMap.get(cell.uri);
+        if (cellEntry) {
+            return cellEntry;
+        }
+        const disposables = ( new DisposableStore());
+        cellEntry = this._register(this._instantiationService.createInstance(ChatEditingNotebookCellEntry, this.modifiedResourceRef.object.resource, cell, modifiedCellModel, originalCellModel, disposables));
+        this.cellEntryMap.set(cell.uri, cellEntry);
+        disposables.add(autorun(r => {
+            if (this.modifiedModel.cells.indexOf(cell) === -1) {
+                return;
+            }
+            const diffs = this.cellsDiffInfo.get().slice();
+            const index = this.modifiedModel.cells.indexOf(cell);
+            let entry = diffs.find(entry => entry.modifiedCellIndex === index);
+            if (!entry) {
+                return;
+            }
+            const entryIndex = diffs.indexOf(entry);
+            entry.diff.set(cellEntry.diffInfo.read(r), undefined);
+            if (cellEntry.diffInfo.get().identical && entry.type === 'modified') {
+                entry = {
+                    ...entry,
+                    type: 'unchanged',
+                };
+            }
+            if (!cellEntry.diffInfo.get().identical && entry.type === 'unchanged') {
+                entry = {
+                    ...entry,
+                    type: 'modified',
+                };
+            }
+            diffs.splice(entryIndex, 1, { ...entry });
+            transaction(tx => {
+                this.updateCellDiffInfo(diffs, tx);
+            });
+        }));
+        disposables.add(autorun(r => {
+            if (this.modifiedModel.cells.indexOf(cell) === -1) {
+                return;
+            }
+            const cellState = cellEntry.state.read(r);
+            if (cellState === WorkingSetEntryState.Accepted) {
+                this.computeStateAfterAcceptingRejectingChanges(true);
+            }
+            else if (cellState === WorkingSetEntryState.Rejected) {
+                this.computeStateAfterAcceptingRejectingChanges(false);
+            }
+        }));
+        return cellEntry;
+    }
+};
+ChatEditingModifiedNotebookEntry = ChatEditingModifiedNotebookEntry_1 = ( __decorate([
+    ( __param(7, IConfigurationService)),
+    ( __param(8, IFilesConfigurationService)),
+    ( __param(9, IChatService)),
+    ( __param(10, IFileService)),
+    ( __param(11, IInstantiationService)),
+    ( __param(12, ITextModelService)),
+    ( __param(13, IModelService)),
+    ( __param(14, IUndoRedoService)),
+    ( __param(15, INotebookEditorWorkerService)),
+    ( __param(16, INotebookLoggingService)),
+    ( __param(17, INotebookEditorModelResolverService))
+], ChatEditingModifiedNotebookEntry));
+function generateCellHash(cellUri) {
+    const hash = ( new StringSHA1());
+    hash.update(( cellUri.toString()));
+    return hash.digest().substring(0, 8);
+}
+
+export { ChatEditingModifiedNotebookEntry };