@gguf/coder 0.3.0 → 0.3.1

package/source/app/helpers.ts

@@ -0,0 +1,63 @@
+import type {
+	NonInteractiveCompletionResult,
+	NonInteractiveModeState,
+} from './types';
+
+/**
+ * Helper function to determine if welcome message should be rendered
+ */
+export function shouldRenderWelcome(nonInteractiveMode?: boolean): boolean {
+	return !nonInteractiveMode;
+}
+
+/**
+ * Helper function to determine if non-interactive mode processing is complete
+ */
+export function isNonInteractiveModeComplete(
+	appState: NonInteractiveModeState,
+	startTime: number,
+	maxExecutionTimeMs: number,
+): NonInteractiveCompletionResult {
+	const isComplete =
+		!appState.isToolExecuting &&
+		!appState.isBashExecuting &&
+		!appState.isToolConfirmationMode;
+	const _hasMessages = appState.messages.length > 0;
+	const hasTimedOut = Date.now() - startTime > maxExecutionTimeMs;
+
+	// Check for error messages in the messages array
+	const hasErrorMessages = appState.messages.some(
+		(message: {role: string; content: string}) =>
+			message.role === 'error' ||
+			(typeof message.content === 'string' &&
+				message.content.toLowerCase().includes('error')),
+	);
+
+	// Check for tool approval required messages
+	const hasToolApprovalRequired = appState.messages.some(
+		(message: {role: string; content: string}) =>
+			typeof message.content === 'string' &&
+			message.content.includes('Tool approval required'),
+	);
+
+	if (hasTimedOut) {
+		return {shouldExit: true, reason: 'timeout'};
+	}
+
+	if (hasToolApprovalRequired) {
+		return {shouldExit: true, reason: 'tool-approval'};
+	}
+
+	if (hasErrorMessages) {
+		return {shouldExit: true, reason: 'error'};
+	}
+
+	// Exit when conversation is complete and either:
+	// - We have messages in history (for chat/bash commands), OR
+	// - Conversation is marked complete (for display-only commands like /mcp)
+	if (isComplete && appState.isConversationComplete) {
+		return {shouldExit: true, reason: 'complete'};
+	}
+
+	return {shouldExit: false, reason: null};
+}

package/source/app/index.ts

@@ -0,0 +1,4 @@
+// Re-export the main App component and types
+export {default} from './App';
+export type {AppProps} from './types';
+export {shouldRenderWelcome, isNonInteractiveModeComplete} from './helpers';

package/source/app/types.ts

@@ -0,0 +1,39 @@
+import type {LoggingCliConfig} from '@/utils/logging/types';
+
+/**
+ * Props for the main App component
+ */
+export interface AppProps {
+	nonInteractivePrompt?: string;
+	nonInteractiveMode?: boolean;
+	loggingConfig?: LoggingCliConfig;
+}
+
+/**
+ * Reasons for non-interactive mode completion
+ */
+export type NonInteractiveExitReason =
+	| 'complete'
+	| 'timeout'
+	| 'error'
+	| 'tool-approval'
+	| null;
+
+/**
+ * Result of checking non-interactive mode completion status
+ */
+export interface NonInteractiveCompletionResult {
+	shouldExit: boolean;
+	reason: NonInteractiveExitReason;
+}
+
+/**
+ * State required for checking non-interactive mode completion
+ */
+export interface NonInteractiveModeState {
+	isToolExecuting: boolean;
+	isBashExecuting: boolean;
+	isToolConfirmationMode: boolean;
+	isConversationComplete: boolean;
+	messages: Array<{role: string; content: string}>;
+}

package/source/app/utils/appUtils.ts

@@ -0,0 +1,294 @@
+import {parseInput} from '@/command-parser';
+import {commandRegistry} from '@/commands';
+import {ErrorMessage, InfoMessage} from '@/components/message-box';
+import ToolMessage from '@/components/tool-message';
+import {
+	DELAY_COMMAND_COMPLETE_MS,
+	TRUNCATION_RESULT_STRING_LENGTH,
+} from '@/constants';
+import {CheckpointManager} from '@/services/checkpoint-manager';
+import {toolRegistry} from '@/tools/index';
+import type {LLMClient} from '@/types/core';
+import type {Message, MessageSubmissionOptions} from '@/types/index';
+import React from 'react';
+
+export async function handleMessageSubmission(
+	message: string,
+	options: MessageSubmissionOptions,
+): Promise<void> {
+	const {
+		customCommandCache,
+		customCommandLoader,
+		customCommandExecutor,
+		onClearMessages,
+		onEnterModelSelectionMode,
+		onEnterProviderSelectionMode,
+		onEnterThemeSelectionMode,
+		onEnterModelDatabaseMode,
+		onEnterConfigWizardMode,
+		onEnterCheckpointLoadMode,
+		onShowStatus,
+		onHandleChatMessage,
+		onAddToChatQueue,
+		onCommandComplete,
+		componentKeyCounter,
+		setMessages,
+		messages,
+		setIsBashExecuting,
+		setCurrentBashCommand,
+	} = options; // Parse the input to determine its type
+	const parsedInput = parseInput(message);
+
+	// Handle bash commands (prefixed with !)
+	if (parsedInput.isBashCommand && parsedInput.bashCommand) {
+		const bashCommand = parsedInput.bashCommand;
+
+		// Set bash execution state to show spinner
+		setCurrentBashCommand(bashCommand);
+		setIsBashExecuting(true);
+
+		try {
+			// Execute the bash command
+			const resultString = await toolRegistry.execute_bash({
+				command: bashCommand,
+			});
+
+			// Parse the result
+			let result: {fullOutput: string; llmContext: string};
+			try {
+				result = JSON.parse(resultString) as {
+					fullOutput: string;
+					llmContext: string;
+				};
+			} catch {
+				// If parsing fails, treat as plain string
+				result = {
+					fullOutput: resultString,
+					llmContext:
+						resultString.length > TRUNCATION_RESULT_STRING_LENGTH
+							? resultString.substring(0, TRUNCATION_RESULT_STRING_LENGTH)
+							: resultString,
+				};
+			}
+
+			// Create a proper display of the command and its full output
+			const commandOutput = `$ ${bashCommand}
+${result.fullOutput || '(No output)'}`;
+
+			// Add the command and its output to the chat queue
+			onAddToChatQueue(
+				React.createElement(ToolMessage, {
+					key: `bash-result-${componentKeyCounter}`,
+					message: commandOutput,
+					hideBox: true,
+					isBashMode: true,
+				}),
+			);
+
+			// Add the truncated output to the LLM context for future interactions
+			if (result.llmContext) {
+				const userMessage: Message = {
+					role: 'user',
+					content: `Bash command output:\n\`\`\`\n$ ${bashCommand}\n${result.llmContext}\n\`\`\``,
+				};
+				setMessages([...messages, userMessage]);
+			}
+
+			// Clear bash execution state
+			setIsBashExecuting(false);
+			setCurrentBashCommand('');
+
+			// Signal completion for non-interactive mode
+			onCommandComplete?.();
+			return;
+		} catch (error: unknown) {
+			// Show error message if command fails
+			const errorMessage =
+				error instanceof Error ? error.message : String(error);
+			onAddToChatQueue(
+				React.createElement(ErrorMessage, {
+					key: `bash-error-${componentKeyCounter}`,
+					message: `Error executing command: ${errorMessage}`,
+				}),
+			);
+
+			// Clear bash execution state
+			setIsBashExecuting(false);
+			setCurrentBashCommand('');
+
+			// Signal completion for non-interactive mode
+			onCommandComplete?.();
+
+			// Don't send to LLM - just return here
+			return;
+		}
+	}
+
+	// Handle regular commands (prefixed with /)
+	if (message.startsWith('/')) {
+		const commandName = message.slice(1).split(' ')[0];
+
+		// Check for custom command first
+		const customCommand =
+			customCommandCache.get(commandName) ||
+			customCommandLoader?.getCommand(commandName);
+
+		if (customCommand) {
+			// Execute custom command with any arguments
+			const args = message
+				.slice(commandName.length + 1)
+				.trim()
+				.split(/\s+/)
+				.filter(arg => arg);
+			const processedPrompt = customCommandExecutor?.execute(
+				customCommand,
+				args,
+			);
+
+			// Send the processed prompt to the AI
+			if (processedPrompt) {
+				await onHandleChatMessage(processedPrompt);
+			} else {
+				// Custom command didn't generate a prompt, signal completion
+				onCommandComplete?.();
+			}
+			return;
+		} else {
+			// Handle special commands that need app state access
+			if (commandName === 'clear') {
+				await onClearMessages();
+				onCommandComplete?.();
+				// Still show the clear command result
+			} else if (commandName === 'model') {
+				onEnterModelSelectionMode();
+				onCommandComplete?.();
+				return;
+			} else if (commandName === 'provider') {
+				onEnterProviderSelectionMode();
+				onCommandComplete?.();
+				return;
+			} else if (commandName === 'theme') {
+				onEnterThemeSelectionMode();
+				onCommandComplete?.();
+				return;
+			} else if (commandName === 'model-database') {
+				onEnterModelDatabaseMode();
+				onCommandComplete?.();
+				return;
+			} else if (commandName === 'setup-config') {
+				onEnterConfigWizardMode();
+				onCommandComplete?.();
+				return;
+			} else if (commandName === 'status') {
+				onShowStatus();
+				// Status adds to queue synchronously, give React time to render
+				setTimeout(() => onCommandComplete?.(), DELAY_COMMAND_COMPLETE_MS);
+				return;
+			}
+
+			// Handle checkpoint load specially for interactive mode
+			const commandParts = message.slice(1).trim().split(/\s+/);
+			if (
+				commandParts[0] === 'checkpoint' &&
+				(commandParts[1] === 'load' || commandParts[1] === 'restore') &&
+				commandParts.length === 2
+			) {
+				// Interactive checkpoint load - no specific checkpoint name provided
+				try {
+					const manager = new CheckpointManager();
+					const checkpoints = await manager.listCheckpoints();
+
+					if (checkpoints.length === 0) {
+						onAddToChatQueue(
+							React.createElement(InfoMessage, {
+								key: `checkpoint-info-${componentKeyCounter}`,
+								message:
+									'No checkpoints available. Create one with /checkpoint create [name]',
+								hideBox: true,
+							}),
+						);
+						return;
+					}
+
+					onEnterCheckpointLoadMode(checkpoints, messages.length);
+					return;
+				} catch (error) {
+					onAddToChatQueue(
+						React.createElement(ErrorMessage, {
+							key: `checkpoint-error-${componentKeyCounter}`,
+							message: `Failed to list checkpoints: ${
+								error instanceof Error ? error.message : 'Unknown error'
+							}`,
+							hideBox: true,
+						}),
+					);
+					return;
+				}
+			}
+
+			// Execute built-in command
+			const totalTokens = messages.reduce(
+				(sum, msg) => sum + options.getMessageTokens(msg),
+				0,
+			);
+			const result = await commandRegistry.execute(message.slice(1), messages, {
+				provider: options.provider,
+				model: options.model,
+				tokens: totalTokens,
+				getMessageTokens: options.getMessageTokens,
+			});
+			if (result) {
+				// Check if result is JSX (React element)
+				// Defer adding to chat queue to avoid "Cannot update a component while rendering" error
+				if (React.isValidElement(result)) {
+					queueMicrotask(() => {
+						onAddToChatQueue(result);
+					});
+					// Give React time to render before signaling completion
+					setTimeout(() => {
+						onCommandComplete?.();
+					}, DELAY_COMMAND_COMPLETE_MS);
+				} else if (typeof result === 'string' && result.trim()) {
+					queueMicrotask(() => {
+						onAddToChatQueue(
+							React.createElement(InfoMessage, {
+								key: `command-result-${componentKeyCounter}`,
+								message: result,
+								hideBox: true,
+							}),
+						);
+					});
+					// Give React time to render before signaling completion
+					setTimeout(() => {
+						onCommandComplete?.();
+					}, DELAY_COMMAND_COMPLETE_MS);
+				} else {
+					// No output to display, signal completion immediately
+					onCommandComplete?.();
+				}
+			} else {
+				// No result, signal completion immediately
+				onCommandComplete?.();
+			}
+		}
+
+		// Return here to avoid sending to LLM
+		return;
+	}
+
+	// Regular chat message - process with AI
+	await onHandleChatMessage(message);
+}
+
+export function createClearMessagesHandler(
+	setMessages: (messages: Message[]) => void,
+	client: LLMClient | null,
+) {
+	return async () => {
+		// Clear message history and client context
+		setMessages([]);
+		if (client) {
+			await client.clearContext();
+		}
+	};
+}

package/source/app/utils/conversationState.ts

@@ -0,0 +1,310 @@
+import type {Message, ToolCall} from '@/types/core';
+
+interface ConversationProgress {
+	originalTask: string;
+	currentStep: number;
+	totalEstimatedSteps: number;
+	completedActions: string[];
+	nextAction?: string;
+	toolCallsExecuted: number;
+	lastToolCall?: ToolCall;
+	isRepeatingAction: boolean;
+	contextSummary?: string;
+}
+
+interface ConversationState {
+	progress: ConversationProgress;
+	lastAssistantMessage?: Message;
+	conversationStartTime: number;
+	toolExecutionCount: number;
+	recentToolCalls: ToolCall[];
+}
+
+export class ConversationStateManager {
+	private state: ConversationState | null = null;
+	private maxRecentToolCalls = 5;
+
+	/**
+	 * Initialize conversation state from the first user message
+	 */
+	initializeState(userMessage: string): ConversationState {
+		// Detect if this is a simple greeting to avoid over-interpreting
+		const isSimpleGreeting = this.isSimpleGreeting(userMessage);
+		this.state = {
+			progress: {
+				originalTask: userMessage,
+				currentStep: 1,
+				totalEstimatedSteps: isSimpleGreeting
+					? 1
+					: this.estimateSteps(userMessage),
+				completedActions: [],
+				toolCallsExecuted: 0,
+				isRepeatingAction: false,
+			},
+			conversationStartTime: Date.now(),
+			toolExecutionCount: 0,
+			recentToolCalls: [],
+		};
+		return this.state;
+	}
+
+	/**
+	 * Update state after tool execution
+	 */
+	updateAfterToolExecution(toolCall: ToolCall, result: string): void {
+		if (!this.state) return;
+
+		// Add to recent tool calls
+		this.state.recentToolCalls.push(toolCall);
+		if (this.state.recentToolCalls.length > this.maxRecentToolCalls) {
+			this.state.recentToolCalls.shift();
+		}
+
+		// Check for repetition
+		const isRepeating = this.detectRepetition(toolCall);
+
+		// Update progress
+		this.state.progress.toolCallsExecuted++;
+		this.state.progress.lastToolCall = toolCall;
+		this.state.progress.isRepeatingAction = isRepeating;
+		this.state.progress.currentStep++;
+
+		// Add completed action
+		const actionDescription = this.describeToolAction(toolCall, result);
+		this.state.progress.completedActions.push(actionDescription);
+
+		// Update total estimated steps if needed
+		if (
+			this.state.progress.currentStep > this.state.progress.totalEstimatedSteps
+		) {
+			this.state.progress.totalEstimatedSteps =
+				this.state.progress.currentStep + 2;
+		}
+
+		this.state.toolExecutionCount++;
+	}
+
+	/**
+	 * Update assistant message in state
+	 */
+	updateAssistantMessage(message: Message): void {
+		if (!this.state) return;
+		this.state.lastAssistantMessage = message;
+	}
+
+	/**
+	 * Generate context-aware continuation prompt
+	 */
+	generateContinuationContext(): string {
+		if (!this.state) return '';
+
+		const progress = this.state.progress;
+		let context = `[Task Progress: Step ${progress.currentStep} of ~${progress.totalEstimatedSteps}]\n`;
+		context += `[Original Task: "${progress.originalTask}"]\n\n`;
+
+		if (progress.completedActions.length > 0) {
+			context += `Recent actions completed:\n`;
+			progress.completedActions.slice(-3).forEach((action, i) => {
+				context += `${i + 1}. ${action}\n`;
+			});
+			context += '\n';
+		}
+
+		if (progress.isRepeatingAction) {
+			context += `⚠️ Warning: You may be repeating a similar action. Consider a different approach or move to the next step.\n\n`;
+		}
+
+		// Suggest next logical step
+		context += this.generateNextStepSuggestion();
+
+		context += `Continue working toward completing: "${progress.originalTask}"`;
+
+		return context;
+	}
+
+	/**
+	 * Get current state
+	 */
+	getState(): ConversationState | null {
+		return this.state;
+	}
+
+	/**
+	 * Reset state
+	 */
+	reset(): void {
+		this.state = null;
+	}
+
+	/**
+	 * Estimate number of steps for a task
+	 */
+	private estimateSteps(task: string): number {
+		const taskLower = task.toLowerCase();
+
+		// Simple heuristics based on task complexity
+		if (
+			taskLower.includes('create') ||
+			taskLower.includes('build') ||
+			taskLower.includes('implement')
+		) {
+			return 5;
+		}
+		if (
+			taskLower.includes('fix') ||
+			taskLower.includes('debug') ||
+			taskLower.includes('troubleshoot')
+		) {
+			return 4;
+		}
+		if (
+			taskLower.includes('analyze') ||
+			taskLower.includes('understand') ||
+			taskLower.includes('explain')
+		) {
+			return 3;
+		}
+		if (
+			taskLower.includes('read') ||
+			taskLower.includes('show') ||
+			taskLower.includes('list')
+		) {
+			return 2;
+		}
+
+		// Default based on length
+		return Math.max(3, Math.min(8, Math.ceil(task.length / 50)));
+	}
+
+	/**
+	 * Detect if the current tool call is repetitive
+	 */
+	private detectRepetition(toolCall: ToolCall): boolean {
+		if (!this.state || this.state.recentToolCalls.length < 2) return false;
+
+		const recentToolCalls = this.state.recentToolCalls;
+		const recent = recentToolCalls.slice(-2);
+		return recent.some(
+			prevCall =>
+				prevCall.function.name === toolCall.function.name &&
+				JSON.stringify(prevCall.function.arguments) ===
+					JSON.stringify(toolCall.function.arguments),
+		);
+	}
+
+	/**
+	 * Describe what a tool action accomplished
+	 */
+	private describeToolAction(toolCall: ToolCall, _result: string): string {
+		const toolName = toolCall.function.name;
+		const args = toolCall.function.arguments;
+
+		const getFilename = () => {
+			const filename = args.filename;
+			const path = args.path;
+			if (typeof filename === 'string') return filename;
+			if (typeof path === 'string') return path;
+			return 'unknown';
+		};
+
+		switch (toolName) {
+			case 'read_file':
+				return `Read file: ${getFilename()}`;
+			case 'write_file':
+			case 'create_file':
+				return `Created/wrote file: ${getFilename()}`;
+			case 'edit_file':
+				return `Edited file: ${getFilename()}`;
+			case 'execute_bash': {
+				const command = args.command;
+				const commandStr = typeof command === 'string' ? command : '';
+				return `Executed command: ${commandStr.substring(0, 50)}${
+					commandStr.length > 50 ? '...' : ''
+				}`;
+			}
+			default:
+				return `Used ${toolName}`;
+		}
+	}
+
+	/**
+	 * Generate intelligent next step suggestions
+	 */
+	private generateNextStepSuggestion(): string {
+		if (!this.state) return '';
+
+		const progress = this.state.progress;
+		const lastTool = progress.lastToolCall;
+
+		if (!lastTool) {
+			return 'Consider what information you need to gather first.\n\n';
+		}
+
+		const suggestions: string[] = [];
+
+		// Suggest logical next steps based on last tool
+		switch (lastTool.function.name) {
+			case 'read_file':
+				suggestions.push(
+					'Based on the file contents, determine what changes or analysis are needed.',
+				);
+				break;
+			case 'execute_bash':
+				suggestions.push(
+					'Review the command output and decide on the next action.',
+				);
+				break;
+			case 'create_file':
+			case 'write_file':
+				suggestions.push(
+					'Consider testing or verifying the file you just created.',
+				);
+				break;
+			case 'edit_file':
+				suggestions.push(
+					'Consider testing the changes or making additional modifications.',
+				);
+				break;
+			default:
+				suggestions.push('Use the tool result to inform your next action.');
+		}
+
+		// Add progress-based suggestions
+		if (progress.currentStep / progress.totalEstimatedSteps > 0.7) {
+			suggestions.push(
+				"You're near completion - focus on finalizing and testing.",
+			);
+		}
+
+		return suggestions.join(' ') + '\n\n';
+	}
+
+	/**
+	 * Detect if a message is a simple greeting to avoid over-interpreting
+	 */
+	private isSimpleGreeting(message: string): boolean {
+		const lowerMessage = message.toLowerCase().trim();
+		const greetings = [
+			'hi',
+			'hello',
+			'hey',
+			'hiya',
+			'howdy',
+			'good morning',
+			'good afternoon',
+			'good evening',
+			"what's up",
+			'whats up',
+			'sup',
+			'yo',
+		];
+
+		// Check if the entire message is just a greeting (with optional punctuation)
+		const cleanMessage = lowerMessage.replace(/[!?.,\s]+$/g, '');
+		return (
+			greetings.includes(cleanMessage) ||
+			(cleanMessage.length <= 10 &&
+				greetings.some(greeting => cleanMessage.includes(greeting)))
+		);
+	}
+}