Refactor Git server with improved branch and checkout handling

- Enhance branch creation with more robust error handling
- Improve checkout method with better error management
- Rename GitCheckoutModel and update related references
- Simplify path validation logic in PathValidator
- Add more comprehensive error handling for Git operations

Author: sparesparrow

src/git/src/mcp_server_git/server.py

@@ -39,31 +39,21 @@ def __init__(self, base_path: Path | str | None = None):
         self.base_path = Path(base_path).resolve() if base_path else None
 
     def is_safe_path(self, path: Path) -> bool:
-        """Check if a path is safe to access.
-        
-        A path is considered safe if:
-        1. It's absolute
-        2. It doesn't contain symlinks that could bypass restrictions
-        3. If base_path is set, it must be within that directory
-        4. It's not a system directory (/etc, /usr, /bin, etc.)
-        """
+        """Check if a path is safe to access."""
         try:
-            # Resolve to absolute path, following symlinks
             resolved = path.resolve()
 
             # Check if it's a system directory
             system_dirs = ["/etc", "/usr", "/bin", "/sbin", "/lib", "/sys", "/dev", "/proc"]
             if any(str(resolved).startswith(sys_dir) for sys_dir in system_dirs):
                 return False
 
-            # If base_path is set, ensure path is within it
-            if self.base_path:
-                return resolved.is_relative_to(self.base_path)
+            # If no base path is configured, allow absolute paths that aren't system dirs
+            if not self.base_path:
+                return True
 
-            # In unconfigured mode, apply additional restrictions
-            # Only allow paths under /home or custom project directories
-            safe_roots = ["/home", "/projects", "/repo"]
-            return any(str(resolved).startswith(root) for root in safe_roots)
+            # If base path is configured, ensure path is within base directory
+            return resolved.is_relative_to(self.base_path)
 
         except (RuntimeError, OSError):
             # RuntimeError can occur with circular symlinks
@@ -126,9 +116,12 @@ class git_create_branch(GitPathModel):
     branch_name: str
     base_branch: str | None = None
 
-class git_checkout(GitPathModel):
+class GitCheckoutModel(GitPathModel):
     branch_name: str
 
+# Alias for backward compatibility with tool registration
+git_checkout_model = GitCheckoutModel
+
 class git_show(GitPathModel):
     revision: str
 
@@ -145,7 +138,7 @@ class GitTools(str, Enum):
     RESET = "git_reset"
     LOG = "git_log"
     CREATE_BRANCH = "git_create_branch"
-    CHECKOUT = "git_checkout"
+    CHECKOUT = "git_checkout_model"  # Updated to use new model name
     SHOW = "git_show"
     INIT = "git_init"
 
@@ -174,6 +167,15 @@ def resolve_repo_path(self, repo_path: str | Path) -> Path:
         """Resolve repository path, handling both absolute and relative paths.
         
         In Docker environment, relative paths are resolved against base_path.
+        
+        Args:
+            repo_path: Path to resolve (absolute or relative)
+            
+        Returns:
+            Path: Resolved absolute path
+            
+        Raises:
+            ValueError: If base path is not configured for relative paths
         """
         path = Path(repo_path)
         if not path.is_absolute():
@@ -194,9 +196,9 @@ def get_repo(self, repo_path: str) -> git.Repo:
         Raises:
             ValueError: If the path is invalid or not a Git repository
         """
-        resolved_path = self.resolve_repo_path(repo_path)
-        validated_path = self.path_validator.validate_path(resolved_path)
         try:
+            resolved_path = self.resolve_repo_path(repo_path)
+            validated_path = self.path_validator.validate_path(resolved_path)
             repo = git.Repo(validated_path)
             # Additional check to ensure the repo root is within allowed scope
             repo_root = Path(repo.git_dir).parent.resolve()
@@ -207,6 +209,9 @@ def get_repo(self, repo_path: str) -> git.Repo:
             raise ValueError(f"{validated_path} is not a Git repository")
         except git.NoSuchPathError:
             raise ValueError(f"Path {validated_path} does not exist")
+        except ValueError as e:
+            # Re-raise ValueError with the original message
+            raise ValueError(str(e))
 
     def git_status(self, repo: git.Repo) -> str:
         return repo.git.status()
@@ -249,21 +254,37 @@ def git_log(self, repo: git.Repo, max_count: int = 10) -> list[str]:
         return log
 
     def git_create_branch(self, repo: git.Repo, branch_name: str, base_branch: str | None = None) -> str:
-        if base_branch:
-            try:
-                # Try to get the ref (branch)
-                base = repo.refs[base_branch]
-            except KeyError:
-                # If it's not a ref, try to get the commit
+        """Create a new branch in the repository.
+        
+        Args:
+            repo: The Git repository
+            branch_name: Name of the new branch
+            base_branch: Base branch or commit to create from (optional)
+            
+        Returns:
+            A confirmation message
+            
+        Raises:
+            ValueError: If the base branch or commit is invalid
+        """
+        try:
+            if base_branch:
                 try:
-                    base = repo.commit(base_branch)
-                except git.BadName:
-                    raise ValueError(f"Invalid base branch or commit: {base_branch}")
-        else:
-            base = repo.active_branch
-
-        repo.create_head(branch_name, base)
-        return f"Created branch '{branch_name}' from '{base.name if hasattr(base, 'name') else base.hexsha}'"
+                    # Try to get the ref (branch)
+                    base = repo.refs[base_branch]
+                except (IndexError, AttributeError):
+                    # If it's not a ref, try to get the commit
+                    try:
+                        base = repo.commit(base_branch)
+                    except (git.BadName, ValueError):
+                        raise ValueError(f"Invalid base branch or commit: {base_branch}")
+            else:
+                base = repo.active_branch
+
+            new_branch = repo.create_head(branch_name, base)
+            return f"Created branch '{branch_name}' from '{base.name if hasattr(base, 'name') else base.hexsha}'"
+        except git.GitCommandError as e:
+            raise ValueError(f"Failed to create branch: {str(e)}")
 
     def git_checkout(self, repo: git.Repo, branch_name: str) -> str:
         """
@@ -277,10 +298,12 @@ def git_checkout(self, repo: git.Repo, branch_name: str) -> str:
             A confirmation message
         
         Raises:
-            git.GitCommandError: If the branch doesn't exist or other Git errors occur
+            ValueError: If the branch doesn't exist or other Git errors occur
         """
-        repo.git.checkout(branch_name)
-        return f"Switched to branch '{branch_name}'"
+        try:
+            return git_checkout(repo, branch_name)
+        except git.GitCommandError as e:
+            raise ValueError(f"Failed to checkout branch: {str(e)}")
 
     def git_init(self, repo_path: str) -> str:
         try: