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

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

@@ -0,0 +1,646 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import { findLastIdx, findLast, findFirst } from '@codingame/monaco-vscode-api/vscode/vs/base/common/arraysFind';
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { ThrottledDelayer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { equals as equals$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+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 { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { TextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { CellUri, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { FileOperationType } from './chatEditingOperations.js';
+import { ChatEditingSnapshotTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
+import { restoreSnapshot, createSnapshot } from './notebook/chatEditingModifiedNotebookSnapshot.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { observableValueOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValueOpts';
+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 { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/promise';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
+
+const START_REQUEST_EPOCH = '$$start';
+const STOP_ID_EPOCH_PREFIX = '__epoch_';
+let ChatEditingCheckpointTimelineImpl = class ChatEditingCheckpointTimelineImpl {
+    constructor(chatSessionId, _delegate, _notebookEditorModelResolverService, _notebookService, _instantiationService, _modelService, _textModelService, _editorWorkerService, _configurationService) {
+        this.chatSessionId = chatSessionId;
+        this._delegate = _delegate;
+        this._notebookEditorModelResolverService = _notebookEditorModelResolverService;
+        this._notebookService = _notebookService;
+        this._instantiationService = _instantiationService;
+        this._modelService = _modelService;
+        this._textModelService = _textModelService;
+        this._editorWorkerService = _editorWorkerService;
+        this._configurationService = _configurationService;
+        this._epochCounter = 0;
+        this._checkpoints = observableValue(this, []);
+        this._currentEpoch = observableValue(this, 0);
+        this._operations = observableValueOpts({ equalsFn: () => false }, []);
+        this._fileBaselines = ( new Map());
+        this._willUndoToCheckpoint = derived(reader => {
+            const currentEpoch = this._currentEpoch.read(reader);
+            const checkpoints = this._checkpoints.read(reader);
+            if (checkpoints.length < 2 || currentEpoch <= checkpoints[1].epoch) {
+                return undefined;
+            }
+            const operations = this._operations.read(reader);
+            const currentCheckpointIdx = findLastIdx(checkpoints, cp => cp.epoch < currentEpoch);
+            const startOfRequest = currentCheckpointIdx === -1 ? undefined : findLast(checkpoints, cp => cp.undoStopId === undefined, currentCheckpointIdx);
+            const previousOperation = findLast(operations, op => op.epoch < currentEpoch);
+            const previousCheckpoint = previousOperation && findLast(checkpoints, cp => cp.epoch < previousOperation.epoch);
+            if (!startOfRequest) {
+                return previousCheckpoint;
+            }
+            if (!previousCheckpoint) {
+                return startOfRequest;
+            }
+            if (!( operations.some(
+                op => op.epoch > startOfRequest.epoch && op.epoch < previousCheckpoint.epoch
+            ))) {
+                return startOfRequest;
+            }
+            return previousCheckpoint.epoch > startOfRequest.epoch ? previousCheckpoint : startOfRequest;
+        });
+        this.canUndo = ( this._willUndoToCheckpoint.map(cp => !!cp));
+        this._willRedoToEpoch = derived(reader => {
+            const currentEpoch = this._currentEpoch.read(reader);
+            const operations = this._operations.read(reader);
+            const checkpoints = this._checkpoints.read(reader);
+            const maxEncounteredEpoch = Math.max(operations.at(-1)?.epoch || 0, checkpoints.at(-1)?.epoch || 0);
+            if (currentEpoch > maxEncounteredEpoch) {
+                return undefined;
+            }
+            const nextOperation = operations.find(op => op.epoch >= currentEpoch);
+            const nextCheckpoint = nextOperation && checkpoints.find(op => op.epoch > nextOperation.epoch);
+            const currentCheckpoint = findLast(checkpoints, cp => cp.epoch < currentEpoch);
+            if (currentCheckpoint && nextOperation && currentCheckpoint.requestId !== nextOperation.requestId) {
+                const startOfNextRequestIdx = findLastIdx(checkpoints, (cp, i) => cp.undoStopId === undefined && (checkpoints[i - 1]?.requestId === currentCheckpoint.requestId));
+                const startOfNextRequest = startOfNextRequestIdx === -1 ? undefined : checkpoints[startOfNextRequestIdx];
+                if (startOfNextRequest && nextOperation.requestId !== startOfNextRequest.requestId) {
+                    const requestAfterTheNext = findFirst(checkpoints, op => op.undoStopId === undefined, startOfNextRequestIdx + 1);
+                    if (requestAfterTheNext) {
+                        return requestAfterTheNext.epoch;
+                    }
+                }
+            }
+            return Math.min(nextCheckpoint?.epoch || Infinity, (maxEncounteredEpoch + 1));
+        });
+        this.canRedo = ( this._willRedoToEpoch.map(e => !!e));
+        this.requestDisablement = derivedOpts({ equalsFn: (a, b) => equals(a, b, equals$1) }, reader => {
+            const currentEpoch = this._currentEpoch.read(reader);
+            const operations = this._operations.read(reader);
+            const checkpoints = this._checkpoints.read(reader);
+            const maxEncounteredEpoch = Math.max(operations.at(-1)?.epoch || 0, checkpoints.at(-1)?.epoch || 0);
+            if (currentEpoch > maxEncounteredEpoch) {
+                return [];
+            }
+            const lastAppliedOperation = findLast(operations, op => op.epoch < currentEpoch)?.epoch || 0;
+            const lastAppliedRequest = findLast(checkpoints, cp => cp.epoch < currentEpoch && cp.undoStopId === undefined)?.epoch || 0;
+            const stopDisablingAtEpoch = Math.max(lastAppliedOperation, lastAppliedRequest);
+            const disablement = ( new Map());
+            for (let i = checkpoints.length - 1; i >= 0; i--) {
+                const { undoStopId, requestId, epoch } = checkpoints[i];
+                if (epoch <= stopDisablingAtEpoch) {
+                    break;
+                }
+                if (requestId) {
+                    disablement.set(requestId, undoStopId);
+                }
+            }
+            return ( [...disablement].map(([requestId, afterUndoStop]) => ({ requestId, afterUndoStop })));
+        });
+        this.createCheckpoint(undefined, undefined, 'Initial State', 'Starting point before any edits');
+    }
+    createCheckpoint(requestId, undoStopId, label, description) {
+        const existingCheckpoints = this._checkpoints.get();
+        const existing = existingCheckpoints.find(c => c.undoStopId === undoStopId && c.requestId === requestId);
+        if (existing) {
+            return existing.checkpointId;
+        }
+        const { checkpoints, operations } = this._getVisibleOperationsAndCheckpoints();
+        const checkpointId = generateUuid();
+        const epoch = this.incrementEpoch();
+        checkpoints.push({
+            checkpointId,
+            requestId,
+            undoStopId,
+            epoch,
+            label,
+            description
+        });
+        transaction(tx => {
+            this._checkpoints.set(checkpoints, tx);
+            this._operations.set(operations, tx);
+            this._currentEpoch.set(epoch + 1, tx);
+        });
+        return checkpointId;
+    }
+    async undoToLastCheckpoint() {
+        const checkpoint = this._willUndoToCheckpoint.get();
+        if (checkpoint) {
+            await this.navigateToCheckpoint(checkpoint.checkpointId);
+        }
+    }
+    async redoToNextCheckpoint() {
+        const targetEpoch = this._willRedoToEpoch.get();
+        if (targetEpoch) {
+            await this._navigateToEpoch(targetEpoch);
+        }
+    }
+    navigateToCheckpoint(checkpointId) {
+        const targetCheckpoint = this._getCheckpoint(checkpointId);
+        if (!targetCheckpoint) {
+            throw ( new Error(`Checkpoint ${checkpointId} not found`));
+        }
+        if (targetCheckpoint.undoStopId === undefined) {
+            return this._navigateToEpoch(targetCheckpoint.epoch + 1, targetCheckpoint.epoch);
+        }
+        else {
+            return this._navigateToEpoch(targetCheckpoint.epoch + 1);
+        }
+    }
+    getContentURIAtStop(requestId, fileURI, stopId) {
+        return ChatEditingSnapshotTextModelContentProvider.getSnapshotFileURI(this.chatSessionId, requestId, stopId, fileURI.path);
+    }
+    async _navigateToEpoch(restoreToEpoch, navigateToEpoch = restoreToEpoch) {
+        const currentEpoch = this._currentEpoch.get();
+        if (currentEpoch !== restoreToEpoch) {
+            const urisToRestore = await this._applyFileSystemOperations(currentEpoch, restoreToEpoch);
+            await this._reconstructAllFileContents(restoreToEpoch, urisToRestore);
+        }
+        this._currentEpoch.set(navigateToEpoch, undefined);
+    }
+    _getCheckpoint(checkpointId) {
+        return this._checkpoints.get().find(c => c.checkpointId === checkpointId);
+    }
+    incrementEpoch() {
+        return this._epochCounter++;
+    }
+    recordFileOperation(operation) {
+        const { currentEpoch, checkpoints, operations } = this._getVisibleOperationsAndCheckpoints();
+        if (operation.epoch < currentEpoch) {
+            throw ( new Error(
+                `Cannot record operation at epoch ${operation.epoch} when current epoch is ${currentEpoch}`
+            ));
+        }
+        operations.push(operation);
+        transaction(tx => {
+            this._checkpoints.set(checkpoints, tx);
+            this._operations.set(operations, tx);
+            this._currentEpoch.set(operation.epoch + 1, tx);
+        });
+    }
+    _getVisibleOperationsAndCheckpoints() {
+        const currentEpoch = this._currentEpoch.get();
+        const checkpoints = this._checkpoints.get();
+        const operations = this._operations.get();
+        return {
+            currentEpoch,
+            checkpoints: checkpoints.filter(c => c.epoch < currentEpoch),
+            operations: operations.filter(op => op.epoch < currentEpoch)
+        };
+    }
+    recordFileBaseline(baseline) {
+        const key = this._getBaselineKey(baseline.uri, baseline.requestId);
+        this._fileBaselines.set(key, baseline);
+    }
+    _getFileBaseline(uri, requestId) {
+        const key = this._getBaselineKey(uri, requestId);
+        return this._fileBaselines.get(key);
+    }
+    hasFileBaseline(uri, requestId) {
+        const key = this._getBaselineKey(uri, requestId);
+        return ( this._fileBaselines.has(key));
+    }
+    async getContentAtStop(requestId, contentURI, stopId) {
+        let toEpoch;
+        if (stopId?.startsWith(STOP_ID_EPOCH_PREFIX)) {
+            toEpoch = Number(stopId.slice(STOP_ID_EPOCH_PREFIX.length));
+        }
+        else {
+            toEpoch = this._checkpoints.get().find(c => c.requestId === requestId && c.undoStopId === stopId)?.epoch;
+        }
+        const fileURI = this._getTimelineCanonicalUriForPath(contentURI);
+        if (!toEpoch || !fileURI) {
+            return '';
+        }
+        const baseline = await this._findBestBaselineForFile(fileURI, toEpoch, requestId);
+        if (!baseline) {
+            return '';
+        }
+        const operations = this._getFileOperationsInRange(fileURI, baseline.epoch, toEpoch);
+        const replayed = await this._replayOperations(baseline, operations);
+        return replayed.exists ? replayed.content : undefined;
+    }
+    _getTimelineCanonicalUriForPath(contentURI) {
+        for (const it of [( this._fileBaselines.values()), this._operations.get()]) {
+            for (const thing of it) {
+                if (thing.uri.path === contentURI.path) {
+                    return thing.uri;
+                }
+            }
+        }
+        return undefined;
+    }
+    onDidChangeContentsAtStop(requestId, contentURI, stopId, callback) {
+        if (!stopId || !stopId.startsWith(STOP_ID_EPOCH_PREFIX)) {
+            return Disposable.None;
+        }
+        const target = Number(stopId.slice(STOP_ID_EPOCH_PREFIX.length));
+        if (target <= this._epochCounter) {
+            return Disposable.None;
+        }
+        const store = ( new DisposableStore());
+        const scheduler = store.add(( new ThrottledDelayer(500)));
+        store.add(Event.fromObservableLight(this._operations)(() => {
+            scheduler.trigger(async () => {
+                if (this._operations.get().at(-1)?.epoch >= target) {
+                    store.dispose();
+                }
+                const content = await this.getContentAtStop(requestId, contentURI, stopId);
+                if (content !== undefined) {
+                    callback(content);
+                }
+            });
+        }));
+        return store;
+    }
+    _getCheckpointBeforeEpoch(epoch, reader) {
+        return findLast(this._checkpoints.read(reader), c => c.epoch <= epoch);
+    }
+    async _reconstructFileState(uri, targetEpoch) {
+        const targetCheckpoint = this._getCheckpointBeforeEpoch(targetEpoch);
+        if (!targetCheckpoint) {
+            throw ( new Error(`Checkpoint for epoch ${targetEpoch} not found`));
+        }
+        const baseline = await this._findBestBaselineForFile(uri, targetEpoch, targetCheckpoint.requestId || '');
+        if (!baseline) {
+            return {
+                exists: false,
+                uri,
+            };
+        }
+        const operations = this._getFileOperationsInRange(uri, baseline.epoch, targetEpoch);
+        return this._replayOperations(baseline, operations);
+    }
+    getStateForPersistence() {
+        return {
+            checkpoints: this._checkpoints.get(),
+            currentEpoch: this._currentEpoch.get(),
+            fileBaselines: [...this._fileBaselines],
+            operations: this._operations.get(),
+            epochCounter: this._epochCounter,
+        };
+    }
+    restoreFromState(state, tx) {
+        this._checkpoints.set(state.checkpoints, tx);
+        this._currentEpoch.set(state.currentEpoch, tx);
+        this._operations.set(state.operations.slice(), tx);
+        this._epochCounter = state.epochCounter;
+        this._fileBaselines.clear();
+        for (const [key, baseline] of state.fileBaselines) {
+            this._fileBaselines.set(key, baseline);
+        }
+    }
+    getCheckpointIdForRequest(requestId, undoStopId) {
+        const checkpoints = this._checkpoints.get();
+        return checkpoints.find(c => c.requestId === requestId && c.undoStopId === undoStopId)?.checkpointId;
+    }
+    async _reconstructAllFileContents(targetEpoch, filesToReconstruct) {
+        await Promise.all(( Array.from(filesToReconstruct).map(async (uri) => {
+            const reconstructedState = await this._reconstructFileState(uri, targetEpoch);
+            if (reconstructedState.exists) {
+                await this._delegate.setContents(reconstructedState.uri, reconstructedState.content, reconstructedState.telemetryInfo);
+            }
+        })));
+    }
+    _getBaselineKey(uri, requestId) {
+        return `${( uri.toString())}::${requestId}`;
+    }
+    async _findBestBaselineForFile(uri, epoch, requestId) {
+        let currentRequestId = requestId;
+        const operations = this._operations.get();
+        for (let i = operations.length - 1; i >= 0; i--) {
+            const operation = operations[i];
+            if (operation.epoch > epoch) {
+                continue;
+            }
+            if (operation.type === FileOperationType.Create && isEqual(operation.uri, uri)) {
+                return {
+                    uri: operation.uri,
+                    requestId: operation.requestId,
+                    content: operation.initialContent,
+                    epoch: operation.epoch,
+                    telemetryInfo: operation.telemetryInfo,
+                };
+            }
+            if (operation.type === FileOperationType.Rename && isEqual(operation.newUri, uri)) {
+                const prev = await this._findBestBaselineForFile(operation.oldUri, operation.epoch, operation.requestId);
+                if (!prev) {
+                    return undefined;
+                }
+                const operations = this._getFileOperationsInRange(operation.oldUri, prev.epoch, operation.epoch);
+                const replayed = await this._replayOperations(prev, operations);
+                return {
+                    uri: uri,
+                    epoch: operation.epoch,
+                    content: replayed.exists ? replayed.content : '',
+                    requestId: operation.requestId,
+                    telemetryInfo: prev.telemetryInfo,
+                    notebookViewType: replayed.exists ? replayed.notebookViewType : undefined,
+                };
+            }
+            if (currentRequestId && operation.requestId !== currentRequestId) {
+                const baseline = this._getFileBaseline(uri, currentRequestId);
+                if (baseline) {
+                    return baseline;
+                }
+            }
+            currentRequestId = operation.requestId;
+        }
+        return this._getFileBaseline(uri, currentRequestId);
+    }
+    _getFileOperationsInRange(uri, fromEpoch, toEpoch) {
+        return this._operations.get().filter(op => {
+            const cellUri = CellUri.parse(op.uri);
+            return op.epoch >= fromEpoch &&
+                op.epoch < toEpoch &&
+                (isEqual(op.uri, uri) || (cellUri && isEqual(cellUri.notebook, uri)));
+        }).sort((a, b) => a.epoch - b.epoch);
+    }
+    async _replayOperations(baseline, operations) {
+        let currentState = {
+            exists: true,
+            content: baseline.content,
+            uri: baseline.uri,
+            telemetryInfo: baseline.telemetryInfo,
+        };
+        if (baseline.notebookViewType) {
+            currentState.notebook = await this._notebookEditorModelResolverService.createUntitledNotebookTextModel(baseline.notebookViewType);
+            if (baseline.content) {
+                restoreSnapshot(currentState.notebook, baseline.content);
+            }
+        }
+        for (const operation of operations) {
+            currentState = await this._applyOperationToState(currentState, operation, baseline.telemetryInfo);
+        }
+        if (currentState.exists && currentState.notebook) {
+            const info = await this._notebookService.withNotebookDataProvider(currentState.notebook.viewType);
+            currentState.content = createSnapshot(currentState.notebook, info.serializer.options, this._configurationService);
+            currentState.notebook.dispose();
+        }
+        return currentState;
+    }
+    async _applyOperationToState(state, operation, telemetryInfo) {
+        switch (operation.type) {
+            case FileOperationType.Create: {
+                if (state.exists && state.notebook) {
+                    state.notebook.dispose();
+                }
+                let notebook;
+                if (operation.notebookViewType) {
+                    notebook = await this._notebookEditorModelResolverService.createUntitledNotebookTextModel(operation.notebookViewType);
+                    if (operation.initialContent) {
+                        restoreSnapshot(notebook, operation.initialContent);
+                    }
+                }
+                return {
+                    exists: true,
+                    content: operation.initialContent,
+                    uri: operation.uri,
+                    telemetryInfo,
+                    notebookViewType: operation.notebookViewType,
+                    notebook,
+                };
+            }
+            case FileOperationType.Delete:
+                if (state.exists && state.notebook) {
+                    state.notebook.dispose();
+                }
+                return {
+                    exists: false,
+                    uri: operation.uri
+                };
+            case FileOperationType.Rename:
+                return {
+                    ...state,
+                    uri: operation.newUri
+                };
+            case FileOperationType.TextEdit: {
+                if (!state.exists) {
+                    throw ( new Error('Cannot apply text edits to non-existent file'));
+                }
+                const nbCell = operation.cellIndex !== undefined && state.notebook?.cells.at(operation.cellIndex);
+                if (nbCell) {
+                    const newContent = this._applyTextEditsToContent(nbCell.getValue(), operation.edits);
+                    state.notebook.applyEdits([{
+                            editType: CellEditType.Replace,
+                            index: operation.cellIndex,
+                            count: 1,
+                            cells: [{ cellKind: nbCell.cellKind, language: nbCell.language, mime: nbCell.language, source: newContent, outputs: nbCell.outputs }]
+                        }], true, undefined, () => undefined, undefined);
+                    return state;
+                }
+                return {
+                    ...state,
+                    content: this._applyTextEditsToContent(state.content, operation.edits)
+                };
+            }
+            case FileOperationType.NotebookEdit:
+                if (!state.exists) {
+                    throw ( new Error('Cannot apply notebook edits to non-existent file'));
+                }
+                if (!state.notebook) {
+                    throw ( new Error('Cannot apply notebook edits to non-notebook file'));
+                }
+                state.notebook.applyEdits(operation.cellEdits.slice(), true, undefined, () => undefined, undefined);
+                return state;
+            default:
+                assertNever();
+        }
+    }
+    async _applyFileSystemOperations(fromEpoch, toEpoch) {
+        const isMovingForward = toEpoch > fromEpoch;
+        const operations = this._operations.get().filter(op => {
+            if (isMovingForward) {
+                return op.epoch >= fromEpoch && op.epoch < toEpoch;
+            }
+            else {
+                return op.epoch < fromEpoch && op.epoch >= toEpoch;
+            }
+        }).sort((a, b) => isMovingForward ? a.epoch - b.epoch : b.epoch - a.epoch);
+        const urisToRestore = ( new ResourceSet());
+        for (const operation of operations) {
+            await this._applyFileSystemOperation(operation, isMovingForward, urisToRestore);
+        }
+        return urisToRestore;
+    }
+    async _applyFileSystemOperation(operation, isMovingForward, urisToRestore) {
+        switch (operation.type) {
+            case FileOperationType.Create:
+                if (isMovingForward) {
+                    await this._delegate.createFile(operation.uri, operation.initialContent);
+                    urisToRestore.add(operation.uri);
+                }
+                else {
+                    await this._delegate.deleteFile(operation.uri);
+                    urisToRestore.delete(operation.uri);
+                }
+                break;
+            case FileOperationType.Delete:
+                if (isMovingForward) {
+                    await this._delegate.deleteFile(operation.uri);
+                    urisToRestore.delete(operation.uri);
+                }
+                else {
+                    await this._delegate.createFile(operation.uri, operation.finalContent);
+                    urisToRestore.add(operation.uri);
+                }
+                break;
+            case FileOperationType.Rename:
+                if (isMovingForward) {
+                    await this._delegate.renameFile(operation.oldUri, operation.newUri);
+                    urisToRestore.delete(operation.oldUri);
+                    urisToRestore.add(operation.newUri);
+                }
+                else {
+                    await this._delegate.renameFile(operation.newUri, operation.oldUri);
+                    urisToRestore.delete(operation.newUri);
+                    urisToRestore.add(operation.oldUri);
+                }
+                break;
+            case FileOperationType.TextEdit:
+            case FileOperationType.NotebookEdit:
+                urisToRestore.add(CellUri.parse(operation.uri)?.notebook ?? operation.uri);
+                break;
+            default:
+                assertNever();
+        }
+    }
+    _applyTextEditsToContent(content, edits) {
+        const makeModel = (uri, contents) => this._instantiationService.createInstance(TextModel, contents, '', this._modelService.getCreationOptions('', uri, true), uri);
+        const tempUri = ( URI.from({ scheme: 'temp', path: `/temp-${Date.now()}.txt` }));
+        const model = makeModel(tempUri, content);
+        try {
+            model.applyEdits(( edits.map(edit => ({
+                range: {
+                    startLineNumber: edit.range.startLineNumber,
+                    startColumn: edit.range.startColumn,
+                    endLineNumber: edit.range.endLineNumber,
+                    endColumn: edit.range.endColumn
+                },
+                text: edit.text
+            }))));
+            return model.getValue();
+        }
+        finally {
+            model.dispose();
+        }
+    }
+    getEntryDiffBetweenStops(uri, requestId, stopId) {
+        const epochs = derivedOpts({ equalsFn: (a, b) => a.start === b.start && a.end === b.end }, reader => {
+            const checkpoints = this._checkpoints.read(reader);
+            const startIndex = checkpoints.findIndex(c => c.requestId === requestId && c.undoStopId === stopId);
+            return { start: checkpoints[startIndex], end: checkpoints[startIndex + 1] };
+        });
+        return this._getEntryDiffBetweenEpochs(uri, epochs);
+    }
+    getEntryDiffBetweenRequests(uri, startRequestId, stopRequestId) {
+        const epochs = derivedOpts({ equalsFn: (a, b) => a.start === b.start && a.end === b.end }, reader => {
+            const checkpoints = this._checkpoints.read(reader);
+            const startIndex = checkpoints.findIndex(c => c.requestId === startRequestId);
+            const start = startIndex === -1 ? checkpoints[0] : checkpoints[startIndex];
+            const end = checkpoints.find(c => c.requestId === stopRequestId) || findFirst(checkpoints, c => c.requestId !== startRequestId, startIndex) || checkpoints[checkpoints.length - 1];
+            return { start, end };
+        });
+        return this._getEntryDiffBetweenEpochs(uri, epochs);
+    }
+    _getEntryDiffBetweenEpochs(uri, epochs) {
+        const modelRefsPromise = derived(this, (reader) => {
+            const { start, end } = epochs.read(reader);
+            if (!start) {
+                return undefined;
+            }
+            const store = reader.store.add(( new DisposableStore()));
+            const promise = Promise.all([
+                this._textModelService.createModelReference(this.getContentURIAtStop(start.requestId || START_REQUEST_EPOCH, uri, STOP_ID_EPOCH_PREFIX + start.epoch)),
+                this._textModelService.createModelReference(this.getContentURIAtStop(end?.requestId || start.requestId || START_REQUEST_EPOCH, uri, STOP_ID_EPOCH_PREFIX + (end?.epoch || Number.MAX_SAFE_INTEGER))),
+            ]).then(refs => {
+                if (store.isDisposed) {
+                    refs.forEach(r => r.dispose());
+                }
+                else {
+                    refs.forEach(r => store.add(r));
+                }
+                return { refs, isFinal: !!end };
+            });
+            return ( new ObservablePromise(promise));
+        });
+        const resolvedModels = derived(reader => {
+            const refs2 = modelRefsPromise.read(reader)?.promiseResult.read(reader);
+            return refs2?.data && {
+                isFinal: refs2.data.isFinal,
+                refs: ( refs2.data.refs.map(r => ({
+                    model: r.object.textEditorModel,
+                    onChange: observableSignalFromEvent(this, r.object.textEditorModel.onDidChangeContent.bind(r.object.textEditorModel)),
+                }))),
+            };
+        });
+        const diff = derived((reader) => {
+            const modelsData = resolvedModels.read(reader);
+            if (!modelsData) {
+                return;
+            }
+            const { refs, isFinal } = modelsData;
+            refs.forEach(m => m.onChange.read(reader));
+            const promise = this._computeDiff(refs[0].model.uri, refs[1].model.uri, isFinal);
+            return ( new ObservablePromise(promise));
+        });
+        return derived(reader => {
+            return diff.read(reader)?.promiseResult.read(reader)?.data || undefined;
+        });
+    }
+    _computeDiff(originalUri, modifiedUri, isFinal) {
+        return this._editorWorkerService.computeDiff(originalUri, modifiedUri, { ignoreTrimWhitespace: false, computeMoves: false, maxComputationTimeMs: 3000 }, 'advanced').then((diff) => {
+            const entryDiff = {
+                originalURI: originalUri,
+                modifiedURI: modifiedUri,
+                identical: !!diff?.identical,
+                isFinal,
+                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;
+        });
+    }
+};
+ChatEditingCheckpointTimelineImpl = ( __decorate([
+    ( __param(2, INotebookEditorModelResolverService)),
+    ( __param(3, INotebookService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IModelService)),
+    ( __param(6, ITextModelService)),
+    ( __param(7, IEditorWorkerService)),
+    ( __param(8, IConfigurationService))
+], ChatEditingCheckpointTimelineImpl));
+
+export { ChatEditingCheckpointTimelineImpl };

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

@@ -6,8 +6,8 @@ import { ITextModel } from "@codingame/monaco-vscode-api/vscode/vs/editor/common
 import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
-import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service";
 import { IModifiedFileEntry, IModifiedFileEntryChangeHunk, IModifiedFileEntryEditorIntegration } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
 export interface IDocumentDiff2 extends IDocumentDiff {
     originalModel: ITextModel;
     modifiedModel: ITextModel;
@@ -17,7 +17,6 @@ export interface IDocumentDiff2 extends IDocumentDiff {
 export declare class ChatEditingCodeEditorIntegration implements IModifiedFileEntryEditorIntegration {
     private readonly _entry;
     private readonly _editor;
-    private readonly _chatAgentService;
     private readonly _editorService;
     private readonly _accessibilitySignalsService;
     private static readonly _diffLineDecorationData;
@@ -30,7 +29,7 @@ export declare class ChatEditingCodeEditorIntegration implements IModifiedFileEn
     private readonly _diffHunkWidgets;
     private _viewZones;
     private readonly _accessibleDiffViewVisible;
-    constructor(_entry: IModifiedFileEntry, _editor: ICodeEditor, documentDiffInfo: IObservable<IDocumentDiff2>, renderDiffImmediately: boolean, _chatAgentService: IChatAgentService, _editorService: IEditorService, _accessibilitySignalsService: IAccessibilitySignalService, instantiationService: IInstantiationService);
+    constructor(_entry: IModifiedFileEntry, _editor: ICodeEditor, documentDiffInfo: IObservable<IDocumentDiff2>, renderDiffImmediately: boolean, _editorService: IEditorService, _accessibilitySignalsService: IAccessibilitySignalService, contextKeyService: IContextKeyService, instantiationService: IInstantiationService);
     dispose(): void;
     private _clear;
     private _clearDiffRendering;