@gguf/coder 0.3.1 → 0.3.2

package/source/app/helpers.ts

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

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

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

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

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