@mks2508/better-logger 0.0.1

package/src/cli/CommandProcessor.ts

@@ -0,0 +1,77 @@
+/**
+ * @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;
+    execute(args: string, logger: Logger): void | Promise<void>;
+}
+
+/**
+ * CLI command processor
+ */
+export class CommandProcessor {
+    private commands: Map<string, ICommand> = new Map();
+
+    /**
+     * Register a command
+     */
+    registerCommand(command: ICommand): void {
+        this.commands.set(command.name, command);
+    }
+
+    /**
+     * Get all registered commands
+     */
+    getCommands(): ICommand[] {
+        return Array.from(this.commands.values());
+    }
+
+    /**
+     * Get a specific command
+     */
+    getCommand(name: string): ICommand | undefined {
+        return this.commands.get(name);
+    }
+
+    /**
+     * Process a CLI command
+     */
+    async processCommand(commandString: string, logger: Logger): Promise<void> {
+        if (!commandString.startsWith('/')) {
+            logger.error('Invalid command. Commands must start with /');
+            return;
+        }
+
+        const parts = commandString.slice(1).split(' ');
+        const commandName = parts[0];
+        const args = parts.slice(1).join(' ');
+
+        const command = this.commands.get(commandName);
+        if (!command) {
+            logger.error(`Unknown command: ${commandName}. Type /help for available commands.`);
+            return;
+        }
+
+        try {
+            await command.execute(args, logger);
+        } catch (error) {
+            logger.error(`Command '${commandName}' failed:`, error);
+        }
+    }
+
+    /**
+     * 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

@@ -0,0 +1,93 @@
+/**
+ * @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(', ')}`);
+        }
+    }
+}

package/src/cli/commands/ExportCommand.ts

@@ -0,0 +1,271 @@
+/**
+ * @fileoverview Export and clipboard commands for Advanced Logger CLI
+ */
+
+import type { ICommand } from '../CommandProcessor.js';
+import type { Logger } from '../../Logger.js';
+import type { ExportFormat, ExportFilters, ExportOptions, LogLevel } from '../../types/index.js';
+import { EXPORT_FORMATS } from '../../constants.js';
+
+/**
+ * Parse command line arguments into filters and options
+ */
+function parseArguments(args: string): { filters: ExportFilters; options: ExportOptions; format?: ExportFormat } {
+    const filters: ExportFilters = {};
+    const options: ExportOptions = {};
+    let format: ExportFormat | undefined;
+
+    if (!args.trim()) return { filters, options };
+
+    // Split args by spaces, but keep quoted strings together
+    const argParts = args.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+    
+    for (let i = 0; i < argParts.length; i++) {
+        const arg = argParts[i];
+
+        // Format (first argument without --)
+        if (i === 0 && !arg.startsWith('--') && arg in EXPORT_FORMATS) {
+            format = arg as ExportFormat;
+            continue;
+        }
+
+        // Parse --flags
+        if (arg.startsWith('--')) {
+            const [flag, value] = arg.slice(2).split('=');
+            
+            switch (flag) {
+                case 'level':
+                case 'levels':
+                    if (value) {
+                        filters.levels = value.split(',').map(l => l.trim()) as LogLevel[];
+                    }
+                    break;
+                case 'since':
+                    if (value) filters.since = value;
+                    break;
+                case 'until':
+                    if (value) filters.until = value;
+                    break;
+                case 'prefix':
+                case 'prefixes':
+                    if (value) {
+                        filters.prefixes = value.split(',').map(p => p.trim());
+                    }
+                    break;
+                case 'exclude-prefix':
+                case 'exclude-prefixes':
+                    if (value) {
+                        filters.excludePrefixes = value.split(',').map(p => p.trim());
+                    }
+                    break;
+                case 'last':
+                    if (value) filters.last = parseInt(value, 10);
+                    break;
+                case 'first':
+                    if (value) filters.first = parseInt(value, 10);
+                    break;
+                case 'search':
+                    if (value) filters.search = value.replace(/['"]/g, '');
+                    break;
+                case 'with-stack':
+                    filters.withStackTrace = true;
+                    break;
+                case 'errors-only':
+                    filters.errorsOnly = true;
+                    break;
+                case 'group-by':
+                    if (value) {
+                        filters.groupBy = value as ExportFilters['groupBy'];
+                        options.groupBy = value as ExportOptions['groupBy'];
+                    }
+                    break;
+                case 'minimal':
+                    options.minimal = true;
+                    break;
+                case 'compact':
+                    options.compact = true;
+                    break;
+                case 'styled':
+                    options.styled = true;
+                    break;
+            }
+        }
+    }
+
+    return { filters, options, format };
+}
+
+/**
+ * Export command - export logs in various formats
+ */
+export class ExportCommand implements ICommand {
+    name = 'export';
+    description = 'Export logs to various formats';
+    usage = '/export <format> [--filter=value] [--option]';
+
+    execute(args: string, logger: Logger): void {
+        const exportHandler = logger.getExportHandler();
+        if (!exportHandler) {
+            logger.error('Export handler not available. Make sure ExportLogHandler is registered.');
+            return;
+        }
+
+        const { filters, options, format } = parseArguments(args);
+
+        if (!format) {
+            logger.error('Format required. Available formats: ' + Object.keys(EXPORT_FORMATS).join(', '));
+            logger.info('Usage: /export <format> [--filter=value]');
+            logger.info('Example: /export json --level=error,warn --last=50');
+            return;
+        }
+
+        try {
+            const result = exportHandler.export(format, filters, options);
+            
+            // Log success with metadata
+            logger.success(`✅ Export completed: ${result.metadata.filteredLogs} logs exported in ${format} format`);
+            
+            // Show preview for small exports
+            if (result.data.length < 1000) {
+                logger.group(`📄 Preview (${format.toUpperCase()})`);
+                console.log(result.data);
+                logger.groupEnd();
+            } else {
+                logger.info(`📄 Export size: ${(result.data.length / 1024).toFixed(2)}KB`);
+            }
+
+            // Show metadata
+            logger.table({
+                format: result.format,
+                totalLogs: result.metadata.totalLogs,
+                filtered: result.metadata.filteredLogs,
+                exported: result.metadata.exportedAt
+            });
+
+        } catch (error) {
+            logger.error('Export failed:', error);
+        }
+    }
+}
+
+/**
+ * Copy command - copy logs to clipboard
+ */
+export class CopyCommand implements ICommand {
+    name = 'copy';
+    description = 'Copy logs to clipboard';
+    usage = '/copy <format> [--filter=value] [--option]';
+
+    async execute(args: string, logger: Logger): Promise<void> {
+        const exportHandler = logger.getExportHandler();
+        if (!exportHandler) {
+            logger.error('Export handler not available. Make sure ExportLogHandler is registered.');
+            return;
+        }
+
+        const { filters, options, format } = parseArguments(args);
+
+        if (!format) {
+            logger.error('Format required. Available formats: ' + Object.keys(EXPORT_FORMATS).join(', '));
+            logger.info('Usage: /copy <format> [--filter=value]');
+            logger.info('Example: /copy plain --level=error --last=25');
+            return;
+        }
+
+        try {
+            const success = await exportHandler.copyToClipboard(format, filters, options);
+            
+            if (success) {
+                const result = exportHandler.export(format, filters, options);
+                logger.success(`📋 Copied ${result.metadata.filteredLogs} logs to clipboard (${format} format)`);
+            } else {
+                logger.error('Failed to copy to clipboard. Browser may not support clipboard API.');
+            }
+
+        } catch (error) {
+            logger.error('Copy failed:', error);
+        }
+    }
+}
+
+/**
+ * Buffer-size command - configure buffer size
+ */
+export class BufferSizeCommand implements ICommand {
+    name = 'buffer-size';
+    description = 'Set log buffer size';
+    usage = '/buffer-size <size>';
+
+    execute(args: string, logger: Logger): void {
+        const exportHandler = logger.getExportHandler();
+        if (!exportHandler) {
+            logger.error('Export handler not available.');
+            return;
+        }
+
+        const size = parseInt(args.trim(), 10);
+        if (isNaN(size) || size <= 0) {
+            logger.error('Invalid buffer size. Must be a positive number.');
+            logger.info('Example: /buffer-size 2000');
+            return;
+        }
+
+        exportHandler.setBufferSize(size);
+        logger.success(`Buffer size set to ${size}`);
+    }
+}
+
+/**
+ * Clear-buffer command - clear log buffer
+ */
+export class ClearBufferCommand implements ICommand {
+    name = 'clear-buffer';
+    description = 'Clear the log buffer';
+    usage = '/clear-buffer';
+
+    execute(_args: string, logger: Logger): void {
+        const exportHandler = logger.getExportHandler();
+        if (!exportHandler) {
+            logger.error('Export handler not available.');
+            return;
+        }
+
+        const stats = exportHandler.getBufferStats();
+        exportHandler.clearBuffer();
+        
+        logger.success(`✅ Buffer cleared. Removed ${stats.size} log entries.`);
+    }
+}
+
+/**
+ * Buffer-info command - show buffer information
+ */
+export class BufferInfoCommand implements ICommand {
+    name = 'buffer-info';
+    description = 'Show buffer statistics and information';
+    usage = '/buffer-info';
+
+    execute(_args: string, logger: Logger): void {
+        const exportHandler = logger.getExportHandler();
+        if (!exportHandler) {
+            logger.error('Export handler not available.');
+            return;
+        }
+
+        const stats = exportHandler.getBufferStats();
+        
+        logger.group('📊 Buffer Information');
+        logger.table({
+            size: `${stats.size}/${stats.maxSize}`,
+            usage: `${stats.usage.toFixed(1)}%`,
+            oldestLog: stats.oldestLog?.toLocaleString() || 'None',
+            newestLog: stats.newestLog?.toLocaleString() || 'None'
+        });
+        
+        logger.group('📈 Log Level Counts');
+        logger.table(stats.levelCounts);
+        logger.groupEnd();
+        
+        logger.groupEnd();
+    }
+}

package/src/cli/commands/StatusCommand.ts

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Status and demo commands for Advanced Logger CLI
+ */
+
+import type { ICommand } from '../CommandProcessor.js';
+import type { Logger } from '../../Logger.js';
+
+/**
+ * Status command - show logger configuration and statistics
+ */
+export class StatusCommand implements ICommand {
+    name = 'status';
+    description = 'Show current logger status and configuration';
+    usage = '/status';
+
+    execute(_args: string, 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,
+            bufferSize: logger.getConfig().bufferSize || 1000
+        };
+
+        logger.group('⚙️ Logger Configuration');
+        logger.table(statusData);
+        logger.groupEnd();
+
+        // Show buffer stats if ExportLogHandler is present
+        const exportHandler = logger.getExportHandler();
+        if (exportHandler) {
+            const bufferStats = exportHandler.getBufferStats();
+            logger.group('📊 Buffer Statistics');
+            logger.table({
+                size: `${bufferStats.size}/${bufferStats.maxSize}`,
+                usage: `${bufferStats.usage.toFixed(1)}%`,
+                oldestLog: bufferStats.oldestLog?.toISOString() || 'None',
+                newestLog: bufferStats.newestLog?.toISOString() || 'None',
+                errorCount: bufferStats.levelCounts.error + bufferStats.levelCounts.critical,
+                warningCount: bufferStats.levelCounts.warn
+            });
+            logger.groupEnd();
+        }
+    }
+}
+
+/**
+ * Reset command - reset logger to defaults
+ */
+export class ResetCommand implements ICommand {
+    name = 'reset';
+    description = 'Reset logger configuration to defaults';
+    usage = '/reset';
+
+    execute(_args: string, logger: Logger): void {
+        logger.resetConfig();
+    }
+}
+
+/**
+ * Demo command - show logger feature demonstration
+ */
+export class DemoCommand implements ICommand {
+    name = 'demo';
+    description = 'Show comprehensive feature demonstration';
+    usage = '/demo';
+
+    execute(_args: string, logger: Logger): void {
+        logger.group('🎪 Advanced Logger Demo');
+        
+        // Basic logging demo
+        logger.debug('Debug message with detailed information');
+        logger.info('Informational message about system state'); 
+        logger.warn('Warning about deprecated feature');
+        logger.error('Error processing user request');
+        logger.success('Operation completed successfully');
+        logger.critical('Critical system failure detected');
+        
+        // Advanced features demo
+        logger.group('📊 Advanced Features Demo');
+        
+        // Table demo
+        logger.table([
+            { feature: 'Styled Console', status: '✅ Active', performance: 'Excellent' },
+            { feature: 'Theme System', status: '✅ Active', performance: 'Great' },
+            { feature: 'CLI Interface', status: '✅ Active', performance: 'Good' },
+            { feature: 'Export System', status: '✅ Active', performance: 'Excellent' }
+        ]);
+        
+        // Timer demo
+        logger.time('demo-operation');
+        setTimeout(() => {
+            logger.timeEnd('demo-operation');
+        }, 100);
+        
+        // SVG demo
+        logger.logWithSVG('SVG Demo');
+        
+        // Animated demo
+        logger.logAnimated('🌟 Animated Logger Demo 🌟', 2);
+        
+        logger.groupEnd();
+        logger.groupEnd();
+
+        logger.info('Demo completed! Check the console for styled output.');
+    }
+}

package/src/cli/commands/ThemeCommand.ts

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview Theme and banner commands for Advanced Logger CLI
+ */
+
+import type { ICommand } from '../CommandProcessor.js';
+import type { Logger } from '../../Logger.js';
+import type { BannerType } from '../../types/index.js';
+import { THEME_PRESETS, BANNER_VARIANTS } from '../../styling/index.js';
+import { StyleBuilder } from '../../styling/index.js';
+
+/**
+ * Themes command - show available themes
+ */
+export class ThemesCommand implements ICommand {
+    name = 'themes';
+    description = 'Show available theme presets';
+    usage = '/themes';
+
+    execute(_args: string, logger: Logger): void {
+        logger.group('🎨 Available Themes');
+        Object.keys(THEME_PRESETS).forEach(themeName => {
+            const preview = (THEME_PRESETS as any)[themeName];
+            const previewStyle = new StyleBuilder()
+                .bg(preview.info.background)
+                .color(preview.info.color)
+                .padding('4px 8px')
+                .rounded('4px')
+                .border(preview.info.border)
+                .build();
+            
+            console.log(`%c${themeName}`, previewStyle, `- ${themeName} theme preview`);
+        });
+        logger.groupEnd();
+    }
+}
+
+/**
+ * Banners command - show available banner types
+ */
+export class BannersCommand implements ICommand {
+    name = 'banners';
+    description = 'Show available banner types';
+    usage = '/banners';
+
+    execute(_args: string, logger: Logger): void {
+        logger.group('🖼️ Available Banner Types');
+        Object.keys(BANNER_VARIANTS).forEach(bannerName => {
+            const banner = (BANNER_VARIANTS as any)[bannerName];
+            console.log(`%c${bannerName}`, 'font-weight: bold; color: #667eea;');
+            console.log(`%cPreview:`, 'color: #666; font-size: 12px;');
+            
+            // Show a mini preview
+            if (bannerName === 'simple') {
+                console.log(`%c${banner.text}`, banner.style);
+            } else if (bannerName === 'ascii') {
+                console.log(`%c${banner.text.split('\n').slice(1, 4).join('\n')}...`, 'font-family: monospace; color: #667eea; font-size: 10px;');
+            } else if (bannerName === 'unicode') {
+                console.log(`%c${banner.text}`, banner.style);
+            } else {
+                console.log(`%c${bannerName} banner`, 'color: #666; font-style: italic;');
+            }
+        });
+        logger.groupEnd();
+    }
+}
+
+/**
+ * Banner command - change/show banner type
+ */
+export class BannerCommand implements ICommand {
+    name = 'banner';
+    description = 'Change or show current banner type';
+    usage = '/banner [type]';
+
+    execute(args: string, logger: Logger): void {
+        if (!args) {
+            logger.showBanner();
+            return;
+        }
+
+        if (args in BANNER_VARIANTS) {
+            logger.setBannerType(args as BannerType);
+            logger.showBanner();
+        } else {
+            logger.error(`Invalid banner type: ${args}. Available: ${Object.keys(BANNER_VARIANTS).join(', ')}`);
+        }
+    }
+}