claude-mpm 4.2.13__py3-none-any.whl → 4.2.14__py3-none-any.whl

claude_mpm/dashboard/static/js/shared/event-bus.js

@@ -0,0 +1,330 @@
+/**
+ * Event Bus Service
+ * 
+ * Central event management for decoupled component communication.
+ * Implements a simple pub/sub pattern for dashboard components.
+ * 
+ * @module event-bus
+ */
+
+class EventBus {
+    constructor() {
+        this.events = new Map();
+        this.onceEvents = new Map();
+        this.eventHistory = [];
+        this.maxHistorySize = 100;
+        this.debugMode = false;
+    }
+
+    /**
+     * Subscribe to an event
+     * @param {string} event - Event name
+     * @param {Function} handler - Event handler function
+     * @param {Object} options - Subscription options
+     * @returns {Function} Unsubscribe function
+     */
+    on(event, handler, options = {}) {
+        if (typeof handler !== 'function') {
+            throw new Error('Handler must be a function');
+        }
+
+        // Initialize event handlers array if needed
+        if (!this.events.has(event)) {
+            this.events.set(event, []);
+        }
+
+        // Create handler wrapper with context and priority
+        const wrapper = {
+            handler,
+            context: options.context || null,
+            priority: options.priority || 0,
+            id: this.generateId()
+        };
+
+        // Add to handlers array (sorted by priority)
+        const handlers = this.events.get(event);
+        handlers.push(wrapper);
+        handlers.sort((a, b) => b.priority - a.priority);
+
+        // Log subscription if debugging
+        if (this.debugMode) {
+            console.log(`[EventBus] Subscribed to "${event}" with handler ${wrapper.id}`);
+        }
+
+        // Return unsubscribe function
+        return () => this.off(event, wrapper.id);
+    }
+
+    /**
+     * Subscribe to an event only once
+     * @param {string} event - Event name
+     * @param {Function} handler - Event handler function
+     * @param {Object} options - Subscription options
+     * @returns {Function} Unsubscribe function
+     */
+    once(event, handler, options = {}) {
+        const wrappedHandler = (...args) => {
+            handler(...args);
+            this.off(event, wrappedHandler);
+        };
+        wrappedHandler._originalHandler = handler;
+        return this.on(event, wrappedHandler, options);
+    }
+
+    /**
+     * Unsubscribe from an event
+     * @param {string} event - Event name
+     * @param {string|Function} handlerOrId - Handler function or ID
+     */
+    off(event, handlerOrId) {
+        if (!this.events.has(event)) {
+            return;
+        }
+
+        const handlers = this.events.get(event);
+        const index = handlers.findIndex(wrapper => 
+            wrapper.id === handlerOrId || 
+            wrapper.handler === handlerOrId ||
+            wrapper.handler._originalHandler === handlerOrId
+        );
+
+        if (index !== -1) {
+            const removed = handlers.splice(index, 1)[0];
+            if (this.debugMode) {
+                console.log(`[EventBus] Unsubscribed from "${event}" handler ${removed.id}`);
+            }
+        }
+
+        // Clean up empty event arrays
+        if (handlers.length === 0) {
+            this.events.delete(event);
+        }
+    }
+
+    /**
+     * Emit an event
+     * @param {string} event - Event name
+     * @param {...any} args - Arguments to pass to handlers
+     * @returns {Array} Results from all handlers
+     */
+    emit(event, ...args) {
+        const results = [];
+
+        // Record in history
+        this.recordEvent(event, args);
+
+        // Log emission if debugging
+        if (this.debugMode) {
+            console.log(`[EventBus] Emitting "${event}" with args:`, args);
+        }
+
+        // Call handlers for this specific event
+        if (this.events.has(event)) {
+            const handlers = this.events.get(event).slice(); // Clone to prevent modification during iteration
+            for (const wrapper of handlers) {
+                try {
+                    const result = wrapper.context
+                        ? wrapper.handler.call(wrapper.context, ...args)
+                        : wrapper.handler(...args);
+                    results.push(result);
+                } catch (error) {
+                    console.error(`[EventBus] Error in handler for "${event}":`, error);
+                    if (this.debugMode) {
+                        console.error('Handler details:', wrapper);
+                    }
+                }
+            }
+        }
+
+        // Call wildcard handlers
+        if (this.events.has('*')) {
+            const wildcardHandlers = this.events.get('*').slice();
+            for (const wrapper of wildcardHandlers) {
+                try {
+                    const result = wrapper.context
+                        ? wrapper.handler.call(wrapper.context, event, ...args)
+                        : wrapper.handler(event, ...args);
+                    results.push(result);
+                } catch (error) {
+                    console.error(`[EventBus] Error in wildcard handler for "${event}":`, error);
+                }
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Emit an event asynchronously
+     * @param {string} event - Event name
+     * @param {...any} args - Arguments to pass to handlers
+     * @returns {Promise<Array>} Promise resolving to results from all handlers
+     */
+    async emitAsync(event, ...args) {
+        return new Promise(resolve => {
+            setTimeout(() => {
+                resolve(this.emit(event, ...args));
+            }, 0);
+        });
+    }
+
+    /**
+     * Wait for an event to occur
+     * @param {string} event - Event name to wait for
+     * @param {number} timeout - Timeout in milliseconds (optional)
+     * @returns {Promise} Promise resolving when event occurs
+     */
+    waitFor(event, timeout) {
+        return new Promise((resolve, reject) => {
+            let timeoutId;
+            
+            const handler = (...args) => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                resolve(args);
+            };
+
+            this.once(event, handler);
+
+            if (timeout) {
+                timeoutId = setTimeout(() => {
+                    this.off(event, handler);
+                    reject(new Error(`Timeout waiting for event "${event}"`));
+                }, timeout);
+            }
+        });
+    }
+
+    /**
+     * Clear all handlers for an event
+     * @param {string} event - Event name (optional, clears all if not provided)
+     */
+    clear(event) {
+        if (event) {
+            this.events.delete(event);
+            if (this.debugMode) {
+                console.log(`[EventBus] Cleared all handlers for "${event}"`);
+            }
+        } else {
+            this.events.clear();
+            if (this.debugMode) {
+                console.log('[EventBus] Cleared all event handlers');
+            }
+        }
+    }
+
+    /**
+     * Get all registered events
+     * @returns {Array} Array of event names
+     */
+    getEvents() {
+        return Array.from(this.events.keys());
+    }
+
+    /**
+     * Get handler count for an event
+     * @param {string} event - Event name
+     * @returns {number} Number of handlers
+     */
+    getHandlerCount(event) {
+        return this.events.has(event) ? this.events.get(event).length : 0;
+    }
+
+    /**
+     * Check if event has handlers
+     * @param {string} event - Event name
+     * @returns {boolean} Whether event has handlers
+     */
+    hasHandlers(event) {
+        return this.getHandlerCount(event) > 0;
+    }
+
+    /**
+     * Enable or disable debug mode
+     * @param {boolean} enabled - Debug mode state
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+        if (enabled) {
+            console.log('[EventBus] Debug mode enabled');
+        }
+    }
+
+    /**
+     * Get event history
+     * @param {string} event - Optional event name filter
+     * @returns {Array} Event history
+     */
+    getHistory(event) {
+        if (event) {
+            return this.eventHistory.filter(entry => entry.event === event);
+        }
+        return this.eventHistory.slice();
+    }
+
+    /**
+     * Clear event history
+     */
+    clearHistory() {
+        this.eventHistory = [];
+    }
+
+    /**
+     * Record event in history
+     * @private
+     * @param {string} event - Event name
+     * @param {Array} args - Event arguments
+     */
+    recordEvent(event, args) {
+        this.eventHistory.push({
+            event,
+            args: args.slice(),
+            timestamp: Date.now()
+        });
+
+        // Limit history size
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.shift();
+        }
+    }
+
+    /**
+     * Generate unique ID
+     * @private
+     * @returns {string} Unique ID
+     */
+    generateId() {
+        return `handler_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    /**
+     * Create a scoped event bus
+     * @param {string} scope - Scope prefix
+     * @returns {Object} Scoped event bus interface
+     */
+    createScope(scope) {
+        const prefix = scope + ':';
+        return {
+            on: (event, handler, options) => this.on(prefix + event, handler, options),
+            once: (event, handler, options) => this.once(prefix + event, handler, options),
+            off: (event, handler) => this.off(prefix + event, handler),
+            emit: (event, ...args) => this.emit(prefix + event, ...args),
+            emitAsync: (event, ...args) => this.emitAsync(prefix + event, ...args),
+            clear: (event) => this.clear(event ? prefix + event : undefined),
+            hasHandlers: (event) => this.hasHandlers(prefix + event)
+        };
+    }
+}
+
+// Create singleton instance
+const eventBus = new EventBus();
+
+// Support both module and global usage
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = eventBus;
+} else if (typeof define === 'function' && define.amd) {
+    define([], () => eventBus);
+} else {
+    window.eventBus = eventBus;
+}

claude_mpm/dashboard/static/js/shared/logger.js

@@ -0,0 +1,385 @@
+/**
+ * Logger Service
+ * 
+ * Centralized logging service with levels, formatting, and performance timing.
+ * Provides consistent logging across dashboard components.
+ * 
+ * @module logger
+ */
+
+class Logger {
+    constructor() {
+        this.logLevels = {
+            DEBUG: 0,
+            INFO: 1,
+            WARN: 2,
+            ERROR: 3,
+            NONE: 4
+        };
+        
+        this.currentLevel = this.logLevels.INFO;
+        this.enableTimestamps = true;
+        this.enableColors = true;
+        this.logHistory = [];
+        this.maxHistorySize = 500;
+        this.performanceMarks = new Map();
+        this.componentLoggers = new Map();
+    }
+
+    /**
+     * Set the current log level
+     * @param {string|number} level - Log level name or value
+     */
+    setLevel(level) {
+        if (typeof level === 'string') {
+            level = level.toUpperCase();
+            if (level in this.logLevels) {
+                this.currentLevel = this.logLevels[level];
+            }
+        } else if (typeof level === 'number') {
+            this.currentLevel = level;
+        }
+    }
+
+    /**
+     * Create a logger for a specific component
+     * @param {string} componentName - Name of the component
+     * @returns {Object} Component logger instance
+     */
+    createComponentLogger(componentName) {
+        if (this.componentLoggers.has(componentName)) {
+            return this.componentLoggers.get(componentName);
+        }
+
+        const componentLogger = {
+            debug: (...args) => this.debug(`[${componentName}]`, ...args),
+            info: (...args) => this.info(`[${componentName}]`, ...args),
+            warn: (...args) => this.warn(`[${componentName}]`, ...args),
+            error: (...args) => this.error(`[${componentName}]`, ...args),
+            time: (label) => this.time(`${componentName}:${label}`),
+            timeEnd: (label) => this.timeEnd(`${componentName}:${label}`),
+            group: (label) => this.group(`${componentName}: ${label}`),
+            groupEnd: () => this.groupEnd()
+        };
+
+        this.componentLoggers.set(componentName, componentLogger);
+        return componentLogger;
+    }
+
+    /**
+     * Debug level logging
+     * @param {...any} args - Arguments to log
+     */
+    debug(...args) {
+        if (this.currentLevel <= this.logLevels.DEBUG) {
+            this.log('DEBUG', args, '#6c757d');
+        }
+    }
+
+    /**
+     * Info level logging
+     * @param {...any} args - Arguments to log
+     */
+    info(...args) {
+        if (this.currentLevel <= this.logLevels.INFO) {
+            this.log('INFO', args, '#0d6efd');
+        }
+    }
+
+    /**
+     * Warning level logging
+     * @param {...any} args - Arguments to log
+     */
+    warn(...args) {
+        if (this.currentLevel <= this.logLevels.WARN) {
+            this.log('WARN', args, '#ffc107');
+        }
+    }
+
+    /**
+     * Error level logging
+     * @param {...any} args - Arguments to log
+     */
+    error(...args) {
+        if (this.currentLevel <= this.logLevels.ERROR) {
+            this.log('ERROR', args, '#dc3545');
+        }
+    }
+
+    /**
+     * Core logging function
+     * @private
+     * @param {string} level - Log level
+     * @param {Array} args - Arguments to log
+     * @param {string} color - Color for the log level
+     */
+    log(level, args, color) {
+        const timestamp = this.enableTimestamps ? new Date().toISOString() : '';
+        const prefix = this.formatPrefix(level, timestamp, color);
+        
+        // Console output
+        const method = level === 'ERROR' ? 'error' : level === 'WARN' ? 'warn' : 'log';
+        if (this.enableColors && color) {
+            console[method](`%c${prefix}`, `color: ${color}; font-weight: bold;`, ...args);
+        } else {
+            console[method](prefix, ...args);
+        }
+        
+        // Add to history
+        this.addToHistory(level, timestamp, args);
+    }
+
+    /**
+     * Format log prefix
+     * @private
+     * @param {string} level - Log level
+     * @param {string} timestamp - Timestamp
+     * @param {string} color - Color
+     * @returns {string} Formatted prefix
+     */
+    formatPrefix(level, timestamp, color) {
+        const parts = [];
+        if (timestamp) {
+            parts.push(`[${timestamp}]`);
+        }
+        parts.push(`[${level}]`);
+        return parts.join(' ');
+    }
+
+    /**
+     * Add log entry to history
+     * @private
+     * @param {string} level - Log level
+     * @param {string} timestamp - Timestamp
+     * @param {Array} args - Log arguments
+     */
+    addToHistory(level, timestamp, args) {
+        this.logHistory.push({
+            level,
+            timestamp,
+            message: args.map(arg => 
+                typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+            ).join(' ')
+        });
+        
+        // Limit history size
+        if (this.logHistory.length > this.maxHistorySize) {
+            this.logHistory.shift();
+        }
+    }
+
+    /**
+     * Start a performance timer
+     * @param {string} label - Timer label
+     */
+    time(label) {
+        this.performanceMarks.set(label, {
+            start: performance.now(),
+            memory: performance.memory ? performance.memory.usedJSHeapSize : null
+        });
+        this.debug(`Timer started: ${label}`);
+    }
+
+    /**
+     * End a performance timer and log the result
+     * @param {string} label - Timer label
+     * @returns {number} Elapsed time in milliseconds
+     */
+    timeEnd(label) {
+        const mark = this.performanceMarks.get(label);
+        if (!mark) {
+            this.warn(`Timer not found: ${label}`);
+            return null;
+        }
+        
+        const elapsed = performance.now() - mark.start;
+        const memoryDelta = performance.memory 
+            ? performance.memory.usedJSHeapSize - mark.memory 
+            : null;
+        
+        this.performanceMarks.delete(label);
+        
+        const message = [`Timer ended: ${label} - ${elapsed.toFixed(2)}ms`];
+        if (memoryDelta !== null) {
+            message.push(`(Memory: ${this.formatBytes(memoryDelta)})`);
+        }
+        
+        this.info(...message);
+        return elapsed;
+    }
+
+    /**
+     * Log a performance mark
+     * @param {string} name - Mark name
+     */
+    mark(name) {
+        if (performance.mark) {
+            performance.mark(name);
+            this.debug(`Performance mark: ${name}`);
+        }
+    }
+
+    /**
+     * Log a performance measure
+     * @param {string} name - Measure name
+     * @param {string} startMark - Start mark name
+     * @param {string} endMark - End mark name
+     */
+    measure(name, startMark, endMark) {
+        if (performance.measure) {
+            try {
+                performance.measure(name, startMark, endMark);
+                const entries = performance.getEntriesByName(name);
+                if (entries.length > 0) {
+                    const duration = entries[entries.length - 1].duration;
+                    this.info(`Performance measure: ${name} - ${duration.toFixed(2)}ms`);
+                }
+            } catch (error) {
+                this.error(`Failed to measure performance: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Create a log group
+     * @param {string} label - Group label
+     */
+    group(label) {
+        if (console.group) {
+            console.group(label);
+        }
+    }
+
+    /**
+     * Create a collapsed log group
+     * @param {string} label - Group label
+     */
+    groupCollapsed(label) {
+        if (console.groupCollapsed) {
+            console.groupCollapsed(label);
+        }
+    }
+
+    /**
+     * End a log group
+     */
+    groupEnd() {
+        if (console.groupEnd) {
+            console.groupEnd();
+        }
+    }
+
+    /**
+     * Log a table
+     * @param {Array|Object} data - Data to display as table
+     * @param {Array} columns - Optional column names
+     */
+    table(data, columns) {
+        if (console.table) {
+            console.table(data, columns);
+        }
+    }
+
+    /**
+     * Clear the console
+     */
+    clear() {
+        if (console.clear) {
+            console.clear();
+        }
+    }
+
+    /**
+     * Get log history
+     * @param {string} level - Optional level filter
+     * @returns {Array} Log history
+     */
+    getHistory(level) {
+        if (level) {
+            return this.logHistory.filter(entry => entry.level === level);
+        }
+        return this.logHistory.slice();
+    }
+
+    /**
+     * Export log history as text
+     * @returns {string} Log history as text
+     */
+    exportHistory() {
+        return this.logHistory
+            .map(entry => `${entry.timestamp} [${entry.level}] ${entry.message}`)
+            .join('\n');
+    }
+
+    /**
+     * Clear log history
+     */
+    clearHistory() {
+        this.logHistory = [];
+    }
+
+    /**
+     * Format bytes for display
+     * @private
+     * @param {number} bytes - Number of bytes
+     * @returns {string} Formatted string
+     */
+    formatBytes(bytes) {
+        const sign = bytes < 0 ? '-' : '+';
+        bytes = Math.abs(bytes);
+        
+        if (bytes === 0) return '0 B';
+        
+        const units = ['B', 'KB', 'MB', 'GB'];
+        const index = Math.floor(Math.log(bytes) / Math.log(1024));
+        const value = bytes / Math.pow(1024, index);
+        
+        return `${sign}${value.toFixed(2)} ${units[index]}`;
+    }
+
+    /**
+     * Assert a condition
+     * @param {boolean} condition - Condition to assert
+     * @param {string} message - Error message if condition is false
+     */
+    assert(condition, message) {
+        if (!condition) {
+            this.error(`Assertion failed: ${message}`);
+            if (console.trace) {
+                console.trace();
+            }
+        }
+    }
+
+    /**
+     * Count occurrences
+     * @param {string} label - Counter label
+     */
+    count(label = 'default') {
+        if (console.count) {
+            console.count(label);
+        }
+    }
+
+    /**
+     * Reset a counter
+     * @param {string} label - Counter label
+     */
+    countReset(label = 'default') {
+        if (console.countReset) {
+            console.countReset(label);
+        }
+    }
+}
+
+// Create singleton instance
+const logger = new Logger();
+
+// Support both module and global usage
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = logger;
+} else if (typeof define === 'function' && define.amd) {
+    define([], () => logger);
+} else {
+    window.logger = logger;
+}