@codingame/monaco-vscode-chat-service-override 1.85.1

package/vscode/src/vs/workbench/contrib/chat/browser/chatQuick.js

@@ -0,0 +1,271 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Sash } from 'monaco-editor/esm/vs/base/browser/ui/sash/sash.js';
+import { disposableTimeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, MutableDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { quickInputForeground, quickInputBackground, inputBackground, editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+
+var QuickChat_1;
+let QuickChatService = class QuickChatService extends Disposable {
+    constructor(quickInputService, chatService, instantiationService) {
+        super();
+        this.quickInputService = quickInputService;
+        this.chatService = chatService;
+        this.instantiationService = instantiationService;
+        this._onDidClose = this._register(( new Emitter()));
+        this.onDidClose = this._onDidClose.event;
+    }
+    get enabled() {
+        return this.chatService.getProviderInfos().length > 0;
+    }
+    get focused() {
+        const widget = this._input?.widget;
+        if (!widget) {
+            return false;
+        }
+        return dom.isAncestorOfActiveElement(widget);
+    }
+    toggle(providerId, options) {
+        if (this.focused && !options?.query) {
+            this.close();
+        }
+        else {
+            this.open(providerId, options);
+            if (options?.isPartialQuery) {
+                const disposable = this._store.add(Event.once(this.onDidClose)(() => {
+                    this._currentChat?.clearValue();
+                    this._store.delete(disposable);
+                }));
+            }
+        }
+    }
+    open(providerId, options) {
+        if (this._input) {
+            if (this._currentChat && options?.query) {
+                this._currentChat.setValue(options.query, options.selection);
+                if (!options.isPartialQuery) {
+                    this._currentChat.acceptInput();
+                }
+            }
+            return this.focus();
+        }
+        const providerInfo = providerId
+            ? this.chatService.getProviderInfos().find(info => info.id === providerId)
+            : this.chatService.getProviderInfos()[0];
+        if (!providerInfo) {
+            return;
+        }
+        const disposableStore = ( new DisposableStore());
+        this._input = this.quickInputService.createQuickWidget();
+        this._input.contextKey = 'chatInputVisible';
+        this._input.ignoreFocusOut = true;
+        disposableStore.add(this._input);
+        this._container ??= dom.$('.interactive-session');
+        this._input.widget = this._container;
+        this._input.show();
+        if (!this._currentChat) {
+            this._currentChat = this.instantiationService.createInstance(QuickChat, {
+                providerId: providerInfo.id,
+            });
+            this._currentChat.render(this._container);
+        }
+        else {
+            this._currentChat.show();
+        }
+        disposableStore.add(this._input.onDidHide(() => {
+            disposableStore.dispose();
+            this._currentChat.hide();
+            this._input = undefined;
+            this._onDidClose.fire();
+        }));
+        this._currentChat.focus();
+        if (options?.query) {
+            this._currentChat.setValue(options.query, options.selection);
+            if (!options.isPartialQuery) {
+                this._currentChat.acceptInput();
+            }
+        }
+    }
+    focus() {
+        this._currentChat?.focus();
+    }
+    close() {
+        this._input?.dispose();
+        this._input = undefined;
+    }
+    async openInChatView() {
+        await this._currentChat?.openChatView();
+        this.close();
+    }
+};
+QuickChatService = ( __decorate([
+    ( __param(0, IQuickInputService)),
+    ( __param(1, IChatService)),
+    ( __param(2, IInstantiationService))
+], QuickChatService));
+let QuickChat = class QuickChat extends Disposable {
+    static { QuickChat_1 = this; }
+    static { this.DEFAULT_MIN_HEIGHT = 200; }
+    static { this.DEFAULT_HEIGHT_OFFSET = 100; }
+    constructor(_options, instantiationService, contextKeyService, chatService, _chatWidgetService, layoutService) {
+        super();
+        this._options = _options;
+        this.instantiationService = instantiationService;
+        this.contextKeyService = contextKeyService;
+        this.chatService = chatService;
+        this._chatWidgetService = _chatWidgetService;
+        this.layoutService = layoutService;
+        this.maintainScrollTimer = this._register(( new MutableDisposable()));
+        this._deferUpdatingDynamicLayout = false;
+    }
+    clear() {
+        this.model?.dispose();
+        this.model = undefined;
+        this.updateModel();
+        this.widget.inputEditor.setValue('');
+    }
+    focus(selection) {
+        if (this.widget) {
+            this.widget.focusInput();
+            const value = this.widget.inputEditor.getValue();
+            if (value) {
+                this.widget.inputEditor.setSelection(selection ?? {
+                    startLineNumber: 1,
+                    startColumn: 1,
+                    endLineNumber: 1,
+                    endColumn: value.length + 1
+                });
+            }
+        }
+    }
+    hide() {
+        this.widget.setVisible(false);
+        this.maintainScrollTimer.value = disposableTimeout(() => {
+            this.maintainScrollTimer.clear();
+        }, 30 * 1000);
+    }
+    show() {
+        this.widget.setVisible(true);
+        if (this._deferUpdatingDynamicLayout) {
+            this._deferUpdatingDynamicLayout = false;
+            this.widget.updateDynamicChatTreeItemLayout(2, this.maxHeight);
+        }
+        if (!this.maintainScrollTimer.value) {
+            this.widget.layoutDynamicChatTreeItemMode();
+        }
+    }
+    render(parent) {
+        if (this.widget) {
+            throw new Error('Cannot render quick chat twice');
+        }
+        const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([
+            IContextKeyService,
+            this._register(this.contextKeyService.createScoped(parent))
+        ])));
+        this.widget = this._register(scopedInstantiationService.createInstance(ChatWidget, { resource: true }, { renderInputOnTop: true, renderStyle: 'compact' }, {
+            listForeground: quickInputForeground,
+            listBackground: quickInputBackground,
+            inputEditorBackground: inputBackground,
+            resultEditorBackground: editorBackground
+        }));
+        this.widget.render(parent);
+        this.widget.setVisible(true);
+        this.widget.setDynamicChatTreeItemLayout(2, this.maxHeight);
+        this.updateModel();
+        this.sash = this._register(( new Sash(
+            parent,
+            { getHorizontalSashTop: () => parent.offsetHeight },
+            { orientation: 1  }
+        )));
+        this.registerListeners(parent);
+    }
+    get maxHeight() {
+        return this.layoutService.mainContainerDimension.height - QuickChat_1.DEFAULT_HEIGHT_OFFSET;
+    }
+    registerListeners(parent) {
+        this._register(this.layoutService.onDidLayoutMainContainer(() => {
+            if (this.widget.visible) {
+                this.widget.updateDynamicChatTreeItemLayout(2, this.maxHeight);
+            }
+            else {
+                this._deferUpdatingDynamicLayout = true;
+            }
+        }));
+        this._register(this.widget.inputEditor.onDidChangeModelContent((e) => {
+            this._currentQuery = this.widget.inputEditor.getValue();
+        }));
+        this._register(this.widget.onDidClear(() => this.clear()));
+        this._register(this.widget.onDidChangeHeight((e) => this.sash.layout()));
+        const width = parent.offsetWidth;
+        this._register(this.sash.onDidStart(() => {
+            this.widget.isDynamicChatTreeItemLayoutEnabled = false;
+        }));
+        this._register(this.sash.onDidChange((e) => {
+            if (e.currentY < QuickChat_1.DEFAULT_MIN_HEIGHT || e.currentY > this.maxHeight) {
+                return;
+            }
+            this.widget.layout(e.currentY, width);
+            this.sash.layout();
+        }));
+        this._register(this.sash.onDidReset(() => {
+            this.widget.isDynamicChatTreeItemLayoutEnabled = true;
+            this.widget.layoutDynamicChatTreeItemMode();
+        }));
+    }
+    async acceptInput() {
+        return this.widget.acceptInput();
+    }
+    async openChatView() {
+        const widget = await this._chatWidgetService.revealViewForProvider(this._options.providerId);
+        if (!widget?.viewModel || !this.model) {
+            return;
+        }
+        for (const request of this.model.getRequests()) {
+            if (request.response?.response.value || request.response?.errorDetails) {
+                this.chatService.addCompleteRequest(widget.viewModel.sessionId, request.message, {
+                    message: request.response.response.value,
+                    errorDetails: request.response.errorDetails,
+                    followups: request.response.followups
+                });
+            }
+        }
+        const value = this.widget.inputEditor.getValue();
+        if (value) {
+            widget.inputEditor.setValue(value);
+        }
+        widget.focusInput();
+    }
+    setValue(value, selection) {
+        this.widget.inputEditor.setValue(value);
+        this.focus(selection);
+    }
+    clearValue() {
+        this.widget.inputEditor.setValue('');
+    }
+    updateModel() {
+        this.model ??= this.chatService.startSession(this._options.providerId, CancellationToken.None);
+        if (!this.model) {
+            throw new Error('Could not start chat session');
+        }
+        this.widget.setModel(this.model, { inputValue: this._currentQuery });
+    }
+};
+QuickChat = QuickChat_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, IChatService)),
+    ( __param(4, IChatWidgetService)),
+    ( __param(5, ILayoutService))
+], QuickChat));
+
+export { QuickChatService };

package/vscode/src/vs/workbench/contrib/chat/browser/chatVariables.js

@@ -0,0 +1,91 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IChatWidgetService } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chat';
+import { ChatDynamicVariableModel } from 'vscode/vscode/vs/workbench/contrib/chat/browser/contrib/chatDynamicVariables';
+import { ChatRequestVariablePart, ChatRequestDynamicVariablePart } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatParserTypes';
+
+let ChatVariablesService = class ChatVariablesService {
+    constructor(chatWidgetService) {
+        this.chatWidgetService = chatWidgetService;
+        this._resolver = ( new Map());
+    }
+    async resolveVariables(prompt, model, token) {
+        const resolvedVariables = {};
+        const jobs = [];
+        const parsedPrompt = [];
+        prompt.parts
+            .forEach((part, i) => {
+            if (part instanceof ChatRequestVariablePart) {
+                const data = this._resolver.get(part.variableName.toLowerCase());
+                if (data) {
+                    jobs.push(data.resolver(prompt.text, part.variableArg, model, token).then(value => {
+                        if (value) {
+                            resolvedVariables[part.variableName] = value;
+                            parsedPrompt[i] = `[${part.text}](values:${part.variableName})`;
+                        }
+                        else {
+                            parsedPrompt[i] = part.promptText;
+                        }
+                    }).catch(onUnexpectedExternalError));
+                }
+            }
+            else if (part instanceof ChatRequestDynamicVariablePart) {
+                const referenceName = this.getUniqueReferenceName(part.referenceText, resolvedVariables);
+                resolvedVariables[referenceName] = part.data;
+                const safeText = part.text.replace(/[\[\]]/g, '_');
+                const safeTarget = referenceName.replace(/[\(\)]/g, '_');
+                parsedPrompt[i] = `[${safeText}](values:${safeTarget})`;
+            }
+            else {
+                parsedPrompt[i] = part.promptText;
+            }
+        });
+        await Promise.allSettled(jobs);
+        return {
+            variables: resolvedVariables,
+            prompt: parsedPrompt.join('').trim()
+        };
+    }
+    getUniqueReferenceName(name, vars) {
+        let i = 1;
+        while (vars[name]) {
+            name = `${name}_${i++}`;
+        }
+        return name;
+    }
+    hasVariable(name) {
+        return ( this._resolver.has(name.toLowerCase()));
+    }
+    getVariables() {
+        const all = ( Iterable.map(( this._resolver.values()), data => data.data));
+        return Iterable.filter(all, data => !data.hidden);
+    }
+    getDynamicVariables(sessionId) {
+        const widget = this.chatWidgetService.getWidgetBySessionId(sessionId);
+        if (!widget || !widget.viewModel || !widget.supportsFileReferences) {
+            return [];
+        }
+        const model = widget.getContrib(ChatDynamicVariableModel.ID);
+        if (!model) {
+            return [];
+        }
+        return model.variables;
+    }
+    registerVariable(data, resolver) {
+        const key = data.name.toLowerCase();
+        if (( this._resolver.has(key))) {
+            throw new Error(`A chat variable with the name '${data.name}' already exists.`);
+        }
+        this._resolver.set(key, { data, resolver });
+        return toDisposable(() => {
+            this._resolver.delete(key);
+        });
+    }
+};
+ChatVariablesService = ( __decorate([
+    ( __param(0, IChatWidgetService))
+], ChatVariablesService));
+
+export { ChatVariablesService };

package/vscode/src/vs/workbench/contrib/chat/browser/chatViewPane.js

@@ -0,0 +1,165 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from 'monaco-editor/esm/vs/platform/instantiation/common/serviceCollection.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { editorBackground } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
+import { SIDE_BAR_FOREGROUND } from 'vscode/vscode/vs/workbench/common/theme';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { ChatWidget } from 'vscode/vscode/vs/workbench/contrib/chat/browser/chatWidget';
+import { IChatService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatService';
+
+const CHAT_SIDEBAR_PANEL_ID = 'workbench.panel.chatSidebar';
+let ChatViewPane = class ChatViewPane extends ViewPane {
+    static { this.ID = 'workbench.panel.chat.view'; }
+    get widget() { return this._widget; }
+    constructor(chatViewOptions, options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService, storageService, chatService, logService) {
+        super(options, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, instantiationService, openerService, themeService, telemetryService);
+        this.chatViewOptions = chatViewOptions;
+        this.storageService = storageService;
+        this.chatService = chatService;
+        this.logService = logService;
+        this.modelDisposables = this._register(( new DisposableStore()));
+        this.didProviderRegistrationFail = false;
+        this.memento = ( new Memento(
+            'interactive-session-view-' + this.chatViewOptions.providerId,
+            this.storageService
+        ));
+        this.viewState = this.memento.getMemento(1 , 1 );
+        this._register(this.chatService.onDidRegisterProvider(({ providerId }) => {
+            if (providerId === this.chatViewOptions.providerId && !this._widget?.viewModel) {
+                const sessionId = this.getSessionId();
+                const model = sessionId ? this.chatService.getOrRestoreSession(sessionId) : undefined;
+                try {
+                    this._widget.setVisible(false);
+                    this.updateModel(model);
+                    this._onDidChangeViewWelcomeState.fire();
+                }
+                finally {
+                    this.widget.setVisible(true);
+                }
+            }
+        }));
+    }
+    updateModel(model, viewState) {
+        this.modelDisposables.clear();
+        model = model ?? (this.chatService.transferredSessionData?.sessionId
+            ? this.chatService.getOrRestoreSession(this.chatService.transferredSessionData.sessionId)
+            : this.chatService.startSession(this.chatViewOptions.providerId, CancellationToken.None));
+        if (!model) {
+            throw new Error('Could not start chat session');
+        }
+        this._widget.setModel(model, { ...(viewState ?? this.viewState) });
+        this.viewState.sessionId = model.sessionId;
+    }
+    shouldShowWelcome() {
+        const noPersistedSessions = !this.chatService.hasSessions(this.chatViewOptions.providerId);
+        return !this._widget?.viewModel && (noPersistedSessions || this.didProviderRegistrationFail);
+    }
+    getSessionId() {
+        let sessionId;
+        if (this.chatService.transferredSessionData) {
+            sessionId = this.chatService.transferredSessionData.sessionId;
+            this.viewState.inputValue = this.chatService.transferredSessionData.inputValue;
+        }
+        else {
+            sessionId = this.viewState.sessionId;
+        }
+        return sessionId;
+    }
+    renderBody(parent) {
+        try {
+            super.renderBody(parent);
+            const scopedInstantiationService = this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this.scopedContextKeyService])));
+            this._widget = this._register(scopedInstantiationService.createInstance(ChatWidget, { viewId: this.id }, { supportsFileReferences: true }, {
+                listForeground: SIDE_BAR_FOREGROUND,
+                listBackground: this.getBackgroundColor(),
+                inputEditorBackground: this.getBackgroundColor(),
+                resultEditorBackground: editorBackground
+            }));
+            this._register(this.onDidChangeBodyVisibility(visible => {
+                this._widget.setVisible(visible);
+            }));
+            this._register(this._widget.onDidClear(() => this.clear()));
+            this._widget.render(parent);
+            const sessionId = this.getSessionId();
+            const disposeListener = sessionId ? this._register(this.chatService.onDidDisposeSession((e) => {
+                if (e.reason === 'initializationFailed' && e.providerId === this.chatViewOptions.providerId) {
+                    this.didProviderRegistrationFail = true;
+                    disposeListener?.dispose();
+                    this._onDidChangeViewWelcomeState.fire();
+                }
+            })) : undefined;
+            const model = sessionId ? this.chatService.getOrRestoreSession(sessionId) : undefined;
+            this.updateModel(model);
+        }
+        catch (e) {
+            this.logService.error(e);
+            throw e;
+        }
+    }
+    acceptInput(query) {
+        this._widget.acceptInput(query);
+    }
+    async clear() {
+        if (this.widget.viewModel) {
+            this.chatService.clearSession(this.widget.viewModel.sessionId);
+        }
+        this.updateModel(undefined, { ...this.viewState, inputValue: undefined });
+    }
+    loadSession(sessionId) {
+        if (this.widget.viewModel) {
+            this.chatService.clearSession(this.widget.viewModel.sessionId);
+        }
+        const newModel = this.chatService.getOrRestoreSession(sessionId);
+        this.updateModel(newModel);
+    }
+    focusInput() {
+        this._widget.focusInput();
+    }
+    focus() {
+        super.focus();
+        this._widget.focusInput();
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        this._widget.layout(height, width);
+    }
+    saveState() {
+        if (this._widget) {
+            this._widget.saveState();
+            const widgetViewState = this._widget.getViewState();
+            this.viewState.inputValue = widgetViewState.inputValue;
+            this.viewState.inputState = widgetViewState.inputState;
+            this.memento.saveMemento();
+        }
+        super.saveState();
+    }
+};
+ChatViewPane = ( __decorate([
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextMenuService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IContextKeyService)),
+    ( __param(6, IViewDescriptorService)),
+    ( __param(7, IInstantiationService)),
+    ( __param(8, IOpenerService)),
+    ( __param(9, IThemeService)),
+    ( __param(10, ITelemetryService)),
+    ( __param(11, IStorageService)),
+    ( __param(12, IChatService)),
+    ( __param(13, ILogService))
+], ChatViewPane));
+
+export { CHAT_SIDEBAR_PANEL_ID, ChatViewPane };

package/vscode/src/vs/workbench/contrib/chat/browser/contrib/chatHistoryVariables.js

@@ -0,0 +1,26 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IChatVariablesService } from 'vscode/vscode/vs/workbench/contrib/chat/common/chatVariables';
+
+let ChatHistoryVariables = class ChatHistoryVariables extends Disposable {
+    constructor(chatVariablesService) {
+        super();
+        this._register(chatVariablesService.registerVariable({ name: 'response', description: '', canTakeArgument: true, hidden: true }, async (message, arg, model, token) => {
+            if (!arg) {
+                return undefined;
+            }
+            const responseNum = parseInt(arg, 10);
+            const response = model.getRequests()[responseNum - 1].response;
+            if (!response) {
+                return undefined;
+            }
+            return [{ level: 'full', value: response.response.asString() }];
+        }));
+    }
+};
+ChatHistoryVariables = ( __decorate([
+    ( __param(0, IChatVariablesService))
+], ChatHistoryVariables));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ChatHistoryVariables, 4 );