@codingame/monaco-vscode-chat-service-override 16.1.0 → 17.0.0

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

@@ -1,55 +1,47 @@
 
 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 { 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 { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
 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 { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { isEqual, joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service';
-import { OffsetEdit } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/offsetEdit';
 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 { IEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service';
-import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
-import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
-import { DiffEditorInput } from '@codingame/monaco-vscode-fdf643f9-94dd-5510-b97a-408abf26ad92-common/vscode/vs/workbench/common/editor/diffEditorInput';
+import { DiffEditorInput } from '@codingame/monaco-vscode-9c72783f-914c-50be-b9ef-da16356d81a8-common/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 { 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, ChatEditingSessionChangeType, WorkingSetEntryState, getMultiDiffSourceUri, ChatEditKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+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 { AbstractChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
 import { ChatEditingModifiedDocumentEntry } from './chatEditingModifiedDocumentEntry.js';
-import { ChatEditingTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
-import { CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { AbstractChatEditingModifiedFileEntry } from './chatEditingModifiedFileEntry.js';
 import { ChatEditingModifiedNotebookEntry } from './chatEditingModifiedNotebookEntry.js';
-import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { ChatEditingSessionStorage } from './chatEditingSessionStorage.js';
+import { ChatEditingTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
 import { ChatEditingModifiedNotebookDiff } from './notebook/chatEditingModifiedNotebookDiff.js';
-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 { observableValue, asyncTransaction, transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
 import { derived, derivedWithStore, derivedOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
 import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-import { ObservablePromise } from '@codingame/monaco-vscode-ae8a8ca1-f243-508b-9c37-c88ebbd295fa-common/vscode/vs/base/common/observableInternal/promise';
+import { ObservablePromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/promise';
 
-const STORAGE_CONTENTS_FOLDER = 'contents';
-const STORAGE_STATE_FILE = 'state.json';
 const POST_EDIT_STOP_ID = 'd19944f6-f46c-4e17-911b-79a8e843c7c0';
 class ThrottledSequencer extends Sequencer {
     constructor(_minDuration, _maxOverallDelay) {
@@ -105,6 +97,33 @@ function getCurrentAndNextStop(requestId, stopId, history) {
     }
     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();
@@ -113,10 +132,6 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
     get state() {
         return this._state;
     }
-    get onDidChange() {
-        this._assertNotDisposed();
-        return this._onDidChange.event;
-    }
     get onDidDispose() {
         this._assertNotDisposed();
         return this._onDidDispose.event;
@@ -143,7 +158,6 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         this._linearHistoryIndex = observableValue(this, 0);
         this._initialFileContents = ( new ResourceMap());
         this._entriesObs = observableValue(this, []);
-        this._workingSet = ( new ResourceMap());
         this.canUndo = derived((r) => {
             if (this.state.read(r) !== ChatEditingSessionState.Idle) {
                 return false;
@@ -158,11 +172,11 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             const linearHistoryIndex = this._linearHistoryIndex.read(r);
             return linearHistoryIndex < getMaxHistoryIndex(this._linearHistory.read(r));
         });
-        this._onDidChange = this._register(( new Emitter()));
         this._onDidDispose = ( new Emitter());
         this._diffsBetweenStops = ( new Map());
-        this._ignoreTrimWhitespaceObservable = observableConfigValue('diffEditor.ignoreTrimWhitespace', true, this._configurationService);
+        this._fullDiffs = ( new Map());
         this._streamingEditLocks = ( new SequencerByKey());
+        this._ignoreTrimWhitespaceObservable = observableConfigValue('diffEditor.ignoreTrimWhitespace', true, this._configurationService);
     }
     async init() {
         const restoredSessionState = await this._instantiationService.createInstance(ChatEditingSessionStorage, this.chatSessionId).restoreState();
@@ -186,7 +200,6 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             entries.forEach(entry => {
                 entry.state.read(reader);
             });
-            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         }));
     }
     _getEntry(uri) {
@@ -243,7 +256,8 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             return ( new ObservablePromise(promise));
         });
         return derived((reader) => {
-            const refs = modelRefsPromise.read(reader)?.promiseResult.read(reader)?.data;
+            const refs2 = modelRefsPromise.read(reader)?.promiseResult.read(reader);
+            const refs = refs2?.data;
             if (!refs) {
                 return;
             }
@@ -277,7 +291,9 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         const entries = derivedOpts({
             equalsFn: (a, b) => snapshotsEqualForDiff(a?.before, b?.before) && snapshotsEqualForDiff(a?.after, b?.after),
         }, reader => {
-            const stops = getCurrentAndNextStop(requestId, stopId, this._linearHistory.read(reader));
+            const stops = requestId ?
+                getCurrentAndNextStop(requestId, stopId, this._linearHistory.read(reader)) :
+                getFirstAndLastStop(uri, this._linearHistory.read(reader));
             if (!stops) {
                 return undefined;
             }
@@ -301,19 +317,27 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         });
     }
     getEntryDiffBetweenStops(uri, requestId, stopId) {
-        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);
+        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;
         }
-        return observable;
-    }
-    createSnapshot(requestId, undoStop) {
-        const snapshot = this._createSnapshot(requestId, undoStop);
-        for (const [uri, _] of this._workingSet) {
-            this._workingSet.set(uri, { state: WorkingSetEntryState.Sent });
+        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;
         }
+    }
+    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()) {
@@ -337,15 +361,19 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             this._linearHistoryIndex.set(last.startIndex + last.stops.length, tx);
         });
     }
+    _createEmptySnapshot(undoStop) {
+        return {
+            stopId: undoStop,
+            entries: ( new ResourceMap()),
+        };
+    }
     _createSnapshot(requestId, undoStop) {
-        const workingSet = ( new ResourceMap(this._workingSet));
         const entries = ( new ResourceMap());
         for (const entry of this._entriesObs.get()) {
             entries.set(entry.modifiedURI, entry.createSnapshot(requestId, undoStop));
         }
         return {
             stopId: undoStop,
-            workingSet,
             entries,
         };
     }
@@ -387,8 +415,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             await this._restoreSnapshot(pendingSnapshot, undefined);
         }
     }
-    async _restoreSnapshot({ workingSet, entries }, tx, restoreResolvedToDisk = true) {
-        this._workingSet = ( new ResourceMap(workingSet));
+    async _restoreSnapshot({ entries }, tx, restoreResolvedToDisk = true) {
         for (const entry of this._entriesObs.get()) {
             const snapshotEntry = entries.get(entry.modifiedURI);
             if (!snapshotEntry) {
@@ -399,13 +426,13 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         const entriesArr = [];
         for (const snapshotEntry of ( entries.values())) {
             const entry = await this._getOrCreateModifiedFileEntry(snapshotEntry.resource, snapshotEntry.telemetryInfo);
-            const restoreToDisk = snapshotEntry.state === WorkingSetEntryState.Modified || restoreResolvedToDisk;
+            const restoreToDisk = snapshotEntry.state === ModifiedFileEntryState.Modified || restoreResolvedToDisk;
             entry.restoreFromSnapshot(snapshotEntry, restoreToDisk);
             entriesArr.push(entry);
         }
         this._entriesObs.set(entriesArr, tx);
     }
-    remove(reason, ...uris) {
+    remove(...uris) {
         this._assertNotDisposed();
         let didRemoveUris = false;
         for (const uri of uris) {
@@ -416,15 +443,10 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
                 this._entriesObs.set(newEntries, undefined);
                 didRemoveUris = true;
             }
-            const state = this._workingSet.get(uri);
-            if (state !== undefined) {
-                didRemoveUris = this._workingSet.delete(uri) || didRemoveUris;
-            }
         }
         if (!didRemoveUris) {
             return;
         }
-        this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
     }
     _assertNotDisposed() {
         if (this._state.get() === ChatEditingSessionState.Disposed) {
@@ -445,7 +467,6 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             }
         });
         this._accessibilitySignalService.playSignal(AccessibilitySignal.editsKept, { allowManyInParallel: true });
-        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
     }
     async reject(...uris) {
         this._assertNotDisposed();
@@ -461,9 +482,8 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             }
         });
         this._accessibilitySignalService.playSignal(AccessibilitySignal.editsUndone, { allowManyInParallel: true });
-        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
     }
-    async show() {
+    async show(previousChanges) {
         this._assertNotDisposed();
         if (this._editorPane) {
             if (this._editorPane.isVisible()) {
@@ -475,8 +495,8 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             }
         }
         const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
-            multiDiffSource: getMultiDiffSourceUri(this),
-            label: ( localize(4694, "Suggested Edits"))
+            multiDiffSource: getMultiDiffSourceUri(this, previousChanges),
+            label: ( localize(4758, "Suggested Edits"))
         }, this._instantiationService);
         this._editorPane = await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
     }
@@ -637,7 +657,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         }
         if (next) {
             if (stopIndex === snap.stops.length - 1) {
-                const postEdit = ( new ResourceMap(snap.postEdit || this._createSnapshot(undefined, undefined).entries));
+                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();
@@ -661,6 +681,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         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);
     }
@@ -686,7 +707,6 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
             this.ensureEditInUndoStopMatches(requestId, undoStop, entry,  true, tx);
             return entry.acceptStreamingEditsEnd(tx);
         });
-        this._onDidChange.fire(ChatEditingSessionChangeType.Other);
     }
     async _getOrCreateModifiedFileEntry(resource, telemetryInfo) {
         resource = CellUri.parse(resource)?.notebook ?? resource;
@@ -712,18 +732,15 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         const listener = entry.onDidDelete(() => {
             const newEntries = this._entriesObs.get().filter(e => !isEqual(e.modifiedURI, entry.modifiedURI));
             this._entriesObs.set(newEntries, undefined);
-            this._workingSet.delete(entry.modifiedURI);
             this._editorService.closeEditors(this._editorService.findEditors(entry.modifiedURI));
             if (!existingExternalEntry) {
                 entry.dispose();
             }
             this._store.delete(listener);
-            this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         });
         this._store.add(listener);
         const entriesArr = [...this._entriesObs.get(), entry];
         this._entriesObs.set(entriesArr, undefined);
-        this._onDidChange.fire(ChatEditingSessionChangeType.WorkingSet);
         return entry;
     }
     async _createModifiedFileEntry(resource, telemetryInfo, mustExist = false, initialContent) {
@@ -731,7 +748,7 @@ let ChatEditingSession = class ChatEditingSession extends Disposable {
         const chatKind = mustExist ? ChatEditKind.Created : ChatEditKind.Modified;
         const notebookUri = CellUri.parse(resource)?.notebook || resource;
         try {
-            if (this._notebookService.hasSupportedNotebooks(notebookUri) && (this._notebookService.getNotebookTextModel(notebookUri) || ChatEditingModifiedNotebookEntry.canHandleSnapshotContent(initialContent))) {
+            if (this._notebookService.hasSupportedNotebooks(notebookUri)) {
                 return await ChatEditingModifiedNotebookEntry.create(notebookUri, multiDiffEntryDelegate, telemetryInfo, chatKind, initialContent, this._instantiationService);
             }
             else {
@@ -776,210 +793,5 @@ ChatEditingSession = ( __decorate([
     ( __param(13, IConfigurationService)),
     ( __param(14, IAccessibilitySignalService))
 ], ChatEditingSession));
-let ChatEditingSessionStorage = class ChatEditingSessionStorage {
-    constructor(chatSessionId, _fileService, _environmentService, _logService, _workspaceContextService) {
-        this.chatSessionId = chatSessionId;
-        this._fileService = _fileService;
-        this._environmentService = _environmentService;
-        this._logService = _logService;
-        this._workspaceContextService = _workspaceContextService;
-    }
-    _getStorageLocation() {
-        const workspaceId = this._workspaceContextService.getWorkspace().id;
-        return joinPath(this._environmentService.workspaceStorageHome, workspaceId, 'chatEditingSessions', this.chatSessionId);
-    }
-    async restoreState() {
-        const storageLocation = this._getStorageLocation();
-        const fileContents = ( new Map());
-        const getFileContent = (hash) => {
-            let readPromise = fileContents.get(hash);
-            if (!readPromise) {
-                readPromise = this._fileService.readFile(joinPath(storageLocation, STORAGE_CONTENTS_FOLDER, hash)).then(content => ( content.value.toString()));
-                fileContents.set(hash, readPromise);
-            }
-            return readPromise;
-        };
-        const deserializeResourceMap = (resourceMap, deserialize, result) => {
-            resourceMap.forEach(([resourceURI, value]) => {
-                result.set(( URI.parse(resourceURI)), deserialize(value));
-            });
-            return result;
-        };
-        const deserializeSnapshotEntriesDTO = async (dtoEntries) => {
-            const entries = ( new ResourceMap());
-            for (const entryDTO of dtoEntries) {
-                const entry = await deserializeSnapshotEntry(entryDTO);
-                entries.set(entry.resource, entry);
-            }
-            return entries;
-        };
-        const deserializeChatEditingStopDTO = async (stopDTO) => {
-            const entries = await deserializeSnapshotEntriesDTO(stopDTO.entries);
-            const workingSet = deserializeResourceMap(stopDTO.workingSet, (value) => value, ( new ResourceMap()));
-            return { stopId: 'stopId' in stopDTO ? stopDTO.stopId : undefined, workingSet, entries };
-        };
-        const normalizeSnapshotDtos = (snapshot) => {
-            if ('stops' in snapshot) {
-                return snapshot;
-            }
-            return { requestId: snapshot.requestId, stops: [{ stopId: undefined, entries: snapshot.entries, workingSet: snapshot.workingSet }], postEdit: undefined };
-        };
-        const deserializeChatEditingSessionSnapshot = async (startIndex, snapshot) => {
-            const stops = await Promise.all(( snapshot.stops.map(deserializeChatEditingStopDTO)));
-            return { startIndex, requestId: snapshot.requestId, stops, postEdit: snapshot.postEdit && (await deserializeSnapshotEntriesDTO(snapshot.postEdit)) };
-        };
-        const deserializeSnapshotEntry = async (entry) => {
-            return {
-                resource: ( URI.parse(entry.resource)),
-                languageId: entry.languageId,
-                original: await getFileContent(entry.originalHash),
-                current: await getFileContent(entry.currentHash),
-                originalToCurrentEdit: OffsetEdit.fromJson(entry.originalToCurrentEdit),
-                state: entry.state,
-                snapshotUri: ( URI.parse(entry.snapshotUri)),
-                telemetryInfo: { requestId: entry.telemetryInfo.requestId, agentId: entry.telemetryInfo.agentId, command: entry.telemetryInfo.command, sessionId: this.chatSessionId, result: undefined }
-            };
-        };
-        try {
-            const stateFilePath = joinPath(storageLocation, STORAGE_STATE_FILE);
-            if (!(await this._fileService.exists(stateFilePath))) {
-                this._logService.debug(`chatEditingSession: No editing session state found at ${( stateFilePath.toString())}`);
-                return undefined;
-            }
-            this._logService.debug(`chatEditingSession: Restoring editing session at ${( stateFilePath.toString())}`);
-            const stateFileContent = await this._fileService.readFile(stateFilePath);
-            const data = JSON.parse(( stateFileContent.value.toString()));
-            if (!COMPATIBLE_STORAGE_VERSIONS.includes(data.version)) {
-                return undefined;
-            }
-            let linearHistoryIndex = 0;
-            const linearHistory = await Promise.all(( data.linearHistory.map(snapshot => {
-                const norm = normalizeSnapshotDtos(snapshot);
-                const result = deserializeChatEditingSessionSnapshot(linearHistoryIndex, norm);
-                linearHistoryIndex += norm.stops.length;
-                return result;
-            })));
-            const initialFileContents = ( new ResourceMap());
-            for (const fileContentDTO of data.initialFileContents) {
-                initialFileContents.set(( URI.parse(fileContentDTO[0])), await getFileContent(fileContentDTO[1]));
-            }
-            const pendingSnapshot = data.pendingSnapshot ? await deserializeChatEditingStopDTO(data.pendingSnapshot) : undefined;
-            const recentSnapshot = await deserializeChatEditingStopDTO(data.recentSnapshot);
-            return {
-                initialFileContents,
-                pendingSnapshot,
-                recentSnapshot,
-                linearHistoryIndex: data.linearHistoryIndex,
-                linearHistory
-            };
-        }
-        catch (e) {
-            this._logService.error(`Error restoring chat editing session from ${( storageLocation.toString())}`, e);
-        }
-        return undefined;
-    }
-    async storeState(state) {
-        const storageFolder = this._getStorageLocation();
-        const contentsFolder = URI.joinPath(storageFolder, STORAGE_CONTENTS_FOLDER);
-        const existingContents = ( new Set());
-        try {
-            const stat = await this._fileService.resolve(contentsFolder);
-            stat.children?.forEach(child => {
-                if (child.isFile) {
-                    existingContents.add(child.name);
-                }
-            });
-        }
-        catch (e) {
-            try {
-                await this._fileService.createFolder(contentsFolder);
-            }
-            catch (e) {
-                this._logService.error(`Error creating chat editing session content folder ${( contentsFolder.toString())}`, e);
-                return;
-            }
-        }
-        const fileContents = ( new Map());
-        const addFileContent = (content) => {
-            const shaComputer = ( new StringSHA1());
-            shaComputer.update(content);
-            const sha = shaComputer.digest().substring(0, 7);
-            fileContents.set(sha, content);
-            return sha;
-        };
-        const serializeResourceMap = (resourceMap, serialize) => {
-            return ( Array.from(resourceMap.entries()).map(([resourceURI, value]) => [( resourceURI.toString()), serialize(value)]));
-        };
-        const serializeChatEditingSessionStop = (stop) => {
-            return {
-                stopId: stop.stopId,
-                workingSet: serializeResourceMap(stop.workingSet, value => value),
-                entries: ( Array.from(( stop.entries.values())).map(serializeSnapshotEntry))
-            };
-        };
-        const serializeChatEditingSessionSnapshot = (snapshot) => {
-            return {
-                requestId: snapshot.requestId,
-                stops: ( snapshot.stops.map(serializeChatEditingSessionStop)),
-                postEdit: snapshot.postEdit ? ( Array.from(( snapshot.postEdit.values())).map(serializeSnapshotEntry)) : undefined
-            };
-        };
-        const serializeSnapshotEntry = (entry) => {
-            return {
-                resource: ( entry.resource.toString()),
-                languageId: entry.languageId,
-                originalHash: addFileContent(entry.original),
-                currentHash: addFileContent(entry.current),
-                originalToCurrentEdit: ( entry.originalToCurrentEdit.edits.map(
-                    edit => ({ pos: edit.replaceRange.start, len: edit.replaceRange.length, txt: edit.newText })
-                )),
-                state: entry.state,
-                snapshotUri: ( entry.snapshotUri.toString()),
-                telemetryInfo: { requestId: entry.telemetryInfo.requestId, agentId: entry.telemetryInfo.agentId, command: entry.telemetryInfo.command }
-            };
-        };
-        try {
-            const data = {
-                version: STORAGE_VERSION,
-                sessionId: this.chatSessionId,
-                linearHistory: ( state.linearHistory.map(serializeChatEditingSessionSnapshot)),
-                linearHistoryIndex: state.linearHistoryIndex,
-                initialFileContents: serializeResourceMap(state.initialFileContents, value => addFileContent(value)),
-                pendingSnapshot: state.pendingSnapshot ? serializeChatEditingSessionStop(state.pendingSnapshot) : undefined,
-                recentSnapshot: serializeChatEditingSessionStop(state.recentSnapshot),
-            };
-            this._logService.debug(`chatEditingSession: Storing editing session at ${( storageFolder.toString())}: ${fileContents.size} files`);
-            for (const [hash, content] of fileContents) {
-                if (!( existingContents.has(hash))) {
-                    await this._fileService.writeFile(joinPath(contentsFolder, hash), VSBuffer.fromString(content));
-                }
-            }
-            await this._fileService.writeFile(joinPath(storageFolder, STORAGE_STATE_FILE), VSBuffer.fromString(JSON.stringify(data, undefined, 2)));
-        }
-        catch (e) {
-            this._logService.debug(`Error storing chat editing session to ${( storageFolder.toString())}`, e);
-        }
-    }
-    async clearState() {
-        const storageFolder = this._getStorageLocation();
-        if (await this._fileService.exists(storageFolder)) {
-            this._logService.debug(`chatEditingSession: Clearing editing session at ${( storageFolder.toString())}`);
-            try {
-                await this._fileService.del(storageFolder, { recursive: true });
-            }
-            catch (e) {
-                this._logService.debug(`Error clearing chat editing session from ${( storageFolder.toString())}`, e);
-            }
-        }
-    }
-};
-ChatEditingSessionStorage = ( __decorate([
-    ( __param(1, IFileService)),
-    ( __param(2, IEnvironmentService)),
-    ( __param(3, ILogService)),
-    ( __param(4, IWorkspaceContextService))
-], ChatEditingSessionStorage));
-const COMPATIBLE_STORAGE_VERSIONS = [1, 2];
-const STORAGE_VERSION = 2;
 
 export { ChatEditingSession };

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

@@ -0,0 +1,36 @@
+import { ResourceMap } from "@codingame/monaco-vscode-api/vscode/vs/base/common/map";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { ISnapshotEntry } from "./chatEditingModifiedFileEntry.js";
+export interface StoredSessionState {
+    readonly initialFileContents: ResourceMap<string>;
+    readonly pendingSnapshot?: IChatEditingSessionStop;
+    readonly recentSnapshot: IChatEditingSessionStop;
+    readonly linearHistoryIndex: number;
+    readonly linearHistory: readonly IChatEditingSessionSnapshot[];
+}
+export declare class ChatEditingSessionStorage {
+    private readonly chatSessionId;
+    private readonly _fileService;
+    private readonly _environmentService;
+    private readonly _logService;
+    private readonly _workspaceContextService;
+    constructor(chatSessionId: string, _fileService: IFileService, _environmentService: IEnvironmentService, _logService: ILogService, _workspaceContextService: IWorkspaceContextService);
+    protected _getStorageLocation(): URI;
+    restoreState(): Promise<StoredSessionState | undefined>;
+    storeState(state: StoredSessionState): Promise<void>;
+    clearState(): Promise<void>;
+}
+export interface IChatEditingSessionSnapshot {
+    readonly startIndex: number;
+    readonly requestId: string | undefined;
+    readonly stops: IChatEditingSessionStop[];
+    readonly postEdit: ResourceMap<ISnapshotEntry> | undefined;
+}
+export interface IChatEditingSessionStop {
+    stopId: string | undefined;
+    readonly entries: ResourceMap<ISnapshotEntry>;
+}