github-agent 1.4.2__py3-none-any.whl → 2.3.0__py3-none-any.whl

github_agent/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "2.3.0"

github_agent/__main__.py

@@ -1,4 +1,4 @@
-from github_agent.agent_server import agent_server
+from github_agent.mcp_server import mcp_server
 
 if __name__ == "__main__":
-    agent_server()
+    mcp_server()

github_agent/api/api_client_base.py

@@ -7,17 +7,20 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import TypeVar
 
 import requests
-import urllib3
-from agent_utilities.base_utilities import get_logger
-from agent_utilities.exceptions import (
+from agent_connector_sdk.exceptions import (
     AuthError,
     MissingParameterError,
     UnauthorizedError,
 )
+from agent_connector_sdk.tls.profile import ResolvedTLSProfile
+from agent_connector_sdk.tls.resolve import resolve_tls_profile
+from agent_connector_sdk.utilities import get_logger
 from pydantic import BaseModel
 
 logger = get_logger(__name__)
 T = TypeVar("T", bound=BaseModel)
+_VerifyValue = bool | str
+_MANDATORY_VERIFY: _VerifyValue = True
 
 
 def _default_timeout() -> tuple[float, float]:
@@ -50,10 +53,12 @@ class _TimeoutAdapter(requests.adapters.HTTPAdapter):
         request: requests.PreparedRequest,
         stream: bool = False,
         timeout: None | float | tuple[float, float] | tuple[float, None] = None,
-        verify: bool | str = True,
+        verify: _VerifyValue = _MANDATORY_VERIFY,
         cert: None | bytes | str | tuple[bytes | str, bytes | str] = None,
         proxies: Mapping[str, str] | None = None,
     ) -> requests.Response:
+        if verify is False:
+            raise ValueError("transport certificate verification cannot be disabled")
         if timeout is None:
             timeout = self._timeout
         return super().send(
@@ -71,8 +76,7 @@ class BaseApiClient:
         self,
         url: str | None = "https://api.github.com",
         token: str | None = None,
-        proxies: dict | None = None,
-        verify: bool = True,
+        tls_profile: ResolvedTLSProfile | None = None,
         debug: bool = False,
     ):
         if debug:
@@ -83,7 +87,8 @@ class BaseApiClient:
         if url is None:
             raise MissingParameterError
 
-        self._session = requests.Session()
+        self.tls_profile = tls_profile or resolve_tls_profile("github")
+        self._session = self.tls_profile.configure_requests_session(requests.Session())
         _adapter = _TimeoutAdapter(_default_timeout())
         self._session.mount("https://", _adapter)
         self._session.mount("http://", _adapter)
@@ -92,13 +97,8 @@ class BaseApiClient:
             "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:
@@ -108,14 +108,17 @@ class BaseApiClient:
             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.text}")
+                logger.error("GitHub authentication was rejected")
                 raise AuthError if response.status_code == 401 else UnauthorizedError
         except requests.exceptions.RequestException as e:
-            logger.error(f"Connection Error: {str(e)}")
+            logger.error("Operation failed: error_type=%s", type(e).__name__)
+
+    def close(self) -> None:
+        """Release transport resources and runtime-only TLS material."""
+        self._session.close()
+        self.tls_profile.cleanup()
 
     def _fetch_next_page(
         self, endpoint: str, model: T, header: dict, page: int
@@ -127,8 +130,6 @@ class BaseApiClient:
             url=f"{self.url}{endpoint}" if endpoint.startswith("/") else endpoint,
             params=model.api_parameters,  # type: ignore[attr-defined]
             headers=header,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         page_data = response.json()
@@ -157,8 +158,6 @@ class BaseApiClient:
             url=initial_url,
             params=model.api_parameters,  # type: ignore[attr-defined]
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         initial_data = response.json()
@@ -199,6 +198,8 @@ class BaseApiClient:
                     try:
                         all_data.extend(future.result())
                     except Exception as e:
-                        logger.error(f"Error fetching page: {str(e)}")
+                        logger.error(
+                            "Operation failed: error_type=%s", type(e).__name__
+                        )
 
         return response, all_data

github_agent/api/api_client_branches.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
-from agent_utilities.decorators import require_auth
-from agent_utilities.exceptions import (
+from agent_connector_sdk.exceptions import (
     ParameterError,
+    require_auth,
 )
 from pydantic import ValidationError
 
@@ -38,8 +38,6 @@ class Api(BaseApiClient):
                 url=f"{self.url}/repos/{owner}/{repo}/git/refs",
                 json=payload,
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             return Response(response=response, data=response.json())
@@ -52,8 +50,6 @@ class Api(BaseApiClient):
         response = self._session.delete(
             url=f"{self.url}/repos/{owner}/{repo}/git/refs/heads/{branch}",
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data={"status": "deleted"})
@@ -64,8 +60,6 @@ class Api(BaseApiClient):
         response = self._session.get(
             url=f"{self.url}/repos/{owner}/{repo}/branches/{branch}",
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         try:
@@ -80,8 +74,6 @@ class Api(BaseApiClient):
         response = self._session.get(
             url=f"{self.url}/repos/{owner}/{repo}/branches/{branch}/protection",
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data=response.json())
@@ -95,8 +87,6 @@ class Api(BaseApiClient):
             url=f"{self.url}/repos/{owner}/{repo}/branches/{branch}/protection",
             json=protection_config,
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data=response.json())
@@ -107,8 +97,6 @@ class Api(BaseApiClient):
         response = self._session.delete(
             url=f"{self.url}/repos/{owner}/{repo}/branches/{branch}/protection",
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data={"status": "protection_deleted"})

github_agent/api/api_client_comments.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python
+from agent_connector_sdk.exceptions import require_auth
+
+from github_agent.api.api_client_base import BaseApiClient
+from github_agent.github_response_models import Response
+
+
+class Api(BaseApiClient):
+    # --- Issue / pull-request comments -----------------------------------
+    # A pull request IS an issue on GitHub, so these endpoints work for both.
+
+    @require_auth
+    def list_issue_comments(
+        self, owner: str, repo: str, issue_number: int, **filters
+    ) -> Response:
+        """List comments on an issue or pull request.
+
+        GET /repos/{owner}/{repo}/issues/{issue_number}/comments. Optional
+        filters passed straight through as query parameters (since, per_page,
+        page). A pull request IS an issue on GitHub, so this also lists a
+        PR's top-level (non-review) comments. Returns the raw JSON list of
+        comments in ``Response.data``.
+        """
+        params = {k: v for k, v in filters.items() if v is not None}
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/issues/{issue_number}/comments",
+            params=params or None,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def list_repo_issue_comments(self, owner: str, repo: str, **filters) -> Response:
+        """List every issue/PR comment in a repository.
+
+        GET /repos/{owner}/{repo}/issues/comments. Optional filters passed
+        straight through as query parameters (sort, direction, since,
+        per_page, page). Returns the raw JSON list of comments in
+        ``Response.data``.
+        """
+        params = {k: v for k, v in filters.items() if v is not None}
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/issues/comments",
+            params=params or None,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def get_issue_comment(self, owner: str, repo: str, comment_id: int) -> Response:
+        """Get a single issue/PR comment.
+
+        GET /repos/{owner}/{repo}/issues/comments/{comment_id}.
+        """
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/issues/comments/{comment_id}",
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def create_issue_comment(
+        self, owner: str, repo: str, issue_number: int, body: str
+    ) -> Response:
+        """Create a comment on an issue or pull request.
+
+        POST /repos/{owner}/{repo}/issues/{issue_number}/comments. A pull
+        request IS an issue on GitHub, so this is also how you reply to a PR
+        (a top-level comment — for an inline code review comment see
+        create_review_comment).
+        """
+        response = self._session.post(
+            url=f"{self.url}/repos/{owner}/{repo}/issues/{issue_number}/comments",
+            json={"body": body},
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def update_issue_comment(
+        self, owner: str, repo: str, comment_id: int, body: str
+    ) -> Response:
+        """Edit an issue/PR comment.
+
+        PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}.
+        """
+        response = self._session.patch(
+            url=f"{self.url}/repos/{owner}/{repo}/issues/comments/{comment_id}",
+            json={"body": body},
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def delete_issue_comment(self, owner: str, repo: str, comment_id: int) -> Response:
+        """Permanently delete an issue/PR comment.
+
+        DELETE /repos/{owner}/{repo}/issues/comments/{comment_id} (HTTP 204).
+        """
+        response = self._session.delete(
+            url=f"{self.url}/repos/{owner}/{repo}/issues/comments/{comment_id}",
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data={"status": "deleted"})
+
+    # --- Pull-request review comments (inline code comments) -------------
+
+    @require_auth
+    def list_review_comments(
+        self, owner: str, repo: str, pull_number: int, **filters
+    ) -> Response:
+        """List review (inline code) comments on a pull request.
+
+        GET /repos/{owner}/{repo}/pulls/{pull_number}/comments. Optional
+        filters passed straight through as query parameters (since, per_page,
+        page). Returns the raw JSON list of comments in ``Response.data``.
+        """
+        params = {k: v for k, v in filters.items() if v is not None}
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/pulls/{pull_number}/comments",
+            params=params or None,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def list_repo_review_comments(self, owner: str, repo: str, **filters) -> Response:
+        """List every pull-request review comment in a repository.
+
+        GET /repos/{owner}/{repo}/pulls/comments. Optional filters passed
+        straight through as query parameters (sort, direction, since,
+        per_page, page). Returns the raw JSON list of comments in
+        ``Response.data``.
+        """
+        params = {k: v for k, v in filters.items() if v is not None}
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/pulls/comments",
+            params=params or None,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def get_review_comment(self, owner: str, repo: str, comment_id: int) -> Response:
+        """Get a single pull-request review comment.
+
+        GET /repos/{owner}/{repo}/pulls/comments/{comment_id}.
+        """
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/pulls/comments/{comment_id}",
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def create_review_comment(
+        self, owner: str, repo: str, pull_number: int, body: str, **kwargs
+    ) -> Response:
+        """Create an inline review comment on a pull request's diff.
+
+        POST /repos/{owner}/{repo}/pulls/{pull_number}/comments. Requires
+        either a new-thread payload (``commit_id``, ``path``, plus ``line`` +
+        ``side``, or ``start_line`` + ``start_side`` for a multi-line
+        comment, or the legacy ``position``) or ``in_reply_to`` (an existing
+        review comment id) to reply within its thread — the simpler
+        create_review_comment_reply wraps that second case.
+        """
+        payload = {"body": body, **kwargs}
+        response = self._session.post(
+            url=f"{self.url}/repos/{owner}/{repo}/pulls/{pull_number}/comments",
+            json=payload,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def create_review_comment_reply(
+        self, owner: str, repo: str, pull_number: int, comment_id: int, body: str
+    ) -> Response:
+        """Reply to an existing pull-request review comment thread.
+
+        POST /repos/{owner}/{repo}/pulls/{pull_number}/comments/{comment_id}/replies.
+        Simpler than create_review_comment(in_reply_to=...) — no commit_id or
+        path required.
+        """
+        response = self._session.post(
+            url=(
+                f"{self.url}/repos/{owner}/{repo}/pulls/{pull_number}/comments/"
+                f"{comment_id}/replies"
+            ),
+            json={"body": body},
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def update_review_comment(
+        self, owner: str, repo: str, comment_id: int, body: str
+    ) -> Response:
+        """Edit a pull-request review comment.
+
+        PATCH /repos/{owner}/{repo}/pulls/comments/{comment_id}.
+        """
+        response = self._session.patch(
+            url=f"{self.url}/repos/{owner}/{repo}/pulls/comments/{comment_id}",
+            json={"body": body},
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def delete_review_comment(self, owner: str, repo: str, comment_id: int) -> Response:
+        """Permanently delete a pull-request review comment.
+
+        DELETE /repos/{owner}/{repo}/pulls/comments/{comment_id} (HTTP 204).
+        """
+        response = self._session.delete(
+            url=f"{self.url}/repos/{owner}/{repo}/pulls/comments/{comment_id}",
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data={"status": "deleted"})
+
+    # --- Commit comments ---------------------------------------------------
+
+    @require_auth
+    def list_commit_comments(
+        self, owner: str, repo: str, sha: str, **filters
+    ) -> Response:
+        """List comments on a single commit.
+
+        GET /repos/{owner}/{repo}/commits/{sha}/comments. Optional filters
+        passed straight through as query parameters (per_page, page).
+        Returns the raw JSON list of comments in ``Response.data``.
+        """
+        params = {k: v for k, v in filters.items() if v is not None}
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/commits/{sha}/comments",
+            params=params or None,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def list_repo_commit_comments(self, owner: str, repo: str, **filters) -> Response:
+        """List every commit comment in a repository.
+
+        GET /repos/{owner}/{repo}/comments. Optional filters passed straight
+        through as query parameters (per_page, page). Returns the raw JSON
+        list of comments in ``Response.data``.
+        """
+        params = {k: v for k, v in filters.items() if v is not None}
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/comments",
+            params=params or None,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def get_commit_comment(self, owner: str, repo: str, comment_id: int) -> Response:
+        """Get a single commit comment.
+
+        GET /repos/{owner}/{repo}/comments/{comment_id}.
+        """
+        response = self._session.get(
+            url=f"{self.url}/repos/{owner}/{repo}/comments/{comment_id}",
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def create_commit_comment(
+        self, owner: str, repo: str, sha: str, body: str, **kwargs
+    ) -> Response:
+        """Create a comment on a commit.
+
+        POST /repos/{owner}/{repo}/commits/{sha}/comments. Optionally anchor
+        the comment to a line of a file in the commit's diff via ``path``
+        (the file path) and ``line`` (the line number in the file).
+        """
+        payload = {"body": body, **kwargs}
+        response = self._session.post(
+            url=f"{self.url}/repos/{owner}/{repo}/commits/{sha}/comments",
+            json=payload,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def update_commit_comment(
+        self, owner: str, repo: str, comment_id: int, body: str
+    ) -> Response:
+        """Edit a commit comment.
+
+        PATCH /repos/{owner}/{repo}/comments/{comment_id}.
+        """
+        response = self._session.patch(
+            url=f"{self.url}/repos/{owner}/{repo}/comments/{comment_id}",
+            json={"body": body},
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data=response.json())
+
+    @require_auth
+    def delete_commit_comment(self, owner: str, repo: str, comment_id: int) -> Response:
+        """Permanently delete a commit comment.
+
+        DELETE /repos/{owner}/{repo}/comments/{comment_id} (HTTP 204).
+        """
+        response = self._session.delete(
+            url=f"{self.url}/repos/{owner}/{repo}/comments/{comment_id}",
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return Response(response=response, data={"status": "deleted"})

github_agent/api/api_client_commits.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
-from agent_utilities.decorators import require_auth
-from agent_utilities.exceptions import (
+from agent_connector_sdk.exceptions import (
     ParameterError,
+    require_auth,
 )
 from pydantic import ValidationError
 
@@ -35,8 +35,6 @@ class Api(BaseApiClient):
         response = self._session.get(
             url=f"{self.url}/repos/{owner}/{repo}/commits/{sha}",
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         try:

github_agent/api/api_client_contents.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
-from agent_utilities.decorators import require_auth
-from agent_utilities.exceptions import (
+from agent_connector_sdk.exceptions import (
     ParameterError,
+    require_auth,
 )
 from pydantic import ValidationError
 
@@ -25,8 +25,6 @@ class Api(BaseApiClient):
                 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()
@@ -50,8 +48,6 @@ class Api(BaseApiClient):
                 url=f"{self.url}/repos/{owner}/{repo}/contents/{path}",
                 json=payload,
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             res_json = response.json()
@@ -80,8 +76,6 @@ class Api(BaseApiClient):
                 url=f"{self.url}/repos/{owner}/{repo}/contents/{path}",
                 json=payload,
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             res_json = response.json()
@@ -103,8 +97,6 @@ class Api(BaseApiClient):
                 url=f"{self.url}/repos/{owner}/{repo}/contents/{path}",
                 json=payload,
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             return Response(response=response, data=response.json())

github_agent/api/api_client_dependabot.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from typing import Any
 
-from agent_utilities.decorators import require_auth
+from agent_connector_sdk.exceptions import require_auth
 
 from github_agent.api.api_client_base import BaseApiClient
 from github_agent.github_response_models import Response
@@ -22,8 +22,6 @@ class Api(BaseApiClient):
             url=f"{self.url}/repos/{owner}/{repo}/dependabot/alerts",
             params=params or None,
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data=response.json())
@@ -39,8 +37,6 @@ class Api(BaseApiClient):
         response = self._session.get(
             url=(f"{self.url}/repos/{owner}/{repo}/dependabot/alerts/{alert_number}"),
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data=response.json())
@@ -59,8 +55,6 @@ class Api(BaseApiClient):
             url=f"{self.url}/orgs/{org}/dependabot/alerts",
             params=params or None,
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data=response.json())
@@ -91,8 +85,6 @@ class Api(BaseApiClient):
             url=(f"{self.url}/repos/{owner}/{repo}/dependabot/alerts/{alert_number}"),
             json=payload,
             headers=self.headers,
-            verify=self.verify,
-            proxies=self.proxies,
         )
         response.raise_for_status()
         return Response(response=response, data=response.json())

github_agent/api/api_client_issues.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python
-from agent_utilities.decorators import require_auth
-from agent_utilities.exceptions import (
+from agent_connector_sdk.exceptions import (
     MissingParameterError,
     ParameterError,
+    require_auth,
 )
 from pydantic import ValidationError
 
@@ -41,8 +41,6 @@ class Api(BaseApiClient):
                 url=f"{self.url}/repos/{owner}/{repo}/issues",
                 json=payload,
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             parsed_data = Issue(**response.json())
@@ -58,8 +56,6 @@ class Api(BaseApiClient):
                 url=f"{self.url}/repos/{owner}/{repo}/issues/{number}",
                 json=kwargs,
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             parsed_data = Issue(**response.json())
@@ -74,8 +70,6 @@ class Api(BaseApiClient):
             response = self._session.get(
                 url=f"{self.url}/repos/{owner}/{repo}/issues/{number}",
                 headers=self.headers,
-                verify=self.verify,
-                proxies=self.proxies,
             )
             response.raise_for_status()
             parsed_data = Issue(**response.json())