alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/tools/github/__init__.py

@@ -5,14 +5,15 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 
 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
 
 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', ''),
@@ -30,21 +31,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(
@@ -57,12 +53,11 @@ class AlitaGitHubToolkit(BaseToolkit):
                     },
                 }
             ),
-            github_configuration=(Optional[GithubConfiguration], Field(description="Github configuration", default=None,
-                                                                     json_schema_extra={'configuration_types': ['github']})),
+            github_configuration=(GithubConfiguration, Field(description="Github configuration",
+                                                             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
@@ -72,6 +67,7 @@ class AlitaGitHubToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -85,18 +81,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": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/github/api_wrapper.py

@@ -1,9 +1,7 @@
-from typing import Any, Dict, List, Optional, Union, Tuple
 import logging
-import traceback
-import json
-import re
-from pydantic import BaseModel, model_validator, Field, SecretStr
+from typing import Any, Dict, Optional
+
+from pydantic import model_validator, Field, SecretStr
 
 from .github_client import GitHubClient
 from .graphql_client_wrapper import GraphQLClientWrapper
@@ -11,28 +9,17 @@ from .schemas import (
     GitHubAuthConfig,
     GitHubRepoConfig
 )
-
-from ..elitea_base import BaseCodeToolApiWrapper
-
-from langchain_core.callbacks import dispatch_custom_event
+from ..code_indexer_toolkit import CodeIndexerToolkit
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
 
 logger = logging.getLogger(__name__)
 
 # Import prompts for tools
-from .tool_prompts import (
-    UPDATE_FILE_PROMPT,
-    CREATE_ISSUE_PROMPT,
-    UPDATE_ISSUE_PROMPT,
-    CREATE_ISSUE_ON_PROJECT_PROMPT,
-    UPDATE_ISSUE_ON_PROJECT_PROMPT
-)
 
 # Create schema models for the new indexing functionality
-from pydantic import create_model
-from typing import Literal
 
 
-class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
+class AlitaGitHubAPIWrapper(CodeIndexerToolkit):
     """
     Wrapper for GitHub API that integrates both REST and GraphQL functionality.
     """
@@ -117,7 +104,7 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
         if "llm" not in values:
             values["llm"] = None
 
-        return values
+        return super().validate_toolkit(values)
 
     # Expose GitHub REST client methods directly via property
     @property
@@ -131,7 +118,7 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
         """Access to GitHub GraphQL client methods"""
         return self.graphql_client_instance
 
-
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         # this is horrible, I need to think on something better
         if not self.github_client_instance:
@@ -142,12 +129,8 @@ class AlitaGitHubAPIWrapper(BaseCodeToolApiWrapper):
             graphql_tools = GraphQLClientWrapper.model_construct().get_available_tools()
         else:
             graphql_tools = self.graphql_client_instance.get_available_tools()
-            
-        # Add vector search tools from base class (includes index_data + search tools)
-        vector_search_tools = self._get_vector_search_tools()
         
-        tools = github_tools + graphql_tools + vector_search_tools
-        return tools
+        return github_tools + graphql_tools
 
     def _get_files(self, path: str = "", branch: str = None):
         """Get list of files from GitHub repository."""

alita_sdk/tools/github/github_client.py

@@ -11,6 +11,7 @@ from github import Auth, Github, GithubIntegration, Repository
 from github.Consts import DEFAULT_BASE_URL
 from langchain_core.tools import ToolException
 
+from ..elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
 from .schemas import (
     GitHubAuthConfig,
     GitHubRepoConfig,
@@ -87,7 +88,6 @@ class GitHubClient(BaseModel):
 
     # Using optional variables with None defaults instead of PrivateAttr
     github_api: Optional[Github] = Field(default=None, exclude=True)
-    github_repo_instance: Optional[Repository.Repository] = Field(default=None, exclude=True)
 
     # Adding auth config and repo config as optional fields for initialization
     auth_config: Optional[GitHubAuthConfig] = Field(default=None, exclude=True)
@@ -95,6 +95,25 @@ 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]:
+        if not hasattr(self, "_github_repo_instance") or self._github_repo_instance is None:
+            try:
+                if self.github_api and self.github_repository:
+                    self._github_repo_instance = self.github_api.get_repo(self.github_repository)
+                else:
+                    self._github_repo_instance = None
+            except Exception as e:
+                # Only raise when accessed, not during initialization
+                raise ToolException(e)
+        return self._github_repo_instance
 
     @model_validator(mode='before')
     def initialize_github_client(cls, values):
@@ -144,15 +163,6 @@ class GitHubClient(BaseModel):
             else:
                 values["github_api"] = Github(base_url=values["github_base_url"], auth=auth)
 
-            # Get repository instance
-            if values.get("github_repository"):
-                values["github_repo_instance"] = values["github_api"].get_repo(values["github_repository"])
-        else:
-            # Initialize with default authentication if no auth_config provided
-            values["github_api"] = Github(base_url=values.get("github_base_url", DEFAULT_BASE_URL))
-            if values.get("github_repository"):
-                values["github_repo_instance"] = values["github_api"].get_repo(values["github_repository"])
-
         return values
 
     @staticmethod
@@ -1411,13 +1421,16 @@ 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
@@ -1442,6 +1455,61 @@ 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:
+            repo = self.github_api.get_repo(repo_name) if repo_name 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,
@@ -1874,6 +1942,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 [
              {

alita_sdk/tools/github/schemas.py

@@ -119,7 +119,8 @@ LoaderSchema = create_model(
     "LoaderSchema",
     branch=(Optional[str], Field(description="The branch to set as active. If None, the current active branch is used.", default=None)),
     whitelist=(Optional[List[str]], Field(description="A list of file extensions or paths to include. If None, all files are included.", default=None)),
-    blacklist=(Optional[List[str]], Field(description="A list of file extensions or paths to exclude. If None, no files are excluded.", default=None))
+    blacklist=(Optional[List[str]], Field(description="A list of file extensions or paths to exclude. If None, no files are excluded.", default=None)),
+    progress_step=(Optional[int], Field(default=5, ge=0, le=100, description="Optional step size for progress reporting during indexing (0-100)"))
 )
 
 CreateIssueOnProject = create_model(

alita_sdk/tools/github/tool.py

@@ -29,6 +29,10 @@ class GitHubAction(BaseTool):
     ) -> str:
         """Use the GitHub API to run an operation."""
         try:
-            return self.api_wrapper.run(self.mode, *args, **kwargs)
+            # Strip numeric suffix added for deduplication (_2, _3, etc.)
+            # to get the original tool name that exists in the wrapper
+            import re
+            mode = re.sub(r'_\d+$', '', self.mode) if self.mode else self.mode
+            return self.api_wrapper.run(mode, *args, **kwargs)
         except Exception as e:
             return f"Error: {format_exc()}"

alita_sdk/tools/gitlab/__init__.py

@@ -7,17 +7,17 @@ from pydantic import create_model, BaseModel, ConfigDict
 from pydantic.fields import Field
 
 from .api_wrapper import GitLabAPIWrapper
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.gitlab import GitlabConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 
 name = "gitlab"
 
 
-def get_tools(tool):
+def get_toolkit(tool):
     return AlitaGitlabToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        url=tool['settings']['url'],
         repository=tool['settings']['repository'],
         branch=tool['settings']['branch'],
         gitlab_configuration=tool['settings']['gitlab_configuration'],
@@ -30,21 +30,22 @@ def get_tools(tool):
         embedding_model=tool['settings'].get('embedding_model'),
         vectorstore_type="PGVector",
         toolkit_name=tool.get('toolkit_name')
-    ).get_tools()
+    )
+
+def get_tools(tool):
+    return get_toolkit(tool).get_tools()
 
 class AlitaGitlabToolkit(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
                           GitLabAPIWrapper.model_construct().get_available_tools()}
-        AlitaGitlabToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            repository=(str, Field(description="GitLab repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AlitaGitlabToolkit.toolkit_max_length})),
-            gitlab_configuration=(Optional[GitlabConfiguration], Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
+            repository=(str, Field(description="GitLab repository")),
+            gitlab_configuration=(GitlabConfiguration, Field(description="GitLab configuration", json_schema_extra={'configuration_types': ['gitlab']})),
             branch=(str, Field(description="Main branch", default="main")),
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default = None,
@@ -64,6 +65,7 @@ class AlitaGitlabToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -75,19 +77,22 @@ class AlitaGitlabToolkit(BaseToolkit):
             **(kwargs.get('embedding_configuration') or {}),
         }
         gitlab_api_wrapper = GitLabAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools: List[Dict] = gitlab_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
-
+            description = tool["description"] +  f"\nrepo: {gitlab_api_wrapper.repository}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=gitlab_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"] +  f"\nrepo: {gitlab_api_wrapper.repository}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)