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

alita_sdk/tools/gitlab/api_wrapper.py

@@ -2,12 +2,16 @@
 import fnmatch
 from typing import Any, Dict, List, Optional
 
+from gitlab import GitlabGetError
 from langchain_core.tools import ToolException
 from pydantic import create_model, Field, model_validator, SecretStr, PrivateAttr
 
 from ..code_indexer_toolkit import CodeIndexerToolkit
 from ..utils.available_tools_decorator import extend_with_parent_available_tools
+from ..elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
 from ..utils.content_parser import parse_file_content
+from .utils import get_position
+from ..utils.tool_prompts import EDIT_FILE_DESCRIPTION, UPDATE_FILE_PROMPT_WITH_PATH
 
 AppendFileModel = create_model(
     "AppendFileModel",
@@ -19,7 +23,7 @@ DeleteFileModel = create_model(
     "DeleteFileModel",
     file_path=(str, Field(description="The path of the file")),
     branch=(str, Field(description="The branch to delete the file from")),
-    commit_message=(str, Field(default=None, description="Commit message for deleting the file. Optional.")),
+    commit_message=(Optional[str], Field(default=None, description="Commit message for deleting the file. Optional.")),
 )
 CreateFileModel = create_model(
     "CreateFileModel",
@@ -34,7 +38,7 @@ ReadFileModel = create_model(
 )
 UpdateFileModel = create_model(
     "UpdateFileModel",
-    file_query=(str, Field(description="The file query string")),
+    file_query=(str, Field(description=UPDATE_FILE_PROMPT_WITH_PATH)),
     branch=(str, Field(description="The branch to update the file in")),
 )
 CommentOnIssueModel = create_model(
@@ -51,6 +55,11 @@ CreatePullRequestModel = create_model(
     pr_body=(str, Field(description="The body of the pull request")),
     branch=(str, Field(description="The branch to create the pull request from")),
 )
+CommentOnPRModel = create_model(
+    "CommentOnPRModel",
+    pr_number=(int, Field(description="The number of the pull request/merge request")),
+    comment=(str, Field(description="The comment text to add")),
+)
 
 CreateBranchModel = create_model(
     "CreateBranchModel",
@@ -58,7 +67,7 @@ CreateBranchModel = create_model(
 )
 ListBranchesInRepoModel = create_model(
     "ListBranchesInRepoModel",
-    limit=(Optional[int], Field(default=20, description="Maximum number of branches to return. If not provided, all branches will be returned.")),
+    limit=(Optional[int], Field(default=20, description="Maximum number of branches to return. If not provided, all branches will be returned.", gt=0)),
     branch_wildcard=(Optional[str], Field(default=None, description="Wildcard pattern to filter branches by name. If not provided, all branches will be returned."))
 
 )
@@ -89,9 +98,9 @@ GetPRChangesModel = create_model(
 CreatePRChangeCommentModel = create_model(
     "CreatePRChangeCommentModel",
     pr_number=(int, Field(description="GitLab Merge Request (Pull Request) number")),
-    file_path=(str, Field(description="File path of the changed file")),
-    line_number=(int, Field(description="Line number from the diff for a changed file")),
-    comment=(str, Field(description="Comment content")),
+    file_path=(str, Field(description="File path of the changed file as shown in the diff")),
+    line_number=(int, Field(description="Line index (0-based) from the diff output. Use get_pr_changes first to see the diff and identify the correct line index to comment on.")),
+    comment=(str, Field(description="Comment content to add to the specific line")),
 )
 GetCommitsModel = create_model(
     "GetCommitsModel",
@@ -109,6 +118,12 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
     branch: Optional[str] = 'main'
     _git: Any = PrivateAttr()
     _active_branch: Any = PrivateAttr()
+    
+    # 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
 
     @staticmethod
     def _sanitize_url(url: str) -> str:
@@ -117,7 +132,11 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
 
     @model_validator(mode='before')
     @classmethod
-    def validate_toolkit(cls, values: Dict) -> Dict:
+    def validate_toolkit_before(cls, values: Dict) -> Dict:
+        return super().validate_toolkit(values)
+
+    @model_validator(mode='after')
+    def validate_toolkit(self):
         try:
            import gitlab
         except ImportError:
@@ -125,17 +144,17 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
                 "python-gitlab is not installed. "
                 "Please install it with `pip install python-gitlab`"
             )
-        values['repository'] = cls._sanitize_url(values['repository'])
+        self.repository = self._sanitize_url(self.repository)
         g = gitlab.Gitlab(
-            url=cls._sanitize_url(values['url']),
-            private_token=values['private_token'],
+            url=self._sanitize_url(self.url),
+            private_token=self.private_token.get_secret_value(),
             keep_base_url=True,
         )
 
         g.auth()
-        cls._git = g
-        cls._active_branch = values.get('branch')
-        return super().validate_toolkit(values)
+        self._git = g
+        self._active_branch = self.branch
+        return self
 
     @property
     def repo_instance(self):
@@ -211,8 +230,22 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
         except Exception as e:
             return f"Unable to get commit hash for {file_path} due to error:\n{e}"
 
-    def _read_file(self, file_path: str, branch: str):
-        return self.read_file(file_path, branch)
+    def _read_file(self, file_path: str, branch: str, **kwargs):
+        """
+        Read a file from specified branch with optional partial read support.
+        
+        Parameters:
+            file_path: the file path
+            branch: the branch to read the file from
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
+        
+        Returns:
+            File content as string
+        """
+        # Default to active branch if branch is None, consistent with other methods
+        branch = branch if branch else self._active_branch
+        return str(self.read_file(file_path, branch))
 
     def create_branch(self, branch_name: str) -> str:
         try:
@@ -299,7 +332,30 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
         except Exception as e:
             return "Unable to make comment due to error:\n" + str(e)
 
+    def comment_on_pr(self, pr_number: int, comment: str) -> str:
+        """
+        Add a comment to a pull request (merge request) in GitLab.
+
+        This method adds a general comment to the entire merge request,
+        not tied to specific code lines or file changes.
+
+        Parameters:
+            pr_number: GitLab Merge Request (Pull Request) number
+            comment: Comment text to add
+
+        Returns:
+            Success message or error description
+        """
+        try:
+            mr = self.repo_instance.mergerequests.get(pr_number)
+            mr.notes.create({"body": comment})
+            return "Commented on merge request " + str(pr_number)
+        except Exception as e:
+            return "Unable to make comment due to error:\n" + str(e)
+
     def create_file(self, file_path: str, file_contents: str, branch: str) -> str:
+        # Default to active branch if branch is None
+        branch = branch if branch else self._active_branch
         try:
             self.set_active_branch(branch)
             self.repo_instance.files.get(file_path, branch)
@@ -316,50 +372,126 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
             return "Created file " + file_path
 
     def read_file(self, file_path: str, branch: str) -> str:
+        # Default to active branch if branch is None
+        branch = branch if branch else self._active_branch
         self.set_active_branch(branch)
         file = self.repo_instance.files.get(file_path, branch)
         return parse_file_content(file_name=file_path,
                                   file_content=file.decode(),
                                   llm=self.llm)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: 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
+            
+        Returns:
+            Success message
+        """
+        try:
+            branch = branch or self._active_branch
+            
+            if branch == self.branch:
+                raise ToolException(
+                    f"Cannot commit directly to the {self.branch} branch. "
+                    "Please create a new branch and try again."
+                )
+            
+            self.set_active_branch(branch)
+            
+            # Check if file exists
+            try:
+                self.repo_instance.files.get(file_path, branch)
+                # File exists, update it
+                commit = {
+                    "branch": branch,
+                    "commit_message": commit_message or f"Update {file_path}",
+                    "actions": [
+                        {
+                            "action": "update",
+                            "file_path": file_path,
+                            "content": content,
+                        }
+                    ],
+                }
+                self.repo_instance.commits.create(commit)
+                return f"Updated file {file_path}"
+            except:
+                # File doesn't exist, create it
+                data = {
+                    "branch": branch,
+                    "commit_message": commit_message or f"Create {file_path}",
+                    "file_path": file_path,
+                    "content": content,
+                }
+                self.repo_instance.files.create(data)
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def update_file(self, file_query: str, branch: str) -> str:
+        """
+        Update file using edit_file functionality.
+
+        This method now delegates to edit_file which uses OLD/NEW markers.
+        For backwards compatibility, it extracts the file_path from the query.
+
+        Expected format:
+            file_path
+            OLD <<<<
+            old content
+            >>>> OLD
+            NEW <<<<
+            new content
+            >>>> NEW
+
+        Args:
+            file_query: File path on first line, followed by OLD/NEW markers
+            branch: Branch to update the file in
+
+        Returns:
+            Success or error message
+        """
         if branch == self.branch:
             return (
-                "You're attempting to commit to the directly"
+                "You're attempting to commit directly "
                 f"to the {self.branch} branch, which is protected. "
                 "Please create a new branch and try again."
             )
         try:
-            file_path: str = file_query.split("\n")[0]
-            self.set_active_branch(branch)
-            file_content = self.read_file(file_path, branch)
-            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."
                 )
 
-            commit = {
-                "branch": branch,
-                "commit_message": "Create " + file_path,
-                "actions": [
-                    {
-                        "action": "update",
-                        "file_path": file_path,
-                        "content": updated_file_content,
-                    }
-                ],
-            }
+            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:])
+
+            # Delegate to edit_file method with appropriate commit message
+            commit_message = f"Update {file_path}"
+            return self.edit_file(file_path, edit_content, branch, commit_message)
 
-            self.repo_instance.commits.create(commit)
-            return "Updated file " + file_path
         except Exception as e:
             return "Unable to update file due to error:\n" + str(e)
 
@@ -411,10 +543,41 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
         return res
 
     def create_pr_change_comment(self, pr_number: int, file_path: str, line_number: int, comment: str) -> str:
-        mr = self.repo_instance.mergerequests.get(pr_number)
-        position = {"position_type": "text", "new_path": file_path, "new_line": line_number}
-        mr.discussions.create({"body": comment, "position": position})
-        return "Comment added"
+        """
+        Create a comment on a specific line in a pull request (merge request) change in GitLab.
+
+        This method adds an inline comment to a specific line in the diff of a merge request.
+        The line_number parameter refers to the line index in the diff output (0-based),
+        not the line number in the original file.
+
+        **Important**: Use get_pr_changes first to see the diff and identify the correct
+        line index for commenting.
+
+        Parameters:
+            pr_number: GitLab Merge Request number
+            file_path: Path to the file being commented on (as shown in the diff)
+            line_number: Line index from the diff (0-based index)
+            comment: Comment text to add
+
+        Returns:
+            Success message or error description
+        """
+        try:
+            mr = self.repo_instance.mergerequests.get(pr_number)
+        except GitlabGetError as e:
+            if e.response_code == 404:
+                raise ToolException(f"Merge request number {pr_number} wasn't found: {e}")
+            raise ToolException(f"Error retrieving merge request {pr_number}: {e}")
+
+        try:
+            # Calculate proper position with SHA references and line mappings
+            position = get_position(file_path=file_path, line_number=line_number, mr=mr)
+
+            # Create discussion with the comment
+            mr.discussions.create({"body": comment, "position": position})
+            return f"Comment added successfully to line {line_number} in {file_path} on MR #{pr_number}"
+        except Exception as e:
+            raise ToolException(f"Failed to create comment on MR #{pr_number}: {e}")
 
     def get_commits(self, sha: Optional[str] = None, path: Optional[str] = None, since: Optional[str] = None, until: Optional[str] = None, author: Optional[str] = None):
         params = {}
@@ -441,6 +604,7 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
         ]
 
     @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {
@@ -491,6 +655,12 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
                 "description": self.comment_on_issue.__doc__ or "Comment on an issue in the repository.",
                 "args_schema": CommentOnIssueModel,
             },
+            {
+                "name": "comment_on_pr",
+                "ref": self.comment_on_pr,
+                "description": self.comment_on_pr.__doc__ or "Comment on a pull request (merge request) in the repository.",
+                "args_schema": CommentOnPRModel,
+            },
             {
                 "name": "create_file",
                 "ref": self.create_file,
@@ -506,7 +676,7 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
             {
                 "name": "update_file",
                 "ref": self.update_file,
-                "description": self.update_file.__doc__ or "Update the contents of a file in the repository.",
+                "description": EDIT_FILE_DESCRIPTION,
                 "args_schema": UpdateFileModel,
             },
             {
@@ -536,7 +706,7 @@ class GitLabAPIWrapper(CodeIndexerToolkit):
             {
                 "name": "create_pr_change_comment",
                 "ref": self.create_pr_change_comment,
-                "description": "Create a comment on a pull request change.",
+                "description": self.create_pr_change_comment.__doc__ or "Create an inline comment on a specific line in a pull request change. Use get_pr_changes first to see the diff and identify the line index for commenting. The line_number is a 0-based index from the diff output, not the file line number.",
                 "args_schema": CreatePRChangeCommentModel,
             },
             {

alita_sdk/tools/gitlab_org/__init__.py

@@ -6,8 +6,9 @@ from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 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.gitlab import GitlabConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "gitlab_org"
 
@@ -22,16 +23,12 @@ def get_tools(tool):
 
 class AlitaGitlabSpaceToolkit(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 GitLabWorkspaceAPIWrapper.model_construct().get_available_tools()}
-        AlitaGitlabSpaceToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True,
-                                                                            'max_toolkit_length': AlitaGitlabSpaceToolkit.toolkit_max_length})),
             gitlab_configuration=(GitlabConfiguration, Field(description="GitLab configuration",
                                                                        json_schema_extra={
                                                                            'configuration_types': ['gitlab']})),
@@ -63,18 +60,22 @@ class AlitaGitlabSpaceToolkit(BaseToolkit):
             **kwargs['gitlab_configuration'],
         }
         gitlab_wrapper = GitLabWorkspaceAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, AlitaGitlabSpaceToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = gitlab_wrapper.get_available_tools()
         tools = []
         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 = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=gitlab_wrapper,
-                name=prefix + tool['name'],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool['name'],
+                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/gitlab_org/api_wrapper.py

@@ -8,8 +8,9 @@ from langchain_core.tools import ToolException
 from pydantic import model_validator, PrivateAttr, create_model, SecretStr
 from pydantic.fields import Field
 
-from ..elitea_base import BaseToolApiWrapper
+from ..elitea_base import BaseToolApiWrapper, BaseCodeToolApiWrapper
 from ..gitlab.utils import get_diff_w_position, get_position
+from ..utils.tool_prompts import EDIT_FILE_DESCRIPTION, UPDATE_FILE_PROMPT_NO_PATH
 
 logger = logging.getLogger(__name__)
 
@@ -24,7 +25,7 @@ GitLabCreateBranch = create_model(
 GitLabListBranches = create_model(
     "GitLabListBranchesModel",
     repository=(Optional[str], Field(description="Name of the repository", default=None)),
-    limit=(Optional[int], Field(description="Maximum number of branches to return. If not provided, all branches will be returned.", default=20)),
+    limit=(Optional[int], Field(description="Maximum number of branches to return. If not provided, all branches will be returned.", default=20, gt=0)),
     branch_wildcard=(Optional[str], Field(description="Wildcard pattern to filter branches by name. If not provided, all branches will be returned.", default=None))
 )
 
@@ -75,7 +76,7 @@ GitLabReadFile = create_model(
 GitLabUpdateFile = create_model(
     "GitLabUpdateFile",
     file_path=(str, Field(description="Path of the file to update")),
-    update_query=(str, Field(description="File path followed by the old and new contents")),
+    update_query=(str, Field(description=UPDATE_FILE_PROMPT_NO_PATH)),
     repository=(Optional[str], Field(description="Name of the repository", default=None)),
     branch=(str, Field(description=branch_description))
 )
@@ -159,6 +160,9 @@ class GitLabWorkspaceAPIWrapper(BaseToolApiWrapper):
     repo_instances: Dict[str, Any] = {}
     _active_branch: Optional[str] = PrivateAttr(default='main')
 
+    # Reuse common file helpers from BaseCodeToolApiWrapper where applicable
+    edit_file = BaseCodeToolApiWrapper.edit_file
+
     class Config:
         arbitrary_types_allowed = True
 
@@ -371,51 +375,76 @@ class GitLabWorkspaceAPIWrapper(BaseToolApiWrapper):
         except Exception as e:
             return ToolException(e)
 
-    def update_file(self, file_path: str, update_query: str, branch: str, repository: Optional[str] = None) -> str:
-        """Updates a file with new content.
-        Parameters:
-            branch (str): The name of the branch where update the file.
-            update_query(str): Contains file contents.
-                The old file contents is wrapped in OLD <<<< and >>>> OLD
-                The new file contents is wrapped in NEW <<<< and >>>> NEW
-                For example:
-                /test/hello.txt
-                OLD <<<<
-                Hello Earth!
-                >>>> OLD
-                NEW <<<<
-                Hello Mars!
-                >>>> NEW
+    def _read_file(self, file_path: str, branch: str, **kwargs) -> str:
+        """
+        Internal read_file used by BaseCodeToolApiWrapper.edit_file.
+        Delegates to the public `read_file` implementation which supports an optional repository argument.
+        The repository may be passed via kwargs or provided earlier through `update_file` which sets
+        a temporary attribute `_tmp_repository_for_edit`.
+        """
+        # Repository from temporary context, then None
+        repository = getattr(self, "_tmp_repository_for_edit", None)
+        try:
+            # Public read_file signature: read_file(file_path, branch, repository=None)
+            return self.read_file(file_path, branch, repository)
+        except Exception as e:
+            raise ToolException(f"Can't extract file content (`{file_path}`) due to error:\n{str(e)}")
+
+    def _write_file(self, file_path: str, content: str, branch: str = None, commit_message: str = None) -> str:
+        """
+        Write content to a file (update only) in the specified GitLab repository.
+
+        This implementation follows the same commit flow as the previous `update_file`:
+        it does not attempt to create the file when it is missing — it will always
+        create a commit with a single `update` action. If the file does not exist on
+        the target branch, the underlying GitLab API will typically return an error.
         """
         try:
+            branch = branch if branch else (self._active_branch if self._active_branch else self.branch)
+            # pick repository from temporary edit context
+            repository = getattr(self, "_tmp_repository_for_edit", None)
             repo_instance = self._get_repo(repository)
-            file_content = self.read_file(file_path, branch, repository)
-            updated_file_content = file_content
-            for old, new in self.extract_old_new_pairs(update_query):
-                if not old.strip():
-                    continue
-                updated_file_content = updated_file_content.replace(old, new)
-            if file_content == updated_file_content:
-                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."
-                )
+
+            # Always perform an 'update' action commit (do not create file when missing)
             commit = {
                 "branch": branch,
-                "commit_message": "Update " + file_path,
+                "commit_message": commit_message or f"Update {file_path}",
                 "actions": [
                     {
                         "action": "update",
                         "file_path": file_path,
-                        "content": updated_file_content,
+                        "content": content,
                     }
                 ],
             }
             repo_instance.commits.create(commit)
-            return "Updated file " + file_path
+            return f"Updated file {file_path}"
+        except ToolException:
+            raise
+        except Exception as e:
+            return ToolException(f"Unable to write file due to error: {str(e)}")
+
+    def update_file(self, file_path: str, update_query: str, branch: str, repository: Optional[str] = None) -> str:
+        """Updates a file with new content using OLD/NEW markers by delegating to `edit_file`.
+
+        The method sets a temporary repository context so that `edit_file`'s internal
+        calls to `_read_file` and `_write_file` operate on the requested repository.
+        """
+        # Set temporary repository context used by _read_file/_write_file
+        self._tmp_repository_for_edit = repository
+        try:
+            commit_message = f"Update {file_path}"
+            return self.edit_file(file_path=file_path, file_query=update_query, branch=branch, commit_message=commit_message)
+        except ToolException as e:
+            return str(e)
         except Exception as e:
             return ToolException(f"Unable to update file due to error: {str(e)}")
+        finally:
+            # Clear temporary context
+            try:
+                delattr(self, "_tmp_repository_for_edit")
+            except Exception:
+                self._tmp_repository_for_edit = None
 
     def delete_file(self, file_path: str, branch: str, repository: Optional[str] = None) -> str:
         """Deletes a file from the repo."""
@@ -428,36 +457,6 @@ class GitLabWorkspaceAPIWrapper(BaseToolApiWrapper):
         except Exception as e:
             return ToolException(f"Unable to delete file due to error: {str(e)}")
 
-    def extract_old_new_pairs(self, file_query):
-        """Extract old and new content pairs from the file query."""
-        code_lines = file_query.split("\n")
-        old_contents = []
-        new_contents = []
-        in_old_section = False
-        in_new_section = False
-        current_section_content = []
-        for line in code_lines:
-            if "OLD <<<" in line:
-                in_old_section = True
-                current_section_content = []
-                continue
-            if ">>>> OLD" in line:
-                in_old_section = False
-                old_contents.append("\n".join(current_section_content).strip())
-                current_section_content = []
-                continue
-            if "NEW <<<" in line:
-                in_new_section = True
-                current_section_content = []
-                continue
-            if ">>>> NEW" in line:
-                in_new_section = False
-                new_contents.append("\n".join(current_section_content).strip())
-                current_section_content = []
-                continue
-            if in_old_section or in_new_section:
-                current_section_content.append(line)
-        return list(zip(old_contents, new_contents))
 
     def append_file(self, file_path: str, content: str, branch: str, repository: Optional[str] = None) -> str:
         """
@@ -641,7 +640,7 @@ class GitLabWorkspaceAPIWrapper(BaseToolApiWrapper):
             },
             {
                 "name": "update_file",
-                "description": self.update_file.__doc__ or "Updates a file in the GitLab repository.",
+                "description": EDIT_FILE_DESCRIPTION,
                 "args_schema": GitLabUpdateFile,
                 "ref": self.update_file,
             },