claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/services/socketio/handlers/git.py

@@ -5,561 +5,743 @@ file tracking status, and git add operations. Isolating git operations
 improves maintainability and makes it easier to extend git functionality.
 """
 
+import asyncio
 import os
 import subprocess
-import asyncio
-from typing import Optional, Dict, Any, List
 from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
+from ....core.typing_utils import EventData, PathLike, SocketId
 from .base import BaseEventHandler
-from ....core.typing_utils import SocketId, EventData, PathLike
 
 
 class GitEventHandler(BaseEventHandler):
     """Handles git-related Socket.IO events.
-    
+
     WHY: Git operations are a distinct domain that benefits from focused
     handling. This includes checking branches, file tracking status,
     and adding files to git. Separating these improves code organization.
     """
-    
+
     def register_events(self) -> None:
         """Register git-related event handlers."""
-        
+
         @self.sio.event
         async def get_git_branch(sid, working_dir=None):
             """Get the current git branch for a directory.
-            
+
             WHY: The dashboard needs to display the current git branch
             to provide context about which branch changes are being made on.
             """
             try:
-                self.logger.info(f"[GIT-BRANCH-DEBUG] get_git_branch called with working_dir: {repr(working_dir)} (type: {type(working_dir)})")
-                
+                # Debug: get_git_branch called
+
                 # Validate and sanitize working directory
                 working_dir = self._sanitize_working_dir(working_dir, "get_git_branch")
-                
-                if not self._validate_directory(sid, working_dir, "git_branch_response"):
+
+                if not await self._validate_directory(
+                    sid, working_dir, "git_branch_response"
+                ):
                     return
-                
-                self.logger.info(f"[GIT-BRANCH-DEBUG] Running git command in directory: {working_dir}")
-                
+
+                # Debug: Running git command
+
                 # Run git command to get current branch
                 result = subprocess.run(
                     ["git", "rev-parse", "--abbrev-ref", "HEAD"],
                     cwd=working_dir,
                     capture_output=True,
-                    text=True
+                    text=True,
                 )
-                
-                self.logger.info(f"[GIT-BRANCH-DEBUG] Git command result: returncode={result.returncode}, stdout={repr(result.stdout)}, stderr={repr(result.stderr)}")
-                
+
+                # Debug: Git command completed
+
                 if result.returncode == 0:
                     branch = result.stdout.strip()
-                    self.logger.info(f"[GIT-BRANCH-DEBUG] Successfully got git branch: {branch}")
-                    await self.emit_to_client(sid, 'git_branch_response', {
-                        'success': True,
-                        'branch': branch,
-                        'working_dir': working_dir,
-                        'original_working_dir': working_dir
-                    })
+                    # Debug: Successfully got git branch
+                    await self.emit_to_client(
+                        sid,
+                        "git_branch_response",
+                        {
+                            "success": True,
+                            "branch": branch,
+                            "working_dir": working_dir,
+                            "original_working_dir": working_dir,
+                        },
+                    )
                 else:
-                    self.logger.warning(f"[GIT-BRANCH-DEBUG] Git command failed: {result.stderr}")
-                    await self.emit_to_client(sid, 'git_branch_response', {
-                        'success': False,
-                        'error': 'Not a git repository',
-                        'working_dir': working_dir,
-                        'original_working_dir': working_dir,
-                        'git_error': result.stderr
-                    })
-                    
+                    self.logger.warning(f"Git command failed: {result.stderr}")
+                    await self.emit_to_client(
+                        sid,
+                        "git_branch_response",
+                        {
+                            "success": False,
+                            "error": "Not a git repository",
+                            "working_dir": working_dir,
+                            "original_working_dir": working_dir,
+                            "git_error": result.stderr,
+                        },
+                    )
+
             except Exception as e:
                 self.log_error("get_git_branch", e, {"working_dir": working_dir})
-                await self.emit_to_client(sid, 'git_branch_response', {
-                    'success': False,
-                    'error': str(e),
-                    'working_dir': working_dir,
-                    'original_working_dir': working_dir
-                })
-        
+                await self.emit_to_client(
+                    sid,
+                    "git_branch_response",
+                    {
+                        "success": False,
+                        "error": str(e),
+                        "working_dir": working_dir,
+                        "original_working_dir": working_dir,
+                    },
+                )
+
         @self.sio.event
         async def check_file_tracked(sid, data):
             """Check if a file is tracked by git.
-            
+
             WHY: The dashboard needs to know if a file is tracked by git
             to determine whether to show git-related UI elements.
             """
             try:
-                file_path = data.get('file_path')
-                working_dir = data.get('working_dir', os.getcwd())
-                
+                file_path = data.get("file_path")
+                working_dir = data.get("working_dir", os.getcwd())
+
                 if not file_path:
-                    await self.emit_to_client(sid, 'file_tracked_response', {
-                        'success': False,
-                        'error': 'file_path is required',
-                        'file_path': file_path
-                    })
+                    await self.emit_to_client(
+                        sid,
+                        "file_tracked_response",
+                        {
+                            "success": False,
+                            "error": "file_path is required",
+                            "file_path": file_path,
+                        },
+                    )
                     return
-                
+
                 # Use git ls-files to check if file is tracked
                 result = subprocess.run(
                     ["git", "-C", working_dir, "ls-files", "--", file_path],
                     capture_output=True,
-                    text=True
+                    text=True,
                 )
-                
+
                 is_tracked = result.returncode == 0 and result.stdout.strip()
-                
-                await self.emit_to_client(sid, 'file_tracked_response', {
-                    'success': True,
-                    'file_path': file_path,
-                    'working_dir': working_dir,
-                    'is_tracked': bool(is_tracked)
-                })
-                    
+
+                await self.emit_to_client(
+                    sid,
+                    "file_tracked_response",
+                    {
+                        "success": True,
+                        "file_path": file_path,
+                        "working_dir": working_dir,
+                        "is_tracked": bool(is_tracked),
+                    },
+                )
+
             except Exception as e:
                 self.log_error("check_file_tracked", e, data)
-                await self.emit_to_client(sid, 'file_tracked_response', {
-                    'success': False,
-                    'error': str(e),
-                    'file_path': data.get('file_path', 'unknown')
-                })
-        
+                await self.emit_to_client(
+                    sid,
+                    "file_tracked_response",
+                    {
+                        "success": False,
+                        "error": str(e),
+                        "file_path": data.get("file_path", "unknown"),
+                    },
+                )
+
         @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.
-            
+
             WHY: The dashboard shows git diff icons for files that have changes.
             This checks if a file has git status to determine icon visibility.
             """
             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)}")
-                
+                file_path = data.get("file_path")
+                working_dir = data.get("working_dir", os.getcwd())
+
+                # Debug: check_git_status called
+
                 if not file_path:
-                    await self.emit_to_client(sid, 'git_status_response', {
-                        'success': False,
-                        'error': 'file_path is required',
-                        'file_path': file_path
-                    })
+                    await self.emit_to_client(
+                        sid,
+                        "git_status_response",
+                        {
+                            "success": False,
+                            "error": "file_path is required",
+                            "file_path": file_path,
+                        },
+                    )
                     return
-                
+
                 # Validate and sanitize working_dir
                 original_working_dir = working_dir
-                working_dir = self._sanitize_working_dir(working_dir, "check_git_status")
-                
-                if not self._validate_directory_for_status(sid, working_dir, original_working_dir, file_path):
+                working_dir = self._sanitize_working_dir(
+                    working_dir, "check_git_status"
+                )
+
+                if not await self._validate_directory_for_status(
+                    sid, working_dir, original_working_dir, file_path
+                ):
                     return
-                
+
                 # Check if this is a git repository
                 if not self._is_git_repository(working_dir):
-                    await self.emit_to_client(sid, 'git_status_response', {
-                        'success': False,
-                        'error': 'Not a git repository',
-                        'file_path': file_path,
-                        'working_dir': working_dir,
-                        'original_working_dir': original_working_dir
-                    })
+                    await self.emit_to_client(
+                        sid,
+                        "git_status_response",
+                        {
+                            "success": False,
+                            "error": "Not a git repository",
+                            "file_path": file_path,
+                            "working_dir": working_dir,
+                            "original_working_dir": original_working_dir,
+                        },
+                    )
                     return
-                
+
                 # Check git status for the file
-                file_path_for_git = self._make_path_relative_to_git(file_path, working_dir)
-                
+                file_path_for_git = self._make_path_relative_to_git(
+                    file_path, working_dir
+                )
+
                 # 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.emit_to_client(sid, '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
-                    })
+                file_path_obj = Path(file_path)
+                full_path = (
+                    file_path_obj
+                    if file_path_obj.is_absolute()
+                    else Path(working_dir) / file_path
+                )
+                if not full_path.exists():
+                    self.logger.warning(f"File does not exist: {full_path}")
+                    await self.emit_to_client(
+                        sid,
+                        "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,
+                        },
+                    )
                     return
-                
+
                 # Check git status and tracking
-                is_tracked, has_changes = self._check_file_git_status(file_path_for_git, working_dir)
-                
+                is_tracked, has_changes = self._check_file_git_status(
+                    file_path_for_git, working_dir
+                )
+
                 if is_tracked or has_changes:
-                    self.logger.info(f"[GIT-STATUS-DEBUG] Git status check successful for {file_path}")
-                    await self.emit_to_client(sid, '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': has_changes
-                    })
+                    # Debug: Git status check successful
+                    await self.emit_to_client(
+                        sid,
+                        "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": has_changes,
+                        },
+                    )
                 else:
-                    self.logger.info(f"[GIT-STATUS-DEBUG] File {file_path} is not tracked by git")
-                    await self.emit_to_client(sid, '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
-                    })
-                    
+                    # Debug: File is not tracked by git
+                    await self.emit_to_client(
+                        sid,
+                        "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,
+                        },
+                    )
+
             except Exception as e:
                 self.log_error("check_git_status", e, data)
-                await self.emit_to_client(sid, 'git_status_response', {
-                    'success': False,
-                    'error': str(e),
-                    'file_path': data.get('file_path', 'unknown'),
-                    'working_dir': data.get('working_dir', 'unknown')
-                })
-        
+                await self.emit_to_client(
+                    sid,
+                    "git_status_response",
+                    {
+                        "success": False,
+                        "error": str(e),
+                        "file_path": data.get("file_path", "unknown"),
+                        "working_dir": data.get("working_dir", "unknown"),
+                    },
+                )
+
         @self.sio.event
         async def git_add_file(sid, data):
             """Add file to git tracking.
-            
+
             WHY: Users can add untracked files to git directly from the dashboard,
             making it easier to manage version control without leaving the UI.
             """
             try:
-                file_path = data.get('file_path')
-                working_dir = data.get('working_dir', os.getcwd())
-                
-                self.logger.info(f"[GIT-ADD-DEBUG] git_add_file called with file_path: {repr(file_path)}, working_dir: {repr(working_dir)} (type: {type(working_dir)})")
-                
+                file_path = data.get("file_path")
+                working_dir = data.get("working_dir", os.getcwd())
+
+                # Debug: git_add_file called
+
                 if not file_path:
-                    await self.emit_to_client(sid, 'git_add_response', {
-                        'success': False,
-                        'error': 'file_path is required',
-                        'file_path': file_path
-                    })
+                    await self.emit_to_client(
+                        sid,
+                        "git_add_response",
+                        {
+                            "success": False,
+                            "error": "file_path is required",
+                            "file_path": file_path,
+                        },
+                    )
                     return
-                
+
                 # Validate and sanitize working_dir
                 original_working_dir = working_dir
                 working_dir = self._sanitize_working_dir(working_dir, "git_add_file")
-                
-                if not self._validate_directory_for_add(sid, working_dir, original_working_dir, file_path):
+
+                if not await self._validate_directory_for_add(
+                    sid, working_dir, original_working_dir, file_path
+                ):
                     return
-                
-                self.logger.info(f"[GIT-ADD-DEBUG] Running git add command in directory: {working_dir}")
-                
+
+                # Debug: Running git add command
+
                 # Use git add to track the file
                 result = subprocess.run(
                     ["git", "-C", working_dir, "add", file_path],
                     capture_output=True,
-                    text=True
+                    text=True,
                 )
-                
-                self.logger.info(f"[GIT-ADD-DEBUG] Git add result: returncode={result.returncode}, stdout={repr(result.stdout)}, stderr={repr(result.stderr)}")
-                
+
+                # Debug: Git add completed
+
                 if result.returncode == 0:
-                    self.logger.info(f"[GIT-ADD-DEBUG] Successfully added {file_path} to git in {working_dir}")
-                    await self.emit_to_client(sid, 'git_add_response', {
-                        'success': True,
-                        'file_path': file_path,
-                        'working_dir': working_dir,
-                        'original_working_dir': original_working_dir,
-                        'message': 'File successfully added to git tracking'
-                    })
+                    # Debug: Successfully added file to git
+                    await self.emit_to_client(
+                        sid,
+                        "git_add_response",
+                        {
+                            "success": True,
+                            "file_path": file_path,
+                            "working_dir": working_dir,
+                            "original_working_dir": original_working_dir,
+                            "message": "File successfully added to git tracking",
+                        },
+                    )
                 else:
-                    error_message = result.stderr.strip() or 'Unknown git error'
-                    self.logger.warning(f"[GIT-ADD-DEBUG] Git add failed: {error_message}")
-                    await self.emit_to_client(sid, 'git_add_response', {
-                        'success': False,
-                        'error': f'Git add failed: {error_message}',
-                        'file_path': file_path,
-                        'working_dir': working_dir,
-                        'original_working_dir': original_working_dir
-                    })
-                    
+                    error_message = result.stderr.strip() or "Unknown git error"
+                    self.logger.warning(f"Git add failed: {error_message}")
+                    await self.emit_to_client(
+                        sid,
+                        "git_add_response",
+                        {
+                            "success": False,
+                            "error": f"Git add failed: {error_message}",
+                            "file_path": file_path,
+                            "working_dir": working_dir,
+                            "original_working_dir": original_working_dir,
+                        },
+                    )
+
             except Exception as e:
                 self.log_error("git_add_file", e, data)
-                await self.emit_to_client(sid, 'git_add_response', {
-                    'success': False,
-                    'error': str(e),
-                    'file_path': data.get('file_path', 'unknown'),
-                    'working_dir': data.get('working_dir', 'unknown')
-                })
-    
+                await self.emit_to_client(
+                    sid,
+                    "git_add_response",
+                    {
+                        "success": False,
+                        "error": str(e),
+                        "file_path": data.get("file_path", "unknown"),
+                        "working_dir": data.get("working_dir", "unknown"),
+                    },
+                )
+
     def _sanitize_working_dir(self, working_dir: Optional[str], operation: str) -> str:
         """Sanitize and validate working directory input.
-        
+
         WHY: Working directory input from clients can be invalid or malformed.
         This ensures we have a valid directory path to work with.
         """
         invalid_states = [
-            None, '', 'Unknown', 'Loading...', 'Loading', 'undefined', 'null', 
-            'Not Connected', 'Invalid Directory', 'No Directory', '.'
+            None,
+            "",
+            "Unknown",
+            "Loading...",
+            "Loading",
+            "undefined",
+            "null",
+            "Not Connected",
+            "Invalid Directory",
+            "No Directory",
+            ".",
         ]
-        
+
         original_working_dir = working_dir
-        if working_dir in invalid_states or (isinstance(working_dir, str) and working_dir.strip() == ''):
+        if working_dir in invalid_states or (
+            isinstance(working_dir, str) and working_dir.strip() == ""
+        ):
             working_dir = os.getcwd()
-            self.logger.info(f"[{operation}] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}")
+            self.logger.info(
+                f"[{operation}] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}"
+            )
         else:
             self.logger.info(f"[{operation}] 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"[{operation}] working_dir contains null bytes, using cwd instead")
+            if "\x00" in working_dir:
+                self.logger.warning(
+                    f"[{operation}] working_dir contains null bytes, using cwd instead"
+                )
                 working_dir = os.getcwd()
-        
+
         return working_dir
-    
-    async def _validate_directory(self, sid: str, working_dir: str, response_event: str) -> bool:
+
+    async def _validate_directory(
+        self, sid: str, working_dir: str, response_event: str
+    ) -> bool:
         """Validate that a directory exists and is accessible.
-        
+
         WHY: We need to ensure the directory exists and is a directory
         before attempting git operations on it.
         """
-        if not os.path.exists(working_dir):
-            self.logger.info(f"Directory does not exist: {working_dir} - responding gracefully")
-            await self.emit_to_client(sid, response_event, {
-                'success': False,
-                'error': f'Directory not found',
-                'working_dir': working_dir,
-                'detail': f'Path does not exist: {working_dir}'
-            })
+        working_dir_path = Path(working_dir)
+        if not working_dir_path.exists():
+            self.logger.info(
+                f"Directory does not exist: {working_dir} - responding gracefully"
+            )
+            await self.emit_to_client(
+                sid,
+                response_event,
+                {
+                    "success": False,
+                    "error": f"Directory not found",
+                    "working_dir": working_dir,
+                    "detail": f"Path does not exist: {working_dir}",
+                },
+            )
             return False
-            
-        if not os.path.isdir(working_dir):
-            self.logger.info(f"Path is not a directory: {working_dir} - responding gracefully")
-            await self.emit_to_client(sid, response_event, {
-                'success': False,
-                'error': f'Not a directory',
-                'working_dir': working_dir,
-                'detail': f'Path is not a directory: {working_dir}'
-            })
+
+        if not working_dir_path.is_dir():
+            self.logger.info(
+                f"Path is not a directory: {working_dir} - responding gracefully"
+            )
+            await self.emit_to_client(
+                sid,
+                response_event,
+                {
+                    "success": False,
+                    "error": f"Not a directory",
+                    "working_dir": working_dir,
+                    "detail": f"Path is not a directory: {working_dir}",
+                },
+            )
             return False
-        
+
         return True
-    
-    async def _validate_directory_for_status(self, sid: str, working_dir: str, original_working_dir: str, file_path: str) -> bool:
+
+    async def _validate_directory_for_status(
+        self, sid: str, working_dir: str, original_working_dir: str, file_path: str
+    ) -> bool:
         """Validate directory for git status operations."""
-        if not os.path.exists(working_dir):
-            self.logger.warning(f"[GIT-STATUS-DEBUG] Directory does not exist: {working_dir}")
-            await self.emit_to_client(sid, '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
-            })
+        working_dir_path = Path(working_dir)
+        if not working_dir_path.exists():
+            self.logger.warning(f"Directory does not exist: {working_dir}")
+            await self.emit_to_client(
+                sid,
+                "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,
+                },
+            )
             return False
-            
-        if not os.path.isdir(working_dir):
-            self.logger.warning(f"[GIT-STATUS-DEBUG] Path is not a directory: {working_dir}")
-            await self.emit_to_client(sid, '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
-            })
+
+        if not working_dir_path.is_dir():
+            self.logger.warning(f"Path is not a directory: {working_dir}")
+            await self.emit_to_client(
+                sid,
+                "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,
+                },
+            )
             return False
-        
+
         return True
-    
-    async def _validate_directory_for_add(self, sid: str, working_dir: str, original_working_dir: str, file_path: str) -> bool:
+
+    async def _validate_directory_for_add(
+        self, sid: str, working_dir: str, original_working_dir: str, file_path: str
+    ) -> bool:
         """Validate directory for git add operations."""
-        if not os.path.exists(working_dir):
-            self.logger.warning(f"[GIT-ADD-DEBUG] Directory does not exist: {working_dir}")
-            await self.emit_to_client(sid, 'git_add_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
-            })
+        working_dir_path = Path(working_dir)
+        if not working_dir_path.exists():
+            self.logger.warning(f"Directory does not exist: {working_dir}")
+            await self.emit_to_client(
+                sid,
+                "git_add_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,
+                },
+            )
             return False
-            
-        if not os.path.isdir(working_dir):
-            self.logger.warning(f"[GIT-ADD-DEBUG] Path is not a directory: {working_dir}")
-            await self.emit_to_client(sid, 'git_add_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
-            })
+
+        if not working_dir_path.is_dir():
+            self.logger.warning(f"Path is not a directory: {working_dir}")
+            await self.emit_to_client(
+                sid,
+                "git_add_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,
+                },
+            )
             return False
-        
+
         return True
-    
+
     def _is_git_repository(self, working_dir: str) -> bool:
         """Check if a directory is a git repository."""
         git_check = subprocess.run(
             ["git", "-C", working_dir, "rev-parse", "--git-dir"],
             capture_output=True,
-            text=True
+            text=True,
         )
         return git_check.returncode == 0
-    
+
     def _make_path_relative_to_git(self, file_path: str, working_dir: str) -> str:
         """Make an absolute path relative to the git root if needed."""
-        if not os.path.isabs(file_path):
+        file_path_obj = Path(file_path)
+        if not file_path_obj.is_absolute():
             return 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
+            text=True,
         )
-        
+
         if git_root_result.returncode == 0:
-            git_root = git_root_result.stdout.strip()
+            git_root = Path(git_root_result.stdout.strip())
             try:
-                relative_path = os.path.relpath(file_path, git_root)
-                self.logger.info(f"Made file path relative to git root: {relative_path}")
-                return relative_path
+                relative_path = file_path_obj.relative_to(git_root)
+                self.logger.info(
+                    f"Made file path relative to git root: {relative_path}"
+                )
+                return str(relative_path)
             except ValueError:
                 # File is not under git root - keep original path
-                self.logger.info(f"File not under git root, keeping original path: {file_path}")
-        
+                self.logger.info(
+                    f"File not under git root, keeping original path: {file_path}"
+                )
+
         return file_path
-    
-    def _check_file_git_status(self, file_path: str, working_dir: str) -> tuple[bool, bool]:
+
+    def _check_file_git_status(
+        self, file_path: str, working_dir: str
+    ) -> tuple[bool, bool]:
         """Check if a file is tracked and has changes."""
         # Check git status for the file
         git_status_result = subprocess.run(
             ["git", "-C", working_dir, "status", "--porcelain", file_path],
             capture_output=True,
-            text=True
+            text=True,
         )
-        
+
         # Check if file is tracked by git
         ls_files_result = subprocess.run(
             ["git", "-C", working_dir, "ls-files", file_path],
             capture_output=True,
-            text=True
+            text=True,
         )
-        
+
         is_tracked = ls_files_result.returncode == 0 and ls_files_result.stdout.strip()
-        has_changes = git_status_result.returncode == 0 and bool(git_status_result.stdout.strip())
-        
-        self.logger.info(f"File tracking status: is_tracked={is_tracked}, has_changes={has_changes}")
-        
+        has_changes = git_status_result.returncode == 0 and bool(
+            git_status_result.stdout.strip()
+        )
+
+        self.logger.info(
+            f"File tracking status: is_tracked={is_tracked}, has_changes={has_changes}"
+        )
+
         return is_tracked, has_changes
-    
-    async def generate_git_diff(self, file_path: str, timestamp: Optional[str] = None, working_dir: Optional[str] = None) -> Dict[str, Any]:
+
+    async def generate_git_diff(
+        self,
+        file_path: str,
+        timestamp: Optional[str] = None,
+        working_dir: Optional[str] = None,
+    ) -> Dict[str, Any]:
         """Generate git diff for a specific file operation.
-        
+
         WHY: This method generates a git diff showing the changes made to a file
         during a specific write operation. It uses git log and show commands to
         find the most relevant commit around the specified timestamp.
-        
+
         Args:
             file_path: Path to the file relative to the git repository
             timestamp: ISO timestamp of the file operation (optional)
             working_dir: Working directory containing the git repository
-            
+
         Returns:
             dict: Contains diff content, metadata, and status information
         """
         try:
             # If file_path is absolute, determine its git repository
-            if os.path.isabs(file_path):
+            file_path_obj = Path(file_path)
+            if file_path_obj.is_absolute():
                 # Find the directory containing the file
-                file_dir = os.path.dirname(file_path)
-                if os.path.exists(file_dir):
+                file_dir = file_path_obj.parent
+                if file_dir.exists():
                     # Try to find the git root from the file's directory
                     current_dir = file_dir
-                    while current_dir != "/" and current_dir:
-                        if os.path.exists(os.path.join(current_dir, ".git")):
-                            working_dir = current_dir
+                    while current_dir != current_dir.parent:  # Stop at root
+                        if (current_dir / ".git").exists():
+                            working_dir = str(current_dir)
                             self.logger.info(f"Found git repository at: {working_dir}")
                             break
-                        current_dir = os.path.dirname(current_dir)
+                        current_dir = current_dir.parent
                     else:
                         # If no git repo found, use the file's directory
-                        working_dir = file_dir
-                        self.logger.info(f"No git repo found, using file's directory: {working_dir}")
-            
+                        working_dir = str(file_dir)
+                        self.logger.info(
+                            f"No git repo found, using file's directory: {working_dir}"
+                        )
+
             # 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() == '':
+            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}")
+                # Debug: working_dir was invalid, using cwd
             else:
-                self.logger.info(f"[GIT-DIFF-DEBUG] Using provided working_dir: {working_dir}")
-                
+                # Debug: Using provided working_dir
+                pass
+
             # For read-only git operations, we can work from any directory
             # by passing the -C flag to git commands instead of changing directories
             original_cwd = os.getcwd()
             try:
                 # We'll use git -C <working_dir> for all commands instead of chdir
-                
+
                 # Check if this is a git repository
                 git_check = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'rev-parse', '--git-dir',
+                    "git",
+                    "-C",
+                    working_dir,
+                    "rev-parse",
+                    "--git-dir",
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 await git_check.communicate()
-                
+
                 if git_check.returncode != 0:
                     return {
                         "success": False,
                         "error": "Not a git repository",
                         "file_path": file_path,
-                        "working_dir": working_dir
+                        "working_dir": working_dir,
                     }
-                
+
                 # Get the absolute path of the file relative to git root
                 git_root_proc = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'rev-parse', '--show-toplevel',
+                    "git",
+                    "-C",
+                    working_dir,
+                    "rev-parse",
+                    "--show-toplevel",
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 git_root_output, _ = await git_root_proc.communicate()
-                
+
                 if git_root_proc.returncode != 0:
-                    return {"success": False, "error": "Failed to determine git root directory"}
-                
+                    return {
+                        "success": False,
+                        "error": "Failed to determine git root directory",
+                    }
+
                 git_root = git_root_output.decode().strip()
-                
+
                 # Make file_path relative to git root if it's absolute
-                if os.path.isabs(file_path):
+                file_path_obj = Path(file_path)
+                if file_path_obj.is_absolute():
                     try:
-                        file_path = os.path.relpath(file_path, git_root)
+                        file_path = str(file_path_obj.relative_to(Path(git_root)))
                     except ValueError:
                         # File is not under git root
                         pass
-                
+
                 # If timestamp is provided, try to find commits around that time
                 if timestamp:
                     # Convert timestamp to git format
                     try:
-                        dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
-                        git_since = dt.strftime('%Y-%m-%d %H:%M:%S')
-                        
+                        dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+                        git_since = dt.strftime("%Y-%m-%d %H:%M:%S")
+
                         # Find commits that modified this file around the timestamp
                         log_proc = await asyncio.create_subprocess_exec(
-                            'git', '-C', working_dir, 'log', '--oneline', '--since', git_since, 
-                            '--until', f'{git_since} +1 hour', '--', file_path,
+                            "git",
+                            "-C",
+                            working_dir,
+                            "log",
+                            "--oneline",
+                            "--since",
+                            git_since,
+                            "--until",
+                            f"{git_since} +1 hour",
+                            "--",
+                            file_path,
                             stdout=asyncio.subprocess.PIPE,
-                            stderr=asyncio.subprocess.PIPE
+                            stderr=asyncio.subprocess.PIPE,
                         )
                         log_output, _ = await log_proc.communicate()
-                        
+
                         if log_proc.returncode == 0 and log_output:
                             # Get the most recent commit hash
-                            commits = log_output.decode().strip().split('\n')
+                            commits = log_output.decode().strip().split("\n")
                             if commits and commits[0]:
                                 commit_hash = commits[0].split()[0]
-                                
+
                                 # Get the diff for this specific commit
                                 diff_proc = await asyncio.create_subprocess_exec(
-                                    'git', '-C', working_dir, 'show', '--format=fuller', commit_hash, '--', file_path,
+                                    "git",
+                                    "-C",
+                                    working_dir,
+                                    "show",
+                                    "--format=fuller",
+                                    commit_hash,
+                                    "--",
+                                    file_path,
                                     stdout=asyncio.subprocess.PIPE,
-                                    stderr=asyncio.subprocess.PIPE
+                                    stderr=asyncio.subprocess.PIPE,
                                 )
                                 diff_output, diff_error = await diff_proc.communicate()
-                                
+
                                 if diff_proc.returncode == 0:
                                     return {
                                         "success": True,
@@ -567,30 +749,46 @@ class GitEventHandler(BaseEventHandler):
                                         "commit_hash": commit_hash,
                                         "file_path": file_path,
                                         "method": "timestamp_based",
-                                        "timestamp": timestamp
+                                        "timestamp": timestamp,
                                     }
                     except Exception as e:
-                        self.logger.warning(f"Failed to parse timestamp or find commits: {e}")
-                
+                        self.logger.warning(
+                            f"Failed to parse timestamp or find commits: {e}"
+                        )
+
                 # Fallback: Get the most recent change to the file
                 log_proc = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'log', '-1', '--oneline', '--', file_path,
+                    "git",
+                    "-C",
+                    working_dir,
+                    "log",
+                    "-1",
+                    "--oneline",
+                    "--",
+                    file_path,
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 log_output, _ = await log_proc.communicate()
-                
+
                 if log_proc.returncode == 0 and log_output:
                     commit_hash = log_output.decode().strip().split()[0]
-                    
+
                     # Get the diff for the most recent commit
                     diff_proc = await asyncio.create_subprocess_exec(
-                        'git', '-C', working_dir, 'show', '--format=fuller', commit_hash, '--', file_path,
+                        "git",
+                        "-C",
+                        working_dir,
+                        "show",
+                        "--format=fuller",
+                        commit_hash,
+                        "--",
+                        file_path,
                         stdout=asyncio.subprocess.PIPE,
-                        stderr=asyncio.subprocess.PIPE
+                        stderr=asyncio.subprocess.PIPE,
                     )
                     diff_output, diff_error = await diff_proc.communicate()
-                    
+
                     if diff_proc.returncode == 0:
                         return {
                             "success": True,
@@ -598,17 +796,22 @@ class GitEventHandler(BaseEventHandler):
                             "commit_hash": commit_hash,
                             "file_path": file_path,
                             "method": "latest_commit",
-                            "timestamp": timestamp
+                            "timestamp": timestamp,
                         }
-                
+
                 # Try to show unstaged changes first
                 diff_proc = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'diff', '--', file_path,
+                    "git",
+                    "-C",
+                    working_dir,
+                    "diff",
+                    "--",
+                    file_path,
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 diff_output, _ = await diff_proc.communicate()
-                
+
                 if diff_proc.returncode == 0 and diff_output.decode().strip():
                     return {
                         "success": True,
@@ -616,17 +819,23 @@ class GitEventHandler(BaseEventHandler):
                         "commit_hash": "unstaged_changes",
                         "file_path": file_path,
                         "method": "unstaged_changes",
-                        "timestamp": timestamp
+                        "timestamp": timestamp,
                     }
-                
+
                 # Then try staged changes
                 diff_proc = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'diff', '--cached', '--', file_path,
+                    "git",
+                    "-C",
+                    working_dir,
+                    "diff",
+                    "--cached",
+                    "--",
+                    file_path,
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 diff_output, _ = await diff_proc.communicate()
-                
+
                 if diff_proc.returncode == 0 and diff_output.decode().strip():
                     return {
                         "success": True,
@@ -634,17 +843,23 @@ class GitEventHandler(BaseEventHandler):
                         "commit_hash": "staged_changes",
                         "file_path": file_path,
                         "method": "staged_changes",
-                        "timestamp": timestamp
+                        "timestamp": timestamp,
                     }
-                
+
                 # Final fallback: Show changes against HEAD
                 diff_proc = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'diff', 'HEAD', '--', file_path,
+                    "git",
+                    "-C",
+                    working_dir,
+                    "diff",
+                    "HEAD",
+                    "--",
+                    file_path,
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 diff_output, _ = await diff_proc.communicate()
-                
+
                 if diff_proc.returncode == 0:
                     working_diff = diff_output.decode()
                     if working_diff.strip():
@@ -654,19 +869,26 @@ class GitEventHandler(BaseEventHandler):
                             "commit_hash": "working_directory",
                             "file_path": file_path,
                             "method": "working_directory",
-                            "timestamp": timestamp
+                            "timestamp": timestamp,
                         }
-                
+
                 # Check if file is tracked by git
                 status_proc = await asyncio.create_subprocess_exec(
-                    'git', '-C', working_dir, 'ls-files', '--', file_path,
+                    "git",
+                    "-C",
+                    working_dir,
+                    "ls-files",
+                    "--",
+                    file_path,
                     stdout=asyncio.subprocess.PIPE,
-                    stderr=asyncio.subprocess.PIPE
+                    stderr=asyncio.subprocess.PIPE,
                 )
                 status_output, _ = await status_proc.communicate()
-                
-                is_tracked = status_proc.returncode == 0 and status_output.decode().strip()
-                
+
+                is_tracked = (
+                    status_proc.returncode == 0 and status_output.decode().strip()
+                )
+
                 if not is_tracked:
                     # File is not tracked by git
                     return {
@@ -677,47 +899,59 @@ class GitEventHandler(BaseEventHandler):
                         "suggestions": [
                             "This file has not been added to git yet",
                             "Use 'git add' to track this file before viewing its diff",
-                            "Git diff can only show changes for files that are tracked by git"
-                        ]
+                            "Git diff can only show changes for files that are tracked by git",
+                        ],
                     }
-                
+
                 # File is tracked but has no changes to show
                 suggestions = [
                     "The file may not have any committed changes yet",
                     "The file may have been added but not committed",
-                    "The timestamp may be outside the git history range"
+                    "The timestamp may be outside the git history range",
                 ]
-                
-                if os.path.isabs(file_path) and not file_path.startswith(os.getcwd()):
-                    current_repo = os.path.basename(os.getcwd())
+
+                file_path_obj = Path(file_path)
+                current_cwd = Path.cwd()
+                if file_path_obj.is_absolute() and not str(file_path_obj).startswith(
+                    str(current_cwd)
+                ):
+                    current_repo = current_cwd.name
                     file_repo = "unknown"
                     # Try to extract repository name from path
-                    path_parts = file_path.split("/")
+                    path_parts = file_path_obj.parts
                     if "Projects" in path_parts:
                         idx = path_parts.index("Projects")
                         if idx + 1 < len(path_parts):
                             file_repo = path_parts[idx + 1]
-                    
+
                     suggestions.clear()
-                    suggestions.append(f"This file is from the '{file_repo}' repository")
-                    suggestions.append(f"The git diff viewer is running from the '{current_repo}' repository")
-                    suggestions.append("Git diff can only show changes for files in the current repository")
-                    suggestions.append("To view changes for this file, run the monitoring dashboard from its repository")
-                
+                    suggestions.append(
+                        f"This file is from the '{file_repo}' repository"
+                    )
+                    suggestions.append(
+                        f"The git diff viewer is running from the '{current_repo}' repository"
+                    )
+                    suggestions.append(
+                        "Git diff can only show changes for files in the current repository"
+                    )
+                    suggestions.append(
+                        "To view changes for this file, run the monitoring dashboard from its repository"
+                    )
+
                 return {
                     "success": False,
                     "error": "No git history found for this file",
                     "file_path": file_path,
-                    "suggestions": suggestions
+                    "suggestions": suggestions,
                 }
-                
+
             finally:
                 os.chdir(original_cwd)
-                
+
         except Exception as e:
             self.logger.error(f"Error in generate_git_diff: {e}")
             return {
                 "success": False,
                 "error": f"Git diff generation failed: {str(e)}",
-                "file_path": file_path
-            }
+                "file_path": file_path,
+            }