@mks2508/better-logger 0.14.0-alpha.2 → 0.18.2-alpha.1

package/src/ScopedLogger.ts

@@ -1,454 +0,0 @@
-/**
- * @fileoverview ScopedLogger con badges y logging contextual
- * @version 0.3.0
- * @since 2024
- * 
- * Proporciona loggers especializados con contexto, badges automáticos
- * y características avanzadas para componentes y APIs.
- */
-
-import { Logger } from './Logger.js';
-import type { LoggerConfig, LogLevel, Verbosity, BannerType, StyleOptions, ILogHandler } from './types/index.js';
-
-/**
- * Logger con scope mejorado con badges y API simplificada
- * 
- * @class ScopedLogger
- * @extends Logger
- * @description Logger contextual que añade prefijos y badges automáticamente
- * 
- * @example
- * const dbLogger = logger.scope('Database');
- * dbLogger.info('Conectando...'); // [Database] Conectando...
- * 
- * // Con badges personalizados
- * dbLogger.badge('SLOW').warn('Query lenta detectada');
- * // [SLOW] [Database] Query lenta detectada
- * 
- * @since 0.3.0
- */
-export class ScopedLogger extends Logger {
-    private parentLogger: Logger;
-    private scopeName: string;
-    private badgeList: string[] = [];
-    private contextStack: string[] = [];
-
-    constructor(parentLogger: Logger, scopeName: string, config?: Partial<LoggerConfig>) {
-        // Initialize with parent's config plus any overrides
-        super({ ...parentLogger.getConfig(), ...config });
-        this.parentLogger = parentLogger;
-        this.scopeName = scopeName;
-        
-        // Inherit parent's handlers
-        const parentHandlers = parentLogger.getHandlers();
-        parentHandlers.forEach(handler => this.addHandler(handler));
-    }
-
-    /**
-     * Añade múltiples badges a este logger con scope
-     * 
-     * @param {string[]} badges - Array de badges a añadir
-     * @returns {ScopedLogger} Esta instancia para encadenamiento
-     * 
-     * @example
-     * const api = logger.scope('API');
-     * api.badges(['v2', 'beta', 'cached'])
-     *    .info('Respuesta desde caché');
-     * // [v2] [beta] [cached] [API] Respuesta desde caché
-     * 
-     * @since 0.3.0
-     */
-    badges(badges: string[]): ScopedLogger {
-        this.badgeList = [...badges];
-        return this;
-    }
-
-    /**
-     * Añade un badge individual
-     * 
-     * @param {string} badge - Badge a añadir
-     * @returns {ScopedLogger} Esta instancia para encadenamiento
-     * 
-     * @example
-     * dbLogger.badge('SLOW').warn('Query tardó 3s');
-     * // [SLOW] [Database] Query tardó 3s
-     * 
-     * @since 0.3.0
-     */
-    badge(badge: string): ScopedLogger {
-        if (!this.badgeList.includes(badge)) {
-            this.badgeList.push(badge);
-        }
-        return this;
-    }
-
-    /**
-     * Elimina todos los badges
-     * 
-     * @returns {ScopedLogger} Esta instancia para encadenamiento
-     * 
-     * @example
-     * api.clearBadges().info('Sin badges');
-     * // [API] Sin badges
-     * 
-     * @since 0.3.0
-     */
-    clearBadges(): ScopedLogger {
-        this.badgeList = [];
-        return this;
-    }
-
-    /**
-     * Establece un preset de estilo para este logger con scope
-     * 
-     * @param {string} presetName - Nombre del preset a aplicar
-     * @returns {ScopedLogger} Esta instancia para encadenamiento
-     * 
-     * @example
-     * const errorLogger = logger.scope('ErrorHandler')
-     *   .style('cyberpunk');
-     * 
-     * @since 0.3.0
-     */
-    style(presetName: string): ScopedLogger {
-        this.setTheme(presetName as any); // Will be updated when we implement presets
-        return this;
-    }
-
-    /**
-     * Crea un contexto temporal que se limpia automáticamente
-     * 
-     * @param {string} contextName - Nombre del contexto
-     * @returns {ContextLogger} Logger con contexto temporal
-     * 
-     * @example
-     * const db = logger.scope('Database');
-     * 
-     * // Contexto temporal para una operación
-     * db.context('Migration').run(() => {
-     *   db.info('Iniciando migración');
-     *   db.success('Tablas creadas');
-     * });
-     * // Contexto automáticamente limpiado
-     * 
-     * @since 0.3.0
-     */
-    context(contextName: string): ContextLogger {
-        return new ContextLogger(this, contextName);
-    }
-
-    /**
-     * Sobrescribe el logging principal para incluir badges
-     * @protected
-     * @param {LogLevel} level - Nivel del log
-     * @param {...any} args - Argumentos del log
-     */
-    protected log(level: LogLevel, ...args: any[]): void {
-        // Build the enhanced message with badges
-        const badges = this.getBadgeString();
-        const scopePrefix = this.getScopePrefix();
-        
-        let enhancedMessage = '';
-        if (badges) enhancedMessage += badges + ' ';
-        if (scopePrefix) enhancedMessage += `[${scopePrefix}] `;
-        
-        if (args.length > 0) {
-            enhancedMessage += String(args[0]);
-            // Replace the first argument with our enhanced message
-            args[0] = enhancedMessage;
-        }
-
-        // Call parent's log method
-        super.log(level, ...args);
-    }
-
-    /**
-     * Obtiene la cadena de badges formateada
-     * @private
-     * @returns {string} Badges formateados como [BADGE1][BADGE2]
-     */
-    private getBadgeString(): string {
-        if (this.badgeList.length === 0) return '';
-        return this.badgeList.map(badge => `[${badge}]`).join('');
-    }
-
-    /**
-     * Obtiene el prefijo del scope (incluye stack de contexto)
-     * @private
-     * @returns {string} Prefijo completo con contextos
-     */
-    private getScopePrefix(): string {
-        const parts = [this.scopeName, ...this.contextStack].filter(Boolean);
-        return parts.join(':');
-    }
-
-    /**
-     * Método interno para añadir contexto
-     * @internal
-     */
-    _pushContext(context: string): void {
-        this.contextStack.push(context);
-    }
-
-    /**
-     * Método interno para eliminar contexto
-     * @internal
-     */
-    _popContext(): void {
-        this.contextStack.pop();
-    }
-}
-
-/**
- * Logger específico para APIs con badges comunes de API
- * 
- * @class APILogger
- * @extends ScopedLogger
- * @description Logger especializado para endpoints y servicios API
- * 
- * @example
- * const api = logger.api('REST');
- * api.info('GET /users');
- * // [API] [REST] GET /users
- * 
- * api.slow('Query lenta', 3500);
- * // [API] [SLOW] [REST] Query lenta (3500ms)
- * 
- * @since 0.3.0
- */
-export class APILogger extends ScopedLogger {
-    constructor(parentLogger: Logger, apiName: string, config?: Partial<LoggerConfig>) {
-        super(parentLogger, `API:${apiName}`, config);
-        this.badge('API');
-    }
-
-    /**
-     * Registra operaciones lentas
-     * 
-     * @param {string} message - Mensaje sobre la operación lenta
-     * @param {number} duration - Duración en milisegundos (opcional)
-     * 
-     * @example
-     * api.slow('Query compleja', 5000);
-     * api.slow('Procesamiento pesado');
-     * 
-     * @since 0.3.0
-     */
-    slow(message: string, duration?: number): void {
-        this.badge('SLOW');
-        const msg = duration ? `${message} (${duration}ms)` : message;
-        this.warn(msg);
-    }
-
-    /**
-     * Registra límites de tasa alcanzados
-     * 
-     * @param {string} message - Mensaje sobre el límite
-     * 
-     * @example
-     * api.rateLimit('Límite excedido: 100 req/min');
-     * 
-     * @since 0.3.0
-     */
-    rateLimit(message: string): void {
-        this.badge('RATE_LIMIT');
-        this.warn(message);
-    }
-
-    /**
-     * Registra problemas de autenticación
-     * 
-     * @param {string} message - Mensaje de autenticación
-     * 
-     * @example
-     * api.auth('Token inválido o expirado');
-     * api.auth('Credenciales incorrectas');
-     * 
-     * @since 0.3.0
-     */
-    auth(message: string): void {
-        this.badge('AUTH');
-        this.error(message);
-    }
-
-    /**
-     * Registra advertencias de deprecación
-     * 
-     * @param {string} message - Mensaje de deprecación
-     * 
-     * @example
-     * api.deprecated('Este endpoint será eliminado en v2.0');
-     * api.deprecated('Usar /v2/users en lugar de /users');
-     * 
-     * @since 0.3.0
-     */
-    deprecated(message: string): void {
-        this.badge('DEPRECATED');
-        this.warn(message);
-    }
-}
-
-/**
- * Logger específico para componentes de UI
- * 
- * @class ComponentLogger
- * @extends ScopedLogger
- * @description Logger especializado para componentes con eventos de ciclo de vida
- * 
- * @example
- * const authForm = logger.component('AuthForm');
- * authForm.lifecycle('mounted');
- * authForm.stateChange('idle', 'loading');
- * 
- * @since 0.3.0
- */
-export class ComponentLogger extends ScopedLogger {
-    constructor(parentLogger: Logger, componentName: string, config?: Partial<LoggerConfig>) {
-        super(parentLogger, componentName, config);
-        this.badge('COMPONENT');
-    }
-
-    /**
-     * Registra eventos del ciclo de vida del componente
-     * 
-     * @param {string} event - Nombre del evento (mounted, unmounted, updated, etc)
-     * @param {string} message - Mensaje adicional (opcional)
-     * 
-     * @example
-     * component.lifecycle('mounted', 'Componente listo');
-     * component.lifecycle('beforeDestroy');
-     * 
-     * @since 0.3.0
-     */
-    lifecycle(event: string, message?: string): void {
-        this.badge('LIFECYCLE');
-        const msg = message ? `${event}: ${message}` : event;
-        this.info(msg);
-    }
-
-    /**
-     * Registra cambios de estado
-     * 
-     * @param {string} from - Estado anterior
-     * @param {string} to - Estado nuevo
-     * @param {any} data - Datos adicionales (opcional)
-     * 
-     * @example
-     * component.stateChange('idle', 'loading');
-     * component.stateChange('loading', 'error', { code: 404 });
-     * 
-     * @since 0.3.0
-     */
-    stateChange(from: string, to: string, data?: any): void {
-        this.badge('STATE');
-        const msg = `${from} → ${to}`;
-        if (data) {
-            this.info(msg, data);
-        } else {
-            this.info(msg);
-        }
-    }
-
-    /**
-     * Registra cambios en las propiedades
-     * 
-     * @param {Record<string, any>} changes - Objeto con los cambios
-     * 
-     * @example
-     * component.propsChange({
-     *   user: newUser,
-     *   isActive: true
-     * });
-     * 
-     * @since 0.3.0
-     */
-    propsChange(changes: Record<string, any>): void {
-        this.badge('PROPS');
-        this.debug('Props changed:', changes);
-    }
-}
-
-/**
- * Logger de contexto temporal que se limpia automáticamente
- * 
- * @class ContextLogger
- * @description Proporciona un contexto temporal para operaciones agrupadas
- * 
- * @example
- * const db = logger.scope('Database');
- * 
- * // El contexto se limpia automáticamente al finalizar
- * db.context('Transaction').run(() => {
- *   db.info('Iniciando transacción');
- *   db.success('Transacción completada');
- * });
- * 
- * @since 0.3.0
- */
-export class ContextLogger {
-    private parentLogger: ScopedLogger;
-    private contextName: string;
-
-    constructor(parentLogger: ScopedLogger, contextName: string) {
-        this.parentLogger = parentLogger;
-        this.contextName = contextName;
-    }
-
-    /**
-     * Ejecuta una función con este contexto activo
-     * 
-     * @template T - Tipo de retorno de la función
-     * @param {Function} fn - Función a ejecutar
-     * @returns {T} Resultado de la función
-     * 
-     * @example
-     * const result = logger.context('Process').run(() => {
-     *   logger.info('Procesando...');
-     *   return processData();
-     * });
-     * 
-     * @since 0.3.0
-     */
-    run<T>(fn: () => T): T {
-        this.parentLogger._pushContext(this.contextName);
-        try {
-            return fn();
-        } finally {
-            this.parentLogger._popContext();
-        }
-    }
-
-    /**
-     * Run an async function with this context active
-     */
-    async runAsync<T>(fn: () => Promise<T>): Promise<T> {
-        this.parentLogger._pushContext(this.contextName);
-        try {
-            return await fn();
-        } finally {
-            this.parentLogger._popContext();
-        }
-    }
-
-    /**
-     * Start the context (manual mode)
-     */
-    start(): void {
-        this.parentLogger._pushContext(this.contextName);
-    }
-
-    /**
-     * End the context (manual mode)
-     */
-    end(): void {
-        this.parentLogger._popContext();
-    }
-
-    // Delegate logging methods to parent with context
-    debug(...args: any[]): void { this.parentLogger.debug(...args); }
-    info(...args: any[]): void { this.parentLogger.info(...args); }
-    warn(...args: any[]): void { this.parentLogger.warn(...args); }
-    error(...args: any[]): void { this.parentLogger.error(...args); }
-    success(...args: any[]): void { this.parentLogger.success(...args); }
-    critical(...args: any[]): void { this.parentLogger.critical(...args); }
-}

package/src/cli/CommandProcessor.ts

@@ -1,248 +0,0 @@
-/**
- * @fileoverview CLI Command processor for Advanced Logger
- */
-
-import type { Logger } from '../Logger.js';
-
-/**
- * Base interface for CLI commands
- */
-export interface ICommand {
-    name: string;
-    description: string;
-    usage: string;
-    category?: string;
-    aliases?: string[];
-    execute(args: string, logger: Logger): void | Promise<void>;
-}
-
-/**
- * Plugin interface for extending CLI functionality
- */
-export interface ICLIPlugin {
-    name: string;
-    version: string;
-    description: string;
-    commands: ICommand[];
-    initialize?(processor: CommandProcessor, logger: Logger): void;
-    cleanup?(): void;
-}
-
-/**
- * Command history entry
- */
-interface HistoryEntry {
-    command: string;
-    timestamp: Date;
-    success: boolean;
-}
-
-/**
- * CLI command processor
- */
-export class CommandProcessor {
-    private commands: Map<string, ICommand> = new Map();
-    private aliases: Map<string, string> = new Map();
-    private plugins: Map<string, ICLIPlugin> = new Map();
-    private history: HistoryEntry[] = [];
-    private maxHistorySize: number = 100;
-    private isInteractiveMode: boolean = false;
-
-    /**
-     * Register a command
-     */
-    registerCommand(command: ICommand): void {
-        this.commands.set(command.name, command);
-        
-        // Register aliases
-        if (command.aliases) {
-            for (const alias of command.aliases) {
-                this.aliases.set(alias, command.name);
-            }
-        }
-    }
-    
-    /**
-     * Register a plugin
-     */
-    registerPlugin(plugin: ICLIPlugin, logger?: Logger): void {
-        if (this.plugins.has(plugin.name)) {
-            throw new Error(`Plugin ${plugin.name} is already registered`);
-        }
-        
-        this.plugins.set(plugin.name, plugin);
-        
-        // Register plugin commands
-        for (const command of plugin.commands) {
-            this.registerCommand(command);
-        }
-        
-        // Initialize plugin
-        if (plugin.initialize && logger) {
-            plugin.initialize(this, logger);
-        }
-    }
-    
-    /**
-     * Unregister a plugin
-     */
-    unregisterPlugin(pluginName: string): void {
-        const plugin = this.plugins.get(pluginName);
-        if (!plugin) return;
-        
-        // Remove plugin commands
-        for (const command of plugin.commands) {
-            this.commands.delete(command.name);
-            if (command.aliases) {
-                for (const alias of command.aliases) {
-                    this.aliases.delete(alias);
-                }
-            }
-        }
-        
-        // Cleanup plugin
-        if (plugin.cleanup) {
-            plugin.cleanup();
-        }
-        
-        this.plugins.delete(pluginName);
-    }
-
-    /**
-     * Get all registered commands
-     */
-    getCommands(): ICommand[] {
-        return Array.from(this.commands.values());
-    }
-
-    /**
-     * Get a specific command
-     */
-    getCommand(name: string): ICommand | undefined {
-        // Check direct command name
-        let command = this.commands.get(name);
-        if (command) return command;
-        
-        // Check aliases
-        const aliasTarget = this.aliases.get(name);
-        if (aliasTarget) {
-            return this.commands.get(aliasTarget);
-        }
-        
-        return undefined;
-    }
-    
-    /**
-     * Get command history
-     */
-    getHistory(): HistoryEntry[] {
-        return [...this.history];
-    }
-    
-    /**
-     * Clear command history
-     */
-    clearHistory(): void {
-        this.history = [];
-    }
-    
-    /**
-     * Get registered plugins
-     */
-    getPlugins(): ICLIPlugin[] {
-        return Array.from(this.plugins.values());
-    }
-    
-    /**
-     * Enter interactive mode
-     */
-    enterInteractiveMode(logger: Logger): void {
-        this.isInteractiveMode = true;
-        logger.info('🔧 Interactive CLI mode activated. Type /exit to quit, /help for commands.');
-        
-        // Set up browser console listener for interactive commands
-        if (typeof window !== 'undefined') {
-            this.setupBrowserInteractiveMode(logger);
-        }
-    }
-    
-    /**
-     * Exit interactive mode
-     */
-    exitInteractiveMode(): void {
-        this.isInteractiveMode = false;
-    }
-    
-    /**
-     * Setup browser interactive mode
-     */
-    private setupBrowserInteractiveMode(logger: Logger): void {
-        // Add global CLI function for browser usage
-        (window as any).cli = (commandString: string) => {
-            return this.processCommand(`/${commandString}`, logger);
-        };
-        
-        logger.info('💡 Use cli("command") to execute CLI commands in browser console.');
-    }
-
-    /**
-     * Process a CLI command
-     */
-    async processCommand(commandString: string, logger: Logger): Promise<void> {
-        if (!commandString.startsWith('/')) {
-            logger.error('Invalid command. Commands must start with /');
-            this.addToHistory(commandString, false);
-            return;
-        }
-
-        const parts = commandString.slice(1).split(' ');
-        const commandName = parts[0] || '';
-        const args = parts.slice(1).join(' ');
-
-        const command = this.getCommand(commandName);
-        if (!command) {
-            logger.error(`Unknown command: ${commandName}. Type /help for available commands.`);
-            
-            // Suggest similar commands
-            const suggestions = this.getSuggestions(commandName);
-            if (suggestions.length > 0) {
-                logger.info(`📋 Did you mean: ${suggestions.slice(0, 3).join(', ')}?`);
-            }
-            
-            this.addToHistory(commandString, false);
-            return;
-        }
-
-        try {
-            await command.execute(args || '', logger);
-            this.addToHistory(commandString, true);
-        } catch (error) {
-            logger.error(`Command '${commandName}' failed:`, error);
-            this.addToHistory(commandString, false);
-        }
-    }
-    
-    /**
-     * Add command to history
-     */
-    private addToHistory(command: string, success: boolean): void {
-        this.history.unshift({
-            command,
-            timestamp: new Date(),
-            success
-        });
-        
-        // Limit history size
-        if (this.history.length > this.maxHistorySize) {
-            this.history = this.history.slice(0, this.maxHistorySize);
-        }
-    }
-
-    /**
-     * Get command suggestions for partial matches
-     */
-    getSuggestions(partial: string): string[] {
-        const commandNames = Array.from(this.commands.keys());
-        return commandNames.filter(name => name.startsWith(partial));
-    }
-}