@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

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

@@ -0,0 +1,17 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
+import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IAgentSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+export declare class ChatSlashCommandsContribution extends Disposable {
+    private readonly environmentService;
+    static readonly ID = "workbench.contrib.chatSlashCommands";
+    constructor(slashCommandService: IChatSlashCommandService, commandService: ICommandService, chatAgentService: IChatAgentService, instantiationService: IInstantiationService, agentSessionsService: IAgentSessionsService, chatService: IChatService, configurationService: IConfigurationService, dialogService: IDialogService, notificationService: INotificationService, storageService: IStorageService, environmentService: IWorkbenchEnvironmentService);
+}

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

@@ -0,0 +1,394 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { MarkdownString, isMarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IChatAgentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service';
+import { IChatSlashCommandService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { ChatAgentLocation, ChatConfiguration, ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
+import { OpenModelPickerAction, OpenModePickerAction, ChatSubmitAction } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/actions/chatExecuteActions';
+import { ManagePluginsAction } from './actions/chatPluginActions.js';
+import { ConfigureToolsAction } from './actions/chatToolActions.js';
+import { IAgentSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsService.service';
+import { CONFIGURE_INSTRUCTIONS_ACTION_ID } from '@codingame/monaco-vscode-xterm-addons-common/vscode/vs/workbench/contrib/chat/browser/promptSyntax/attachInstructionsAction';
+import { showConfigureHooksQuickPick } from './promptSyntax/hookActions.js';
+import { CONFIGURE_PROMPTS_ACTION_ID } from './promptSyntax/runPromptAction.js';
+import { CONFIGURE_SKILLS_ACTION_ID } from './promptSyntax/skillActions.js';
+import { AutoApproveStorageKeys, globalAutoApproveDescription } from './tools/languageModelToolsService.js';
+import { agentToMarkdown, agentSlashCommandToMarkdown } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/chatContentParts/chatMarkdownDecorationsRenderer';
+import { Target } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severity';
+
+let ChatSlashCommandsContribution = class ChatSlashCommandsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chatSlashCommands";
+    }
+    constructor(
+        slashCommandService,
+        commandService,
+        chatAgentService,
+        instantiationService,
+        agentSessionsService,
+        chatService,
+        configurationService,
+        dialogService,
+        notificationService,
+        storageService,
+        environmentService
+    ) {
+        super();
+        this.environmentService = environmentService;
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "clear",
+            detail: ( localize(6121, "Start a new chat and archive the current one")),
+            sortText: "z2_clear",
+            executeImmediately: true,
+            locations: [ChatAgentLocation.Chat]
+        }, async (_prompt, _progress, _history, _location, sessionResource) => {
+            agentSessionsService.getSession(sessionResource)?.setArchived(true);
+            commandService.executeCommand(ACTION_ID_NEW_CHAT);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "hooks",
+            detail: ( localize(6122, "Configure hooks")),
+            sortText: "z3_hooks",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await instantiationService.invokeFunction(showConfigureHooksQuickPick);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "models",
+            detail: ( localize(6123, "Open the model picker")),
+            sortText: "z3_models",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(OpenModelPickerAction.ID);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "tools",
+            detail: ( localize(6124, "Configure tools")),
+            sortText: "z3_tools",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(ConfigureToolsAction.ID);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "plugins",
+            detail: ( localize(6125, "Manage plugins")),
+            sortText: "z3_plugins",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(ManagePluginsAction.ID);
+        }));
+        if (!this.environmentService.isSessionsWindow) {
+            this._store.add(slashCommandService.registerSlashCommand({
+                command: "debug",
+                detail: ( localize(6126, "Show Chat Debug View")),
+                sortText: "z3_debug",
+                executeImmediately: true,
+                silent: true,
+                locations: [ChatAgentLocation.Chat]
+            }, async () => {
+                await commandService.executeCommand("github.copilot.debug.showChatLogView");
+            }));
+        }
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "agents",
+            detail: ( localize(6127, "Configure custom agents")),
+            sortText: "z3_agents",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(OpenModePickerAction.ID);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "skills",
+            detail: ( localize(6128, "Configure skills")),
+            sortText: "z3_skills",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(CONFIGURE_SKILLS_ACTION_ID);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "instructions",
+            detail: ( localize(6129, "Configure instructions")),
+            sortText: "z3_instructions",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(CONFIGURE_INSTRUCTIONS_ACTION_ID);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "prompts",
+            detail: ( localize(6130, "Configure prompt files")),
+            sortText: "z3_prompts",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async () => {
+            await commandService.executeCommand(CONFIGURE_PROMPTS_ACTION_ID);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "fork",
+            detail: ( localize(6131, "Fork conversation into a new chat session")),
+            sortText: "z2_fork",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async (_prompt, _progress, _history, _location, sessionResource) => {
+            await commandService.executeCommand("workbench.action.chat.forkConversation", sessionResource);
+        }));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "rename",
+            detail: ( localize(6132, "Rename this chat")),
+            sortText: "z2_rename",
+            executeImmediately: false,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, async (prompt, _progress, _history, _location, sessionResource) => {
+            const title = prompt.trim();
+            if (title) {
+                chatService.setChatSessionTitle(sessionResource, title);
+            }
+        }));
+        const handleEnableAutoApprove = async () => {
+            const inspection = configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+            if (inspection.policyValue !== undefined) {
+                if (inspection.policyValue === true) {
+                    notificationService.info(( localize(6133, "Global auto-approve is already enabled.")));
+                    return;
+                }
+                notificationService.warn(( localize(
+                    6134,
+                    "Global auto-approve is managed by your organization policy. Contact your administrator to change this setting."
+                )));
+                return;
+            }
+            if (configurationService.getValue(ChatConfiguration.GlobalAutoApprove)) {
+                notificationService.info(( localize(6133, "Global auto-approve is already enabled.")));
+                return;
+            }
+            const alreadyOptedIn = storageService.getBoolean(
+                AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                StorageScope.APPLICATION,
+                false
+            );
+            if (!alreadyOptedIn) {
+                const store = ( new DisposableStore());
+                try {
+                    const cts = ( new CancellationTokenSource());
+                    store.add(cts);
+                    store.add(storageService.onDidChangeValue(
+                        StorageScope.APPLICATION,
+                        AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                        store
+                    )(() => {
+                        if (storageService.getBoolean(
+                            AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                            StorageScope.APPLICATION,
+                            false
+                        )) {
+                            cts.cancel();
+                        }
+                    }));
+                    const result = await dialogService.prompt({
+                        type: Severity.Warning,
+                        message: ( localize(6135, "Enable global auto approve?")),
+                        buttons: [{
+                            label: ( localize(6136, "Enable")),
+                            run: () => true
+                        }, {
+                            label: ( localize(6137, "Cancel")),
+                            run: () => false
+                        }],
+                        custom: {
+                            markdownDetails: [{
+                                markdown: ( new MarkdownString(globalAutoApproveDescription.value, {
+                                    isTrusted: {
+                                        enabledCommands: ["workbench.action.openSettings"]
+                                    }
+                                }))
+                            }]
+                        },
+                        token: cts.token
+                    });
+                    if (!cts.token.isCancellationRequested && result.result !== true) {
+                        return;
+                    }
+                    storageService.store(
+                        AutoApproveStorageKeys.GlobalAutoApproveOptIn,
+                        true,
+                        StorageScope.APPLICATION,
+                        StorageTarget.USER
+                    );
+                } finally {
+                    store.dispose();
+                }
+            }
+            await configurationService.updateValue(ChatConfiguration.GlobalAutoApprove, true);
+            notificationService.info(( localize(
+                6138,
+                "Global auto-approve enabled — all tool calls will be approved automatically"
+            )));
+        };
+        const handleDisableAutoApprove = async () => {
+            const inspection = configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+            if (inspection.policyValue !== undefined) {
+                if (inspection.policyValue === false) {
+                    notificationService.info(( localize(6139, "Global auto-approve is already disabled.")));
+                    return;
+                }
+                notificationService.warn(( localize(
+                    6134,
+                    "Global auto-approve is managed by your organization policy. Contact your administrator to change this setting."
+                )));
+                return;
+            }
+            if (!configurationService.getValue(ChatConfiguration.GlobalAutoApprove)) {
+                notificationService.info(( localize(6139, "Global auto-approve is already disabled.")));
+                return;
+            }
+            await configurationService.updateValue(ChatConfiguration.GlobalAutoApprove, false);
+            notificationService.info(( localize(6140, "Global auto-approve disabled — tools will require approval")));
+        };
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "autoApprove",
+            detail: ( localize(6141, "Enable global auto-approval of all tool calls")),
+            sortText: "z1_autoApprove",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, handleEnableAutoApprove));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "disableAutoApprove",
+            detail: ( localize(6142, "Disable global auto-approval of all tool calls")),
+            sortText: "z1_disableAutoApprove",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, handleDisableAutoApprove));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "yolo",
+            detail: ( localize(6143, "Enable global auto-approval of all tool calls")),
+            sortText: "z1_yolo",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, handleEnableAutoApprove));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "disableYolo",
+            detail: ( localize(6144, "Disable global auto-approval of all tool calls")),
+            sortText: "z1_disableYolo",
+            executeImmediately: true,
+            silent: true,
+            locations: [ChatAgentLocation.Chat],
+            target: Target.VSCode
+        }, handleDisableAutoApprove));
+        this._store.add(slashCommandService.registerSlashCommand({
+            command: "help",
+            detail: "",
+            sortText: "z1_help",
+            executeImmediately: true,
+            locations: [ChatAgentLocation.Chat],
+            modes: [ChatModeKind.Ask],
+            target: Target.VSCode
+        }, async (prompt, progress, _history, _location, sessionResource) => {
+            const defaultAgent = chatAgentService.getDefaultAgent(ChatAgentLocation.Chat);
+            const agents = chatAgentService.getAgents();
+            if (defaultAgent?.metadata.helpTextPrefix) {
+                if (isMarkdownString(defaultAgent.metadata.helpTextPrefix)) {
+                    progress.report({
+                        content: defaultAgent.metadata.helpTextPrefix,
+                        kind: "markdownContent"
+                    });
+                } else {
+                    progress.report({
+                        content: ( new MarkdownString(defaultAgent.metadata.helpTextPrefix)),
+                        kind: "markdownContent"
+                    });
+                }
+                progress.report({
+                    content: ( new MarkdownString("\n\n")),
+                    kind: "markdownContent"
+                });
+            }
+            const agentText = (await Promise.all(( agents.filter(a => !a.isDefault && !a.isCore).filter(a => a.locations.includes(ChatAgentLocation.Chat)).map(async a => {
+                const description = a.description ? `- ${a.description}` : "";
+                const agentMarkdown = instantiationService.invokeFunction(accessor => agentToMarkdown(a, sessionResource, true, accessor));
+                const agentLine = `- ${agentMarkdown} ${description}`;
+                const commandText = ( a.slashCommands.map(c => {
+                    const description = c.description ? `- ${c.description}` : "";
+                    return `\t* ${agentSlashCommandToMarkdown(a, c, sessionResource)} ${description}`;
+                })).join("\n");
+                return (agentLine + "\n" + commandText).trim();
+            })))).join("\n");
+            progress.report({
+                content: ( new MarkdownString(agentText, {
+                    isTrusted: {
+                        enabledCommands: [ChatSubmitAction.ID]
+                    }
+                })),
+                kind: "markdownContent"
+            });
+            if (defaultAgent?.metadata.helpTextPostfix) {
+                progress.report({
+                    content: ( new MarkdownString("\n\n")),
+                    kind: "markdownContent"
+                });
+                if (isMarkdownString(defaultAgent.metadata.helpTextPostfix)) {
+                    progress.report({
+                        content: defaultAgent.metadata.helpTextPostfix,
+                        kind: "markdownContent"
+                    });
+                } else {
+                    progress.report({
+                        content: ( new MarkdownString(defaultAgent.metadata.helpTextPostfix)),
+                        kind: "markdownContent"
+                    });
+                }
+            }
+            await timeout(200);
+        }));
+    }
+};
+ChatSlashCommandsContribution = ( __decorate([( __param(0, IChatSlashCommandService)), ( __param(1, ICommandService)), ( __param(2, IChatAgentService)), ( __param(3, IInstantiationService)), ( __param(4, IAgentSessionsService)), ( __param(5, IChatService)), ( __param(6, IConfigurationService)), ( __param(7, IDialogService)), ( __param(8, INotificationService)), ( __param(9, IStorageService)), ( __param(10, IWorkbenchEnvironmentService))], ChatSlashCommandsContribution));
+
+export { ChatSlashCommandsContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/chatStatus/chatStatusDashboard.d.ts

@@ -53,4 +53,5 @@ export declare class ChatStatusDashboard extends DomWidget {
     private createNextEditSuggestionsSetting;
     private createCompletionsSnooze;
     private showModelPicker;
+    private showProviderOptionPicker;
 }