@mcpilotx/intentorch 0.5.0

package/dist/core/error-handler.js

@@ -0,0 +1,467 @@
+/**
+ * IntentOrch SDK Unified Error Handling System
+ * Balances minimalist style with functional robustness
+ * Formerly known as MCPilot SDK
+ */
+/**
+ * Error Code Enumeration
+ * Clear categorization for easy identification and handling
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // ==================== Configuration Errors (1xx) ====================
+    ErrorCode["CONFIG_INVALID"] = "CONFIG_001";
+    ErrorCode["CONFIG_MISSING"] = "CONFIG_002";
+    ErrorCode["CONFIG_VALIDATION_FAILED"] = "CONFIG_003";
+    ErrorCode["CONFIG_MIGRATION_FAILED"] = "CONFIG_004";
+    // ==================== Service Errors (2xx) ====================
+    ErrorCode["SERVICE_NOT_FOUND"] = "SERVICE_001";
+    ErrorCode["SERVICE_ALREADY_EXISTS"] = "SERVICE_002";
+    ErrorCode["SERVICE_START_FAILED"] = "SERVICE_003";
+    ErrorCode["SERVICE_STOP_FAILED"] = "SERVICE_004";
+    ErrorCode["SERVICE_HEALTH_CHECK_FAILED"] = "SERVICE_005";
+    // ==================== Runtime Errors (3xx) ====================
+    ErrorCode["RUNTIME_DETECTION_FAILED"] = "RUNTIME_001";
+    ErrorCode["RUNTIME_NOT_SUPPORTED"] = "RUNTIME_002";
+    ErrorCode["RUNTIME_NOT_INSTALLED"] = "RUNTIME_003";
+    ErrorCode["RUNTIME_ADAPTER_ERROR"] = "RUNTIME_004";
+    // ==================== Process Errors (4xx) ====================
+    ErrorCode["PROCESS_NOT_FOUND"] = "PROCESS_001";
+    ErrorCode["PROCESS_START_FAILED"] = "PROCESS_002";
+    ErrorCode["PROCESS_STOP_FAILED"] = "PROCESS_003";
+    ErrorCode["PROCESS_TIMEOUT"] = "PROCESS_004";
+    // ==================== Resource Errors (5xx) ====================
+    ErrorCode["RESOURCE_LIMIT_EXCEEDED"] = "RESOURCE_001";
+    ErrorCode["MEMORY_LIMIT_EXCEEDED"] = "RESOURCE_002";
+    ErrorCode["CPU_LIMIT_EXCEEDED"] = "RESOURCE_003";
+    ErrorCode["DISK_SPACE_INSUFFICIENT"] = "RESOURCE_004";
+    // ==================== Permission Errors (6xx) ====================
+    ErrorCode["PERMISSION_DENIED"] = "PERMISSION_001";
+    ErrorCode["FILE_PERMISSION_ERROR"] = "PERMISSION_002";
+    ErrorCode["NETWORK_PERMISSION_ERROR"] = "PERMISSION_003";
+    // ==================== Network Errors (7xx) ====================
+    ErrorCode["NETWORK_ERROR"] = "NETWORK_001";
+    ErrorCode["CONNECTION_REFUSED"] = "NETWORK_002";
+    ErrorCode["CONNECTION_TIMEOUT"] = "NETWORK_003";
+    ErrorCode["DNS_RESOLUTION_FAILED"] = "NETWORK_004";
+    // ==================== AI Errors (8xx) ====================
+    ErrorCode["AI_CONFIG_INVALID"] = "AI_001";
+    ErrorCode["AI_PROVIDER_NOT_AVAILABLE"] = "AI_002";
+    ErrorCode["AI_QUERY_FAILED"] = "AI_003";
+    ErrorCode["AI_MODEL_NOT_FOUND"] = "AI_004";
+    // ==================== System Errors (9xx) ====================
+    ErrorCode["SYSTEM_ERROR"] = "SYSTEM_001";
+    ErrorCode["UNEXPECTED_ERROR"] = "SYSTEM_002";
+    ErrorCode["NOT_IMPLEMENTED"] = "SYSTEM_003";
+    // ==================== Validation Errors (10xx) ====================
+    ErrorCode["VALIDATION_FAILED"] = "VALIDATION_001";
+    ErrorCode["REQUIRED_FIELD_MISSING"] = "VALIDATION_002";
+    ErrorCode["INVALID_FORMAT"] = "VALIDATION_003";
+    ErrorCode["OUT_OF_RANGE"] = "VALIDATION_004";
+})(ErrorCode || (ErrorCode = {}));
+/**
+ * Error Severity Levels
+ */
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    ErrorSeverity["LOW"] = "low";
+    ErrorSeverity["MEDIUM"] = "medium";
+    ErrorSeverity["HIGH"] = "high";
+    ErrorSeverity["CRITICAL"] = "critical";
+})(ErrorSeverity || (ErrorSeverity = {}));
+/**
+ * IntentOrch Unified Error Class
+ */
+export class IntentOrchError extends Error {
+    code;
+    message;
+    severity;
+    context;
+    suggestions;
+    cause;
+    constructor(code, message, severity = ErrorSeverity.MEDIUM, context = {}, suggestions = [], cause) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.severity = severity;
+        this.context = context;
+        this.suggestions = suggestions;
+        this.cause = cause;
+        this.name = 'IntentOrchError';
+        // Ensure stack trace includes original error
+        if (cause && cause.stack) {
+            this.stack = `${this.stack}\nCaused by: ${cause.stack}`;
+        }
+        // Automatically add timestamp
+        if (!context.timestamp) {
+            context.timestamp = new Date();
+        }
+    }
+    /**
+     * Convert to JSON format for easy logging and transmission
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            severity: this.severity,
+            context: this.context,
+            suggestions: this.suggestions,
+            stack: this.stack,
+            cause: this.cause ? (this.cause instanceof IntentOrchError ? this.cause.toJSON() : {
+                name: this.cause.name,
+                message: this.cause.message,
+                stack: this.cause.stack,
+            }) : undefined,
+        };
+    }
+    /**
+     * Get error summary for display
+     */
+    getSummary() {
+        return `[${this.code}] ${this.message}`;
+    }
+    /**
+     * Get detailed error information
+     */
+    getDetails() {
+        const details = [
+            `Error: ${this.name}`,
+            `Code: ${this.code}`,
+            `Message: ${this.message}`,
+            `Severity: ${this.severity}`,
+        ];
+        if (Object.keys(this.context).length > 0) {
+            details.push(`Context: ${JSON.stringify(this.context, null, 2)}`);
+        }
+        if (this.suggestions.length > 0) {
+            details.push('Suggestions:');
+            this.suggestions.forEach((suggestion, index) => {
+                details.push(`  ${index + 1}. ${suggestion.title}: ${suggestion.description}`);
+            });
+        }
+        if (this.stack) {
+            details.push(`Stack: ${this.stack}`);
+        }
+        return details.join('\n');
+    }
+}
+/**
+ * MCPilot Unified Error Class (for backward compatibility)
+ * @deprecated Use IntentOrchError instead
+ */
+export class MCPilotError extends IntentOrchError {
+    constructor(code, message, severity = ErrorSeverity.MEDIUM, context = {}, suggestions = [], cause) {
+        super(code, message, severity, context, suggestions, cause);
+        this.name = 'MCPilotError';
+    }
+}
+/**
+ * Error Factory - Create standardized error instances
+ */
+export class ErrorFactory {
+    /**
+     * Configuration error
+     */
+    static configInvalid(message, context = {}, cause) {
+        return new MCPilotError(ErrorCode.CONFIG_INVALID, message, ErrorSeverity.HIGH, context, [
+            {
+                title: 'Check configuration file',
+                description: 'Please check if the configuration file format and content are correct',
+                steps: [
+                    'Verify configuration file path is correct',
+                    'Check if JSON format is correct',
+                    'Confirm all required fields are filled',
+                    'Refer to configuration examples in documentation',
+                ],
+                documentationUrl: 'https://github.com/MCPilotX/IntentOrch/docs/configuration',
+            },
+        ], cause);
+    }
+    /**
+     * Service not found error
+     */
+    static serviceNotFound(serviceName, context = {}) {
+        return new MCPilotError(ErrorCode.SERVICE_NOT_FOUND, `Service '${serviceName}' not found`, ErrorSeverity.MEDIUM, { ...context, serviceName }, [
+            {
+                title: 'Check service name',
+                description: 'Please confirm if the service name is correct',
+                steps: [
+                    'Use \'mcp ls\' command to view all services',
+                    'Confirm service name spelling is correct',
+                    'Check if service has been deleted',
+                    'If needed, re-add service: mcp add <path>',
+                ],
+            },
+        ]);
+    }
+    /**
+     * Runtime detection failed error
+     */
+    static runtimeDetectionFailed(path, context = {}, cause) {
+        return new MCPilotError(ErrorCode.RUNTIME_DETECTION_FAILED, `Failed to detect runtime for path: ${path}`, ErrorSeverity.MEDIUM, { ...context, path }, [
+            {
+                title: 'Manually specify runtime type',
+                description: 'Auto-detection failed, please manually specify runtime type',
+                steps: [
+                    'Use --type parameter to specify runtime: mcp add <path> --type <runtime>',
+                    'Supported runtime types: node, python, docker, go, rust, binary',
+                    'Check if project directory contains correct configuration files',
+                    'Confirm project structure meets expectations',
+                ],
+                codeExample: 'mcp add ./my-service --type node',
+            },
+        ], cause);
+    }
+    /**
+     * Process start failed error
+     */
+    static processStartFailed(serviceName, context = {}, cause) {
+        return new MCPilotError(ErrorCode.PROCESS_START_FAILED, `Failed to start process for service '${serviceName}'`, ErrorSeverity.HIGH, { ...context, serviceName }, [
+            {
+                title: 'Check service configuration',
+                description: 'Service startup failed, please check configuration and dependencies',
+                steps: [
+                    'Check if service path is correct',
+                    'Confirm runtime environment is installed',
+                    `View service logs: mcp logs ${serviceName}`,
+                    'Check if port is occupied',
+                    'Verify dependencies are installed',
+                ],
+            },
+        ], cause);
+    }
+    /**
+     * Permission denied error
+     */
+    static permissionDenied(operation, resource, context = {}) {
+        return new MCPilotError(ErrorCode.PERMISSION_DENIED, `Permission denied for ${operation} on ${resource}`, ErrorSeverity.HIGH, { ...context, operation, resource }, [
+            {
+                title: 'Check file permissions',
+                description: 'Insufficient permissions to perform operation',
+                steps: [
+                    `Check file/directory permissions: ls -la ${resource}`,
+                    'Use sudo to run command (if applicable)',
+                    `Modify file permissions: chmod +x ${resource}`,
+                    `Change file owner: chown $(whoami) ${resource}`,
+                ],
+            },
+        ]);
+    }
+    /**
+     * Network error
+     */
+    static networkError(operation, url, context = {}, cause) {
+        return new MCPilotError(ErrorCode.NETWORK_ERROR, `Network error during ${operation} to ${url}`, ErrorSeverity.MEDIUM, { ...context, operation, url }, [
+            {
+                title: 'Check network connection',
+                description: 'Network connection failed, please check network settings',
+                steps: [
+                    'Check if network connection is normal',
+                    'Verify URL is correct',
+                    'Check firewall settings',
+                    'Try using proxy (if configured)',
+                    'Wait and retry after some time',
+                ],
+            },
+        ], cause);
+    }
+    /**
+     * Not implemented error
+     */
+    static notImplemented(feature, context = {}) {
+        return new MCPilotError(ErrorCode.NOT_IMPLEMENTED, `Feature '${feature}' is not implemented yet`, ErrorSeverity.LOW, { ...context, feature }, [
+            {
+                title: 'Feature under development',
+                description: 'This feature is under development and will be available in future versions',
+                steps: [
+                    'View project roadmap',
+                    'Follow GitHub release page',
+                    'Consider using alternative solutions',
+                    'Submit feature request (if urgently needed)',
+                ],
+                documentationUrl: 'https://github.com/MCPilotX/IntentOrch/issues',
+            },
+        ]);
+    }
+    /**
+     * Validation error
+     */
+    static validationFailed(field, reason, context = {}) {
+        return new MCPilotError(ErrorCode.VALIDATION_FAILED, `Validation failed for field '${field}': ${reason}`, ErrorSeverity.MEDIUM, { ...context, field, reason }, [
+            {
+                title: 'Fix validation error',
+                description: 'Input data validation failed',
+                steps: [
+                    `Check value of ${field} field`,
+                    `Ensure value meets requirements: ${reason}`,
+                    'Refer to field description in documentation',
+                    'Use valid example values',
+                ],
+            },
+        ]);
+    }
+}
+/**
+ * Error Handler - Handle, log and recover from errors
+ */
+export class ErrorHandler {
+    static instance;
+    handlers = [];
+    constructor() { }
+    static getInstance() {
+        if (!ErrorHandler.instance) {
+            ErrorHandler.instance = new ErrorHandler();
+        }
+        return ErrorHandler.instance;
+    }
+    /**
+     * Register error handler
+     */
+    registerHandler(handler) {
+        this.handlers.push(handler);
+    }
+    /**
+     * Handle error
+     */
+    async handle(error) {
+        // Convert to MCPilotError (if not already)
+        const mcError = error instanceof MCPilotError
+            ? error
+            : new MCPilotError(ErrorCode.UNEXPECTED_ERROR, error.message, ErrorSeverity.HIGH, {}, [], error);
+        // Log error
+        console.error(`[IntentOrch Error] ${mcError.getSummary()}`);
+        // Execute all registered handlers
+        for (const handler of this.handlers) {
+            try {
+                await handler(mcError);
+            }
+            catch (handlerError) {
+                console.error('Error handler failed:', handlerError);
+            }
+        }
+    }
+    /**
+     * Safely execute function, automatically handle errors
+     */
+    async execute(operation, fn, context = {}) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const mcError = error instanceof MCPilotError
+                ? error
+                : new MCPilotError(ErrorCode.UNEXPECTED_ERROR, `Operation '${operation}' failed: ${error instanceof Error ? error.message : String(error)}`, ErrorSeverity.HIGH, { ...context, operation }, [], error instanceof Error ? error : undefined);
+            await this.handle(mcError);
+            throw mcError;
+        }
+    }
+}
+/**
+ * Default Error Handler - Console Output
+ */
+export class ConsoleErrorHandler {
+    static async handle(error) {
+        const colors = {
+            low: '\x1b[36m', // cyan
+            medium: '\x1b[33m', // yellow
+            high: '\x1b[31m', // red
+            critical: '\x1b[41m\x1b[37m', // red background, white text
+        };
+        const color = colors[error.severity] || '\x1b[0m';
+        const reset = '\x1b[0m';
+        console.error(`\n${color}╔══════════════════════════════════════════════════════════════╗${reset}`);
+        console.error(`${color}║ IntentOrch Error: ${error.getSummary().padEnd(48)} ║${reset}`);
+        console.error(`${color}╚══════════════════════════════════════════════════════════════╝${reset}`);
+        console.error(`\n${color}Details:${reset}`);
+        console.error(error.getDetails());
+        if (error.suggestions.length > 0) {
+            console.error(`\n${color}Suggestions:${reset}`);
+            error.suggestions.forEach((suggestion, index) => {
+                console.error(`  ${index + 1}. ${suggestion.title}`);
+                console.error(`     ${suggestion.description}`);
+                if (suggestion.steps.length > 0) {
+                    console.error('     Steps:');
+                    suggestion.steps.forEach(step => {
+                        console.error(`       • ${step}`);
+                    });
+                }
+            });
+        }
+        console.error(`\n${color}Need more help?${reset}`);
+        console.error('  • Check documentation: https://github.com/MCPilotX/IntentOrch/docs');
+        console.error('  • Report issue: https://github.com/MCPilotX/IntentOrch/issues');
+        console.error('  • Ask community: https://github.com/MCPilotX/IntentOrch/discussions\n');
+    }
+}
+/**
+ * Error Handler with Retry
+ */
+export class RetryErrorHandler {
+    static async withRetry(operation, fn, strategy = {
+        maxAttempts: 3,
+        backoff: 'exponential',
+        baseDelay: 1000,
+        maxDelay: 10000,
+    }, context = {}) {
+        let lastError;
+        for (let attempt = 1; attempt <= strategy.maxAttempts; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // If this is the last attempt, throw error directly
+                if (attempt === strategy.maxAttempts) {
+                    throw error;
+                }
+                // Calculate delay time
+                let delay = strategy.baseDelay;
+                if (strategy.backoff === 'exponential') {
+                    delay = strategy.baseDelay * Math.pow(2, attempt - 1);
+                }
+                else if (strategy.backoff === 'linear') {
+                    delay = strategy.baseDelay * attempt;
+                }
+                // Apply maximum delay limit
+                if (strategy.maxDelay && delay > strategy.maxDelay) {
+                    delay = strategy.maxDelay;
+                }
+                console.warn(`[Retry] Attempt ${attempt}/${strategy.maxAttempts} failed for '${operation}'. Retrying in ${delay}ms...`);
+                // Wait for delay
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        // Theoretically won't reach here because error will be thrown in loop
+        throw lastError || new Error(`Operation '${operation}' failed after ${strategy.maxAttempts} attempts`);
+    }
+}
+// Initialize default error handler
+const errorHandler = ErrorHandler.getInstance();
+errorHandler.registerHandler(ConsoleErrorHandler.handle);
+// Export common functions
+export function createError(code, message, severity, context) {
+    return new MCPilotError(code, message, severity, context);
+}
+export function wrapError(error, code = ErrorCode.UNEXPECTED_ERROR, context) {
+    return new MCPilotError(code, error.message, ErrorSeverity.HIGH, context, [], error);
+}
+export function isMCPilotError(error) {
+    return error instanceof MCPilotError;
+}
+export function shouldRetry(error) {
+    if (!isMCPilotError(error)) {
+        return false;
+    }
+    // These error types can usually be resolved by retrying
+    const retryableCodes = [
+        ErrorCode.NETWORK_ERROR,
+        ErrorCode.CONNECTION_TIMEOUT,
+        ErrorCode.CONNECTION_REFUSED,
+        ErrorCode.PROCESS_START_FAILED,
+        ErrorCode.SERVICE_START_FAILED,
+    ];
+    return retryableCodes.includes(error.code);
+}
+//# sourceMappingURL=error-handler.js.map

package/dist/core/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Core Module Exports
+ * Provides unified interface for core functionality
+ */
+export { ConfigManager } from './config-manager';
+export type { RuntimeType, ServiceConfig, Config, AIConfig, DetectionResult, DockerConnectionConfig, RuntimeSpecificConfig, } from './types';
+export { MCPILOT_HOME, CONFIG_PATH, } from './constants';
+export { MCPilotError, ErrorCode, ErrorSeverity, ErrorFactory, ErrorHandler, ConsoleErrorHandler, RetryErrorHandler, createError, wrapError, isMCPilotError, shouldRetry, } from './error-handler';
+export { AIError } from './error-ai';
+export { logger } from './logger';
+export { PerformanceMonitor } from './performance-monitor';
+export { RetryManager } from './retry-manager';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -0,0 +1,17 @@
+/**
+ * Core Module Exports
+ * Provides unified interface for core functionality
+ */
+// Export configuration management
+export { ConfigManager } from './config-manager.js';
+// Export constants
+export { MCPILOT_HOME, CONFIG_PATH, } from './constants.js';
+// Export error handling
+export { MCPilotError, ErrorCode, ErrorSeverity, ErrorFactory, ErrorHandler, ConsoleErrorHandler, RetryErrorHandler, createError, wrapError, isMCPilotError, shouldRetry, } from './error-handler.js';
+// Export logger
+export { logger } from './logger.js';
+// Export performance monitor
+export { PerformanceMonitor } from './performance-monitor.js';
+// Export retry manager
+export { RetryManager } from './retry-manager.js';
+//# sourceMappingURL=index.js.map

package/dist/core/logger.d.ts

@@ -0,0 +1,27 @@
+export declare enum LogLevel {
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARN = "WARN",
+    ERROR = "ERROR"
+}
+export declare class Logger {
+    private static instance;
+    private logFile;
+    private logLevel;
+    private constructor();
+    static getInstance(): Logger;
+    setLogLevel(level: LogLevel): void;
+    private shouldLog;
+    private formatMessage;
+    private writeToFile;
+    debug(message: string, context?: any): void;
+    info(message: string, context?: any): void;
+    warn(message: string, context?: any): void;
+    error(message: string, context?: any): void;
+    logRequest(command: string, data?: any): void;
+    logServiceEvent(serviceName: string, event: string, details?: any): void;
+    logAIQuery(query: string, result?: any): void;
+    logConfigUpdate(configType: string, config: any): void;
+}
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/core/logger.js

@@ -0,0 +1,108 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { LOGS_DIR } from './constants.js';
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["WARN"] = "WARN";
+    LogLevel["ERROR"] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    static instance;
+    logFile;
+    logLevel = LogLevel.INFO;
+    constructor() {
+        // Ensure log directory exists
+        if (!fs.existsSync(LOGS_DIR)) {
+            fs.mkdirSync(LOGS_DIR, { recursive: true });
+        }
+        // Create date-named log file
+        const date = new Date().toISOString().split('T')[0];
+        this.logFile = path.join(LOGS_DIR, `mcpilot-${date}.log`);
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    shouldLog(level) {
+        const levels = [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN, LogLevel.ERROR];
+        return levels.indexOf(level) >= levels.indexOf(this.logLevel);
+    }
+    formatMessage(level, message, context) {
+        const timestamp = new Date().toISOString();
+        const contextStr = context ? ` ${JSON.stringify(context)}` : '';
+        return `[${timestamp}] [${level}] ${message}${contextStr}`;
+    }
+    writeToFile(message) {
+        try {
+            // Ensure log directory exists
+            const logDir = path.dirname(this.logFile);
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            // Ensure log file exists
+            if (!fs.existsSync(this.logFile)) {
+                fs.writeFileSync(this.logFile, '', 'utf8');
+            }
+            fs.appendFileSync(this.logFile, message + '\n', 'utf8');
+        }
+        catch (error) {
+            // If file write fails, at least output to console
+            console.error(`Failed to write to log file ${this.logFile}: ${error.message}`);
+        }
+    }
+    debug(message, context) {
+        if (this.shouldLog(LogLevel.DEBUG)) {
+            const formatted = this.formatMessage(LogLevel.DEBUG, message, context);
+            console.debug(formatted);
+            this.writeToFile(formatted);
+        }
+    }
+    info(message, context) {
+        if (this.shouldLog(LogLevel.INFO)) {
+            const formatted = this.formatMessage(LogLevel.INFO, message, context);
+            console.info(formatted);
+            this.writeToFile(formatted);
+        }
+    }
+    warn(message, context) {
+        if (this.shouldLog(LogLevel.WARN)) {
+            const formatted = this.formatMessage(LogLevel.WARN, message, context);
+            console.warn(formatted);
+            this.writeToFile(formatted);
+        }
+    }
+    error(message, context) {
+        if (this.shouldLog(LogLevel.ERROR)) {
+            const formatted = this.formatMessage(LogLevel.ERROR, message, context);
+            console.error(formatted);
+            this.writeToFile(formatted);
+        }
+    }
+    logRequest(command, data) {
+        this.info(`Received command: ${command}`, { data });
+    }
+    logServiceEvent(serviceName, event, details) {
+        this.info(`Service ${serviceName}: ${event}`, details);
+    }
+    logAIQuery(query, result) {
+        this.info(`AI Query: "${query}"`, { result });
+    }
+    logConfigUpdate(configType, config) {
+        // Safely record configuration updates, hide sensitive information
+        const safeConfig = { ...config };
+        if (safeConfig.apiKey) {
+            safeConfig.apiKey = '***' + safeConfig.apiKey.slice(-4);
+        }
+        this.info(`Configuration updated: ${configType}`, { config: safeConfig });
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();
+//# sourceMappingURL=logger.js.map