@gguf/coder 0.3.1 → 0.3.2

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

@@ -1,19 +0,0 @@
-/**
- * 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

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

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

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

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

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