mirror of
https://github.com/QwenLM/qwen-code.git
synced 2025-12-21 17:27:54 +00:00
654 lines
22 KiB
TypeScript
654 lines
22 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2025 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
import { useCallback, useMemo, useEffect, useState } from 'react';
|
|
import { type PartListUnion } from '@google/genai';
|
|
import process from 'node:process';
|
|
import type { UseHistoryManagerReturn } from './useHistoryManager.js';
|
|
import type { Config } from '@qwen-code/qwen-code-core';
|
|
import {
|
|
GitService,
|
|
Logger,
|
|
logSlashCommand,
|
|
makeSlashCommandEvent,
|
|
SlashCommandStatus,
|
|
ToolConfirmationOutcome,
|
|
Storage,
|
|
IdeClient,
|
|
} from '@qwen-code/qwen-code-core';
|
|
import { useSessionStats } from '../contexts/SessionContext.js';
|
|
import { formatDuration } from '../utils/formatters.js';
|
|
import type {
|
|
Message,
|
|
HistoryItemWithoutId,
|
|
SlashCommandProcessorResult,
|
|
HistoryItem,
|
|
ConfirmationRequest,
|
|
} from '../types.js';
|
|
import { MessageType } from '../types.js';
|
|
import type { LoadedSettings } from '../../config/settings.js';
|
|
import { type CommandContext, type SlashCommand } from '../commands/types.js';
|
|
import { CommandService } from '../../services/CommandService.js';
|
|
import { BuiltinCommandLoader } from '../../services/BuiltinCommandLoader.js';
|
|
import { FileCommandLoader } from '../../services/FileCommandLoader.js';
|
|
import { McpPromptLoader } from '../../services/McpPromptLoader.js';
|
|
import { parseSlashCommand } from '../../utils/commands.js';
|
|
import {
|
|
type ExtensionUpdateAction,
|
|
type ExtensionUpdateStatus,
|
|
} from '../state/extensions.js';
|
|
|
|
interface SlashCommandProcessorActions {
|
|
openAuthDialog: () => void;
|
|
openThemeDialog: () => void;
|
|
openEditorDialog: () => void;
|
|
openSettingsDialog: () => void;
|
|
openModelDialog: () => void;
|
|
openPermissionsDialog: () => void;
|
|
openApprovalModeDialog: () => void;
|
|
quit: (messages: HistoryItem[]) => void;
|
|
setDebugMessage: (message: string) => void;
|
|
toggleCorgiMode: () => void;
|
|
dispatchExtensionStateUpdate: (action: ExtensionUpdateAction) => void;
|
|
addConfirmUpdateExtensionRequest: (request: ConfirmationRequest) => void;
|
|
openSubagentCreateDialog: () => void;
|
|
openAgentsManagerDialog: () => void;
|
|
_showQuitConfirmation: () => void;
|
|
}
|
|
|
|
/**
|
|
* Hook to define and process slash commands (e.g., /help, /clear).
|
|
*/
|
|
export const useSlashCommandProcessor = (
|
|
config: Config | null,
|
|
settings: LoadedSettings,
|
|
addItem: UseHistoryManagerReturn['addItem'],
|
|
clearItems: UseHistoryManagerReturn['clearItems'],
|
|
loadHistory: UseHistoryManagerReturn['loadHistory'],
|
|
refreshStatic: () => void,
|
|
toggleVimEnabled: () => Promise<boolean>,
|
|
setIsProcessing: (isProcessing: boolean) => void,
|
|
setGeminiMdFileCount: (count: number) => void,
|
|
actions: SlashCommandProcessorActions,
|
|
extensionsUpdateState: Map<string, ExtensionUpdateStatus>,
|
|
isConfigInitialized: boolean,
|
|
) => {
|
|
const session = useSessionStats();
|
|
const [commands, setCommands] = useState<readonly SlashCommand[]>([]);
|
|
const [reloadTrigger, setReloadTrigger] = useState(0);
|
|
|
|
const reloadCommands = useCallback(() => {
|
|
setReloadTrigger((v) => v + 1);
|
|
}, []);
|
|
const [shellConfirmationRequest, setShellConfirmationRequest] =
|
|
useState<null | {
|
|
commands: string[];
|
|
onConfirm: (
|
|
outcome: ToolConfirmationOutcome,
|
|
approvedCommands?: string[],
|
|
) => void;
|
|
}>(null);
|
|
const [confirmationRequest, setConfirmationRequest] = useState<null | {
|
|
prompt: React.ReactNode;
|
|
onConfirm: (confirmed: boolean) => void;
|
|
}>(null);
|
|
const [quitConfirmationRequest, setQuitConfirmationRequest] =
|
|
useState<null | {
|
|
onConfirm: (shouldQuit: boolean, action?: string) => void;
|
|
}>(null);
|
|
|
|
const [sessionShellAllowlist, setSessionShellAllowlist] = useState(
|
|
new Set<string>(),
|
|
);
|
|
const gitService = useMemo(() => {
|
|
if (!config?.getProjectRoot()) {
|
|
return;
|
|
}
|
|
return new GitService(config.getProjectRoot(), config.storage);
|
|
}, [config]);
|
|
|
|
const logger = useMemo(() => {
|
|
const l = new Logger(
|
|
config?.getSessionId() || '',
|
|
config?.storage ?? new Storage(process.cwd()),
|
|
);
|
|
// The logger's initialize is async, but we can create the instance
|
|
// synchronously. Commands that use it will await its initialization.
|
|
return l;
|
|
}, [config]);
|
|
|
|
const [pendingItem, setPendingItem] = useState<HistoryItemWithoutId | null>(
|
|
null,
|
|
);
|
|
|
|
const pendingHistoryItems = useMemo(() => {
|
|
const items: HistoryItemWithoutId[] = [];
|
|
if (pendingItem != null) {
|
|
items.push(pendingItem);
|
|
}
|
|
return items;
|
|
}, [pendingItem]);
|
|
|
|
const addMessage = useCallback(
|
|
(message: Message) => {
|
|
// Convert Message to HistoryItemWithoutId
|
|
let historyItemContent: HistoryItemWithoutId;
|
|
if (message.type === MessageType.ABOUT) {
|
|
historyItemContent = {
|
|
type: 'about',
|
|
systemInfo: message.systemInfo,
|
|
};
|
|
} else if (message.type === MessageType.HELP) {
|
|
historyItemContent = {
|
|
type: 'help',
|
|
timestamp: message.timestamp,
|
|
};
|
|
} else if (message.type === MessageType.STATS) {
|
|
historyItemContent = {
|
|
type: 'stats',
|
|
duration: message.duration,
|
|
};
|
|
} else if (message.type === MessageType.MODEL_STATS) {
|
|
historyItemContent = {
|
|
type: 'model_stats',
|
|
};
|
|
} else if (message.type === MessageType.TOOL_STATS) {
|
|
historyItemContent = {
|
|
type: 'tool_stats',
|
|
};
|
|
} else if (message.type === MessageType.QUIT) {
|
|
historyItemContent = {
|
|
type: 'quit',
|
|
duration: message.duration,
|
|
};
|
|
} else if (message.type === MessageType.QUIT_CONFIRMATION) {
|
|
historyItemContent = {
|
|
type: 'quit_confirmation',
|
|
duration: message.duration,
|
|
};
|
|
} else if (message.type === MessageType.COMPRESSION) {
|
|
historyItemContent = {
|
|
type: 'compression',
|
|
compression: message.compression,
|
|
};
|
|
} else if (message.type === MessageType.SUMMARY) {
|
|
historyItemContent = {
|
|
type: 'summary',
|
|
summary: message.summary,
|
|
};
|
|
} else {
|
|
historyItemContent = {
|
|
type: message.type,
|
|
text: message.content,
|
|
};
|
|
}
|
|
addItem(historyItemContent, message.timestamp.getTime());
|
|
},
|
|
[addItem],
|
|
);
|
|
const commandContext = useMemo(
|
|
(): CommandContext => ({
|
|
services: {
|
|
config,
|
|
settings,
|
|
git: gitService,
|
|
logger,
|
|
},
|
|
ui: {
|
|
addItem,
|
|
clear: () => {
|
|
clearItems();
|
|
console.clear();
|
|
refreshStatic();
|
|
},
|
|
loadHistory,
|
|
setDebugMessage: actions.setDebugMessage,
|
|
pendingItem,
|
|
setPendingItem,
|
|
toggleCorgiMode: actions.toggleCorgiMode,
|
|
toggleVimEnabled,
|
|
setGeminiMdFileCount,
|
|
reloadCommands,
|
|
extensionsUpdateState,
|
|
dispatchExtensionStateUpdate: actions.dispatchExtensionStateUpdate,
|
|
addConfirmUpdateExtensionRequest:
|
|
actions.addConfirmUpdateExtensionRequest,
|
|
},
|
|
session: {
|
|
stats: session.stats,
|
|
sessionShellAllowlist,
|
|
},
|
|
}),
|
|
[
|
|
config,
|
|
settings,
|
|
gitService,
|
|
logger,
|
|
loadHistory,
|
|
addItem,
|
|
clearItems,
|
|
refreshStatic,
|
|
session.stats,
|
|
actions,
|
|
pendingItem,
|
|
setPendingItem,
|
|
toggleVimEnabled,
|
|
sessionShellAllowlist,
|
|
setGeminiMdFileCount,
|
|
reloadCommands,
|
|
extensionsUpdateState,
|
|
],
|
|
);
|
|
|
|
useEffect(() => {
|
|
if (!config) {
|
|
return;
|
|
}
|
|
|
|
const listener = () => {
|
|
reloadCommands();
|
|
};
|
|
|
|
(async () => {
|
|
const ideClient = await IdeClient.getInstance();
|
|
ideClient.addStatusChangeListener(listener);
|
|
})();
|
|
|
|
return () => {
|
|
(async () => {
|
|
const ideClient = await IdeClient.getInstance();
|
|
ideClient.removeStatusChangeListener(listener);
|
|
})();
|
|
};
|
|
}, [config, reloadCommands]);
|
|
|
|
useEffect(() => {
|
|
const controller = new AbortController();
|
|
const load = async () => {
|
|
const loaders = [
|
|
new McpPromptLoader(config),
|
|
new BuiltinCommandLoader(config),
|
|
new FileCommandLoader(config),
|
|
];
|
|
const commandService = await CommandService.create(
|
|
loaders,
|
|
controller.signal,
|
|
);
|
|
setCommands(commandService.getCommands());
|
|
};
|
|
|
|
load();
|
|
|
|
return () => {
|
|
controller.abort();
|
|
};
|
|
}, [config, reloadTrigger, isConfigInitialized]);
|
|
|
|
const handleSlashCommand = useCallback(
|
|
async (
|
|
rawQuery: PartListUnion,
|
|
oneTimeShellAllowlist?: Set<string>,
|
|
overwriteConfirmed?: boolean,
|
|
): Promise<SlashCommandProcessorResult | false> => {
|
|
if (typeof rawQuery !== 'string') {
|
|
return false;
|
|
}
|
|
|
|
const trimmed = rawQuery.trim();
|
|
if (!trimmed.startsWith('/') && !trimmed.startsWith('?')) {
|
|
return false;
|
|
}
|
|
|
|
setIsProcessing(true);
|
|
|
|
const userMessageTimestamp = Date.now();
|
|
addItem({ type: MessageType.USER, text: trimmed }, userMessageTimestamp);
|
|
|
|
let hasError = false;
|
|
const {
|
|
commandToExecute,
|
|
args,
|
|
canonicalPath: resolvedCommandPath,
|
|
} = parseSlashCommand(trimmed, commands);
|
|
|
|
const subcommand =
|
|
resolvedCommandPath.length > 1
|
|
? resolvedCommandPath.slice(1).join(' ')
|
|
: undefined;
|
|
|
|
try {
|
|
if (commandToExecute) {
|
|
if (commandToExecute.action) {
|
|
const fullCommandContext: CommandContext = {
|
|
...commandContext,
|
|
invocation: {
|
|
raw: trimmed,
|
|
name: commandToExecute.name,
|
|
args,
|
|
},
|
|
overwriteConfirmed,
|
|
};
|
|
|
|
// If a one-time list is provided for a "Proceed" action, temporarily
|
|
// augment the session allowlist for this single execution.
|
|
if (oneTimeShellAllowlist && oneTimeShellAllowlist.size > 0) {
|
|
fullCommandContext.session = {
|
|
...fullCommandContext.session,
|
|
sessionShellAllowlist: new Set([
|
|
...fullCommandContext.session.sessionShellAllowlist,
|
|
...oneTimeShellAllowlist,
|
|
]),
|
|
};
|
|
}
|
|
const result = await commandToExecute.action(
|
|
fullCommandContext,
|
|
args,
|
|
);
|
|
|
|
if (result) {
|
|
switch (result.type) {
|
|
case 'tool':
|
|
return {
|
|
type: 'schedule_tool',
|
|
toolName: result.toolName,
|
|
toolArgs: result.toolArgs,
|
|
};
|
|
case 'message':
|
|
if (result.messageType === 'info') {
|
|
addMessage({
|
|
type: MessageType.INFO,
|
|
content: result.content,
|
|
timestamp: new Date(),
|
|
});
|
|
} else {
|
|
addMessage({
|
|
type: MessageType.ERROR,
|
|
content: result.content,
|
|
timestamp: new Date(),
|
|
});
|
|
}
|
|
return { type: 'handled' };
|
|
case 'dialog':
|
|
switch (result.dialog) {
|
|
case 'auth':
|
|
actions.openAuthDialog();
|
|
return { type: 'handled' };
|
|
case 'theme':
|
|
actions.openThemeDialog();
|
|
return { type: 'handled' };
|
|
case 'editor':
|
|
actions.openEditorDialog();
|
|
return { type: 'handled' };
|
|
case 'settings':
|
|
actions.openSettingsDialog();
|
|
return { type: 'handled' };
|
|
case 'model':
|
|
actions.openModelDialog();
|
|
return { type: 'handled' };
|
|
case 'permissions':
|
|
actions.openPermissionsDialog();
|
|
return { type: 'handled' };
|
|
case 'subagent_create':
|
|
actions.openSubagentCreateDialog();
|
|
return { type: 'handled' };
|
|
case 'subagent_list':
|
|
actions.openAgentsManagerDialog();
|
|
return { type: 'handled' };
|
|
case 'approval-mode':
|
|
actions.openApprovalModeDialog();
|
|
return { type: 'handled' };
|
|
case 'help':
|
|
return { type: 'handled' };
|
|
default: {
|
|
const unhandled: never = result.dialog;
|
|
throw new Error(
|
|
`Unhandled slash command result: ${unhandled}`,
|
|
);
|
|
}
|
|
}
|
|
case 'load_history': {
|
|
config?.getGeminiClient()?.setHistory(result.clientHistory);
|
|
config?.getGeminiClient()?.stripThoughtsFromHistory();
|
|
fullCommandContext.ui.clear();
|
|
result.history.forEach((item, index) => {
|
|
fullCommandContext.ui.addItem(item, index);
|
|
});
|
|
return { type: 'handled' };
|
|
}
|
|
case 'quit_confirmation':
|
|
// Show quit confirmation dialog instead of immediately quitting
|
|
setQuitConfirmationRequest({
|
|
onConfirm: (shouldQuit: boolean, action?: string) => {
|
|
setQuitConfirmationRequest(null);
|
|
if (!shouldQuit) {
|
|
// User cancelled the quit operation - do nothing
|
|
return;
|
|
}
|
|
if (shouldQuit) {
|
|
if (action === 'save_and_quit') {
|
|
// First save conversation with auto-generated tag, then quit
|
|
const timestamp = new Date()
|
|
.toISOString()
|
|
.replace(/[:.]/g, '-');
|
|
const autoSaveTag = `auto-save chat ${timestamp}`;
|
|
handleSlashCommand(`/chat save "${autoSaveTag}"`);
|
|
setTimeout(() => handleSlashCommand('/quit'), 100);
|
|
} else if (action === 'summary_and_quit') {
|
|
// Generate summary and then quit
|
|
handleSlashCommand('/summary')
|
|
.then(() => {
|
|
// Wait for user to see the summary result
|
|
setTimeout(() => {
|
|
handleSlashCommand('/quit');
|
|
}, 1200);
|
|
})
|
|
.catch((error) => {
|
|
// If summary fails, still quit but show error
|
|
addItem(
|
|
{
|
|
type: 'error',
|
|
text: `Failed to generate summary before quit: ${
|
|
error instanceof Error
|
|
? error.message
|
|
: String(error)
|
|
}`,
|
|
},
|
|
Date.now(),
|
|
);
|
|
// Give user time to see the error message
|
|
setTimeout(() => {
|
|
handleSlashCommand('/quit');
|
|
}, 1000);
|
|
});
|
|
} else {
|
|
// Just quit immediately - trigger the actual quit action
|
|
const now = Date.now();
|
|
const { sessionStartTime } = session.stats;
|
|
const wallDuration = now - sessionStartTime.getTime();
|
|
|
|
actions.quit([
|
|
{
|
|
type: 'user',
|
|
text: `/quit`,
|
|
id: now - 1,
|
|
},
|
|
{
|
|
type: 'quit',
|
|
duration: formatDuration(wallDuration),
|
|
id: now,
|
|
},
|
|
]);
|
|
}
|
|
}
|
|
},
|
|
});
|
|
return { type: 'handled' };
|
|
|
|
case 'quit':
|
|
actions.quit(result.messages);
|
|
return { type: 'handled' };
|
|
|
|
case 'submit_prompt':
|
|
return {
|
|
type: 'submit_prompt',
|
|
content: result.content,
|
|
};
|
|
case 'confirm_shell_commands': {
|
|
const { outcome, approvedCommands } = await new Promise<{
|
|
outcome: ToolConfirmationOutcome;
|
|
approvedCommands?: string[];
|
|
}>((resolve) => {
|
|
setShellConfirmationRequest({
|
|
commands: result.commandsToConfirm,
|
|
onConfirm: (
|
|
resolvedOutcome,
|
|
resolvedApprovedCommands,
|
|
) => {
|
|
setShellConfirmationRequest(null); // Close the dialog
|
|
resolve({
|
|
outcome: resolvedOutcome,
|
|
approvedCommands: resolvedApprovedCommands,
|
|
});
|
|
},
|
|
});
|
|
});
|
|
|
|
if (
|
|
outcome === ToolConfirmationOutcome.Cancel ||
|
|
!approvedCommands ||
|
|
approvedCommands.length === 0
|
|
) {
|
|
return { type: 'handled' };
|
|
}
|
|
|
|
if (outcome === ToolConfirmationOutcome.ProceedAlways) {
|
|
setSessionShellAllowlist(
|
|
(prev) => new Set([...prev, ...approvedCommands]),
|
|
);
|
|
}
|
|
|
|
return await handleSlashCommand(
|
|
result.originalInvocation.raw,
|
|
// Pass the approved commands as a one-time grant for this execution.
|
|
new Set(approvedCommands),
|
|
);
|
|
}
|
|
case 'confirm_action': {
|
|
const { confirmed } = await new Promise<{
|
|
confirmed: boolean;
|
|
}>((resolve) => {
|
|
setConfirmationRequest({
|
|
prompt: result.prompt,
|
|
onConfirm: (resolvedConfirmed) => {
|
|
setConfirmationRequest(null);
|
|
resolve({ confirmed: resolvedConfirmed });
|
|
},
|
|
});
|
|
});
|
|
|
|
if (!confirmed) {
|
|
addItem(
|
|
{
|
|
type: MessageType.INFO,
|
|
text: 'Operation cancelled.',
|
|
},
|
|
Date.now(),
|
|
);
|
|
return { type: 'handled' };
|
|
}
|
|
|
|
return await handleSlashCommand(
|
|
result.originalInvocation.raw,
|
|
undefined,
|
|
true,
|
|
);
|
|
}
|
|
default: {
|
|
const unhandled: never = result;
|
|
throw new Error(
|
|
`Unhandled slash command result: ${unhandled}`,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
return { type: 'handled' };
|
|
} else if (commandToExecute.subCommands) {
|
|
const helpText = `Command '/${commandToExecute.name}' requires a subcommand. Available:\n${commandToExecute.subCommands
|
|
.map((sc) => ` - ${sc.name}: ${sc.description || ''}`)
|
|
.join('\n')}`;
|
|
addMessage({
|
|
type: MessageType.INFO,
|
|
content: helpText,
|
|
timestamp: new Date(),
|
|
});
|
|
return { type: 'handled' };
|
|
}
|
|
}
|
|
|
|
addMessage({
|
|
type: MessageType.ERROR,
|
|
content: `Unknown command: ${trimmed}`,
|
|
timestamp: new Date(),
|
|
});
|
|
|
|
return { type: 'handled' };
|
|
} catch (e: unknown) {
|
|
hasError = true;
|
|
if (config) {
|
|
const event = makeSlashCommandEvent({
|
|
command: resolvedCommandPath[0],
|
|
subcommand,
|
|
status: SlashCommandStatus.ERROR,
|
|
});
|
|
logSlashCommand(config, event);
|
|
}
|
|
addItem(
|
|
{
|
|
type: MessageType.ERROR,
|
|
text: e instanceof Error ? e.message : String(e),
|
|
},
|
|
Date.now(),
|
|
);
|
|
return { type: 'handled' };
|
|
} finally {
|
|
if (config && resolvedCommandPath[0] && !hasError) {
|
|
const event = makeSlashCommandEvent({
|
|
command: resolvedCommandPath[0],
|
|
subcommand,
|
|
status: SlashCommandStatus.SUCCESS,
|
|
});
|
|
logSlashCommand(config, event);
|
|
}
|
|
setIsProcessing(false);
|
|
}
|
|
},
|
|
[
|
|
config,
|
|
addItem,
|
|
actions,
|
|
commands,
|
|
commandContext,
|
|
addMessage,
|
|
setShellConfirmationRequest,
|
|
setSessionShellAllowlist,
|
|
setIsProcessing,
|
|
setConfirmationRequest,
|
|
session.stats,
|
|
],
|
|
);
|
|
|
|
return {
|
|
handleSlashCommand,
|
|
slashCommands: commands,
|
|
pendingHistoryItems,
|
|
commandContext,
|
|
shellConfirmationRequest,
|
|
confirmationRequest,
|
|
quitConfirmationRequest,
|
|
};
|
|
};
|