claude-mpm 3.4.0__py3-none-any.whl → 3.4.2__py3-none-any.whl

claude_mpm/services/socketio_server.py

@@ -294,7 +294,7 @@ class SocketIOServer:
             self.app.router.add_get('/dashboard', self._handle_dashboard)
             
             # Add static file serving for web assets
-            static_path = get_project_root() / 'src' / 'claude_mpm' / 'web' / 'static'
+            static_path = get_project_root() / 'src' / 'claude_mpm' / 'dashboard' / 'static'
             if static_path.exists():
                 self.app.router.add_static('/static/', path=str(static_path), name='static')
             
@@ -348,7 +348,7 @@ class SocketIOServer:
 
     async def _handle_dashboard(self, request):
         """Serve the dashboard HTML file."""
-        dashboard_path = get_project_root() / 'src' / 'claude_mpm' / 'web' / 'templates' / 'index.html'
+        dashboard_path = get_project_root() / 'src' / 'claude_mpm' / 'dashboard' / 'templates' / 'index.html'
         self.logger.info(f"Dashboard requested, looking for: {dashboard_path}")
         self.logger.info(f"Path exists: {dashboard_path.exists()}")
         if dashboard_path.exists():
@@ -648,8 +648,13 @@ class SocketIOServer:
                         working_dir = file_dir
                         self.logger.info(f"No git repo found, using file's directory: {working_dir}")
             
-            if working_dir is None:
+            # Handle case where working_dir is None, empty string, or 'Unknown'
+            original_working_dir = working_dir
+            if not working_dir or working_dir == 'Unknown' or working_dir.strip() == '':
                 working_dir = os.getcwd()
+                self.logger.info(f"[GIT-DIFF-DEBUG] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}")
+            else:
+                self.logger.info(f"[GIT-DIFF-DEBUG] Using provided working_dir: {working_dir}")
                 
             # For read-only git operations, we can work from any directory
             # by passing the -C flag to git commands instead of changing directories
@@ -999,32 +1004,47 @@ class SocketIOServer:
             try:
                 self.logger.info(f"[GIT-BRANCH-DEBUG] get_git_branch called with working_dir: {repr(working_dir)} (type: {type(working_dir)})")
                 
-                # Handle case where working_dir is None, empty string, or 'Unknown'
+                # Handle case where working_dir is None, empty string, or common invalid states
                 original_working_dir = working_dir
-                if not working_dir or working_dir == 'Unknown' or working_dir.strip() == '':
+                invalid_states = [
+                    None, '', 'Unknown', 'Loading...', 'Loading', 'undefined', 'null', 
+                    'Not Connected', 'Invalid Directory', 'No Directory'
+                ]
+                
+                if working_dir in invalid_states or (isinstance(working_dir, str) and working_dir.strip() == ''):
                     working_dir = os.getcwd()
                     self.logger.info(f"[GIT-BRANCH-DEBUG] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}")
                 else:
                     self.logger.info(f"[GIT-BRANCH-DEBUG] Using provided working_dir: {working_dir}")
+                    
+                # Additional validation for obviously invalid paths
+                if isinstance(working_dir, str):
+                    working_dir = working_dir.strip()
+                    # Check for null bytes or other invalid characters
+                    if '\x00' in working_dir:
+                        self.logger.warning(f"[GIT-BRANCH-DEBUG] working_dir contains null bytes, using cwd instead")
+                        working_dir = os.getcwd()
                 
                 # Validate that the directory exists and is a valid path
                 if not os.path.exists(working_dir):
-                    self.logger.warning(f"[GIT-BRANCH-DEBUG] Directory does not exist: {working_dir}")
+                    self.logger.info(f"[GIT-BRANCH-DEBUG] Directory does not exist: {working_dir} - responding gracefully")
                     await self.sio.emit('git_branch_response', {
                         'success': False,
-                        'error': f'Directory does not exist: {working_dir}',
+                        'error': f'Directory not found',
                         'working_dir': working_dir,
-                        'original_working_dir': original_working_dir
+                        'original_working_dir': original_working_dir,
+                        'detail': f'Path does not exist: {working_dir}'
                     }, room=sid)
                     return
                     
                 if not os.path.isdir(working_dir):
-                    self.logger.warning(f"[GIT-BRANCH-DEBUG] Path is not a directory: {working_dir}")
+                    self.logger.info(f"[GIT-BRANCH-DEBUG] Path is not a directory: {working_dir} - responding gracefully")
                     await self.sio.emit('git_branch_response', {
                         'success': False,
-                        'error': f'Path is not a directory: {working_dir}',
+                        'error': f'Not a directory',
                         'working_dir': working_dir,
-                        'original_working_dir': original_working_dir
+                        'original_working_dir': original_working_dir,
+                        'detail': f'Path is not a directory: {working_dir}'
                     }, room=sid)
                     return
                 
@@ -1140,6 +1160,163 @@ class SocketIOServer:
                     'file_path': data.get('file_path', 'unknown')
                 }, room=sid)
         
+        @self.sio.event
+        async def check_git_status(sid, data):
+            """Check git status for a file to determine if git diff icons should be shown"""
+            import subprocess
+            try:
+                file_path = data.get('file_path')
+                working_dir = data.get('working_dir', os.getcwd())
+                
+                self.logger.info(f"[GIT-STATUS-DEBUG] check_git_status called with file_path: {repr(file_path)}, working_dir: {repr(working_dir)}")
+                
+                if not file_path:
+                    await self.sio.emit('git_status_response', {
+                        'success': False,
+                        'error': 'file_path is required',
+                        'file_path': file_path
+                    }, room=sid)
+                    return
+                
+                # Validate and sanitize working_dir
+                original_working_dir = working_dir
+                if not working_dir or working_dir == 'Unknown' or working_dir.strip() == '' or working_dir == '.':
+                    working_dir = os.getcwd()
+                    self.logger.info(f"[GIT-STATUS-DEBUG] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}")
+                else:
+                    self.logger.info(f"[GIT-STATUS-DEBUG] Using provided working_dir: {working_dir}")
+                
+                # Check if the working directory exists and is a directory
+                if not os.path.exists(working_dir):
+                    self.logger.warning(f"[GIT-STATUS-DEBUG] Directory does not exist: {working_dir}")
+                    await self.sio.emit('git_status_response', {
+                        'success': False,
+                        'error': f'Directory does not exist: {working_dir}',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                    
+                if not os.path.isdir(working_dir):
+                    self.logger.warning(f"[GIT-STATUS-DEBUG] Path is not a directory: {working_dir}")
+                    await self.sio.emit('git_status_response', {
+                        'success': False,
+                        'error': f'Path is not a directory: {working_dir}',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                
+                # Check if this is a git repository
+                self.logger.info(f"[GIT-STATUS-DEBUG] Checking if {working_dir} is a git repository")
+                git_check = subprocess.run(
+                    ["git", "-C", working_dir, "rev-parse", "--git-dir"],
+                    capture_output=True,
+                    text=True
+                )
+                
+                if git_check.returncode != 0:
+                    self.logger.info(f"[GIT-STATUS-DEBUG] Not a git repository: {working_dir}")
+                    await self.sio.emit('git_status_response', {
+                        'success': False,
+                        'error': 'Not a git repository',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                
+                # Determine if the file path should be made relative to git root
+                file_path_for_git = file_path
+                if os.path.isabs(file_path):
+                    # Get git root to make path relative if needed
+                    git_root_result = subprocess.run(
+                        ["git", "-C", working_dir, "rev-parse", "--show-toplevel"],
+                        capture_output=True,
+                        text=True
+                    )
+                    
+                    if git_root_result.returncode == 0:
+                        git_root = git_root_result.stdout.strip()
+                        try:
+                            file_path_for_git = os.path.relpath(file_path, git_root)
+                            self.logger.info(f"[GIT-STATUS-DEBUG] Made file path relative to git root: {file_path_for_git}")
+                        except ValueError:
+                            # File is not under git root - keep original path
+                            self.logger.info(f"[GIT-STATUS-DEBUG] File not under git root, keeping original path: {file_path}")
+                            pass
+                
+                # Check if the file exists
+                full_path = file_path if os.path.isabs(file_path) else os.path.join(working_dir, file_path)
+                if not os.path.exists(full_path):
+                    self.logger.warning(f"[GIT-STATUS-DEBUG] File does not exist: {full_path}")
+                    await self.sio.emit('git_status_response', {
+                        'success': False,
+                        'error': f'File does not exist: {file_path}',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                
+                # Check git status for the file - this succeeds if git knows about the file
+                # (either tracked, modified, staged, etc.)
+                self.logger.info(f"[GIT-STATUS-DEBUG] Checking git status for file: {file_path_for_git}")
+                git_status_result = subprocess.run(
+                    ["git", "-C", working_dir, "status", "--porcelain", file_path_for_git],
+                    capture_output=True,
+                    text=True
+                )
+                
+                self.logger.info(f"[GIT-STATUS-DEBUG] Git status result: returncode={git_status_result.returncode}, stdout={repr(git_status_result.stdout)}, stderr={repr(git_status_result.stderr)}")
+                
+                # Also check if file is tracked by git (alternative approach)
+                ls_files_result = subprocess.run(
+                    ["git", "-C", working_dir, "ls-files", file_path_for_git],
+                    capture_output=True,
+                    text=True
+                )
+                
+                is_tracked = ls_files_result.returncode == 0 and ls_files_result.stdout.strip()
+                has_status = git_status_result.returncode == 0
+                
+                self.logger.info(f"[GIT-STATUS-DEBUG] File tracking status: is_tracked={is_tracked}, has_status={has_status}")
+                
+                # Success if git knows about the file (either tracked or has status changes)
+                if is_tracked or has_status:
+                    self.logger.info(f"[GIT-STATUS-DEBUG] Git status check successful for {file_path}")
+                    await self.sio.emit('git_status_response', {
+                        'success': True,
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir,
+                        'is_tracked': is_tracked,
+                        'has_changes': bool(git_status_result.stdout.strip()) if has_status else False
+                    }, room=sid)
+                else:
+                    self.logger.info(f"[GIT-STATUS-DEBUG] File {file_path} is not tracked by git")
+                    await self.sio.emit('git_status_response', {
+                        'success': False,
+                        'error': 'File is not tracked by git',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir,
+                        'is_tracked': False
+                    }, room=sid)
+                    
+            except Exception as e:
+                self.logger.error(f"[GIT-STATUS-DEBUG] Exception in check_git_status: {e}")
+                import traceback
+                self.logger.error(f"[GIT-STATUS-DEBUG] Stack trace: {traceback.format_exc()}")
+                await self.sio.emit('git_status_response', {
+                    'success': False,
+                    'error': str(e),
+                    'file_path': data.get('file_path', 'unknown'),
+                    'working_dir': data.get('working_dir', 'unknown')
+                }, room=sid)
+
         @self.sio.event
         async def git_add_file(sid, data):
             """Add file to git tracking"""