@gguf/coder 0.3.1 → 0.3.3

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

@@ -1,42 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,291 +0,0 @@
-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,
-	};
-}