michael
0461c6c7ab
### Findings and Changes
#### Changes:
- **Added **: Included a standard Python to avoid tracking unnecessary files (e.g., , , ).
- **Added **: Prepared the project for better dependency management.
- **Enhanced Gitea Tools**:
- Implemented in .
- Implemented (via ) in .
#### Implementation Details:
- Used the Gitea API to programmatically create a new branch and commit files directly from a script.
- Verified that the NAME:
tea - command line tool to interact with Gitea
USAGE:
tea [global options] [command [command options]]
VERSION:
Version: [1m0.14.1[0m golang: 1.26.3 go-sdk: v0.25.1
DESCRIPTION:
tea is a productivity helper for Gitea. It can be used to manage most entities on
one or multiple Gitea instances & provides local helpers like 'tea pr checkout'.
tea tries to make use of context provided by the repository in $PWD if available.
tea works best in a upstream/fork workflow, when the local main branch tracks the
upstream repo. tea assumes that local git state is published on the remote before
doing operations with tea. Configuration is persisted in $XDG_CONFIG_HOME/tea.
COMMANDS:
help, h Shows a list of commands or help for one command
ENTITIES:
issues, issue, i List, create and update issues
pulls, pull, pr Manage and checkout pull requests
labels, label Manage issue labels
milestones, milestone, ms List and create milestones
releases, release, r Manage releases
times, time, t Operate on tracked times of a repository's issues & pulls
organizations, organization, org List, create, delete organizations
repos, repo Manage repositories
branches, branch, b Consult branches
actions, action Manage repository actions
webhooks, webhook, hooks, hook Manage webhooks
comment, c Add a comment to an issue / pr
HELPERS:
open, o Open something of the repository in web browser
notifications, notification, n Show notifications
clone, C Clone a repository locally
api Make an authenticated API request
MISCELLANEOUS:
whoami Show current logged in user
admin, a Operations requiring admin access on the Gitea instance
SETUP:
logins, login Log in to a Gitea server
logout Log out from a Gitea server
ssh-keys, ssh-key Manage SSH public keys
GLOBAL OPTIONS:
--debug, --vvv Enable debug mode
--help, -h show help
--version, -v print the version CLI can be used for automated PR creation.
- Successfully configured Git user identity and remote tracking in the environment.
---------
Co-authored-by: Michael <michael@example.com>
Reviewed-on: #1
123 lines
7.3 KiB
Python
123 lines
7.3 KiB
Python
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) -> str:
|
|
"""Get all comments on an issue. Args: owner (repo owner), repo (repo name), issue_number (issue ID)."""
|
|
return self.issue_tools.get_issue_comments(owner, repo, issue_number)
|
|
|
|
def get_pull_request_comments(self, owner: str, repo: str, pull_number: int) -> str:
|
|
"""Get all comments on a pull request. Args: owner (repo owner), repo (repo name), pull_number (PR ID)."""
|
|
return self.pr_tools.get_pull_request_comments(owner, repo, pull_number)
|
|
|
|
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) -> str:
|
|
"""Get the content of a file from a repository. Args: owner (repo owner), repo (repo name), path (file path)."""
|
|
return self.file_tools.get_file_content(owner, repo, path)
|
|
|
|
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 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) -> str:
|
|
"""Get the diff of a pull request. Args: owner, repo, pull_number."""
|
|
return self.pr_tools.get_pull_request_diff(owner, repo, pull_number)
|
|
|
|
def get_pull_request_patch(self, owner: str, repo: str, pull_number: int) -> str:
|
|
"""Get the patch of a pull request. Args: owner, repo, pull_number."""
|
|
return self.pr_tools.get_pull_request_patch(owner, repo, pull_number)
|
|
|
|
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") -> str:
|
|
"""Get file content with a specific git ref. Args: owner, repo, path, ref (branch/tag)."""
|
|
return self.file_tools.get_file_content_with_ref(owner, repo, path, ref)
|
|
|
|
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)
|