@mks2508/better-logger 0.0.2-alpha.2 → 0.3.0

package/src/cli/CommandProcessor.ts

@@ -11,20 +11,101 @@ 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);
     }
 
     /**
@@ -38,7 +119,70 @@ export class CommandProcessor {
      * Get a specific command
      */
     getCommand(name: string): ICommand | undefined {
-        return this.commands.get(name);
+        // 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.');
     }
 
     /**
@@ -47,6 +191,7 @@ export class CommandProcessor {
     async processCommand(commandString: string, logger: Logger): Promise<void> {
         if (!commandString.startsWith('/')) {
             logger.error('Invalid command. Commands must start with /');
+            this.addToHistory(commandString, false);
             return;
         }
 
@@ -54,16 +199,42 @@ export class CommandProcessor {
         const commandName = parts[0] || '';
         const args = parts.slice(1).join(' ');
 
-        const command = this.commands.get(commandName);
+        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);
         }
     }
 

package/src/cli/commands/HistoryCommand.ts

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview History management commands for CLI
+ */
+
+import type { ICommand } from '../CommandProcessor.js';
+import type { Logger } from '../../Logger.js';
+
+/**
+ * Show command history
+ */
+export class HistoryCommand implements ICommand {
+    name = 'history';
+    description = 'Show command execution history';
+    usage = '/history [limit] - Show recent commands (default: 10)';
+    category = 'system';
+    aliases = ['hist', 'h'];
+
+    execute(args: string, logger: Logger): void {
+        const processor = (logger as any).cliProcessor;
+        if (!processor) {
+            logger.error('CLI processor not available');
+            return;
+        }
+
+        const limit = parseInt(args) || 10;
+        const history = processor.getHistory().slice(0, limit);
+        
+        if (history.length === 0) {
+            logger.info('📝 No command history available');
+            return;
+        }
+
+        logger.info(`📋 Last ${history.length} commands:`);
+        
+        history.forEach((entry: any, index: number) => {
+            const status = entry.success ? '✅' : '❌';
+            const time = entry.timestamp.toLocaleTimeString();
+            logger.info(`${status} [${time}] ${entry.command}`);
+        });
+    }
+}
+
+/**
+ * Clear command history
+ */
+export class ClearHistoryCommand implements ICommand {
+    name = 'clearhistory';
+    description = 'Clear command execution history';
+    usage = '/clearhistory - Remove all command history';
+    category = 'system';
+    aliases = ['clrhist'];
+
+    execute(args: string, logger: Logger): void {
+        const processor = (logger as any).cliProcessor;
+        if (!processor) {
+            logger.error('CLI processor not available');
+            return;
+        }
+
+        processor.clearHistory();
+        logger.success('🗑️ Command history cleared');
+    }
+}
+
+/**
+ * Interactive mode command
+ */
+export class InteractiveCommand implements ICommand {
+    name = 'interactive';
+    description = 'Enter interactive CLI mode';
+    usage = '/interactive - Start interactive command mode';
+    category = 'system';
+    aliases = ['i', 'repl'];
+
+    execute(args: string, logger: Logger): void {
+        const processor = (logger as any).cliProcessor;
+        if (!processor) {
+            logger.error('CLI processor not available');
+            return;
+        }
+
+        processor.enterInteractiveMode(logger);
+    }
+}
+
+/**
+ * Plugin management command
+ */
+export class PluginsCommand implements ICommand {
+    name = 'plugins';
+    description = 'List loaded CLI plugins';
+    usage = '/plugins - Show all registered plugins';
+    category = 'system';
+    aliases = ['plug'];
+
+    execute(args: string, logger: Logger): void {
+        const processor = (logger as any).cliProcessor;
+        if (!processor) {
+            logger.error('CLI processor not available');
+            return;
+        }
+
+        const plugins = processor.getPlugins();
+        
+        if (plugins.length === 0) {
+            logger.info('🔌 No plugins registered');
+            return;
+        }
+
+        logger.info(`🔌 Loaded plugins (${plugins.length}):`);
+        
+        plugins.forEach((plugin: any) => {
+            logger.info(`  📦 ${plugin.name} v${plugin.version} - ${plugin.description}`);
+            logger.info(`     Commands: ${plugin.commands.map((c: any) => c.name).join(', ')}`);
+        });
+    }
+}

package/src/cli/index.ts

@@ -33,6 +33,12 @@ import {
     ClearBufferCommand, 
     BufferInfoCommand 
 } from './commands/ExportCommand.js';
+import { 
+    HistoryCommand, 
+    ClearHistoryCommand, 
+    InteractiveCommand, 
+    PluginsCommand 
+} from './commands/HistoryCommand.js';
 
 /**
  * Create and configure default CLI processor
@@ -55,5 +61,11 @@ export function createDefaultCLI(): CommandProcessor {
     processor.registerCommand(new ClearBufferCommand());
     processor.registerCommand(new BufferInfoCommand());
     
+    // Register new enhanced commands
+    processor.registerCommand(new HistoryCommand());
+    processor.registerCommand(new ClearHistoryCommand());
+    processor.registerCommand(new InteractiveCommand());
+    processor.registerCommand(new PluginsCommand());
+    
     return processor;
 }

package/src/constants.ts

@@ -2,7 +2,8 @@
  * @fileoverview Global constants for Advanced Logger
  */
 
-import type { LogLevel } from './types/index.js';
+import type { LogLevel, AdaptiveColors } from './types/index.js';
+import type { LevelStyleConfig } from './utils/index.js';
 
 /**
  * Default configuration values
@@ -15,6 +16,61 @@ export const DEFAULT_CONFIG = {
     theme: 'default' as const,
     bannerType: 'simple' as const,
     bufferSize: 1000,
+    autoDetectTheme: true,
+} as const;
+
+/**
+ * Basic level styles for core module (minimal CSS styling)
+ */
+export const LEVEL_STYLES: Record<LogLevel | 'success', LevelStyleConfig> = {
+    debug: {
+        emoji: '🔍',
+        label: 'DEBUG',
+        background: 'linear-gradient(90deg, #6c757d, #495057)',
+        color: '#ffffff',
+        border: '1px solid #6c757d',
+        shadow: '0 2px 4px rgba(108, 117, 125, 0.3)'
+    },
+    info: {
+        emoji: 'ℹ️',
+        label: 'INFO',
+        background: 'linear-gradient(90deg, #007bff, #0056b3)',
+        color: '#ffffff',
+        border: '1px solid #007bff',
+        shadow: '0 2px 4px rgba(0, 123, 255, 0.3)'
+    },
+    warn: {
+        emoji: '⚠️',
+        label: 'WARN',
+        background: 'linear-gradient(90deg, #ffc107, #e0a800)',
+        color: '#000000',
+        border: '1px solid #ffc107',
+        shadow: '0 2px 4px rgba(255, 193, 7, 0.3)'
+    },
+    error: {
+        emoji: '❌',
+        label: 'ERROR',
+        background: 'linear-gradient(90deg, #dc3545, #c82333)',
+        color: '#ffffff',
+        border: '1px solid #dc3545',
+        shadow: '0 2px 4px rgba(220, 53, 69, 0.3)'
+    },
+    critical: {
+        emoji: '🚨',
+        label: 'CRITICAL',
+        background: 'linear-gradient(90deg, #8B0000, #FF0000)',
+        color: '#ffffff',
+        border: '2px solid #FF0000',
+        shadow: '0 4px 8px rgba(255, 0, 0, 0.4)'
+    },
+    success: {
+        emoji: '✅',
+        label: 'SUCCESS',
+        background: 'linear-gradient(90deg, #28a745, #1e7e34)',
+        color: '#ffffff',
+        border: '1px solid #28a745',
+        shadow: '0 2px 4px rgba(40, 167, 69, 0.3)'
+    }
 } as const;
 
 /**
@@ -86,4 +142,30 @@ export const LEVEL_PRIORITIES: Record<LogLevel, number> = {
     warn: 2,
     error: 3,
     critical: 4,
-} as const;
+} as const;
+
+/**
+ * Adaptive color configurations for DevTools theme compatibility
+ */
+export const ADAPTIVE_COLORS = {
+    timestamp: {
+        light: '#666666',
+        dark: '#a0a0a0',
+    },
+    messageText: {
+        light: '#2d3748',
+        dark: '#f7fafc',
+    },
+    prefix: {
+        light: '#2d3748',
+        dark: '#e2e8f0',
+    },
+    prefixBackground: {
+        light: '#2d3748',
+        dark: '#4a5568',
+    },
+    location: {
+        light: '#718096',
+        dark: '#a0aec0',
+    },
+} as const satisfies Record<string, AdaptiveColors>;