@mks2508/better-logger 5.0.1 → 5.0.2

package/src/ScopedLogger.ts

@@ -1,256 +0,0 @@
-import { Logger } from './Logger.js';
-import type { TimerEntry, Bindings, ISpinnerHandle, IBoxOptions, ITableOptions, CLILogLevel } from './types/index.js';
-
-export class ScopedLogger {
-    private readonly parent: Logger;
-    private readonly scopeName: string;
-    private badgeList: string[] = [];
-    private contextStack: string[] = [];
-    private _timers?: Map<string, TimerEntry>;
-
-    constructor(parent: Logger, scopeName: string) {
-        this.parent = parent;
-        this.scopeName = scopeName;
-    }
-
-    private get timers(): Map<string, TimerEntry> {
-        if (!this._timers) this._timers = new Map();
-        return this._timers;
-    }
-
-    private getBindings(): Bindings {
-        return {
-            scope: this.getScopePrefix(),
-            badges: this.badgeList.length > 0 ? [...this.badgeList] : undefined,
-        };
-    }
-
-    private getScopePrefix(): string {
-        if (this.contextStack.length === 0) return this.scopeName;
-        return [this.scopeName, ...this.contextStack].join(':');
-    }
-
-    badges(badges: string[]): this {
-        this.badgeList = [...badges];
-        return this;
-    }
-
-    badge(badge: string): this {
-        if (!this.badgeList.includes(badge)) {
-            this.badgeList.push(badge);
-        }
-        return this;
-    }
-
-    clearBadges(): this {
-        this.badgeList = [];
-        return this;
-    }
-
-    style(presetName: string): this {
-        this.parent.setTheme(presetName as any);
-        return this;
-    }
-
-    context(contextName: string): ContextLogger {
-        return new ContextLogger(this, contextName);
-    }
-
-    time(label: string): void {
-        this.timers.set(label, {
-            label: `${this.scopeName}:${label}`,
-            startTime: performance.now(),
-        });
-    }
-
-    timeEnd(label: string): number | undefined {
-        const timer = this.timers.get(label);
-        if (!timer) {
-            this.warn(`Timer '${label}' not found`);
-            return undefined;
-        }
-        const elapsed = performance.now() - timer.startTime;
-        this.timers.delete(label);
-        this.success(`Timer: ${label} - ${elapsed.toFixed(2)}ms`);
-        return elapsed;
-    }
-
-    debug(...args: any[]): void {
-        this.parent.logWithBindings(this.getBindings(), 'debug', ...args);
-    }
-
-    info(...args: any[]): void {
-        this.parent.logWithBindings(this.getBindings(), 'info', ...args);
-    }
-
-    warn(...args: any[]): void {
-        this.parent.logWithBindings(this.getBindings(), 'warn', ...args);
-    }
-
-    error(...args: any[]): void {
-        this.parent.logWithBindings(this.getBindings(), 'error', ...args);
-    }
-
-    success(...args: any[]): void {
-        const bindings = this.getBindings();
-        this.parent.logWithBindings(bindings, 'info', ...args);
-    }
-
-    critical(...args: any[]): void {
-        this.parent.logWithBindings(this.getBindings(), 'critical', ...args);
-    }
-
-    trace(...args: any[]): void {
-        this.parent.logWithBindings(this.getBindings(), 'debug', ...args);
-        console.trace(`[${this.scopeName}]`);
-    }
-
-    // ===== CLI PRIMITIVES (v5.0 delegation) =====
-
-    /** @see Logger.step */
-    step(current: number, total: number, message: string): void {
-        this.parent.step(current, total, message);
-    }
-
-    /** @see Logger.header */
-    header(title: string, subtitle?: string): void {
-        this.parent.header(title, subtitle);
-    }
-
-    /** @see Logger.divider */
-    divider(): void {
-        this.parent.divider();
-    }
-
-    /** @see Logger.blank */
-    blank(): void {
-        this.parent.blank();
-    }
-
-    /** @see Logger.box */
-    box(content: string, options?: IBoxOptions): void {
-        this.parent.box(content, options);
-    }
-
-    /** @see Logger.cliTable */
-    cliTable(rows: Record<string, unknown>[], options?: ITableOptions): void {
-        this.parent.cliTable(rows, options);
-    }
-
-    /** @see Logger.spinner */
-    spinner(message: string): ISpinnerHandle {
-        return this.parent.spinner(message);
-    }
-
-    /** @see Logger.setCLILevel */
-    setCLILevel(level: CLILogLevel): void {
-        this.parent.setCLILevel(level);
-    }
-
-    _pushContext(context: string): void {
-        this.contextStack.push(context);
-    }
-
-    _popContext(): void {
-        this.contextStack.pop();
-    }
-}
-
-export class APILogger extends ScopedLogger {
-    constructor(parent: Logger, apiName: string) {
-        super(parent, `API:${apiName}`);
-        this.badge('API');
-    }
-
-    slow(message: string, duration?: number): void {
-        this.badge('SLOW');
-        const msg = duration ? `${message} (${duration}ms)` : message;
-        this.warn(msg);
-    }
-
-    rateLimit(message: string): void {
-        this.badge('RATE_LIMIT');
-        this.warn(message);
-    }
-
-    auth(message: string): void {
-        this.badge('AUTH');
-        this.error(message);
-    }
-
-    deprecated(message: string): void {
-        this.badge('DEPRECATED');
-        this.warn(message);
-    }
-}
-
-export class ComponentLogger extends ScopedLogger {
-    constructor(parent: Logger, componentName: string) {
-        super(parent, componentName);
-        this.badge('COMPONENT');
-    }
-
-    lifecycle(event: string, message?: string): void {
-        this.badge('LIFECYCLE');
-        const msg = message ? `${event}: ${message}` : event;
-        this.info(msg);
-    }
-
-    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);
-        }
-    }
-
-    propsChange(changes: Record<string, any>): void {
-        this.badge('PROPS');
-        this.debug('Props changed:', changes);
-    }
-}
-
-export class ContextLogger {
-    private parentLogger: ScopedLogger;
-    private contextName: string;
-
-    constructor(parentLogger: ScopedLogger, contextName: string) {
-        this.parentLogger = parentLogger;
-        this.contextName = contextName;
-    }
-
-    run<T>(fn: () => T): T {
-        this.parentLogger._pushContext(this.contextName);
-        try {
-            return fn();
-        } finally {
-            this.parentLogger._popContext();
-        }
-    }
-
-    async runAsync<T>(fn: () => Promise<T>): Promise<T> {
-        this.parentLogger._pushContext(this.contextName);
-        try {
-            return await fn();
-        } finally {
-            this.parentLogger._popContext();
-        }
-    }
-
-    start(): void {
-        this.parentLogger._pushContext(this.contextName);
-    }
-
-    end(): void {
-        this.parentLogger._popContext();
-    }
-
-    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));
-    }
-}

package/src/cli/commands/ConfigCommand.ts

@@ -1,93 +0,0 @@
-/**
- * @fileoverview Configuration commands for Advanced Logger CLI
- */
-
-import type { ICommand } from '../CommandProcessor.js';
-import type { Logger } from '../../Logger.js';
-import type { ThemeVariant, BannerType, Verbosity } from '../../types/index.js';
-
-/**
- * Configuration command handler
- */
-export class ConfigCommand implements ICommand {
-    name = 'config';
-    description = 'Show or update logger configuration';
-    usage = '/config [json|key=value,...]';
-
-    execute(args: string, logger: Logger): void {
-        if (!args) {
-            this.showStatus(logger);
-            return;
-        }
-
-        try {
-            // Try to parse as JSON first
-            if (args.startsWith('{')) {
-                const config = JSON.parse(args);
-                this.applyConfig(config, logger);
-            } else {
-                // Parse key=value pairs
-                const pairs = args.split(',').map(pair => pair.trim().split('='));
-                const config: any = {};
-                pairs.forEach(([key, value]) => {
-                    if (key && value) {
-                        config[key.trim()] = value.trim().replace(/["']/g, '');
-                    }
-                });
-                this.applyConfig(config, logger);
-            }
-        } catch (error) {
-            logger.error('Invalid config format. Use JSON or key=value pairs:', error);
-            logger.info('Examples: /config {"theme":"dark"} or /config theme=neon,verbosity=debug');
-        }
-    }
-
-    private showStatus(logger: Logger): void {
-        const statusData = {
-            theme: logger.getConfig().theme || 'default',
-            verbosity: logger.getConfig().verbosity,
-            colors: logger.getConfig().enableColors,
-            timestamps: logger.getConfig().enableTimestamps,
-            stackTrace: logger.getConfig().enableStackTrace,
-            globalPrefix: logger.getConfig().globalPrefix || 'none',
-            bannerType: logger.getConfig().bannerType || 'simple',
-            handlers: logger.getHandlers().length
-        };
-
-        logger.group('⚙️ Logger Configuration');
-        logger.table(statusData);
-        logger.groupEnd();
-    }
-
-    private applyConfig(config: any, logger: Logger): void {
-        const validKeys = ['theme', 'verbosity', 'enableColors', 'enableTimestamps', 'enableStackTrace', 'globalPrefix', 'bannerType'];
-        const applied: string[] = [];
-
-        Object.entries(config).forEach(([key, value]) => {
-            if (validKeys.includes(key)) {
-                if (key === 'theme' && typeof value === 'string') {
-                    logger.setTheme(value as ThemeVariant);
-                    applied.push(`${key}=${value}`);
-                } else if (key === 'bannerType' && typeof value === 'string') {
-                    logger.setBannerType(value as BannerType);
-                    applied.push(`${key}=${value}`);
-                } else if (key === 'verbosity') {
-                    logger.setVerbosity(value as Verbosity);
-                    applied.push(`${key}=${value}`);
-                } else if (key === 'globalPrefix') {
-                    logger.setGlobalPrefix(value as string);
-                    applied.push(`${key}=${value}`);
-                } else {
-                    logger.updateConfig({ [key]: value });
-                    applied.push(`${key}=${value}`);
-                }
-            } else {
-                logger.warn(`Invalid config key: ${key}`);
-            }
-        });
-
-        if (applied.length > 0) {
-            logger.success(`Configuration updated: ${applied.join(', ')}`);
-        }
-    }
-}