git-llm-tool 0.1.12__py3-none-any.whl

git_llm_tool/core/git_helper.py

@@ -0,0 +1,250 @@
+"""Git operations helper for git-llm-tool."""
+
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+from git_llm_tool.core.exceptions import GitError
+
+
+class GitHelper:
+    """Helper class for Git operations."""
+
+    def __init__(self):
+        """Initialize Git helper."""
+        self._verify_git_repo()
+
+    def _verify_git_repo(self) -> None:
+        """Verify that we're in a git repository."""
+        try:
+            self._run_git_command(["git", "rev-parse", "--git-dir"])
+        except GitError:
+            raise GitError("Not in a git repository")
+
+    def _run_git_command(self, command: List[str]) -> str:
+        """Run a git command and return output.
+
+        Args:
+            command: Git command as list of strings
+
+        Returns:
+            Command output as string
+
+        Raises:
+            GitError: If command fails
+        """
+        try:
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=True,
+                cwd=os.getcwd()
+            )
+            return result.stdout.strip()
+        except subprocess.CalledProcessError as e:
+            stderr = e.stderr.strip() if e.stderr else "Unknown error"
+            raise GitError(f"Git command failed: {' '.join(command)}\n{stderr}")
+        except FileNotFoundError:
+            raise GitError("Git command not found. Is git installed?")
+
+    def get_staged_diff(self) -> str:
+        """Get diff of staged changes.
+
+        Returns:
+            Git diff output of staged changes
+
+        Raises:
+            GitError: If no staged changes or git command fails
+        """
+        diff = self._run_git_command(["git", "diff", "--cached"])
+
+        if not diff.strip():
+            raise GitError("No staged changes found. Use 'git add' to stage files first.")
+
+        return diff
+
+    def get_current_branch(self) -> str:
+        """Get current branch name.
+
+        Returns:
+            Current branch name
+
+        Raises:
+            GitError: If git command fails
+        """
+        return self._run_git_command(["git", "symbolic-ref", "--short", "HEAD"])
+
+    def get_commit_messages(self, from_ref: Optional[str] = None, to_ref: str = "HEAD") -> List[str]:
+        """Get commit messages in a range.
+
+        Args:
+            from_ref: Starting reference (if None, uses last tag)
+            to_ref: Ending reference
+
+        Returns:
+            List of commit messages
+
+        Raises:
+            GitError: If git command fails
+        """
+        if from_ref is None:
+            # Try to get last tag
+            try:
+                from_ref = self._run_git_command(["git", "describe", "--tags", "--abbrev=0"])
+            except GitError:
+                # If no tags exist, use initial commit
+                from_ref = self._run_git_command(["git", "rev-list", "--max-parents=0", "HEAD"])
+
+        # Get commit messages in range
+        commit_range = f"{from_ref}..{to_ref}"
+        log_output = self._run_git_command([
+            "git", "log", commit_range, "--pretty=format:%s"
+        ])
+
+        if not log_output.strip():
+            raise GitError(f"No commits found in range {commit_range}")
+
+        return [msg.strip() for msg in log_output.split('\n') if msg.strip()]
+
+    def commit_with_message(self, message: str) -> None:
+        """Create a commit with the given message.
+
+        Args:
+            message: Commit message
+
+        Raises:
+            GitError: If commit fails
+        """
+        try:
+            self._run_git_command(["git", "commit", "-m", message])
+        except GitError as e:
+            if "nothing to commit" in str(e).lower():
+                raise GitError("No staged changes to commit")
+            raise
+
+    def open_commit_editor(self, message: str, config=None) -> bool:
+        """Open commit message in editor for review.
+
+        Args:
+            message: Initial commit message
+            config: Optional AppConfig instance for preferred editor
+
+        Returns:
+            True if commit was made, False if cancelled
+
+        Raises:
+            GitError: If git operations fail
+        """
+        # Create temporary file with commit message
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+            temp_file.write(message)
+            temp_file_path = temp_file.name
+
+        try:
+            # Get git editor (with config support)
+            editor = self._get_git_editor(config)
+
+            # Open editor
+            result = subprocess.run([editor, temp_file_path])
+
+            if result.returncode != 0:
+                raise GitError("Editor exited with non-zero status")
+
+            # Read edited message
+            with open(temp_file_path, 'r') as f:
+                edited_message = f.read().strip()
+
+            # Check if message was cleared (user cancelled)
+            if not edited_message:
+                return False
+
+            # Create commit with edited message
+            self.commit_with_message(edited_message)
+            return True
+
+        finally:
+            # Clean up temporary file
+            try:
+                os.unlink(temp_file_path)
+            except OSError:
+                pass
+
+    def _get_git_editor(self, config=None) -> str:
+        """Get the configured git editor.
+
+        Args:
+            config: Optional AppConfig instance to get preferred editor
+
+        Returns:
+            Editor command
+
+        Raises:
+            GitError: If no editor is configured
+        """
+        # First priority: app config preferred editor
+        if config and config.editor.preferred_editor:
+            return config.editor.preferred_editor
+
+        # Second priority: git config
+        try:
+            editor = self._run_git_command(["git", "config", "--get", "core.editor"])
+            if editor:
+                return editor
+        except GitError:
+            pass
+
+        # Third priority: environment variables
+        for env_var in ["GIT_EDITOR", "VISUAL", "EDITOR"]:
+            editor = os.environ.get(env_var)
+            if editor:
+                return editor
+
+        # Fourth priority: default editors by platform
+        if os.name == 'nt':
+            # Windows
+            return "notepad"
+        else:
+            # Unix-like systems
+            for default_editor in ["nano", "vim", "vi"]:
+                try:
+                    subprocess.run(["which", default_editor],
+                                 capture_output=True, check=True)
+                    return default_editor
+                except (subprocess.CalledProcessError, FileNotFoundError):
+                    continue
+
+        raise GitError("No suitable editor found. Please set core.editor in git config or editor.preferred_editor in git-llm config")
+
+    def get_repository_info(self) -> dict:
+        """Get basic repository information.
+
+        Returns:
+            Dictionary with repository info
+        """
+        try:
+            return {
+                "branch": self.get_current_branch(),
+                "has_staged_changes": bool(self._run_git_command(["git", "diff", "--cached", "--name-only"])),
+                "has_unstaged_changes": bool(self._run_git_command(["git", "diff", "--name-only"])),
+                "repository_root": self._run_git_command(["git", "rev-parse", "--show-toplevel"])
+            }
+        except GitError:
+            return {}
+
+    def is_clean_workspace(self) -> bool:
+        """Check if workspace has no uncommitted changes.
+
+        Returns:
+            True if workspace is clean
+        """
+        try:
+            staged = self._run_git_command(["git", "diff", "--cached", "--name-only"])
+            unstaged = self._run_git_command(["git", "diff", "--name-only"])
+            untracked = self._run_git_command(["git", "ls-files", "--others", "--exclude-standard"])
+
+            return not (staged or unstaged or untracked)
+        except GitError:
+            return False

git_llm_tool/core/jira_helper.py

@@ -0,0 +1,238 @@
+"""Jira integration helper for git-llm-tool."""
+
+import re
+import click
+from typing import Optional, Tuple
+
+from git_llm_tool.core.config import AppConfig
+from git_llm_tool.core.git_helper import GitHelper
+from git_llm_tool.core.exceptions import JiraError
+
+
+class JiraHelper:
+    """Helper class for Jira integration."""
+
+    def __init__(self, config: AppConfig, git_helper: GitHelper):
+        """Initialize Jira helper.
+
+        Args:
+            config: Application configuration
+            git_helper: Git helper instance
+        """
+        self.config = config
+        self.git_helper = git_helper
+
+    def get_jira_context(
+        self, verbose: bool = False
+    ) -> Tuple[Optional[str], Optional[str]]:
+        """Get Jira ticket and work hours context.
+
+        Args:
+            verbose: Enable verbose output
+
+        Returns:
+            Tuple of (jira_ticket, work_hours)
+        """
+        if not self.config.jira.enabled:
+            if verbose:
+                click.echo("🔒 Jira integration is disabled")
+            return None, None
+
+        # Try to extract ticket from branch name
+        jira_ticket = self._extract_ticket_from_branch()
+
+        if jira_ticket:
+            if verbose:
+                click.echo(f"🎯 Auto-detected Jira ticket: {jira_ticket}")
+        else:
+            # Interactive prompt for ticket
+            jira_ticket = self._prompt_for_ticket()
+
+        # Interactive prompt for work hours
+        work_hours = self._prompt_for_work_hours()
+
+        return jira_ticket, work_hours
+
+    def _extract_ticket_from_branch(self) -> Optional[str]:
+        """Extract Jira ticket from current branch name using regex.
+
+        Returns:
+            Jira ticket number if found, None otherwise
+        """
+        try:
+            branch_name = self.git_helper.get_current_branch()
+
+            # Use ticket pattern to extract Jira ticket
+            if self.config.jira.ticket_pattern:
+                match = re.search(self.config.jira.ticket_pattern, branch_name)
+                if match:
+                    # If the pattern has capture groups, use the first one
+                    if match.groups():
+                        return match.group(1)
+                    else:
+                        # If no capture groups, use the whole match
+                        return match.group(0)
+
+        except Exception:
+            # Ignore any errors in regex matching or git operations
+            pass
+
+        return None
+
+    def _is_jira_ticket_format(self, text: str) -> bool:
+        """Check if text matches typical Jira ticket format.
+
+        Args:
+            text: Text to check
+
+        Returns:
+            True if text looks like a Jira ticket (e.g., PROJECT-123)
+        """
+        import re
+
+        # Common Jira ticket format: UPPERCASE-DIGITS
+        return bool(re.match(r"^[A-Z]+-\d+$", text))
+
+    def _prompt_for_ticket(self) -> Optional[str]:
+        """Interactively prompt user for Jira ticket.
+
+        Returns:
+            Jira ticket number or None if skipped
+        """
+        click.echo("\n🎫 Jira Integration")
+        try:
+            ticket = click.prompt(
+                "Enter Jira ticket number (or press Enter to skip)",
+                default="",
+                show_default=False,
+            ).strip()
+        except (KeyboardInterrupt, click.Abort):
+            click.echo("\n⏭️  Skipping Jira integration")
+            return None
+
+        if not ticket:
+            return None
+
+        # Basic validation - should look like a Jira ticket
+        if not re.match(r"^[A-Z]+-\d+$", ticket.upper()):
+            click.echo(
+                "⚠️  Warning: Ticket format doesn't look like standard Jira format (e.g., PROJ-123)"
+            )
+            if not click.confirm("Continue anyway?"):
+                return None
+
+        return ticket.upper()
+
+    def _prompt_for_work_hours(self) -> Optional[str]:
+        """Interactively prompt user for work hours.
+
+        Returns:
+            Work hours string or None if skipped
+        """
+        work_hours = click.prompt(
+            "Enter work hours (e.g., '1h 30m', '2h', '45m', '1d 2h', '1w 3d 4h 30m') or press Enter to skip",
+            default="",
+            show_default=False,
+        ).strip()
+
+        if not work_hours:
+            return None
+
+        # Basic validation for work hours format
+        if not re.match(
+            r"^(\d+w\s*)?(\d+d\s*)?(\d+h\s*)?(\d+m)?$",
+            work_hours.lower().replace(" ", ""),
+        ):
+            click.echo(
+                "⚠️  Warning: Work hours format should be like '1h 30m', '2h', '45m', '1d 2h', or '1w 2d 3h 30m'"
+            )
+            if not click.confirm("Continue anyway?"):
+                return None
+
+        # Normalize the work hours format
+        normalized_hours = self._normalize_work_hours(work_hours)
+        return normalized_hours
+
+    def _normalize_work_hours(self, work_hours: str) -> str:
+        """Normalize work hours to standard format: 0w 0d 0h 0m.
+
+        Args:
+            work_hours: Input work hours string (e.g., '1h 30m', '2h', '45m')
+
+        Returns:
+            Normalized work hours string in format '0w 0d 0h 0m'
+        """
+        # Initialize all time units to 0
+        weeks = 0
+        days = 0
+        hours = 0
+        minutes = 0
+
+        # Clean the input and make it lowercase
+        clean_input = work_hours.lower().replace(" ", "")
+
+        # Extract weeks
+        week_match = re.search(r"(\d+)w", clean_input)
+        if week_match:
+            weeks = int(week_match.group(1))
+
+        # Extract days
+        day_match = re.search(r"(\d+)d", clean_input)
+        if day_match:
+            days = int(day_match.group(1))
+
+        # Extract hours
+        hour_match = re.search(r"(\d+)h", clean_input)
+        if hour_match:
+            hours = int(hour_match.group(1))
+
+        # Extract minutes
+        minute_match = re.search(r"(\d+)m", clean_input)
+        if minute_match:
+            minutes = int(minute_match.group(1))
+
+        # Return in standard format
+        return f"{weeks}w {days}d {hours}h {minutes}m"
+
+    def format_jira_info(
+        self, jira_ticket: Optional[str], work_hours: Optional[str]
+    ) -> str:
+        """Format Jira information for display.
+
+        Args:
+            jira_ticket: Jira ticket number
+            work_hours: Work hours
+
+        Returns:
+            Formatted string for display
+        """
+        info_parts = []
+
+        if jira_ticket:
+            info_parts.append(f"🎫 Ticket: {jira_ticket}")
+
+        if work_hours:
+            info_parts.append(f"⏱️  Time: {work_hours}")
+
+        return " | ".join(info_parts) if info_parts else "No Jira information"
+
+    def validate_config(self) -> bool:
+        """Validate Jira configuration.
+
+        Returns:
+            True if configuration is valid
+
+        Raises:
+            JiraError: If configuration is invalid
+        """
+        if not self.config.jira.enabled:
+            return True
+
+        # Validate ticket pattern regex if provided
+        if self.config.jira.ticket_pattern:
+            try:
+                re.compile(self.config.jira.ticket_pattern)
+            except re.error as e:
+                raise JiraError(f"Invalid ticket pattern regex: {e}")
+
+        return True

git_llm_tool/core/rate_limiter.py

@@ -0,0 +1,136 @@
+"""Rate limiting and retry mechanisms for API calls."""
+
+import time
+import random
+from typing import Any, Callable, Optional
+from dataclasses import dataclass
+from functools import wraps
+import logging
+
+from git_llm_tool.core.exceptions import ApiError
+
+
+@dataclass
+class RateLimitConfig:
+    """Configuration for rate limiting."""
+    max_retries: int = 5
+    initial_delay: float = 1.0
+    max_delay: float = 60.0
+    backoff_multiplier: float = 2.0
+    jitter: bool = True
+    rate_limit_delay: float = 0.5  # Minimum delay between requests
+
+
+class RateLimiter:
+    """Rate limiter with exponential backoff and jitter."""
+
+    def __init__(self, config: RateLimitConfig):
+        self.config = config
+        self.last_request_time = 0.0
+        self.logger = logging.getLogger(__name__)
+
+    def wait_if_needed(self):
+        """Ensure minimum delay between requests."""
+        current_time = time.time()
+        time_since_last = current_time - self.last_request_time
+
+        if time_since_last < self.config.rate_limit_delay:
+            sleep_time = self.config.rate_limit_delay - time_since_last
+            time.sleep(sleep_time)
+
+        self.last_request_time = time.time()
+
+    def exponential_backoff(self, attempt: int) -> float:
+        """Calculate delay for exponential backoff."""
+        delay = min(
+            self.config.initial_delay * (self.config.backoff_multiplier ** attempt),
+            self.config.max_delay
+        )
+
+        if self.config.jitter:
+            # Add jitter to prevent thundering herd
+            delay *= (0.5 + random.random() * 0.5)
+
+        return delay
+
+    def retry_with_backoff(self, func: Callable, *args, **kwargs) -> Any:
+        """Execute function with exponential backoff retry."""
+        last_exception = None
+
+        for attempt in range(self.config.max_retries):
+            try:
+                # Wait before making request (rate limiting)
+                self.wait_if_needed()
+
+                # Execute the function
+                return func(*args, **kwargs)
+
+            except Exception as e:
+                last_exception = e
+
+                # Check if it's a rate limit error
+                is_rate_limit_error = self._is_rate_limit_error(e)
+
+                if not is_rate_limit_error and attempt == 0:
+                    # If it's not a rate limit error, don't retry on first attempt
+                    # unless it's a network error
+                    if not self._is_retryable_error(e):
+                        raise e
+
+                if attempt == self.config.max_retries - 1:
+                    # Last attempt, re-raise the exception
+                    break
+
+                delay = self.exponential_backoff(attempt)
+                self.logger.warning(
+                    f"API call failed (attempt {attempt + 1}/{self.config.max_retries}): {e}. "
+                    f"Retrying in {delay:.2f}s..."
+                )
+                time.sleep(delay)
+
+        # All retries exhausted
+        raise ApiError(f"API call failed after {self.config.max_retries} attempts: {last_exception}")
+
+    def _is_rate_limit_error(self, error: Exception) -> bool:
+        """Check if error is related to rate limiting."""
+        error_str = str(error).lower()
+        rate_limit_indicators = [
+            "rate limit",
+            "too many requests",
+            "quota exceeded",
+            "429",
+            "throttled",
+            "rate_limit_exceeded"
+        ]
+        return any(indicator in error_str for indicator in rate_limit_indicators)
+
+    def _is_retryable_error(self, error: Exception) -> bool:
+        """Check if error is retryable."""
+        error_str = str(error).lower()
+        retryable_indicators = [
+            "timeout",
+            "connection",
+            "network",
+            "502",
+            "503",
+            "504",
+            "internal server error",
+            "service unavailable",
+            "gateway timeout"
+        ]
+        return any(indicator in error_str for indicator in retryable_indicators)
+
+
+def rate_limited(config: Optional[RateLimitConfig] = None):
+    """Decorator for rate limiting API calls."""
+    if config is None:
+        config = RateLimitConfig()
+
+    rate_limiter = RateLimiter(config)
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return rate_limiter.retry_with_backoff(func, *args, **kwargs)
+        return wrapper
+    return decorator