@gguf/coder 0.3.0 → 0.3.1

package/source/hooks/chat-handler/utils/message-helpers.spec.ts

@@ -0,0 +1,42 @@
+import test from 'ava';
+import {displayError} from './message-helpers.js';
+import type React from 'react';
+
+test('displayError - handles cancellation errors specially', t => {
+	let capturedComponent: React.ReactNode = null;
+	const addToChatQueue = (component: React.ReactNode) => {
+		capturedComponent = component;
+	};
+
+	const error = new Error('Operation was cancelled');
+	displayError(error, 'test', addToChatQueue, 1);
+
+	t.truthy(capturedComponent);
+	// Check that component was created (we can't easily inspect JSX in tests)
+	t.pass();
+});
+
+test('displayError - handles generic errors', t => {
+	let capturedComponent: React.ReactNode = null;
+	const addToChatQueue = (component: React.ReactNode) => {
+		capturedComponent = component;
+	};
+
+	const error = new Error('Test error');
+	displayError(error, 'test', addToChatQueue, 1);
+
+	t.truthy(capturedComponent);
+	t.pass();
+});
+
+test('displayError - handles non-Error objects', t => {
+	let capturedComponent: React.ReactNode = null;
+	const addToChatQueue = (component: React.ReactNode) => {
+		capturedComponent = component;
+	};
+
+	displayError('string error', 'test', addToChatQueue, 1);
+
+	t.truthy(capturedComponent);
+	t.pass();
+});

package/source/hooks/chat-handler/utils/message-helpers.tsx

@@ -0,0 +1,36 @@
+import {ErrorMessage} from '@/components/message-box';
+import {formatError} from '@/utils/error-formatter';
+import type React from 'react';
+
+/**
+ * Displays an error in the chat queue with special handling for cancellation errors.
+ *
+ * @param error - The error to display
+ * @param keyPrefix - Prefix for the React component key
+ * @param addToChatQueue - Callback to add error message to chat
+ * @param componentKeyCounter - Unique key counter for React components
+ */
+export const displayError = (
+	error: unknown,
+	keyPrefix: string,
+	addToChatQueue: (component: React.ReactNode) => void,
+	componentKeyCounter: number,
+): void => {
+	if (error instanceof Error && error.message === 'Operation was cancelled') {
+		addToChatQueue(
+			<ErrorMessage
+				key={`${keyPrefix}-${componentKeyCounter}`}
+				message="Interrupted by user."
+				hideBox={true}
+			/>,
+		);
+	} else {
+		addToChatQueue(
+			<ErrorMessage
+				key={`${keyPrefix}-${componentKeyCounter}`}
+				message={formatError(error)}
+				hideBox={true}
+			/>,
+		);
+	}
+};

package/source/hooks/chat-handler/utils/tool-filters.spec.ts

@@ -0,0 +1,109 @@
+import test from 'ava';
+import {filterValidToolCalls} from './tool-filters.js';
+import type {ToolCall} from '@/types/core';
+import type {ToolManager} from '@/tools/tool-manager';
+
+test('filterValidToolCalls - filters out empty tool calls', t => {
+	const toolCalls: ToolCall[] = [
+		{
+			id: '',
+			function: {name: 'test', arguments: {}},
+		},
+		{
+			id: 'call_1',
+			function: {name: '', arguments: {}},
+		},
+		{
+			id: 'call_2',
+			function: {name: 'valid_tool', arguments: {}},
+		},
+	];
+
+	const {validToolCalls, errorResults} = filterValidToolCalls(toolCalls, null);
+
+	t.is(validToolCalls.length, 1);
+	t.is(validToolCalls[0].id, 'call_2');
+	t.is(errorResults.length, 0);
+});
+
+test('filterValidToolCalls - creates error for non-existent tools', t => {
+	const toolCalls: ToolCall[] = [
+		{
+			id: 'call_1',
+			function: {name: 'nonexistent_tool', arguments: {}},
+		},
+	];
+
+	const mockToolManager = {
+		hasTool: (name: string) => name === 'existing_tool',
+	} as unknown as ToolManager;
+
+	const {validToolCalls, errorResults} = filterValidToolCalls(
+		toolCalls,
+		mockToolManager,
+	);
+
+	t.is(validToolCalls.length, 0);
+	t.is(errorResults.length, 1);
+	t.is(errorResults[0].tool_call_id, 'call_1');
+	t.is(errorResults[0].name, 'nonexistent_tool');
+	t.true(errorResults[0].content.includes('does not exist'));
+});
+
+test('filterValidToolCalls - deduplicates by ID', t => {
+	const toolCalls: ToolCall[] = [
+		{
+			id: 'call_1',
+			function: {name: 'tool', arguments: {a: 1}},
+		},
+		{
+			id: 'call_1', // Duplicate ID
+			function: {name: 'tool', arguments: {a: 2}},
+		},
+	];
+
+	const {validToolCalls} = filterValidToolCalls(toolCalls, null);
+
+	t.is(validToolCalls.length, 1);
+	t.is(validToolCalls[0].id, 'call_1');
+	t.deepEqual(validToolCalls[0].function.arguments, {a: 1}); // First one wins
+});
+
+test('filterValidToolCalls - deduplicates by function signature', t => {
+	const toolCalls: ToolCall[] = [
+		{
+			id: 'call_1',
+			function: {name: 'tool', arguments: {a: 1}},
+		},
+		{
+			id: 'call_2',
+			function: {name: 'tool', arguments: {a: 1}}, // Same tool + args
+		},
+	];
+
+	const {validToolCalls} = filterValidToolCalls(toolCalls, null);
+
+	t.is(validToolCalls.length, 1);
+	t.is(validToolCalls[0].id, 'call_1'); // First one wins
+});
+
+test('filterValidToolCalls - allows different tool calls', t => {
+	const toolCalls: ToolCall[] = [
+		{
+			id: 'call_1',
+			function: {name: 'tool_a', arguments: {a: 1}},
+		},
+		{
+			id: 'call_2',
+			function: {name: 'tool_b', arguments: {b: 2}},
+		},
+		{
+			id: 'call_3',
+			function: {name: 'tool_a', arguments: {a: 2}}, // Same tool, different args
+		},
+	];
+
+	const {validToolCalls} = filterValidToolCalls(toolCalls, null);
+
+	t.is(validToolCalls.length, 3);
+});

package/source/hooks/chat-handler/utils/tool-filters.ts

@@ -0,0 +1,64 @@
+import type {ToolManager} from '@/tools/tool-manager';
+import type {ToolCall, ToolResult} from '@/types/core';
+
+/**
+ * Filters out invalid tool calls and deduplicates by ID and function signature.
+ * Returns valid tool calls and error results for invalid ones.
+ *
+ * Handles:
+ * - Empty tool calls (missing id or function name)
+ * - Tools that don't exist in the tool manager
+ * - Duplicate tool call IDs (GPT-5 issue)
+ * - Functionally identical tool calls (same tool + arguments)
+ */
+export const filterValidToolCalls = (
+	toolCalls: ToolCall[],
+	toolManager: ToolManager | null,
+): {validToolCalls: ToolCall[]; errorResults: ToolResult[]} => {
+	const seenIds = new Set<string>();
+	const seenFunctionCalls = new Set<string>();
+	const validToolCalls: ToolCall[] = [];
+	const errorResults: ToolResult[] = [];
+
+	for (const toolCall of toolCalls) {
+		// Filter out completely empty tool calls
+		if (!toolCall.id || !toolCall.function?.name) {
+			continue;
+		}
+
+		// Filter out tool calls with empty names
+		if (toolCall.function.name.trim() === '') {
+			continue;
+		}
+
+		// Filter out tool calls for tools that don't exist
+		if (toolManager && !toolManager.hasTool(toolCall.function.name)) {
+			errorResults.push({
+				tool_call_id: toolCall.id,
+				role: 'tool' as const,
+				name: toolCall.function.name,
+				content: `This tool does not exist. Please use only the tools that are available in the system.`,
+			});
+			continue;
+		}
+
+		// Filter out duplicate tool call IDs (GPT-5 issue)
+		if (seenIds.has(toolCall.id)) {
+			continue;
+		}
+
+		// Filter out functionally identical tool calls (same tool + args)
+		const functionSignature = `${toolCall.function.name}:${JSON.stringify(
+			toolCall.function.arguments,
+		)}`;
+		if (seenFunctionCalls.has(functionSignature)) {
+			continue;
+		}
+
+		seenIds.add(toolCall.id);
+		seenFunctionCalls.add(functionSignature);
+		validToolCalls.push(toolCall);
+	}
+
+	return {validToolCalls, errorResults};
+};

package/source/hooks/useAppHandlers.tsx

@@ -0,0 +1,291 @@
+import {handleMessageSubmission} from '@/app/utils/appUtils';
+import {createClearMessagesHandler} from '@/app/utils/appUtils';
+import {
+	ErrorMessage,
+	SuccessMessage,
+	WarningMessage,
+} from '@/components/message-box';
+import Status from '@/components/status';
+import {setCurrentMode as setCurrentModeContext} from '@/context/mode-context';
+import {CustomCommandExecutor} from '@/custom-commands/executor';
+import {CustomCommandLoader} from '@/custom-commands/loader';
+import {CheckpointManager} from '@/services/checkpoint-manager';
+import type {
+	CheckpointListItem,
+	DevelopmentMode,
+	LLMClient,
+	LSPConnectionStatus,
+	MCPConnectionStatus,
+	Message,
+} from '@/types';
+import type {CustomCommand} from '@/types/commands';
+import type {ThemePreset} from '@/types/ui';
+import type {UpdateInfo} from '@/types/utils';
+import {getLogger} from '@/utils/logging';
+import {addToMessageQueue} from '@/utils/message-queue';
+import React from 'react';
+
+interface UseAppHandlersProps {
+	// State
+	messages: Message[];
+	currentProvider: string;
+	currentModel: string;
+	currentTheme: ThemePreset;
+	abortController: AbortController | null;
+	updateInfo: UpdateInfo | null;
+	mcpServersStatus: MCPConnectionStatus[] | undefined;
+	lspServersStatus: LSPConnectionStatus[];
+	preferencesLoaded: boolean;
+	customCommandsCount: number;
+	componentKeyCounter: number;
+	customCommandCache: Map<string, CustomCommand>;
+	customCommandLoader: CustomCommandLoader | null;
+	customCommandExecutor: CustomCommandExecutor | null;
+
+	// State setters
+	updateMessages: (newMessages: Message[]) => void;
+	setIsCancelling: (value: boolean) => void;
+	setDevelopmentMode: (
+		updater: DevelopmentMode | ((prev: DevelopmentMode) => DevelopmentMode),
+	) => void;
+	setIsConversationComplete: (value: boolean) => void;
+	setIsBashExecuting: (value: boolean) => void;
+	setCurrentBashCommand: (value: string) => void;
+	setIsCheckpointLoadMode: (value: boolean) => void;
+	setCheckpointLoadData: (
+		value: {
+			checkpoints: CheckpointListItem[];
+			currentMessageCount: number;
+		} | null,
+	) => void;
+
+	// Callbacks
+	addToChatQueue: (component: React.ReactNode) => void;
+	client: LLMClient | null;
+	getMessageTokens: (message: Message) => number;
+
+	// Mode handlers
+	enterModelSelectionMode: () => void;
+	enterProviderSelectionMode: () => void;
+	enterThemeSelectionMode: () => void;
+	enterModelDatabaseMode: () => void;
+	enterConfigWizardMode: () => void;
+
+	// Chat handler
+	handleChatMessage: (message: string) => Promise<void>;
+}
+
+export interface AppHandlers {
+	clearMessages: () => Promise<void>;
+	handleCancel: () => void;
+	handleToggleDevelopmentMode: () => void;
+	handleShowStatus: () => void;
+	handleCheckpointSelect: (
+		checkpointName: string,
+		createBackup: boolean,
+	) => Promise<void>;
+	handleCheckpointCancel: () => void;
+	enterCheckpointLoadMode: (
+		checkpoints: CheckpointListItem[],
+		currentMessageCount: number,
+	) => void;
+	handleMessageSubmit: (message: string) => Promise<void>;
+}
+
+/**
+ * Consolidates all app handler setup into a single hook
+ */
+export function useAppHandlers(props: UseAppHandlersProps): AppHandlers {
+	const logger = getLogger();
+
+	// Clear messages handler
+	const clearMessages = React.useMemo(
+		() => createClearMessagesHandler(props.updateMessages, props.client),
+		[props.updateMessages, props.client],
+	);
+
+	// Cancel handler
+	const handleCancel = React.useCallback(() => {
+		if (props.abortController) {
+			logger.info('Cancelling current operation', {
+				operation: 'user_cancellation',
+				hasAbortController: !!props.abortController,
+			});
+
+			props.setIsCancelling(true);
+			props.abortController.abort();
+		} else {
+			logger.debug('Cancel requested but no active operation to cancel');
+		}
+	}, [props.abortController, props.setIsCancelling, logger]);
+
+	// Toggle development mode handler
+	const handleToggleDevelopmentMode = React.useCallback(() => {
+		props.setDevelopmentMode(currentMode => {
+			const modes: Array<'normal' | 'auto-accept' | 'plan'> = [
+				'normal',
+				'auto-accept',
+				'plan',
+			];
+			const currentIndex = modes.indexOf(currentMode);
+			const nextIndex = (currentIndex + 1) % modes.length;
+			const nextMode = modes[nextIndex];
+
+			logger.info('Development mode toggled', {
+				previousMode: currentMode,
+				nextMode,
+				modeIndex: nextIndex,
+				totalModes: modes.length,
+			});
+
+			// Sync global mode context for tool needsApproval logic
+			setCurrentModeContext(nextMode);
+
+			return nextMode;
+		});
+	}, [props.setDevelopmentMode, logger]);
+
+	// Show status handler
+	const handleShowStatus = React.useCallback(() => {
+		logger.debug('Status display requested', {
+			currentProvider: props.currentProvider,
+			currentModel: props.currentModel,
+			currentTheme: props.currentTheme,
+			componentKeyCounter: props.componentKeyCounter,
+		});
+
+		props.addToChatQueue(
+			<Status
+				key={`status-${props.componentKeyCounter}`}
+				provider={props.currentProvider}
+				model={props.currentModel}
+				theme={props.currentTheme}
+				updateInfo={props.updateInfo}
+				mcpServersStatus={props.mcpServersStatus}
+				lspServersStatus={props.lspServersStatus}
+				preferencesLoaded={props.preferencesLoaded}
+				customCommandsCount={props.customCommandsCount}
+			/>,
+		);
+	}, [props, logger]);
+
+	// Checkpoint select handler
+	const handleCheckpointSelect = React.useCallback(
+		async (checkpointName: string, createBackup: boolean) => {
+			try {
+				const manager = new CheckpointManager();
+
+				if (createBackup) {
+					try {
+						await manager.saveCheckpoint(
+							`backup-${new Date().toISOString().replace(/[:.]/g, '-')}`,
+							props.messages,
+							props.currentProvider,
+							props.currentModel,
+						);
+					} catch (error) {
+						addToMessageQueue(
+							<WarningMessage
+								key={`backup-warning-${Date.now()}`}
+								message={`Warning: Failed to create backup: ${
+									error instanceof Error ? error.message : 'Unknown error'
+								}`}
+								hideBox={true}
+							/>,
+						);
+					}
+				}
+
+				const checkpointData = await manager.loadCheckpoint(checkpointName, {
+					validateIntegrity: true,
+				});
+
+				await manager.restoreFiles(checkpointData);
+
+				addToMessageQueue(
+					<SuccessMessage
+						key={`restore-success-${Date.now()}`}
+						message={`✓ Checkpoint '${checkpointName}' restored successfully`}
+						hideBox={true}
+					/>,
+				);
+			} catch (error) {
+				addToMessageQueue(
+					<ErrorMessage
+						key={`restore-error-${Date.now()}`}
+						message={`Failed to restore checkpoint: ${
+							error instanceof Error ? error.message : 'Unknown error'
+						}`}
+						hideBox={true}
+					/>,
+				);
+			} finally {
+				props.setIsCheckpointLoadMode(false);
+				props.setCheckpointLoadData(null);
+			}
+		},
+		[props],
+	);
+
+	// Checkpoint cancel handler
+	const handleCheckpointCancel = React.useCallback(() => {
+		props.setIsCheckpointLoadMode(false);
+		props.setCheckpointLoadData(null);
+	}, [props.setIsCheckpointLoadMode, props.setCheckpointLoadData]);
+
+	// Enter checkpoint load mode handler
+	const enterCheckpointLoadMode = React.useCallback(
+		(checkpoints: CheckpointListItem[], currentMessageCount: number) => {
+			props.setCheckpointLoadData({checkpoints, currentMessageCount});
+			props.setIsCheckpointLoadMode(true);
+		},
+		[props.setCheckpointLoadData, props.setIsCheckpointLoadMode],
+	);
+
+	// Message submit handler
+	const handleMessageSubmit = React.useCallback(
+		async (message: string) => {
+			// Reset conversation completion flag when starting a new message
+			props.setIsConversationComplete(false);
+
+			await handleMessageSubmission(message, {
+				customCommandCache: props.customCommandCache,
+				customCommandLoader: props.customCommandLoader,
+				customCommandExecutor: props.customCommandExecutor,
+				onClearMessages: clearMessages,
+				onEnterModelSelectionMode: props.enterModelSelectionMode,
+				onEnterProviderSelectionMode: props.enterProviderSelectionMode,
+				onEnterThemeSelectionMode: props.enterThemeSelectionMode,
+				onEnterModelDatabaseMode: props.enterModelDatabaseMode,
+				onEnterConfigWizardMode: props.enterConfigWizardMode,
+				onEnterCheckpointLoadMode: enterCheckpointLoadMode,
+				onShowStatus: handleShowStatus,
+				onHandleChatMessage: props.handleChatMessage,
+				onAddToChatQueue: props.addToChatQueue,
+				onCommandComplete: () => props.setIsConversationComplete(true),
+				componentKeyCounter: props.componentKeyCounter,
+				setMessages: props.updateMessages,
+				messages: props.messages,
+				setIsBashExecuting: props.setIsBashExecuting,
+				setCurrentBashCommand: props.setCurrentBashCommand,
+				provider: props.currentProvider,
+				model: props.currentModel,
+				theme: props.currentTheme,
+				updateInfo: props.updateInfo,
+				getMessageTokens: props.getMessageTokens,
+			});
+		},
+		[props, clearMessages, enterCheckpointLoadMode, handleShowStatus],
+	);
+
+	return {
+		clearMessages,
+		handleCancel,
+		handleToggleDevelopmentMode,
+		handleShowStatus,
+		handleCheckpointSelect,
+		handleCheckpointCancel,
+		enterCheckpointLoadMode,
+		handleMessageSubmit,
+	};
+}