@gguf/coder 0.3.0 → 0.3.1

package/source/utils/message-builder.ts

@@ -0,0 +1,101 @@
+import type {Message, ToolResult} from '@/types/core';
+
+/**
+ * Builder pattern for constructing message arrays.
+ * Provides a fluent interface for adding messages without side effects.
+ * This ensures messages are only added to state once, preventing duplication.
+ */
+export class MessageBuilder {
+	private messages: Message[];
+
+	constructor(initialMessages: Message[]) {
+		this.messages = [...initialMessages];
+	}
+
+	/**
+	 * Add auto-executed messages from AI SDK multi-step execution.
+	 * These include both assistant messages (with tool_calls) and tool result messages.
+	 */
+	addAutoExecutedMessages(autoMessages: Message[]): this {
+		this.messages.push(...autoMessages);
+		return this;
+	}
+
+	/**
+	 * Add an assistant message (with or without tool_calls).
+	 */
+	addAssistantMessage(msg: Message): this {
+		if (msg.role !== 'assistant') {
+			throw new Error(
+				'addAssistantMessage requires a message with role "assistant"',
+			);
+		}
+		this.messages.push(msg);
+		return this;
+	}
+
+	/**
+	 * Add tool result messages from tool execution.
+	 */
+	addToolResults(results: ToolResult[]): this {
+		const toolMessages: Message[] = results.map(result => ({
+			role: 'tool' as const,
+			content: result.content || '',
+			tool_call_id: result.tool_call_id,
+			name: result.name,
+		}));
+		this.messages.push(...toolMessages);
+		return this;
+	}
+
+	/**
+	 * Add a user message.
+	 */
+	addUserMessage(content: string): this {
+		this.messages.push({
+			role: 'user',
+			content,
+		});
+		return this;
+	}
+
+	/**
+	 * Add an error message as a user message (for model self-correction).
+	 */
+	addErrorMessage(errorContent: string): this {
+		this.messages.push({
+			role: 'user',
+			content: errorContent,
+		});
+		return this;
+	}
+
+	/**
+	 * Add an arbitrary message (use sparingly, prefer specific methods).
+	 */
+	addMessage(message: Message): this {
+		this.messages.push(message);
+		return this;
+	}
+
+	/**
+	 * Build and return the final messages array.
+	 */
+	build(): Message[] {
+		return this.messages;
+	}
+
+	/**
+	 * Get the current length of the messages array.
+	 */
+	get length(): number {
+		return this.messages.length;
+	}
+
+	/**
+	 * Check if the builder has any messages.
+	 */
+	get isEmpty(): boolean {
+		return this.messages.length === 0;
+	}
+}

package/source/utils/message-queue.tsx

@@ -0,0 +1,486 @@
+import {
+	ErrorMessage,
+	InfoMessage,
+	SuccessMessage,
+	WarningMessage,
+} from '@/components/message-box';
+import {TIMEOUT_MESSAGE_PROCESSING_MS} from '@/constants';
+import type {MessageType} from '@/types/index';
+import {createErrorInfo} from '@/utils/error-formatter';
+// Import logging utilities with dependency injection pattern
+import {
+	calculateMemoryDelta,
+	endMetrics,
+	formatMemoryUsage,
+	generateCorrelationId,
+	startMetrics,
+	withNewCorrelationContext,
+} from '@/utils/logging';
+import React from 'react';
+
+// Global message queue function - will be set by App component
+let globalAddToChatQueue: ((component: React.ReactNode) => void) | null = null;
+let componentKeyCounter = 0;
+
+// Get logger instance to avoid circular dependencies
+import {getLogger} from '@/utils/logging';
+const logger = getLogger();
+
+// Set the global chat queue function
+export function setGlobalMessageQueue(
+	addToChatQueue: (component: React.ReactNode) => void,
+) {
+	logger.info('Global message queue initialized', {
+		hasPreviousQueue: !!globalAddToChatQueue,
+	});
+	globalAddToChatQueue = addToChatQueue;
+}
+
+// Helper function to generate stable keys
+function getNextKey(): string {
+	componentKeyCounter++;
+	return `global-msg-${componentKeyCounter}`;
+}
+
+// Enhanced message metadata for tracking and debugging
+export interface MessageMetadata {
+	id: string;
+	type: MessageType;
+	timestamp: string;
+	correlationId?: string;
+	duration?: number;
+	source?: string;
+	context?: Record<string, unknown>;
+	performanceMetrics?: {
+		duration: number;
+		memoryDelta: number;
+	};
+}
+
+// Message queue statistics for monitoring
+export interface MessageQueueStats {
+	totalMessages: number;
+	messagesByType: Record<MessageType, number>;
+	averageRenderTime: number;
+	lastMessageTime: string;
+	errorsLogged: number;
+}
+
+// Global message statistics
+let messageStats: MessageQueueStats = {
+	totalMessages: 0,
+	messagesByType: {
+		info: 0,
+		success: 0,
+		warning: 0,
+		error: 0,
+	},
+	averageRenderTime: 0,
+	lastMessageTime: '',
+	errorsLogged: 0,
+};
+
+// Add a React component directly to the queue
+export function addToMessageQueue(component: React.ReactNode) {
+	if (!globalAddToChatQueue) {
+		console.log('[message-queue] Queue not available, component not added');
+		return;
+	}
+	globalAddToChatQueue(component);
+}
+
+// Add typed message to chat queue (internal helper) with enhanced logging and metadata
+function addTypedMessage(
+	type: MessageType,
+	message: string,
+	hideBox: boolean = true,
+	options?: {
+		correlationId?: string;
+		source?: string;
+		context?: Record<string, unknown>;
+		error?: unknown;
+	},
+) {
+	const correlationId = options?.correlationId || generateCorrelationId();
+	const metrics = startMetrics();
+	const timestamp = new Date().toISOString();
+
+	return withNewCorrelationContext(() => {
+		// Log the message to structured logging system
+		logger[
+			type === 'error'
+				? 'error'
+				: type === 'warning'
+					? 'warn'
+					: type === 'success'
+						? 'info'
+						: 'info'
+		](`Message queued: ${type.toUpperCase()}`, {
+			messageType: type,
+			message: message.substring(0, 200), // Truncate long messages for logs
+			hideBox,
+			source: options?.source || 'unknown',
+			context: options?.context,
+			correlationId,
+			hasGlobalQueue: !!globalAddToChatQueue,
+			messageId: `msg-${componentKeyCounter + 1}`,
+		});
+
+		// Log error details if provided
+		if (options?.error && type === 'error') {
+			const errorInfo = createErrorInfo(
+				options.error,
+				options.context,
+				correlationId,
+			);
+			logger.error('Message queue error details', {
+				errorInfo,
+				correlationId,
+			});
+		}
+
+		// Update statistics
+		messageStats.totalMessages++;
+		messageStats.messagesByType[type]++;
+		messageStats.lastMessageTime = timestamp;
+		if (type === 'error') {
+			messageStats.errorsLogged++;
+		}
+
+		// Fallback to structured logging if queue not available
+		if (!globalAddToChatQueue) {
+			logger.warn(
+				'Message queue not available, using structured logging fallback',
+				{
+					messageType: type,
+					message: message.substring(0, 100),
+					correlationId,
+				},
+			);
+
+			// Use structured logging instead of console
+			if (type === 'error') {
+				logger.error(message, {
+					correlationId,
+					source: 'message-queue-fallback',
+				});
+			} else if (type === 'warning') {
+				logger.warn(message, {correlationId, source: 'message-queue-fallback'});
+			} else {
+				logger.info(message, {correlationId, source: 'message-queue-fallback'});
+			}
+			return;
+		}
+
+		const key = getNextKey();
+		let component: React.ReactNode;
+
+		switch (type) {
+			case 'error':
+				component = (
+					<ErrorMessage key={key} message={message} hideBox={hideBox} />
+				);
+				break;
+			case 'success':
+				component = (
+					<SuccessMessage key={key} message={message} hideBox={hideBox} />
+				);
+				break;
+			case 'warning':
+				component = (
+					<WarningMessage key={key} message={message} hideBox={hideBox} />
+				);
+				break;
+			case 'info':
+			default:
+				component = (
+					<InfoMessage key={key} message={message} hideBox={hideBox} />
+				);
+				break;
+		}
+
+		// Track performance metrics
+		const finalMetrics = endMetrics(metrics);
+		const memoryDelta = calculateMemoryDelta(
+			// biome-ignore lint/style/noNonNullAssertion: memoryUsage is always defined after endMetrics
+			metrics.memoryUsage!,
+			// biome-ignore lint/style/noNonNullAssertion: memoryUsage is always defined after endMetrics
+			finalMetrics.memoryUsage!,
+		);
+
+		logger.debug('Message component created', {
+			messageType: type,
+			componentKey: key,
+			renderTime: `${finalMetrics.duration.toFixed(2)}ms`,
+			memoryDelta: formatMemoryUsage(
+				memoryDelta as unknown as NodeJS.MemoryUsage,
+			),
+			correlationId,
+		});
+
+		// Add to global queue
+		globalAddToChatQueue(component);
+	}, correlationId);
+}
+
+// Enhanced convenience functions with additional context
+export function logInfo(
+	message: string,
+	hideBox: boolean = true,
+	options?: {
+		source?: string;
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic format args
+		context?: Record<string, any>;
+		correlationId?: string;
+	},
+) {
+	addTypedMessage('info', message, hideBox, {
+		...options,
+		source: options?.source || 'logInfo',
+	});
+}
+
+export function logError(
+	message: string,
+	hideBox: boolean = true,
+	options?: {
+		source?: string;
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic format args
+		context?: Record<string, any>;
+		correlationId?: string;
+		error?: unknown;
+	},
+) {
+	addTypedMessage('error', message, hideBox, {
+		...options,
+		source: options?.source || 'logError',
+	});
+}
+
+export function logSuccess(
+	message: string,
+	hideBox: boolean = true,
+	options?: {
+		source?: string;
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic format args
+		context?: Record<string, any>;
+		correlationId?: string;
+	},
+) {
+	addTypedMessage('success', message, hideBox, {
+		...options,
+		source: options?.source || 'logSuccess',
+	});
+}
+
+export function logWarning(
+	message: string,
+	hideBox: boolean = true,
+	options?: {
+		source?: string;
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic format args
+		context?: Record<string, any>;
+		correlationId?: string;
+	},
+) {
+	addTypedMessage('warning', message, hideBox, {
+		...options,
+		source: options?.source || 'logWarning',
+	});
+}
+
+// Specialized logging functions for common scenarios
+export function logApiCall(
+	method: string,
+	url: string,
+	statusCode: number,
+	duration: number,
+	options?: {
+		requestSize?: number;
+		responseSize?: number;
+		correlationId?: string;
+	},
+) {
+	const correlationId = options?.correlationId || generateCorrelationId();
+
+	withNewCorrelationContext(() => {
+		if (statusCode >= 400) {
+			logError(`API ${method} ${url} failed (${statusCode})`, false, {
+				source: 'api-call',
+				correlationId,
+				context: {
+					method,
+					url,
+					statusCode,
+					duration: `${duration}ms`,
+					requestSize: options?.requestSize,
+					responseSize: options?.responseSize,
+				},
+			});
+		} else {
+			logInfo(`API ${method} ${url} completed (${statusCode})`, true, {
+				source: 'api-call',
+				correlationId,
+				context: {
+					method,
+					url,
+					statusCode,
+					duration: `${duration}ms`,
+					requestSize: options?.requestSize,
+					responseSize: options?.responseSize,
+				},
+			});
+		}
+	}, correlationId);
+}
+
+export function logToolExecution(
+	toolName: string,
+	status: 'started' | 'completed' | 'failed',
+	duration?: number,
+	options?: {
+		correlationId?: string;
+		error?: unknown;
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic format args
+		context?: Record<string, any>;
+	},
+) {
+	const correlationId = options?.correlationId || generateCorrelationId();
+	const context = {
+		toolName,
+		status,
+		duration: duration ? `${duration}ms` : undefined,
+		...options?.context,
+	};
+
+	switch (status) {
+		case 'started':
+			logInfo(`Tool execution started: ${toolName}`, true, {
+				source: 'tool-execution',
+				correlationId,
+				context,
+			});
+			break;
+		case 'completed':
+			logSuccess(`Tool execution completed: ${toolName}`, true, {
+				source: 'tool-execution',
+				correlationId,
+				context,
+			});
+			break;
+		case 'failed':
+			logError(`Tool execution failed: ${toolName}`, false, {
+				source: 'tool-execution',
+				correlationId,
+				context,
+				error: options?.error,
+			});
+			break;
+	}
+}
+
+export function logUserAction(
+	action: string,
+	// biome-ignore lint/suspicious/noExplicitAny: Dynamic details type
+	details?: Record<string, any>,
+	options?: {
+		correlationId?: string;
+	},
+) {
+	logInfo(`User action: ${action}`, true, {
+		source: 'user-action',
+		correlationId: options?.correlationId,
+		context: {
+			action,
+			...details,
+		},
+	});
+}
+
+// Get current message queue statistics
+export function getMessageQueueStats(): MessageQueueStats {
+	return {...messageStats};
+}
+
+// Reset message queue statistics
+export function resetMessageQueueStats() {
+	messageStats = {
+		totalMessages: 0,
+		messagesByType: {
+			info: 0,
+			success: 0,
+			warning: 0,
+			error: 0,
+		},
+		averageRenderTime: 0,
+		lastMessageTime: '',
+		errorsLogged: 0,
+	};
+
+	logger.info('Message queue statistics reset', {
+		correlationId: generateCorrelationId(),
+	});
+}
+
+// Log current message queue statistics
+export function logMessageQueueStats() {
+	logger.info('Message queue statistics', {
+		stats: messageStats,
+		correlationId: generateCorrelationId(),
+	});
+}
+
+// Enhanced message queue health check
+export function checkMessageQueueHealth(): {
+	isHealthy: boolean;
+	issues: string[];
+	stats: MessageQueueStats;
+} {
+	const issues: string[] = [];
+
+	// Check if queue is initialized
+	if (!globalAddToChatQueue) {
+		issues.push('Global message queue not initialized');
+	}
+
+	// Check error rate
+	const errorRate =
+		messageStats.totalMessages > 0
+			? (messageStats.errorsLogged / messageStats.totalMessages) * 100
+			: 0;
+
+	if (errorRate > 20) {
+		// More than 20% errors is concerning
+		issues.push(`High error rate: ${errorRate.toFixed(1)}%`);
+	}
+
+	// Check if messages are being processed
+	if (messageStats.lastMessageTime) {
+		const lastMessageAge =
+			Date.now() - new Date(messageStats.lastMessageTime).getTime();
+
+		if (
+			lastMessageAge > TIMEOUT_MESSAGE_PROCESSING_MS &&
+			messageStats.totalMessages > 0
+		) {
+			issues.push(
+				`No messages for ${Math.round(lastMessageAge / 60000)} minutes`,
+			);
+		}
+	}
+
+	const isHealthy = issues.length === 0;
+
+	logger.debug('Message queue health check', {
+		isHealthy,
+		issues,
+		stats: messageStats,
+		correlationId: generateCorrelationId(),
+	});
+
+	return {
+		isHealthy,
+		issues,
+		stats: messageStats,
+	};
+}

package/source/utils/paste-detection.spec.ts

@@ -0,0 +1,69 @@
+import test from 'ava';
+import {PasteDetector} from './paste-detection';
+
+// Tests for PasteDetector class
+// Validates CLI paste detection logic
+
+console.log(`\npaste-detection.spec.ts`);
+
+test('PasteDetector detects rapid input as paste', t => {
+	const detector = new PasteDetector();
+
+	// Simulate rapid input - use 110 chars to exceed 50*2=100 threshold
+	const result = detector.detectPaste('a'.repeat(110));
+
+	t.true(result.isPaste);
+	t.is(result.method, 'size'); // Large input detected as paste
+	t.is(result.addedText, 'a'.repeat(110));
+});
+
+test('PasteDetector detects multi-line input as paste', t => {
+	const detector = new PasteDetector();
+
+	const multiLineText = 'line1\nline2\nline3\nline4';
+	const result = detector.detectPaste(multiLineText);
+
+	t.true(result.isPaste);
+	// With low thresholds, size method triggers first (25 chars > 1*2 = 2)
+	// but still correctly detected as paste
+	t.true(['size', 'lines'].includes(result.method));
+	t.is(result.addedText, multiLineText);
+});
+
+test('PasteDetector detects small paste', t => {
+	const detector = new PasteDetector();
+
+	// 15 characters - enough to trigger size detection (> 5*2 = 10)
+	const result = detector.detectPaste('small paste txt');
+
+	t.true(result.isPaste);
+	t.is(result.method, 'size'); // 15 chars > 5*2 = 10
+});
+
+test('PasteDetector does not detect manual typing', async t => {
+	const detector = new PasteDetector();
+
+	// First input - 5 chars, below 10-char size threshold
+	const result1 = detector.detectPaste('hello');
+	t.false(result1.isPaste);
+	t.is(result1.method, 'none');
+
+	// Wait to simulate human typing speed (not a paste)
+	await new Promise(resolve => setTimeout(resolve, 100));
+
+	// Add more text (incremental) - adds " world" (6 chars), still below threshold
+	const result2 = detector.detectPaste('hello world');
+	t.false(result2.isPaste);
+	t.is(result2.addedText, ' world');
+	t.is(result2.method, 'none');
+});
+
+test('PasteDetector reset clears state', t => {
+	const detector = new PasteDetector();
+
+	detector.detectPaste('some text');
+	detector.reset();
+
+	const result = detector.detectPaste('new text');
+	t.is(result.addedText, 'new text'); // Should be full text, not just diff
+});