@mks2508/better-logger 0.0.2-alpha.2 → 0.11.0-alpha.1

package/src/Logger.ts

@@ -594,4 +594,5 @@ export const cli = (command: string) => defaultLogger.cli(command);
 
 // Re-export handlers and utilities for backward compatibility
 export { FileLogHandler, RemoteLogHandler, AnalyticsLogHandler, ExportLogHandler } from './handlers/index.js';
-export { StyleBuilder, StylePresets as Styles } from './styling/index.js';
+export { StyleBuilder, StylePresets as Styles } from './styling/index.js';// Test change to trigger workflow
+// Test permissions fix

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/handlers/ExportLogHandler.ts

@@ -465,4 +465,145 @@ export class ExportLogHandler implements ILogHandler {
     getAllLogs(): LogEntry[] {
         return [...this.buffer];
     }
+
+    /**
+     * Save export to file with download prompt
+     */
+    async saveToFile(format: ExportFormat, filters: ExportFilters = {}, options: ExportOptions = {}): Promise<boolean> {
+        try {
+            const result = this.export(format, filters, options);
+            const blob = new Blob([result.data], { 
+                type: this.getMimeType(format) 
+            });
+            
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            const filename = this.generateFilename(format, filters);
+            
+            a.href = url;
+            a.download = filename;
+            a.style.display = 'none';
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+            
+            return true;
+        } catch (error) {
+            console.error('Failed to save file:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Get MIME type for format
+     */
+    private getMimeType(format: ExportFormat): string {
+        const mimeTypes = {
+            json: 'application/json',
+            csv: 'text/csv',
+            markdown: 'text/markdown',
+            plain: 'text/plain',
+            html: 'text/html'
+        };
+        return mimeTypes[format] || 'text/plain';
+    }
+
+    /**
+     * Generate filename with timestamp
+     */
+    private generateFilename(format: ExportFormat, filters: ExportFilters): string {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+        const prefix = filters.prefixes?.length === 1 ? `_${filters.prefixes[0]}` : '';
+        const extension = format === 'markdown' ? 'md' : format;
+        return `logs${prefix}_${timestamp}.${extension}`;
+    }
+
+    /**
+     * Stream logs to external endpoint
+     */
+    async streamToEndpoint(endpoint: string, filters: ExportFilters = {}, options: { 
+        apiKey?: string; 
+        batchSize?: number; 
+        format?: ExportFormat 
+    } = {}): Promise<boolean> {
+        try {
+            const logs = this.filterLogs(filters);
+            const batchSize = options.batchSize || 100;
+            const format = options.format || 'json';
+            
+            // Send in batches
+            for (let i = 0; i < logs.length; i += batchSize) {
+                const batch = logs.slice(i, i + batchSize);
+                const result = this.export(format, {}, { compact: true });
+                
+                const headers: Record<string, string> = {
+                    'Content-Type': 'application/json'
+                };
+                
+                if (options.apiKey) {
+                    headers['Authorization'] = `Bearer ${options.apiKey}`;
+                }
+                
+                const response = await fetch(endpoint, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({
+                        logs: batch,
+                        metadata: {
+                            batchIndex: Math.floor(i / batchSize),
+                            totalBatches: Math.ceil(logs.length / batchSize),
+                            timestamp: new Date().toISOString()
+                        }
+                    })
+                });
+                
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+            }
+            
+            return true;
+        } catch (error) {
+            console.error('Failed to stream logs:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Create export with metadata enrichment
+     */
+    exportWithMetadata(format: ExportFormat, filters: ExportFilters = {}, options: ExportOptions = {}): ExportResult {
+        const baseResult = this.export(format, filters, options);
+        const bufferStats = this.getBufferStats();
+        
+        return {
+            ...baseResult,
+            metadata: {
+                ...baseResult.metadata,
+                bufferStats: bufferStats,
+                performance: {
+                    memoryUsage: this.estimateMemoryUsage(),
+                    processingTime: Date.now()
+                },
+                system: {
+                    userAgent: typeof navigator !== 'undefined' ? navigator.userAgent : 'Node.js',
+                    timestamp: new Date().toISOString(),
+                    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+                }
+            } as any
+        };
+    }
+
+    /**
+     * Estimate memory usage of buffer
+     */
+    private estimateMemoryUsage(): number {
+        const sampleEntry = this.buffer[0];
+        if (!sampleEntry) return 0;
+        
+        // Rough estimation: JSON.stringify size * buffer length
+        const sampleSize = JSON.stringify(sampleEntry).length;
+        return sampleSize * this.buffer.length;
+    }
 }