@gguf/coder 0.2.9 → 0.3.1

package/source/utils/logging/transports.ts

@@ -0,0 +1,305 @@
+/**
+ * Transport configuration for different output destinations
+ */
+
+import {join} from 'path';
+import {BUFFER_LOG_BYTES, INTERVAL_LOG_FLUSH_MS} from '@/constants';
+import {getDefaultLogDirectory} from './config.js';
+import type {TransportConfig} from './types.js';
+
+// Type definition for Pino transport target
+type TransportTarget = {
+	target: string;
+	options?: Record<string, unknown>;
+	level?: string;
+};
+
+/**
+ * Create a development transport with pretty printing
+ */
+export function createDevelopmentTransport(): TransportTarget {
+	return {
+		target: 'pino-pretty',
+		level: 'debug',
+		options: {
+			colorize: true,
+			translateTime: 'HH:MM:ss Z',
+			ignore: 'pid,hostname',
+			levelFirst: true,
+			messageFormat: '{levelLabel} - {msg}',
+			customPrettifiers: {
+				time: (timestamp: number) => {
+					return new Date(timestamp).toLocaleTimeString('en-US', {
+						hour12: false,
+						timeZone: 'UTC',
+					});
+				},
+			},
+			singleLine: false,
+		},
+	};
+}
+
+/**
+ * Create a production transport with file rotation
+ */
+export function createProductionTransport(
+	logDir: string = getDefaultLogDirectory(),
+): TransportTarget {
+	return {
+		target: 'pino-roll',
+		level: 'info',
+		options: {
+			file: join(logDir, 'coder-%Y-%m-%d.log'), // nosemgrep
+			frequency: 'daily',
+			size: '100m',
+			dateFormat: 'yyyy-MM-dd',
+			extension: '.log',
+			symlink: true,
+			mkdir: true,
+			compress: true,
+			sync: false,
+			limit: {
+				count: 30,
+				removeOtherLogFiles: true,
+			},
+			minLength: 4096,
+			maxLength: 1048576, // 1MB
+			periodicFlush: INTERVAL_LOG_FLUSH_MS,
+		},
+	};
+}
+
+/**
+ * Create a test transport that outputs to /dev/null
+ */
+export function createTestTransport(): TransportTarget {
+	return {
+		target: 'pino/file',
+		level: 'silent',
+		options: {
+			destination: '/dev/null',
+		},
+	};
+}
+
+/**
+ * Create a custom transport for specific needs
+ */
+export function createCustomTransport(
+	config: TransportConfig,
+): TransportTarget {
+	return {
+		target: config.target,
+		level: (config.options as {level?: string})?.level || 'info',
+		options: {
+			...config.options,
+			// Ensure minimum buffer size for performance
+			minLength: config.options.minLength || 4096,
+			// Set maximum buffer size to prevent memory issues
+			maxLength: config.options.maxLength || 1048576,
+		},
+	};
+}
+
+/**
+ * Create a multi-transport configuration
+ */
+export function createMultiTransport(): TransportTarget[] {
+	const transports: TransportTarget[] = [];
+	const env = process.env.NODE_ENV || 'development';
+
+	// Always include console output for development
+	if (env !== 'production') {
+		transports.push(createDevelopmentTransport());
+	}
+
+	// Add file output for production or when explicitly enabled
+	if (env === 'production' || process.env.CODER_LOG_TO_FILE === 'true') {
+		transports.push(createProductionTransport());
+	}
+
+	return transports;
+}
+
+/**
+ * Create a transport with buffering for high-performance scenarios
+ */
+export function createBufferedTransport(
+	baseTransport: TransportTarget,
+	bufferSize: number = BUFFER_LOG_BYTES,
+): TransportTarget {
+	return {
+		...baseTransport,
+		options: {
+			...baseTransport.options,
+			// Use sonic-boom for high-performance buffering
+			bufferSize,
+			// Enable async writing
+			sync: false,
+		},
+	};
+}
+
+/**
+ * Create a transport for error-specific logging
+ */
+export function createErrorTransport(
+	logDir: string = getDefaultLogDirectory(),
+): TransportTarget {
+	return {
+		target: 'pino-roll',
+		level: 'error',
+		options: {
+			file: join(logDir, 'coder-error-%Y-%m-%d.log'), // nosemgrep
+			frequency: 'daily',
+			size: '50m', // Smaller files for errors
+			dateFormat: 'yyyy-MM-dd',
+			extension: '.log',
+			mkdir: true,
+			compress: true,
+			sync: true, // Sync writes for errors to ensure they're logged
+			limit: {
+				count: 90, // Keep more error logs
+				removeOtherLogFiles: true,
+			},
+			minLength: 1024,
+			maxLength: 1048576,
+		},
+	};
+}
+
+/**
+ * Create a transport for audit logging
+ */
+export function createAuditTransport(
+	logDir: string = getDefaultLogDirectory(),
+): TransportTarget {
+	return {
+		target: 'pino-roll',
+		level: 'info',
+		options: {
+			file: join(logDir, 'coder-audit-%Y-%m-%d.log'), // nosemgrep
+			frequency: 'daily',
+			size: '200m',
+			dateFormat: 'yyyy-MM-dd',
+			extension: '.log',
+			mkdir: true,
+			compress: true,
+			sync: true, // Sync writes for audit logs
+			limit: {
+				count: 365, // Keep 1 year of audit logs
+				removeOtherLogFiles: false,
+			},
+			minLength: 1024,
+			maxLength: 10485760, // 10MB for audit logs
+		},
+	};
+}
+
+/**
+ * Get transport configuration based on environment variables
+ */
+export function getTransportFromEnvironment():
+	| TransportTarget
+	| TransportTarget[] {
+	// Support multiple transports via comma separation
+	const transportTypes = (process.env.CODER_LOG_TRANSPORTS || 'default')
+		.split(',')
+		.map(t => t.trim());
+	const transports: TransportTarget[] = [];
+
+	for (const transportType of transportTypes) {
+		switch (transportType) {
+			case 'development':
+			case 'dev':
+				transports.push(createDevelopmentTransport());
+				break;
+
+			case 'production':
+			case 'prod':
+				transports.push(createProductionTransport());
+				break;
+
+			case 'test':
+				transports.push(createTestTransport());
+				break;
+
+			case 'error':
+				transports.push(createErrorTransport());
+				break;
+
+			case 'audit':
+				transports.push(createAuditTransport());
+				break;
+
+			case 'default':
+			default:
+				// Use default behavior
+				{
+					const defaultTransports = createMultiTransport();
+					transports.push(...defaultTransports);
+				}
+				break;
+		}
+	}
+
+	// Return single transport if only one, otherwise return array
+	return transports.length === 1 ? transports[0] : transports;
+}
+
+/**
+ * Validate transport configuration
+ */
+export function validateTransport(transport: TransportTarget): boolean {
+	if (!transport.target) {
+		console.error('[ERROR] Transport target is required');
+		return false;
+	}
+
+	// Validate target is a string or function
+	if (
+		typeof transport.target !== 'string' &&
+		typeof transport.target !== 'function'
+	) {
+		console.error('[ERROR] Transport target must be a string or function');
+		return false;
+	}
+
+	// Validate options if present
+	if (transport.options && typeof transport.options !== 'object') {
+		console.error('[ERROR] Transport options must be an object');
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Create transport with error handling and fallback
+ */
+export function createSafeTransport(
+	primaryTransport: TransportTarget,
+	fallbackTransport?: TransportTarget,
+): TransportTarget {
+	try {
+		if (!validateTransport(primaryTransport)) {
+			throw new Error('Invalid primary transport configuration');
+		}
+
+		return primaryTransport;
+	} catch (error) {
+		console.error('[ERROR] Failed to create primary transport:', error);
+
+		if (fallbackTransport) {
+			console.warn('[WARN] Falling back to secondary transport');
+			if (validateTransport(fallbackTransport)) {
+				return fallbackTransport;
+			}
+		}
+
+		// Ultimate fallback to console
+		console.warn('[WARN] Falling back to console transport');
+		return createDevelopmentTransport();
+	}
+}

package/source/utils/logging/types.ts

@@ -0,0 +1,216 @@
+/**
+ * Type definitions for the structured logging system
+ */
+
+export type LogLevel =
+	| 'silent'
+	| 'fatal'
+	| 'error'
+	| 'warn'
+	| 'info'
+	| 'http'
+	| 'debug'
+	| 'trace';
+
+export interface LoggerConfig {
+	level: LogLevel;
+	destination?: string;
+	pretty: boolean;
+	redact: string[];
+	correlation: boolean;
+	serialize: boolean;
+	transport?: unknown;
+}
+
+export interface LogEntry {
+	level: LogLevel;
+	time: string;
+	pid: number;
+	hostname: string;
+	correlationId?: string;
+	nodeVersion?: string; // NEW: Node.js version field
+	platform?: string; // NEW: platform field
+	arch?: string; // NEW: architecture field
+	service?: string; // NEW: service field
+	version?: string; // NEW: version field
+	environment?: string; // NEW: environment field
+	msg: string;
+	[key: string]: unknown;
+}
+
+// Enhanced logger configuration types
+export interface EnhancedLoggerConfig extends LoggerConfig {
+	options?: EnhancedTransportOptions;
+	[key: string]: unknown;
+}
+
+export interface EnhancedTransportOptions {
+	destination?: string | number;
+	level?: LogLevel;
+	translateTime?: string;
+	ignore?: string;
+	messageFormat?: string;
+	customPrettifiers?: Record<string, (data: unknown) => string>;
+	levelFirst?: boolean;
+	singleLine?: boolean;
+	colorize?: boolean;
+	[key: string]: unknown;
+}
+
+export interface Logger {
+	fatal: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+	error: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+	warn: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+	info: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+	http: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+	debug: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+	trace: ((msg: string, ...args: unknown[]) => void) &
+		((obj: object, msg?: string) => void);
+
+	child(bindings: Record<string, unknown>): Logger;
+	isLevelEnabled(level: LogLevel): boolean;
+	flush(): Promise<void>;
+	end(): Promise<void>;
+}
+
+export interface PiiRedactionRules {
+	patterns: RegExp[];
+	customPaths: string[];
+	emailRedaction: boolean;
+	userIdRedaction: boolean;
+}
+
+export interface CorrelationContext {
+	id: string;
+	parentId?: string;
+	metadata?: Record<string, unknown>;
+}
+
+export interface CorrelationMetadata {
+	source?: string;
+	version?: string;
+	environment?: string;
+	requestId?: string;
+	[key: string]: unknown;
+}
+
+export interface PerformanceMetrics {
+	startTime: number;
+	duration?: number;
+	memoryUsage?: NodeJS.MemoryUsage;
+	cpuUsage?: NodeJS.CpuUsage;
+}
+
+export interface TransportConfig {
+	target: string;
+	options: {
+		destination?: string;
+		level?: LogLevel;
+		formatters?: Record<string, (data: unknown) => unknown>;
+		redact?: string[];
+		frequency?: string | number;
+		size?: string | number;
+		limit?: {
+			count: number;
+			removeOtherLogFiles?: boolean;
+		};
+		dateFormat?: string;
+		extension?: string;
+		symlink?: boolean;
+		mkdir?: boolean;
+		compress?: boolean;
+		sync?: boolean;
+		minLength?: number;
+		maxLength?: number;
+		periodicFlush?: number;
+	};
+}
+
+/**
+ * CLI configuration for logging control
+ */
+export interface LoggingCliConfig {
+	logToFile?: boolean;
+	logToConsole?: boolean;
+	noLogFile?: boolean;
+	noLogConsole?: boolean;
+}
+
+/**
+ * Environment-specific transport configuration
+ */
+export interface EnvironmentTransportConfig {
+	enableFile: boolean;
+	enableConsole: boolean;
+}
+
+/**
+ * Pino transport options type
+ */
+export interface PinoTransportOptions {
+	target: string;
+	options?: {
+		destination?: string;
+		mkdir?: boolean;
+		append?: boolean;
+		[key: string]: unknown;
+	};
+}
+
+/**
+ * Type for console method arguments
+ */
+export type ConsoleArgument =
+	| string
+	| number
+	| boolean
+	| null
+	| undefined
+	| Error
+	| Record<string, unknown>
+	| Array<unknown>;
+
+/**
+ * Type for console method arguments array
+ */
+export type ConsoleArguments = ConsoleArgument[];
+
+/**
+ * Typed object for console log data
+ */
+export interface ConsoleLogData extends Record<string, unknown> {
+	correlationId: string;
+	source: string;
+	argumentCount?: number;
+	stringArgs?: number;
+	objectArgs?: number;
+	primitiveArgs?: number;
+	objects?: unknown[];
+	errorLikeObjects?: unknown[];
+	moduleName?: string;
+	allArgs?: ConsoleArguments;
+}
+
+/**
+ * Type for HTTP request object in correlation tracking
+ */
+export interface CorrelationHttpRequest {
+	method?: string;
+	url?: string;
+	headers?: Record<string, string>;
+}
+
+/**
+ * Type for HTTP response object in correlation tracking
+ */
+export interface CorrelationHttpResponse {
+	statusCode?: number;
+	headers?: Record<string, string>;
+	setHeader?: (name: string, value: string) => void;
+}

package/source/utils/message-builder.spec.ts

@@ -0,0 +1,179 @@
+import test from 'ava';
+import {MessageBuilder} from './message-builder.js';
+import type {Message, ToolResult} from '@/types/core';
+
+test('MessageBuilder starts with initial messages', t => {
+	const userMsg: Message = {role: 'user', content: 'Hello'};
+	const builder = new MessageBuilder([userMsg]);
+
+	const messages = builder.build();
+
+	t.is(messages.length, 1);
+	t.deepEqual(messages[0], userMsg);
+});
+
+test('MessageBuilder addAssistantMessage adds assistant message', t => {
+	const builder = new MessageBuilder([]);
+	const assistantMsg: Message = {
+		role: 'assistant',
+		content: 'Hi there',
+	};
+
+	builder.addAssistantMessage(assistantMsg);
+	const messages = builder.build();
+
+	t.is(messages.length, 1);
+	t.is(messages[0].role, 'assistant');
+	t.is(messages[0].content, 'Hi there');
+});
+
+test('MessageBuilder addAssistantMessage throws on non-assistant message', t => {
+	const builder = new MessageBuilder([]);
+	const userMsg: Message = {role: 'user', content: 'Test'};
+
+	t.throws(
+		() => {
+			builder.addAssistantMessage(userMsg);
+		},
+		{message: /requires a message with role "assistant"/},
+	);
+});
+
+test('MessageBuilder addToolResults adds tool messages', t => {
+	const builder = new MessageBuilder([]);
+	const toolResults: ToolResult[] = [
+		{
+			tool_call_id: 'tool_1',
+			role: 'tool',
+			name: 'read_file',
+			content: 'File contents here',
+		},
+		{
+			tool_call_id: 'tool_2',
+			role: 'tool',
+			name: 'execute_bash',
+			content: 'Command output',
+		},
+	];
+
+	builder.addToolResults(toolResults);
+	const messages = builder.build();
+
+	t.is(messages.length, 2);
+	t.is(messages[0].role, 'tool');
+	t.is(messages[0].tool_call_id, 'tool_1');
+	t.is(messages[0].name, 'read_file');
+	t.is(messages[0].content, 'File contents here');
+
+	t.is(messages[1].role, 'tool');
+	t.is(messages[1].tool_call_id, 'tool_2');
+});
+
+test('MessageBuilder addAutoExecutedMessages adds multiple messages', t => {
+	const builder = new MessageBuilder([]);
+	const autoMessages: Message[] = [
+		{role: 'assistant', content: '', tool_calls: [{id: '1', function: {name: 'test', arguments: {}}}]},
+		{role: 'tool', content: 'result', tool_call_id: '1', name: 'test'},
+	];
+
+	builder.addAutoExecutedMessages(autoMessages);
+	const messages = builder.build();
+
+	t.is(messages.length, 2);
+	t.is(messages[0].role, 'assistant');
+	t.is(messages[1].role, 'tool');
+});
+
+test('MessageBuilder addUserMessage adds user message', t => {
+	const builder = new MessageBuilder([]);
+
+	builder.addUserMessage('Hello');
+	const messages = builder.build();
+
+	t.is(messages.length, 1);
+	t.is(messages[0].role, 'user');
+	t.is(messages[0].content, 'Hello');
+});
+
+test('MessageBuilder addErrorMessage adds error as user message', t => {
+	const builder = new MessageBuilder([]);
+
+	builder.addErrorMessage('Error: something went wrong');
+	const messages = builder.build();
+
+	t.is(messages.length, 1);
+	t.is(messages[0].role, 'user');
+	t.is(messages[0].content, 'Error: something went wrong');
+});
+
+test('MessageBuilder supports method chaining', t => {
+	const builder = new MessageBuilder([]);
+
+	const messages = builder
+		.addUserMessage('Hello')
+		.addAssistantMessage({role: 'assistant', content: 'Hi'})
+		.addUserMessage('How are you?')
+		.build();
+
+	t.is(messages.length, 3);
+	t.is(messages[0].role, 'user');
+	t.is(messages[1].role, 'assistant');
+	t.is(messages[2].role, 'user');
+});
+
+test('MessageBuilder length property returns correct count', t => {
+	const builder = new MessageBuilder([]);
+
+	t.is(builder.length, 0);
+
+	builder.addUserMessage('Test');
+	t.is(builder.length, 1);
+
+	builder.addAssistantMessage({role: 'assistant', content: 'Response'});
+	t.is(builder.length, 2);
+});
+
+test('MessageBuilder isEmpty property works correctly', t => {
+	const builder = new MessageBuilder([]);
+
+	t.true(builder.isEmpty);
+
+	builder.addUserMessage('Test');
+	t.false(builder.isEmpty);
+});
+
+test('MessageBuilder builds complete conversation flow', t => {
+	const userMsg: Message = {role: 'user', content: 'Read config.json'};
+	const assistantMsg: Message = {
+		role: 'assistant',
+		content: '',
+		tool_calls: [
+			{
+				id: 'call_1',
+				function: {
+					name: 'read_file',
+					arguments: {path: 'config.json'},
+				},
+			},
+		],
+	};
+	const toolResult: ToolResult = {
+		tool_call_id: 'call_1',
+		role: 'tool',
+		name: 'read_file',
+		content: '{"setting": "value"}',
+	};
+
+	const builder = new MessageBuilder([userMsg]);
+	const messages = builder
+		.addAssistantMessage(assistantMsg)
+		.addToolResults([toolResult])
+		.build();
+
+	t.is(messages.length, 3);
+	t.is(messages[0].role, 'user');
+	t.is(messages[1].role, 'assistant');
+	t.is(messages[1].tool_calls?.length, 1);
+	t.is(messages[2].role, 'tool');
+	t.is(messages[2].content, '{"setting": "value"}');
+});