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

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

@@ -1,7 +1,7 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { hashAsync } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
 import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
 import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
@@ -51,11 +51,11 @@ let ChatEditingSessionStorage = class ChatEditingSessionStorage {
             if ('stops' in snapshot) {
                 return snapshot;
             }
-            return { requestId: snapshot.requestId, stops: [{ stopId: undefined, entries: snapshot.entries }], postEdit: undefined };
+            return { requestId: snapshot.requestId, stops: [{ stopId: undefined, entries: snapshot.entries }] };
         };
         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)) };
+            return { startIndex, requestId: snapshot.requestId, stops };
         };
         const deserializeSnapshotEntry = async (entry) => {
             return {
@@ -127,36 +127,44 @@ let ChatEditingSessionStorage = class ChatEditingSessionStorage {
                 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 contentWritePromises = ( new Map());
+        const writeContent = async (content) => {
+            const buffer = VSBuffer.fromString(content);
+            const hash = (await hashAsync(buffer)).substring(0, 7);
+            if (!( existingContents.has(hash))) {
+                await this._fileService.writeFile(joinPath(contentsFolder, hash), buffer);
+            }
+            return hash;
+        };
+        const addFileContent = async (content) => {
+            let storedContentHash = contentWritePromises.get(content);
+            if (!storedContentHash) {
+                storedContentHash = writeContent(content);
+                contentWritePromises.set(content, storedContentHash);
+            }
+            return storedContentHash;
         };
-        const serializeResourceMap = (resourceMap, serialize) => {
-            return ( Array.from(resourceMap.entries()).map(([resourceURI, value]) => [( resourceURI.toString()), serialize(value)]));
+        const serializeResourceMap = async (resourceMap, serialize) => {
+            return await Promise.all(( Array.from(resourceMap.entries()).map(async ([resourceURI, value]) => [( resourceURI.toString()), await serialize(value)])));
         };
-        const serializeChatEditingSessionStop = (stop) => {
+        const serializeChatEditingSessionStop = async (stop) => {
             return {
                 stopId: stop.stopId,
-                entries: ( Array.from(( stop.entries.values())).map(serializeSnapshotEntry))
+                entries: await Promise.all(( Array.from(( stop.entries.values())).map(serializeSnapshotEntry)))
             };
         };
-        const serializeChatEditingSessionSnapshot = (snapshot) => {
+        const serializeChatEditingSessionSnapshot = async (snapshot) => {
             return {
                 requestId: snapshot.requestId,
-                stops: ( snapshot.stops.map(serializeChatEditingSessionStop)),
-                postEdit: snapshot.postEdit ? ( Array.from(( snapshot.postEdit.values())).map(serializeSnapshotEntry)) : undefined
+                stops: await Promise.all(( snapshot.stops.map(serializeChatEditingSessionStop))),
             };
         };
-        const serializeSnapshotEntry = (entry) => {
+        const serializeSnapshotEntry = async (entry) => {
             return {
                 resource: ( entry.resource.toString()),
                 languageId: entry.languageId,
-                originalHash: addFileContent(entry.original),
-                currentHash: addFileContent(entry.current),
+                originalHash: await addFileContent(entry.original),
+                currentHash: await addFileContent(entry.current),
                 state: entry.state,
                 snapshotUri: ( entry.snapshotUri.toString()),
                 telemetryInfo: { requestId: entry.telemetryInfo.requestId, agentId: entry.telemetryInfo.agentId, command: entry.telemetryInfo.command }
@@ -166,18 +174,13 @@ let ChatEditingSessionStorage = class ChatEditingSessionStorage {
             const data = {
                 version: STORAGE_VERSION,
                 sessionId: this.chatSessionId,
-                linearHistory: ( state.linearHistory.map(serializeChatEditingSessionSnapshot)),
+                linearHistory: await Promise.all(( 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),
+                initialFileContents: await serializeResourceMap(state.initialFileContents, value => addFileContent(value)),
+                pendingSnapshot: state.pendingSnapshot ? await serializeChatEditingSessionStop(state.pendingSnapshot) : undefined,
+                recentSnapshot: await 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));
-                }
-            }
+            this._logService.debug(`chatEditingSession: Storing editing session at ${( storageFolder.toString())}: ${contentWritePromises.size} files`);
             await this._fileService.writeFile(joinPath(storageFolder, STORAGE_STATE_FILE), VSBuffer.fromString(JSON.stringify(data)));
         }
         catch (e) {

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

@@ -8,7 +8,12 @@ import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/edi
 import { IAccessibilitySignalService } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service";
 import { ICellEditOperation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
 import { ModifiedFileEntryState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
-import { IChatResponseModel } from "@codingame/monaco-vscode-9911aec2-e4dd-5483-8369-9d695cc70d8a-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { IChatResponseModel } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+type acceptedOrRejectedLines = {
+    state: "accepted" | "rejected";
+    lineCount: number;
+    hasRemainingEdits: boolean;
+};
 export declare class ChatEditingTextModelChangeService extends Disposable {
     private readonly originalModel;
     private readonly modifiedModel;
@@ -39,10 +44,15 @@ export declare class ChatEditingTextModelChangeService extends Disposable {
     private _editDecorations;
     private readonly _didAcceptOrRejectAllHunks;
     readonly onDidAcceptOrRejectAllHunks: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<ModifiedFileEntryState.Accepted | ModifiedFileEntryState.Rejected>;
+    private readonly _didAcceptOrRejectLines;
+    readonly onDidAcceptOrRejectLines: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<acceptedOrRejectedLines>;
+    private notifyHunkAction;
     private readonly _didUserEditModel;
     readonly onDidUserEditModel: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
     private _originalToModifiedEdit;
+    private lineChangeCount;
     constructor(originalModel: ITextModel, modifiedModel: ITextModel, state: IObservable<ModifiedFileEntryState>, _editorWorkerService: IEditorWorkerService, _accessibilitySignalService: IAccessibilitySignalService);
+    private updateLineChangeCount;
     clearCurrentEditLineDecoration(): void;
     areOriginalAndModifiedIdentical(): Promise<boolean>;
     acceptAgentEdits(resource: URI, textEdits: (TextEdit | ICellEditOperation)[], isLastEdits: boolean, responseModel: IChatResponseModel): Promise<{
@@ -59,3 +69,4 @@ export declare class ChatEditingTextModelChangeService extends Disposable {
     private _updateDiffInfoSeq;
     private _updateDiffInfo;
 }
+export {};

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

@@ -18,7 +18,7 @@ import { OverviewRulerLane, MinimapPosition } from '@codingame/monaco-vscode-api
 import { ModelDecorationOptions } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
 import { offsetEditFromContentChanges, offsetEditToEditOperations, offsetEditFromLineRangeMapping } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelStringEdit';
 import { IEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.service';
-import { EditReasons } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditReason';
+import { EditSources } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/textModelEditSource';
 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 '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
@@ -35,6 +35,7 @@ import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/sear
 import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
 import { pendingRewriteMinimap } from './chatEditingModifiedFileEntry.js';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
 
 var ChatEditingTextModelChangeService_1;
 let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService extends Disposable {
@@ -84,6 +85,11 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
             };
         }));
     }
+    notifyHunkAction(state, lineCount, hasRemainingEdits) {
+        if (lineCount > 0) {
+            this._didAcceptOrRejectLines.fire({ state, lineCount, hasRemainingEdits });
+        }
+    }
     constructor(originalModel, modifiedModel, state, _editorWorkerService, _accessibilitySignalService) {
         super();
         this.originalModel = originalModel;
@@ -102,15 +108,27 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         this._editDecorations = [];
         this._didAcceptOrRejectAllHunks = this._register(( new Emitter()));
         this.onDidAcceptOrRejectAllHunks = this._didAcceptOrRejectAllHunks.event;
+        this._didAcceptOrRejectLines = this._register(( new Emitter()));
+        this.onDidAcceptOrRejectLines = this._didAcceptOrRejectLines.event;
         this._didUserEditModel = this._register(( new Emitter()));
         this.onDidUserEditModel = this._didUserEditModel.event;
         this._originalToModifiedEdit = StringEdit.empty;
+        this.lineChangeCount = 0;
         this._register(this.modifiedModel.onDidChangeContent(e => {
             this._mirrorEdits(e);
         }));
         this._register(toDisposable(() => {
             this.clearCurrentEditLineDecoration();
         }));
+        this._register(autorun(r => this.updateLineChangeCount(this._diffInfo.read(r))));
+    }
+    updateLineChangeCount(diff) {
+        this.lineChangeCount = 0;
+        for (const change of diff.changes) {
+            const modifiedRange = change.modified.endLineNumberExclusive - change.modified.startLineNumber;
+            const originalRange = change.original.endLineNumberExclusive - change.original.startLineNumber;
+            this.lineChangeCount += Math.max(modifiedRange, originalRange);
+        }
     }
     clearCurrentEditLineDecoration() {
         this._editDecorations = this.modifiedModel.deltaDecorations(this._editDecorations, []);
@@ -125,12 +143,13 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         const isAtomicEdits = textEdits.length > 0 && isLastEdits;
         let maxLineNumber = 0;
         let rewriteRatio = 0;
-        const modelId = responseModel.session.getRequests().at(-1)?.modelId;
-        const reason = EditReasons.chatApplyEdits({ modelId: modelId });
+        const sessionId = responseModel.session.sessionId;
+        const request = responseModel.session.getRequests().at(-1);
+        const source = EditSources.chatApplyEdits({ modelId: request?.modelId, requestId: request?.id, sessionId: sessionId });
         if (isAtomicEdits) {
             const minimalEdits = (await this._editorWorkerService.computeMoreMinimalEdits(this.modifiedModel.uri, textEdits)) ?? textEdits;
             const ops = ( minimalEdits.map(TextEdit.asEditOperation));
-            const undoEdits = this._applyEdits(ops, reason);
+            const undoEdits = this._applyEdits(ops, source);
             if (undoEdits.length > 0) {
                 let range;
                 for (let i = 0; i < undoEdits.length; i++) {
@@ -161,7 +180,7 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         }
         else {
             const ops = ( textEdits.map(TextEdit.asEditOperation));
-            const undoEdits = this._applyEdits(ops, reason);
+            const undoEdits = this._applyEdits(ops, source);
             maxLineNumber = undoEdits.reduce((max, op) => Math.max(max, op.range.startLineNumber), 0);
             rewriteRatio = Math.min(1, maxLineNumber / this.modifiedModel.getLineCount());
             const newDecorations = [
@@ -184,17 +203,14 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         }
         return { rewriteRatio, maxLineNumber };
     }
-    _applyEdits(edits, reason) {
-        if (!reason) {
-            reason = EditReasons.chatApplyEdits({ modelId: undefined });
-        }
+    _applyEdits(edits, source) {
         try {
             this._isEditFromUs = true;
             let result = [];
             this.modifiedModel.pushEditOperations(null, edits, (undoEdits) => {
                 result = undoEdits;
                 return null;
-            }, undefined, reason);
+            }, undefined, source);
             return result;
         }
         finally {
@@ -202,13 +218,15 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         }
     }
     keep() {
+        this.notifyHunkAction('accepted', this.lineChangeCount, false);
         this.originalModel.setValue(this.modifiedModel.createSnapshot());
         this._diffInfo.set(nullDocumentDiff, undefined);
         this._originalToModifiedEdit = StringEdit.empty;
     }
     undo() {
+        this.notifyHunkAction('rejected', this.lineChangeCount, false);
         this.modifiedModel.pushStackElement();
-        this._applyEdits([(EditOperation.replace(this.modifiedModel.getFullModelRange(), this.originalModel.getValue()))]);
+        this._applyEdits([(EditOperation.replace(this.modifiedModel.getFullModelRange(), this.originalModel.getValue()))], EditSources.chatUndoEdits());
         this.modifiedModel.pushStackElement();
         this._originalToModifiedEdit = StringEdit.empty;
         this._diffInfo.set(nullDocumentDiff, undefined);
@@ -221,7 +239,7 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         }
         if (newModified !== undefined && this.modifiedModel.getValue() !== newModified) {
             this.modifiedModel.pushStackElement();
-            this._applyEdits([(EditOperation.replace(this.modifiedModel.getFullModelRange(), newModified))]);
+            this._applyEdits([(EditOperation.replace(this.modifiedModel.getFullModelRange(), newModified))], EditSources.chatReset());
             this.modifiedModel.pushStackElement();
             didChange = true;
         }
@@ -239,14 +257,14 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
         else {
             const e_ai = this._originalToModifiedEdit;
             const e_user = edit;
-            const e_user_r = e_user.tryRebase(e_ai.inverse(this.originalModel.getValue()), true);
+            const e_user_r = e_user.tryRebase(e_ai.inverse(this.originalModel.getValue()));
             if (e_user_r === undefined) {
                 this._originalToModifiedEdit = e_ai.compose(e_user);
             }
             else {
                 const edits = offsetEditToEditOperations(e_user_r, this.originalModel);
                 this.originalModel.applyEdits(edits);
-                this._originalToModifiedEdit = e_ai.tryRebase(e_user_r);
+                this._originalToModifiedEdit = e_ai.rebaseSkipConflicting(e_user_r);
             }
             this._allEditsAreFromUs = false;
             this._updateDiffInfoSeq();
@@ -263,7 +281,7 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
             edits.push(EditOperation.replace(edit.originalRange, newText));
         }
         this.originalModel.pushEditOperations(null, edits, _ => null);
-        await this._updateDiffInfoSeq();
+        await this._updateDiffInfoSeq('accepted');
         if (this._diffInfo.get().identical) {
             this._didAcceptOrRejectAllHunks.fire(ModifiedFileEntryState.Accepted);
         }
@@ -280,20 +298,24 @@ let ChatEditingTextModelChangeService = class ChatEditingTextModelChangeService
             edits.push(EditOperation.replace(edit.modifiedRange, newText));
         }
         this.modifiedModel.pushEditOperations(null, edits, _ => null);
-        await this._updateDiffInfoSeq();
+        await this._updateDiffInfoSeq('rejected');
         if (this._diffInfo.get().identical) {
             this._didAcceptOrRejectAllHunks.fire(ModifiedFileEntryState.Rejected);
         }
         this._accessibilitySignalService.playSignal(AccessibilitySignal.editsUndone, { allowManyInParallel: true });
         return true;
     }
-    async _updateDiffInfoSeq() {
+    async _updateDiffInfoSeq(notifyAction = undefined) {
         const myDiffOperationId = ++this._diffOperationIds;
         await Promise.resolve(this._diffOperation);
+        const previousCount = this.lineChangeCount;
         if (this._diffOperationIds === myDiffOperationId) {
             const thisDiffOperation = this._updateDiffInfo();
             this._diffOperation = thisDiffOperation;
             await thisDiffOperation;
+            if (notifyAction) {
+                this.notifyHunkAction(notifyAction, previousCount - this.lineChangeCount, this.lineChangeCount > 0);
+            }
         }
     }
     async _updateDiffInfo() {

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

@@ -0,0 +1,55 @@
+import { IObservable, ITransaction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/editorWorker.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 { IEditSessionEntryDiff } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService";
+import { IChatRequestDisablement } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatModel";
+import { AbstractChatEditingModifiedFileEntry } from "./chatEditingModifiedFileEntry.js";
+import { IChatEditingSessionSnapshot, IChatEditingSessionStop } from "./chatEditingSessionStorage.js";
+export declare class ChatEditingTimeline {
+    private readonly _editorWorkerService;
+    private readonly _instantiationService;
+    private readonly _textModelService;
+    static readonly POST_EDIT_STOP_ID = "d19944f6-f46c-4e17-911b-79a8e843c7c0";
+    static createEmptySnapshot(undoStop: string | undefined): IChatEditingSessionStop;
+    private readonly _linearHistory;
+    private readonly _linearHistoryIndex;
+    private readonly _diffsBetweenStops;
+    private readonly _fullDiffs;
+    private readonly _ignoreTrimWhitespaceObservable;
+    readonly canUndo: IObservable<boolean>;
+    readonly canRedo: IObservable<boolean>;
+    readonly requestDisablement: IObservable<IChatRequestDisablement[]>;
+    constructor(_editorWorkerService: IEditorWorkerService, _instantiationService: IInstantiationService, configurationService: IConfigurationService, _textModelService: ITextModelService);
+    restoreFromState(state: {
+        history: readonly IChatEditingSessionSnapshot[];
+        index: number;
+    }, tx: ITransaction): void;
+    getSnapshotForRestore(requestId: string | undefined, stopId: string | undefined): {
+        stop: IChatEditingSessionStop;
+        apply(): void;
+    } | undefined;
+    ensureEditInUndoStopMatches(requestId: string, undoStop: string | undefined, entry: Pick<AbstractChatEditingModifiedFileEntry, "modifiedURI" | "createSnapshot" | "equalsSnapshot">, next: boolean, tx: ITransaction | undefined): void;
+    getUndoSnapshot(): {
+        stop: IChatEditingSessionStop;
+        apply(): void;
+    } | undefined;
+    getRedoSnapshot(): {
+        stop: IChatEditingSessionStop;
+        apply(): void;
+    } | undefined;
+    private getUndoRedoSnapshot;
+    getStateForPersistence(): {
+        history: readonly IChatEditingSessionSnapshot[];
+        index: number;
+    };
+    private findSnapshot;
+    private findEditStop;
+    private getHistoryEntryByLinearIndex;
+    pushSnapshot(requestId: string, undoStop: string | undefined, snapshot: IChatEditingSessionStop): void;
+    private _entryDiffBetweenTextStops;
+    private _createDiffBetweenStopsObservable;
+    getEntryDiffBetweenStops(uri: URI, requestId: string | undefined, stopId: string | undefined): IObservable<IEditSessionEntryDiff | undefined>;
+}