@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatQuickInputActions.js

@@ -1,2 +1,206 @@
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { CHAT_CATEGORY } from './chatActions.js';
+import { IQuickChatService } from '../chat.js';
+import { CONTEXT_PROVIDER_EXISTS } from '../../common/chatContextKeys.js';
+import { InlineChatController } from '../../../inlineChat/browser/inlineChatController.js';
 const ASK_QUICK_QUESTION_ACTION_ID = 'workbench.action.quickchat.toggle';
-export { ASK_QUICK_QUESTION_ACTION_ID };
+function registerQuickChatActions() {
+    registerAction2(QuickChatGlobalAction);
+    registerAction2(class OpenInChatViewAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.quickchat.openInChatView',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                        'chat.openInChatView.label',
+                        "Open in Chat View"
+                    )),
+                    original: 'Open in Chat View'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.commentDiscussion,
+                menu: {
+                    id: MenuId.ChatInputSide,
+                    group: 'navigation',
+                    order: 10
+                }
+            });
+        }
+        run(accessor) {
+            const quickChatService = accessor.get(IQuickChatService);
+            quickChatService.openInChatView();
+        }
+    });
+    registerAction2(class CloseQuickChatAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.quickchat.close',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                        'chat.closeQuickChat.label',
+                        "Close Quick Chat"
+                    )),
+                    original: 'Close Quick Chat'
+                },
+                f1: false,
+                category: CHAT_CATEGORY,
+                icon: Codicon.close,
+                menu: {
+                    id: MenuId.ChatInputSide,
+                    group: 'navigation',
+                    order: 20
+                }
+            });
+        }
+        run(accessor) {
+            const quickChatService = accessor.get(IQuickChatService);
+            quickChatService.close();
+        }
+    });
+    registerAction2(class LaunchInlineChatFromQuickChatAction extends Action2 {
+        constructor() {
+            super({
+                id: 'workbench.action.quickchat.launchInlineChat',
+                title: {
+                    value: ( localizeWithPath(
+                        'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                        'chat.launchInlineChat.label',
+                        "Launch Inline Chat"
+                    )),
+                    original: 'Launch Inline Chat'
+                },
+                f1: false,
+                category: CHAT_CATEGORY
+            });
+        }
+        async run(accessor) {
+            const quickChatService = accessor.get(IQuickChatService);
+            const codeEditorService = accessor.get(ICodeEditorService);
+            if (quickChatService.focused) {
+                quickChatService.close();
+            }
+            const codeEditor = codeEditorService.getActiveCodeEditor();
+            if (!codeEditor) {
+                return;
+            }
+            const controller = InlineChatController.get(codeEditor);
+            if (!controller) {
+                return;
+            }
+            await controller.run();
+            controller.focus();
+        }
+    });
+}
+class QuickChatGlobalAction extends Action2 {
+    constructor() {
+        super({
+            id: ASK_QUICK_QUESTION_ACTION_ID,
+            title: { value: ( localizeWithPath(
+                'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                'quickChat',
+                "Quick Chat"
+            )), original: 'Quick Chat' },
+            precondition: CONTEXT_PROVIDER_EXISTS,
+            icon: Codicon.commentDiscussion,
+            f1: false,
+            category: CHAT_CATEGORY,
+            keybinding: {
+                weight: 200 ,
+                primary: 2048  | 1024  | 39 ,
+                linux: {
+                    primary: 2048  | 1024  | 512  | 39
+                }
+            },
+            metadata: {
+                description: ( localizeWithPath(
+                    'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                    'toggle.desc',
+                    'Toggle the quick chat'
+                )),
+                args: [{
+                        name: 'args',
+                        schema: {
+                            anyOf: [
+                                {
+                                    type: 'object',
+                                    required: ['query'],
+                                    properties: {
+                                        query: {
+                                            description: ( localizeWithPath(
+                                                'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                                                'toggle.query',
+                                                "The query to open the quick chat with"
+                                            )),
+                                            type: 'string'
+                                        },
+                                        isPartialQuery: {
+                                            description: ( localizeWithPath(
+                                                'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                                                'toggle.isPartialQuery',
+                                                "Whether the query is partial; it will wait for more user input"
+                                            )),
+                                            type: 'boolean'
+                                        }
+                                    },
+                                },
+                                {
+                                    type: 'string',
+                                    description: ( localizeWithPath(
+                                        'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                                        'toggle.query',
+                                        "The query to open the quick chat with"
+                                    ))
+                                }
+                            ]
+                        }
+                    }]
+            },
+        });
+    }
+    run(accessor, query) {
+        const quickChatService = accessor.get(IQuickChatService);
+        let options;
+        switch (typeof query) {
+            case 'string':
+                options = { query };
+                break;
+            case 'object':
+                options = query;
+                break;
+        }
+        if (options?.query) {
+            options.selection = ( new Selection(1, options.query.length + 1, 1, options.query.length + 1));
+        }
+        quickChatService.toggle(undefined, options);
+    }
+}
+function getQuickChatActionForProvider(id, label) {
+    return class AskQuickChatAction extends Action2 {
+        constructor() {
+            super({
+                id: `workbench.action.openQuickChat.${id}`,
+                category: CHAT_CATEGORY,
+                title: { value: ( localizeWithPath(
+                    'vs/workbench/contrib/chat/browser/actions/chatQuickInputActions',
+                    'interactiveSession.open',
+                    "Open Quick Chat ({0})",
+                    label
+                )), original: `Open Quick Chat (${label})` },
+                f1: true
+            });
+        }
+        run(accessor, query) {
+            const quickChatService = accessor.get(IQuickChatService);
+            quickChatService.toggle(id, query ? { query } : undefined);
+        }
+    };
+}
+export { ASK_QUICK_QUESTION_ACTION_ID, getQuickChatActionForProvider, registerQuickChatActions };

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

@@ -0,0 +1,168 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { toDisposable, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { EditorInput } from '../../../common/editor/editorInput.js';
+import { IChatService } from '../common/chatService.js';
+var ChatEditorInput_1;
+let ChatEditorInput = class ChatEditorInput extends EditorInput {
+    static { ChatEditorInput_1 = this; }
+    static { this.countsInUse = ( new Set()); }
+    static { this.TypeID = 'workbench.input.chatSession'; }
+    static { this.EditorID = 'workbench.editor.chatSession'; }
+    static getNewEditorUri() {
+        const handle = Math.floor(Math.random() * 1e9);
+        return ChatUri.generate(handle);
+    }
+    static getNextCount() {
+        let count = 0;
+        while (( ChatEditorInput_1.countsInUse.has(count))) {
+            count++;
+        }
+        return count;
+    }
+    constructor(resource, options, chatService) {
+        super();
+        this.resource = resource;
+        this.options = options;
+        this.chatService = chatService;
+        const parsed = ChatUri.parse(resource);
+        if (typeof parsed?.handle !== 'number') {
+            throw new Error('Invalid chat URI');
+        }
+        this.sessionId = 'sessionId' in options.target ? options.target.sessionId : undefined;
+        this.providerId = 'providerId' in options.target ? options.target.providerId : undefined;
+        this.inputCount = ChatEditorInput_1.getNextCount();
+        ChatEditorInput_1.countsInUse.add(this.inputCount);
+        this._register(toDisposable(() => ChatEditorInput_1.countsInUse.delete(this.inputCount)));
+    }
+    get editorId() {
+        return ChatEditorInput_1.EditorID;
+    }
+    get capabilities() {
+        return super.capabilities | 8 ;
+    }
+    matches(otherInput) {
+        return otherInput instanceof ChatEditorInput_1 && ( otherInput.resource.toString()) === ( this.resource.toString());
+    }
+    get typeId() {
+        return ChatEditorInput_1.TypeID;
+    }
+    getName() {
+        return this.model?.title || ( nls.localizeWithPath(
+            'vs/workbench/contrib/chat/browser/chatEditorInput',
+            'chatEditorName',
+            "Chat"
+        )) + (this.inputCount > 0 ? ` ${this.inputCount + 1}` : '');
+    }
+    getLabelExtraClasses() {
+        return ['chat-editor-label'];
+    }
+    async resolve() {
+        if (typeof this.sessionId === 'string') {
+            this.model = this.chatService.getOrRestoreSession(this.sessionId);
+        }
+        else if (typeof this.providerId === 'string') {
+            this.model = this.chatService.startSession(this.providerId, CancellationToken.None);
+        }
+        else if ('data' in this.options.target) {
+            this.model = this.chatService.loadSessionFromContent(this.options.target.data);
+        }
+        if (!this.model) {
+            return null;
+        }
+        this.sessionId = this.model.sessionId;
+        this.providerId = this.model.providerId;
+        this._register(this.model.onDidChange(() => this._onDidChangeLabel.fire()));
+        return this._register(( new ChatEditorModel(this.model)));
+    }
+    dispose() {
+        super.dispose();
+        if (this.sessionId) {
+            this.chatService.clearSession(this.sessionId);
+        }
+    }
+};
+ChatEditorInput = ChatEditorInput_1 = ( __decorate([
+    ( __param(2, IChatService))
+], ChatEditorInput));
+class ChatEditorModel extends Disposable {
+    constructor(model) {
+        super();
+        this.model = model;
+        this._onWillDispose = this._register(( new Emitter()));
+        this.onWillDispose = this._onWillDispose.event;
+        this._isDisposed = false;
+        this._isResolved = false;
+    }
+    async resolve() {
+        this._isResolved = true;
+    }
+    isResolved() {
+        return this._isResolved;
+    }
+    isDisposed() {
+        return this._isDisposed;
+    }
+    dispose() {
+        super.dispose();
+        this._isDisposed = true;
+    }
+}
+var ChatUri;
+( (function(ChatUri) {
+    ChatUri.scheme = Schemas.vscodeChatSesssion;
+    function generate(handle) {
+        return ( URI.from({ scheme: ChatUri.scheme, path: `chat-${handle}` }));
+    }
+    ChatUri.generate = generate;
+    function parse(resource) {
+        if (resource.scheme !== ChatUri.scheme) {
+            return undefined;
+        }
+        const match = resource.path.match(/chat-(\d+)/);
+        const handleStr = match?.[1];
+        if (typeof handleStr !== 'string') {
+            return undefined;
+        }
+        const handle = parseInt(handleStr);
+        if (isNaN(handle)) {
+            return undefined;
+        }
+        return { handle };
+    }
+    ChatUri.parse = parse;
+})(ChatUri || (ChatUri = {})));
+class ChatEditorInputSerializer {
+    canSerialize(input) {
+        return input instanceof ChatEditorInput;
+    }
+    serialize(input) {
+        if (!(input instanceof ChatEditorInput)) {
+            return undefined;
+        }
+        if (typeof input.sessionId !== 'string') {
+            return undefined;
+        }
+        const obj = {
+            options: input.options,
+            sessionId: input.sessionId,
+            resource: input.resource
+        };
+        return JSON.stringify(obj);
+    }
+    deserialize(instantiationService, serializedEditor) {
+        try {
+            const parsed = JSON.parse(serializedEditor);
+            const resource = URI.revive(parsed.resource);
+            return instantiationService.createInstance(ChatEditorInput, resource, { ...parsed.options, target: { sessionId: parsed.sessionId } });
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+}
+export { ChatEditorInput, ChatEditorInputSerializer, ChatEditorModel, ChatUri };

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

@@ -0,0 +1,35 @@
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { Button } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+const $ = dom.$;
+class ChatFollowups extends Disposable {
+    constructor(container, followups, options, clickHandler, contextService) {
+        super();
+        this.options = options;
+        this.clickHandler = clickHandler;
+        this.contextService = contextService;
+        const followupsContainer = dom.append(container, $('.interactive-session-followups'));
+        followups.forEach(followup => this.renderFollowup(followupsContainer, followup));
+    }
+    renderFollowup(container, followup) {
+        if (followup.kind === 'command' && followup.when && !this.contextService.contextMatchesRules(ContextKeyExpr.deserialize(followup.when))) {
+            return;
+        }
+        const tooltip = 'tooltip' in followup ? followup.tooltip : undefined;
+        const button = this._register(( new Button(container, { ...this.options, supportIcons: true, title: tooltip })));
+        if (followup.kind === 'reply') {
+            button.element.classList.add('interactive-followup-reply');
+        }
+        else if (followup.kind === 'command') {
+            button.element.classList.add('interactive-followup-command');
+        }
+        const label = followup.kind === 'reply' ?
+            '$(sparkle) ' + (followup.title || followup.message) :
+            followup.title;
+        button.label = ( new MarkdownString(label, { supportThemeIcons: true }));
+        this._register(button.onDidClick(() => this.clickHandler(followup)));
+    }
+}
+export { ChatFollowups };