chatSlashCommands.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import { timeout } from '../../../../base/common/async.js';
import { MarkdownString, isMarkdownString } from '../../../../base/common/htmlContent.js';
import { Disposable, DisposableMap, DisposableStore } from '../../../../base/common/lifecycle.js';
import { URI } from '../../../../base/common/uri.js';
import * as nls from '../../../../nls.js';
import { ICommandService } from '../../../../platform/commands/common/commands.js';
import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
import { ILogService } from '../../../../platform/log/common/log.js';
import { IChatAgentService } from '../common/participants/chatAgents.js';
import { ChatContextKeys } from '../common/actions/chatContextKeys.js';
import { IChatSlashCommandService } from '../common/participants/chatSlashCommands.js';
import { IChatService } from '../common/chatService/chatService.js';
import { IChatSessionsService, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem, SessionType } from '../common/chatSessionsService.js';
import { ChatAgentLocation, ChatConfiguration, ChatModeKind, ChatPermissionLevel } from '../common/constants.js';
import { ACTION_ID_NEW_CHAT } from './actions/chatActions.js';
import { ChatSubmitAction, OpenModePickerAction, OpenModelPickerAction } from './actions/chatExecuteActions.js';
import { ManagePluginsAction } from './actions/chatPluginActions.js';
import { ConfigureToolsAction } from './actions/chatToolActions.js';
import { IAgentSessionsService } from './agentSessions/agentSessionsService.js';
import { CONFIGURE_INSTRUCTIONS_ACTION_ID } from './promptSyntax/attachInstructionsAction.js';
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 { IChatWidgetService } from './chat.js';
import { agentSlashCommandToMarkdown, agentToMarkdown } from './widget/chatContentParts/chatMarkdownDecorationsRenderer.js';
import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
import { ContextKeyExpr } from '../../../../platform/contextkey/common/contextkey.js';

export class ChatSlashCommandsContribution extends Disposable {

	static readonly ID = 'workbench.contrib.chatSlashCommands';

	constructor(
		@IChatSlashCommandService slashCommandService: IChatSlashCommandService,
		@ICommandService commandService: ICommandService,
		@IChatAgentService chatAgentService: IChatAgentService,
		@IInstantiationService instantiationService: IInstantiationService,
		@IAgentSessionsService agentSessionsService: IAgentSessionsService,
		@IChatService chatService: IChatService,
		@IConfigurationService configurationService: IConfigurationService,
		@IChatWidgetService chatWidgetService: IChatWidgetService,
		@IWorkbenchEnvironmentService private readonly environmentService: IWorkbenchEnvironmentService,
	) {
		super();

		this._store.add(slashCommandService.registerSlashCommand({
			command: 'clear',
			detail: nls.localize('clear', "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: nls.localize('hooks', "Configure hooks"),
			sortText: 'z3_hooks',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await instantiationService.invokeFunction(showConfigureHooksQuickPick);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'models',
			detail: nls.localize('models', "Open the model picker"),
			sortText: 'z3_models',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
		}, async () => {
			await commandService.executeCommand(OpenModelPickerAction.ID);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'tools',
			detail: nls.localize('tools', "Configure tools"),
			sortText: 'z3_tools',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await commandService.executeCommand(ConfigureToolsAction.ID);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'plugins',
			detail: nls.localize('plugins', "Manage plugins"),
			sortText: 'z3_plugins',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await commandService.executeCommand(ManagePluginsAction.ID);
		}));
		if (!this.environmentService.isSessionsWindow) {
			this._store.add(slashCommandService.registerSlashCommand({
				command: 'debug',
				detail: nls.localize('debug', "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: nls.localize('agents', "Configure custom agents"),
			sortText: 'z3_agents',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await commandService.executeCommand(OpenModePickerAction.ID);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'skills',
			detail: nls.localize('skills', "Configure skills"),
			sortText: 'z3_skills',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await commandService.executeCommand(CONFIGURE_SKILLS_ACTION_ID);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'instructions',
			detail: nls.localize('instructions', "Configure instructions"),
			sortText: 'z3_instructions',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await commandService.executeCommand(CONFIGURE_INSTRUCTIONS_ACTION_ID);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'prompts',
			detail: nls.localize('prompts', "Configure prompt files"),
			sortText: 'z3_prompts',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async () => {
			await commandService.executeCommand(CONFIGURE_PROMPTS_ACTION_ID);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'fork',
			detail: nls.localize('fork', "Fork conversation into a new chat session"),
			sortText: 'z2_fork',
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			when: ContextKeyExpr.or(
				ChatContextKeys.lockedToCodingAgent.negate(),
				ChatContextKeys.chatSessionSupportsFork
			),
		}, async (_prompt, _progress, _history, _location, sessionResource) => {
			await commandService.executeCommand('workbench.action.chat.forkConversation', sessionResource);
		}));
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'rename',
			detail: nls.localize('rename', "Rename this chat"),
			sortText: 'z2_rename',
			executeImmediately: false,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [SessionType.Local],
		}, async (prompt, _progress, _history, _location, sessionResource) => {
			const title = prompt.trim();
			if (title) {
				chatService.setChatSessionTitle(sessionResource, title);
			}
		}));
		const setPermissionLevelForSession = (sessionResource: URI, level: ChatPermissionLevel) => {
			const widget = chatWidgetService.getWidgetBySessionResource(sessionResource) ?? chatWidgetService.lastFocusedWidget;
			if (widget) {
				widget.input.setPermissionLevel(level);
			}
		};
		const autoApprovePolicyValue = configurationService.inspect<boolean>(ChatConfiguration.GlobalAutoApprove).policyValue;
		if (autoApprovePolicyValue !== false) {
			this._store.add(slashCommandService.registerSlashCommand({
				command: 'autoApprove',
				detail: nls.localize('autoApprove', "Set permissions to bypass approvals"),
				sortText: 'z1_autoApprove',
				executeImmediately: true,
				silent: true,
				locations: [ChatAgentLocation.Chat],
				sessionTypes: [SessionType.Local, SessionType.CopilotCLI],
			}, async (_prompt, _progress, _history, _location, sessionResource) => {
				setPermissionLevelForSession(sessionResource, ChatPermissionLevel.AutoApprove);
			}));
			this._store.add(slashCommandService.registerSlashCommand({
				command: 'disableAutoApprove',
				detail: nls.localize('disableAutoApprove', "Set permissions back to default"),
				sortText: 'z1_disableAutoApprove',
				executeImmediately: true,
				silent: true,
				locations: [ChatAgentLocation.Chat],
				sessionTypes: [SessionType.Local, SessionType.CopilotCLI],
			}, async (_prompt, _progress, _history, _location, sessionResource) => {
				setPermissionLevelForSession(sessionResource, ChatPermissionLevel.Default);
			}));
			this._store.add(slashCommandService.registerSlashCommand({
				command: 'yolo',
				detail: nls.localize('yolo', "Set permissions to bypass approvals"),
				sortText: 'z1_yolo',
				executeImmediately: true,
				silent: true,
				locations: [ChatAgentLocation.Chat],
				sessionTypes: [SessionType.Local, SessionType.CopilotCLI],
			}, async (_prompt, _progress, _history, _location, sessionResource) => {
				setPermissionLevelForSession(sessionResource, ChatPermissionLevel.AutoApprove);
			}));
			this._store.add(slashCommandService.registerSlashCommand({
				command: 'disableYolo',
				detail: nls.localize('disableYolo', "Set permissions back to default"),
				sortText: 'z1_disableYolo',
				executeImmediately: true,
				silent: true,
				locations: [ChatAgentLocation.Chat],
				sessionTypes: [SessionType.Local, SessionType.CopilotCLI],
			}, async (_prompt, _progress, _history, _location, sessionResource) => {
				setPermissionLevelForSession(sessionResource, ChatPermissionLevel.Default);
			}));
			if (configurationService.getValue<boolean>(ChatConfiguration.AutopilotEnabled) !== false) {
				this._store.add(slashCommandService.registerSlashCommand({
					command: 'autopilot',
					detail: nls.localize('autopilot', "Set permissions to autopilot mode"),
					sortText: 'z1_autopilot',
					executeImmediately: true,
					silent: true,
					locations: [ChatAgentLocation.Chat],
					sessionTypes: [SessionType.Local, SessionType.CopilotCLI],
				}, async (_prompt, _progress, _history, _location, sessionResource) => {
					setPermissionLevelForSession(sessionResource, ChatPermissionLevel.Autopilot);
				}));
				this._store.add(slashCommandService.registerSlashCommand({
					command: 'exitAutopilot',
					detail: nls.localize('exitAutopilot', "Set permissions back to default"),
					sortText: 'z1_exitAutopilot',
					executeImmediately: true,
					silent: true,
					locations: [ChatAgentLocation.Chat],
					sessionTypes: [SessionType.Local, SessionType.CopilotCLI],
				}, async (_prompt, _progress, _history, _location, sessionResource) => {
					setPermissionLevelForSession(sessionResource, ChatPermissionLevel.Default);
				}));
			}
		}
		this._store.add(slashCommandService.registerSlashCommand({
			command: 'help',
			detail: '',
			sortText: 'z1_help',
			executeImmediately: true,
			locations: [ChatAgentLocation.Chat],
			modes: [ChatModeKind.Ask],
			sessionTypes: [SessionType.Local],
		}, async (prompt, progress, _history, _location, sessionResource) => {
			const defaultAgent = chatAgentService.getDefaultAgent(ChatAgentLocation.Chat);
			const agents = chatAgentService.getAgents();

			// Report prefix
			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' });
			}

			// Report agent list
			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' });

			// Report help text ending
			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' });
				}
			}

			// Without this, the response will be done before it renders and so it will not stream. This ensures that if the response starts
			// rendering during the next 200ms, then it will be streamed. Once it starts streaming, the whole response streams even after
			// it has received all response data has been received.
			await timeout(200);
		}));
	}
}

/**
 * Registers slash commands declared by chat session providers via
 * {@link IChatSessionProviderOptionItem.slashCommand}. Each slash command is
 * scoped to its contributing session type via a `chatSessionType == X` `when`
 * clause, executes immediately, and updates the session option corresponding
 * to its declaring item — so e.g. `/yolo` switches the active permission mode
 * without sending a chat request.
 */
export class ChatSessionOptionSlashCommandsContribution extends Disposable {

	static readonly ID = 'workbench.contrib.chatSessionOptionSlashCommands';

	private readonly _registrationsByType = this._register(new DisposableMap<string>());

	constructor(
		@IChatSessionsService private readonly chatSessionsService: IChatSessionsService,
		@IChatSlashCommandService private readonly slashCommandService: IChatSlashCommandService,
		@ILogService private readonly logService: ILogService,
	) {
		super();

		this._register(this.chatSessionsService.onDidChangeOptionGroups(chatSessionType => {
			this.refreshForSessionType(chatSessionType);
		}));
	}

	private refreshForSessionType(chatSessionType: string): void {
		// Always tear down the previous registrations for this type before re-adding,
		// so renames / removals are honored.
		this._registrationsByType.deleteAndDispose(chatSessionType);

		const groups = this.chatSessionsService.getOptionGroupsForSessionType(chatSessionType);
		if (!groups || groups.length === 0) {
			return;
		}

		const store = new DisposableStore();
		const seen = new Set<string>();

		for (const group of groups) {
			for (const item of group.items) {
				const name = item.slashCommand?.trim();
				if (!name) {
					continue;
				}
				if (seen.has(name)) {
					this.logService.warn(`[ChatSessionOptionSlashCommands] Skipping duplicate slash command '${name}' contributed by session type '${chatSessionType}'.`);
					continue;
				}
				if (this.slashCommandService.hasCommand(name, chatSessionType)) {
					this.logService.warn(`[ChatSessionOptionSlashCommands] Slash command '${name}' contributed by session type '${chatSessionType}' is already registered; skipping.`);
					continue;
				}
				seen.add(name);
				store.add(this.registerOne(chatSessionType, group, item, name));
			}
		}

		if (store.isDisposed || seen.size === 0) {
			store.dispose();
			return;
		}
		this._registrationsByType.set(chatSessionType, store);
	}

	private registerOne(
		chatSessionType: string,
		group: IChatSessionProviderOptionGroup,
		item: IChatSessionProviderOptionItem,
		name: string
	) {
		return this.slashCommandService.registerSlashCommand({
			command: name,
			detail: item.description ?? nls.localize('chatSessionOption.slashCommand.detail', "Switch to '{0}'", item.name),
			sortText: `z1_${name}`,
			executeImmediately: true,
			silent: true,
			locations: [ChatAgentLocation.Chat],
			sessionTypes: [chatSessionType],
		}, async (_prompt, _progress, _history, _location, sessionResource) => {
			if (!sessionResource) {
				return;
			}
			this.chatSessionsService.setSessionOption(sessionResource, group.id, item);
		});
	}
}