"""

def __init__(self,

token: Optional[str] = None,

use_docker: bool = True,

github_host: Optional[str] = None):

"""

# Get token from parameter or environment

self.token = token or os.getenv("GITHUB_TOKEN") or os.getenv("GITHUB_PERSONAL_ACCESS_TOKEN")

if not self.token:

raise ValueError(

"GitHub token required. Set GITHUB_TOKEN or GITHUB_PERSONAL_ACCESS_TOKEN environment variable."

)

self.use_docker = use_docker

self.github_host = github_host

# Initialize base provider

super().__init__()

def _create_config(self) -> ServerConfig:

"""Create GitHub MCP server configuration."""

if self.use_docker:

# Docker configuration

args = ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN"]

env = {"GITHUB_PERSONAL_ACCESS_TOKEN": self.token}

if self.github_host:

args.extend(["-e", "GITHUB_HOST"])

env["GITHUB_HOST"] = self.github_host

args.append("ghcr.io/github/github-mcp-server")

return ServerConfig(command="docker", args=args, env=env)

else:

# NPX configuration with auto-installation

env = {"GITHUB_PERSONAL_ACCESS_TOKEN": self.token}

if self.github_host:

env["GITHUB_HOST"] = self.github_host

# Use shared utility for robust npm/npx handling

return self._create_npm_server_config(

package_name="@github/github-mcp-server",

args=[],

env=env,

use_npx=True, # GitHub server works best with NPX

require_node=True

)

def _get_provider_name(self) -> str:

"""Get provider name."""

return "github"

# User Operations

async def get_authenticated_user(self) -> Dict[str, Any]:

"""

return await self._call_tool("get_me", {})

async def get_user(self, username: str) -> Dict[str, Any]:

"""

return await self._call_tool("get_user", {"username": username})

# Repository Operations

async def search_repositories(self,

query: str,

sort: str = "updated",

order: str = "desc",

per_page: int = 30,

page: int = 1) -> Dict[str, Any]:

"""

return await self._call_tool("search_repositories", {

"query": query,

"sort": sort,

"order": order,

"per_page": min(per_page, 100), # GitHub API limit

"page": page

})

async def get_file_contents(self,

owner: str,

repo: str,

path: str,

ref: Optional[str] = None) -> Dict[str, Any]:

"""

params = {"owner": owner, "repo": repo, "path": path}

if ref:

params["ref"] = ref

return await self._call_tool("get_file_contents", params)

async def create_repository(self,

name: str,

description: str = "",

private: bool = False,

has_issues: bool = True,

has_projects: bool = True,

has_wiki: bool = True) -> Dict[str, Any]:

"""

return await self._call_tool("create_repository", {

"name": name,

"description": description,

"private": private,

"has_issues": has_issues,

"has_projects": has_projects,

"has_wiki": has_wiki

})

async def create_or_update_file(self,

owner: str,

repo: str,

path: str,

content: str,

message: str,

sha: Optional[str] = None,

branch: Optional[str] = None) -> Dict[str, Any]:

"""

params = {

"owner": owner,

"repo": repo,

"path": path,

"content": content,

"message": message

}

if sha:

params["sha"] = sha

if branch:

params["branch"] = branch

return await self._call_tool("create_or_update_file", params)

async def fork_repository(self, owner: str, repo: str) -> Dict[str, Any]:

"""

return await self._call_tool("fork_repository", {"owner": owner, "repo": repo})

async def list_branches(self, owner: str, repo: str) -> List[Dict[str, Any]]:

"""

result = await self._call_tool("list_branches", {"owner": owner, "repo": repo})

return result if isinstance(result, list) else []

async def create_branch(self,

owner: str,

repo: str,

branch: str,

from_branch: str = "main") -> Dict[str, Any]:

"""

return await self._call_tool("create_branch", {

"owner": owner,

"repo": repo,

"branch": branch,

"from_branch": from_branch

})

async def list_commits(self,

owner: str,

repo: str,

sha: Optional[str] = None,

path: Optional[str] = None,

since: Optional[str] = None,

until: Optional[str] = None) -> List[Dict[str, Any]]:

"""

params = {"owner": owner, "repo": repo}

if sha:

params["sha"] = sha

if path:

params["path"] = path

if since:

params["since"] = since

if until:

params["until"] = until

result = await self._call_tool("list_commits", params)

return result if isinstance(result, list) else []

async def get_commit(self, owner: str, repo: str, sha: str) -> Dict[str, Any]:

"""

return await self._call_tool("get_commit", {

"owner": owner,

"repo": repo,

"sha": sha

})

async def search_code(self,

query: str,

sort: str = "indexed",

order: str = "desc",

per_page: int = 30,

page: int = 1) -> Dict[str, Any]:

"""

return await self._call_tool("search_code", {

"query": query,

"sort": sort,

"order": order,

"per_page": min(per_page, 100),

"page": page

})

async def push_files(self,

owner: str,

repo: str,

files: List[Dict[str, str]],

message: str,

branch: str = "main") -> Dict[str, Any]:

"""

return await self._call_tool("push_files", {

"owner": owner,

"repo": repo,

"files": files,

"message": message,

"branch": branch

})

# Issue Operations

async def list_issues(self,

owner: str,

repo: str,

state: str = "open",

labels: Optional[List[str]] = None,

sort: str = "created",

direction: str = "desc") -> List[Dict[str, Any]]:

"""

params = {

"owner": owner,

"repo": repo,

"state": state,

"sort": sort,

"direction": direction

}

if labels:

params["labels"] = ",".join(labels)

result = await self._call_tool("list_issues", params)

return result if isinstance(result, list) else []

async def get_issue(self, owner: str, repo: str, issue_number: int) -> Dict[str, Any]:

"""

return await self._call_tool("get_issue", {

"owner": owner,

"repo": repo,

"issue_number": issue_number

})

async def create_issue(self,

owner: str,

repo: str,

title: str,

body: str = "",

labels: Optional[List[str]] = None,

assignees: Optional[List[str]] = None) -> Dict[str, Any]:

"""

params = {

"owner": owner,

"repo": repo,

"title": title,

"body": body

}

if labels:

params["labels"] = labels

if assignees:

params["assignees"] = assignees

return await self._call_tool("create_issue", params)

async def update_issue(self,

owner: str,

repo: str,

issue_number: int,

title: Optional[str] = None,

body: Optional[str] = None,

state: Optional[str] = None,

labels: Optional[List[str]] = None) -> Dict[str, Any]:

"""

params = {

"owner": owner,

"repo": repo,

"issue_number": issue_number

}

if title is not None:

params["title"] = title

if body is not None:

params["body"] = body

if state is not None:

params["state"] = state

if labels is not None:

params["labels"] = labels

return await self._call_tool("update_issue", params)

async def add_issue_comment(self,

owner: str,

repo: str,

issue_number: int,

body: str) -> Dict[str, Any]:

"""

return await self._call_tool("add_issue_comment", {

"owner": owner,

"repo": repo,

"issue_number": issue_number,

"body": body

})

async def get_issue_comments(self,

owner: str,

repo: str,

issue_number: int) -> List[Dict[str, Any]]:

"""

result = await self._call_tool("get_issue_comments", {

"owner": owner,

"repo": repo,

"issue_number": issue_number

})

return result if isinstance(result, list) else []

async def search_issues(self,

query: str,

sort: str = "created",

order: str = "desc",

per_page: int = 30,

page: int = 1) -> Dict[str, Any]:

"""

return await self._call_tool("search_issues", {

"query": query,

"sort": sort,

"order": order,

"per_page": min(per_page, 100),

"page": page

})

# Pull Request Operations

async def list_pull_requests(self,

owner: str,

repo: str,

state: str = "open",

head: Optional[str] = None,

base: Optional[str] = None) -> List[Dict[str, Any]]:

"""

params = {"owner": owner, "repo": repo, "state": state}

if head:

params["head"] = head

if base:

params["base"] = base

result = await self._call_tool("list_pull_requests", params)

return result if isinstance(result, list) else []

async def create_pull_request(self,

owner: str,

repo: str,

title: str,

head: str,

base: str,

body: str = "",

draft: bool = False) -> Dict[str, Any]:

"""

return await self._call_tool("create_pull_request", {

"owner": owner,

"repo": repo,

"title": title,

"head": head,

"base": base,

"body": body,

"draft": draft

})

async def get_pull_request(self, owner: str, repo: str, pull_number: int) -> Dict[str, Any]:

"""

return await self._call_tool("get_pull_request", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})

async def update_pull_request(self,

owner: str,

repo: str,

pull_number: int,

title: Optional[str] = None,

body: Optional[str] = None,

state: Optional[str] = None,

base: Optional[str] = None) -> Dict[str, Any]:

"""

params = {

"owner": owner,

"repo": repo,

"pull_number": pull_number

}

if title is not None:

params["title"] = title

if body is not None:

params["body"] = body

if state is not None:

params["state"] = state

if base is not None:

params["base"] = base

return await self._call_tool("update_pull_request", params)

async def merge_pull_request(self,

owner: str,

repo: str,

pull_number: int,

commit_title: Optional[str] = None,

commit_message: Optional[str] = None,

merge_method: str = "merge") -> Dict[str, Any]:

"""

params = {

"owner": owner,

"repo": repo,

"pull_number": pull_number,

"merge_method": merge_method

}

if commit_title:

params["commit_title"] = commit_title

if commit_message:

params["commit_message"] = commit_message

return await self._call_tool("merge_pull_request", params)

async def get_pull_request_files(self, owner: str, repo: str, pull_number: int) -> List[Dict[str, Any]]:

"""

result = await self._call_tool("get_pull_request_files", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})

return result if isinstance(result, list) else []

async def get_pull_request_status(self, owner: str, repo: str, pull_number: int) -> Dict[str, Any]:

"""

return await self._call_tool("get_pull_request_status", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})

async def update_pull_request_branch(self, owner: str, repo: str, pull_number: int) -> Dict[str, Any]:

"""

return await self._call_tool("update_pull_request_branch", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})

async def get_pull_request_comments(self, owner: str, repo: str, pull_number: int) -> List[Dict[str, Any]]:

"""

result = await self._call_tool("get_pull_request_comments", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})

return result if isinstance(result, list) else []

async def add_pull_request_review_comment(self,

owner: str,

repo: str,

pull_number: int,

body: str,

commit_sha: str,

path: str,

line: int) -> Dict[str, Any]:

"""

return await self._call_tool("add_pull_request_review_comment", {

"owner": owner,

"repo": repo,

"pull_number": pull_number,

"body": body,

"commit_sha": commit_sha,

"path": path,

"line": line

})

async def get_pull_request_reviews(self, owner: str, repo: str, pull_number: int) -> List[Dict[str, Any]]:

"""

result = await self._call_tool("get_pull_request_reviews", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})

return result if isinstance(result, list) else []

async def create_pull_request_review(self,

owner: str,

repo: str,

pull_number: int,

body: str = "",

event: str = "COMMENT",

comments: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:

"""

params = {

"owner": owner,

"repo": repo,

"pull_number": pull_number,

"body": body,

"event": event

}

if comments:

params["comments"] = comments

return await self._call_tool("create_pull_request_review", params)

async def request_copilot_review(self, owner: str, repo: str, pull_number: int) -> Dict[str, Any]:

"""

return await self._call_tool("request_copilot_review", {

"owner": owner,

"repo": repo,

"pull_number": pull_number

})