quantalogic 0.35.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

quantalogic/tools/git/bitbucket_clone_repo_tool.py

@@ -0,0 +1,181 @@
+"""Tool for cloning Bitbucket repositories using Repository Access Tokens.
+
+Following Bitbucket's official documentation for Repository Access Tokens:
+https://support.atlassian.com/bitbucket-cloud/docs/using-repository-access-tokens/
+"""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from git import Repo
+from git.exc import GitCommandError
+from loguru import logger
+from pydantic import Field
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# Base directory for all cloned repositories
+BITBUCKET_REPOS_BASE_DIR = "/tmp/bitbucket_repos"
+
+class BitbucketCloneTool(Tool):
+    """Tool for cloning Bitbucket repositories using Repository Access Tokens."""
+
+    name: str = "bitbucket_clone_tool"
+    description: str = (
+        "Clones a Bitbucket repository using Repository Access Token authentication. "
+        "Requires a token with 'Repository Read' and 'Repository Write' permissions."
+    )
+    need_validation: bool = False
+    access_token: Optional[str] = Field(
+        default=None,
+        description="Bitbucket Repository Access Token. Must have 'Repository Read' and 'Repository Write' permissions."
+    )
+
+    def __init__(self, access_token: Optional[str] = None, **data):
+        """Initialize the tool with a Bitbucket Repository Access Token."""
+        super().__init__(**data)
+        # Treat empty string as None
+        self.access_token = access_token if access_token and access_token.strip() else None
+        logger.info(f"BitbucketCloneTool initialized with access token: {'provided' if self.access_token else 'not provided'}")
+        
+        # Add token validation logging
+        if self.access_token:
+            logger.info(f"Access token provided, length: {len(self.access_token)}")
+            logger.info(f"First 4 chars of token (masked): {self.access_token[:4]}***")
+        else:
+            logger.warning("No access token provided during initialization")
+
+    arguments: list = [
+        ToolArgument(
+            name="repo_url",
+            arg_type="string",
+            description="The URL of the Bitbucket repository to clone (HTTPS format)",
+            required=True,
+            example="https://bitbucket.org/workspace/repository.git",
+        ),
+        ToolArgument(
+            name="target_path",
+            arg_type="string",
+            description="The local path where the repository should be cloned",
+            required=True,
+            example="/tmp/bitbucket_repos/repo_name",
+        ),
+        ToolArgument(
+            name="branch",
+            arg_type="string",
+            description="Specific branch to clone (defaults to main/master)",
+            required=False,
+            default="main",
+        ),
+    ]
+
+    def _prepare_directory(self, path: str) -> None:
+        """Prepare the target directory for cloning."""
+        path = os.path.abspath(path)
+        if not path.startswith(BITBUCKET_REPOS_BASE_DIR):
+            raise ValueError(f"Target path must be within {BITBUCKET_REPOS_BASE_DIR}")
+        
+        os.makedirs(BITBUCKET_REPOS_BASE_DIR, exist_ok=True)
+        if os.path.exists(path):
+            shutil.rmtree(path)
+        os.makedirs(path)
+        logger.debug(f"Prepared directory: {path}")
+
+    def _get_clone_url(self, repo_url: str) -> str:
+        """Get the proper clone URL with Repository Access Token authentication.
+        
+        Following Bitbucket's official format:
+        https://x-token-auth:{repository_access_token}@bitbucket.org/{workspace}/{repository}.git
+        """
+        # Log token state at URL construction
+        logger.debug(f"Token state in _get_clone_url: {'present' if self.access_token else 'missing'}")
+        if self.access_token:
+            logger.debug(f"Token length: {len(self.access_token)}")
+        
+        logger.debug(f"Original URL: {repo_url}")
+        
+        # Remove /src/branch/ if present (from web URLs)
+        if '/src/' in repo_url:
+            repo_url = repo_url.split('/src/')[0]
+            logger.debug(f"URL after removing /src/: {repo_url}")
+        
+        # Ensure URL ends with .git
+        if not repo_url.endswith('.git'):
+            repo_url = f"{repo_url}.git"
+            logger.debug(f"URL after adding .git: {repo_url}")
+
+        # Add authentication using the official Bitbucket format
+        if self.access_token and self.access_token.strip():
+            # First, extract the workspace and repository from the URL
+            parts = repo_url.split('bitbucket.org/')
+            if len(parts) != 2:
+                raise ValueError("Invalid Bitbucket URL format")
+            
+            workspace_repo = parts[1].rstrip('.git')
+            # Construct the URL exactly as per Bitbucket docs
+            clone_url = f"https://x-token-auth:{self.access_token}@bitbucket.org/{workspace_repo}.git"
+            logger.debug("Added Repository Access Token authentication to clone URL")
+            logger.debug(f"Final URL format (token masked): {clone_url.replace(self.access_token, '***')}")
+            return clone_url
+        
+        logger.debug("No token provided, using public URL")
+        return repo_url
+
+    def execute(self, **kwargs) -> str:
+        """Execute the repository cloning operation using Repository Access Token."""
+        # Log token state at execution start
+        logger.debug("=== Token Tracing ===")
+        logger.debug(f"Token present at execute start: {bool(self.access_token)}")
+        if self.access_token:
+            logger.debug(f"Token length at execute: {len(self.access_token)}")
+            logger.debug(f"Token first 4 chars (masked): {self.access_token[:4]}***")
+        else:
+            logger.warning("No access token available during execution")
+        logger.debug("==================")
+
+        repo_url = kwargs.get("repo_url")
+        target_path = kwargs.get("target_path")
+        branch = kwargs.get("branch", "main")
+        
+        if not repo_url or not target_path:
+            raise ValueError("Both repo_url and target_path are required")
+        
+        try:
+            logger.info(f"Starting clone of {repo_url} to {target_path}")
+            self._prepare_directory(target_path)
+            
+            clone_url = self._get_clone_url(repo_url)
+            
+            # Log environment before clone
+            logger.debug("=== Clone Environment ===")
+            logger.debug(f"Branch: {branch}")
+            logger.debug(f"Target path: {target_path}")
+            logger.debug("======================")
+            
+            # Clone with authentication disabled to prevent prompts
+            repo = Repo.clone_from(
+                clone_url,
+                target_path,
+                branch=branch,
+                env={"GIT_TERMINAL_PROMPT": "0"}
+            )
+            
+            logger.info(f"Successfully cloned repository to {target_path}")
+            return f"Repository successfully cloned to {target_path}"
+            
+        except GitCommandError as e:
+            error_msg = str(e)
+            if self.access_token:
+                error_msg = error_msg.replace(self.access_token, '***')
+            logger.error(f"Git command error: {error_msg}")
+            raise GitCommandError("git clone", error_msg)
+        
+        except Exception as e:
+            logger.error(f"Error during repository cloning: {str(e)}")
+            raise
+
+if __name__ == "__main__":
+    tool = BitbucketCloneTool(access_token="your_access_token_here")
+    print(tool.to_markdown())

quantalogic/tools/git/bitbucket_operations_tool.py

@@ -0,0 +1,326 @@
+"""Tool for performing Bitbucket operations including cloning, branch management, and commits.
+
+This tool provides a comprehensive interface for Bitbucket operations, supporting both
+public and private repositories through Repository Access Token authentication.
+"""
+
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import ClassVar, Dict, List, Optional
+from urllib.parse import urlparse
+
+from git import Repo
+from git.exc import GitCommandError
+from loguru import logger
+from pydantic import Field, validator
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# Base directory for all Bitbucket repositories
+BITBUCKET_REPOS_BASE_DIR = "/tmp/bitbucket_repos"
+
+class BitbucketOperationsTool(Tool):
+    """Tool for comprehensive Bitbucket operations.
+    
+    Provides functionality for:
+    - Cloning repositories
+    - Creating and managing branches
+    - Making commits
+    - Pushing and pulling changes
+    - Managing repository access
+    
+    All operations use Bitbucket's Repository Access Token for authentication.
+    """
+
+    name: str = "bitbucket_operations_tool"
+    description: str = (
+        "Comprehensive tool for Bitbucket operations including cloning, branch management, "
+        "commits, and repository access. Uses Repository Access Token authentication."
+    )
+    need_validation: bool = False
+    access_token: Optional[str] = Field(
+        default=None,
+        description="Bitbucket Repository Access Token with 'Repository Read' and 'Repository Write' permissions"
+    )
+
+    def __init__(self, access_token: Optional[str] = None, **data):
+        """Initialize the tool with a Bitbucket Repository Access Token.
+        
+        Args:
+            access_token: Bitbucket Repository Access Token
+            **data: Additional tool configuration data
+        """
+        super().__init__(**data)
+        self.access_token = access_token if access_token and access_token.strip() else None
+        logger.info(f"BitbucketOperationsTool initialized with token: {'provided' if self.access_token else 'not provided'}")
+
+    arguments: list = [
+        ToolArgument(
+            name="operation",
+            arg_type="string",
+            description=(
+                "The Git operation to perform. One of: clone, create_branch, checkout, "
+                "commit, push, pull, status"
+            ),
+            required=True,
+            example="clone",
+        ),
+        ToolArgument(
+            name="repo_url",
+            arg_type="string",
+            description="The Bitbucket repository URL (HTTPS format)",
+            required=False,
+            example="https://bitbucket.org/workspace/repository.git",
+        ),
+        ToolArgument(
+            name="repo_path",
+            arg_type="string",
+            description="Local repository path (must be within /tmp/bitbucket_repos)",
+            required=True,
+            example="/tmp/bitbucket_repos/repo_name",
+        ),
+        ToolArgument(
+            name="branch_name",
+            arg_type="string",
+            description="Branch name for operations that require it",
+            required=False,
+            example="feature/new-feature",
+        ),
+        ToolArgument(
+            name="commit_message",
+            arg_type="string",
+            description="Commit message for commit operations",
+            required=False,
+            example="Add new feature implementation",
+        ),
+        ToolArgument(
+            name="files_to_commit",
+            arg_type="string",
+            description="Comma-separated list of files to commit",
+            required=False,
+            example="file1.py,file2.py",
+        ),
+    ]
+
+    def _prepare_directory(self, path: str) -> None:
+        """Prepare the target directory for repository operations."""
+        path = os.path.abspath(path)
+        if not path.startswith(BITBUCKET_REPOS_BASE_DIR):
+            raise ValueError(f"Target path must be within {BITBUCKET_REPOS_BASE_DIR}")
+        
+        os.makedirs(BITBUCKET_REPOS_BASE_DIR, exist_ok=True)
+        if os.path.exists(path):
+            shutil.rmtree(path)
+        os.makedirs(path)
+        logger.debug(f"Prepared directory: {path}")
+
+    def _get_clone_url(self, repo_url: str) -> str:
+        """Get the proper clone URL with Repository Access Token authentication."""
+        if not self.access_token:
+            return repo_url
+
+        # Remove /src/branch/ if present (from web URLs)
+        if '/src/' in repo_url:
+            repo_url = repo_url.split('/src/')[0]
+
+        # Remove .git if present
+        repo_url = repo_url.rstrip('.git')
+        
+        # Construct authenticated URL
+        return f"https://x-token-auth:{self.access_token}@bitbucket.org/{repo_url.split('bitbucket.org/')[-1]}.git"
+
+    def _clone_repository(self, repo_url: str, target_path: str, branch: str = "main") -> Repo:
+        """Clone a Bitbucket repository.
+        
+        Args:
+            repo_url: Repository URL
+            target_path: Local path for cloning
+            branch: Branch to clone (default: main)
+            
+        Returns:
+            git.Repo: Cloned repository object
+        """
+        try:
+            self._prepare_directory(target_path)
+            clone_url = self._get_clone_url(repo_url)
+            
+            logger.info(f"Cloning repository to {target_path}")
+            repo = Repo.clone_from(
+                clone_url,
+                target_path,
+                branch=branch,
+            )
+            logger.info("Repository cloned successfully")
+            return repo
+            
+        except GitCommandError as e:
+            logger.error(f"Failed to clone repository: {str(e)}")
+            raise
+
+    def _create_branch(self, repo: Repo, branch_name: str) -> None:
+        """Create and checkout a new branch.
+        
+        Args:
+            repo: Repository object
+            branch_name: Name of the branch to create
+        """
+        try:
+            current = repo.active_branch
+            new_branch = repo.create_head(branch_name)
+            new_branch.checkout()
+            logger.info(f"Created and checked out branch: {branch_name}")
+            
+        except GitCommandError as e:
+            logger.error(f"Failed to create branch: {str(e)}")
+            raise
+
+    def _commit_changes(self, repo: Repo, message: str, files: Optional[List[str]] = None) -> None:
+        """Commit changes to the repository.
+        
+        Args:
+            repo: Repository object
+            message: Commit message
+            files: Optional list of specific files to commit
+        """
+        try:
+            if files:
+                repo.index.add(files)
+            else:
+                repo.git.add(A=True)
+                
+            repo.index.commit(message)
+            logger.info(f"Changes committed with message: {message}")
+            
+        except GitCommandError as e:
+            logger.error(f"Failed to commit changes: {str(e)}")
+            raise
+
+    def _push_changes(self, repo: Repo, branch_name: Optional[str] = None) -> None:
+        """Push changes to remote repository.
+        
+        Args:
+            repo: Repository object
+            branch_name: Optional branch name to push
+        """
+        try:
+            if branch_name:
+                repo.git.push('origin', branch_name)
+            else:
+                repo.git.push()
+            logger.info("Changes pushed to remote")
+            
+        except GitCommandError as e:
+            logger.error(f"Failed to push changes: {str(e)}")
+            raise
+
+    def _pull_changes(self, repo: Repo) -> None:
+        """Pull latest changes from remote repository.
+        
+        Args:
+            repo: Repository object
+        """
+        try:
+            repo.git.pull()
+            logger.info("Latest changes pulled from remote")
+            
+        except GitCommandError as e:
+            logger.error(f"Failed to pull changes: {str(e)}")
+            raise
+
+    def execute(self, **kwargs) -> Dict:
+        """Execute the requested Bitbucket operation.
+        
+        Args:
+            **kwargs: Operation-specific arguments
+            
+        Returns:
+            Dict: Operation result status and details
+        """
+        operation = kwargs.get('operation')
+        repo_path = kwargs.get('repo_path')
+        
+        try:
+            if operation == 'clone':
+                repo_url = kwargs.get('repo_url')
+                if not repo_url:
+                    raise ValueError("repo_url is required for clone operation")
+                    
+                repo = self._clone_repository(
+                    repo_url,
+                    repo_path,
+                    kwargs.get('branch_name', 'main')
+                )
+                return {"status": "success", "message": f"Repository cloned to {repo_path}"}
+
+            # For other operations, we need an existing repository
+            if not os.path.exists(repo_path):
+                raise ValueError(f"Repository not found at {repo_path}")
+                
+            repo = Repo(repo_path)
+            
+            if operation == 'create_branch':
+                branch_name = kwargs.get('branch_name')
+                if not branch_name:
+                    raise ValueError("branch_name is required for create_branch operation")
+                    
+                self._create_branch(repo, branch_name)
+                return {"status": "success", "message": f"Created branch: {branch_name}"}
+                
+            elif operation == 'commit':
+                message = kwargs.get('commit_message')
+                if not message:
+                    raise ValueError("commit_message is required for commit operation")
+                    
+                files = kwargs.get('files_to_commit', '').split(',') if kwargs.get('files_to_commit') else None
+                self._commit_changes(repo, message, files)
+                return {"status": "success", "message": f"Changes committed: {message}"}
+                
+            elif operation == 'push':
+                self._push_changes(repo, kwargs.get('branch_name'))
+                return {"status": "success", "message": "Changes pushed to remote"}
+                
+            elif operation == 'pull':
+                self._pull_changes(repo)
+                return {"status": "success", "message": "Latest changes pulled from remote"}
+                
+            elif operation == 'checkout':
+                branch_name = kwargs.get('branch_name')
+                if not branch_name:
+                    raise ValueError("branch_name is required for checkout operation")
+                    
+                repo.git.checkout(branch_name)
+                return {"status": "success", "message": f"Checked out branch: {branch_name}"}
+                
+            elif operation == 'status':
+                status = repo.git.status()
+                return {"status": "success", "message": status}
+                
+            else:
+                raise ValueError(f"Unsupported operation: {operation}")
+                
+        except Exception as e:
+            logger.error(f"Operation failed: {str(e)}")
+            return {"status": "error", "message": str(e)}
+
+
+if __name__ == "__main__":
+    # Example usage
+    tool = BitbucketOperationsTool(access_token="your_access_token_here")
+    
+    # Clone a repository
+    result = tool.execute(
+        operation="clone",
+        repo_url="https://bitbucket.org/workspace/repository.git",
+        repo_path="/tmp/bitbucket_repos/repository"
+    )
+    print(result)
+    
+    # Create a new branch
+    result = tool.execute(
+        operation="create_branch",
+        repo_path="/tmp/bitbucket_repos/repository",
+        branch_name="feature/new-feature"
+    )
+    print(result)

quantalogic/tools/git/clone_repo_tool.py

@@ -0,0 +1,189 @@
+"""Tool for cloning Git repositories with support for both public and private repositories."""
+
+import os
+import shutil
+from pathlib import Path
+
+import requests
+from git import Repo
+from git.exc import GitCommandError
+from loguru import logger
+from pydantic import Field
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# Base directory for all cloned repositories
+GITHUB_REPOS_BASE_DIR = "/tmp/github_repos"
+
+class CloneRepoTool(Tool):
+    """Tool for cloning Git repositories."""
+
+    name: str = "clone_repo_tool"
+    description: str = (
+        "Clones a Git repository (public or private) to a specified location. "
+        "Automatically handles authentication for private repositories using the provided token."
+    )
+    need_validation: bool = False
+    auth_token: str = Field(default=None, description="GitHub authentication token for private repositories")
+
+    def __init__(self, auth_token: str = None, **data):
+        """Initialize the tool with an optional auth token.
+        
+        Args:
+            auth_token: GitHub authentication token for private repositories
+            **data: Additional tool configuration data
+        """
+        super().__init__(**data)
+        self.auth_token = auth_token
+
+    arguments: list = [
+        ToolArgument(
+            name="repo_url",
+            arg_type="string",
+            description="The URL of the Git repository to clone (HTTPS format)",
+            required=True,
+            example="https://github.com/username/repo.git",
+        ),
+        ToolArgument(
+            name="target_path",
+            arg_type="string",
+            description="The local path where the repository should be cloned (must be within /tmp/github_repos)",
+            required=True,
+            example="/tmp/github_repos/repo_name",
+        ),
+        ToolArgument(
+            name="branch",
+            arg_type="string",
+            description="Specific branch to clone (defaults to main/master)",
+            required=False,
+            default="main",
+        ),
+    ]
+
+    def is_private_repo(self, repo_url: str) -> bool:
+        """Check if a GitHub repository is private.
+        
+        Args:
+            repo_url: Repository URL in format https://github.com/username/repo.git
+        
+        Returns:
+            bool: True if repository is private, False otherwise
+        """
+        try:
+            # Extract owner and repo name from URL
+            parts = repo_url.rstrip(".git").split("/")
+            owner, repo = parts[-2], parts[-1]
+            
+            # Try to access repo info without token first
+            response = requests.get(f"https://api.github.com/repos/{owner}/{repo}")
+            
+            if response.status_code == 404 and self.auth_token:
+                # Try again with token
+                headers = {"Authorization": f"token {self.auth_token}"}
+                response = requests.get(
+                    f"https://api.github.com/repos/{owner}/{repo}",
+                    headers=headers
+                )
+                return response.status_code == 200  # If accessible with token, it's private
+            
+            return False  # Repository is public
+            
+        except Exception as e:
+            logger.warning(f"Error checking repository visibility: {str(e)}")
+            return True  # Assume private if can't determine
+
+    def _prepare_target_directory(self, target_path: str) -> None:
+        """Prepare the target directory for cloning.
+        
+        Ensures the target directory is within GITHUB_REPOS_BASE_DIR and prepares it for cloning.
+        
+        Args:
+            target_path: Path where the repository will be cloned
+            
+        Raises:
+            ValueError: If the target path is not within GITHUB_REPOS_BASE_DIR
+        """
+        # Ensure base directory exists
+        os.makedirs(GITHUB_REPOS_BASE_DIR, exist_ok=True)
+        
+        # Convert to absolute path and ensure it's within GITHUB_REPOS_BASE_DIR
+        abs_target = os.path.abspath(target_path)
+        if not abs_target.startswith(GITHUB_REPOS_BASE_DIR):
+            raise ValueError(f"Target directory must be within {GITHUB_REPOS_BASE_DIR}")
+        
+        if os.path.exists(target_path):
+            logger.info(f"Target directory exists, removing: {target_path}")
+            try:
+                # Remove directory and all its contents
+                shutil.rmtree(target_path)
+            except Exception as e:
+                logger.error(f"Error removing existing directory: {str(e)}")
+                raise ValueError(f"Failed to remove existing directory: {str(e)}")
+        
+        # Create new empty directory
+        os.makedirs(target_path, exist_ok=True)
+        logger.info(f"Created clean target directory: {target_path}")
+
+    def execute(self, repo_url: str, target_path: str, branch: str = "main") -> str:
+        """Clones a Git repository to the specified path within GITHUB_REPOS_BASE_DIR.
+
+        Args:
+            repo_url: URL of the Git repository
+            target_path: Local path where to clone the repository (must be within GITHUB_REPOS_BASE_DIR)
+            branch: Branch to clone (defaults to main)
+
+        Returns:
+            str: Path where the repository was cloned
+
+        Raises:
+            GitCommandError: If there's an error during cloning
+            ValueError: If the parameters are invalid or target_path is outside GITHUB_REPOS_BASE_DIR
+        """
+        try:
+            # Ensure target_path is within GITHUB_REPOS_BASE_DIR
+            if not os.path.abspath(target_path).startswith(GITHUB_REPOS_BASE_DIR):
+                target_path = os.path.join(GITHUB_REPOS_BASE_DIR, os.path.basename(target_path))
+                logger.info(f"Adjusting target path to: {target_path}")
+
+            # Prepare target directory (remove if exists and create new)
+            self._prepare_target_directory(target_path)
+
+            # Check if repo is private and token is needed
+            is_private = self.is_private_repo(repo_url)
+            
+            if is_private and not self.auth_token:
+                raise ValueError("Authentication token required for private repository")
+            
+            # Prepare the clone URL with auth token if needed
+            clone_url = repo_url
+            if is_private and self.auth_token:
+                clone_url = repo_url.replace("https://", f"https://{self.auth_token}@")
+
+            logger.info(f"Cloning repository to {target_path}")
+            
+            # Clone the repository
+            repo = Repo.clone_from(
+                url=clone_url,
+                to_path=target_path,
+                branch=branch,
+            )
+
+            logger.info(f"Successfully cloned repository to {target_path}")
+            return f"Repository successfully cloned to: {target_path}"
+
+        except GitCommandError as e:
+            error_msg = str(e)
+            # Remove sensitive information from error message if present
+            if self.auth_token:
+                error_msg = error_msg.replace(self.auth_token, "***")
+            logger.error(f"Failed to clone repository: {error_msg}")
+            raise GitCommandError(f"Failed to clone repository: {error_msg}", e.status)
+        
+        except Exception as e:
+            logger.error(f"An error occurred while cloning the repository: {str(e)}")
+            raise ValueError(f"An error occurred while cloning the repository: {str(e)}")
+
+
+if __name__ == "__main__":
+    tool = CloneRepoTool(auth_token="your_token_here")
+    print(tool.to_markdown())