@codingame/monaco-vscode-chat-service-override 2.0.3 → 2.1.0

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl.js

@@ -0,0 +1,236 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Queue, raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { DisposableStore, MutableDisposable, dispose, combinedDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { isCodeEditor } from 'vscode/vscode/vs/editor/browser/editorBrowser';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IInlineChatSessionService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSessionService';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IFilesConfigurationService } from 'vscode/vscode/vs/workbench/services/filesConfiguration/common/filesConfigurationService';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { compare } from 'vscode/vscode/vs/base/common/strings';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { Event } from 'vscode/vscode/vs/base/common/event';
+import { InlineChatController } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+
+let InlineChatSavingServiceImpl = class InlineChatSavingServiceImpl {
+    constructor(_fileConfigService, _editorGroupService, _textFileService, _editorService, _inlineChatSessionService, _configService, _workingCopyFileService, _logService) {
+        this._fileConfigService = _fileConfigService;
+        this._editorGroupService = _editorGroupService;
+        this._textFileService = _textFileService;
+        this._editorService = _editorService;
+        this._inlineChatSessionService = _inlineChatSessionService;
+        this._configService = _configService;
+        this._workingCopyFileService = _workingCopyFileService;
+        this._logService = _logService;
+        this._store = ( new DisposableStore());
+        this._saveParticipant = this._store.add(( new MutableDisposable()));
+        this._sessionData = ( new Map());
+        this._store.add(Event.any(_inlineChatSessionService.onDidEndSession, _inlineChatSessionService.onDidStashSession)(e => {
+            this._sessionData.get(e.session)?.dispose();
+        }));
+    }
+    dispose() {
+        this._store.dispose();
+        dispose(( this._sessionData.values()));
+    }
+    markChanged(session) {
+        if (!( this._sessionData.has(session))) {
+            let uri = session.targetUri;
+            if (uri.scheme === Schemas.vscodeNotebookCell) {
+                const data = CellUri.parse(uri);
+                if (!data) {
+                    return;
+                }
+                uri = data?.notebook;
+            }
+            if (this._sessionData.size === 0) {
+                this._installSaveParticpant();
+            }
+            const saveConfigOverride = this._fileConfigService.disableAutoSave(uri);
+            this._sessionData.set(session, {
+                resourceUri: uri,
+                groupCandidate: this._editorGroupService.activeGroup,
+                session,
+                dispose: () => {
+                    saveConfigOverride.dispose();
+                    this._sessionData.delete(session);
+                    if (this._sessionData.size === 0) {
+                        this._saveParticipant.clear();
+                    }
+                }
+            });
+        }
+    }
+    _installSaveParticpant() {
+        const queue = ( new Queue());
+        const d1 = this._textFileService.files.addSaveParticipant({
+            participate: (model, context, progress, token) => {
+                return queue.queue(() => this._participate(model.textEditorModel?.uri, context.reason, progress, token));
+            }
+        });
+        const d2 = this._workingCopyFileService.addSaveParticipant({
+            participate: (workingCopy, env, progress, token) => {
+                return queue.queue(() => this._participate(workingCopy.resource, env.reason, progress, token));
+            }
+        });
+        this._saveParticipant.value = combinedDisposable(d1, d2, queue);
+    }
+    async _participate(uri, reason, progress, token) {
+        if (reason !== 1 ) {
+            return;
+        }
+        if (!this._configService.getValue("inlineChat.acceptedOrDiscardBeforeSave" )) {
+            return;
+        }
+        const sessions = ( new Map());
+        for (const [session, data] of this._sessionData) {
+            if (uri?.toString() === ( data.resourceUri.toString())) {
+                sessions.set(session, data);
+            }
+        }
+        if (sessions.size === 0) {
+            return;
+        }
+        progress.report({
+            message: sessions.size === 1
+                ? ( localizeWithPath(
+                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
+                'inlineChat',
+                "Waiting for Inline Chat changes to be Accepted or Discarded..."
+            ))
+                : ( localizeWithPath(
+                'vs/workbench/contrib/inlineChat/browser/inlineChatSavingServiceImpl',
+                'inlineChat.N',
+                "Waiting for Inline Chat changes in {0} editors to be Accepted or Discarded...",
+                sessions.size
+            ))
+        });
+        const { groups, orphans } = this._getGroupsAndOrphans(( sessions.values()));
+        const editorsOpenedAndSessionsEnded = this._openAndWait(groups, token).then(() => {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            return this._openAndWait(( Iterable.map(orphans, s => [this._editorGroupService.activeGroup, s])), token);
+        });
+        const allSessionsEnded = this._whenSessionsEnded(Iterable.concat(( groups.map(tuple => tuple[1])), orphans), token);
+        await Promise.race([allSessionsEnded, editorsOpenedAndSessionsEnded]);
+    }
+    _getGroupsAndOrphans(sessions) {
+        const groupByEditor = ( new Map());
+        for (const group of this._editorGroupService.getGroups(1 )) {
+            const candidate = group.activeEditorPane?.getControl();
+            if (isCodeEditor(candidate)) {
+                groupByEditor.set(candidate, group);
+            }
+        }
+        const groups = [];
+        const orphans = ( new Set());
+        for (const data of sessions) {
+            const editor = this._inlineChatSessionService.getCodeEditor(data.session);
+            const group = groupByEditor.get(editor);
+            if (group) {
+                groups.push([group, data]);
+            }
+            else if (this._editorGroupService.groups.includes(data.groupCandidate)) {
+                groups.push([data.groupCandidate, data]);
+            }
+            else {
+                orphans.add(data);
+            }
+        }
+        return { groups, orphans };
+    }
+    async _openAndWait(groups, token) {
+        const dataByGroup = ( new Map());
+        for (const [group, data] of groups) {
+            let array = dataByGroup.get(group);
+            if (!array) {
+                array = [];
+                dataByGroup.set(group, array);
+            }
+            array.push(data);
+        }
+        for (const [group, array] of dataByGroup) {
+            if (token.isCancellationRequested) {
+                break;
+            }
+            array.sort((a, b) => compare(( a.session.targetUri.toString()), ( b.session.targetUri.toString())));
+            for (const data of array) {
+                const input = { resource: data.resourceUri };
+                const pane = await this._editorService.openEditor(input, group);
+                let editor;
+                if (data.session.targetUri.scheme === Schemas.vscodeNotebookCell) {
+                    const notebookEditor = getNotebookEditorFromEditorPane(pane);
+                    const uriData = CellUri.parse(data.session.targetUri);
+                    if (notebookEditor && notebookEditor.hasModel() && uriData) {
+                        const cell = notebookEditor.getCellByHandle(uriData.handle);
+                        if (cell) {
+                            await notebookEditor.revealRangeInCenterIfOutsideViewportAsync(cell, data.session.wholeRange.value);
+                        }
+                        const tuple = notebookEditor.codeEditors.find(tuple => tuple[1].getModel()?.uri.toString() === ( data.session.targetUri.toString()));
+                        editor = tuple?.[1];
+                    }
+                }
+                else {
+                    if (isCodeEditor(pane?.getControl())) {
+                        editor = pane.getControl();
+                    }
+                }
+                if (!editor) {
+                    break;
+                }
+                this._inlineChatSessionService.moveSession(data.session, editor);
+                InlineChatController.get(editor)?.showSaveHint();
+                this._logService.info('WAIT for session to end', editor.getId(), ( data.session.targetUri.toString()));
+                await this._whenSessionsEnded(Iterable.single(data), token);
+            }
+        }
+    }
+    async _whenSessionsEnded(iterable, token) {
+        const sessions = ( new Map());
+        for (const item of iterable) {
+            sessions.set(item.session, item);
+        }
+        if (sessions.size === 0) {
+            return;
+        }
+        let listener;
+        const whenEnded = ( new Promise(resolve => {
+            listener = Event.any(this._inlineChatSessionService.onDidEndSession, this._inlineChatSessionService.onDidStashSession)(e => {
+                const data = sessions.get(e.session);
+                if (data) {
+                    data.dispose();
+                    sessions.delete(e.session);
+                    if (sessions.size === 0) {
+                        resolve();
+                    }
+                }
+            });
+        }));
+        try {
+            await raceCancellation(whenEnded, token);
+        }
+        finally {
+            listener?.dispose();
+        }
+    }
+};
+InlineChatSavingServiceImpl = ( __decorate([
+    ( __param(0, IFilesConfigurationService)),
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, ITextFileService)),
+    ( __param(3, IEditorService)),
+    ( __param(4, IInlineChatSessionService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, IWorkingCopyFileService)),
+    ( __param(7, ILogService))
+], InlineChatSavingServiceImpl));
+
+export { InlineChatSavingServiceImpl };

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSessionServiceImpl.js

@@ -0,0 +1,210 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { IInlineChatService } from 'vscode/vscode/vs/workbench/contrib/inlineChat/common/inlineChat';
+import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import { DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { createTextBufferFactoryFromSnapshot } from 'vscode/vscode/vs/editor/common/model/textModel';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { Iterable } from 'vscode/vscode/vs/base/common/iterator';
+import { raceCancellation } from 'vscode/vscode/vs/base/common/async';
+import { Session, SessionWholeRange, HunkData, StashedSession } from 'vscode/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatSession';
+import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/editorWorker';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { generateUuid } from 'vscode/vscode/vs/base/common/uuid';
+import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
+
+let InlineChatSessionServiceImpl = class InlineChatSessionServiceImpl {
+    constructor(_inlineChatService, _telemetryService, _modelService, _textModelService, _editorWorkerService, _logService, _instaService, _textFileService) {
+        this._inlineChatService = _inlineChatService;
+        this._telemetryService = _telemetryService;
+        this._modelService = _modelService;
+        this._textModelService = _textModelService;
+        this._editorWorkerService = _editorWorkerService;
+        this._logService = _logService;
+        this._instaService = _instaService;
+        this._textFileService = _textFileService;
+        this._onWillStartSession = ( new Emitter());
+        this.onWillStartSession = this._onWillStartSession.event;
+        this._onDidMoveSession = ( new Emitter());
+        this.onDidMoveSession = this._onDidMoveSession.event;
+        this._onDidEndSession = ( new Emitter());
+        this.onDidEndSession = this._onDidEndSession.event;
+        this._onDidStashSession = ( new Emitter());
+        this.onDidStashSession = this._onDidStashSession.event;
+        this._sessions = ( new Map());
+        this._keyComputers = ( new Map());
+        this._recordings = [];
+    }
+    dispose() {
+        this._onWillStartSession.dispose();
+        this._onDidEndSession.dispose();
+        this._sessions.forEach(x => x.store.dispose());
+        this._sessions.clear();
+    }
+    async createSession(editor, options, token) {
+        const provider = Iterable.first(this._inlineChatService.getAllProvider());
+        if (!provider) {
+            this._logService.trace('[IE] NO provider found');
+            return undefined;
+        }
+        this._onWillStartSession.fire(editor);
+        const textModel = editor.getModel();
+        const selection = editor.getSelection();
+        let rawSession;
+        try {
+            rawSession = await raceCancellation(Promise.resolve(provider.prepareInlineChatSession(textModel, selection, token)), token);
+        }
+        catch (error) {
+            this._logService.error('[IE] FAILED to prepare session', provider.debugName);
+            this._logService.error(error);
+            return undefined;
+        }
+        if (!rawSession) {
+            this._logService.trace('[IE] NO session', provider.debugName);
+            return undefined;
+        }
+        this._logService.trace('[IE] NEW session', provider.debugName);
+        this._logService.trace(`[IE] creating NEW session for ${editor.getId()},  ${provider.debugName}`);
+        const store = ( new DisposableStore());
+        const id = generateUuid();
+        const targetUri = textModel.uri;
+        let textModelN;
+        if (options.editMode === "preview" ) {
+            textModelN = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.inMemory, query: ( ( new URLSearchParams({ id, 'inline-chat-textModelN': '' })).toString()) }), true));
+        }
+        else {
+            store.add((await this._textModelService.createModelReference(textModel.uri)));
+            textModelN = textModel;
+        }
+        const textModel0 = store.add(this._modelService.createModel(createTextBufferFactoryFromSnapshot(textModel.createSnapshot()), { languageId: textModel.getLanguageId(), onDidChange: Event.None }, targetUri.with({ scheme: Schemas.inMemory, query: ( ( new URLSearchParams({ id, 'inline-chat-textModel0': '' })).toString()) }), true));
+        if (targetUri.scheme === Schemas.untitled) {
+            const untitledTextModel = this._textFileService.untitled.get(targetUri);
+            if (untitledTextModel) {
+                store.add(untitledTextModel.onDidChangeDirty(() => {
+                    if (!untitledTextModel.isDirty()) {
+                        this.releaseSession(session);
+                    }
+                }));
+            }
+        }
+        let wholeRange = options.wholeRange;
+        if (!wholeRange) {
+            wholeRange = rawSession.wholeRange ? Range.lift(rawSession.wholeRange) : editor.getSelection();
+        }
+        const session = ( new Session(
+            options.editMode,
+            targetUri,
+            textModel0,
+            textModelN,
+            provider,
+            rawSession,
+            store.add(( new SessionWholeRange(textModelN, wholeRange))),
+            store.add(( new HunkData(this._editorWorkerService, textModel0, textModelN)))
+        ));
+        const key = this._key(editor, session.targetUri);
+        if (( this._sessions.has(key))) {
+            store.dispose();
+            throw new Error(`Session already stored for ${key}`);
+        }
+        this._sessions.set(key, { session, editor, store });
+        return session;
+    }
+    moveSession(session, target) {
+        const newKey = this._key(target, session.targetUri);
+        const existing = this._sessions.get(newKey);
+        if (existing) {
+            if (existing.session !== session) {
+                throw new Error(`Cannot move session because the target editor already/still has one`);
+            }
+            else {
+                return;
+            }
+        }
+        let found = false;
+        for (const [oldKey, data] of this._sessions) {
+            if (data.session === session) {
+                found = true;
+                this._sessions.delete(oldKey);
+                this._sessions.set(newKey, { ...data, editor: target });
+                this._logService.trace(`[IE] did MOVE session for ${data.editor.getId()} to NEW EDITOR ${target.getId()}, ${session.provider.debugName}`);
+                this._onDidMoveSession.fire({ session, editor: target });
+                break;
+            }
+        }
+        if (!found) {
+            throw new Error(`Cannot move session because it is not stored`);
+        }
+    }
+    releaseSession(session) {
+        let data;
+        for (const [key, value] of this._sessions) {
+            if (value.session === session) {
+                data = value;
+                value.store.dispose();
+                this._sessions.delete(key);
+                this._logService.trace(`[IE] did RELEASED session for ${value.editor.getId()}, ${session.provider.debugName}`);
+                break;
+            }
+        }
+        if (!data) {
+            return;
+        }
+        this._keepRecording(session);
+        this._telemetryService.publicLog2('interactiveEditor/session', session.asTelemetryData());
+        this._onDidEndSession.fire({ editor: data.editor, session });
+    }
+    stashSession(session, editor, undoCancelEdits) {
+        this._keepRecording(session);
+        const result = this._instaService.createInstance(StashedSession, editor, session, undoCancelEdits);
+        this._onDidStashSession.fire({ editor, session });
+        this._logService.trace(`[IE] did STASH session for ${editor.getId()}, ${session.provider.debugName}`);
+        return result;
+    }
+    getCodeEditor(session) {
+        for (const [, data] of this._sessions) {
+            if (data.session === session) {
+                return data.editor;
+            }
+        }
+        throw new Error('session not found');
+    }
+    getSession(editor, uri) {
+        const key = this._key(editor, uri);
+        return this._sessions.get(key)?.session;
+    }
+    _key(editor, uri) {
+        const item = this._keyComputers.get(uri.scheme);
+        return item
+            ? item.getComparisonKey(editor, uri)
+            : `${editor.getId()}@${( uri.toString())}`;
+    }
+    registerSessionKeyComputer(scheme, value) {
+        this._keyComputers.set(scheme, value);
+        return toDisposable(() => this._keyComputers.delete(scheme));
+    }
+    _keepRecording(session) {
+        const newLen = this._recordings.unshift(session.asRecording());
+        if (newLen > 5) {
+            this._recordings.pop();
+        }
+    }
+    recordings() {
+        return this._recordings;
+    }
+};
+InlineChatSessionServiceImpl = ( __decorate([
+    ( __param(0, IInlineChatService)),
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ITextModelService)),
+    ( __param(4, IEditorWorkerService)),
+    ( __param(5, ILogService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, ITextFileService))
+], InlineChatSessionServiceImpl));
+
+export { InlineChatSessionServiceImpl };

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -1,3 +0,0 @@
-var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
-
-export { n as default };

package/vscode/src/vs/workbench/contrib/chat/browser/media/chatEditor.css.js

@@ -1,6 +0,0 @@
-import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-
-var css = ".show-file-icons .chat-editor-label.file-icon:before,.vs .show-file-icons .chat-editor-label.file-icon:before{content:\"\\EAC7\";font-family:codicon;font-size:16px}";
-n(css,{});
-
-export { css, css as default };