@gguf/coder 0.3.1 → 0.3.2

package/source/utils/logging/config.spec.ts

@@ -1,311 +0,0 @@
-import {existsSync, mkdirSync, rmSync} from 'fs';
-import {tmpdir} from 'os';
-import {join} from 'path';
-import test from 'ava';
-
-console.log(`\nlogging/config.spec.ts`);
-
-// Import configuration functions
-import {
-	createConfig,
-	createDevelopmentConfig,
-	createProductionConfig,
-	createTestConfig,
-	getDefaultLogDirectory,
-	getEnvironmentConfig,
-	normalizeLogLevel,
-	validateLogLevel,
-} from './config.js';
-
-// Import types
-import type {LoggerConfig} from './types.js';
-
-// Create a temporary test directory
-const testDir = join(tmpdir(), `coder-config-test-${Date.now()}`);
-
-test.before(() => {
-	mkdirSync(testDir, {recursive: true});
-});
-
-test.after.always(() => {
-	// Clean up test directory
-	if (existsSync(testDir)) {
-		rmSync(testDir, {recursive: true, force: true});
-	}
-});
-
-test('getDefaultLogDirectory returns valid directory path', t => {
-	const directory = getDefaultLogDirectory();
-
-	t.is(typeof directory, 'string', 'Should return string');
-	t.true(directory.length > 0, 'Should not be empty');
-	t.true(directory.includes('logs'), 'Should include logs in path');
-});
-
-test('createDevelopmentConfig creates valid development config', t => {
-	const config = createDevelopmentConfig();
-
-	t.is(typeof config, 'object', 'Should return object');
-	t.is(config.level, 'debug', 'Should use debug level in development');
-	t.true(config.pretty, 'Should enable pretty printing in development');
-	t.true(config.correlation, 'Should enable correlation in development');
-	t.false(config.serialize, 'Should not serialize in development');
-	t.true(Array.isArray(config.redact), 'Should have redaction array');
-});
-
-test('createProductionConfig creates valid production config', t => {
-	const config = createProductionConfig();
-
-	t.is(typeof config, 'object', 'Should return object');
-	t.is(config.level, 'silent', 'Should use silent level in production (silent-by-default for CLI)');
-	t.false(config.pretty, 'Should disable pretty printing in production');
-	t.true(config.correlation, 'Should enable correlation in production');
-	t.true(config.serialize, 'Should serialize in production');
-	t.true(Array.isArray(config.redact), 'Should have redaction array');
-});
-
-test('createTestConfig creates valid test config', t => {
-	const config = createTestConfig();
-
-	t.is(typeof config, 'object', 'Should return object');
-	t.is(config.level, 'debug', 'Should use debug level in tests');
-	t.false(config.pretty, 'Should disable pretty printing in tests');
-	t.false(config.correlation, 'Should disable correlation in tests');
-	t.false(config.serialize, 'Should not serialize in tests');
-});
-
-test('getEnvironmentConfig detects environment correctly', t => {
-	// Test development environment
-	const originalEnv = process.env.NODE_ENV;
-
-	process.env.NODE_ENV = 'development';
-	const devConfig = getEnvironmentConfig();
-	t.is(devConfig.level, 'debug', 'Should detect development');
-	t.true(devConfig.pretty, 'Should enable pretty in development');
-
-	// Test production environment
-	process.env.NODE_ENV = 'production';
-	const prodConfig = getEnvironmentConfig();
-	t.is(prodConfig.level, 'silent', 'Should detect production (silent-by-default)');
-	t.false(prodConfig.pretty, 'Should disable pretty in production');
-
-	// Test test environment
-	process.env.NODE_ENV = 'test';
-	const testConfig = getEnvironmentConfig();
-	t.is(testConfig.level, 'debug', 'Should detect test');
-	t.is(testConfig.level, 'debug', 'Should use debug in test');
-
-	// Test unknown environment (should default to production/silent for CLI tools)
-	process.env.NODE_ENV = 'unknown';
-	const unknownConfig = getEnvironmentConfig();
-	t.is(unknownConfig.level, 'silent', 'Should default to silent for unknown (production default)');
-
-	// Restore original environment
-	process.env.NODE_ENV = originalEnv;
-});
-
-test('validateLogLevel validates log levels correctly', t => {
-	// Valid levels
-	t.true(validateLogLevel('trace'), 'Should accept trace');
-	t.true(validateLogLevel('debug'), 'Should accept debug');
-	t.true(validateLogLevel('info'), 'Should accept info');
-	t.true(validateLogLevel('warn'), 'Should accept warn');
-	t.true(validateLogLevel('error'), 'Should accept error');
-	t.true(validateLogLevel('fatal'), 'Should accept fatal');
-	t.true(validateLogLevel('silent'), 'Should accept silent');
-
-	// Invalid levels
-	t.false(validateLogLevel('invalid'), 'Should reject invalid');
-	t.false(validateLogLevel(''), 'Should reject empty');
-	t.false(validateLogLevel('info '), 'Should reject with space');
-	t.false(validateLogLevel(' info'), 'Should reject with leading space');
-});
-
-test('normalizeLogLevel normalizes log levels', t => {
-	// Valid levels should pass through
-	t.is(normalizeLogLevel('trace'), 'trace', 'Should pass trace');
-	t.is(normalizeLogLevel('debug'), 'debug', 'Should pass debug');
-	t.is(normalizeLogLevel('info'), 'info', 'Should pass info');
-	t.is(normalizeLogLevel('warn'), 'warn', 'Should pass warn');
-	t.is(normalizeLogLevel('error'), 'error', 'Should pass error');
-	t.is(normalizeLogLevel('fatal'), 'fatal', 'Should pass fatal');
-	t.is(normalizeLogLevel('silent'), 'silent', 'Should pass silent');
-
-	// Uppercase should be normalized
-	t.is(normalizeLogLevel('TRACE'), 'trace', 'Should normalize TRACE');
-	t.is(normalizeLogLevel('DEBUG'), 'debug', 'Should normalize DEBUG');
-	t.is(normalizeLogLevel('INFO'), 'info', 'Should normalize INFO');
-	t.is(normalizeLogLevel('WARN'), 'warn', 'Should normalize WARN');
-	t.is(normalizeLogLevel('ERROR'), 'error', 'Should normalize ERROR');
-	t.is(normalizeLogLevel('FATAL'), 'fatal', 'Should normalize FATAL');
-	t.is(normalizeLogLevel('SILENT'), 'silent', 'Should normalize SILENT');
-
-	// Invalid should default to info
-	t.is(normalizeLogLevel('INFO'), 'info', 'Should default to info');
-});
-
-test('createConfig merges overrides correctly', t => {
-	// Note: createConfig() uses getEnvironmentConfig()
-	// Tests run in NODE_ENV='test', which has correlation: false and serialize: false
-
-	const overrides: Partial<LoggerConfig> = {
-		level: 'error',
-		pretty: true,
-		redact: ['token', 'password'],
-	};
-
-	const merged = createConfig(overrides);
-
-	t.is(merged.level, 'error', 'Should override level');
-	t.is(merged.pretty, true, 'Should override pretty');
-	t.deepEqual(merged.redact, ['token', 'password'], 'Should override redact');
-	t.is(merged.correlation, false, 'Should preserve correlation from test config');
-	t.is(merged.serialize, false, 'Should preserve serialize from test config');
-});
-
-test('createConfig handles missing overrides', t => {
-	const baseConfig: LoggerConfig = {
-		level: 'info',
-		pretty: true,
-		redact: ['apiKey'],
-		correlation: false,
-		serialize: false,
-	};
-
-	const result = createConfig(baseConfig);
-
-	t.notDeepEqual(
-		result,
-		baseConfig,
-		'Should return environment config with no overrides',
-	);
-});
-
-test('createConfig handles overrides correctly', t => {
-	const overrides: Partial<LoggerConfig> = {
-		level: 'debug',
-		pretty: false,
-	};
-
-	t.notThrows(() => {
-		const result = createConfig(overrides);
-		t.is(typeof result, 'object', 'Should return object');
-	}, 'Should handle overrides');
-});
-
-test('createConfig handles partial overrides', t => {
-	const partialOverride: Partial<LoggerConfig> = {
-		level: 'warn',
-	};
-
-	const result = createConfig(partialOverride);
-
-	t.is(result.level, 'warn', 'Should override specified field');
-	// Note: Other fields will depend on the environment config, not preserved from a base
-});
-
-test('createConfig validates log level in overrides', t => {
-	const invalidOverride: Partial<LoggerConfig> = {
-		level: 'debug',
-	};
-
-	t.notThrows(() => {
-		const result = createConfig(invalidOverride);
-		t.is(typeof result, 'object', 'Should handle valid level');
-	}, 'Should handle valid log level');
-});
-
-test('createConfig overrides redact arrays correctly', t => {
-	const overrideWithArray: Partial<LoggerConfig> = {
-		redact: ['password', 'secret'],
-	};
-
-	const result = createConfig(overrideWithArray);
-
-	// Should use override array, not merge
-	t.deepEqual(
-		result.redact,
-		['password', 'secret'],
-		'Should replace redact array',
-	);
-});
-
-test('configuration respects environment variables', t => {
-	const originalLogLevel = process.env.CODER_LOG_LEVEL;
-	const originalNodeEnv = process.env.NODE_ENV;
-
-	// Set environment variables
-	process.env.CODER_LOG_LEVEL = 'error';
-	process.env.NODE_ENV = 'production';
-
-	try {
-		const config = getEnvironmentConfig();
-
-		t.is(config.level, 'error', 'Should use LOG_LEVEL from environment');
-		// Production config should be applied
-		t.false(config.pretty, 'Should apply production config');
-	} finally {
-		// Restore environment variables
-		if (originalLogLevel) {
-			process.env.LOG_LEVEL = originalLogLevel;
-		} else {
-			delete process.env.LOG_LEVEL;
-		}
-		process.env.NODE_ENV = originalNodeEnv;
-	}
-});
-
-test('createDevelopmentConfig includes sensible defaults', t => {
-	const config = createDevelopmentConfig();
-
-	// Check default redaction patterns
-	t.true(config.redact.includes('apiKey'), 'Should redact API keys by default');
-	t.true(config.redact.includes('token'), 'Should redact tokens by default');
-	t.true(
-		config.redact.includes('password'),
-		'Should redact passwords by default',
-	);
-
-	// Check correlation settings
-	t.true(config.correlation, 'Should enable correlation in development');
-
-	// Note: Current implementation doesn't include transport configuration
-	// t.truthy(config.transport, 'Should have transport configuration');
-	// t.is(
-	//   (config.transport as any)?.target,
-	//   'pino-pretty',
-	//   'Should use pretty transport in development',
-	// );
-});
-
-test('createProductionConfig includes production optimizations', t => {
-	const config = createProductionConfig();
-
-	// Check production-specific settings
-	t.true(config.serialize, 'Should serialize in production');
-	t.is(config.level, 'error', 'Should default to error in production');
-
-	// Check redaction patterns for production
-	t.true(config.redact.includes('email'), 'Should redact emails in production');
-	t.true(
-		config.redact.includes('userId'),
-		'Should redact user IDs in production',
-	);
-
-	// Note: Current implementation doesn't include transport configuration
-	// t.truthy(config.transport, 'Should have transport configuration');
-	// t.is(
-	//   (config.transport as any)?.target,
-	//   'pino-roll',
-	//   'Should use roll transport in production',
-	// );
-});
-
-test('createTestConfig minimizes output', t => {
-	const config = createTestConfig();
-
-	t.is(config.level, 'debug', 'Should be debug in tests');
-	t.false(config.pretty, 'Should disable pretty in tests');
-	t.false(config.correlation, 'Should disable correlation in tests');
-	t.false(config.serialize, 'Should disable serialization in tests');
-});

package/source/utils/logging/config.ts

@@ -1,210 +0,0 @@
-/**
- * Environment-based configuration for Pino logger
- */
-
-import {platform} from 'os';
-import {homedir} from 'os';
-import {join} from 'path';
-import type {EnhancedLoggerConfig, LogLevel, LoggerConfig} from './types.js';
-
-/**
- * Get the default log directory based on platform
- */
-export function getDefaultLogDirectory(): string {
-	if (process.env.CODER_LOG_DIR) {
-		return process.env.CODER_LOG_DIR;
-	}
-
-	switch (platform()) {
-		case 'win32':
-			return join(process.env.APPDATA || homedir(), 'coder', 'logs');
-		case 'darwin':
-			return join(homedir(), 'Library', 'Preferences', 'coder', 'logs');
-		default: // linux
-			return join(homedir(), '.config', 'coder', 'logs');
-	}
-}
-
-/**
- * Create development configuration
- */
-export function createDevelopmentConfig(): EnhancedLoggerConfig {
-	return {
-		level: (process.env.CODER_LOG_LEVEL as LogLevel) || 'debug',
-		destination: String(process.stdout.fd),
-		pretty: true,
-		redact: ['apiKey', 'token', 'password', 'secret'],
-		correlation: true,
-		serialize: false,
-		target: 'pino-pretty',
-		options: {
-			translateTime: 'HH:MM:ss Z',
-			ignore: 'pid,hostname',
-			messageFormat: undefined,
-			customPrettifiers: {},
-			levelFirst: false,
-			singleLine: false,
-		},
-	};
-}
-
-/**
- * Create production configuration
- */
-export function createProductionConfig(): EnhancedLoggerConfig {
-	// Check if file logging is explicitly disabled
-	const disableFileLogging = process.env.CODER_LOG_DISABLE_FILE === 'true';
-
-	const baseConfig = {
-		level: (process.env.CODER_LOG_LEVEL as LogLevel) || 'silent', // Production users shouldn't see internal logs
-		pretty: false,
-		redact: ['apiKey', 'token', 'password', 'email', 'userId', 'secret'],
-		correlation: true,
-		serialize: true,
-	};
-
-	// If file logging is disabled, only use stdout (for UI)
-	if (disableFileLogging) {
-		return {
-			...baseConfig,
-			destination: String(process.stdout.fd),
-			target: 'pino-pretty',
-			options: {
-				colorize: false, // No colors in production
-				translateTime: 'HH:MM:ss Z',
-				ignore: 'pid,hostname',
-				levelFirst: true,
-				messageFormat: '{level} - {msg}',
-				singleLine: true, // Compact for UI
-			},
-		};
-	}
-
-	// Otherwise use stdout for UI with optional file logging
-	// This ensures UI works while still allowing file persistence when needed
-	return {
-		...baseConfig,
-		// Always output to stdout for UI compatibility
-		destination: String(process.stdout.fd),
-		target: 'pino-pretty',
-		options: {
-			colorize: false, // No colors in production
-			translateTime: 'HH:MM:ss Z',
-			ignore: 'pid,hostname', // Reduce UI clutter
-			levelFirst: false,
-			messageFormat: '{msg}',
-			singleLine: true, // Compact for UI
-		},
-		// Note: File logging will be handled by the multi-transport system in transports.ts
-		// when CODER_LOG_TO_FILE=true is set
-	};
-}
-
-/**
- * Create test configuration
- */
-export function createTestConfig(): EnhancedLoggerConfig {
-	return {
-		level: (process.env.LOG_LEVEL as LogLevel) || 'debug', // Changed from 'silent' to 'debug'
-		pretty: false,
-		redact: ['apiKey', 'token', 'password'],
-		correlation: false,
-		serialize: false,
-		target: 'pino/file',
-		options: {
-			destination: '/dev/null',
-		},
-	};
-}
-
-/**
- * Get configuration based on current environment
- *
- * For CLI tools, we default to production (silent) behavior when NODE_ENV is not set.
- * This gives users a clean experience. Developers working on coder itself should
- * explicitly set NODE_ENV=development to see debug logs.
- */
-export function getEnvironmentConfig(): EnhancedLoggerConfig {
-	const env = process.env.NODE_ENV;
-
-	switch (env) {
-		case 'development':
-			return createDevelopmentConfig();
-		case 'test':
-			return createTestConfig();
-		default:
-			// Default to production (silent) for normal CLI usage
-			return createProductionConfig();
-	}
-}
-
-/**
- * Validate log level
- */
-export function validateLogLevel(level: string): boolean {
-	const validLevels = [
-		'fatal',
-		'error',
-		'warn',
-		'info',
-		'http',
-		'debug',
-		'trace',
-		'silent',
-	];
-	return validLevels.includes(level.toLowerCase());
-}
-
-/**
- * Normalize log level string
- */
-export function normalizeLogLevel(level: string): string {
-	const normalized = level.toLowerCase().trim();
-
-	// Map common aliases
-	const aliases: Record<string, string> = {
-		warning: 'warn',
-		err: 'error',
-		information: 'info',
-		http: 'http',
-	};
-
-	return aliases[normalized] || normalized;
-}
-
-/**
- * Create configuration with overrides
- */
-export function createConfig(
-	overrides: Partial<LoggerConfig> = {},
-): EnhancedLoggerConfig {
-	const baseConfig = getEnvironmentConfig();
-
-	// Apply overrides with validation
-	if (overrides.level) {
-		const normalizedLevel = normalizeLogLevel(overrides.level);
-		if (!validateLogLevel(normalizedLevel)) {
-			console.warn(
-				`[WARNING] Invalid log level "${overrides.level}", using default`,
-			);
-		} else {
-			baseConfig.level = normalizedLevel as LogLevel;
-		}
-	}
-
-	if (overrides.redact) {
-		baseConfig.redact = [
-			...new Set([...baseConfig.redact, ...overrides.redact]),
-		];
-	}
-
-	// Merge other properties
-	return {
-		...baseConfig,
-		...overrides,
-		options: {
-			...baseConfig.options,
-			...(overrides as EnhancedLoggerConfig)?.options,
-		},
-	};
-}

package/source/utils/logging/console-facade.spec.ts

@@ -1,184 +0,0 @@
-import test from 'ava';
-
-// Implementation imports
-import {
-	ConsoleInterceptor,
-	ConsoleUsageTracker,
-	StructuredConsole,
-	createModuleConsole,
-	globalConsoleInterceptor,
-	useStructuredConsole,
-} from './console-facade.js';
-
-// Since the console-facade uses the real logger at module load time,
-// we'll test the behavior by checking that the methods work correctly
-// and produce the expected output structure.
-
-test('StructuredConsole.log handles empty arguments', t => {
-	// This test verifies that StructuredConsole.log works without throwing
-	// The real logger will handle the call, so we just check it doesn't throw
-	t.notThrows(() => {
-		StructuredConsole.log();
-	}, 'Should handle empty arguments without throwing');
-});
-
-test('StructuredConsole.log handles single string argument', t => {
-	const testMessage = 'Test log message';
-	t.notThrows(() => {
-		StructuredConsole.log(testMessage);
-	}, 'Should handle single string argument without throwing');
-});
-
-test('StructuredConsole.log handles single object argument', t => {
-	const testObject = {key: 'value', number: 42};
-	t.notThrows(() => {
-		StructuredConsole.log(testObject);
-	}, 'Should handle single object argument without throwing');
-});
-
-test('StructuredConsole.log handles single primitive argument', t => {
-	const testValue = 123;
-	t.notThrows(() => {
-		StructuredConsole.log(testValue);
-	}, 'Should handle single primitive argument without throwing');
-});
-
-test('StructuredConsole.log handles multiple arguments', t => {
-	const stringArg = 'Test message';
-	const objectArg = {data: 'test'};
-	const numberArg = 42;
-	t.notThrows(() => {
-		StructuredConsole.log(stringArg, objectArg, numberArg);
-	}, 'Should handle multiple arguments without throwing');
-});
-
-test('StructuredConsole.error handles Error objects', t => {
-	const testError = new Error('Test error');
-	t.notThrows(() => {
-		StructuredConsole.error(testError);
-	}, 'Should handle Error objects without throwing');
-});
-
-test('StructuredConsole.warn handles arguments correctly', t => {
-	t.notThrows(() => {
-		StructuredConsole.warn('Warning message', {context: 'test'});
-	}, 'Should handle arguments correctly without throwing');
-});
-
-test('ConsoleInterceptor activates and deactivates correctly', t => {
-	const originalConsole = {
-		log: console.log,
-		error: console.error,
-		warn: console.warn,
-		info: console.info,
-		debug: console.debug,
-	};
-
-	const interceptor = new ConsoleInterceptor();
-
-	// Test activation
-	interceptor.activate();
-	t.true(interceptor.isInterceptorActive());
-
-	// Verify console methods are replaced
-	t.is(console.log, StructuredConsole.log);
-	t.is(console.error, StructuredConsole.error);
-	t.is(console.warn, StructuredConsole.warn);
-	t.is(console.info, StructuredConsole.info);
-	t.is(console.debug, StructuredConsole.debug);
-
-	// Test deactivation
-	interceptor.deactivate();
-	t.false(interceptor.isInterceptorActive());
-
-	// Verify original methods are restored
-	t.is(console.log, originalConsole.log);
-	t.is(console.error, originalConsole.error);
-	t.is(console.warn, originalConsole.warn);
-	t.is(console.info, originalConsole.info);
-	t.is(console.debug, originalConsole.debug);
-});
-
-test('ConsoleInterceptor handles multiple activation calls', t => {
-	const interceptor = new ConsoleInterceptor();
-
-	interceptor.activate();
-	const firstActivation = interceptor.isInterceptorActive();
-
-	interceptor.activate(); // Should not cause issues
-	const secondActivation = interceptor.isInterceptorActive();
-
-	t.true(firstActivation);
-	t.true(secondActivation);
-	t.is(console.log, StructuredConsole.log);
-
-	interceptor.deactivate();
-});
-
-test('ConsoleInterceptor handles deactivation when not active', t => {
-	const interceptor = new ConsoleInterceptor();
-
-	// Should not throw when deactivating while not active
-	t.notThrows(() => {
-		interceptor.deactivate();
-	}, 'Deactivation when not active should not throw');
-
-	t.false(interceptor.isInterceptorActive());
-});
-
-test('globalConsoleInterceptor is available and functional', t => {
-	t.truthy(globalConsoleInterceptor);
-	t.true(globalConsoleInterceptor instanceof ConsoleInterceptor);
-	t.false(globalConsoleInterceptor.isInterceptorActive());
-});
-
-test('createModuleConsole creates properly scoped console', t => {
-	const moduleName = 'test-module';
-	const moduleConsole = createModuleConsole(moduleName);
-
-	t.truthy(moduleConsole);
-	t.truthy(typeof moduleConsole.log === 'function');
-	t.truthy(typeof moduleConsole.error === 'function');
-	t.truthy(typeof moduleConsole.warn === 'function');
-	t.truthy(typeof moduleConsole.info === 'function');
-	t.truthy(typeof moduleConsole.debug === 'function');
-});
-
-test('ConsoleUsageTracker tracks console usage', t => {
-	const tracker = new ConsoleUsageTracker();
-
-	// Simulate some console calls
-	console.log('test log');
-	console.error('test error');
-	console.log('another log');
-
-	const stats = tracker.getUsageStats();
-	t.true(typeof stats === 'object');
-});
-
-test('ConsoleUsageTracker.reportUsage logs statistics', t => {
-	const tracker = new ConsoleUsageTracker();
-
-	t.notThrows(() => {
-		tracker.reportUsage();
-	}, 'Should report usage without throwing');
-});
-
-test('ConsoleUsageTracker.restore works without errors', t => {
-	const tracker = new ConsoleUsageTracker();
-
-	t.notThrows(() => {
-		tracker.restore();
-	}, 'Restore should not throw errors');
-});
-
-test('StructuredConsole handles all console methods consistently', t => {
-	const methods = ['log', 'error', 'warn', 'info', 'debug'] as const;
-
-	methods.forEach(method => {
-		// Call the method with a test message
-		t.notThrows(() => {
-			StructuredConsole[method](`Test ${method} message`);
-		}, `${method} should work without throwing`);
-	});
-});