@gguf/coder 0.2.9 → 0.3.1

package/source/hooks/useNonInteractiveMode.ts

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

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

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

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

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