@gguf/coder 0.3.0 → 0.3.1

package/source/hooks/chat-handler/state/streaming-state.ts

@@ -0,0 +1,19 @@
+/**
+ * Creates a function to reset all streaming-related state.
+ * Used to clean up after streaming responses complete or error.
+ */
+export const createResetStreamingState = (
+	setIsCancelling: (cancelling: boolean) => void,
+	setAbortController: (controller: AbortController | null) => void,
+	setIsGenerating: (generating: boolean) => void,
+	setStreamingContent: (content: string) => void,
+	setTokenCount: (count: number) => void,
+) => {
+	return () => {
+		setIsCancelling(false);
+		setAbortController(null);
+		setIsGenerating(false);
+		setStreamingContent('');
+		setTokenCount(0);
+	};
+};

package/source/hooks/chat-handler/types.ts

@@ -0,0 +1,38 @@
+import type {ToolManager} from '@/tools/tool-manager';
+import type {LLMClient, Message, ToolCall} from '@/types/core';
+import type React from 'react';
+
+export interface UseChatHandlerProps {
+	client: LLMClient | null;
+	toolManager: ToolManager | null;
+	messages: Message[];
+	setMessages: (messages: Message[]) => void;
+	currentProvider: string;
+	currentModel: string;
+	setIsCancelling: (cancelling: boolean) => void;
+
+	addToChatQueue: (component: React.ReactNode) => void;
+	componentKeyCounter: number;
+	abortController: AbortController | null;
+	setAbortController: (controller: AbortController | null) => void;
+	developmentMode?: 'normal' | 'auto-accept' | 'plan';
+	nonInteractiveMode?: boolean;
+	onStartToolConfirmationFlow: (
+		toolCalls: ToolCall[],
+		updatedMessages: Message[],
+		assistantMsg: Message,
+		systemMessage: Message,
+	) => void;
+	onConversationComplete?: () => void;
+}
+
+export interface ChatHandlerReturn {
+	handleChatMessage: (message: string) => Promise<void>;
+	processAssistantResponse: (
+		systemMessage: Message,
+		messages: Message[],
+	) => Promise<void>;
+	isGenerating: boolean;
+	streamingContent: string;
+	tokenCount: number;
+}

package/source/hooks/chat-handler/useChatHandler.spec.tsx

@@ -0,0 +1,321 @@
+import test from 'ava';
+import React from 'react';
+import {render} from 'ink-testing-library';
+import {useChatHandler} from './useChatHandler';
+import type {UseChatHandlerProps, ChatHandlerReturn} from './types';
+import type {Message} from '../../types/core';
+
+// Test component that uses the hook and exposes results
+function TestHookComponent(props: UseChatHandlerProps & {onResult?: (result: ChatHandlerReturn) => void}) {
+	const {onResult, ...hookProps} = props;
+	const result = useChatHandler(hookProps);
+
+	React.useEffect(() => {
+		onResult?.(result);
+	}, [result, onResult]);
+
+	return <></>;
+}
+
+// Helper to create mock props
+const createMockProps = (overrides?: Partial<UseChatHandlerProps>): UseChatHandlerProps => ({
+	client: null,
+	toolManager: null,
+	messages: [],
+	setMessages: () => {},
+	currentProvider: 'test-provider',
+	currentModel: 'test-model',
+	setIsCancelling: () => {},
+	addToChatQueue: () => {},
+	componentKeyCounter: 1,
+	abortController: null,
+	setAbortController: () => {},
+	onStartToolConfirmationFlow: () => {},
+	...overrides,
+});
+
+test('useChatHandler - returns correct interface', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps();
+
+	render(
+		<TestHookComponent
+			{...props}
+			onResult={result => {
+				hookResult = result;
+			}}
+		/>,
+	);
+
+	// Verify the hook returned the expected interface
+	t.truthy(hookResult);
+	t.true('handleChatMessage' in hookResult!);
+	t.true('processAssistantResponse' in hookResult!);
+	t.true('isGenerating' in hookResult!);
+	t.true('streamingContent' in hookResult!);
+	t.true('tokenCount' in hookResult!);
+});
+
+test('useChatHandler - returns correct function types', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps();
+
+	render(
+		<TestHookComponent
+			{...props}
+			onResult={result => {
+				hookResult = result;
+			}}
+		/>,
+	);
+
+	t.truthy(hookResult);
+	t.is(typeof hookResult!.handleChatMessage, 'function');
+	t.is(typeof hookResult!.processAssistantResponse, 'function');
+	t.is(typeof hookResult!.isGenerating, 'boolean');
+	t.is(typeof hookResult!.streamingContent, 'string');
+	t.is(typeof hookResult!.tokenCount, 'number');
+});
+
+test('useChatHandler - initial streaming state is correct', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps();
+
+	render(
+		<TestHookComponent
+			{...props}
+			onResult={result => {
+				hookResult = result;
+			}}
+		/>,
+	);
+
+	t.truthy(hookResult);
+	t.is(hookResult!.isGenerating, false);
+	t.is(hookResult!.streamingContent, '');
+	t.is(hookResult!.tokenCount, 0);
+});
+
+test('useChatHandler - handles empty messages array', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps({
+		messages: [],
+	});
+
+	t.notThrows(() => {
+		render(
+			<TestHookComponent
+				{...props}
+				onResult={result => {
+					hookResult = result;
+				}}
+			/>,
+		);
+	});
+
+	t.truthy(hookResult);
+});
+
+test('useChatHandler - handles messages with content', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const messages: Message[] = [
+		{role: 'user', content: 'test message'},
+		{role: 'assistant', content: 'test response'},
+	];
+
+	const props = createMockProps({
+		messages,
+	});
+
+	t.notThrows(() => {
+		render(
+			<TestHookComponent
+				{...props}
+				onResult={result => {
+					hookResult = result;
+				}}
+			/>,
+		);
+	});
+
+	t.truthy(hookResult);
+});
+
+test('useChatHandler - handles different development modes', t => {
+	const modes: Array<'normal' | 'auto-accept' | 'plan'> = ['normal', 'auto-accept', 'plan'];
+
+	for (const mode of modes) {
+		let hookResult: ChatHandlerReturn | null = null;
+
+		const props = createMockProps({
+			developmentMode: mode,
+		});
+
+		t.notThrows(() => {
+			render(
+				<TestHookComponent
+					{...props}
+					onResult={result => {
+						hookResult = result;
+					}}
+				/>,
+			);
+		}, `Should handle ${mode} mode`);
+
+		t.truthy(hookResult);
+	}
+});
+
+test('useChatHandler - handles non-interactive mode', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps({
+		nonInteractiveMode: true,
+	});
+
+	t.notThrows(() => {
+		render(
+			<TestHookComponent
+				{...props}
+				onResult={result => {
+					hookResult = result;
+				}}
+			/>,
+		);
+	});
+
+	t.truthy(hookResult);
+});
+
+test('useChatHandler - accepts abort controller', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const controller = new AbortController();
+	const props = createMockProps({
+		abortController: controller,
+	});
+
+	t.notThrows(() => {
+		render(
+			<TestHookComponent
+				{...props}
+				onResult={result => {
+					hookResult = result;
+				}}
+			/>,
+		);
+	});
+
+	t.truthy(hookResult);
+});
+
+test('useChatHandler - handles null client gracefully', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps({
+		client: null,
+		toolManager: null,
+	});
+
+	t.notThrows(() => {
+		render(
+			<TestHookComponent
+				{...props}
+				onResult={result => {
+					hookResult = result;
+				}}
+			/>,
+		);
+	});
+
+	t.truthy(hookResult);
+});
+
+test('useChatHandler - setMessages callback works', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const messages: Message[] = [];
+	const setMessages = (newMessages: Message[]) => {
+		messages.length = 0;
+		messages.push(...newMessages);
+	};
+
+	const props = createMockProps({
+		messages,
+		setMessages,
+	});
+
+	render(
+		<TestHookComponent
+			{...props}
+			onResult={result => {
+				hookResult = result;
+			}}
+		/>,
+	);
+
+	t.truthy(hookResult);
+
+	// Test that setMessages works
+	const newMessages: Message[] = [{role: 'user', content: 'test'}];
+	props.setMessages(newMessages);
+
+	t.is(messages.length, 1);
+	t.is(messages[0].content, 'test');
+});
+
+test('useChatHandler - callbacks are provided', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps({
+		onStartToolConfirmationFlow: () => {},
+		onConversationComplete: () => {},
+	});
+
+	render(
+		<TestHookComponent
+			{...props}
+			onResult={result => {
+				hookResult = result;
+			}}
+		/>,
+	);
+
+	t.truthy(hookResult);
+	// The hook should successfully initialize with callbacks
+	t.is(typeof props.onStartToolConfirmationFlow, 'function');
+	t.is(typeof props.onConversationComplete, 'function');
+});
+
+test('useChatHandler - streaming state types are correct', t => {
+	let hookResult: ChatHandlerReturn | null = null;
+
+	const props = createMockProps();
+
+	render(
+		<TestHookComponent
+			{...props}
+			onResult={result => {
+				hookResult = result;
+			}}
+		/>,
+	);
+
+	t.truthy(hookResult);
+
+	// Validate streaming state structure
+	const streamingState = {
+		isGenerating: hookResult!.isGenerating,
+		streamingContent: hookResult!.streamingContent,
+		tokenCount: hookResult!.tokenCount,
+	};
+
+	t.is(typeof streamingState.isGenerating, 'boolean');
+	t.is(typeof streamingState.streamingContent, 'string');
+	t.is(typeof streamingState.tokenCount, 'number');
+});

package/source/hooks/chat-handler/useChatHandler.tsx

@@ -0,0 +1,194 @@
+import {ConversationStateManager} from '@/app/utils/conversationState';
+import UserMessage from '@/components/user-message';
+import {promptHistory} from '@/prompt-history';
+import type {Message} from '@/types/core';
+import {MessageBuilder} from '@/utils/message-builder';
+import {processPromptTemplate} from '@/utils/prompt-processor';
+import React from 'react';
+import {processAssistantResponse} from './conversation/conversation-loop';
+import {createResetStreamingState} from './state/streaming-state';
+import type {ChatHandlerReturn, UseChatHandlerProps} from './types';
+import {checkContextUsage} from './utils/context-checker';
+import {displayError as displayErrorHelper} from './utils/message-helpers';
+
+/**
+ * Main chat handler hook that manages LLM conversations and tool execution.
+ * Orchestrates streaming responses, tool calls, and conversation state.
+ */
+export function useChatHandler({
+	client,
+	toolManager,
+	messages,
+	setMessages,
+	currentProvider,
+	currentModel,
+	setIsCancelling,
+	addToChatQueue,
+	componentKeyCounter,
+	abortController,
+	setAbortController,
+	developmentMode = 'normal',
+	nonInteractiveMode = false,
+	onStartToolConfirmationFlow,
+	onConversationComplete,
+}: UseChatHandlerProps): ChatHandlerReturn {
+	// Conversation state manager for enhanced context
+	const conversationStateManager = React.useRef(new ConversationStateManager());
+
+	// State for streaming message content
+	const [streamingContent, setStreamingContent] = React.useState<string>('');
+	const [isGenerating, setIsGenerating] = React.useState<boolean>(false);
+	const [tokenCount, setTokenCount] = React.useState<number>(0);
+
+	// Helper to reset all streaming state
+	const resetStreamingState = React.useCallback(
+		createResetStreamingState(
+			setIsCancelling,
+			setAbortController,
+			setIsGenerating,
+			setStreamingContent,
+			setTokenCount,
+		),
+		[], // Setters are stable and don't need to be in dependencies
+	);
+
+	// Helper to display errors in chat queue
+	const displayError = React.useCallback(
+		(error: unknown, keyPrefix: string) => {
+			displayErrorHelper(error, keyPrefix, addToChatQueue, componentKeyCounter);
+		},
+		[addToChatQueue, componentKeyCounter],
+	);
+
+	// Reset conversation state when messages are cleared
+	React.useEffect(() => {
+		if (messages.length === 0) {
+			conversationStateManager.current.reset();
+		}
+	}, [messages.length]);
+
+	// Wrapper for processAssistantResponse that includes error handling
+	const processAssistantResponseWithErrorHandling = React.useCallback(
+		async (systemMessage: Message, msgs: Message[]) => {
+			if (!client) return;
+
+			try {
+				await processAssistantResponse({
+					systemMessage,
+					messages: msgs,
+					client,
+					toolManager,
+					abortController,
+					setAbortController,
+					setIsGenerating,
+					setStreamingContent,
+					setTokenCount,
+					setMessages,
+					addToChatQueue,
+					componentKeyCounter,
+					currentModel,
+					developmentMode,
+					nonInteractiveMode,
+					conversationStateManager,
+					onStartToolConfirmationFlow,
+					onConversationComplete,
+				});
+			} catch (error) {
+				displayError(error, 'chat-error');
+				// Signal completion on error to avoid hanging in non-interactive mode
+				onConversationComplete?.();
+			} finally {
+				resetStreamingState();
+			}
+		},
+		[
+			client,
+			toolManager,
+			abortController,
+			setAbortController,
+			setMessages,
+			addToChatQueue,
+			componentKeyCounter,
+			currentModel,
+			developmentMode,
+			nonInteractiveMode,
+			onStartToolConfirmationFlow,
+			onConversationComplete,
+			displayError,
+			resetStreamingState,
+		],
+	);
+
+	// Handle chat message processing
+	const handleChatMessage = async (message: string) => {
+		if (!client || !toolManager) return;
+
+		// For display purposes, try to get the placeholder version from history
+		// This preserves the nice placeholder display in chat history
+		const history = promptHistory.getHistory();
+		const lastEntry = history[history.length - 1];
+		const displayMessage = lastEntry?.displayValue || message;
+
+		// Add user message to chat using display version (with placeholders)
+		addToChatQueue(
+			<UserMessage
+				key={`user-${componentKeyCounter}`}
+				message={displayMessage}
+			/>,
+		);
+
+		// Add user message to conversation history
+		const builder = new MessageBuilder(messages);
+		builder.addUserMessage(message);
+		const updatedMessages = builder.build();
+		setMessages(updatedMessages);
+
+		// Initialize conversation state if this is a new conversation
+		if (messages.length === 0) {
+			conversationStateManager.current.initializeState(message);
+		}
+
+		// Create abort controller for cancellation
+		const controller = new AbortController();
+		setAbortController(controller);
+
+		try {
+			// Load and process system prompt
+			const systemPrompt = processPromptTemplate();
+
+			// Create stream request
+			const systemMessage: Message = {
+				role: 'system',
+				content: systemPrompt,
+			};
+
+			// Check context usage and warn if approaching limit
+			await checkContextUsage(
+				updatedMessages,
+				systemMessage,
+				currentProvider,
+				currentModel,
+				addToChatQueue,
+				componentKeyCounter,
+			);
+
+			// Use the conversation loop
+			await processAssistantResponseWithErrorHandling(
+				systemMessage,
+				updatedMessages,
+			);
+		} catch (error) {
+			displayError(error, 'chat-error');
+		} finally {
+			resetStreamingState();
+		}
+	};
+
+	return {
+		handleChatMessage,
+		processAssistantResponse: processAssistantResponseWithErrorHandling,
+		isGenerating,
+		streamingContent,
+		tokenCount,
+	};
+}

package/source/hooks/chat-handler/utils/context-checker.spec.ts

@@ -0,0 +1,60 @@
+import test from 'ava';
+import {checkContextUsage} from './context-checker.js';
+import type {Message} from '@/types/core';
+
+// Note: This is a simple smoke test since checkContextUsage has many dependencies
+// Full integration testing would require mocking getModelContextLimit, tokenizer, etc.
+
+test('checkContextUsage - does not throw on empty messages', async t => {
+	const messages: Message[] = [];
+	const systemMessage: Message = {role: 'system', content: 'test'};
+	const addToChatQueue = () => {};
+
+	await t.notThrowsAsync(async () => {
+		await checkContextUsage(
+			messages,
+			systemMessage,
+			'test-provider',
+			'test-model',
+			addToChatQueue,
+			1,
+		);
+	});
+});
+
+test('checkContextUsage - handles unknown model gracefully', async t => {
+	const messages: Message[] = [{role: 'user', content: 'test'}];
+	const systemMessage: Message = {role: 'system', content: 'test'};
+	const addToChatQueue = () => {};
+
+	await t.notThrowsAsync(async () => {
+		await checkContextUsage(
+			messages,
+			systemMessage,
+			'unknown-provider',
+			'unknown-model',
+			addToChatQueue,
+			1,
+		);
+	});
+});
+
+test('checkContextUsage - handles errors silently', async t => {
+	const messages: Message[] = [{role: 'user', content: 'test'}];
+	const systemMessage: Message = {role: 'system', content: 'test'};
+	const addToChatQueue = () => {
+		throw new Error('Test error');
+	};
+
+	// Should not throw even if addToChatQueue throws
+	await t.notThrowsAsync(async () => {
+		await checkContextUsage(
+			messages,
+			systemMessage,
+			'test-provider',
+			'test-model',
+			addToChatQueue,
+			1,
+		);
+	});
+});

package/source/hooks/chat-handler/utils/context-checker.tsx

@@ -0,0 +1,73 @@
+import {WarningMessage} from '@/components/message-box';
+import {
+	TOKEN_THRESHOLD_CRITICAL_PERCENT,
+	TOKEN_THRESHOLD_WARNING_PERCENT,
+} from '@/constants';
+import {getModelContextLimit} from '@/models/index';
+import {createTokenizer} from '@/tokenization/index';
+import type {Message} from '@/types/core';
+import {calculateTokenBreakdown} from '@/usage/calculator';
+import type React from 'react';
+
+/**
+ * Checks context usage and displays warning if approaching limit.
+ * Shows different warnings based on TOKEN_THRESHOLD thresholds.
+ *
+ * @param allMessages - All messages to check token count for
+ * @param systemMessage - System message to include in count
+ * @param currentProvider - Current LLM provider name
+ * @param currentModel - Current model name
+ * @param addToChatQueue - Callback to add warning message to chat
+ * @param componentKeyCounter - Unique key for React component
+ */
+export const checkContextUsage = async (
+	allMessages: Message[],
+	systemMessage: Message,
+	currentProvider: string,
+	currentModel: string,
+	addToChatQueue: (component: React.ReactNode) => void,
+	componentKeyCounter: number,
+): Promise<void> => {
+	try {
+		const contextLimit = await getModelContextLimit(currentModel);
+		if (!contextLimit) return; // Unknown limit, skip check
+
+		const tokenizer = createTokenizer(currentProvider, currentModel);
+		const breakdown = calculateTokenBreakdown(
+			[systemMessage, ...allMessages],
+			tokenizer,
+		);
+
+		// Clean up tokenizer if needed
+		if (tokenizer.free) {
+			tokenizer.free();
+		}
+
+		const percentUsed = (breakdown.total / contextLimit) * 100;
+
+		// Show warning on every message once past threshold
+		if (percentUsed >= TOKEN_THRESHOLD_CRITICAL_PERCENT) {
+			addToChatQueue(
+				<WarningMessage
+					key={`context-warning-${componentKeyCounter}`}
+					message={`Context ${Math.round(
+						percentUsed,
+					)}% full (${breakdown.total.toLocaleString()}/${contextLimit.toLocaleString()} tokens). Consider using /clear to start fresh.`}
+					hideBox={true}
+				/>,
+			);
+		} else if (percentUsed >= TOKEN_THRESHOLD_WARNING_PERCENT) {
+			addToChatQueue(
+				<WarningMessage
+					key={`context-warning-${componentKeyCounter}`}
+					message={`Context ${Math.round(
+						percentUsed,
+					)}% full (${breakdown.total.toLocaleString()}/${contextLimit.toLocaleString()} tokens).`}
+					hideBox={true}
+				/>,
+			);
+		}
+	} catch {
+		// Silently ignore errors in context checking - it's not critical
+	}
+};