@codingame/monaco-vscode-chat-service-override 22.1.8 → 23.0.0

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

@@ -1,42 +1,52 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Sequencer, timeout, SequencerByKey, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { BugIndicatingError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
 import { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
 import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
 import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
 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 { 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 import { EditorActivation } from '@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { DiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput';
 import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
 import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { MultiDiffEditorInput } from '@codingame/monaco-vscode-7969284a-1a12-5148-9750-fcf9656a693f-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-bc6f260d-ec63-5c95-9446-1ca7d0872719-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
 import { CellUri } 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';
 import { ChatEditingSessionState, ModifiedFileEntryState, getMultiDiffSourceUri, ChatEditKind } 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 { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatEditingCheckpointTimelineImpl } from './chatEditingCheckpointTimelineImpl.js';
 import { ChatEditingModifiedDocumentEntry } from './chatEditingModifiedDocumentEntry.js';
 import { AbstractChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
 import { ChatEditingModifiedNotebookEntry } from './chatEditingModifiedNotebookEntry.js';
+import { FileOperationType } from './chatEditingOperations.js';
 import { ChatEditingSessionStorage } from './chatEditingSessionStorage.js';
 import { ChatEditingTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
-import { ChatEditingTimeline } from './chatEditingTimeline.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
+var ChatEditingSession_1;
 var NotExistBehavior;
 (function (NotExistBehavior) {
     NotExistBehavior[NotExistBehavior["Create"] = 0] = "Create";
@@ -67,26 +77,39 @@ class ThrottledSequencer extends Sequencer {
         });
     }
 }
-function getCurrentAndNextStop(requestId, stopId, history) {
-    const snapshotIndex = history.findIndex(s => s.requestId === requestId);
-    if (snapshotIndex === -1) {
-        return undefined;
-    }
-    const snapshot = history[snapshotIndex];
-    const stopIndex = snapshot.stops.findIndex(s => s.stopId === stopId);
-    if (stopIndex === -1) {
-        return undefined;
-    }
-    const current = snapshot.stops[stopIndex].entries;
-    const next = stopIndex < snapshot.stops.length - 1
-        ? snapshot.stops[stopIndex + 1].entries
-        : history[snapshotIndex + 1]?.stops[0].entries;
-    if (!next) {
-        return undefined;
-    }
-    return { current, next };
+function createOpeningEditCodeBlock(uri, isNotebook) {
+    return [
+        {
+            kind: 'markdownContent',
+            content: ( new MarkdownString('\n````\n'))
+        },
+        {
+            kind: 'codeblockUri',
+            uri,
+            isEdit: true
+        },
+        {
+            kind: 'markdownContent',
+            content: ( new MarkdownString('\n````\n'))
+        },
+        isNotebook
+            ? {
+                kind: 'notebookEdit',
+                uri,
+                edits: [],
+                done: false,
+                isExternalEdit: true
+            }
+            : {
+                kind: 'textEdit',
+                uri,
+                edits: [],
+                done: false,
+                isExternalEdit: true
+            },
+    ];
 }
-let ChatEditingSession = class ChatEditingSession extends Disposable {
+let ChatEditingSession = ChatEditingSession_1 = class ChatEditingSession extends Disposable {
     get entries() {
         return this._entriesObs;
     }
@@ -97,9 +120,10 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this._assertNotDisposed();
         return this._onDidDispose.event;
     }
-    constructor(chatSessionId, isGlobalEditingSession, _lookupExternalEntry, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _chatService, _notebookService, _accessibilitySignalService) {
+    constructor(chatSessionId, chatSessionResource, isGlobalEditingSession, _lookupExternalEntry, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _chatService, _notebookService, _accessibilitySignalService, _logService, configurationService) {
         super();
         this.chatSessionId = chatSessionId;
+        this.chatSessionResource = chatSessionResource;
         this.isGlobalEditingSession = isGlobalEditingSession;
         this._lookupExternalEntry = _lookupExternalEntry;
         this._instantiationService = _instantiationService;
@@ -112,13 +136,16 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this._chatService = _chatService;
         this._notebookService = _notebookService;
         this._accessibilitySignalService = _accessibilitySignalService;
+        this._logService = _logService;
+        this.configurationService = configurationService;
         this._state = observableValue(this, ChatEditingSessionState.Initial);
         this._initialFileContents = ( new ResourceMap());
+        this._baselineCreationLocks = ( new SequencerByKey());
+        this._streamingEditLocks = ( new SequencerByKey());
+        this._externalEditOperations = ( new Map());
         this._entriesObs = observableValue(this, []);
         this._onDidDispose = ( new Emitter());
-        this._pendingSnapshot = observableValue(this, undefined);
-        this._streamingEditLocks = ( new SequencerByKey());
-        this._timeline = _instantiationService.createInstance(ChatEditingTimeline);
+        this._timeline = this._instantiationService.createInstance(ChatEditingCheckpointTimelineImpl, chatSessionId, this._getTimelineDelegate());
         this.canRedo = ( this._timeline.canRedo.map(
             (hasHistory, reader) => hasHistory && this._state.read(reader) === ChatEditingSessionState.Idle
         ));
@@ -127,31 +154,67 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         ));
         this._register(autorun(reader => {
             const disabled = this._timeline.requestDisablement.read(reader);
-            this._chatService.getSession(this.chatSessionId)?.setDisabledRequests(disabled);
+            this._chatService.getSession(this.chatSessionResource)?.setDisabledRequests(disabled);
         }));
     }
-    async init() {
-        const restoredSessionState = await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).restoreState();
+    _getTimelineDelegate() {
+        return {
+            createFile: (uri, content) => {
+                return this._bulkEditService.apply({
+                    edits: [{
+                            newResource: uri,
+                            options: {
+                                overwrite: true,
+                                contents: content ? Promise.resolve(VSBuffer.fromString(content)) : undefined,
+                            },
+                        }],
+                });
+            },
+            deleteFile: async (uri) => {
+                const entries = this._entriesObs.get().filter(e => !isEqual(e.modifiedURI, uri));
+                this._entriesObs.set(entries, undefined);
+                await this._bulkEditService.apply({ edits: [{ oldResource: uri, options: { ignoreIfNotExists: true } }] });
+            },
+            renameFile: async (fromUri, toUri) => {
+                const entries = this._entriesObs.get();
+                const previousEntry = entries.find(e => isEqual(e.modifiedURI, fromUri));
+                if (previousEntry) {
+                    const newEntry = await this._getOrCreateModifiedFileEntry(toUri, NotExistBehavior.Create, previousEntry.telemetryInfo, this._getCurrentTextOrNotebookSnapshot(previousEntry));
+                    previousEntry.dispose();
+                    this._entriesObs.set(( entries.map(e => e === previousEntry ? newEntry : e)), undefined);
+                }
+            },
+            setContents: async (uri, content, telemetryInfo) => {
+                const entry = await this._getOrCreateModifiedFileEntry(uri, NotExistBehavior.Create, telemetryInfo);
+                if (entry instanceof ChatEditingModifiedNotebookEntry) {
+                    await entry.restoreModifiedModelFromSnapshot(content);
+                }
+                else {
+                    await entry.acceptAgentEdits(uri, [{ range: ( new Range(1, 1, Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)), text: content }], true, undefined);
+                }
+            }
+        };
+    }
+    async init(transferFrom) {
+        let restoredSessionState = await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).restoreState();
+        if (!restoredSessionState && transferFrom instanceof ChatEditingSession_1) {
+            restoredSessionState = transferFrom._getStoredState(this.chatSessionId);
+        }
         if (restoredSessionState) {
             for (const [uri, content] of restoredSessionState.initialFileContents) {
                 this._initialFileContents.set(uri, content);
             }
-            await this._restoreSnapshot(restoredSessionState.recentSnapshot, false);
+            await this._initEntries(restoredSessionState.recentSnapshot);
             transaction(tx => {
-                this._pendingSnapshot.set(restoredSessionState.pendingSnapshot, tx);
-                this._timeline.restoreFromState({ history: restoredSessionState.linearHistory, index: restoredSessionState.linearHistoryIndex }, tx);
+                if (restoredSessionState.timeline) {
+                    this._timeline.restoreFromState(restoredSessionState.timeline, tx);
+                }
                 this._state.set(ChatEditingSessionState.Idle, tx);
             });
         }
         else {
             this._state.set(ChatEditingSessionState.Idle, undefined);
         }
-        this._register(autorun(reader => {
-            const entries = this.entries.read(reader);
-            entries.forEach(entry => {
-                entry.state.read(reader);
-            });
-        }));
     }
     _getEntry(uri) {
         uri = CellUri.parse(uri)?.notebook ?? uri;
@@ -166,21 +229,19 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     }
     storeState() {
         const storage = this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId);
-        const timelineState = this._timeline.getStateForPersistence();
+        return storage.storeState(this._getStoredState());
+    }
+    _getStoredState(sessionId = this.chatSessionId) {
+        const entries = ( new ResourceMap());
+        for (const entry of this._entriesObs.get()) {
+            entries.set(entry.modifiedURI, entry.createSnapshot(sessionId, undefined, undefined));
+        }
         const state = {
             initialFileContents: this._initialFileContents,
-            pendingSnapshot: this._pendingSnapshot.get(),
-            recentSnapshot: this._createSnapshot(undefined, undefined),
-            linearHistoryIndex: timelineState.index,
-            linearHistory: timelineState.history,
+            timeline: this._timeline.getStateForPersistence(),
+            recentSnapshot: { entries, stopId: undefined },
         };
-        return storage.storeState(state);
-    }
-    _ensurePendingSnapshot() {
-        const prev = this._pendingSnapshot.get();
-        if (!prev) {
-            this._pendingSnapshot.set(this._createSnapshot(undefined, undefined), undefined);
-        }
+        return state;
     }
     getEntryDiffBetweenStops(uri, requestId, stopId) {
         return this._timeline.getEntryDiffBetweenStops(uri, requestId, stopId);
@@ -188,70 +249,36 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     getEntryDiffBetweenRequests(uri, startRequestId, stopRequestId) {
         return this._timeline.getEntryDiffBetweenRequests(uri, startRequestId, stopRequestId);
     }
-    createSnapshot(requestId, undoStop, makeEmpty = undoStop !== undefined) {
-        this._timeline.pushSnapshot(requestId, undoStop, makeEmpty ? ChatEditingTimeline.createEmptySnapshot(undoStop) : this._createSnapshot(requestId, undoStop));
+    createSnapshot(requestId, undoStop) {
+        const label = undoStop ? `Request ${requestId} - Stop ${undoStop}` : `Request ${requestId}`;
+        this._timeline.createCheckpoint(requestId, undoStop, label);
     }
-    _createSnapshot(requestId, stopId) {
-        const entries = ( new ResourceMap());
-        for (const entry of this._entriesObs.get()) {
-            entries.set(entry.modifiedURI, entry.createSnapshot(requestId, stopId));
-        }
-        return { stopId, entries };
-    }
-    getSnapshot(requestId, undoStop, snapshotUri) {
-        const stopRef = this._timeline.getSnapshotForRestore(requestId, undoStop);
-        const entries = stopRef?.stop.entries;
-        return entries && [...( entries.values())].find((e) => isEqual(e.snapshotUri, snapshotUri));
+    async getSnapshotContents(requestId, uri, stopId) {
+        const content = await this._timeline.getContentAtStop(requestId, uri, stopId);
+        return typeof content === 'string' ? VSBuffer.fromString(content) : content;
     }
     async getSnapshotModel(requestId, undoStop, snapshotUri) {
-        const snapshotEntry = this.getSnapshot(requestId, undoStop, snapshotUri);
-        if (!snapshotEntry) {
+        await this._baselineCreationLocks.peek(snapshotUri.path);
+        const content = await this._timeline.getContentAtStop(requestId, snapshotUri, undoStop);
+        if (content === undefined) {
             return null;
         }
-        return this._modelService.createModel(snapshotEntry.current, this._languageService.createById(snapshotEntry.languageId), snapshotUri, false);
+        const contentStr = typeof content === 'string' ? content : ( content.toString());
+        const model = this._modelService.createModel(contentStr, this._languageService.createByFilepathOrFirstLine(snapshotUri), snapshotUri, false);
+        const store = ( new DisposableStore());
+        store.add(model.onWillDispose(() => store.dispose()));
+        store.add(this._timeline.onDidChangeContentsAtStop(requestId, snapshotUri, undoStop, c => model.setValue(c)));
+        return model;
     }
     getSnapshotUri(requestId, uri, stopId) {
-        const timelineState = this._timeline.getStateForPersistence();
-        const stops = getCurrentAndNextStop(requestId, stopId, timelineState.history);
-        return stops?.next.get(uri)?.snapshotUri;
+        return this._timeline.getContentURIAtStop(requestId, uri, stopId);
     }
     async restoreSnapshot(requestId, stopId) {
-        if (requestId !== undefined) {
-            const stopRef = this._timeline.getSnapshotForRestore(requestId, stopId);
-            if (stopRef) {
-                this._ensurePendingSnapshot();
-                await this._restoreSnapshot(stopRef.stop);
-                stopRef.apply();
-            }
-        }
-        else {
-            const pendingSnapshot = this._pendingSnapshot.get();
-            if (!pendingSnapshot) {
-                return;
-            }
-            this._pendingSnapshot.set(undefined, undefined);
-            await this._restoreSnapshot(pendingSnapshot, undefined);
+        const checkpointId = this._timeline.getCheckpointIdForRequest(requestId, stopId);
+        if (checkpointId) {
+            await this._timeline.navigateToCheckpoint(checkpointId);
         }
     }
-    async _restoreSnapshot({ entries }, restoreResolvedToDisk = true) {
-        for (const entry of this._entriesObs.get()) {
-            const snapshotEntry = entries.get(entry.modifiedURI);
-            if (!snapshotEntry) {
-                await entry.resetToInitialContent();
-                entry.dispose();
-            }
-        }
-        const entriesArr = [];
-        for (const snapshotEntry of ( entries.values())) {
-            const entry = await this._getOrCreateModifiedFileEntry(snapshotEntry.resource, restoreResolvedToDisk ? NotExistBehavior.Create : NotExistBehavior.Abort, snapshotEntry.telemetryInfo);
-            if (entry) {
-                const restoreToDisk = snapshotEntry.state === ModifiedFileEntryState.Modified || restoreResolvedToDisk;
-                await entry.restoreFromSnapshot(snapshotEntry, restoreToDisk);
-                entriesArr.push(entry);
-            }
-        }
-        this._entriesObs.set(entriesArr, undefined);
-    }
     _assertNotDisposed() {
         if (this._state.get() === ChatEditingSessionState.Disposed) {
             throw ( new BugIndicatingError(`Cannot access a disposed editing session`));
@@ -271,10 +298,18 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this._assertNotDisposed();
         const applicableEntries = this._entriesObs.get()
             .filter(e => uris.length === 0 || ( uris.some(u => isEqual(u, e.modifiedURI))))
-            .filter(e => !e.isCurrentlyBeingModifiedBy.get());
-        for (const entry of applicableEntries) {
-            await entry[action]();
+            .filter(e => !e.isCurrentlyBeingModifiedBy.get())
+            .filter(e => e.state.get() === ModifiedFileEntryState.Modified);
+        if (applicableEntries.length === 0) {
+            return 0;
         }
+        const method = action === 'accept' ? 'acceptDeferred' : 'rejectDeferred';
+        const transitionCallbacks = await Promise.all(( applicableEntries.map(entry => entry[method]().catch(err => {
+            this._logService.error(`Error calling ${method} on entry ${entry.modifiedURI}`, err);
+        }))));
+        transaction(tx => {
+            transitionCallbacks.forEach(callback => callback?.(tx));
+        });
         return applicableEntries.length;
     }
     async show(previousChanges) {
@@ -290,7 +325,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         }
         const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
             multiDiffSource: getMultiDiffSourceUri(this, previousChanges),
-            label: ( localize(5108, "Suggested Edits"))
+            label: ( localize(5184, "Suggested Edits"))
         }, this._instantiationService);
         this._editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
     }
@@ -314,7 +349,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     }
     dispose() {
         this._assertNotDisposed();
-        this._chatService.cancelCurrentRequestForSession(this.chatSessionId);
+        this._chatService.cancelCurrentRequestForSession(this.chatSessionResource);
         dispose(this._entriesObs.get());
         super.dispose();
         this._state.set(ChatEditingSessionState.Disposed, undefined);
@@ -329,6 +364,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         const startPromise = ( new DeferredPromise());
         const sequencer = ( new ThrottledSequencer(15, 1000));
         sequencer.queue(() => startPromise.p);
+        this._baselineCreationLocks.queue(resource.path, () => startPromise.p);
         this._streamingEditLocks.queue(( resource.toString()), async () => {
             if (!this.isDisposed) {
                 await this._acceptStreamingEditsStart(responseModel, inUndoStop, resource);
@@ -374,39 +410,206 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             },
         };
     }
-    async undoInteraction() {
-        const undo = this._timeline.getUndoSnapshot();
-        if (!undo) {
-            return;
+    async startExternalEdits(responseModel, operationId, resources) {
+        const snapshots = ( new ResourceMap());
+        const acquiredLockPromises = [];
+        const releaseLockPromises = [];
+        const undoStopId = generateUuid();
+        const progress = [{
+                kind: 'undoStop',
+                id: undoStopId,
+            }];
+        const telemetryInfo = this._getTelemetryInfoForModel(responseModel);
+        for (const resource of resources) {
+            const releaseLock = ( new DeferredPromise());
+            releaseLockPromises.push(releaseLock);
+            const acquiredLock = ( new DeferredPromise());
+            acquiredLockPromises.push(acquiredLock);
+            this._streamingEditLocks.queue(( resource.toString()), async () => {
+                if (this.isDisposed) {
+                    acquiredLock.complete();
+                    return;
+                }
+                const entry = await this._getOrCreateModifiedFileEntry(resource, NotExistBehavior.Abort, telemetryInfo);
+                if (entry) {
+                    await this._acceptStreamingEditsStart(responseModel, undoStopId, resource);
+                }
+                const notebookUri = CellUri.parse(resource)?.notebook || resource;
+                progress.push(...createOpeningEditCodeBlock(resource, this._notebookService.hasSupportedNotebooks(notebookUri)));
+                await entry?.save();
+                snapshots.set(resource, entry && this._getCurrentTextOrNotebookSnapshot(entry));
+                entry?.startExternalEdit();
+                acquiredLock.complete();
+                return releaseLock.p;
+            });
         }
-        this._ensurePendingSnapshot();
-        await this._restoreSnapshot(undo.stop);
-        undo.apply();
+        await Promise.all(( acquiredLockPromises.map(p => p.p)));
+        this.createSnapshot(responseModel.requestId, undoStopId);
+        this._externalEditOperations.set(operationId, {
+            responseModel,
+            snapshots,
+            undoStopId,
+            releaseLocks: () => releaseLockPromises.forEach(p => p.complete())
+        });
+        return progress;
+    }
+    async stopExternalEdits(responseModel, operationId) {
+        const operation = this._externalEditOperations.get(operationId);
+        if (!operation) {
+            this._logService.warn(`stopExternalEdits called for unknown operation ${operationId}`);
+            return [];
+        }
+        this._externalEditOperations.delete(operationId);
+        const progress = [];
+        try {
+            for (const [resource, beforeSnapshot] of operation.snapshots) {
+                let entry = this._getEntry(resource);
+                if (!entry && beforeSnapshot === undefined) {
+                    entry = await this._getOrCreateModifiedFileEntry(resource, NotExistBehavior.Abort, this._getTelemetryInfoForModel(responseModel), '');
+                    if (entry) {
+                        entry.startExternalEdit();
+                        entry.acceptStreamingEditsStart(responseModel, operation.undoStopId, undefined);
+                    }
+                }
+                if (!entry) {
+                    continue;
+                }
+                await entry.revertToDisk();
+                const afterSnapshot = this._getCurrentTextOrNotebookSnapshot(entry);
+                let edits = [];
+                if (beforeSnapshot === undefined) {
+                    this._timeline.recordFileOperation({
+                        type: FileOperationType.Create,
+                        uri: resource,
+                        requestId: responseModel.requestId,
+                        epoch: this._timeline.incrementEpoch(),
+                        initialContent: afterSnapshot,
+                        telemetryInfo: entry.telemetryInfo,
+                    });
+                }
+                else {
+                    edits = await entry.computeEditsFromSnapshots(beforeSnapshot, afterSnapshot);
+                    this._recordEditOperations(entry, resource, edits, responseModel);
+                }
+                progress.push(entry instanceof ChatEditingModifiedNotebookEntry ? {
+                    kind: 'notebookEdit',
+                    uri: resource,
+                    edits: edits,
+                    done: true,
+                    isExternalEdit: true
+                } : {
+                    kind: 'textEdit',
+                    uri: resource,
+                    edits: edits,
+                    done: true,
+                    isExternalEdit: true
+                });
+                await entry.acceptStreamingEditsEnd();
+                entry.stopExternalEdit();
+            }
+        }
+        finally {
+            operation.releaseLocks();
+            const hasOtherTasks = ( Iterable.some(( this._streamingEditLocks.keys()), k => !( operation.snapshots.has(( URI.parse(k))))));
+            if (!hasOtherTasks) {
+                this._state.set(ChatEditingSessionState.Idle, undefined);
+            }
+        }
+        return progress;
+    }
+    async undoInteraction() {
+        await this._timeline.undoToLastCheckpoint();
     }
     async redoInteraction() {
-        const redo = this._timeline.getRedoSnapshot();
-        const nextSnapshot = redo?.stop || this._pendingSnapshot.get();
-        if (!nextSnapshot) {
-            return;
+        await this._timeline.redoToNextCheckpoint();
+    }
+    _recordEditOperations(entry, resource, edits, responseModel) {
+        const isNotebookEdits = edits.length > 0 && hasKey(edits[0], { cells: true });
+        if (isNotebookEdits) {
+            const notebookEdits = edits;
+            this._timeline.recordFileOperation({
+                type: FileOperationType.NotebookEdit,
+                uri: resource,
+                requestId: responseModel.requestId,
+                epoch: this._timeline.incrementEpoch(),
+                cellEdits: notebookEdits
+            });
+        }
+        else {
+            let cellIndex;
+            if (entry instanceof ChatEditingModifiedNotebookEntry) {
+                const cellUri = CellUri.parse(resource);
+                if (cellUri) {
+                    const i = entry.getIndexOfCellHandle(cellUri.handle);
+                    if (i !== -1) {
+                        cellIndex = i;
+                    }
+                }
+            }
+            const textEdits = edits;
+            this._timeline.recordFileOperation({
+                type: FileOperationType.TextEdit,
+                uri: resource,
+                requestId: responseModel.requestId,
+                epoch: this._timeline.incrementEpoch(),
+                edits: textEdits,
+                cellIndex,
+            });
         }
-        await this._restoreSnapshot(nextSnapshot);
-        if (redo) {
-            redo.apply();
+    }
+    _getCurrentTextOrNotebookSnapshot(entry) {
+        if (entry instanceof ChatEditingModifiedNotebookEntry) {
+            return entry.getCurrentSnapshot();
+        }
+        else if (entry instanceof ChatEditingModifiedDocumentEntry) {
+            return entry.getCurrentContents();
         }
         else {
-            this._pendingSnapshot.set(undefined, undefined);
+            throw ( new Error(`unknown entry type for ${entry.modifiedURI}`));
         }
     }
     async _acceptStreamingEditsStart(responseModel, undoStop, resource) {
         const entry = await this._getOrCreateModifiedFileEntry(resource, NotExistBehavior.Create, this._getTelemetryInfoForModel(responseModel));
+        if (!this._timeline.hasFileBaseline(resource, responseModel.requestId)) {
+            this._timeline.recordFileBaseline({
+                uri: resource,
+                requestId: responseModel.requestId,
+                content: this._getCurrentTextOrNotebookSnapshot(entry),
+                epoch: this._timeline.incrementEpoch(),
+                telemetryInfo: entry.telemetryInfo,
+                notebookViewType: entry instanceof ChatEditingModifiedNotebookEntry ? entry.viewType : undefined,
+            });
+        }
         transaction((tx) => {
             this._state.set(ChatEditingSessionState.StreamingEdits, tx);
-            entry.acceptStreamingEditsStart(responseModel, tx);
-            this._timeline.ensureEditInUndoStopMatches(responseModel.requestId, undoStop, entry, false, tx);
+            entry.acceptStreamingEditsStart(responseModel, undoStop, tx);
         });
+        return entry;
+    }
+    async _initEntries({ entries }) {
+        for (const entry of this._entriesObs.get()) {
+            const snapshotEntry = entries.get(entry.modifiedURI);
+            if (!snapshotEntry) {
+                await entry.resetToInitialContent();
+                entry.dispose();
+            }
+        }
+        const entriesArr = [];
+        for (const snapshotEntry of ( entries.values())) {
+            const entry = await this._getOrCreateModifiedFileEntry(snapshotEntry.resource, NotExistBehavior.Abort, snapshotEntry.telemetryInfo);
+            if (entry) {
+                const restoreToDisk = snapshotEntry.state === ModifiedFileEntryState.Modified;
+                await entry.restoreFromSnapshot(snapshotEntry, restoreToDisk);
+                entriesArr.push(entry);
+            }
+        }
+        this._entriesObs.set(entriesArr, undefined);
     }
     async _acceptEdits(resource, textEdits, isLastEdits, responseModel) {
         const entry = await this._getOrCreateModifiedFileEntry(resource, NotExistBehavior.Create, this._getTelemetryInfoForModel(responseModel));
+        if (textEdits.length > 0) {
+            this._recordEditOperations(entry, resource, textEdits, responseModel);
+        }
         await entry.acceptAgentEdits(resource, textEdits, isLastEdits, responseModel);
     }
     _getTelemetryInfoForModel(responseModel) {
@@ -426,7 +629,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
                 else if (responseModel.session.initialLocation === ChatAgentLocation.EditorInline) {
                     return 'inlineChat';
                 }
-                return responseModel.session.initialLocation;
+                return undefined;
             }
         };
     }
@@ -439,10 +642,11 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         if (!entry) {
             return;
         }
-        this._timeline.ensureEditInUndoStopMatches(requestId, undoStop, entry,  true, undefined);
+        const label = undoStop ? `Request ${requestId} - Stop ${undoStop}` : `Request ${requestId}`;
+        this._timeline.createCheckpoint(requestId, undoStop, label);
         return entry.acceptStreamingEditsEnd();
     }
-    async _getOrCreateModifiedFileEntry(resource, ifNotExists, telemetryInfo) {
+    async _getOrCreateModifiedFileEntry(resource, ifNotExists, telemetryInfo, _initialContent) {
         resource = CellUri.parse(resource)?.notebook ?? resource;
         const existingEntry = this._entriesObs.get().find(e => isEqual(e.modifiedURI, resource));
         if (existingEntry) {
@@ -460,13 +664,13 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             }
         }
         else {
-            const initialContent = this._initialFileContents.get(resource);
+            const initialContent = _initialContent ?? this._initialFileContents.get(resource);
             const maybeEntry = await this._createModifiedFileEntry(resource, telemetryInfo, ifNotExists, initialContent);
             if (!maybeEntry) {
                 return undefined;
             }
             entry = maybeEntry;
-            if (!initialContent) {
+            if (initialContent === undefined) {
                 this._initialFileContents.set(resource, entry.initialContent);
             }
         }
@@ -485,7 +689,13 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         return entry;
     }
     async _createModifiedFileEntry(resource, telemetryInfo, ifNotExists, initialContent) {
-        const multiDiffEntryDelegate = { collapse: (transaction) => this._collapse(resource, transaction) };
+        const multiDiffEntryDelegate = {
+            collapse: (transaction) => this._collapse(resource, transaction),
+            recordOperation: (operation) => {
+                operation.epoch = this._timeline.incrementEpoch();
+                this._timeline.recordFileOperation(operation);
+            },
+        };
         const notebookUri = CellUri.parse(resource)?.notebook || resource;
         const doCreate = async (chatKind) => {
             if (this._notebookService.hasSupportedNotebooks(notebookUri)) {
@@ -504,7 +714,17 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
                 return undefined;
             }
             await this._bulkEditService.apply({ edits: [{ newResource: resource }] });
-            this._editorService.openEditor({ resource, options: { inactive: true, preserveFocus: true, pinned: true } });
+            if (this.configurationService.getValue('accessibility.openChatEditedFiles')) {
+                this._editorService.openEditor({ resource, options: { inactive: true, preserveFocus: true, pinned: true } });
+            }
+            this._timeline.recordFileOperation({
+                type: FileOperationType.Create,
+                uri: resource,
+                requestId: telemetryInfo.requestId,
+                epoch: this._timeline.incrementEpoch(),
+                initialContent: initialContent || '',
+                telemetryInfo,
+            });
             if (this._notebookService.hasSupportedNotebooks(notebookUri)) {
                 return await ChatEditingModifiedNotebookEntry.create(resource, multiDiffEntryDelegate, telemetryInfo, ChatEditKind.Created, initialContent, this._instantiationService);
             }
@@ -522,17 +742,19 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         }
     }
 };
-ChatEditingSession = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IModelService)),
-    ( __param(5, ILanguageService)),
-    ( __param(6, ITextModelService)),
-    ( __param(7, IBulkEditService)),
-    ( __param(8, IEditorGroupsService)),
-    ( __param(9, IEditorService)),
-    ( __param(10, IChatService)),
-    ( __param(11, INotebookService)),
-    ( __param(12, IAccessibilitySignalService))
+ChatEditingSession = ChatEditingSession_1 = ( __decorate([
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IModelService)),
+    ( __param(6, ILanguageService)),
+    ( __param(7, ITextModelService)),
+    ( __param(8, IBulkEditService)),
+    ( __param(9, IEditorGroupsService)),
+    ( __param(10, IEditorService)),
+    ( __param(11, IChatService)),
+    ( __param(12, INotebookService)),
+    ( __param(13, IAccessibilitySignalService)),
+    ( __param(14, ILogService)),
+    ( __param(15, IConfigurationService))
 ], ChatEditingSession));
 
 export { ChatEditingSession };