claude-mpm 4.24.0__py3-none-any.whl → 5.0.9__py3-none-any.whl

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

@@ -1,330 +0,0 @@
-/**
- * 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

@@ -1,385 +0,0 @@
-/**
- * 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;
-}