@codingame/monaco-vscode-chat-service-override 19.1.4 → 20.0.0

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

@@ -1,33 +1,27 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { equals, binarySearch2 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
-import { findLast } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
 import { Sequencer, timeout, SequencerByKey, DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 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 { Iterable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/iterator';
-import { Disposable, DisposableStore, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable, 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 { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service';
 import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
-import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.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 { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
-import { DiffEditorInput } from '@codingame/monaco-vscode-9c72783f-914c-50be-b9ef-da16356d81a8-common/vscode/vs/workbench/common/editor/diffEditorInput';
+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-1cc4ea0a-c5b6-54ed-bb60-078a99119b55-common/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-0af61f78-dfc5-57ba-8d32-66268c8de38d-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';
@@ -37,14 +31,11 @@ import { AbstractChatEditingModifiedFileEntry } from './chatEditingModifiedFileE
 import { ChatEditingModifiedNotebookEntry } from './chatEditingModifiedNotebookEntry.js';
 import { ChatEditingSessionStorage } from './chatEditingSessionStorage.js';
 import { ChatEditingTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
-import { ChatEditingModifiedNotebookDiff } from './notebook/chatEditingModifiedNotebookDiff.js';
+import { ChatEditingTimeline } from './chatEditingTimeline.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-import { derived, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
-import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
 
-const POST_EDIT_STOP_ID = 'd19944f6-f46c-4e17-911b-79a8e843c7c0';
 class ThrottledSequencer extends Sequencer {
     constructor(_minDuration, _maxOverallDelay) {
         super();
@@ -70,16 +61,6 @@ class ThrottledSequencer extends Sequencer {
         });
     }
 }
-function getMaxHistoryIndex(history) {
-    const lastHistory = history.at(-1);
-    return lastHistory ? lastHistory.startIndex + lastHistory.stops.length : 0;
-}
-function snapshotsEqualForDiff(a, b) {
-    if (!a || !b) {
-        return a === b;
-    }
-    return isEqual(a.snapshotUri, b.snapshotUri) && a.current === b.current;
-}
 function getCurrentAndNextStop(requestId, stopId, history) {
     const snapshotIndex = history.findIndex(s => s.requestId === requestId);
     if (snapshotIndex === -1) {
@@ -93,39 +74,12 @@ function getCurrentAndNextStop(requestId, stopId, history) {
     const current = snapshot.stops[stopIndex].entries;
     const next = stopIndex < snapshot.stops.length - 1
         ? snapshot.stops[stopIndex + 1].entries
-        : snapshot.postEdit || history[snapshotIndex + 1]?.stops[0].entries;
+        : history[snapshotIndex + 1]?.stops[0].entries;
     if (!next) {
         return undefined;
     }
     return { current, next };
 }
-function getFirstAndLastStop(uri, history) {
-    let firstStopWithUri;
-    for (const snapshot of history) {
-        const stop = snapshot.stops.find(s => ( s.entries.has(uri)));
-        if (stop) {
-            firstStopWithUri = stop;
-            break;
-        }
-    }
-    let lastStopWithUri;
-    for (let i = history.length - 1; i >= 0; i--) {
-        const snapshot = history[i];
-        if (snapshot.postEdit?.has(uri)) {
-            lastStopWithUri = snapshot.postEdit;
-            break;
-        }
-        const stop = findLast(snapshot.stops, s => ( s.entries.has(uri)));
-        if (stop) {
-            lastStopWithUri = stop.entries;
-            break;
-        }
-    }
-    if (!firstStopWithUri || !lastStopWithUri) {
-        return undefined;
-    }
-    return { current: firstStopWithUri.entries, next: lastStopWithUri };
-}
 let ChatEditingSession = class ChatEditingSession extends Disposable {
     get entries() {
         this._assertNotDisposed();
@@ -138,7 +92,7 @@ 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, _editorWorkerService, _configurationService, _accessibilitySignalService) {
+    constructor(chatSessionId, isGlobalEditingSession, _lookupExternalEntry, _instantiationService, _modelService, _languageService, _textModelService, _bulkEditService, _editorGroupsService, _editorService, _chatService, _notebookService, _accessibilitySignalService) {
         super();
         this.chatSessionId = chatSessionId;
         this.isGlobalEditingSession = isGlobalEditingSession;
@@ -152,33 +106,24 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this._editorService = _editorService;
         this._chatService = _chatService;
         this._notebookService = _notebookService;
-        this._editorWorkerService = _editorWorkerService;
-        this._configurationService = _configurationService;
         this._accessibilitySignalService = _accessibilitySignalService;
         this._state = observableValue(this, ChatEditingSessionState.Initial);
-        this._linearHistory = observableValue(this, []);
-        this._linearHistoryIndex = observableValue(this, 0);
         this._initialFileContents = ( new ResourceMap());
         this._entriesObs = observableValue(this, []);
-        this.canUndo = derived((r) => {
-            if (this.state.read(r) !== ChatEditingSessionState.Idle) {
-                return false;
-            }
-            const linearHistoryIndex = this._linearHistoryIndex.read(r);
-            return linearHistoryIndex > 0;
-        });
-        this.canRedo = derived((r) => {
-            if (this.state.read(r) !== ChatEditingSessionState.Idle) {
-                return false;
-            }
-            const linearHistoryIndex = this._linearHistoryIndex.read(r);
-            return linearHistoryIndex < getMaxHistoryIndex(this._linearHistory.read(r));
-        });
         this._onDidDispose = ( new Emitter());
-        this._diffsBetweenStops = ( new Map());
-        this._fullDiffs = ( new Map());
+        this._pendingSnapshot = observableValue(this, undefined);
         this._streamingEditLocks = ( new SequencerByKey());
-        this._ignoreTrimWhitespaceObservable = observableConfigValue('diffEditor.ignoreTrimWhitespace', true, this._configurationService);
+        this._timeline = _instantiationService.createInstance(ChatEditingTimeline);
+        this.canRedo = ( this._timeline.canRedo.map(
+            (hasHistory, reader) => hasHistory && this._state.read(reader) === ChatEditingSessionState.Idle
+        ));
+        this.canUndo = ( this._timeline.canUndo.map(
+            (hasHistory, reader) => hasHistory && this._state.read(reader) === ChatEditingSessionState.Idle
+        ));
+        this._register(autorun(reader => {
+            const disabled = this._timeline.requestDisablement.read(reader);
+            this._chatService.getSession(this.chatSessionId)?.setDisabledRequests(disabled);
+        }));
     }
     async init() {
         const restoredSessionState = await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).restoreState();
@@ -186,11 +131,10 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             for (const [uri, content] of restoredSessionState.initialFileContents) {
                 this._initialFileContents.set(uri, content);
             }
-            this._pendingSnapshot = restoredSessionState.pendingSnapshot;
             await this._restoreSnapshot(restoredSessionState.recentSnapshot, false);
-            transaction(async (tx) => {
-                this._linearHistory.set(restoredSessionState.linearHistory, tx);
-                this._linearHistoryIndex.set(restoredSessionState.linearHistoryIndex, tx);
+            transaction(tx => {
+                this._pendingSnapshot.set(restoredSessionState.pendingSnapshot, tx);
+                this._timeline.restoreFromState({ history: restoredSessionState.linearHistory, index: restoredSessionState.linearHistoryIndex }, tx);
                 this._state.set(ChatEditingSessionState.Idle, tx);
             });
         }
@@ -217,182 +161,38 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     }
     storeState() {
         const storage = this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId);
+        const timelineState = this._timeline.getStateForPersistence();
         const state = {
             initialFileContents: this._initialFileContents,
-            pendingSnapshot: this._pendingSnapshot,
+            pendingSnapshot: this._pendingSnapshot.get(),
             recentSnapshot: this._createSnapshot(undefined, undefined),
-            linearHistoryIndex: this._linearHistoryIndex.get(),
-            linearHistory: this._linearHistory.get(),
+            linearHistoryIndex: timelineState.index,
+            linearHistory: timelineState.history,
         };
         return storage.storeState(state);
     }
-    _findSnapshot(requestId) {
-        return this._linearHistory.get().find(s => s.requestId === requestId);
-    }
-    _findEditStop(requestId, undoStop) {
-        const snapshot = this._findSnapshot(requestId);
-        if (!snapshot) {
-            return undefined;
-        }
-        const idx = snapshot.stops.findIndex(s => s.stopId === undoStop);
-        return idx === -1 ? undefined : { stop: snapshot.stops[idx], snapshot, historyIndex: snapshot.startIndex + idx };
-    }
     _ensurePendingSnapshot() {
-        this._pendingSnapshot ??= this._createSnapshot(undefined, undefined);
-    }
-    _entryDiffBetweenTextStops(entriesContent, modelUrisObservable) {
-        const modelRefsPromise = derived(this, (reader) => {
-            const modelUris = modelUrisObservable.read(reader);
-            if (!modelUris) {
-                return undefined;
-            }
-            const store = reader.store.add(( new DisposableStore()));
-            const promise = Promise.all(( modelUris.map(u => this._textModelService.createModelReference(u)))).then(refs => {
-                if (store.isDisposed) {
-                    refs.forEach(r => r.dispose());
-                }
-                else {
-                    refs.forEach(r => store.add(r));
-                }
-                return refs;
-            });
-            return ( new ObservablePromise(promise));
-        });
-        return derived((reader) => {
-            const refs2 = modelRefsPromise.read(reader)?.promiseResult.read(reader);
-            const refs = refs2?.data;
-            if (!refs) {
-                return;
-            }
-            const entries = entriesContent.read(reader);
-            if (entries?.before && ChatEditingModifiedNotebookEntry.canHandleSnapshot(entries.before)) {
-                const diffService = this._instantiationService.createInstance(ChatEditingModifiedNotebookDiff, entries.before, entries.after);
-                return ( new ObservablePromise(diffService.computeDiff()));
-            }
-            const ignoreTrimWhitespace = this._ignoreTrimWhitespaceObservable.read(reader);
-            const promise = this._editorWorkerService.computeDiff(refs[0].object.textEditorModel.uri, refs[1].object.textEditorModel.uri, { ignoreTrimWhitespace, computeMoves: false, maxComputationTimeMs: 3000 }, 'advanced').then((diff) => {
-                const entryDiff = {
-                    originalURI: refs[0].object.textEditorModel.uri,
-                    modifiedURI: refs[1].object.textEditorModel.uri,
-                    identical: !!diff?.identical,
-                    quitEarly: !diff || diff.quitEarly,
-                    added: 0,
-                    removed: 0,
-                };
-                if (diff) {
-                    for (const change of diff.changes) {
-                        entryDiff.removed += change.original.endLineNumberExclusive - change.original.startLineNumber;
-                        entryDiff.added += change.modified.endLineNumberExclusive - change.modified.startLineNumber;
-                    }
-                }
-                return entryDiff;
-            });
-            return ( new ObservablePromise(promise));
-        });
-    }
-    _createDiffBetweenStopsObservable(uri, requestId, stopId) {
-        const entries = derivedOpts({
-            equalsFn: (a, b) => snapshotsEqualForDiff(a?.before, b?.before) && snapshotsEqualForDiff(a?.after, b?.after),
-        }, reader => {
-            const stops = requestId ?
-                getCurrentAndNextStop(requestId, stopId, this._linearHistory.read(reader)) :
-                getFirstAndLastStop(uri, this._linearHistory.read(reader));
-            if (!stops) {
-                return undefined;
-            }
-            const before = stops.current.get(uri);
-            const after = stops.next.get(uri);
-            if (!before || !after) {
-                return undefined;
-            }
-            return { before, after };
-        });
-        const modelUrisObservable = derivedOpts({ equalsFn: (a, b) => equals(a, b, isEqual) }, reader => {
-            const entriesValue = entries.read(reader);
-            if (!entriesValue) {
-                return undefined;
-            }
-            return [entriesValue.before.snapshotUri, entriesValue.after.snapshotUri];
-        });
-        const diff = this._entryDiffBetweenTextStops(entries, modelUrisObservable);
-        return derived(reader => {
-            return diff.read(reader)?.promiseResult.read(reader)?.data || undefined;
-        });
+        const prev = this._pendingSnapshot.get();
+        if (!prev) {
+            this._pendingSnapshot.set(this._createSnapshot(undefined, undefined), undefined);
+        }
     }
     getEntryDiffBetweenStops(uri, requestId, stopId) {
-        if (requestId) {
-            const key = `${uri}\0${requestId}\0${stopId}`;
-            let observable = this._diffsBetweenStops.get(key);
-            if (!observable) {
-                observable = this._createDiffBetweenStopsObservable(uri, requestId, stopId);
-                this._diffsBetweenStops.set(key, observable);
-            }
-            return observable;
-        }
-        else {
-            const key = ( uri.toString());
-            let observable = this._fullDiffs.get(key);
-            if (!observable) {
-                observable = this._createDiffBetweenStopsObservable(uri, requestId, stopId);
-                this._fullDiffs.set(key, observable);
-            }
-            return observable;
-        }
+        return this._timeline.getEntryDiffBetweenStops(uri, requestId, stopId);
     }
     createSnapshot(requestId, undoStop, makeEmpty = undoStop !== undefined) {
-        const snapshot = makeEmpty ? this._createEmptySnapshot(undoStop) : this._createSnapshot(requestId, undoStop);
-        const linearHistoryPtr = this._linearHistoryIndex.get();
-        const newLinearHistory = [];
-        for (const entry of this._linearHistory.get()) {
-            if (entry.startIndex >= linearHistoryPtr) {
-                break;
-            }
-            else if (linearHistoryPtr - entry.startIndex < entry.stops.length) {
-                newLinearHistory.push({ requestId: entry.requestId, stops: entry.stops.slice(0, linearHistoryPtr - entry.startIndex), startIndex: entry.startIndex, postEdit: undefined });
-            }
-            else {
-                newLinearHistory.push(entry);
-            }
-        }
-        const lastEntry = newLinearHistory.at(-1);
-        if (requestId && lastEntry?.requestId === requestId) {
-            if (lastEntry.postEdit && undoStop) {
-                const rebaseUri = (uri) => ( URI.parse(( uri.toString()).replaceAll(POST_EDIT_STOP_ID, undoStop)));
-                for (const [uri, prev] of lastEntry.postEdit.entries()) {
-                    snapshot.entries.set(uri, { ...prev, snapshotUri: rebaseUri(prev.snapshotUri), resource: rebaseUri(prev.resource) });
-                }
-            }
-            newLinearHistory[newLinearHistory.length - 1] = { ...lastEntry, stops: [...lastEntry.stops, snapshot], postEdit: undefined };
-        }
-        else {
-            newLinearHistory.push({ requestId, startIndex: lastEntry ? lastEntry.startIndex + lastEntry.stops.length : 0, stops: [snapshot], postEdit: undefined });
-        }
-        transaction((tx) => {
-            const last = newLinearHistory[newLinearHistory.length - 1];
-            this._linearHistory.set(newLinearHistory, tx);
-            this._linearHistoryIndex.set(last.startIndex + last.stops.length, tx);
-        });
+        this._timeline.pushSnapshot(requestId, undoStop, makeEmpty ? ChatEditingTimeline.createEmptySnapshot(undoStop) : this._createSnapshot(requestId, undoStop));
     }
-    _createEmptySnapshot(undoStop) {
-        return {
-            stopId: undoStop,
-            entries: ( new ResourceMap()),
-        };
-    }
-    _createSnapshot(requestId, undoStop) {
+    _createSnapshot(requestId, stopId) {
         const entries = ( new ResourceMap());
         for (const entry of this._entriesObs.get()) {
-            entries.set(entry.modifiedURI, entry.createSnapshot(requestId, undoStop));
+            entries.set(entry.modifiedURI, entry.createSnapshot(requestId, stopId));
         }
-        return {
-            stopId: undoStop,
-            entries,
-        };
+        return { stopId, entries };
     }
     getSnapshot(requestId, undoStop, snapshotUri) {
-        const entries = undoStop === POST_EDIT_STOP_ID
-            ? this._findSnapshot(requestId)?.postEdit
-            : this._findEditStop(requestId, undoStop)?.stop.entries;
+        const stopRef = this._timeline.getSnapshotForRestore(requestId, undoStop);
+        const entries = stopRef?.stop.entries;
         return entries && [...( entries.values())].find((e) => isEqual(e.snapshotUri, snapshotUri));
     }
     async getSnapshotModel(requestId, undoStop, snapshotUri) {
@@ -403,25 +203,25 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         return this._modelService.createModel(snapshotEntry.current, this._languageService.createById(snapshotEntry.languageId), snapshotUri, false);
     }
     getSnapshotUri(requestId, uri, stopId) {
-        const stops = getCurrentAndNextStop(requestId, stopId, this._linearHistory.get());
+        const timelineState = this._timeline.getStateForPersistence();
+        const stops = getCurrentAndNextStop(requestId, stopId, timelineState.history);
         return stops?.next.get(uri)?.snapshotUri;
     }
     async restoreSnapshot(requestId, stopId) {
         if (requestId !== undefined) {
-            const stopRef = this._findEditStop(requestId, stopId);
+            const stopRef = this._timeline.getSnapshotForRestore(requestId, stopId);
             if (stopRef) {
                 this._ensurePendingSnapshot();
-                this._linearHistoryIndex.set(stopRef.historyIndex, undefined);
                 await this._restoreSnapshot(stopRef.stop);
-                this._updateRequestHiddenState();
+                stopRef.apply();
             }
         }
         else {
-            const pendingSnapshot = this._pendingSnapshot;
+            const pendingSnapshot = this._pendingSnapshot.get();
             if (!pendingSnapshot) {
                 return;
             }
-            this._pendingSnapshot = undefined;
+            this._pendingSnapshot.set(undefined, undefined);
             await this._restoreSnapshot(pendingSnapshot, undefined);
         }
     }
@@ -486,7 +286,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         }
         const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
             multiDiffSource: getMultiDiffSourceUri(this, previousChanges),
-            label: ( localize(4883, "Suggested Edits"))
+            label: ( localize(4962, "Suggested Edits"))
         }, this._instantiationService);
         this._editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
     }
@@ -570,104 +370,38 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             },
         };
     }
-    _getHistoryEntryByLinearIndex(index) {
-        const history = this._linearHistory.get();
-        const searchedIndex = binarySearch2(history.length, (e) => history[e].startIndex - index);
-        const entry = history[searchedIndex < 0 ? (~searchedIndex) - 1 : searchedIndex];
-        if (!entry || index - entry.startIndex >= entry.stops.length) {
-            return undefined;
-        }
-        return {
-            entry,
-            stop: entry.stops[index - entry.startIndex]
-        };
-    }
     async undoInteraction() {
-        const newIndex = this._linearHistoryIndex.get() - 1;
-        const previousSnapshot = this._getHistoryEntryByLinearIndex(newIndex);
-        if (!previousSnapshot) {
+        const undo = this._timeline.getUndoSnapshot();
+        if (!undo) {
             return;
         }
         this._ensurePendingSnapshot();
-        await this._restoreSnapshot(previousSnapshot.stop);
-        this._linearHistoryIndex.set(newIndex, undefined);
-        this._updateRequestHiddenState();
+        await this._restoreSnapshot(undo.stop);
+        undo.apply();
     }
     async redoInteraction() {
-        const maxIndex = getMaxHistoryIndex(this._linearHistory.get());
-        const newIndex = this._linearHistoryIndex.get() + 1;
-        if (newIndex > maxIndex) {
-            return;
-        }
-        const nextSnapshot = newIndex === maxIndex ? this._pendingSnapshot : this._getHistoryEntryByLinearIndex(newIndex)?.stop;
+        const redo = this._timeline.getRedoSnapshot();
+        const nextSnapshot = redo?.stop || this._pendingSnapshot.get();
         if (!nextSnapshot) {
             return;
         }
         await this._restoreSnapshot(nextSnapshot);
-        this._linearHistoryIndex.set(newIndex, undefined);
-        this._updateRequestHiddenState();
-    }
-    _updateRequestHiddenState() {
-        const history = this._linearHistory.get();
-        const index = this._linearHistoryIndex.get();
-        const undoRequests = [];
-        for (const entry of history) {
-            if (!entry.requestId) ;
-            else if (entry.startIndex >= index) {
-                undoRequests.push({ requestId: entry.requestId });
-            }
-            else if (entry.startIndex + entry.stops.length > index) {
-                undoRequests.push({ requestId: entry.requestId, afterUndoStop: entry.stops[index - entry.startIndex].stopId });
-            }
+        if (redo) {
+            redo.apply();
+        }
+        else {
+            this._pendingSnapshot.set(undefined, undefined);
         }
-        this._chatService.getSession(this.chatSessionId)?.setDisabledRequests(undoRequests);
     }
     async _acceptStreamingEditsStart(responseModel, undoStop, resource) {
         const entry = await this._getOrCreateModifiedFileEntry(resource, this._getTelemetryInfoForModel(responseModel));
         transaction((tx) => {
             this._state.set(ChatEditingSessionState.StreamingEdits, tx);
             entry.acceptStreamingEditsStart(responseModel, tx);
-            this.ensureEditInUndoStopMatches(responseModel.requestId, undoStop, entry, false, tx);
+            this._timeline.ensureEditInUndoStopMatches(responseModel.requestId, undoStop, entry, false, tx);
         });
     }
-    ensureEditInUndoStopMatches(requestId, undoStop, entry, next, tx) {
-        const history = this._linearHistory.get();
-        const snapIndex = history.findIndex(s => s.requestId === requestId);
-        if (snapIndex === -1) {
-            return;
-        }
-        const snap = history[snapIndex];
-        let stopIndex = snap.stops.findIndex(s => s.stopId === undoStop);
-        if (stopIndex === -1) {
-            return;
-        }
-        if (next) {
-            if (stopIndex === snap.stops.length - 1) {
-                const postEdit = ( new ResourceMap(snap.postEdit || this._createEmptySnapshot(undefined).entries));
-                if (!snap.postEdit || !entry.equalsSnapshot(postEdit.get(entry.modifiedURI))) {
-                    postEdit.set(entry.modifiedURI, entry.createSnapshot(requestId, POST_EDIT_STOP_ID));
-                    const newHistory = history.slice();
-                    newHistory[snapIndex] = { ...snap, postEdit };
-                    this._linearHistory.set(newHistory, tx);
-                }
-                return;
-            }
-            stopIndex++;
-        }
-        const stop = snap.stops[stopIndex];
-        if (entry.equalsSnapshot(stop.entries.get(entry.modifiedURI))) {
-            return;
-        }
-        const newMap = ( new ResourceMap(stop.entries));
-        newMap.set(entry.modifiedURI, entry.createSnapshot(requestId, stop.stopId));
-        const newStop = snap.stops.slice();
-        newStop[stopIndex] = { ...stop, entries: newMap };
-        const newHistory = history.slice();
-        newHistory[snapIndex] = { ...snap, stops: newStop };
-        this._linearHistory.set(newHistory, tx);
-    }
     async _acceptEdits(resource, textEdits, isLastEdits, responseModel) {
-        this._fullDiffs.delete(( resource.toString()));
         const entry = await this._getOrCreateModifiedFileEntry(resource, this._getTelemetryInfoForModel(responseModel));
         await entry.acceptAgentEdits(resource, textEdits, isLastEdits, responseModel);
     }
@@ -689,7 +423,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         if (!entry) {
             return;
         }
-        this.ensureEditInUndoStopMatches(requestId, undoStop, entry,  true, undefined);
+        this._timeline.ensureEditInUndoStopMatches(requestId, undoStop, entry,  true, undefined);
         return entry.acceptStreamingEditsEnd();
     }
     async _getOrCreateModifiedFileEntry(resource, telemetryInfo) {
@@ -773,9 +507,7 @@ ChatEditingSession = ( __decorate([
     ( __param(9, IEditorService)),
     ( __param(10, IChatService)),
     ( __param(11, INotebookService)),
-    ( __param(12, IEditorWorkerService)),
-    ( __param(13, IConfigurationService)),
-    ( __param(14, IAccessibilitySignalService))
+    ( __param(12, IAccessibilitySignalService))
 ], ChatEditingSession));
 
 export { ChatEditingSession };

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

@@ -28,7 +28,6 @@ export interface IChatEditingSessionSnapshot {
     readonly startIndex: number;
     readonly requestId: string | undefined;
     readonly stops: IChatEditingSessionStop[];
-    readonly postEdit: ResourceMap<ISnapshotEntry> | undefined;
 }
 export interface IChatEditingSessionStop {
     stopId: string | undefined;