elizaos-plugin-github 2.0.0a4__py3-none-any.whl

elizaos_plugin_github/__init__.py

@@ -0,0 +1,113 @@
+from elizaos_plugin_github.config import GitHubConfig
+from elizaos_plugin_github.error import (
+    BranchExistsError,
+    BranchNotFoundError,
+    ClientNotInitializedError,
+    ConfigError,
+    FileNotFoundError,
+    GitHubApiError,
+    GitHubError,
+    InvalidArgumentError,
+    IssueNotFoundError,
+    MergeConflictError,
+    MissingSettingError,
+    NetworkError,
+    PermissionDeniedError,
+    PullRequestNotFoundError,
+    RateLimitedError,
+    RepositoryNotFoundError,
+    TimeoutError,
+    ValidationError,
+)
+from elizaos_plugin_github.service import GitHubService
+from elizaos_plugin_github.types import (
+    CreateBranchParams,
+    CreateCommentParams,
+    CreateCommitParams,
+    CreateIssueParams,
+    CreatePullRequestParams,
+    CreateReviewParams,
+    FileChange,
+    GitHubBranch,
+    GitHubComment,
+    GitHubCommit,
+    GitHubDirectoryEntry,
+    GitHubEventType,
+    GitHubFileContent,
+    GitHubIssue,
+    GitHubLabel,
+    GitHubMilestone,
+    GitHubPullRequest,
+    GitHubRepository,
+    GitHubReview,
+    GitHubUser,
+    IssueState,
+    ListIssuesParams,
+    ListPullRequestsParams,
+    MergePullRequestParams,
+    PullRequestState,
+    RepositoryRef,
+    ReviewState,
+    UpdateIssueParams,
+    UpdatePullRequestParams,
+)
+
+__all__ = [
+    # Config
+    "GitHubConfig",
+    # Errors
+    "GitHubError",
+    "ClientNotInitializedError",
+    "ConfigError",
+    "MissingSettingError",
+    "InvalidArgumentError",
+    "RepositoryNotFoundError",
+    "BranchNotFoundError",
+    "FileNotFoundError",
+    "IssueNotFoundError",
+    "PullRequestNotFoundError",
+    "PermissionDeniedError",
+    "RateLimitedError",
+    "MergeConflictError",
+    "BranchExistsError",
+    "ValidationError",
+    "GitHubApiError",
+    "NetworkError",
+    "TimeoutError",
+    # Types
+    "RepositoryRef",
+    "FileChange",
+    "IssueState",
+    "GitHubIssue",
+    "CreateIssueParams",
+    "UpdateIssueParams",
+    "ListIssuesParams",
+    "PullRequestState",
+    "GitHubPullRequest",
+    "CreatePullRequestParams",
+    "UpdatePullRequestParams",
+    "ListPullRequestsParams",
+    "MergePullRequestParams",
+    "ReviewState",
+    "GitHubReview",
+    "CreateReviewParams",
+    "GitHubComment",
+    "CreateCommentParams",
+    "GitHubBranch",
+    "CreateBranchParams",
+    "GitHubCommit",
+    "CreateCommitParams",
+    "GitHubFileContent",
+    "GitHubDirectoryEntry",
+    "GitHubRepository",
+    "GitHubUser",
+    "GitHubLabel",
+    "GitHubMilestone",
+    "GitHubEventType",
+    # Service
+    "GitHubService",
+]
+
+__version__ = "1.0.0"
+PLUGIN_NAME = "github"
+PLUGIN_DESCRIPTION = "GitHub integration for elizaOS agents"

elizaos_plugin_github/actions/__init__.py

@@ -0,0 +1,27 @@
+from elizaos_plugin_github.actions.create_branch import CreateBranchAction
+from elizaos_plugin_github.actions.create_comment import CreateCommentAction
+from elizaos_plugin_github.actions.create_issue import CreateIssueAction
+from elizaos_plugin_github.actions.create_pull_request import CreatePullRequestAction
+from elizaos_plugin_github.actions.merge_pull_request import MergePullRequestAction
+from elizaos_plugin_github.actions.push_code import PushCodeAction
+from elizaos_plugin_github.actions.review_pull_request import ReviewPullRequestAction
+
+__all__ = [
+    "CreateIssueAction",
+    "CreatePullRequestAction",
+    "ReviewPullRequestAction",
+    "CreateCommentAction",
+    "CreateBranchAction",
+    "PushCodeAction",
+    "MergePullRequestAction",
+]
+
+all_actions = [
+    CreateIssueAction(),
+    CreatePullRequestAction(),
+    ReviewPullRequestAction(),
+    CreateCommentAction(),
+    CreateBranchAction(),
+    PushCodeAction(),
+    MergePullRequestAction(),
+]

elizaos_plugin_github/actions/create_branch.py

@@ -0,0 +1,62 @@
+from elizaos_plugin_github.actions.create_issue import ActionContext, ActionResult
+from elizaos_plugin_github.types import CreateBranchParams
+
+
+class CreateBranchAction:
+    @property
+    def name(self) -> str:
+        return "CREATE_GITHUB_BRANCH"
+
+    @property
+    def description(self) -> str:
+        return "Creates a new branch in a GitHub repository from an existing branch or commit."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "NEW_BRANCH",
+            "BRANCH_FROM",
+            "FORK_BRANCH",
+            "CREATE_FEATURE_BRANCH",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "branch" in text or "fork" in text or "checkout" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            branch_name = str(context.message.get("branch_name", "new-branch"))
+            from_ref = str(context.message.get("from_ref", "main"))
+
+            params = CreateBranchParams(
+                owner=context.owner,
+                repo=context.repo,
+                branch_name=branch_name,
+                from_ref=from_ref,
+            )
+
+            branch = await service.create_branch(params)
+
+            return ActionResult.success_result(
+                f"Created branch '{branch.name}' from {from_ref}",
+                {
+                    "branch_name": branch.name,
+                    "sha": branch.sha,
+                },
+            )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to create branch: {e}")

elizaos_plugin_github/actions/create_comment.py

@@ -0,0 +1,67 @@
+from elizaos_plugin_github.actions.create_issue import ActionContext, ActionResult
+from elizaos_plugin_github.types import CreateCommentParams
+
+
+class CreateCommentAction:
+    @property
+    def name(self) -> str:
+        return "CREATE_GITHUB_COMMENT"
+
+    @property
+    def description(self) -> str:
+        return "Creates a comment on a GitHub issue or pull request."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "COMMENT_ON_ISSUE",
+            "COMMENT_ON_PR",
+            "ADD_COMMENT",
+            "REPLY_TO_ISSUE",
+            "POST_COMMENT",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "comment" in text or "reply" in text or "respond" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            content = context.message.get("content", {})
+            text = ""
+            if isinstance(content, dict):
+                text = str(content.get("text", ""))
+
+            issue_number = int(context.message.get("issue_number", 0))
+
+            params = CreateCommentParams(
+                owner=context.owner,
+                repo=context.repo,
+                issue_number=issue_number,
+                body=text,
+            )
+
+            comment = await service.create_comment(params)
+
+            return ActionResult.success_result(
+                f"Added comment to #{issue_number}",
+                {
+                    "comment_id": comment.id,
+                    "html_url": comment.html_url,
+                },
+            )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to create comment: {e}")

elizaos_plugin_github/actions/create_issue.py

@@ -0,0 +1,93 @@
+from typing import Protocol
+
+from elizaos_plugin_github.types import CreateIssueParams
+
+
+class ActionContext(Protocol):
+    message: dict[str, object]
+    owner: str
+    repo: str
+
+
+class ActionResult:
+    def __init__(
+        self,
+        success: bool,
+        message: str,
+        data: dict[str, object] | None = None,
+    ) -> None:
+        self.success = success
+        self.message = message
+        self.data = data or {}
+
+    @classmethod
+    def success_result(cls, message: str, data: dict[str, object] | None = None) -> "ActionResult":
+        return cls(success=True, message=message, data=data)
+
+    @classmethod
+    def error_result(cls, message: str) -> "ActionResult":
+        return cls(success=False, message=message)
+
+
+class CreateIssueAction:
+    @property
+    def name(self) -> str:
+        return "CREATE_GITHUB_ISSUE"
+
+    @property
+    def description(self) -> str:
+        return "Creates a new issue in a GitHub repository. Use this to report bugs, request features, or track tasks."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "OPEN_ISSUE",
+            "NEW_ISSUE",
+            "FILE_ISSUE",
+            "REPORT_BUG",
+            "CREATE_BUG_REPORT",
+            "SUBMIT_ISSUE",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "issue" in text or "bug" in text or "report" in text or "ticket" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            content = context.message.get("content", {})
+            text = ""
+            if isinstance(content, dict):
+                text = str(content.get("text", ""))
+
+            params = CreateIssueParams(
+                owner=context.owner,
+                repo=context.repo,
+                title=text[:100] if text else "New Issue",
+                body=text,
+            )
+
+            issue = await service.create_issue(params)
+
+            return ActionResult.success_result(
+                f"Created issue #{issue.number}: {issue.title}",
+                {
+                    "issue_number": issue.number,
+                    "html_url": issue.html_url,
+                },
+            )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to create issue: {e}")

elizaos_plugin_github/actions/create_pull_request.py

@@ -0,0 +1,73 @@
+from elizaos_plugin_github.actions.create_issue import ActionContext, ActionResult
+from elizaos_plugin_github.types import CreatePullRequestParams
+
+
+class CreatePullRequestAction:
+    @property
+    def name(self) -> str:
+        return "CREATE_GITHUB_PULL_REQUEST"
+
+    @property
+    def description(self) -> str:
+        return "Creates a new pull request in a GitHub repository to merge changes from one branch to another."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "OPEN_PR",
+            "CREATE_PR",
+            "NEW_PULL_REQUEST",
+            "SUBMIT_PR",
+            "OPEN_PULL_REQUEST",
+            "MERGE_REQUEST",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "pull request" in text or "pr" in text or "merge" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            content = context.message.get("content", {})
+            text = ""
+            if isinstance(content, dict):
+                text = str(content.get("text", ""))
+
+            head = str(context.message.get("head", "feature"))
+            base = str(context.message.get("base", "main"))
+
+            params = CreatePullRequestParams(
+                owner=context.owner,
+                repo=context.repo,
+                title=text[:100] if text else "New Pull Request",
+                body=text,
+                head=head,
+                base=base,
+            )
+
+            pr = await service.create_pull_request(params)
+
+            return ActionResult.success_result(
+                f"Created pull request #{pr.number}: {pr.title}",
+                {
+                    "pull_number": pr.number,
+                    "html_url": pr.html_url,
+                    "head": pr.head.ref,
+                    "base": pr.base.ref,
+                },
+            )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to create pull request: {e}")

elizaos_plugin_github/actions/merge_pull_request.py

@@ -0,0 +1,82 @@
+from typing import Literal
+
+from elizaos_plugin_github.actions.create_issue import ActionContext, ActionResult
+from elizaos_plugin_github.types import MergePullRequestParams
+
+
+class MergePullRequestAction:
+    @property
+    def name(self) -> str:
+        return "MERGE_GITHUB_PULL_REQUEST"
+
+    @property
+    def description(self) -> str:
+        return "Merges a GitHub pull request using merge, squash, or rebase strategy."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "MERGE_PR",
+            "SQUASH_MERGE",
+            "REBASE_MERGE",
+            "COMPLETE_PR",
+            "ACCEPT_PR",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "merge" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            content = context.message.get("content", {})
+            text = ""
+            if isinstance(content, dict):
+                text = str(content.get("text", "")).lower()
+
+            # Determine merge method
+            merge_method: Literal["merge", "squash", "rebase"] = "merge"
+            if "squash" in text:
+                merge_method = "squash"
+            elif "rebase" in text:
+                merge_method = "rebase"
+
+            pull_number = int(context.message.get("pull_number", 0))
+
+            params = MergePullRequestParams(
+                owner=context.owner,
+                repo=context.repo,
+                pull_number=pull_number,
+                merge_method=merge_method,
+            )
+
+            sha, merged, message = await service.merge_pull_request(params)
+
+            if merged:
+                return ActionResult.success_result(
+                    f"Successfully merged pull request #{pull_number}",
+                    {
+                        "sha": sha,
+                        "merged": merged,
+                        "merge_method": merge_method,
+                    },
+                )
+            else:
+                return ActionResult.error_result(
+                    f"Could not merge pull request #{pull_number}: {message}"
+                )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to merge pull request: {e}")

elizaos_plugin_github/actions/push_code.py

@@ -0,0 +1,83 @@
+from elizaos_plugin_github.actions.create_issue import ActionContext, ActionResult
+from elizaos_plugin_github.types import CreateCommitParams, FileChange
+
+
+class PushCodeAction:
+    @property
+    def name(self) -> str:
+        return "PUSH_GITHUB_CODE"
+
+    @property
+    def description(self) -> str:
+        return "Creates a commit with file changes and pushes to a GitHub branch."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "COMMIT_CODE",
+            "PUSH_CHANGES",
+            "COMMIT_FILES",
+            "PUSH_FILES",
+            "GIT_PUSH",
+            "SAVE_CODE",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "push" in text or "commit" in text or "save" in text or "upload" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            content = context.message.get("content", {})
+            text = ""
+            if isinstance(content, dict):
+                text = str(content.get("text", ""))
+
+            files_data = context.message.get("files", [])
+            files: list[FileChange] = []
+
+            if isinstance(files_data, list):
+                for f in files_data:
+                    if isinstance(f, dict):
+                        files.append(
+                            FileChange(
+                                path=str(f.get("path", "")),
+                                content=str(f.get("content", "")),
+                            )
+                        )
+
+            branch = str(context.message.get("branch", "main"))
+
+            params = CreateCommitParams(
+                owner=context.owner,
+                repo=context.repo,
+                message=text[:100] if text else "Update files",
+                files=files,
+                branch=branch,
+            )
+
+            commit = await service.create_commit(params)
+
+            return ActionResult.success_result(
+                f"Pushed {len(files)} file(s) to {branch}",
+                {
+                    "sha": commit.sha,
+                    "html_url": commit.html_url,
+                    "message": commit.message,
+                },
+            )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to push code: {e}")

elizaos_plugin_github/actions/review_pull_request.py

@@ -0,0 +1,84 @@
+from elizaos_plugin_github.actions.create_issue import ActionContext, ActionResult
+from elizaos_plugin_github.types import CreateReviewParams, ReviewEvent
+
+
+class ReviewPullRequestAction:
+    @property
+    def name(self) -> str:
+        return "REVIEW_GITHUB_PULL_REQUEST"
+
+    @property
+    def description(self) -> str:
+        return "Creates a review on a GitHub pull request. Can approve, request changes, or add comments."
+
+    @property
+    def similes(self) -> list[str]:
+        return [
+            "APPROVE_PR",
+            "REQUEST_CHANGES",
+            "COMMENT_ON_PR",
+            "REVIEW_PR",
+            "PR_REVIEW",
+            "CODE_REVIEW",
+        ]
+
+    async def validate(self, context: ActionContext) -> bool:
+        content = context.message.get("content", {})
+        text = ""
+        if isinstance(content, dict):
+            text = str(content.get("text", "")).lower()
+
+        return "review" in text or "approve" in text or "request changes" in text or "lgtm" in text
+
+    async def handler(
+        self,
+        context: ActionContext,
+        service: object,
+    ) -> ActionResult:
+        from elizaos_plugin_github.service import GitHubService
+
+        if not isinstance(service, GitHubService):
+            return ActionResult.error_result("GitHub service not available")
+
+        try:
+            content = context.message.get("content", {})
+            text = ""
+            if isinstance(content, dict):
+                text = str(content.get("text", "")).lower()
+
+            event = ReviewEvent.COMMENT
+            if "approve" in text or "lgtm" in text or "looks good" in text:
+                event = ReviewEvent.APPROVE
+            elif "request changes" in text or "needs work" in text or "fix" in text:
+                event = ReviewEvent.REQUEST_CHANGES
+
+            pull_number = int(context.message.get("pull_number", 0))
+
+            params = CreateReviewParams(
+                owner=context.owner,
+                repo=context.repo,
+                pull_number=pull_number,
+                body=text,
+                event=event,
+            )
+
+            review = await service.create_review(params)
+
+            event_label = (
+                "approved"
+                if review.state.value == "APPROVED"
+                else "requested changes on"
+                if review.state.value == "CHANGES_REQUESTED"
+                else "commented on"
+            )
+
+            return ActionResult.success_result(
+                f"Successfully {event_label} pull request #{pull_number}",
+                {
+                    "review_id": review.id,
+                    "html_url": review.html_url,
+                    "state": review.state.value,
+                },
+            )
+        except Exception as e:
+            return ActionResult.error_result(f"Failed to create review: {e}")