Fix pyright failures

Author: olaservo

src/git/src/mcp_server_git/server.py

@@ -219,6 +219,10 @@ def get_repo(self, repo_path: str) -> git.Repo:
         """
         if not self.base_path:
             raise ValueError("No base repository path configured")
+        
+        # Initialize resolved_path to ensure it's always bound for exception handlers
+        resolved_path = Path(repo_path)
+        
         try:
             resolved_path = self.resolve_repo_path(repo_path)
             validated_path = self.path_validator.validate_path(resolved_path)
@@ -229,9 +233,9 @@ def get_repo(self, repo_path: str) -> git.Repo:
                 raise ValueError(f"Repository root {repo_root} not in allowed scope")
             return repo
         except git.InvalidGitRepositoryError:
-            raise ValueError(f"{validated_path} is not a Git repository")
+            raise ValueError(f"{resolved_path} is not a Git repository")
         except git.NoSuchPathError:
-            raise ValueError(f"Path {validated_path} does not exist")
+            raise ValueError(f"Path {resolved_path} does not exist")
         except ValueError as e:
             # Re-raise ValueError with the original message
             raise ValueError(str(e))
@@ -295,17 +299,20 @@ def git_create_branch(self, repo: git.Repo, branch_name: str, base_branch: str |
                 try:
                     # Try to get the ref (branch)
                     base = repo.refs[base_branch]
+                    new_branch = repo.create_head(branch_name, base)
+                    return f"Created branch '{branch_name}' from '{base.name}'"
                 except (IndexError, AttributeError):
                     # If it's not a ref, try to get the commit
                     try:
-                        base = repo.commit(base_branch)
+                        commit = repo.commit(base_branch)
+                        new_branch = repo.create_head(branch_name, commit.hexsha)
+                        return f"Created branch '{branch_name}' from '{commit.hexsha}'"
                     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}'"
+                new_branch = repo.create_head(branch_name, base)
+                return f"Created branch '{branch_name}' from '{base.name}'"
         except git.GitCommandError as e:
             raise ValueError(f"Failed to create branch: {str(e)}")
 
@@ -437,7 +444,7 @@ async def list_tools() -> list[Tool]:
             if repository:
                 # In single-repo mode with a parent directory,
                 # we still need repo_path but restrict it to subdirectories
-                if not git.repo.fun.is_git_dir(repository / ".git"):
+                if not (repository / ".git").exists():
                     schema["properties"]["repo_path"]["description"] = "Path to Git repository (must be under the configured base directory)"
                 else:
                     # If repository itself is a Git repo, remove repo_path as before
@@ -483,7 +490,7 @@ def by_commandline() -> Sequence[str]:
     async def call_tool(name: str, arguments: dict) -> list[TextContent]:
         try:
             # Auto-use configured repository only if it's actually a Git repository
-            if repository and git.repo.fun.is_git_dir(repository / ".git"):
+            if repository and (repository / ".git").exists():
                 arguments = arguments.copy()
                 arguments["repo_path"] = str(repository)
             elif repository:

src/git/tests/test_server.py

@@ -50,47 +50,27 @@ def test_path_validator_accepts_inside_path(git_server_with_repo, test_repositor
 
 @pytest.mark.asyncio
 async def test_call_tool_uses_configured_repo(test_repository):
-    # Create a server with configured repository
-    server = Server("test-git")
+    # Create a git_server with configured repository
     git_server = GitServer(test_repository.working_dir)
 
     # Create a change in the working directory
     test_file = Path(test_repository.working_dir) / "test.txt"
     test_file.write_text("modified content")
 
-    # Mock the call_tool method to use our git_server
-    async def mock_call_tool(name: str, arguments: dict) -> list[TextContent]:
-        if name == "git_status":
-            try:
-                status = git_server.git_status(git_server.get_repo(arguments["repo_path"]))
-                return [TextContent(
-                    type="text",
-                    text=f"Repository status:\n{status}"
-                )]
-            except ValueError as e:
-                # We expect this error when trying to use a different path
-                if "not in allowed scope" in str(e):
-                    # Use the configured repository instead
-                    status = git_server.git_status(git_server.get_repo(test_repository.working_dir))
-                    return [TextContent(
-                        type="text",
-                        text=f"Repository status:\n{status}"
-                    )]
-                raise
-        return []
+    # Test that the git_server correctly handles the configured repository
+    try:
+        # This should fail because the path is outside the allowed scope
+        git_server.get_repo("/some/other/path")
+        assert False, "Expected ValueError for out-of-scope path"
+    except ValueError as e:
+        assert "not in allowed scope" in str(e)
 
-    server.call_tool = mock_call_tool
+    # This should work because it's the configured repository
+    repo = git_server.get_repo(test_repository.working_dir)
+    status = git_server.git_status(repo)
 
-    # Try to use a different repo_path in arguments
-    different_path = "/some/other/path"
-    result = await server.call_tool("git_status", {"repo_path": different_path})
-    
-    # Verify the configured repository was used instead
-    assert isinstance(result, list)
-    assert len(result) == 1
-    assert isinstance(result[0], TextContent)
-    assert "Repository status" in result[0].text
-    assert "test.txt" in result[0].text  # Our test file from the fixture
+    # Verify the configured repository was used
+    assert "test.txt" in status  # Our test file from the fixture
 
 def test_git_server_requires_base_path_for_operations(git_server_without_repo):
     with pytest.raises(ValueError, match="No base repository path configured"):