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

claude_mpm/dashboard/static/js/components/event-processor.js

@@ -537,3 +537,6 @@ class EventProcessor {
 // ES6 Module export
 export { EventProcessor };
 export default EventProcessor;
+
+// Make EventProcessor globally available for dist/dashboard.js
+window.EventProcessor = EventProcessor;

claude_mpm/dashboard/static/js/components/event-viewer.js

@@ -41,6 +41,14 @@ class EventViewer {
         this.socketClient.onEventUpdate((events, sessions) => {
             // Ensure we always have a valid events array
             this.events = Array.isArray(events) ? events : [];
+            console.log('[EventViewer] Events updated - received:', this.events.length);
+
+            // Update debug metrics
+            const debugReceivedEl = document.getElementById('debug-events-received');
+            if (debugReceivedEl) {
+                debugReceivedEl.textContent = this.events.length;
+            }
+
             this.updateDisplay();
         });
     }
@@ -110,7 +118,7 @@ class EventViewer {
         this.filteredEvents = this.events.filter(event => {
             // NO AUTOMATIC FILTERING - All events are shown by default for complete visibility
             // Users can apply their own filters using the search and type filter controls
-            
+
             // User-controlled search filter
             if (this.searchFilter) {
                 const searchableText = [
@@ -221,8 +229,29 @@ class EventViewer {
      * Render events in the UI
      */
     renderEvents() {
-        const eventsList = document.getElementById('events-list');
-        if (!eventsList) return;
+        // CRITICAL FIX: Use the container passed to constructor, not hardcoded events-list
+        // This prevents events from being rendered in the wrong tab
+        const eventsList = this.container;
+        if (!eventsList) {
+            console.warn('[EventViewer] Container not found, skipping render');
+            return;
+        }
+
+        // SAFETY: Basic check to ensure we're rendering to the correct container
+        if (eventsList.id !== 'events-list') {
+            console.error('[EventViewer] CRITICAL: Attempting to render to wrong container:', eventsList.id);
+            return;
+        }
+
+        // Check if events tab exists and render regardless of active state
+        // This allows events to be pre-rendered when tab becomes active
+        const eventsTab = document.getElementById('events-tab');
+        if (!eventsTab) {
+            console.warn('[EventViewer] Events tab not found in DOM');
+            return;
+        }
+
+        console.log('[EventViewer] Rendering events - count:', this.filteredEvents.length);
 
         // Check if user is at bottom BEFORE rendering (for autoscroll decision)
         const wasAtBottom = (eventsList.scrollTop + eventsList.clientHeight >= eventsList.scrollHeight - 10);
@@ -268,6 +297,14 @@ class EventViewer {
         // Update filtered elements reference
         this.filteredEventElements = Array.from(eventsList.querySelectorAll('.event-item'));
 
+        console.log('[EventViewer] Events rendered - filtered:', this.filteredEvents.length, 'elements:', this.filteredEventElements.length);
+
+        // Update debug metrics
+        const debugRenderedEl = document.getElementById('debug-events-rendered');
+        if (debugRenderedEl) {
+            debugRenderedEl.textContent = this.filteredEvents.length;
+        }
+
         // Update Dashboard navigation items if we're in the events tab
         if (window.dashboard && window.dashboard.currentTab === 'events' &&
             window.dashboard.tabNavigation && window.dashboard.tabNavigation.events) {
@@ -483,7 +520,7 @@ class EventViewer {
      */
     formatCodeEvent(event) {
         const data = event.data || {};
-        
+
         // Handle different code event subtypes
         if (event.subtype === 'progress') {
             const message = data.message || 'Processing...';
@@ -513,7 +550,7 @@ class EventViewer {
         } else if (event.subtype === 'error') {
             return `<strong>Error:</strong> ${data.error || 'Unknown error'} in ${data.file || 'file'}`;
         }
-        
+
         // Generic fallback for code events
         const json = JSON.stringify(data);
         return `<strong>Code:</strong> ${json.length > 100 ? json.substring(0, 100) + '...' : json}`;
@@ -550,20 +587,20 @@ class EventViewer {
             'qa_agent': 'QA',
             'unknown': 'Unknown'
         };
-        
+
         // Try to find a match in the map (case-insensitive)
         const lowerType = (agentType || 'unknown').toLowerCase();
         if (agentTypeMap[lowerType]) {
             return agentTypeMap[lowerType];
         }
-        
+
         // If not in map, try to extract the agent name from patterns like "Research Agent" or "research_agent"
         const match = agentType.match(/^(\w+)(?:_agent|Agent)?$/i);
         if (match && match[1]) {
             // Capitalize first letter
             return match[1].charAt(0).toUpperCase() + match[1].slice(1).toLowerCase();
         }
-        
+
         // Fallback: just capitalize first letter of whatever we have
         return agentType.charAt(0).toUpperCase() + agentType.slice(1);
     }
@@ -577,7 +614,7 @@ class EventViewer {
     formatSingleRowEventContent(event) {
         const eventType = this.formatEventType(event);
         const data = event.data || {};
-        
+
         // Include source if it's not the default 'system' source
         const sourcePrefix = event.source && event.source !== 'system' ? `[${event.source}] ` : '';
 
@@ -589,12 +626,12 @@ class EventViewer {
                 // Hook events: show tool name and operation details
                 const toolName = event.tool_name || data.tool_name || 'Unknown';
                 const hookType = event.subtype || 'Unknown';
-                
+
                 // Format specific hook types
                 if (hookType === 'pre_tool' || hookType === 'post_tool') {
                     const operation = data.operation_type || '';
-                    const status = hookType === 'post_tool' && data.success !== undefined 
-                        ? (data.success ? '✓' : '✗') 
+                    const status = hookType === 'post_tool' && data.success !== undefined
+                        ? (data.success ? '✓' : '✗')
                         : '';
                     dataDetails = `${toolName}${operation ? ` (${operation})` : ''}${status ? ` ${status}` : ''}`;
                 } else if (hookType === 'user_prompt') {
@@ -733,7 +770,7 @@ class EventViewer {
         if (hookNames[hookType]) {
             return hookNames[hookType];
         }
-        
+
         // Convert to string and handle null/undefined
         const typeStr = String(hookType || 'unknown');
         return typeStr.replace(/_/g, ' ');

claude_mpm/dashboard/static/js/components/export-manager.js

@@ -363,3 +363,6 @@ class ExportManager {
 // ES6 Module export
 export { ExportManager };
 export default ExportManager;
+
+// Make ExportManager globally available for dist/dashboard.js
+window.ExportManager = ExportManager;

claude_mpm/dashboard/static/js/components/file-change-tracker.js

@@ -0,0 +1,443 @@
+/**
+ * File Change Tracker Module
+ *
+ * Tracks all file operations (Edit, Write, Read, MultiEdit) from event history
+ * and builds a tree structure grouped by working directory.
+ * Supports session-based filtering and stores complete edit history with timestamps.
+ *
+ * Architecture:
+ * - Maintains a hierarchical structure of file changes
+ * - Tracks file lifecycle (create, edit, delete)
+ * - Provides session-aware filtering
+ * - Stores complete history for diff generation
+ */
+class FileChangeTracker {
+    constructor() {
+        // Main data structures
+        this.fileChanges = new Map(); // Map<filePath, FileChangeData>
+        this.sessionData = new Map(); // Map<sessionId, Set<filePath>>
+        this.workingDirectories = new Map(); // Map<workingDir, Set<filePath>>
+
+        // Current state
+        this.currentSessionId = null;
+        this.events = [];
+
+        // File operation types we track
+        this.FILE_OPERATIONS = {
+            READ: 'Read',
+            WRITE: 'Write',
+            EDIT: 'Edit',
+            MULTI_EDIT: 'MultiEdit',
+            DELETE: 'Delete',
+            CREATE: 'Create'
+        };
+
+        // Initialize
+        this.initialized = false;
+        console.log('FileChangeTracker initialized');
+    }
+
+    /**
+     * Initialize the tracker
+     */
+    initialize() {
+        if (this.initialized) return;
+        this.initialized = true;
+        console.log('FileChangeTracker ready');
+    }
+
+    /**
+     * Process an event and extract file operations
+     * @param {Object} event - Event data
+     */
+    processEvent(event) {
+        // Check if this is a file-related tool event
+        if (!this.isFileOperation(event)) return;
+
+        const fileOp = this.extractFileOperation(event);
+        if (!fileOp) return;
+
+        // Add to our tracking structures
+        this.addFileOperation(fileOp);
+    }
+
+    /**
+     * Check if an event is a file operation
+     * @param {Object} event - Event to check
+     * @returns {boolean}
+     */
+    isFileOperation(event) {
+        // Check for tool events with file operations
+        if (event.type === 'tool' || event.subtype === 'pre_tool' || event.subtype === 'post_tool') {
+            const toolName = event.tool_name || (event.data && event.data.tool_name);
+            return Object.values(this.FILE_OPERATIONS).includes(toolName);
+        }
+
+        // Check for hook events with file operations
+        if (event.type === 'hook' && event.data) {
+            const toolName = event.data.tool_name;
+            return Object.values(this.FILE_OPERATIONS).includes(toolName);
+        }
+
+        return false;
+    }
+
+    /**
+     * Extract file operation details from an event
+     * @param {Object} event - Event to process
+     * @returns {Object|null} File operation data
+     */
+    extractFileOperation(event) {
+        const toolName = event.tool_name || (event.data && event.data.tool_name);
+        const params = event.tool_parameters || (event.data && event.data.tool_parameters) || {};
+        const result = event.tool_result || (event.data && event.data.tool_result);
+
+        // Extract file path based on tool type
+        let filePath = null;
+        let operation = toolName;
+        let content = null;
+        let oldContent = null;
+
+        switch (toolName) {
+            case this.FILE_OPERATIONS.READ:
+                filePath = params.file_path;
+                content = result && result.content;
+                break;
+
+            case this.FILE_OPERATIONS.WRITE:
+                filePath = params.file_path;
+                content = params.content;
+                break;
+
+            case this.FILE_OPERATIONS.EDIT:
+                filePath = params.file_path;
+                oldContent = params.old_string;
+                content = params.new_string;
+                break;
+
+            case this.FILE_OPERATIONS.MULTI_EDIT:
+                filePath = params.file_path;
+                // For MultiEdit, we track each edit
+                const edits = params.edits || [];
+                return {
+                    filePath,
+                    operation,
+                    timestamp: event.timestamp,
+                    sessionId: event.session_id || 'unknown',
+                    workingDirectory: this.extractWorkingDirectory(event),
+                    edits: edits.map(edit => ({
+                        oldContent: edit.old_string,
+                        newContent: edit.new_string,
+                        replaceAll: edit.replace_all || false
+                    })),
+                    isMultiEdit: true,
+                    success: event.subtype === 'post_tool' && result && result.success !== false
+                };
+
+            default:
+                return null;
+        }
+
+        if (!filePath) return null;
+
+        return {
+            filePath,
+            operation,
+            timestamp: event.timestamp,
+            sessionId: event.session_id || 'unknown',
+            workingDirectory: this.extractWorkingDirectory(event),
+            content,
+            oldContent,
+            isEdit: operation === this.FILE_OPERATIONS.EDIT,
+            isWrite: operation === this.FILE_OPERATIONS.WRITE,
+            isRead: operation === this.FILE_OPERATIONS.READ,
+            success: event.subtype === 'post_tool' && result && result.success !== false
+        };
+    }
+
+    /**
+     * Extract working directory from event
+     * @param {Object} event - Event data
+     * @returns {string} Working directory path
+     */
+    extractWorkingDirectory(event) {
+        // Try to extract from event data
+        if (event.data && event.data.working_directory) {
+            return event.data.working_directory;
+        }
+
+        // Try to extract from context
+        if (event.context && event.context.working_directory) {
+            return event.context.working_directory;
+        }
+
+        // Try to extract from file path (get parent directory)
+        const filePath = event.tool_parameters?.file_path ||
+                        (event.data && event.data.tool_parameters?.file_path);
+        if (filePath) {
+            const parts = filePath.split('/');
+            parts.pop(); // Remove filename
+            return parts.join('/') || '/';
+        }
+
+        return 'unknown';
+    }
+
+    /**
+     * Add a file operation to our tracking structures
+     * @param {Object} fileOp - File operation data
+     */
+    addFileOperation(fileOp) {
+        const { filePath, sessionId, workingDirectory } = fileOp;
+
+        // Initialize file change data if needed
+        if (!this.fileChanges.has(filePath)) {
+            this.fileChanges.set(filePath, {
+                path: filePath,
+                fileName: this.getFileName(filePath),
+                workingDirectory,
+                sessions: new Set(),
+                operations: [],
+                firstSeen: fileOp.timestamp,
+                lastModified: fileOp.timestamp,
+                currentContent: null,
+                initialContent: null,
+                totalEdits: 0,
+                totalReads: 0,
+                totalWrites: 0
+            });
+        }
+
+        const fileData = this.fileChanges.get(filePath);
+
+        // Update session tracking
+        fileData.sessions.add(sessionId);
+        if (!this.sessionData.has(sessionId)) {
+            this.sessionData.set(sessionId, new Set());
+        }
+        this.sessionData.get(sessionId).add(filePath);
+
+        // Update working directory tracking
+        if (!this.workingDirectories.has(workingDirectory)) {
+            this.workingDirectories.set(workingDirectory, new Set());
+        }
+        this.workingDirectories.get(workingDirectory).add(filePath);
+
+        // Add operation to history
+        fileData.operations.push(fileOp);
+        fileData.lastModified = fileOp.timestamp;
+
+        // Update content tracking
+        if (fileOp.isRead && fileOp.content && !fileData.initialContent) {
+            fileData.initialContent = fileOp.content;
+            fileData.currentContent = fileOp.content;
+            fileData.totalReads++;
+        } else if (fileOp.isWrite) {
+            if (!fileData.initialContent) {
+                fileData.initialContent = '';
+            }
+            fileData.currentContent = fileOp.content;
+            fileData.totalWrites++;
+        } else if (fileOp.isEdit) {
+            // Apply edit to current content
+            if (fileData.currentContent && fileOp.oldContent) {
+                fileData.currentContent = fileData.currentContent.replace(
+                    fileOp.oldContent,
+                    fileOp.content || ''
+                );
+            }
+            fileData.totalEdits++;
+        } else if (fileOp.isMultiEdit && fileOp.edits) {
+            // Apply multiple edits
+            let content = fileData.currentContent || '';
+            for (const edit of fileOp.edits) {
+                if (edit.replaceAll) {
+                    content = content.replaceAll(edit.oldContent, edit.newContent);
+                } else {
+                    content = content.replace(edit.oldContent, edit.newContent);
+                }
+            }
+            fileData.currentContent = content;
+            fileData.totalEdits += fileOp.edits.length;
+        }
+    }
+
+    /**
+     * Get file name from path
+     * @param {string} filePath - Full file path
+     * @returns {string} File name
+     */
+    getFileName(filePath) {
+        const parts = filePath.split('/');
+        return parts[parts.length - 1] || filePath;
+    }
+
+    /**
+     * Update with new events
+     * @param {Array} events - Array of events
+     */
+    updateEvents(events) {
+        // Clear and rebuild
+        this.clear();
+        this.events = events;
+
+        // Process all events
+        for (const event of events) {
+            this.processEvent(event);
+        }
+
+        console.log(`FileChangeTracker updated: ${this.fileChanges.size} files tracked`);
+    }
+
+    /**
+     * Get files for current session
+     * @param {string} sessionId - Session ID to filter by
+     * @returns {Array} Array of file change data
+     */
+    getFilesForSession(sessionId) {
+        if (!sessionId) {
+            return Array.from(this.fileChanges.values());
+        }
+
+        const sessionFiles = this.sessionData.get(sessionId);
+        if (!sessionFiles) return [];
+
+        return Array.from(sessionFiles).map(filePath =>
+            this.fileChanges.get(filePath)
+        ).filter(Boolean);
+    }
+
+    /**
+     * Get file tree structure grouped by working directory
+     * @param {string} sessionId - Optional session filter
+     * @returns {Object} Tree structure
+     */
+    getFileTree(sessionId = null) {
+        const files = this.getFilesForSession(sessionId);
+        const tree = {};
+
+        for (const fileData of files) {
+            const wd = fileData.workingDirectory || 'unknown';
+            if (!tree[wd]) {
+                tree[wd] = {
+                    path: wd,
+                    name: this.getDirectoryName(wd),
+                    files: [],
+                    totalOperations: 0,
+                    totalEdits: 0,
+                    totalReads: 0,
+                    totalWrites: 0
+                };
+            }
+
+            tree[wd].files.push(fileData);
+            tree[wd].totalOperations += fileData.operations.length;
+            tree[wd].totalEdits += fileData.totalEdits;
+            tree[wd].totalReads += fileData.totalReads;
+            tree[wd].totalWrites += fileData.totalWrites;
+        }
+
+        // Sort files within each directory
+        Object.values(tree).forEach(dir => {
+            dir.files.sort((a, b) =>
+                new Date(b.lastModified) - new Date(a.lastModified)
+            );
+        });
+
+        return tree;
+    }
+
+    /**
+     * Get directory name from path
+     * @param {string} dirPath - Directory path
+     * @returns {string} Directory name
+     */
+    getDirectoryName(dirPath) {
+        if (dirPath === 'unknown') return 'Unknown Directory';
+        const parts = dirPath.split('/');
+        return parts[parts.length - 1] || dirPath;
+    }
+
+    /**
+     * Get file change details
+     * @param {string} filePath - File path
+     * @returns {Object|null} File change data
+     */
+    getFileDetails(filePath) {
+        return this.fileChanges.get(filePath) || null;
+    }
+
+    /**
+     * Get operations for a file
+     * @param {string} filePath - File path
+     * @param {string} sessionId - Optional session filter
+     * @returns {Array} Array of operations
+     */
+    getFileOperations(filePath, sessionId = null) {
+        const fileData = this.fileChanges.get(filePath);
+        if (!fileData) return [];
+
+        let operations = fileData.operations;
+        if (sessionId) {
+            operations = operations.filter(op => op.sessionId === sessionId);
+        }
+
+        return operations.sort((a, b) =>
+            new Date(a.timestamp) - new Date(b.timestamp)
+        );
+    }
+
+    /**
+     * Get diff data for a file
+     * @param {string} filePath - File path
+     * @returns {Object} Diff data with initial and current content
+     */
+    getFileDiff(filePath) {
+        const fileData = this.fileChanges.get(filePath);
+        if (!fileData) return null;
+
+        return {
+            filePath,
+            fileName: fileData.fileName,
+            initialContent: fileData.initialContent || '',
+            currentContent: fileData.currentContent || '',
+            hasChanges: fileData.initialContent !== fileData.currentContent,
+            operations: fileData.operations,
+            totalEdits: fileData.totalEdits,
+            totalWrites: fileData.totalWrites
+        };
+    }
+
+    /**
+     * Clear all tracked data
+     */
+    clear() {
+        this.fileChanges.clear();
+        this.sessionData.clear();
+        this.workingDirectories.clear();
+        this.events = [];
+    }
+
+    /**
+     * Get statistics
+     * @returns {Object} Statistics
+     */
+    getStatistics() {
+        return {
+            totalFiles: this.fileChanges.size,
+            totalSessions: this.sessionData.size,
+            totalDirectories: this.workingDirectories.size,
+            filesWithEdits: Array.from(this.fileChanges.values())
+                .filter(f => f.totalEdits > 0).length,
+            filesWithWrites: Array.from(this.fileChanges.values())
+                .filter(f => f.totalWrites > 0).length,
+            readOnlyFiles: Array.from(this.fileChanges.values())
+                .filter(f => f.totalEdits === 0 && f.totalWrites === 0).length
+        };
+    }
+}
+
+// Export for use in other modules
+if (typeof window !== 'undefined') {
+    window.FileChangeTracker = FileChangeTracker;
+}