coding-agent-gitea/gitea/tools/gitea_tools.py

from gitea.tools.issue_tools import IssueTools
from gitea.tools.pr_tools import PRTools
from gitea.tools.file_tools import FileTools
from gitea.tools.git_tools import GitTools
from gitea.client import GiteaClient


class GiteaTools:
    """Facade for Gitea tool operations - delegates to focused tool classes."""

    def __init__(self, client: GiteaClient) -> None:
        self._client = client
        self.issue_tools = IssueTools(client)
        self.pr_tools = PRTools(client)
        self.file_tools = FileTools(client)
        self.git_tools = GitTools(client)

    # ---- Issue operations (delegated) ----

    def get_issue(self, owner: str, repo: str, issue_number: int) -> str:
        """Get the details of a specific issue. Args: owner (repo owner), repo (repo name), issue_number (issue ID)."""
        return self.issue_tools.get_issue(owner, repo, issue_number)

    def get_pull_request(self, owner: str, repo: str, pull_number: int) -> str:
        """Get the details of a specific pull request. Args: owner (repo owner), repo (repo name), pull_number (PR ID)."""
        return self.pr_tools.get_pull_request(owner, repo, pull_number)

    def close_issue(self, owner: str, repo: str, issue_number: int) -> str:
        """Close an issue. Args: owner (repo owner), repo (repo name), issue_number (issue ID)."""
        return self.issue_tools.close_issue(owner, repo, issue_number)

    def close_pull_request(self, owner: str, repo: str, pull_number: int) -> str:
        """Close a pull request. Args: owner (repo owner), repo (repo name), pull_number (PR ID)."""
        return self.pr_tools.close_pull_request(owner, repo, pull_number)

    def get_issue_comments(
        self,
        owner: str,
        repo: str,
        issue_number: int,
        limit: int = 20,
        offset: int = 0,
    ) -> str:
        """Get all comments on an issue. Args: owner, repo, issue_number, limit (default 20), offset (default 0)."""
        return self.issue_tools.get_issue_comments(owner, repo, issue_number, limit=limit, offset=offset)

    def get_pull_request_comments(
        self,
        owner: str,
        repo: str,
        pull_number: int,
        limit: int = 20,
        offset: int = 0,
    ) -> str:
        """Get all comments on a pull request. Args: owner, repo, pull_number, limit (default 20), offset (default 0)."""
        return self.pr_tools.get_pull_request_comments(owner, repo, pull_number, limit=limit, offset=offset)

    def list_assigned_issues(self) -> list[dict]:
        """List all issues assigned to the authenticated user across all repos."""
        return self.issue_tools.list_assigned_issues()

    def list_assigned_pull_requests(self) -> list[dict]:
        """List all pull requests assigned to the authenticated user across all repos."""
        return self.pr_tools.list_assigned_pull_requests()

    def list_issues(self, owner: str, repo: str, state: str = "open") -> str:
        """List issues in a repository. Args: owner (repo owner), repo (repo name), state (open, closed, or all)."""
        return self.issue_tools.list_issues(owner, repo, state)

    def list_pull_requests(self, owner: str, repo: str, state: str = "open") -> str:
        """List pull requests in a repository. Args: owner (repo owner), repo (repo name), state (open, closed, or all)."""
        return self.pr_tools.list_pull_requests(owner, repo, state)

    def get_file_content(
        self,
        owner: str,
        repo: str,
        path: str,
        offset: int = 1,
        limit: int = 250,
    ) -> str:
        """Get the content of a file from a repository. Args: owner, repo, path, offset (line, default 1), limit (default 250)."""
        return self.file_tools.get_file_content(owner, repo, path, offset=offset, limit=limit)

    def create_pull_request(self, owner: str, repo: str, head: str, base: str, title: str, description: str = "") -> str:
        """Create a new pull request. Args: owner, repo, head (source branch), base (target branch), title, description."""
        return self.pr_tools.create_pull_request(owner, repo, head, base, title, description)

    def update_pull_request(
        self,
        owner: str,
        repo: str,
        pull_number: int,
        title: str | None = None,
        body: str | None = None,
        state: str | None = None,
    ) -> str:
        """Update an existing pull request. Args: owner, repo, pull_number, title (optional), body (optional), state (optional)."""
        return self.pr_tools.update_pull_request(owner, repo, pull_number, title, body, state)

    def create_issue(self, owner: str, repo: str, title: str, body: str, labels: list[str] | None = None, assignees: list[str] | None = None) -> str:
        """Create a new issue. Args: owner, repo, title, body, labels (optional), assignees (optional)."""
        return self.issue_tools.create_issue(owner, repo, title, body, labels, assignees)

    def create_branch(self, owner: str, repo: str, ref: str, sha: str) -> str:
        """Create a new branch in a repository. Args: owner, repo, ref (branch name), sha (commit SHA)."""
        return self.git_tools.create_branch(owner, repo, ref, sha)

    def commit_file(self, owner: str, repo: str, path: str, message: str, content: str, branch: str) -> str:
        """Commit a file to a repository. Args: owner, repo, path, message, content, branch."""
        return self.file_tools.commit_file(owner, repo, path, message, content, branch)

    def add_label_to_issue(self, owner: str, repo: str, issue_number: int, label: str) -> str:
        """Add a label to an issue. Args: owner, repo, issue_number, label."""
        return self.issue_tools.add_label_to_issue(owner, repo, issue_number, label)

    def add_label_to_pr(self, owner: str, repo: str, pr_number: int, label: str) -> str:
        """Add a label to a pull request. Args: owner, repo, pr_number, label."""
        return self.pr_tools.add_label_to_pr(owner, repo, pr_number, label)

    def add_comment_to_issue(self, owner: str, repo: str, issue_number: int, body: str) -> str:
        """Add a comment to an issue. Args: owner, repo, issue_number, body."""
        return self.issue_tools.add_comment_to_issue(owner, repo, issue_number, body)

    def get_pull_request_diff(
        self,
        owner: str,
        repo: str,
        pull_number: int,
        max_chars: int = 15000,
        char_offset: int = 0,
    ) -> str:
        """Get the diff of a pull request. Args: owner, repo, pull_number, max_chars (default 15000), char_offset (default 0)."""
        return self.pr_tools.get_pull_request_diff(owner, repo, pull_number, max_chars=max_chars, char_offset=char_offset)

    def get_pull_request_patch(
        self,
        owner: str,
        repo: str,
        pull_number: int,
        max_chars: int = 15000,
        char_offset: int = 0,
    ) -> str:
        """Get the patch of a pull request. Args: owner, repo, pull_number, max_chars (default 15000), char_offset (default 0)."""
        return self.pr_tools.get_pull_request_patch(owner, repo, pull_number, max_chars=max_chars, char_offset=char_offset)

    def approve_pull_request(self, owner: str, repo: str, pull_number: int, comment: str) -> str:
        """Approve a pull request. Args: owner, repo, pull_number, comment."""
        return self.pr_tools.approve_pull_request(owner, repo, pull_number, comment)

    def request_changes(self, owner: str, repo: str, pull_number: int, comment: str) -> str:
        """Request changes on a pull request. Args: owner, repo, pull_number, comment."""
        return self.pr_tools.request_changes(owner, repo, pull_number, comment)

    def add_comment(self, owner: str, repo: str, issue_number: int, body: str) -> str:
        """Add a comment to an issue. Args: owner, repo, issue_number, body."""
        return self.issue_tools.add_comment(owner, repo, issue_number, body)

    def add_label(self, owner: str, repo: str, issue_number: int, label: str) -> str:
        """Add a label to an issue. Args: owner, repo, issue_number, label."""
        return self.issue_tools.add_label(owner, repo, issue_number, label)

    def get_file_content_with_ref(
        self,
        owner: str,
        repo: str,
        path: str,
        ref: str = "master",
        offset: int = 1,
        limit: int = 250,
    ) -> str:
        """Get file content with a specific git ref. Args: owner, repo, path, ref (branch/tag), offset (line, default 1), limit (default 250)."""
        return self.file_tools.get_file_content_with_ref(owner, repo, path, ref=ref, offset=offset, limit=limit)

    def update_file(self, owner: str, repo: str, path: str, message: str, content: str, branch: str) -> str:
        """Update a file in a repository. Args: owner, repo, path, message, content, branch."""
        return self.file_tools.update_file(owner, repo, path, message, content, branch)