github-agent 0.2.46__tar.gz → 0.2.48__tar.gz

{github_agent-0.2.46 → github_agent-0.2.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github-agent
-Version: 0.2.46
+Version: 0.2.48
 Summary: GitHub Agent for MCP
 Author-email: Audel Rouhi <knucklessg1@gmail.com>
 License: MIT
@@ -38,7 +38,7 @@ Dynamic: license-file
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/github-agent)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/github-agent)
 
-*Version: 0.2.46*
+*Version: 0.2.48*
 
 ## Overview
 

{github_agent-0.2.46 → github_agent-0.2.48}/README.md

@@ -21,7 +21,7 @@
 ![PyPI - Wheel](https://img.shields.io/pypi/wheel/github-agent)
 ![PyPI - Implementation](https://img.shields.io/pypi/implementation/github-agent)
 
-*Version: 0.2.46*
+*Version: 0.2.48*
 
 ## Overview
 

github_agent-0.2.48/github_agent/agent_data/mcp_config.json

@@ -0,0 +1,10 @@
+{
+  "mcpServers": {
+    "github": {
+      "serverUrl": "https://api.githubcopilot.com/mcp/",
+      "headers": {
+        "Authorization": "Bearer ${GITHUB_TOKEN}"
+      }
+    }
+  }
+}

github_agent-0.2.48/github_agent/agent_server.py

@@ -0,0 +1,113 @@
+#!/usr/bin/python
+# coding: utf-8
+import os
+import logging
+
+import sys
+import warnings
+from agent_utilities import (
+    build_system_prompt_from_workspace,
+    create_agent_parser,
+    create_graph_agent_server,
+    initialize_workspace,
+    load_identity,
+)
+
+__version__ = "0.2.48"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+# Load identity and system prompt from workspace
+initialize_workspace()
+meta = load_identity()
+DEFAULT_AGENT_NAME = os.getenv("DEFAULT_AGENT_NAME", meta.get("name", "Github Agent"))
+DEFAULT_AGENT_DESCRIPTION = os.getenv(
+    "AGENT_DESCRIPTION",
+    meta.get("description", "AI agent for GitHub Agent management."),
+)
+DEFAULT_AGENT_SYSTEM_PROMPT = os.getenv(
+    "AGENT_SYSTEM_PROMPT",
+    meta.get("content") or build_system_prompt_from_workspace(),
+)
+
+
+def agent_template(mcp_url: str = None, mcp_config: str = None, **kwargs):
+    """Factory function returning the fully initialized graph for execution."""
+    from agent_utilities import create_graph_agent
+    from github_agent.graph_config import TAG_PROMPTS, TAG_ENV_VARS
+
+    # In-process MCP loading: if no external URL/Config, load the local FastMCP instance
+    mcp_toolsets = []
+    effective_mcp_url = mcp_url or os.getenv("MCP_URL")
+    effective_mcp_config = mcp_config or os.getenv("MCP_CONFIG")
+
+    if not effective_mcp_url and not effective_mcp_config:
+        try:
+            from github_agent.mcp_server import get_mcp_instance
+
+            mcp, _, _, _ = get_mcp_instance()
+            mcp_toolsets.append(mcp)
+            logger.info("Github Agent: Using in-process MCP instance.")
+        except (ImportError, Exception) as e:
+            logger.warning(f"Github Agent: Could not load in-process MCP: {e}")
+
+    return create_graph_agent(
+        mcp_url=effective_mcp_url,
+        mcp_config=effective_mcp_config or "",
+        mcp_toolsets=mcp_toolsets,
+        name=f"{DEFAULT_AGENT_NAME} Graph Agent",
+        tag_prompts=TAG_PROMPTS,
+        tag_env_vars=TAG_ENV_VARS,
+        **kwargs,
+    )
+
+
+def agent_server():
+
+    # Suppress RequestsDependencyWarning and FastMCP DeprecationWarnings
+    warnings.filterwarnings("ignore", message=".*urllib3.*or chardet.*")
+    warnings.filterwarnings("ignore", category=DeprecationWarning, module="fastmcp")
+
+    print(f"{DEFAULT_AGENT_NAME} v{__version__}", file=sys.stderr)
+    parser = create_agent_parser()
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+        logger.debug("Debug mode enabled")
+
+    # Create graph and config using standardized template
+    graph_bundle = agent_template(
+        provider=args.provider,
+        agent_model=args.model_id,
+        base_url=args.base_url,
+        api_key=args.api_key,
+        custom_skills_directory=args.custom_skills_directory,
+        debug=args.debug,
+        ssl_verify=not args.insecure,
+    )
+
+    # Start server using the pre-built graph bundle
+    create_graph_agent_server(
+        graph_bundle=graph_bundle,
+        host=args.host,
+        port=args.port,
+        enable_web_ui=args.web,
+        enable_otel=args.otel,
+        otel_endpoint=args.otel_endpoint,
+        otel_headers=args.otel_headers,
+        otel_public_key=args.otel_public_key,
+        otel_secret_key=args.otel_secret_key,
+        otel_protocol=args.otel_protocol,
+        debug=args.debug,
+    )
+
+
+if __name__ == "__main__":
+    agent_server()

github_agent-0.2.48/github_agent/api_wrapper.py

@@ -0,0 +1,278 @@
+#!/usr/bin/python
+# coding: utf-8
+import re
+import requests
+import urllib3
+import logging
+from typing import List, TypeVar, Tuple
+from pydantic import ValidationError
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from agent_utilities.base_utilities import get_logger
+
+logger = get_logger(__name__)
+
+from github_agent.github_input_models import (
+    RepoModel,
+    IssueModel,
+    PullRequestModel,
+    ContentModel,
+    BranchModel,
+    CommitModel,
+)
+from github_agent.github_response_models import (
+    Repository,
+    Issue,
+    PullRequest,
+    Content,
+    Branch,
+    Commit,
+    Response,
+)
+from agent_utilities.decorators import require_auth
+from agent_utilities.exceptions import (
+    AuthError,
+    UnauthorizedError,
+    ParameterError,
+    MissingParameterError,
+)
+
+T = TypeVar("T")
+
+
+class Api(object):
+
+    def __init__(
+        self,
+        url: str = "https://api.github.com",
+        token: str = None,
+        proxies: dict = None,
+        verify: bool = True,
+        debug: bool = False,
+    ):
+        if debug:
+            logger.setLevel(logging.DEBUG)
+        else:
+            logger.setLevel(logging.ERROR)
+
+        if url is None:
+            raise MissingParameterError
+
+        self._session = requests.Session()
+        self.url = url.rstrip("/")
+        self.headers = {
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+        self.verify = verify
+        self.proxies = proxies
+        self.debug = debug
+
+        if self.verify is False:
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+        if token:
+            self.headers["Authorization"] = f"Bearer {token}"
+        else:
+            # GitHub typically requires a token for most operations
+            logger.warning("No token provided for GitHub API")
+
+        # Basic health check / auth test
+        try:
+            response = self._session.get(
+                url=f"{self.url}/user",
+                headers=self.headers,
+                verify=self.verify,
+                proxies=self.proxies,
+            )
+            if response.status_code in (401, 403):
+                logger.error(f"Authentication Error: {response.content}")
+                raise AuthError if response.status_code == 401 else UnauthorizedError
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Connection Error: {str(e)}")
+            # Don't raise here, allow the client to be initialized but operations might fail
+
+    def _fetch_next_page(
+        self, endpoint: str, model: T, header: dict, page: int
+    ) -> List[dict]:
+        """Fetch a single page of data from the specified endpoint"""
+        model.page = page
+        model.model_post_init(None)
+        response = self._session.get(
+            url=f"{self.url}{endpoint}" if endpoint.startswith("/") else endpoint,
+            params=model.api_parameters,
+            headers=header,
+            verify=self.verify,
+            proxies=self.proxies,
+        )
+        response.raise_for_status()
+        page_data = response.json()
+        return page_data if isinstance(page_data, list) else []
+
+    def _get_total_pages(self, response: requests.Response) -> int:
+        """Extract total pages from GitHub Link header"""
+        link = response.headers.get("Link")
+        if not link:
+            return 1
+        # Example: <https://api.github.com/user/repos?page=2>; rel="next", <https://api.github.com/user/repos?page=10>; rel="last"
+        last_match = re.search(r'page=(\d+)>; rel="last"', link)
+        if last_match:
+            return int(last_match.group(1))
+        return 1
+
+    def _fetch_all_pages(
+        self, endpoint: str, model: T
+    ) -> Tuple[requests.Response, List[dict]]:
+        """Generic method to fetch all pages with parallelization if possible"""
+        all_data = []
+
+        initial_url = f"{self.url}{endpoint}" if endpoint.startswith("/") else endpoint
+
+        response = self._session.get(
+            url=initial_url,
+            params=model.api_parameters,
+            headers=self.headers,
+            verify=self.verify,
+            proxies=self.proxies,
+        )
+        response.raise_for_status()
+        initial_data = response.json()
+
+        if isinstance(initial_data, list):
+            all_data.extend(initial_data)
+        else:
+            return response, [initial_data]
+
+        total_pages = self._get_total_pages(response)
+
+        if not model.max_pages or model.max_pages == 0 or model.max_pages > total_pages:
+            model.max_pages = total_pages
+
+        if model.max_pages > 1:
+            # Parallel fetching if more than 1 page
+            with ThreadPoolExecutor(max_workers=5) as executor:
+                futures = []
+                for page in range(2, model.max_pages + 1):
+                    futures.append(
+                        executor.submit(
+                            self._fetch_next_page,
+                            initial_url,
+                            model,
+                            self.headers,
+                            page,
+                        )
+                    )
+
+                for future in as_completed(futures):
+                    try:
+                        all_data.extend(future.result())
+                    except Exception as e:
+                        logger.error(f"Error fetching page: {str(e)}")
+
+        return response, all_data
+
+    @require_auth
+    def get_repositories(self, **kwargs) -> Response:
+        """List repositories for the authenticated user."""
+        model = RepoModel(**kwargs)
+        try:
+            response, data = self._fetch_all_pages("/user/repos", model)
+            parsed_data = [Repository(**item) for item in data]
+            return Response(response=response, data=parsed_data)
+        except ValidationError as e:
+            raise ParameterError(f"Invalid parameters: {e.errors()}")
+
+    @require_auth
+    def get_repository(self, owner: str, repo: str) -> Response:
+        """Get a specific repository."""
+        try:
+            response = self._session.get(
+                url=f"{self.url}/repos/{owner}/{repo}",
+                headers=self.headers,
+                verify=self.verify,
+                proxies=self.proxies,
+            )
+            response.raise_for_status()
+            parsed_data = Repository(**response.json())
+            return Response(response=response, data=parsed_data)
+        except requests.exceptions.HTTPError as e:
+            if e.response.status_code == 404:
+                raise ParameterError(f"Repository {owner}/{repo} not found")
+            raise e
+
+    @require_auth
+    def get_issues(self, **kwargs) -> Response:
+        """List issues for a repository."""
+        model = IssueModel(**kwargs)
+        if not model.owner or not model.repo:
+            raise MissingParameterError("owner and repo are required")
+        try:
+            response, data = self._fetch_all_pages(
+                f"/repos/{model.owner}/{model.repo}/issues", model
+            )
+            parsed_data = [Issue(**item) for item in data]
+            return Response(response=response, data=parsed_data)
+        except ValidationError as e:
+            raise ParameterError(f"Invalid parameters: {e.errors()}")
+
+    @require_auth
+    def get_pull_requests(self, **kwargs) -> Response:
+        """List pull requests for a repository."""
+        model = PullRequestModel(**kwargs)
+        if not model.owner or not model.repo:
+            raise MissingParameterError("owner and repo are required")
+        try:
+            response, data = self._fetch_all_pages(
+                f"/repos/{model.owner}/{model.repo}/pulls", model
+            )
+            parsed_data = [PullRequest(**item) for item in data]
+            return Response(response=response, data=parsed_data)
+        except ValidationError as e:
+            raise ParameterError(f"Invalid parameters: {e.errors()}")
+
+    @require_auth
+    def get_contents(self, **kwargs) -> Response:
+        """Get contents of a file or directory in a repository."""
+        model = ContentModel(**kwargs)
+        try:
+            response = self._session.get(
+                url=f"{self.url}/repos/{model.owner}/{model.repo}/contents/{model.path}",
+                params=model.api_parameters,
+                headers=self.headers,
+                verify=self.verify,
+                proxies=self.proxies,
+            )
+            response.raise_for_status()
+            data = response.json()
+            if isinstance(data, list):
+                parsed_data = [Content(**item) for item in data]
+            else:
+                parsed_data = Content(**data)
+            return Response(response=response, data=parsed_data)
+        except ValidationError as e:
+            raise ParameterError(f"Invalid parameters: {e.errors()}")
+
+    @require_auth
+    def get_branches(self, **kwargs) -> Response:
+        """List branches for a repository."""
+        model = BranchModel(**kwargs)
+        try:
+            response, data = self._fetch_all_pages(
+                f"/repos/{model.owner}/{model.repo}/branches", model
+            )
+            parsed_data = [Branch(**item) for item in data]
+            return Response(response=response, data=parsed_data)
+        except ValidationError as e:
+            raise ParameterError(f"Invalid parameters: {e.errors()}")
+
+    @require_auth
+    def get_commits(self, **kwargs) -> Response:
+        """List commits for a repository."""
+        model = CommitModel(**kwargs)
+        try:
+            response, data = self._fetch_all_pages(
+                f"/repos/{model.owner}/{model.repo}/commits", model
+            )
+            parsed_data = [Commit(**item) for item in data]
+            return Response(response=response, data=parsed_data)
+        except ValidationError as e:
+            raise ParameterError(f"Invalid parameters: {e.errors()}")

github_agent-0.2.48/github_agent/auth.py

@@ -0,0 +1,89 @@
+#!/usr/bin/python
+# coding: utf-8
+import os
+import threading
+from typing import Optional
+
+import requests
+from agent_utilities.base_utilities import to_boolean, get_logger
+from github_agent.api_wrapper import Api
+from agent_utilities.exceptions import AuthError, UnauthorizedError
+
+local = threading.local()
+logger = get_logger(__name__)
+
+
+def get_client(
+    instance: str = os.getenv("GITHUB_URL", "https://api.github.com"),
+    token: Optional[str] = os.getenv("GITHUB_TOKEN", None),
+    verify: bool = to_boolean(string=os.getenv("GITHUB_VERIFY", "True")),
+    config: Optional[dict] = None,
+) -> Api:
+    """
+    Factory function to create the GitHub Api client.
+    Supports fixed credentials (token) and delegation (OAuth exchange).
+    """
+    if config is None:
+        from agent_utilities.mcp_utilities import config as default_config
+
+        config = default_config
+
+    if config.get("enable_delegation"):
+        user_token = getattr(local, "user_token", None)
+        if not user_token:
+            logger.error("No user token available for delegation")
+            raise ValueError("No user token available for delegation")
+
+        logger.info(
+            "Initiating OAuth token exchange for GitHub",
+            extra={
+                "audience": config["audience"],
+                "scopes": config["delegated_scopes"],
+            },
+        )
+
+        exchange_data = {
+            "grant_type": "urn:ietf:params:oauth:grant-type:token-exchange",
+            "subject_token": user_token,
+            "subject_token_type": "urn:ietf:params:oauth:token-type:access_token",
+            "requested_token_type": "urn:ietf:params:oauth:token-type:access_token",
+            "audience": config["audience"],
+            "scope": config["delegated_scopes"],
+        }
+        auth = (config["oidc_client_id"], config["oidc_client_secret"])
+        try:
+            response = requests.post(
+                config["token_endpoint"], data=exchange_data, auth=auth
+            )
+            response.raise_for_status()
+            new_token = response.json()["access_token"]
+            logger.info("Token exchange successful")
+        except Exception as e:
+            logger.error(f"Token exchange failed: {str(e)}")
+            raise RuntimeError(f"Token exchange failed: {str(e)}")
+
+        try:
+            return Api(
+                url=instance,
+                token=new_token,
+                verify=verify,
+            )
+        except (AuthError, UnauthorizedError) as e:
+            raise RuntimeError(
+                f"AUTHENTICATION ERROR: The delegated GitHub credentials are not valid for '{instance}'."
+                f"Error details: {str(e)}"
+            ) from e
+    else:
+        logger.info("Using fixed credentials for GitHub API")
+        try:
+            return Api(
+                url=instance,
+                token=token,
+                verify=verify,
+            )
+        except (AuthError, UnauthorizedError) as e:
+            raise RuntimeError(
+                f"AUTHENTICATION ERROR: The GitHub credentials provided are not valid for '{instance}'. "
+                f"Please check your GITHUB_TOKEN and GITHUB_URL environment variables. "
+                f"Error details: {str(e)}"
+            ) from e