alita-sdk 0.3.151__py3-none-any.whl → 0.3.152__py3-none-any.whl

alita_sdk/tools/github/github_client.py

@@ -3,7 +3,7 @@ import re
 import fnmatch
 import tiktoken
 from datetime import datetime
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -36,6 +36,8 @@ from .schemas import (
     UpdateIssue,
     LoaderSchema,
     GetCommits,
+    GetCommitChanges,
+    ApplyGitPatch,
     TriggerWorkflow,
     GetWorkflowStatus,
     GetWorkflowLogs,
@@ -277,6 +279,7 @@ class GitHubClient(BaseModel):
             until: Optional[str] = None,
             author: Optional[str] = None,
             repo_name: Optional[str] = None,
+            max_count: Optional[int] = 30,
     ) -> str:
         """
         Retrieves a list of commits from the repository.
@@ -288,6 +291,7 @@ class GitHubClient(BaseModel):
             until (Optional[str]): Only commits before this date (ISO format) will be returned.
             author (Optional[str]): The author of the commits.
             repo_name (Optional[str]): Name of the repository in format 'owner/repo'.
+            max_count (Optional[int]): Maximum number of commits to return (default: 30).
 
         Returns:
             str: A list of commit data or an error message.
@@ -309,16 +313,20 @@ class GitHubClient(BaseModel):
             commits = repo.get_commits(**params)
 
             # Convert the commits to a list of dictionaries for easier processing
-            commit_list = [
-                {
+            # Limit the number of commits based on max_count
+            commit_list = []
+            count = 0
+            for commit in commits:
+                if count >= max_count:
+                    break
+                commit_list.append({
                     "sha": commit.sha,
                     "author": commit.commit.author.name,
                     "date": commit.commit.author.date.isoformat(),
                     "message": commit.commit.message,
                     "url": commit.html_url,
-                }
-                for commit in commits
-            ]
+                })
+                count += 1
 
             return commit_list
 
@@ -326,6 +334,440 @@ class GitHubClient(BaseModel):
             # Return error as JSON instead of plain text
             return {"error": str(e), "message": f"Unable to retrieve commits due to error: {str(e)}"}
 
+    def get_commit_changes(self, sha: str, repo_name: Optional[str] = None) -> str:
+        """
+        Retrieves the files changed in a specific commit.
+
+        Parameters:
+            sha (str): The commit SHA to get changed files for.
+            repo_name (Optional[str]): Name of the repository in format 'owner/repo'.
+
+        Returns:
+            str: A list of changed files with their status and changes or an error message.
+        """
+        try:
+            # Get the repository
+            repo = self.github_api.get_repo(repo_name) if repo_name else self.github_repo_instance
+            
+            # Get the specific commit
+            commit = repo.get_commit(sha)
+            
+            # Extract changed files information
+            changed_files = []
+            for file in commit.files:
+                file_info = {
+                    "filename": file.filename,
+                    "status": file.status,  # added, modified, removed, renamed
+                    "additions": file.additions,
+                    "deletions": file.deletions,
+                    "changes": file.changes,
+                    "patch": file.patch if hasattr(file, 'patch') and file.patch else None,
+                    "blob_url": file.blob_url if hasattr(file, 'blob_url') else None,
+                    "raw_url": file.raw_url if hasattr(file, 'raw_url') else None
+                }
+                
+                # Add previous filename for renamed files
+                if file.status == "renamed" and hasattr(file, 'previous_filename'):
+                    file_info["previous_filename"] = file.previous_filename
+                    
+                changed_files.append(file_info)
+            
+            result = {
+                "commit_sha": commit.sha,
+                "commit_message": commit.commit.message,
+                "author": commit.commit.author.name,
+                "date": commit.commit.author.date.isoformat(),
+                "total_files_changed": len(changed_files),
+                "total_additions": sum(f["additions"] for f in changed_files),
+                "total_deletions": sum(f["deletions"] for f in changed_files),
+                "files": changed_files
+            }
+            
+            return result
+
+        except Exception as e:
+            # Return error as JSON instead of plain text
+            return {"error": str(e), "message": f"Unable to retrieve commit changes due to error: {str(e)}"}
+
+    def apply_git_patch(self, patch_content: str, commit_message: Optional[str] = "Apply git patch", repo_name: Optional[str] = None) -> str:
+        """
+        Applies a git patch to the repository by parsing the unified diff format and updating files accordingly.
+
+        Parameters:
+            patch_content (str): The git patch content in unified diff format
+            commit_message (Optional[str]): Commit message for the patch application
+            repo_name (Optional[str]): Name of the repository in format 'owner/repo'
+
+        Returns:
+            str: A summary of applied changes or error message
+        """
+        import re
+        
+        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:
+                return {
+                    "error": "Cannot apply patch",
+                    "message": f"You're attempting to commit directly to the {self.github_base_branch} branch, which is protected. Please create a new branch and try again."
+                }
+
+            # Parse the patch content to extract file changes
+            changes = self._parse_git_patch(patch_content)
+            
+            if not changes:
+                return {
+                    "error": "No valid changes found",
+                    "message": "The patch content does not contain any valid file changes."
+                }
+
+            applied_changes = []
+            failed_changes = []
+
+            for change in changes:
+                try:
+                    if change['operation'] == 'create':
+                        # Create new file
+                        repo.create_file(
+                            path=change['file_path'],
+                            message=f"{commit_message} - Create {change['file_path']}",
+                            content=change['new_content'],
+                            branch=branch
+                        )
+                        applied_changes.append(f"Created: {change['file_path']}")
+
+                    elif change['operation'] == 'delete':
+                        # Delete file
+                        try:
+                            file = repo.get_contents(change['file_path'], ref=branch)
+                            repo.delete_file(
+                                path=change['file_path'],
+                                message=f"{commit_message} - Delete {change['file_path']}",
+                                sha=file.sha,
+                                branch=branch
+                            )
+                            applied_changes.append(f"Deleted: {change['file_path']}")
+                        except Exception:
+                            failed_changes.append(f"Failed to delete {change['file_path']} - file not found")
+
+                    elif change['operation'] == 'modify':
+                        # Modify existing file
+                        try:
+                            file = repo.get_contents(change['file_path'], ref=branch)
+                            current_content = file.decoded_content.decode("utf-8")
+                            
+                            # Apply the patch changes
+                            new_content = self._apply_patch_to_content(current_content, change['hunks'])
+                            
+                            if new_content != current_content:
+                                repo.update_file(
+                                    path=change['file_path'],
+                                    message=f"{commit_message} - Update {change['file_path']}",
+                                    content=new_content,
+                                    sha=file.sha,
+                                    branch=branch
+                                )
+                                applied_changes.append(f"Modified: {change['file_path']}")
+                            else:
+                                failed_changes.append(f"No changes applied to {change['file_path']} - patch may not match current content")
+                        except Exception as e:
+                            failed_changes.append(f"Failed to modify {change['file_path']}: {str(e)}")
+
+                    elif change['operation'] == 'rename':
+                        # Handle file rename (delete old, create new)
+                        try:
+                            # Delete old file
+                            old_file = repo.get_contents(change['old_file_path'], ref=branch)
+                            old_content = old_file.decoded_content.decode("utf-8")
+                            
+                            # Apply changes to content if there are any
+                            if change.get('hunks'):
+                                new_content = self._apply_patch_to_content(old_content, change['hunks'])
+                            else:
+                                new_content = old_content
+                            
+                            # Create new file
+                            repo.create_file(
+                                path=change['file_path'],
+                                message=f"{commit_message} - Rename {change['old_file_path']} to {change['file_path']}",
+                                content=new_content,
+                                branch=branch
+                            )
+                            
+                            # Delete old file
+                            repo.delete_file(
+                                path=change['old_file_path'],
+                                message=f"{commit_message} - Remove old file {change['old_file_path']}",
+                                sha=old_file.sha,
+                                branch=branch
+                            )
+                            
+                            applied_changes.append(f"Renamed: {change['old_file_path']} → {change['file_path']}")
+                        except Exception as e:
+                            failed_changes.append(f"Failed to rename {change.get('old_file_path', 'unknown')} to {change['file_path']}: {str(e)}")
+
+                except Exception as e:
+                    failed_changes.append(f"Failed to process {change.get('file_path', 'unknown file')}: {str(e)}")
+
+            # Return summary
+            result = {
+                "success": len(applied_changes) > 0,
+                "applied_changes": applied_changes,
+                "failed_changes": failed_changes,
+                "total_changes": len(changes),
+                "successful_changes": len(applied_changes),
+                "failed_count": len(failed_changes)
+            }
+
+            if failed_changes:
+                result["message"] = f"Patch partially applied. {len(applied_changes)} successful, {len(failed_changes)} failed."
+            else:
+                result["message"] = f"Patch successfully applied. {len(applied_changes)} changes made."
+
+            return result
+
+        except Exception as e:
+            return {
+                "error": str(e),
+                "message": f"Unable to apply git patch due to error: {str(e)}"
+            }
+
+    def _parse_git_patch(self, patch_content: str) -> List[Dict]:
+        """
+        Parse git patch content in unified diff format and extract file changes.
+        
+        Parameters:
+            patch_content (str): The patch content to parse
+            
+        Returns:
+            List[Dict]: List of change dictionaries
+        """
+        import re
+        
+        changes = []
+        lines = patch_content.strip().split('\n')
+        i = 0
+        
+        while i < len(lines):
+            line = lines[i]
+            
+            # Look for diff --git lines
+            if line.startswith('diff --git'):
+                change = self._parse_file_change(lines, i)
+                if change:
+                    changes.append(change)
+                    i = change.get('next_index', i + 1)
+                else:
+                    i += 1
+            else:
+                i += 1
+                
+        return changes
+
+    def _parse_file_change(self, lines: List[str], start_index: int) -> Optional[Dict]:
+        """
+        Parse a single file change from patch lines.
+        
+        Parameters:
+            lines (List[str]): All patch lines
+            start_index (int): Starting index for this file change
+            
+        Returns:
+            Optional[Dict]: Parsed file change or None if invalid
+        """
+        import re
+        
+        if start_index >= len(lines):
+            return None
+            
+        diff_line = lines[start_index]
+        
+        # Extract file paths from diff line
+        match = re.match(r'diff --git a/(.+) b/(.+)', diff_line)
+        if not match:
+            return None
+            
+        old_path = match.group(1)
+        new_path = match.group(2)
+        
+        change = {
+            'old_file_path': old_path,
+            'file_path': new_path,
+            'hunks': [],
+            'next_index': start_index + 1
+        }
+        
+        i = start_index + 1
+        
+        # Process header lines (index, ---, +++, etc.)
+        while i < len(lines):
+            line = lines[i]
+            
+            if line.startswith('new file mode'):
+                change['operation'] = 'create'
+            elif line.startswith('deleted file mode'):
+                change['operation'] = 'delete'
+            elif line.startswith('rename from'):
+                change['operation'] = 'rename'
+            elif line.startswith('index '):
+                pass  # Skip index lines
+            elif line.startswith('--- '):
+                pass  # Skip old file reference
+            elif line.startswith('+++ '):
+                pass  # Skip new file reference
+            elif line.startswith('@@'):
+                # Found a hunk, parse it
+                hunk, next_i = self._parse_hunk(lines, i)
+                if hunk:
+                    change['hunks'].append(hunk)
+                i = next_i
+                continue
+            elif line.startswith('diff --git') or line.startswith('Binary files'):
+                # Start of next file or binary file
+                break
+            elif line.strip() == '':
+                pass  # Skip empty lines
+            else:
+                # Unknown line, continue
+                pass
+                
+            i += 1
+            
+        # Determine operation if not set
+        if 'operation' not in change:
+            if old_path == new_path:
+                change['operation'] = 'modify'
+            else:
+                change['operation'] = 'rename'
+                
+        change['next_index'] = i
+        
+        # For new files, extract content from hunks
+        if change['operation'] == 'create' and change['hunks']:
+            content_lines = []
+            for hunk in change['hunks']:
+                for line in hunk['lines']:
+                    if line.startswith('+') and not line.startswith('+++'):
+                        content_lines.append(line[1:])  # Remove + prefix
+            change['new_content'] = '\n'.join(content_lines)
+            
+        return change
+
+    def _parse_hunk(self, lines: List[str], start_index: int) -> Tuple[Optional[Dict], int]:
+        """
+        Parse a single hunk from patch lines.
+        
+        Parameters:
+            lines (List[str]): All patch lines  
+            start_index (int): Starting index for this hunk
+            
+        Returns:
+            Tuple[Optional[Dict], int]: Parsed hunk and next index
+        """
+        import re
+        
+        if start_index >= len(lines):
+            return None, start_index + 1
+            
+        hunk_header = lines[start_index]
+        
+        # Parse hunk header: @@ -old_start,old_count +new_start,new_count @@
+        match = re.match(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@', hunk_header)
+        if not match:
+            return None, start_index + 1
+            
+        old_start = int(match.group(1))
+        old_count = int(match.group(2)) if match.group(2) else 1
+        new_start = int(match.group(3))
+        new_count = int(match.group(4)) if match.group(4) else 1
+        
+        hunk = {
+            'old_start': old_start,
+            'old_count': old_count,
+            'new_start': new_start,
+            'new_count': new_count,
+            'lines': []
+        }
+        
+        i = start_index + 1
+        
+        # Collect hunk lines
+        while i < len(lines):
+            line = lines[i]
+            
+            if line.startswith('@@') or line.startswith('diff --git') or line.startswith('Binary files'):
+                # Start of next hunk or file
+                break
+            elif line.startswith(' ') or line.startswith('+') or line.startswith('-'):
+                # Context, addition, or deletion line
+                hunk['lines'].append(line)
+            elif line.strip() == '':
+                # Empty line in hunk
+                hunk['lines'].append(line)
+            else:
+                # Unknown line, stop parsing this hunk
+                break
+                
+            i += 1
+            
+        return hunk, i
+
+    def _apply_patch_to_content(self, original_content: str, hunks: List[Dict]) -> str:
+        """
+        Apply patch hunks to original content.
+        
+        Parameters:
+            original_content (str): Original file content
+            hunks (List[Dict]): List of patch hunks
+            
+        Returns:
+            str: Modified content
+        """
+        if not hunks:
+            return original_content
+            
+        lines = original_content.split('\n')
+        result_lines = []
+        
+        # Sort hunks by line number
+        sorted_hunks = sorted(hunks, key=lambda h: h['old_start'])
+        
+        current_line = 0
+        
+        for hunk in sorted_hunks:
+            # Add lines before this hunk
+            while current_line < hunk['old_start'] - 1:
+                if current_line < len(lines):
+                    result_lines.append(lines[current_line])
+                current_line += 1
+                
+            # Apply hunk changes
+            old_line_in_hunk = 0
+            
+            for patch_line in hunk['lines']:
+                if patch_line.startswith(' '):
+                    # Context line - should match original
+                    context_line = patch_line[1:]
+                    if current_line < len(lines):
+                        result_lines.append(lines[current_line])
+                        current_line += 1
+                    old_line_in_hunk += 1
+                elif patch_line.startswith('-'):
+                    # Deletion - skip original line
+                    current_line += 1
+                    old_line_in_hunk += 1
+                elif patch_line.startswith('+'):
+                    # Addition - add new line
+                    result_lines.append(patch_line[1:])
+                    
+        # Add remaining lines
+        while current_line < len(lines):
+            result_lines.append(lines[current_line])
+            current_line += 1
+            
+        return '\n'.join(result_lines)
+
     def get_pull_request(self, pr_number: str, repo_name: Optional[str] = None) -> str:
         """
         Fetches information about a specific pull request.
@@ -1453,6 +1895,20 @@ class GitHubClient(BaseModel):
                 "description": self.get_commits.__doc__,
                 "args_schema": GetCommits,
             },
+            {
+                "ref": self.get_commit_changes,
+                "name": "get_commit_changes",
+                "mode": "get_commit_changes",
+                "description": self.get_commit_changes.__doc__,
+                "args_schema": GetCommitChanges,
+            },
+            {
+                "ref": self.apply_git_patch,
+                "name": "apply_git_patch",
+                "mode": "apply_git_patch",
+                "description": self.apply_git_patch.__doc__,
+                "args_schema": ApplyGitPatch,
+            },
             {
                 "ref": self.trigger_workflow,
                 "name": "trigger_workflow",

alita_sdk/tools/github/schemas.py

@@ -149,7 +149,21 @@ GetCommits = create_model(
     path=(Optional[str], Field(description="The file path to filter commits by", default=None)),
     since=(Optional[str], Field(description="Only commits after this date will be returned (ISO format)", default=None)),
     until=(Optional[str], Field(description="Only commits before this date will be returned (ISO format)", default=None)),
-    author=(Optional[str], Field(description="The author of the commits", default=None))
+    author=(Optional[str], Field(description="The author of the commits", default=None)),
+    max_count=(Optional[int], Field(description="Maximum number of commits to return (default: 30)", default=30))
+)
+
+GetCommitChanges = create_model(
+    "GetCommitChanges",
+    sha=(str, Field(description="The commit SHA to get changed files for")),
+    repo_name=(Optional[str], Field(default=None, description="Name of the repository (e.g., 'owner/repo'). If None, uses the default repository."))
+)
+
+ApplyGitPatch = create_model(
+    "ApplyGitPatch",
+    patch_content=(str, Field(description="The git patch content in unified diff format")),
+    commit_message=(Optional[str], Field(description="Commit message for the patch application", default="Apply git patch")),
+    repo_name=(Optional[str], Field(default=None, description="Name of the repository (e.g., 'owner/repo'). If None, uses the default repository."))
 )
 
 TriggerWorkflow = create_model(

{alita_sdk-0.3.151.dist-info → alita_sdk-0.3.152.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.151
+Version: 0.3.152
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>
 License-Expression: Apache-2.0
@@ -36,6 +36,7 @@ Requires-Dist: langgraph~=0.2.53; extra == "runtime"
 Requires-Dist: langchain_chroma~=0.2.2; extra == "runtime"
 Requires-Dist: langchain-unstructured~=0.1.6; extra == "runtime"
 Requires-Dist: langchain-postgres~=0.0.13; extra == "runtime"
+Requires-Dist: langmem==0.0.27; extra == "runtime"
 Requires-Dist: keybert==0.8.3; extra == "runtime"
 Requires-Dist: charset_normalizer==3.3.2; extra == "runtime"
 Requires-Dist: unstructured[local-inference]==0.16.23; extra == "runtime"

{alita_sdk-0.3.151.dist-info → alita_sdk-0.3.152.dist-info}/RECORD

@@ -222,9 +222,9 @@ alita_sdk/tools/figma/__init__.py,sha256=rtEebf9zj1zUD0bpkN-SupaYpjmHFM01gY8XZNE
 alita_sdk/tools/figma/api_wrapper.py,sha256=G96pEp_qUOouwkM5xMqRg-Ywfx_kEey8NV8iO7YLodE,17190
 alita_sdk/tools/github/__init__.py,sha256=s-ejtyNXjQ3Wo-QhLMJkOSab-qY5ZJC6V_df0GuS3ro,6337
 alita_sdk/tools/github/api_wrapper.py,sha256=-98miPAF_JQMIEDT3g8KS6QJ7bHMUSlj4s38zXyFJ2M,8281
-alita_sdk/tools/github/github_client.py,sha256=grUumLCQAdwddy46AyjV9xyhT_Ml8qCjHl2XM4wNFsw,60876
+alita_sdk/tools/github/github_client.py,sha256=bzVXim8U-QH6RzlkAzIUiTrhD4MDi3Xs4pKxVdghvhc,79465
 alita_sdk/tools/github/graphql_client_wrapper.py,sha256=d3AGjzLGH_hdQV2V8HeAX92dJ4dlnE5OXqUlCO_PBr0,71539
-alita_sdk/tools/github/schemas.py,sha256=mlJcz22nsBqS8f3jHIH0b1aE2_TRGoZbR0pmGHlXrvw,12004
+alita_sdk/tools/github/schemas.py,sha256=6BAzeGaXkyS-rde2gJDi3xqic161de1PBh-CrlOgK_4,12826
 alita_sdk/tools/github/tool.py,sha256=Jnnv5lenV5ds8AAdyo2m8hSzyJ117HZBjzHC6T1ck-M,1037
 alita_sdk/tools/github/tool_prompts.py,sha256=y6ZW_FpUCE87Uop3WuQAZVRnzxO5t7xjBOI5bCqiluw,30194
 alita_sdk/tools/gitlab/__init__.py,sha256=_nbp3tJviTZxfewyV3Hp9-TK1vCxTmqlxhpwv0f_x4Y,3602
@@ -316,8 +316,8 @@ alita_sdk/tools/zephyr_enterprise/api_wrapper.py,sha256=Ir3zHljhbZQJRJJQOBzS_GL5
 alita_sdk/tools/zephyr_enterprise/zephyr_enterprise.py,sha256=hV9LIrYfJT6oYp-ZfQR0YHflqBFPsUw2Oc55HwK0H48,6809
 alita_sdk/tools/zephyr_scale/__init__.py,sha256=2NTcdrfkx4GSegqyXhsPLsEpc4FlACuDy85b0fk6cAo,4572
 alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=UHVQUVqcBc3SZvDfO78HSuBzwAsRw2cCDQa-xMOzndE,68663
-alita_sdk-0.3.151.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.151.dist-info/METADATA,sha256=mIKo2a6juzMZODMG2UJ_l_UYOxalaJy6wlaoqgnp2_M,18667
-alita_sdk-0.3.151.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.151.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.151.dist-info/RECORD,,
+alita_sdk-0.3.152.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.152.dist-info/METADATA,sha256=N57N-leEOD5Y6R5M1dIJAdWbwWV45N8S0dHUSmGSJYM,18718
+alita_sdk-0.3.152.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.152.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.152.dist-info/RECORD,,