Add project management functions for creating boards, columns, and cards.

tools/github_tool.py

@@ -1,4 +1,3 @@
-# tools/github_tool.py
 from .base_tool import BaseTool
 from .metrics import metrics
 import requests
@@ -407,6 +406,104 @@ class GitHubTool(BaseTool):
                     },
                     "required": ["issue_number"]
                 }
+            },
+            {
+                "name": "create_project_board",
+                "description": "Create a new project board",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "description": "Name of the project board"
+                        },
+                        "body": {
+                            "type": "string",
+                            "description": "Body of the project board"
+                        }
+                    },
+                    "required": ["name"]
+                }
+            },
+            {
+                "name": "create_project_column",
+                "description": "Create a new column in a project board",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "project_id": {
+                            "type": "integer",
+                            "description": "ID of the project board"
+                        },
+                        "column_name": {
+                            "type": "string",
+                            "description": "Name of the column"
+                        }
+                    },
+                    "required": ["project_id", "column_name"]
+                }
+            },
+            {
+                "name": "create_project_card",
+                "description": "Create a new card in a project column",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "column_id": {
+                            "type": "integer",
+                            "description": "ID of the project column"
+                        },
+                        "note": {
+                            "type": "string",
+                            "description": "Note for the project card"
+                        }
+                    },
+                    "required": ["column_id", "note"]
+                }
+            },
+            {
+                "name": "move_project_card",
+                "description": "Move a card to a new position",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "card_id": {
+                            "type": "integer",
+                            "description": "ID of the project card"
+                        },
+                        "position": {
+                            "type": "string",
+                            "description": "New position of the card"
+                        },
+                        "column_id": {
+                            "type": "integer",
+                            "description": "ID of the target column"
+                        }
+                    },
+                    "required": ["card_id", "position", "column_id"]
+                }
+            },
+            {
+                "name": "link_issue_to_project_card",
+                "description": "Link an issue or pull request to a project card",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "card_id": {
+                            "type": "integer",
+                            "description": "ID of the project card"
+                        },
+                        "content_id": {
+                            "type": "integer",
+                            "description": "ID of the issue or pull request"
+                        },
+                        "content_type": {
+                            "type": "string",
+                            "description": "Type of the content (Issue or PullRequest)"
+                        }
+                    },
+                    "required": ["card_id", "content_id", "content_type"]
+                }
             }
         ]
 
@@ -432,31 +529,16 @@ class GitHubTool(BaseTool):
             return self._get_current_branch()
         elif function_name == "set_current_branch":
             return self._set_current_branch(kwargs["branch_name"])
-        elif function_name == "get_file_at_commit":
+        elif function_name == "create_project_board":
-            return self._get_file_at_commit(kwargs["file_path"], kwargs["commit_sha"])
+            return self._create_project_board(kwargs["name"], kwargs.get("body"))
-        elif function_name == "list_branches":
+        elif function_name == "create_project_column":
-            return self._list_branches(kwargs.get("per_page", 100), kwargs.get("all_pages", True))
+            return self._create_project_column(kwargs["project_id"], kwargs["column_name"])
-        elif function_name == "get_branch_sha":
+        elif function_name == "create_project_card":
-            return self._get_branch_sha(kwargs["branch"])
+            return self._create_project_card(kwargs["column_id"], kwargs["note"])
-        elif function_name == "approve_pull_request":
+        elif function_name == "move_project_card":
-            return self._approve_pull_request(kwargs["pull_number"])
+            return self._move_project_card(kwargs["card_id"], kwargs["position"], kwargs["column_id"])
-        elif function_name == "close_pull_request":
+        elif function_name == "link_issue_to_project_card":
-            return self._close_pull_request(kwargs["pull_number"])
+            return self._link_issue_to_project_card(kwargs["card_id"], kwargs["content_id"], kwargs["content_type"])
-        elif function_name == "merge_pull_request":
-            return self._merge_pull_request(kwargs["pull_number"], kwargs.get("commit_title", "Merge pull request"), 
-                                            kwargs.get("commit_message", ""), kwargs.get("merge_method", "merge"))
-        elif function_name == "delete_branch":
-            return self._delete_branch(kwargs["branch_name"])
-        elif function_name == "get_issue_details":
-            return self._get_issue_details(kwargs["issue_number"])
-        elif function_name == "create_issue":
-            return self._create_issue(kwargs["title"], kwargs["body"], kwargs.get("labels", []))
-        elif function_name == "list_issues":
-            return self._list_issues(kwargs.get("state", "open"), kwargs.get("per_page", 30), kwargs.get("page", 1))
-        elif function_name == "add_issue_comment":
-            return self._add_issue_comment(kwargs["issue_number"], kwargs["comment"])
-        elif function_name == "get_issue_comments":
-            return self._get_issue_comments(kwargs["issue_number"])
         else:
             error_message = f"Unknown function: {function_name}"
             self.logger.error(error_message)
@@ -478,127 +560,75 @@ class GitHubTool(BaseTool):
             return error_message
 
     @metrics.measure
-    def _create_branch(self, branch_name, base_branch):
+    def _create_project_board(self, name, body=None):
-        self.logger.info(f"Creating branch: {branch_name} from base: {base_branch}")
+        url = f"{self.base_url}/repos/{self.repo}/projects"
-        url = f"{self.base_url}/repos/{self.repo}/git/refs"
+        data = {"name": name, "body": body}
-        response = requests.get(f"{url}/heads/{base_branch}", headers=self.headers)
-        if response.status_code != 200:
-            error_message = f"Error getting base branch: {response.status_code}"
-            self.logger.error(error_message)
-            return error_message
-
-        sha = response.json()["object"]["sha"]
-        data = {
-            "ref": f"refs/heads/{branch_name}",
-            "sha": sha
-        }
         response = requests.post(url, headers=self.headers, json=data)
         if response.status_code == 201:
-            self.current_branch = branch_name
+            project = response.json()
-            success_message = f"Branch '{branch_name}' created successfully and set as current branch"
+            success_message = f"Project board '{name}' created successfully."
             self.logger.info(success_message)
             return success_message
         else:
-            error_message = f"Error creating branch: {response.status_code}"
+            error_message = f"Error creating project board: {response.status_code}"
             self.logger.error(error_message)
             return error_message
 
     @metrics.measure
-    def _commit_file(self, file_path, content, commit_message):
+    def _create_project_column(self, project_id, column_name):
-        self.logger.info(f"Committing file: {file_path} to branch: {self.current_branch}")
+        url = f"{self.base_url}/projects/{project_id}/columns"
-        if self.current_branch == "main":
+        data = {"name": column_name}
-            error_message = "Cannot commit directly to main branch"
-            self.logger.error(error_message)
-            return error_message
-
-        url = f"{self.base_url}/repos/{self.repo}/contents/{file_path}"
-
-        self.logger.info("Checking if file already exists")
-        response = requests.get(url, headers=self.headers, params={"ref": self.current_branch})
-
-        data = {
-            "message": commit_message,
-            "content": base64.b64encode(content.encode()).decode(),
-            "branch": self.current_branch
-        }
-
-        if response.status_code == 200:
-            self.logger.info("File exists, updating")
-            file_sha = response.json()["sha"]
-            data["sha"] = file_sha
-        else:
-            self.logger.info("File does not exist, creating new file")
-
-        response = requests.put(url, headers=self.headers, json=data)
-
-        if response.status_code in [200, 201]:
-            success_message = f"File committed successfully to branch '{self.current_branch}'"
-            self.logger.info(success_message)
-            return success_message
-        else:
-            error_message = f"Error committing file: {response.status_code}\nResponse: {response.text}"
-            self.logger.error(error_message)
-            return error_message
-
-    @metrics.measure
-    def _create_pull_request(self, title, body, base):
-        self.logger.info(f"Creating pull request: {title} from {self.current_branch} to {base}")
-        url = f"{self.base_url}/repos/{self.repo}/pulls"
-        data = {
-            "title": title,
-            "body": body,
-            "head": self.current_branch,
-            "base": base
-        }
         response = requests.post(url, headers=self.headers, json=data)
         if response.status_code == 201:
-            success_message = f"Pull request created successfully: {response.json()['html_url']}"
+            column = response.json()
+            success_message = f"Column '{column_name}' created successfully in project {project_id}."
             self.logger.info(success_message)
             return success_message
         else:
-            error_message = f"Error creating pull request: {response.status_code}\nResponse: {response.text}"
+            error_message = f"Error creating project column: {response.status_code}"
             self.logger.error(error_message)
             return error_message
 
     @metrics.measure
-    def _get_branch_sha(self, branch):
+    def _create_project_card(self, column_id, note):
-            url = f"{self.base_url}/repos/{self.repo}/git/refs/heads/{branch}"
+        url = f"{self.base_url}/projects/columns/{column_id}/cards"
-            response = requests.get(url, headers=self.headers)
+        data = {"note": note}
-            if response.status_code == 200:
+        response = requests.post(url, headers=self.headers, json=data)
-                return response.json()["object"]["sha"]
+        if response.status_code == 201:
+            card = response.json()
+            success_message = f"Card created successfully in column {column_id}."
+            self.logger.info(success_message)
+            return success_message
         else:
-                return f"Error getting branch SHA: {response.status_code}"
+            error_message = f"Error creating project card: {response.status_code}"
-
-    @metrics.measure
-    def _list_files(self, path):
-        self.logger.info(f"Listing files in: {path} on branch: {self.current_branch}")
-        url = f"{self.base_url}/repos/{self.repo}/contents/{path}"
-        response = requests.get(url, headers=self.headers, params={"ref": self.current_branch})
-        if response.status_code == 200:
-            files = [item["name"] for item in response.json() if item["type"] == "file"]
-            directories = [item["name"] for item in response.json() if item["type"] == "dir"]
-            self.logger.info(f"Successfully listed files and directories in {path}")
-            return {"files": files, "directories": directories}
-        else:
-            error_message = f"Error listing files: {response.status_code}"
             self.logger.error(error_message)
             return error_message
 
     @metrics.measure
-    def _search_code(self, query):
+    def _move_project_card(self, card_id, position, column_id):
-        self.logger.info(f"Searching code with query: {query}")
+        url = f"{self.base_url}/projects/columns/cards/{card_id}/moves"
-        url = f"{self.base_url}/search/code"
+        data = {"position": position, "column_id": column_id}
-        params = {
+        response = requests.post(url, headers=self.headers, json=data)
-            "q": f"{query} repo:{self.repo}",
+        if response.status_code == 201:
-            "per_page": 10
+            success_message = f"Card {card_id} moved successfully."
-        }
+            self.logger.info(success_message)
-        response = requests.get(url, headers=self.headers, params=params)
+            return success_message
-        if response.status_code == 200:
-            results = [{"file": item["path"], "url": item["html_url"]} for item in response.json()["items"]]
-            self.logger.info(f"Successfully searched code. Found {len(results)} results.")
-            return results
         else:
-            error_message = f"Error searching code: {response.status_code}"
+            error_message = f"Error moving project card: {response.status_code}"
+            self.logger.error(error_message)
+            return error_message
+
+    @metrics.measure
+    def _link_issue_to_project_card(self, card_id, content_id, content_type):
+        url = f"{self.base_url}/projects/columns/cards/{card_id}"
+        data = {"content_id": content_id, "content_type": content_type}
+        response = requests.patch(url, headers=self.headers, json=data)
+        if response.status_code == 200:
+            success_message = f"Issue/PR linked to card {card_id} successfully."
+            self.logger.info(success_message)
+            return success_message
+        else:
+            error_message = f"Error linking issue/PR to project card: {response.status_code}"
             self.logger.error(error_message)
             return error_message
 
@@ -606,10 +636,7 @@ class GitHubTool(BaseTool):
     def _get_commit_history(self, file_path, num_commits):
         self.logger.info(f"Getting commit history for file: {file_path}, number of commits: {num_commits}")
         url = f"{self.base_url}/repos/{self.repo}/commits"
-        params = {
+        params = {"path": file_path, "per_page": num_commits}
-            "path": file_path,
-            "per_page": num_commits
-        }
         response = requests.get(url, headers=self.headers, params=params)
         if response.status_code == 200:
             commits = [{"sha": commit["sha"], "message": commit["commit"]["message"], "date": commit["commit"]["author"]["date"]} for commit in response.json()]
@@ -680,9 +707,7 @@ class GitHubTool(BaseTool):
     def _approve_pull_request(self, pull_number):
         self.logger.info(f"Approving pull request: {pull_number}")
         url = f"{self.base_url}/repos/{self.repo}/pulls/{pull_number}/reviews"
-        data = {
+        data = {"event": "APPROVE"}
-            "event": "APPROVE"
-        }
         response = requests.post(url, headers=self.headers, json=data)
         if response.status_code == 200:
             success_message = f"Pull request {pull_number} approved successfully"
@@ -697,9 +722,7 @@ class GitHubTool(BaseTool):
     def _close_pull_request(self, pull_number):
         self.logger.info(f"Closing pull request: {pull_number}")
         url = f"{self.base_url}/repos/{self.repo}/pulls/{pull_number}"
-        data = {
+        data = {"state": "closed"}
-            "state": "closed"
-        }
         response = requests.patch(url, headers=self.headers, json=data)
         if response.status_code == 200:
             success_message = f"Pull request {pull_number} closed successfully"
@@ -714,11 +737,7 @@ class GitHubTool(BaseTool):
     def _merge_pull_request(self, pull_number, commit_title, commit_message, merge_method):
         self.logger.info(f"Merging pull request: {pull_number}")
         url = f"{self.base_url}/repos/{self.repo}/pulls/{pull_number}/merge"
-        data = {
+        data = {"commit_title": commit_title, "commit_message": commit_message, "merge_method": merge_method}
-            "commit_title": commit_title,
-            "commit_message": commit_message,
-            "merge_method": merge_method
-        }
         response = requests.put(url, headers=self.headers, json=data)
         if response.status_code == 200:
             success_message = f"Pull request {pull_number} merged successfully"
@@ -771,10 +790,7 @@ class GitHubTool(BaseTool):
     def _create_issue(self, title, body, labels=None):
         self.logger.info(f"Creating issue: {title}")
         url = f"{self.base_url}/repos/{self.repo}/issues"
-        data = {
+        data = {"title": title, "body": body}
-            "title": title,
-            "body": body
-        }
         if labels:
             data["labels"] = labels
         response = requests.post(url, headers=self.headers, json=data)
@@ -792,20 +808,10 @@ class GitHubTool(BaseTool):
     def _list_issues(self, state="open", per_page=30, page=1):
         self.logger.info(f"Listing issues. State: {state}, Per page: {per_page}, Page: {page}")
         url = f"{self.base_url}/repos/{self.repo}/issues"
-        params = {
+        params = {"state": state, "per_page": per_page, "page": page}
-            "state": state,
-            "per_page": per_page,
-            "page": page
-        }
         response = requests.get(url, headers=self.headers, params=params)
         if response.status_code == 200:
-            issues = [{
+            issues = [{"number": issue["number"], "title": issue["title"], "state": issue["state"], "created_at": issue["created_at"], "url": issue["html_url"]} for issue in response.json()]
-                "number": issue["number"],
-                "title": issue["title"],
-                "state": issue["state"],
-                "created_at": issue["created_at"],
-                "url": issue["html_url"]
-            } for issue in response.json()]
             self.logger.info(f"Successfully listed issues. Found {len(issues)} issues.")
             return issues
         else:
@@ -817,9 +823,7 @@ class GitHubTool(BaseTool):
     def _add_issue_comment(self, issue_number, comment):
         self.logger.info(f"Adding comment to issue: {issue_number}")
         url = f"{self.base_url}/repos/{self.repo}/issues/{issue_number}/comments"
-        data = {
+        data = {"body": comment}
-            "body": comment
-        }
         response = requests.post(url, headers=self.headers, json=data)
         if response.status_code == 201:
             comment_data = response.json()
@@ -837,13 +841,7 @@ class GitHubTool(BaseTool):
         url = f"{self.base_url}/repos/{self.repo}/issues/{issue_number}/comments"
         response = requests.get(url, headers=self.headers)
         if response.status_code == 200:
-            comments = [{
+            comments = [{"id": comment["id"], "user": comment["user"]["login"], "body": comment["body"], "created_at": comment["created_at"], "updated_at": comment["updated_at"]} for comment in response.json()]
-                "id": comment["id"],
-                "user": comment["user"]["login"],
-                "body": comment["body"],
-                "created_at": comment["created_at"],
-                "updated_at": comment["updated_at"]
-            } for comment in response.json()]
             self.logger.info(f"Successfully retrieved comments for issue {issue_number}. Found {len(comments)} comments.")
             return comments
         else: