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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github-agent
-Version: 0.2.46
+Version: 0.2.54
 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.54*
 
 ## Overview
 

{github_agent-0.2.46 → github_agent-0.2.54}/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.54*
 
 ## Overview
 

github_agent-0.2.54/github_agent/agent_data/A2A_AGENTS.md

@@ -0,0 +1,12 @@
+# AGENTS.md - Known A2A Peer Agents
+Last updated: 2026-02-21 01:19
+
+This file is the local registry of other A2A agents this agent can discover and call.
+
+## Registered A2A Peers
+
+| Name | Endpoint URL | Description | Capabilities | Auth | Notes / Last Connected |
+|------|--------------|-------------|--------------|------|------------------------|
+|      |              |             |              |      |                        |
+
+*Add new rows manually or let the agent call `register_a2a_peer(...)`.*

{github_agent-0.2.46 → github_agent-0.2.54}/github_agent/agent_data/IDENTITY.md

@@ -18,9 +18,9 @@ You have three primary operational modes:
 
 #### 1. Context-Aware Delegation
 When dealing with complex Github workflows, optimize your context by spawning specialized versions of yourself:
-- **PR Review**: Call `spawn_agent(agent_template="github", prompt="Review and summarize PR #456...", enabled_tools=["PULL_REQUESTSTOOL", "REPOSTOOL"])`.
-- **Issue Management**: Call `spawn_agent(agent_template="github", prompt="Triage and label new issues with 'bug'...", enabled_tools=["ISSUESTOOL"])`.
-- **Discovery**: Always use `get_mcp_reference(agent_template="github")` to verify available tool tags before spawning.
+- **PR Review**: Call `spawn_agent(agent_name="github", prompt="Review and summarize PR #456...", enabled_tools=["PULL_REQUESTSTOOL", "REPOSTOOL"])`.
+- **Issue Management**: Call `spawn_agent(agent_name="github", prompt="Triage and label new issues with 'bug'...", enabled_tools=["ISSUESTOOL"])`.
+- **Discovery**: Always use `get_mcp_reference(agent_name="github")` to verify available tool tags before spawning.
 
 #### 2. Workflow for Meta-Tasks
 - **Memory Management**:

github_agent-0.2.54/github_agent/agent_data/MCP_AGENTS.md

@@ -0,0 +1,21 @@
+# MCP_AGENTS.md - Dynamic Agent Registry
+
+This file tracks the generated agents from MCP servers. You can manually modify the 'Tools' list to customize agent expertise.
+
+## Agent Mapping Table
+
+| Name | Description | System Prompt | Tools | Tag | Source MCP |
+|------|-------------|---------------|-------|-----|------------|
+| Github Contents Specialist | Expert specialist for contents domain tasks. | You are a Github Contents specialist. Help users manage and interact with Contents functionality using the available tools. | github-mcp_contents_toolset | contents | github-mcp |
+| Github Issue Specialist | Expert specialist for issue domain tasks. | You are a Github Issue specialist. Help users manage and interact with Issue functionality using the available tools. | github-mcp_issue_toolset | issue | github-mcp |
+| Github Pulls Specialist | Expert specialist for pulls domain tasks. | You are a Github Pulls specialist. Help users manage and interact with Pulls functionality using the available tools. | github-mcp_pulls_toolset | pulls | github-mcp |
+| Github Repos Specialist | Expert specialist for repos domain tasks. | You are a Github Repos specialist. Help users manage and interact with Repos functionality using the available tools. | github-mcp_repos_toolset | repos | github-mcp |
+
+## Tool Inventory Table
+
+| Tool Name | Description | Tag | Source |
+|-----------|-------------|-----|--------|
+| github-mcp_contents_toolset | Static hint toolset for contents based on config env. | contents | github-mcp |
+| github-mcp_issue_toolset | Static hint toolset for issue based on config env. | issue | github-mcp |
+| github-mcp_pulls_toolset | Static hint toolset for pulls based on config env. | pulls | github-mcp |
+| github-mcp_repos_toolset | Static hint toolset for repos based on config env. | repos | github-mcp |

github_agent-0.2.54/github_agent/agent_data/mcp_config.json

@@ -0,0 +1,18 @@
+{
+  "mcpServers": {
+    "github-mcp": {
+      "command": "github-mcp",
+      "args": [
+        "--transport",
+        "stdio"
+      ],
+      "env": {
+        "GITHUB_TOKEN": "${GITHUB_TOKEN}",
+        "CONTENTSTOOL": "${ CONTENTSTOOL:-True }",
+        "ISSUETOOL": "${ ISSUETOOL:-True }",
+        "PULLSTOOL": "${ PULLSTOOL:-True }",
+        "REPOSTOOL": "${ REPOSTOOL:-True }"
+      }
+    }
+  }
+}

{github_agent-0.2.46 → github_agent-0.2.54}/github_agent/agent_data/templates.py

@@ -2,7 +2,6 @@ import asyncio
 from typing import Dict
 from github_agent.models import PeriodicTask
 
-# Core files we care about most
 CORE_FILES = {
     "IDENTITY": "IDENTITY.md",
     "USER": "USER.md",
@@ -13,11 +12,11 @@ CORE_FILES = {
     "MCP_CONFIG": "mcp_config.json",
 }
 
-# ============== IN-MEMORY PERIODIC SCHEDULER STATE ==============
+
 tasks: list[PeriodicTask] = []
 lock = asyncio.Lock()
 
-# Templates for workspace initialization
+
 TEMPLATES: Dict[str, str] = {
     "IDENTITY": """# IDENTITY.md - Who I Am, Core Personality, & Boundaries
 
@@ -66,9 +65,9 @@ This file is the local registry of other A2A agents this agent can discover and
 
 ## Registered A2A Peers
 
-| Name            | Endpoint URL                    | Description                          | Capabilities                     | Auth      | Notes / Last Connected |
-|-----------------|---------------------------------|--------------------------------------|----------------------------------|-----------|------------------------|
-| SearchMaster    | http://search-agent:9000/a2a    | Advanced web researcher              | web_search, summarize, browse    | none      | 2026-02-20             |
+| Name | Endpoint URL | Description | Capabilities | Auth | Notes / Last Connected |
+|------|--------------|-------------|--------------|------|------------------------|
+|      |              |             |              |      |                        |
 
 *Add new rows manually or let the agent call `register_a2a_peer(...)`.*
 """,

{github_agent-0.2.46 → github_agent-0.2.54}/github_agent/agent_server.py

@@ -1,17 +1,19 @@
 #!/usr/bin/python
 # coding: utf-8
 import os
+import sys
 import logging
+import warnings
 
 from agent_utilities import (
     build_system_prompt_from_workspace,
     create_agent_parser,
-    create_agent_server,
+    create_graph_agent_server,
     initialize_workspace,
     load_identity,
 )
 
-__version__ = "0.2.46"
+__version__ = "0.2.54"
 
 logging.basicConfig(
     level=logging.INFO,
@@ -20,13 +22,16 @@ logging.basicConfig(
 )
 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."),
+    meta.get(
+        "description",
+        "AI agent for GitHub Agent management.",
+    ),
 )
 DEFAULT_AGENT_SYSTEM_PROMPT = os.getenv(
     "AGENT_SYSTEM_PROMPT",
@@ -35,34 +40,38 @@ DEFAULT_AGENT_SYSTEM_PROMPT = os.getenv(
 
 
 def agent_server():
-    print(f"{DEFAULT_AGENT_NAME} v{__version__}")
-    parser = create_agent_parser()
+    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_agent_server(
+    # Start server using the auto-discovery pattern (from mcp_config.json)
+    create_graph_agent_server(
+        mcp_url=args.mcp_url,
+        mcp_config=args.mcp_config or "mcp_config.json",
+        host=args.host,
+        port=args.port,
         provider=args.provider,
         model_id=args.model_id,
+        router_model=args.model_id,
+        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,
-        host=args.host,
-        port=args.port,
         enable_web_ui=args.web,
-        ssl_verify=not args.insecure,
-        name=DEFAULT_AGENT_NAME,
-        system_prompt=DEFAULT_AGENT_SYSTEM_PROMPT,
         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,
     )
 
 

github_agent-0.2.54/github_agent/api_wrapper.py

@@ -0,0 +1,276 @@
+#!/usr/bin/python
+
+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:
+
+            logger.warning("No token provided for GitHub API")
+
+        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)}")
+
+    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
+
+        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:
+
+            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.54/github_agent/auth.py

@@ -0,0 +1,89 @@
+#!/usr/bin/python
+
+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