@z-test/memory-bank-mcp/dist/utils/LogManager.js

MCP Server for managing Memory Bank

/**
 * LogManager - Utility for managing logs in Memory Bank MCP
 *
 * This utility provides functions for logging messages with different levels
 * and controls log visibility based on debug mode.
 */
/**
 * Log levels
 */
export var LogLevel;
(function (LogLevel) {
    LogLevel["DEBUG"] = "debug";
    LogLevel["INFO"] = "info";
    LogLevel["WARN"] = "warn";
    LogLevel["ERROR"] = "error";
})(LogLevel || (LogLevel = {}));
/**
 * Default configuration
 */
const DEFAULT_CONFIG = {
    debugMode: false,
    showTimestamp: true,
    showSource: true,
    minLevel: LogLevel.INFO
};
/**
 * Log Manager class
 */
export class LogManager {
    /**
     * Private constructor to enforce singleton pattern
     */
    constructor(config = {}) {
        this.config = { ...DEFAULT_CONFIG, ...config };
    }
    /**
     * Get the singleton instance
     */
    static getInstance() {
        if (!LogManager.instance) {
            LogManager.instance = new LogManager();
        }
        return LogManager.instance;
    }
    /**
     * Configure the log manager
     */
    configure(config) {
        this.config = { ...this.config, ...config };
    }
    /**
     * Enable debug mode
     */
    enableDebugMode() {
        this.config.debugMode = true;
    }
    /**
     * Disable debug mode
     */
    disableDebugMode() {
        this.config.debugMode = false;
    }
    /**
     * Check if a message should be logged based on current configuration
     */
    shouldLog(level) {
        const levelPriority = {
            [LogLevel.DEBUG]: 0,
            [LogLevel.INFO]: 1,
            [LogLevel.WARN]: 2,
            [LogLevel.ERROR]: 3
        };
        // Always log errors regardless of debug mode
        if (level === LogLevel.ERROR) {
            return true;
        }
        // Debug messages only in debug mode
        if (level === LogLevel.DEBUG && !this.config.debugMode) {
            return false;
        }
        // Check minimum level
        return levelPriority[level] >= levelPriority[this.config.minLevel];
    }
    /**
     * Format a log message
     */
    formatMessage(level, source, message) {
        const parts = [];
        // Add timestamp if configured
        if (this.config.showTimestamp) {
            parts.push(`[${new Date().toISOString()}]`);
        }
        // Add level
        parts.push(`[${level.toUpperCase()}]`);
        // Add source if configured
        if (this.config.showSource && source) {
            parts.push(`[${source}]`);
        }
        // Add message
        parts.push(message);
        return parts.join(' ');
    }
    /**
     * Log a debug message
     */
    debug(source, message) {
        if (this.shouldLog(LogLevel.DEBUG)) {
            console.error(this.formatMessage(LogLevel.DEBUG, source, message));
        }
    }
    /**
     * Log an info message
     */
    info(source, message) {
        if (this.shouldLog(LogLevel.INFO)) {
            console.error(this.formatMessage(LogLevel.INFO, source, message));
        }
    }
    /**
     * Log a warning message
     */
    warn(source, message) {
        if (this.shouldLog(LogLevel.WARN)) {
            console.warn(this.formatMessage(LogLevel.WARN, source, message));
        }
    }
    /**
     * Log an error message
     */
    error(source, message) {
        if (this.shouldLog(LogLevel.ERROR)) {
            console.error(this.formatMessage(LogLevel.ERROR, source, message));
        }
    }
    /**
     * Log a message with a specific level
     */
    log(level, source, message) {
        switch (level) {
            case LogLevel.DEBUG:
                this.debug(source, message);
                break;
            case LogLevel.INFO:
                this.info(source, message);
                break;
            case LogLevel.WARN:
                this.warn(source, message);
                break;
            case LogLevel.ERROR:
                this.error(source, message);
                break;
        }
    }
}
/**
 * Convenience function to get the log manager instance
 */
export function getLogManager() {
    return LogManager.getInstance();
}
/**
 * Convenience functions for logging
 */
export const logger = {
    debug: (source, message) => getLogManager().debug(source, message),
    info: (source, message) => getLogManager().info(source, message),
    warn: (source, message) => getLogManager().warn(source, message),
    error: (source, message) => getLogManager().error(source, message),
    log: (level, source, message) => getLogManager().log(level, source, message)
};
//# sourceMappingURL=LogManager.js.map