alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/tools/github/__init__.py

@@ -7,13 +7,14 @@ from .api_wrapper import AlitaGitHubAPIWrapper
 from .tool import GitHubAction
 from ..elitea_base import filter_missconfigured_index_tools
 
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.github import GithubConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "github"
 
-def _get_toolkit(tool) -> BaseToolkit:
+def get_toolkit(tool) -> BaseToolkit:
     return AlitaGitHubToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         github_base_url=tool['settings'].get('base_url', ''),
@@ -31,21 +32,16 @@ def _get_toolkit(tool) -> BaseToolkit:
         toolkit_name=tool.get('toolkit_name')
     )
 
-def get_toolkit():
-    return AlitaGitHubToolkit.toolkit_config_schema()
-
 def get_tools(tool):
-    return _get_toolkit(tool).get_tools()
+    return get_toolkit(tool).get_tools()
 
 class AlitaGitHubToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           AlitaGitHubAPIWrapper.model_construct().get_available_tools()}
-        AlitaGitHubToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
             __config__=ConfigDict(
@@ -62,8 +58,7 @@ class AlitaGitHubToolkit(BaseToolkit):
                                                              json_schema_extra={'configuration_types': ['github']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector configuration", default=None,
                                                                      json_schema_extra={'configuration_types': ['pgvector']})),
-            repository=(str, Field(description="Github repository", json_schema_extra={'toolkit_name': True,
-                                                                                       'max_toolkit_length': AlitaGitHubToolkit.toolkit_max_length})),
+            repository=(str, Field(description="Github repository")),
             active_branch=(Optional[str], Field(description="Active branch", default="main")),
             base_branch=(Optional[str], Field(description="Github Base branch", default="main")),
             # embedder settings
@@ -87,18 +82,22 @@ class AlitaGitHubToolkit(BaseToolkit):
         github_api_wrapper = AlitaGitHubAPIWrapper(**wrapper_payload)
         available_tools: List[Dict] = github_api_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, AlitaGitHubToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = f"Repository: {github_api_wrapper.github_repository}\n{description}"
+            description = description[:1000]
             tools.append(GitHubAction(
                 api_wrapper=github_api_wrapper,
-                name=prefix + tool["name"],
+                name=tool["name"],
                 mode=tool["mode"],
-                # set unique description for declared tools to differentiate the same methods for different toolkits
-                description=f"Repository: {github_api_wrapper.github_repository}\n" + tool["description"],
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/github/github_client.py

@@ -11,10 +11,7 @@ from github import Auth, Github, GithubIntegration, Repository
 from github.Consts import DEFAULT_BASE_URL
 from langchain_core.tools import ToolException
 
-from .schemas import (
-    GitHubAuthConfig,
-    GitHubRepoConfig,
-)
+from ..elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
 
 from .schemas import (
     GitHubAuthConfig,
@@ -22,6 +19,7 @@ from .schemas import (
     NoInput,
     BranchName,
     CreateBranchName,
+    DeleteBranchName,
     DirectoryPath,
     ReadFile,
     UpdateFile,
@@ -48,9 +46,9 @@ from .schemas import (
 # Import prompts for tools
 from .tool_prompts import (
     CREATE_FILE_PROMPT,
-    UPDATE_FILE_PROMPT,
     CREATE_ISSUE_PROMPT,
     UPDATE_ISSUE_PROMPT,
+    DELETE_BRANCH_PROMPT,
 )
 
 from langchain_community.tools.github.prompt import (
@@ -71,6 +69,8 @@ from langchain_community.tools.github.prompt import (
     CREATE_PULL_REQUEST_PROMPT
 )
 
+from ..utils.tool_prompts import EDIT_FILE_DESCRIPTION
+
 
 class GitHubClient(BaseModel):
     """Client for interacting with the GitHub REST API."""
@@ -94,6 +94,12 @@ class GitHubClient(BaseModel):
     
     # Alita instance
     alita: Optional[Any] = Field(default=None, exclude=True)
+    
+    # Import file operation methods from BaseCodeToolApiWrapper
+    read_file_chunk = BaseCodeToolApiWrapper.read_file_chunk
+    read_multiple_files = BaseCodeToolApiWrapper.read_multiple_files
+    search_file = BaseCodeToolApiWrapper.search_file
+    edit_file = BaseCodeToolApiWrapper.edit_file
 
     @property
     def github_repo_instance(self) -> Optional[Repository.Repository]:
@@ -408,26 +414,53 @@ class GitHubClient(BaseModel):
         Returns:
             str: A detailed diff comparison between the two commits or an error message.
         """
+        def safe_author_info(commit_obj):
+            """Safely extract author info from a commit object, handling None values."""
+            author = commit_obj.commit.author
+            if author:
+                return {
+                    "name": author.name or "Unknown",
+                    "date": author.date.isoformat() if author.date else None
+                }
+            # Fallback to GitHub user info if git author is not available
+            elif commit_obj.author:
+                return {
+                    "name": commit_obj.author.login,
+                    "date": None
+                }
+            return {"name": "Unknown", "date": None}
+
         try:
             # Get the repository
             repo = self.github_api.get_repo(repo_name) if repo_name else self.github_repo_instance
-            
+
             # Get the comparison between the two commits
             comparison = repo.compare(base_sha, head_sha)
-            
+
+            # Get head commit - the GitHub Compare API doesn't return head_commit,
+            # so we get it from the commits list or fetch it directly
+            if comparison.commits:
+                head_commit_obj = comparison.commits[-1]
+            else:
+                # For identical commits or edge cases, fetch head commit directly
+                head_commit_obj = repo.get_commit(head_sha)
+
+            base_author = safe_author_info(comparison.base_commit)
+            head_author = safe_author_info(head_commit_obj)
+
             # Extract comparison information
             diff_info = {
                 "base_commit": {
                     "sha": comparison.base_commit.sha,
                     "message": comparison.base_commit.commit.message,
-                    "author": comparison.base_commit.commit.author.name,
-                    "date": comparison.base_commit.commit.author.date.isoformat()
+                    "author": base_author["name"],
+                    "date": base_author["date"]
                 },
                 "head_commit": {
-                    "sha": comparison.head_commit.sha,
-                    "message": comparison.head_commit.commit.message,
-                    "author": comparison.head_commit.commit.author.name,
-                    "date": comparison.head_commit.commit.author.date.isoformat()
+                    "sha": head_commit_obj.sha,
+                    "message": head_commit_obj.commit.message,
+                    "author": head_author["name"],
+                    "date": head_author["date"]
                 },
                 "status": comparison.status,  # ahead, behind, identical, or diverged
                 "ahead_by": comparison.ahead_by,
@@ -436,14 +469,15 @@ class GitHubClient(BaseModel):
                 "commits": [],
                 "files": []
             }
-            
+
             # Get commits in the comparison
             for commit in comparison.commits:
+                author_info = safe_author_info(commit)
                 commit_info = {
                     "sha": commit.sha,
                     "message": commit.commit.message,
-                    "author": commit.commit.author.name,
-                    "date": commit.commit.author.date.isoformat(),
+                    "author": author_info["name"],
+                    "date": author_info["date"],
                     "url": commit.html_url
                 }
                 diff_info["commits"].append(commit_info)
@@ -1048,6 +1082,73 @@ class GitHubClient(BaseModel):
         except Exception as e:
             return f"Failed to create branch: {str(e)}"
 
+    def delete_branch(self, branch_name: str, force: bool = False) -> str:
+        """
+        Delete a branch from the GitHub repository.
+
+        Protected branches that cannot be deleted:
+        - 'main' and 'master' branches are always protected
+        - The configured base branch (github_base_branch) is protected
+        - The currently active branch is protected (unless force=True)
+
+        Parameters:
+            branch_name (str): Name of the branch to delete
+            force (bool): If True, allows deletion of the current active branch
+
+        Returns:
+            str: A success or error message.
+        """
+        from github import GithubException
+
+        try:
+            # Protected branch names that should never be deleted
+            protected_branches = {'main', 'master'}
+
+            # Add base branch to protected list
+            if self.github_base_branch:
+                protected_branches.add(self.github_base_branch)
+
+            # Check if trying to delete a protected branch
+            if branch_name.lower() in {b.lower() for b in protected_branches}:
+                return (
+                    f"Cannot delete branch '{branch_name}': "
+                    f"It is a protected branch (main, master, or base branch). "
+                    f"Protected branches: {', '.join(sorted(protected_branches))}"
+                )
+
+            # Check if trying to delete the active branch without force
+            if branch_name == self.active_branch and not force:
+                return (
+                    f"Cannot delete branch '{branch_name}': "
+                    f"It is currently the active branch. "
+                    f"Use force=True to delete it anyway, or switch to a different branch first."
+                )
+
+            # Delete the branch
+            repo = self.github_repo_instance
+            ref = repo.get_git_ref(f"heads/{branch_name}")
+            ref.delete()
+
+            # If we deleted the active branch, reset to base branch
+            if branch_name == self.active_branch:
+                self.active_branch = self.github_base_branch
+                return (
+                    f"Branch '{branch_name}' deleted successfully. "
+                    f"Active branch has been reset to '{self.github_base_branch}'."
+                )
+
+            return f"Branch '{branch_name}' deleted successfully."
+
+        except GithubException as e:
+            if e.status == 422:
+                return f"Cannot delete branch '{branch_name}': {e.data.get('message', str(e))}"
+            elif e.status == 404:
+                return f"Branch '{branch_name}' not found in the repository."
+            else:
+                return f"Failed to delete branch '{branch_name}': {str(e)}"
+        except Exception as e:
+            return f"Failed to delete branch '{branch_name}': {str(e)}"
+
     def create_file(self, file_path: str, file_contents: str, repo_name: Optional[str] = None) -> str:
         """
         Creates a new file on the GitHub repo
@@ -1087,65 +1188,12 @@ class GitHubClient(BaseModel):
         except Exception as e:
             return f"Unable to create file due to error:\n{str(e)}"
 
-    def extract_old_new_pairs(self, file_query):
-        # Split the file content by lines
-        code_lines = file_query.split("\n")
-
-        # Initialize lists to hold the contents of OLD and NEW sections
-        old_contents = []
-        new_contents = []
-
-        # Initialize variables to track whether the current line is within an OLD or NEW section
-        in_old_section = False
-        in_new_section = False
-
-        # Temporary storage for the current section's content
-        current_section_content = []
-
-        # Iterate through each line in the file content
-        for line in code_lines:
-            # Check for OLD section start
-            if "OLD <<<" in line:
-                in_old_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for OLD section end
-            if ">>>> OLD" in line:
-                in_old_section = False
-                old_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section start
-            if "NEW <<<" in line:
-                in_new_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section end
-            if ">>>> NEW" in line:
-                in_new_section = False
-                new_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # If currently in an OLD or NEW section, add the line to the current section content
-            if in_old_section or in_new_section:
-                current_section_content.append(line)
-
-        # Pair the OLD and NEW contents
-        paired_contents = list(zip(old_contents, new_contents))
-
-        return paired_contents
-
     def update_file(self, file_query: str, repo_name: Optional[str] = None, commit_message: Optional[str] = None) -> str:
-        """
-        Updates a file with new content.
+        """Updates a file with new content using OLD/NEW markers and edit_file.
+
         Parameters:
-            file_query(str): Contains the file path and the file contents.
-                The old file contents is wrapped in OLD <<<< and >>>> OLD
-                The new file contents is wrapped in NEW <<<< and >>>> NEW
+            file_query(str): Contains the file path on the first line and the file contents
+                wrapped in OLD <<<< and >>>> OLD / NEW <<<< and >>>> NEW markers.
                 For example:
                 /test/hello.txt
                 OLD <<<<
@@ -1154,13 +1202,13 @@ class GitHubClient(BaseModel):
                 NEW <<<<
                 Hello Mars!
                 >>>> NEW
-            repo_name (Optional[str]): Name of the repository in format 'owner/repo'
+            repo_name (Optional[str]): Name of the repository in format 'owner/repo'. Currently
+                not used by edit_file and must refer to the initialized repository.
 
         Returns:
             A success or failure message
         """
         try:
-            repo = self.github_api.get_repo(repo_name) if repo_name else self.github_repo_instance
             branch = self.active_branch
 
             if branch == self.github_base_branch:
@@ -1169,29 +1217,36 @@ class GitHubClient(BaseModel):
                     "which is protected. Please create a new branch and try again."
                 )
 
-            file_path: str = file_query.split("\n")[0]
-
-            file_content = self._read_file(file_path, branch, repo_name)
-            updated_file_content = file_content
-            for old, new in self.extract_old_new_pairs(file_query):
-                if not old.strip():
-                    continue
-                updated_file_content = updated_file_content.replace(old, new)
-
-            if file_content == updated_file_content:
+            # Split into lines and find first non-empty line for file_path
+            lines = file_query.split("\n")
+            first_non_empty_idx = None
+            for i, line in enumerate(lines):
+                if line.strip():
+                    first_non_empty_idx = i
+                    break
+            
+            if first_non_empty_idx is None:
                 return (
-                    "File content was not updated because old content was not found or empty. "
-                    "It may be helpful to use the read_file action to get the current file contents."
+                    "Invalid file_query format. Expected first non-empty line to be the file path "
+                    "followed by OLD/NEW blocks."
                 )
 
-            repo.update_file(
-                path=file_path,
-                message=commit_message if commit_message else f"Update {file_path}",
-                content=updated_file_content,
-                branch=branch,
-                sha=repo.get_contents(file_path, ref=branch).sha,
-            )
-            return f"Updated file {file_path}"
+            file_path = lines[first_non_empty_idx].strip()
+            # Keep all lines after file_path line (preserving empty lines)
+            edit_content = "\n".join(lines[first_non_empty_idx + 1:])
+
+            # Set temporary repo override for internal helpers
+            self._tmp_repo_for_edit = repo_name
+            try:
+                return self.edit_file(
+                    file_path=file_path,
+                    file_query=edit_content,
+                    branch=branch,
+                    commit_message=commit_message or f"Update {file_path}",
+                )
+            finally:
+                if hasattr(self, "_tmp_repo_for_edit"):
+                    delattr(self, "_tmp_repo_for_edit")
         except Exception as e:
             return f"Unable to update file due to error:\n{str(e)}"
 
@@ -1414,23 +1469,27 @@ class GitHubClient(BaseModel):
         except Exception as e:
             return f"File not found `{file_path}` on branch `{branch}`. Error: {str(e)}"
 
-    def _read_file(self, file_path: str, branch: str, repo_name: Optional[str] = None) -> str:
+    def _read_file(self, file_path: str, branch: str, repo_name: Optional[str] = None, **kwargs) -> str:
         """
-        Read a file from specified branch
+        Read a file from specified branch with optional partial read support.
+        
         Parameters:
             file_path(str): the file path
             branch(str): the branch to read the file from
             repo_name (Optional[str]): Name of the repository in format 'owner/repo'
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
 
         Returns:
             str: The file decoded as a string, or an error message if not found
         """
         try:
-            repo = self.github_api.get_repo(repo_name) if repo_name else self.github_repo_instance
+            # Prefer temporary repo set by update_file, then explicit repo_name
+            effective_repo = getattr(self, "_tmp_repo_for_edit", None) or repo_name
+            repo = self.github_api.get_repo(effective_repo) if effective_repo else self.github_repo_instance
             file = repo.get_contents(file_path, ref=branch)
             return file.decoded_content.decode("utf-8")
         except Exception as e:
-            from traceback import format_exc
             return f"File not found `{file_path}` on branch `{branch}`. Error: {str(e)}"
 
     def read_file(self, file_path: str, branch: Optional[str] = None, repo_name: Optional[str] = None) -> str:
@@ -1445,6 +1504,63 @@ class GitHubClient(BaseModel):
             str: The file contents as a string
         """
         return self._read_file(file_path, branch if branch else self.active_branch, repo_name)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None,
+        repo_name: Optional[str] = None
+    ) -> str:
+        """
+        Write content to a file (create or update).
+        
+        Parameters:
+            file_path: Path to the file
+            content: New file content
+            branch: Branch name (uses active branch if None)
+            commit_message: Commit message
+            repo_name: Name of the repository in format 'owner/repo'
+            
+        Returns:
+            Success message
+        """
+        try:
+            # Prefer temporary repo set by update_file, then explicit repo_name
+            effective_repo = getattr(self, "_tmp_repo_for_edit", None) or repo_name
+            repo = self.github_api.get_repo(effective_repo) if effective_repo else self.github_repo_instance
+            branch = branch or self.active_branch
+            
+            if branch == self.github_base_branch:
+                raise ToolException(
+                    f"Cannot commit directly to the {self.github_base_branch} branch. "
+                    "Please create a new branch and try again."
+                )
+            
+            # Check if file exists
+            try:
+                existing_file = repo.get_contents(file_path, ref=branch)
+                # File exists, update it
+                repo.update_file(
+                    path=file_path,
+                    message=commit_message or f"Update {file_path}",
+                    content=content,
+                    branch=branch,
+                    sha=existing_file.sha,
+                )
+                return f"Updated file {file_path}"
+            except:
+                # File doesn't exist, create it
+                repo.create_file(
+                    path=file_path,
+                    message=commit_message or f"Create {file_path}",
+                    content=content,
+                    branch=branch,
+                )
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def loader(self,
                branch: Optional[str] = None,
@@ -1877,6 +1993,7 @@ class GitHubClient(BaseModel):
             import traceback
             return f"API call failed: {traceback.format_exc()}"
 
+    @extend_with_file_operations
     def get_available_tools(self) -> List[Dict[str, Any]]:
         return [
              {
@@ -1946,7 +2063,7 @@ class GitHubClient(BaseModel):
                 "ref": self.update_file,
                 "name": "update_file",
                 "mode": "update_file",
-                "description": UPDATE_FILE_PROMPT,
+                "description": EDIT_FILE_DESCRIPTION,
                 "args_schema": UpdateFile,
             },
             {
@@ -1991,6 +2108,13 @@ class GitHubClient(BaseModel):
                 "description": CREATE_BRANCH_PROMPT,
                 "args_schema": CreateBranchName,
             },
+            {
+                "ref": self.delete_branch,
+                "name": "delete_branch",
+                "mode": "delete_branch",
+                "description": DELETE_BRANCH_PROMPT,
+                "args_schema": DeleteBranchName,
+            },
             {
                 "ref": self.get_files_from_directory,
                 "name": "get_files_from_directory",