@gguf/coder 0.3.1 → 0.3.2

package/source/hooks/useNonInteractiveMode.ts

@@ -1,140 +0,0 @@
-import {isNonInteractiveModeComplete} from '@/app/helpers';
-import type {NonInteractiveModeState} from '@/app/types';
-import {TIMEOUT_EXECUTION_MAX_MS, TIMEOUT_OUTPUT_FLUSH_MS} from '@/constants';
-import type {DevelopmentMode, LLMClient} from '@/types';
-import {getLogger} from '@/utils/logging';
-import React from 'react';
-
-interface UseNonInteractiveModeProps {
-	nonInteractivePrompt?: string;
-	nonInteractiveMode: boolean;
-	mcpInitialized: boolean;
-	client: LLMClient | null;
-	appState: NonInteractiveModeState;
-	setDevelopmentMode: (mode: DevelopmentMode) => void;
-	handleMessageSubmit: (message: string) => Promise<void>;
-}
-
-export interface NonInteractiveModeResult {
-	nonInteractiveSubmitted: boolean;
-	nonInteractiveLoadingMessage: string | null;
-}
-
-/**
- * Handles non-interactive mode logic:
- * - Automatically submits prompt when ready
- * - Sets auto-accept mode
- * - Monitors completion and exits when done
- */
-export function useNonInteractiveMode({
-	nonInteractivePrompt,
-	mcpInitialized,
-	client,
-	appState,
-	setDevelopmentMode,
-	handleMessageSubmit,
-}: UseNonInteractiveModeProps): NonInteractiveModeResult {
-	const [nonInteractiveSubmitted, setNonInteractiveSubmitted] =
-		React.useState(false);
-	const [startTime] = React.useState(Date.now());
-
-	// Auto-submit prompt when ready
-	React.useEffect(() => {
-		if (
-			nonInteractivePrompt &&
-			mcpInitialized &&
-			client &&
-			!nonInteractiveSubmitted
-		) {
-			setNonInteractiveSubmitted(true);
-			// Set auto-accept mode for non-interactive execution
-			setDevelopmentMode('auto-accept');
-			// Submit the prompt
-			void handleMessageSubmit(nonInteractivePrompt);
-		}
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [
-		nonInteractivePrompt,
-		mcpInitialized,
-		client,
-		nonInteractiveSubmitted,
-		handleMessageSubmit,
-		setDevelopmentMode,
-	]);
-
-	// Exit when processing is complete
-	React.useEffect(() => {
-		if (nonInteractivePrompt && nonInteractiveSubmitted) {
-			const {shouldExit, reason} = isNonInteractiveModeComplete(
-				appState,
-				startTime,
-				TIMEOUT_EXECUTION_MAX_MS,
-			);
-
-			if (shouldExit) {
-				const logger = getLogger();
-				if (reason === 'timeout') {
-					logger.error('Non-interactive mode timed out');
-				} else if (reason === 'error') {
-					logger.error('Non-interactive mode encountered errors');
-				} else if (reason === 'tool-approval') {
-					// Exit with error code when tool approval is required
-					// Error message already printed by useChatHandler
-				}
-				// Wait a bit to ensure all output is flushed
-				const timer = setTimeout(() => {
-					process.exit(
-						reason === 'error' || reason === 'tool-approval' ? 1 : 0,
-					);
-				}, TIMEOUT_OUTPUT_FLUSH_MS);
-
-				return () => clearTimeout(timer);
-			}
-		}
-	}, [nonInteractivePrompt, nonInteractiveSubmitted, appState, startTime]);
-
-	// Compute loading message
-	const nonInteractiveLoadingMessage = React.useMemo(() => {
-		if (!nonInteractivePrompt) {
-			return null;
-		}
-
-		// Don't show loading message when conversation is complete (about to exit)
-		if (appState.isConversationComplete) {
-			return null;
-		}
-
-		if (!mcpInitialized || !client) {
-			return 'Waiting for MCP servers...';
-		}
-
-		const pendingToolCallCount = 0; // This would need to be passed if available
-
-		if (
-			appState.isToolExecuting ||
-			appState.isToolConfirmationMode ||
-			pendingToolCallCount > 0
-		) {
-			return 'Waiting for tooling...';
-		}
-
-		if (appState.isBashExecuting) {
-			return 'Waiting for bash execution...';
-		}
-
-		return 'Waiting for chat to complete...';
-	}, [
-		nonInteractivePrompt,
-		appState.isConversationComplete,
-		mcpInitialized,
-		client,
-		appState.isToolExecuting,
-		appState.isToolConfirmationMode,
-		appState.isBashExecuting,
-	]);
-
-	return {
-		nonInteractiveSubmitted,
-		nonInteractiveLoadingMessage,
-	};
-}

package/source/hooks/useTerminalWidth.tsx

@@ -1,81 +0,0 @@
-import {DEFAULT_TERMINAL_COLUMNS} from '@/constants';
-import {useEffect, useState} from 'react';
-
-type TerminalSize = 'narrow' | 'normal' | 'wide';
-
-// Calculate box width (leave some padding and ensure minimum width)
-const calculateBoxWidth = (columns: number) =>
-	Math.max(Math.min(columns - 4, 120), 40);
-
-export const useTerminalWidth = () => {
-	const [boxWidth, setBoxWidth] = useState(() =>
-		calculateBoxWidth(process.stdout.columns || DEFAULT_TERMINAL_COLUMNS),
-	);
-
-	useEffect(() => {
-		const handleResize = () => {
-			const newWidth = calculateBoxWidth(
-				process.stdout.columns || DEFAULT_TERMINAL_COLUMNS,
-			);
-			// Only update if width actually changed
-			setBoxWidth(prevWidth => (prevWidth !== newWidth ? newWidth : prevWidth));
-		};
-
-		// Increase max listeners if needed (many components use this hook simultaneously)
-		const currentMax = process.stdout.getMaxListeners();
-		if (currentMax !== 0 && currentMax < 50) {
-			// 0 means unlimited, otherwise ensure we have enough headroom
-			process.stdout.setMaxListeners(50);
-		}
-
-		// Listen for terminal resize events
-		process.stdout.on('resize', handleResize);
-
-		return () => {
-			process.stdout.off('resize', handleResize);
-		};
-	}, []);
-
-	return boxWidth;
-};
-
-/**
- * Hook to detect terminal size category and provide responsive utilities
- * @returns Object with terminal width, size category, and utility functions
- */
-export const useResponsiveTerminal = () => {
-	const boxWidth = useTerminalWidth();
-	const actualWidth = process.stdout.columns || DEFAULT_TERMINAL_COLUMNS;
-
-	// Define breakpoints for terminal sizes
-	const getSize = (width: number): TerminalSize => {
-		if (width < 60) return 'narrow';
-		if (width < 100) return 'normal';
-		return 'wide';
-	};
-
-	const size = getSize(actualWidth);
-
-	// Utility to truncate long text with ellipsis
-	const truncate = (text: string, maxLength: number): string => {
-		if (text.length <= maxLength) return text;
-		return text.slice(0, maxLength - 3) + '...';
-	};
-
-	// Utility to truncate path intelligently (keep end of path)
-	const truncatePath = (pathStr: string, maxLength: number): string => {
-		if (pathStr.length <= maxLength) return pathStr;
-		return '...' + pathStr.slice(-(maxLength - 3));
-	};
-
-	return {
-		boxWidth,
-		actualWidth,
-		size,
-		isNarrow: size === 'narrow',
-		isNormal: size === 'normal',
-		isWide: size === 'wide',
-		truncate,
-		truncatePath,
-	};
-};

package/source/hooks/useTheme.ts

@@ -1,18 +0,0 @@
-import type {Colors, ThemePreset} from '@/types/ui';
-import {createContext, useContext} from 'react';
-
-interface ThemeContextType {
-	currentTheme: ThemePreset;
-	colors: Colors;
-	setCurrentTheme: (theme: ThemePreset) => void;
-}
-
-export const ThemeContext = createContext<ThemeContextType | null>(null);
-
-export function useTheme(): ThemeContextType {
-	const context = useContext(ThemeContext);
-	if (!context) {
-		throw new Error('useTheme must be used within a ThemeProvider');
-	}
-	return context;
-}

package/source/hooks/useToolHandler.tsx

@@ -1,349 +0,0 @@
-import { ErrorMessage, InfoMessage } from '@/components/message-box';
-import { ConversationContext } from '@/hooks/useAppState';
-import { getToolManager, processToolUse } from '@/message-handler';
-import {
-	DevelopmentMode,
-	LLMClient,
-	Message,
-	ToolCall,
-	ToolResult,
-} from '@/types/core';
-import { MessageBuilder } from '@/utils/message-builder';
-import { parseToolArguments } from '@/utils/tool-args-parser';
-import { createCancellationResults } from '@/utils/tool-cancellation';
-import { displayToolResult } from '@/utils/tool-result-display';
-
-import React from 'react';
-
-interface UseToolHandlerProps {
-	pendingToolCalls: ToolCall[];
-	currentToolIndex: number;
-	completedToolResults: ToolResult[];
-	currentConversationContext: ConversationContext | null;
-	setPendingToolCalls: (calls: ToolCall[]) => void;
-	setCurrentToolIndex: (index: number) => void;
-	setCompletedToolResults: (results: ToolResult[]) => void;
-	setCurrentConversationContext: (context: ConversationContext | null) => void;
-	setIsToolConfirmationMode: (mode: boolean) => void;
-	setIsToolExecuting: (executing: boolean) => void;
-	setMessages: (messages: Message[]) => void;
-	addToChatQueue: (component: React.ReactNode) => void;
-	componentKeyCounter: number;
-	resetToolConfirmationState: () => void;
-	onProcessAssistantResponse: (
-		systemMessage: Message,
-		messages: Message[],
-	) => Promise<void>;
-	client?: LLMClient | null;
-	currentProvider?: string;
-	setDevelopmentMode?: (mode: DevelopmentMode) => void;
-}
-
-export function useToolHandler({
-	pendingToolCalls,
-	currentToolIndex,
-	completedToolResults,
-	currentConversationContext,
-	setPendingToolCalls,
-	setCurrentToolIndex,
-	setCompletedToolResults,
-	setCurrentConversationContext,
-	setIsToolConfirmationMode,
-	setIsToolExecuting,
-	setMessages,
-	addToChatQueue,
-	componentKeyCounter,
-	resetToolConfirmationState,
-	onProcessAssistantResponse,
-	client: _client,
-	currentProvider: _currentProvider,
-	setDevelopmentMode,
-}: UseToolHandlerProps) {
-	// Continue conversation with tool results - maintains the proper loop
-	const continueConversationWithToolResults = async (
-		toolResults?: ToolResult[],
-	) => {
-		if (!currentConversationContext) {
-			resetToolConfirmationState();
-			return;
-		}
-
-		// Use passed results or fallback to state (for backwards compatibility)
-		const resultsToUse = toolResults || completedToolResults;
-
-		const { messagesBeforeToolExecution, systemMessage } =
-			currentConversationContext;
-
-		// Build updated messages with tool results
-		const builder = new MessageBuilder(messagesBeforeToolExecution);
-		builder.addToolResults(resultsToUse);
-		const updatedMessagesWithTools = builder.build();
-		setMessages(updatedMessagesWithTools);
-
-		// Reset tool confirmation state since we're continuing the conversation
-		resetToolConfirmationState();
-
-		// Continue the main conversation loop with tool results as context
-		await onProcessAssistantResponse(systemMessage, updatedMessagesWithTools);
-	};
-
-	// Handle tool confirmation
-	const handleToolConfirmation = (confirmed: boolean) => {
-		if (!confirmed) {
-			// User cancelled - close all VS Code diffs
-
-
-			// User cancelled - show message
-			addToChatQueue(
-				<InfoMessage
-					key={`tool-cancelled-${componentKeyCounter}`}
-					message="Tool execution cancelled by user"
-					hideBox={true}
-				/>,
-			);
-
-			if (!currentConversationContext) {
-				resetToolConfirmationState();
-				return;
-			}
-
-			// Create cancellation results for all pending tools
-			// This is critical to maintain conversation state integrity
-			const cancellationResults = createCancellationResults(pendingToolCalls);
-
-			const { messagesBeforeToolExecution } = currentConversationContext;
-
-			// Build updated messages with cancellation results
-			const builder = new MessageBuilder(messagesBeforeToolExecution);
-			builder.addToolResults(cancellationResults);
-			const updatedMessagesWithCancellation = builder.build();
-			setMessages(updatedMessagesWithCancellation);
-
-			// Reset state to allow user to type a new message
-			// Do NOT continue the conversation - let the user provide instructions
-			resetToolConfirmationState();
-			return;
-		}
-
-		// Move to tool execution state - this allows UI to update immediately
-		setIsToolConfirmationMode(false);
-		setIsToolExecuting(true);
-
-		// Execute tools asynchronously
-		setImmediate(() => {
-			void executeCurrentTool();
-		});
-	};
-
-	// Execute the current tool asynchronously
-	const executeCurrentTool = async () => {
-		const currentTool = pendingToolCalls[currentToolIndex];
-
-		// Check if this is an MCP tool and show appropriate messaging
-		const toolManager = getToolManager();
-		if (toolManager) {
-			const mcpInfo = toolManager.getMCPToolInfo(currentTool.function.name);
-			if (mcpInfo.isMCPTool) {
-				addToChatQueue(
-					<InfoMessage
-						key={`mcp-tool-executing-${componentKeyCounter}-${Date.now()}`}
-						message={`Executing MCP tool "${currentTool.function.name}" from server "${mcpInfo.serverName}"`}
-						hideBox={true}
-					/>,
-				);
-			}
-
-			// Run validator if available
-			const validator = toolManager.getToolValidator(currentTool.function.name);
-			if (validator) {
-				try {
-					const parsedArgs = parseToolArguments(currentTool.function.arguments);
-
-					const validationResult = await validator(parsedArgs);
-					if (!validationResult.valid) {
-						// Validation failed - show error and skip execution
-						const errorResult = {
-							tool_call_id: currentTool.id,
-							role: 'tool' as const,
-							name: currentTool.function.name,
-							content: validationResult.error,
-						};
-
-						const newResults = [...completedToolResults, errorResult];
-						setCompletedToolResults(newResults);
-
-						// Display the error
-						addToChatQueue(
-							<ErrorMessage
-								key={`tool-validation-error-${componentKeyCounter}-${Date.now()}`}
-								message={validationResult.error}
-								hideBox={true}
-							/>,
-						);
-
-						// Move to next tool or complete the process
-						if (currentToolIndex + 1 < pendingToolCalls.length) {
-							setCurrentToolIndex(currentToolIndex + 1);
-							// Return to confirmation mode for next tool
-							setIsToolExecuting(false);
-							setIsToolConfirmationMode(true);
-						} else {
-							// All tools processed, continue conversation loop with the results
-							setIsToolExecuting(false);
-							await continueConversationWithToolResults(newResults);
-						}
-						return;
-					}
-				} catch (validationError) {
-					// Validation threw an error - treat as validation failure
-					const errorResult = {
-						tool_call_id: currentTool.id,
-						role: 'tool' as const,
-						name: currentTool.function.name,
-						content: `Validation error: ${validationError instanceof Error
-								? validationError.message
-								: String(validationError)
-							}`,
-					};
-
-					const newResults = [...completedToolResults, errorResult];
-					setCompletedToolResults(newResults);
-
-					addToChatQueue(
-						<ErrorMessage
-							key={`tool-validation-error-${componentKeyCounter}-${Date.now()}`}
-							message={`Validation error: ${String(validationError)}`}
-							hideBox={true}
-						/>,
-					);
-
-					// Move to next tool or complete the process
-					if (currentToolIndex + 1 < pendingToolCalls.length) {
-						setCurrentToolIndex(currentToolIndex + 1);
-						setIsToolExecuting(false);
-						setIsToolConfirmationMode(true);
-					} else {
-						setIsToolExecuting(false);
-						await continueConversationWithToolResults(newResults);
-					}
-					return;
-				}
-			}
-		}
-
-		try {
-			// Special handling for switch_mode tool
-			if (currentTool.function.name === 'switch_mode' && setDevelopmentMode) {
-				const parsedArgs = parseToolArguments(currentTool.function.arguments);
-
-				// Actually switch the mode
-				const requestedMode = parsedArgs.mode as DevelopmentMode;
-				setDevelopmentMode(requestedMode);
-
-				addToChatQueue(
-					<InfoMessage
-						key={`mode-switched-${componentKeyCounter}-${Date.now()}`}
-						message={`Development mode switched to: ${requestedMode.toUpperCase()}`}
-						hideBox={true}
-					/>,
-				);
-			}
-
-			const result = await processToolUse(currentTool);
-
-			const newResults = [...completedToolResults, result];
-			setCompletedToolResults(newResults);
-
-			// Display the tool result
-			await displayToolResult(
-				currentTool,
-				result,
-				toolManager,
-				addToChatQueue,
-				componentKeyCounter,
-			);
-
-			// Move to next tool or complete the process
-			if (currentToolIndex + 1 < pendingToolCalls.length) {
-				setCurrentToolIndex(currentToolIndex + 1);
-				// Return to confirmation mode for next tool
-				setIsToolExecuting(false);
-				setIsToolConfirmationMode(true);
-			} else {
-				// All tools executed, continue conversation loop with the updated results
-				setIsToolExecuting(false);
-				await continueConversationWithToolResults(newResults);
-			}
-		} catch (error) {
-			setIsToolExecuting(false);
-			addToChatQueue(
-				<ErrorMessage
-					key={`tool-exec-error-${componentKeyCounter}`}
-					message={`Tool execution error: ${String(error)}`}
-				/>,
-			);
-			resetToolConfirmationState();
-		}
-	};
-
-	// Handle tool confirmation cancel
-	const handleToolConfirmationCancel = () => {
-		// Close all VS Code diffs when user cancels
-
-
-		addToChatQueue(
-			<InfoMessage
-				key={`tool-cancelled-${componentKeyCounter}`}
-				message="Tool execution cancelled by user"
-				hideBox={true}
-			/>,
-		);
-
-		if (!currentConversationContext) {
-			resetToolConfirmationState();
-			return;
-		}
-
-		// Create cancellation results for all pending tools
-		// This is critical to maintain conversation state integrity
-		const cancellationResults = createCancellationResults(pendingToolCalls);
-
-		const { messagesBeforeToolExecution } = currentConversationContext;
-
-		// Build updated messages with cancellation results
-		const builder = new MessageBuilder(messagesBeforeToolExecution);
-		builder.addToolResults(cancellationResults);
-		const updatedMessagesWithCancellation = builder.build();
-		setMessages(updatedMessagesWithCancellation);
-
-		// Reset state to allow user to type a new message
-		// Do NOT continue the conversation - let the user provide instructions
-		resetToolConfirmationState();
-	};
-
-	// Start tool confirmation flow
-	const startToolConfirmationFlow = (
-		toolCalls: ToolCall[],
-		messagesBeforeToolExecution: Message[],
-		assistantMsg: Message,
-		systemMessage: Message,
-	) => {
-		setPendingToolCalls(toolCalls);
-		setCurrentToolIndex(0);
-		setCompletedToolResults([]);
-		setCurrentConversationContext({
-			messagesBeforeToolExecution,
-			assistantMsg,
-			systemMessage,
-		});
-		setIsToolConfirmationMode(true);
-	};
-
-	return {
-		handleToolConfirmation,
-		handleToolConfirmationCancel,
-		startToolConfirmationFlow,
-		continueConversationWithToolResults,
-		executeCurrentTool,
-	};
-}

package/source/hooks/useUIState.ts

@@ -1,61 +0,0 @@
-import {Completion} from '@/types/index';
-import React, {
-	createContext,
-	useCallback,
-	useContext,
-	useMemo,
-	useState,
-} from 'react';
-
-type UIState = {
-	showClearMessage: boolean;
-	showCompletions: boolean;
-	completions: Completion[];
-	setShowClearMessage: React.Dispatch<React.SetStateAction<boolean>>;
-	setShowCompletions: React.Dispatch<React.SetStateAction<boolean>>;
-	setCompletions: React.Dispatch<React.SetStateAction<Completion[]>>;
-	resetUIState: () => void;
-};
-
-const UIStateContext = createContext<UIState | undefined>(undefined);
-
-// Existing hook that builds the UI state (kept to separate creation from context)
-function useUIState(): UIState {
-	const [showClearMessage, setShowClearMessage] = useState(false);
-	const [showCompletions, setShowCompletions] = useState(false);
-	const [completions, setCompletions] = useState<Completion[]>([]);
-
-	const resetUIState = useCallback(() => {
-		setShowClearMessage(false);
-		setShowCompletions(false);
-		setCompletions([]);
-	}, []);
-
-	return useMemo(
-		() => ({
-			showClearMessage,
-			showCompletions,
-			completions,
-			setShowClearMessage,
-			setShowCompletions,
-			setCompletions,
-			resetUIState,
-		}),
-		[showClearMessage, showCompletions, completions, resetUIState],
-	);
-}
-
-// Provider to expose a single shared UI state instance to the subtree
-export function UIStateProvider({children}: {children: React.ReactNode}) {
-	const state = useUIState();
-	return React.createElement(UIStateContext.Provider, {value: state}, children);
-}
-
-// Hook to consume the shared UI state from context (preferred for consumers)
-export function useUIStateContext(): UIState {
-	const ctx = useContext(UIStateContext);
-	if (!ctx) {
-		throw new Error('useUIStateContext must be used within a UIStateProvider');
-	}
-	return ctx;
-}