@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,295 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { h } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable, markAsSingleton } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isITextModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ActionWidgetDropdownActionViewItem } from '../../../../../platform/actions/browser/actionWidgetDropdownActionViewItem.js';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { Action2, MenuId, MenuItemAction } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatAgents.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { chatEditingWidgetFileStateContextKey, ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService';
+import { ChatRequestParser } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatRequestParser';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { PROMPT_LANGUAGE_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { AgentSessionProviders, getAgentSessionProviderName, getAgentSessionProviderIcon } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ctxHasEditorModification } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys';
+import { CHAT_SETUP_ACTION_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { toPromptFileVariableEntry, PromptFileVariableKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatVariableEntries';
+import { NEW_CHAT_SESSION_ACTION_ID } from '../chatSessions/common.js';
+
+var ChatContinueInSessionActionItem_1;
+var ActionLocation;
+(function (ActionLocation) {
+    ActionLocation["ChatWidget"] = "chatWidget";
+    ActionLocation["Editor"] = "editor";
+})(ActionLocation || (ActionLocation = {}));
+class ContinueChatInSessionAction extends Action2 {
+    static { this.ID = 'workbench.action.chat.continueChatInSession'; }
+    constructor() {
+        super({
+            id: ContinueChatInSessionAction.ID,
+            title: ( localize2(4698, "Continue Chat in...")),
+            tooltip: ( localize(4698, "Continue Chat in...")),
+            precondition: ( ContextKeyExpr.and(ChatContextKeys.enabled, ( ChatContextKeys.requestInProgress.negate()), ( ChatContextKeys.remoteJobCreating.negate()))),
+            menu: [{
+                    id: MenuId.ChatExecute,
+                    group: 'navigation',
+                    order: 3.4,
+                    when: ( ChatContextKeys.lockedToCodingAgent.negate()),
+                },
+                {
+                    id: MenuId.EditorContent,
+                    group: 'continueIn',
+                    when: ( ContextKeyExpr.and(( ContextKeyExpr.equals(ResourceContextKey.Scheme.key, Schemas.untitled)), ( ContextKeyExpr.equals(ResourceContextKey.LangId.key, PROMPT_LANGUAGE_ID)), ( ContextKeyExpr.notEquals(chatEditingWidgetFileStateContextKey.key, ModifiedFileEntryState.Modified)), ( ctxHasEditorModification.negate()))),
+                }
+            ]
+        });
+    }
+    async run() {
+    }
+}
+let ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = class ChatContinueInSessionActionItem extends ActionWidgetDropdownActionViewItem {
+    constructor(action, location, actionWidgetService, contextKeyService, keybindingService, chatSessionsService, instantiationService, openerService) {
+        super(action, {
+            actionProvider: ChatContinueInSessionActionItem_1.actionProvider(chatSessionsService, instantiationService, location),
+            actionBarActions: ChatContinueInSessionActionItem_1.getActionBarActions(openerService)
+        }, actionWidgetService, keybindingService, contextKeyService);
+        this.location = location;
+        this.contextKeyService = contextKeyService;
+    }
+    static getActionBarActions(openerService) {
+        const learnMoreUrl = 'https://aka.ms/vscode-continue-chat-in';
+        return [{
+                id: 'workbench.action.chat.continueChatInSession.learnMore',
+                label: ( localize(4699, "Learn More")),
+                tooltip: ( localize(4699, "Learn More")),
+                class: undefined,
+                enabled: true,
+                run: async () => {
+                    await openerService.open(( URI.parse(learnMoreUrl)));
+                }
+            }];
+    }
+    static actionProvider(chatSessionsService, instantiationService, location) {
+        return {
+            getActions: () => {
+                const actions = [];
+                const contributions = chatSessionsService.getAllChatSessionContributions();
+                const backgroundContrib = contributions.find(contrib => contrib.type === AgentSessionProviders.Background);
+                if (backgroundContrib && backgroundContrib.canDelegate !== false) {
+                    actions.push(this.toAction(AgentSessionProviders.Background, backgroundContrib, instantiationService, location));
+                }
+                const cloudContrib = contributions.find(contrib => contrib.type === AgentSessionProviders.Cloud);
+                if (cloudContrib && cloudContrib.canDelegate !== false) {
+                    actions.push(this.toAction(AgentSessionProviders.Cloud, cloudContrib, instantiationService, location));
+                }
+                if (actions.length === 0) {
+                    actions.push(this.toSetupAction(AgentSessionProviders.Background, instantiationService));
+                    actions.push(this.toSetupAction(AgentSessionProviders.Cloud, instantiationService));
+                }
+                return actions;
+            }
+        };
+    }
+    static toAction(provider, contrib, instantiationService, location) {
+        return {
+            id: contrib.type,
+            enabled: true,
+            icon: getAgentSessionProviderIcon(provider),
+            class: undefined,
+            description: `@${contrib.name}`,
+            label: getAgentSessionProviderName(provider),
+            tooltip: ( localize(4700, "Continue in {0}", getAgentSessionProviderName(provider))),
+            category: { label: ( localize(4701, "Continue In")), order: 0, showHeader: true },
+            run: () => instantiationService.invokeFunction(accessor => {
+                if (location === ActionLocation.Editor) {
+                    return ( new CreateRemoteAgentJobFromEditorAction()).run(accessor, contrib);
+                }
+                return ( new CreateRemoteAgentJobAction()).run(accessor, contrib);
+            })
+        };
+    }
+    static toSetupAction(provider, instantiationService) {
+        return {
+            id: provider,
+            enabled: true,
+            icon: getAgentSessionProviderIcon(provider),
+            class: undefined,
+            label: getAgentSessionProviderName(provider),
+            tooltip: ( localize(4700, "Continue in {0}", getAgentSessionProviderName(provider))),
+            category: { label: ( localize(4701, "Continue In")), order: 0, showHeader: true },
+            run: () => instantiationService.invokeFunction(accessor => {
+                const commandService = accessor.get(ICommandService);
+                return commandService.executeCommand(CHAT_SETUP_ACTION_ID);
+            })
+        };
+    }
+    renderLabel(element) {
+        if (this.location === ActionLocation.Editor) {
+            const view = h('span.action-widget-delegate-label', [
+                h('span', { className: ThemeIcon.asClassName(Codicon.forward) }),
+                h('span', [( localize(4702, "Continue in..."))])
+            ]);
+            element.appendChild(view.root);
+            return null;
+        }
+        else {
+            const icon = this.contextKeyService.contextMatchesRules(ChatContextKeys.remoteJobCreating) ? Codicon.sync : Codicon.forward;
+            element.classList.add(...ThemeIcon.asClassNameArray(icon));
+            return super.renderLabel(element);
+        }
+    }
+};
+ChatContinueInSessionActionItem = ChatContinueInSessionActionItem_1 = ( __decorate([
+    ( __param(2, IActionWidgetService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IKeybindingService)),
+    ( __param(5, IChatSessionsService)),
+    ( __param(6, IInstantiationService)),
+    ( __param(7, IOpenerService))
+], ChatContinueInSessionActionItem));
+class CreateRemoteAgentJobAction {
+    constructor() { }
+    openUntitledEditor(commandService, continuationTarget) {
+        commandService.executeCommand(`${NEW_CHAT_SESSION_ACTION_ID}.${continuationTarget.type}`);
+    }
+    async run(accessor, continuationTarget) {
+        const contextKeyService = accessor.get(IContextKeyService);
+        const commandService = accessor.get(ICommandService);
+        const widgetService = accessor.get(IChatWidgetService);
+        const chatAgentService = accessor.get(IChatAgentService);
+        const chatService = accessor.get(IChatService);
+        const editorService = accessor.get(IEditorService);
+        const remoteJobCreatingKey = ChatContextKeys.remoteJobCreating.bindTo(contextKeyService);
+        try {
+            remoteJobCreatingKey.set(true);
+            const widget = widgetService.lastFocusedWidget;
+            if (!widget || !widget.viewModel) {
+                return this.openUntitledEditor(commandService, continuationTarget);
+            }
+            const chatModel = widget.viewModel.model;
+            if (!chatModel) {
+                return;
+            }
+            const sessionResource = widget.viewModel.sessionResource;
+            const chatRequests = chatModel.getRequests();
+            let userPrompt = widget.getInput();
+            if (!userPrompt) {
+                if (!chatRequests.length) {
+                    return this.openUntitledEditor(commandService, continuationTarget);
+                }
+                userPrompt = 'implement this.';
+            }
+            const attachedContext = widget.input.getAttachedAndImplicitContext(sessionResource);
+            widget.input.acceptInput(true);
+            if (widget.location === ChatAgentLocation.EditorInline) {
+                const activeEditor = editorService.activeTextEditorControl;
+                if (activeEditor) {
+                    const model = activeEditor.getModel();
+                    let activeEditorUri = undefined;
+                    if (model && isITextModel(model)) {
+                        activeEditorUri = model.uri;
+                    }
+                    const selection = activeEditor.getSelection();
+                    if (activeEditorUri && selection) {
+                        attachedContext.add({
+                            kind: 'file',
+                            id: 'vscode.implicit.selection',
+                            name: basename(activeEditorUri),
+                            value: {
+                                uri: activeEditorUri,
+                                range: selection
+                            },
+                        });
+                    }
+                }
+            }
+            const defaultAgent = chatAgentService.getDefaultAgent(ChatAgentLocation.Chat);
+            const instantiationService = accessor.get(IInstantiationService);
+            const requestParser = instantiationService.createInstance(ChatRequestParser);
+            const continuationTargetType = continuationTarget.type;
+            const parsedRequest = requestParser.parseChatRequest(sessionResource, userPrompt, ChatAgentLocation.Chat);
+            const addedRequest = chatModel.addRequest(parsedRequest, { variables: attachedContext.asArray() }, 0, undefined, defaultAgent);
+            await chatService.removeRequest(sessionResource, addedRequest.id);
+            const requestData = await chatService.sendRequest(sessionResource, userPrompt, {
+                agentIdSilent: continuationTargetType,
+                attachedContext: attachedContext.asArray(),
+                userSelectedModelId: widget.input.currentLanguageModel,
+                ...widget.getModeRequestOptions()
+            });
+            if (requestData) {
+                await widget.handleDelegationExitIfNeeded(defaultAgent, requestData.agent);
+            }
+        }
+        catch (e) {
+            console.error('Error creating remote coding agent job', e);
+            throw e;
+        }
+        finally {
+            remoteJobCreatingKey.set(false);
+        }
+    }
+}
+class CreateRemoteAgentJobFromEditorAction {
+    constructor() { }
+    async run(accessor, continuationTarget) {
+        try {
+            const editorService = accessor.get(IEditorService);
+            const activeEditor = editorService.activeTextEditorControl;
+            const commandService = accessor.get(ICommandService);
+            if (!activeEditor) {
+                return;
+            }
+            const model = activeEditor.getModel();
+            if (!model || !isITextModel(model)) {
+                return;
+            }
+            const uri = model.uri;
+            const attachedContext = [toPromptFileVariableEntry(uri, PromptFileVariableKind.PromptFile, undefined, false, [])];
+            const prompt = `Follow instructions in [${basename(uri)}](${( uri.toString())}).`;
+            await commandService.executeCommand(`${NEW_CHAT_SESSION_ACTION_ID}.${continuationTarget.type}`, { prompt, attachedContext });
+        }
+        catch (e) {
+            console.error('Error creating remote agent job from editor', e);
+            throw e;
+        }
+    }
+}
+let ContinueChatInSessionActionRendering = class ContinueChatInSessionActionRendering extends Disposable {
+    static { this.ID = 'chat.continueChatInSessionActionRendering'; }
+    constructor(actionViewItemService, instantiationService) {
+        super();
+        const disposable = actionViewItemService.register(MenuId.EditorContent, ContinueChatInSessionAction.ID, (action, options, instantiationService2) => {
+            if (!(action instanceof MenuItemAction)) {
+                return undefined;
+            }
+            return instantiationService.createInstance(ChatContinueInSessionActionItem, action, ActionLocation.Editor);
+        });
+        markAsSingleton(disposable);
+    }
+};
+ContinueChatInSessionActionRendering = ( __decorate([
+    ( __param(0, IActionViewItemService)),
+    ( __param(1, IInstantiationService))
+], ContinueChatInSessionActionRendering));
+
+export { ActionLocation, ChatContinueInSessionActionItem, ContinueChatInSessionAction, ContinueChatInSessionActionRendering };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatElicitationActions.d.ts

@@ -0,0 +1,2 @@
+export declare const AcceptElicitationRequestActionId = "workbench.action.chat.acceptElicitation";
+export declare function registerChatElicitationActions(): void;

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

@@ -0,0 +1,60 @@
+
+import { KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Action2, registerAction2 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { KeybindingWeight } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatContextKeys';
+import { ElicitationState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService';
+import { isResponseVM } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatViewModel';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { CHAT_CATEGORY } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+
+const AcceptElicitationRequestActionId = 'workbench.action.chat.acceptElicitation';
+class AcceptElicitationRequestAction extends Action2 {
+    constructor() {
+        super({
+            id: AcceptElicitationRequestActionId,
+            title: ( localize2(4708, "Accept Request")),
+            f1: false,
+            category: CHAT_CATEGORY,
+            keybinding: {
+                when: ( ContextKeyExpr.and(
+                    ChatContextKeys.inChatSession,
+                    ChatContextKeys.Editing.hasElicitationRequest
+                )),
+                primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                weight: KeybindingWeight.WorkbenchContrib + 1,
+            },
+        });
+    }
+    async run(accessor) {
+        const chatWidgetService = accessor.get(IChatWidgetService);
+        const widget = chatWidgetService.lastFocusedWidget;
+        if (!widget) {
+            return;
+        }
+        const items = widget.viewModel?.getItems();
+        if (!items?.length) {
+            return;
+        }
+        for (let i = items.length - 1; i >= 0; i--) {
+            const item = items[i];
+            if (!isResponseVM(item)) {
+                continue;
+            }
+            for (const content of item.response.value) {
+                if (content.kind === 'elicitation2' && content.state.get() === ElicitationState.Pending) {
+                    await content.accept(true);
+                    widget.focusInput();
+                    return;
+                }
+            }
+        }
+    }
+}
+function registerChatElicitationActions() {
+    registerAction2(AcceptElicitationRequestAction);
+}
+
+export { AcceptElicitationRequestActionId, registerChatElicitationActions };

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatExecuteActions.d.ts

@@ -0,0 +1,65 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions";
+import { Action2 } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+export interface IVoiceChatExecuteActionContext {
+    readonly disableTimeout?: boolean;
+}
+export interface IChatExecuteActionContext {
+    widget?: IChatWidget;
+    inputValue?: string;
+    voice?: IVoiceChatExecuteActionContext;
+}
+declare abstract class SubmitAction extends Action2 {
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
+export declare class ChatSubmitAction extends SubmitAction {
+    static readonly ID = "workbench.action.chat.submit";
+    constructor();
+}
+export declare class ChatDelegateToEditSessionAction extends Action2 {
+    static readonly ID = "workbench.action.chat.delegateToEditSession";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
+export declare const ToggleAgentModeActionId = "workbench.action.chat.toggleAgentMode";
+export interface IToggleChatModeArgs {
+    modeId: ChatModeKind | string;
+    sessionResource: URI | undefined;
+}
+export declare const ChatOpenModelPickerActionId = "workbench.action.chat.openModelPicker";
+export declare class OpenModePickerAction extends Action2 {
+    static readonly ID = "workbench.action.chat.openModePicker";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
+export declare class ChatSessionPrimaryPickerAction extends Action2 {
+    static readonly ID = "workbench.action.chat.chatSessionPrimaryPicker";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): Promise<void>;
+}
+export declare const ChangeChatModelActionId = "workbench.action.chat.changeModel";
+export declare class ChatEditingSessionSubmitAction extends SubmitAction {
+    static readonly ID = "workbench.action.edits.submit";
+    constructor();
+}
+export declare class ChatSubmitWithCodebaseAction extends Action2 {
+    static readonly ID = "workbench.action.chat.submitWithCodebase";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): void;
+}
+export declare const CancelChatActionId = "workbench.action.chat.cancel";
+export declare class CancelAction extends Action2 {
+    static readonly ID = "workbench.action.chat.cancel";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): void;
+}
+export declare const CancelChatEditId = "workbench.edit.chat.cancel";
+export declare class CancelEdit extends Action2 {
+    static readonly ID = "workbench.edit.chat.cancel";
+    constructor();
+    run(accessor: ServicesAccessor, ...args: unknown[]): void;
+}
+export declare function registerChatExecuteActions(): void;
+export {};