@codingame/monaco-vscode-chat-service-override 10.1.3 → 11.0.0

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

@@ -0,0 +1,448 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { delta, compareBy } from 'vscode/vscode/vs/base/common/arrays';
+import { AsyncIterableSource } from 'vscode/vscode/vs/base/common/async';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Codicon } from 'vscode/vscode/vs/base/common/codicons';
+import { BugIndicatingError } from 'vscode/vscode/vs/base/common/errors';
+import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { observableValue } from 'vscode/vscode/vs/base/common/observableInternal/base';
+import 'vscode/vscode/vs/base/common/observableInternal/autorun';
+import { derived } from 'vscode/vscode/vs/base/common/observableInternal/derived';
+import { runOnChange, ValueWithChangeEventFromObservable } from 'vscode/vscode/vs/base/common/observableInternal/utils';
+import { compare } from 'vscode/vscode/vs/base/common/strings';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { localize, localize2 } from 'vscode/vscode/vs/nls';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { EditorActivation } from 'vscode/vscode/vs/platform/editor/common/editor';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { bindContextKey } from 'vscode/vscode/vs/platform/observable/common/platformObservableUtils';
+import { IProgressService } from 'vscode/vscode/vs/platform/progress/common/progress.service';
+import { IWorkbenchAssignmentService } from 'vscode/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { IDecorationsService } from 'vscode/vscode/vs/workbench/services/decorations/common/decorations.service';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { MultiDiffEditorInput } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { MultiDiffEditorItem } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService';
+import { IMultiDiffSourceResolverService } from 'vscode/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service';
+import { ICodeMapperService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatCodeMapperService.service';
+import { CONTEXT_CHAT_EDITING_CAN_UNDO, CONTEXT_CHAT_EDITING_CAN_REDO } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { defaultChatEditingMaxFileLimit, applyingChatEditsFailedContextKey, decidedChatEditingResourceContextKey, hasUndecidedChatEditingResourceContextKey, hasAppliedChatEditsContextKey, inChatEditingSessionContextKey, applyingChatEditsContextKey, chatEditingMaxFileAssignmentName, CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME, chatEditingResourceContextKey } from '@codingame/monaco-vscode-chat-extensions-interactive-notebook-quickaccess-search-terminal-common/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { ChatEditingSession } from './chatEditingSession.js';
+import { ChatEditingTextModelContentProvider, ChatEditingSnapshotTextModelContentProvider } from './chatEditingTextModelContentProviders.js';
+
+var ChatEditingMultiDiffSourceResolver_1;
+let ChatEditingService = class ChatEditingService extends Disposable {
+    get currentAutoApplyOperation() {
+        return this._currentAutoApplyOperationObs.get();
+    }
+    get currentEditingSession() {
+        return this._currentSessionObs.get();
+    }
+    get currentEditingSessionObs() {
+        return this._currentSessionObs;
+    }
+    get onDidCreateEditingSession() {
+        return this._onDidCreateEditingSession.event;
+    }
+    get editingSessionFileLimit() {
+        return this._editingSessionFileLimit ?? defaultChatEditingMaxFileLimit;
+    }
+    constructor(_editorGroupsService, _instantiationService, multiDiffSourceResolverService, textModelService, contextKeyService, _chatService, _progressService, _codeMapperService, _editorService, decorationsService, _fileService, _workbenchAssignmentService) {
+        super();
+        this._editorGroupsService = _editorGroupsService;
+        this._instantiationService = _instantiationService;
+        this._chatService = _chatService;
+        this._progressService = _progressService;
+        this._codeMapperService = _codeMapperService;
+        this._editorService = _editorService;
+        this._fileService = _fileService;
+        this._workbenchAssignmentService = _workbenchAssignmentService;
+        this._currentSessionObs = observableValue(this, null);
+        this._currentSessionDisposables = this._register(( (new DisposableStore())));
+        this._currentAutoApplyOperationObs = observableValue(this, null);
+        this._onDidCreateEditingSession = this._register(( (new Emitter())));
+        this._onDidChangeEditingSession = this._register(( (new Emitter())));
+        this.onDidChangeEditingSession = this._onDidChangeEditingSession.event;
+        this._applyingChatEditsFailedContextKey = applyingChatEditsFailedContextKey.bindTo(contextKeyService);
+        this._applyingChatEditsFailedContextKey.set(false);
+        this._register(decorationsService.registerDecorationsProvider(( (new ChatDecorationsProvider(this._currentSessionObs)))));
+        this._register(multiDiffSourceResolverService.registerResolver(_instantiationService.createInstance(ChatEditingMultiDiffSourceResolver, this._currentSessionObs)));
+        textModelService.registerTextModelContentProvider(ChatEditingTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingTextModelContentProvider, this._currentSessionObs));
+        textModelService.registerTextModelContentProvider(ChatEditingSnapshotTextModelContentProvider.scheme, _instantiationService.createInstance(ChatEditingSnapshotTextModelContentProvider, this._currentSessionObs));
+        this._register(bindContextKey(decidedChatEditingResourceContextKey, contextKeyService, (reader) => {
+            const currentSession = this._currentSessionObs.read(reader);
+            if (!currentSession) {
+                return;
+            }
+            const entries = currentSession.entries.read(reader);
+            const decidedEntries = entries.filter(entry => entry.state.read(reader) !== 0 );
+            return (
+                 (decidedEntries.map(entry => entry.entryId))
+            );
+        }));
+        this._register(bindContextKey(hasUndecidedChatEditingResourceContextKey, contextKeyService, (reader) => {
+            const currentSession = this._currentSessionObs.read(reader);
+            if (!currentSession) {
+                return;
+            }
+            const entries = currentSession.entries.read(reader);
+            const decidedEntries = entries.filter(entry => entry.state.read(reader) === 0 );
+            return decidedEntries.length > 0;
+        }));
+        this._register(bindContextKey(hasAppliedChatEditsContextKey, contextKeyService, (reader) => {
+            const currentSession = this._currentSessionObs.read(reader);
+            if (!currentSession) {
+                return false;
+            }
+            const entries = currentSession.entries.read(reader);
+            return entries.length > 0;
+        }));
+        this._register(bindContextKey(inChatEditingSessionContextKey, contextKeyService, (reader) => {
+            return this._currentSessionObs.read(reader) !== null;
+        }));
+        this._register(bindContextKey(applyingChatEditsContextKey, contextKeyService, (reader) => {
+            return this._currentAutoApplyOperationObs.read(reader) !== null;
+        }));
+        this._register(bindContextKey(CONTEXT_CHAT_EDITING_CAN_UNDO, contextKeyService, (r) => {
+            return this._currentSessionObs.read(r)?.canUndo.read(r) || false;
+        }));
+        this._register(bindContextKey(CONTEXT_CHAT_EDITING_CAN_REDO, contextKeyService, (r) => {
+            return this._currentSessionObs.read(r)?.canRedo.read(r) || false;
+        }));
+        this._register(this._chatService.onDidDisposeSession((e) => {
+            if (e.reason === 'cleared' && this._currentSessionObs.get()?.chatSessionId === e.sessionId) {
+                void this._currentSessionObs.get()?.stop();
+            }
+        }));
+        this._editingSessionFileLimitPromise = this._workbenchAssignmentService.getTreatment(chatEditingMaxFileAssignmentName).then(value => {
+            this._editingSessionFileLimit = value ?? defaultChatEditingMaxFileLimit;
+            return this._editingSessionFileLimit;
+        });
+    }
+    getSnapshotUri(id, uri) {
+        const session = this._currentSessionObs.get();
+        if (!session) {
+            return undefined;
+        }
+        return session.getSnapshot(id, uri)?.snapshotUri;
+    }
+    getEditingSession(resource) {
+        const session = this.currentEditingSession;
+        if (!session) {
+            return null;
+        }
+        const entries = session.entries.get();
+        for (const entry of entries) {
+            if (( (entry.modifiedURI.toString())) === ( (resource.toString()))) {
+                return session;
+            }
+        }
+        return null;
+    }
+    dispose() {
+        this._currentSessionObs.get()?.dispose();
+        super.dispose();
+    }
+    async startOrContinueEditingSession(chatSessionId, options) {
+        const session = this._currentSessionObs.get();
+        if (session) {
+            if (session.chatSessionId !== chatSessionId) {
+                throw ( (new BugIndicatingError('Cannot start new session while another session is active')));
+            }
+        }
+        return this._createEditingSession(chatSessionId, options);
+    }
+    async _createEditingSession(chatSessionId, options) {
+        if (this._currentSessionObs.get()) {
+            throw ( (new BugIndicatingError('Cannot have more than one active editing session')));
+        }
+        this._currentSessionDisposables.clear();
+        this._currentSessionDisposables.add(this.installAutoApplyObserver(chatSessionId));
+        const input = MultiDiffEditorInput.fromResourceMultiDiffEditorInput({
+            multiDiffSource: ChatEditingMultiDiffSourceResolver.getMultiDiffSourceUri(),
+            label: ( localize(2734, "Suggested Edits"))
+        }, this._instantiationService);
+        const editorPane = options?.silent ? undefined : await this._editorGroupsService.activeGroup.openEditor(input, { pinned: true, activation: EditorActivation.ACTIVATE });
+        const session = this._instantiationService.createInstance(ChatEditingSession, chatSessionId, editorPane, this._editingSessionFileLimitPromise);
+        this._currentSessionDisposables.add(session.onDidDispose(() => {
+            this._currentSessionDisposables.clear();
+            this._currentSessionObs.set(null, undefined);
+            this._onDidChangeEditingSession.fire();
+        }));
+        this._currentSessionDisposables.add(session.onDidChange(() => {
+            this._onDidChangeEditingSession.fire();
+        }));
+        this._currentSessionObs.set(session, undefined);
+        this._onDidCreateEditingSession.fire(session);
+        this._onDidChangeEditingSession.fire();
+        return session;
+    }
+    triggerEditComputation(responseModel) {
+        return this._continueEditingSession(async (builder, token) => {
+            const codeMapperResponse = {
+                textEdit: (resource, edits) => builder.textEdits(resource, edits, responseModel),
+            };
+            await this._codeMapperService.mapCodeFromResponse(responseModel, codeMapperResponse, token);
+        }, { silent: true });
+    }
+    createSnapshot(requestId) {
+        this._currentSessionObs.get()?.createSnapshot(requestId);
+    }
+    async restoreSnapshot(requestId) {
+        await this._currentSessionObs.get()?.restoreSnapshot(requestId);
+    }
+    installAutoApplyObserver(sessionId) {
+        const chatModel = this._chatService.getSession(sessionId);
+        if (!chatModel) {
+            throw ( (new Error(`Edit session was created for a non-existing chat session: ${sessionId}`)));
+        }
+        const observerDisposables = ( (new DisposableStore()));
+        let editsSource;
+        const editsSeen = ( (new ResourceMap()));
+        const editedFilesExist = ( (new ResourceMap()));
+        const onResponseComplete = (responseModel) => {
+            if (responseModel.result?.errorDetails) {
+                this.restoreSnapshot(responseModel.requestId);
+                this._applyingChatEditsFailedContextKey.set(true);
+            }
+            else if (responseModel.result?.metadata?.autoApplyEdits) {
+                this.triggerEditComputation(responseModel);
+            }
+            editsSource?.resolve();
+            editsSource = undefined;
+            editsSeen.clear();
+            editedFilesExist.clear();
+        };
+        const handleResponseParts = (responseModel) => {
+            for (const part of responseModel.response.value) {
+                if (part.kind === 'codeblockUri' || part.kind === 'textEditGroup') {
+                    if (!editedFilesExist.get(part.uri)) {
+                        editedFilesExist.set(part.uri, this._fileService.exists(part.uri).then((e) => {
+                            if (e) {
+                                this._editorService.openEditor({ resource: part.uri, options: { inactive: true, preserveFocus: true, pinned: true } });
+                            }
+                            return e;
+                        }));
+                    }
+                    const first = editsSeen.size === 0;
+                    let entry = editsSeen.get(part.uri);
+                    if (!entry) {
+                        entry = { seen: 0 };
+                        editsSeen.set(part.uri, entry);
+                    }
+                    const allEdits = part.kind === 'textEditGroup' ? part.edits : [];
+                    const newEdits = allEdits.slice(entry.seen);
+                    entry.seen += newEdits.length;
+                    editsSource ??= ( (new AsyncIterableSource()));
+                    editsSource.emitOne({ uri: part.uri, edits: newEdits, kind: 'textEditGroup' });
+                    if (first) {
+                        this._continueEditingSession(async (builder, token) => {
+                            for await (const item of editsSource.asyncIterable) {
+                                if (token.isCancellationRequested) {
+                                    break;
+                                }
+                                for (const group of item.edits) {
+                                    builder.textEdits(item.uri, group, responseModel);
+                                }
+                            }
+                        }, { silent: true });
+                    }
+                }
+            }
+        };
+        observerDisposables.add(chatModel.onDidChange(e => {
+            if (e.kind === 'addRequest') {
+                this._applyingChatEditsFailedContextKey.set(false);
+                const responseModel = e.request.response;
+                if (responseModel) {
+                    if (responseModel.isComplete) {
+                        handleResponseParts(responseModel);
+                        onResponseComplete(responseModel);
+                    }
+                    else {
+                        const disposable = responseModel.onDidChange(() => {
+                            handleResponseParts(responseModel);
+                            if (responseModel.isComplete) {
+                                onResponseComplete(responseModel);
+                                disposable.dispose();
+                            }
+                            else if (responseModel.isCanceled || responseModel.isStale) {
+                                disposable.dispose();
+                            }
+                        });
+                    }
+                }
+            }
+        }));
+        observerDisposables.add(chatModel.onDidDispose(() => observerDisposables.dispose()));
+        return observerDisposables;
+    }
+    async _continueEditingSession(builder, options) {
+        const session = this._currentSessionObs.get();
+        if (!session) {
+            throw ( (new BugIndicatingError('Cannot continue missing session')));
+        }
+        if (session.state.get() === 1 ) {
+            throw ( (new BugIndicatingError('Cannot continue session that is still streaming')));
+        }
+        let editorPane;
+        if (!options?.silent && session.isVisible) {
+            const groupedEditors = this._findGroupedEditors();
+            if (groupedEditors.length !== 1) {
+                throw ( (new Error(`Unexpected number of editors: ${groupedEditors.length}`)));
+            }
+            const [group, editor] = groupedEditors[0];
+            editorPane = await group.openEditor(editor, { pinned: true, activation: EditorActivation.ACTIVATE });
+        }
+        const stream = {
+            textEdits: (resource, textEdits, responseModel) => {
+                session.acceptTextEdits(resource, textEdits, responseModel);
+            }
+        };
+        session.acceptStreamingEditsStart();
+        const cancellationTokenSource = ( (new CancellationTokenSource()));
+        this._currentAutoApplyOperationObs.set(cancellationTokenSource, undefined);
+        try {
+            if (editorPane) {
+                await editorPane?.showWhile(builder(stream, cancellationTokenSource.token));
+            }
+            else {
+                await this._progressService.withProgress({
+                    location: 10 ,
+                    title: ( localize2(2735, 'Generating edits...')).value,
+                }, async () => {
+                    await builder(stream, cancellationTokenSource.token);
+                }, () => cancellationTokenSource.cancel());
+            }
+        }
+        finally {
+            cancellationTokenSource.dispose();
+            this._currentAutoApplyOperationObs.set(null, undefined);
+            session.resolve();
+        }
+    }
+    _findGroupedEditors() {
+        const editors = [];
+        for (const group of this._editorGroupsService.groups) {
+            for (const editor of group.editors) {
+                if (editor.resource?.scheme === ChatEditingMultiDiffSourceResolver.scheme) {
+                    editors.push([group, editor]);
+                }
+            }
+        }
+        return editors;
+    }
+};
+ChatEditingService = ( (__decorate([
+    ( (__param(0, IEditorGroupsService))),
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IMultiDiffSourceResolverService))),
+    ( (__param(3, ITextModelService))),
+    ( (__param(4, IContextKeyService))),
+    ( (__param(5, IChatService))),
+    ( (__param(6, IProgressService))),
+    ( (__param(7, ICodeMapperService))),
+    ( (__param(8, IEditorService))),
+    ( (__param(9, IDecorationsService))),
+    ( (__param(10, IFileService))),
+    ( (__param(11, IWorkbenchAssignmentService)))
+], ChatEditingService)));
+function observeArrayChanges(obs, compare, store) {
+    const emitter = store.add(( (new Emitter())));
+    store.add(runOnChange(obs, (newArr, oldArr) => {
+        const change = delta(oldArr || [], newArr, compare);
+        const changedElements = [].concat(change.added).concat(change.removed);
+        emitter.fire(changedElements);
+    }));
+    return emitter.event;
+}
+class ChatDecorationsProvider extends Disposable {
+    constructor(_session) {
+        super();
+        this._session = _session;
+        this.label = ( localize(2736, "Chat Editing"));
+        this._currentlyEditingUris = derived(this, (r) => {
+            const session = this._session.read(r);
+            if (!session) {
+                return [];
+            }
+            const state = session.state.read(r);
+            if (state === 3 ) {
+                return [];
+            }
+            return (
+                 (session.entries.read(r).filter(entry => entry.isCurrentlyBeingModified.read(r)).map(entry => entry.modifiedURI))
+            );
+        });
+        this.onDidChange = observeArrayChanges(this._currentlyEditingUris, compareBy(uri => ( (uri.toString())), compare), this._store);
+    }
+    provideDecorations(uri, _token) {
+        const isCurrentlyBeingModified = ( (this._currentlyEditingUris.get().some(e => ( (e.toString())) === ( (uri.toString())))));
+        if (!isCurrentlyBeingModified) {
+            return undefined;
+        }
+        return {
+            weight: 1000,
+            letter: ThemeIcon.modify(Codicon.loading, 'spin'),
+            bubble: false
+        };
+    }
+}
+let ChatEditingMultiDiffSourceResolver = class ChatEditingMultiDiffSourceResolver {
+    static { ChatEditingMultiDiffSourceResolver_1 = this; }
+    static { this.scheme = CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME; }
+    static getMultiDiffSourceUri() {
+        return (
+             (URI.from({
+                scheme: ChatEditingMultiDiffSourceResolver_1.scheme,
+                path: '',
+            }))
+        );
+    }
+    constructor(_currentSession, _instantiationService) {
+        this._currentSession = _currentSession;
+        this._instantiationService = _instantiationService;
+    }
+    canHandleUri(uri) {
+        return uri.scheme === ChatEditingMultiDiffSourceResolver_1.scheme;
+    }
+    async resolveDiffSource(uri) {
+        return this._instantiationService.createInstance(ChatEditingMultiDiffSource, this._currentSession);
+    }
+};
+ChatEditingMultiDiffSourceResolver = ChatEditingMultiDiffSourceResolver_1 = ( (__decorate([
+    ( (__param(1, IInstantiationService)))
+], ChatEditingMultiDiffSourceResolver)));
+class ChatEditingMultiDiffSource {
+    constructor(_currentSession) {
+        this._currentSession = _currentSession;
+        this._resources = derived(this, (reader) => {
+            const currentSession = this._currentSession.read(reader);
+            if (!currentSession) {
+                return [];
+            }
+            const entries = currentSession.entries.read(reader);
+            return (
+                 (entries.map((entry) => {
+                    return (
+                         (new MultiDiffEditorItem(entry.originalURI, entry.modifiedURI, undefined, {
+                            [chatEditingResourceContextKey.key]: entry.entryId,
+                        }))
+                    );
+                }))
+            );
+        });
+        this.resources = ( (new ValueWithChangeEventFromObservable(this._resources)));
+        this.contextKeys = {
+            [inChatEditingSessionContextKey.key]: true
+        };
+    }
+}
+
+export { ChatEditingMultiDiffSourceResolver, ChatEditingService };