git-llm-tool 0.1.0__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,168 @@
+"""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
+        """
+        if not self.config.jira.branch_regex:
+            return None
+
+        try:
+            branch_name = self.git_helper.get_current_branch()
+            pattern = self.config.jira.branch_regex
+
+            match = re.search(pattern, branch_name)
+            if match:
+                # If regex 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 _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")
+        ticket = click.prompt(
+            "Enter Jira ticket number (or press Enter to skip)",
+            default="",
+            show_default=False
+        ).strip()
+
+        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') 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+h\s*)?(\d+m)?$', work_hours.lower().replace(' ', '')):
+            click.echo("⚠️  Warning: Work hours format should be like '1h 30m', '2h', or '45m'")
+            if not click.confirm("Continue anyway?"):
+                return None
+
+        return work_hours
+
+    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 regex if provided
+        if self.config.jira.branch_regex:
+            try:
+                re.compile(self.config.jira.branch_regex)
+            except re.error as e:
+                raise JiraError(f"Invalid branch regex pattern: {e}")
+
+        return True

git_llm_tool/providers/__init__.py

@@ -0,0 +1,17 @@
+"""LLM providers module."""
+
+from git_llm_tool.providers.base import LlmProvider
+from git_llm_tool.providers.openai import OpenAiProvider
+from git_llm_tool.providers.azure_openai import AzureOpenAiProvider
+from git_llm_tool.providers.anthropic import AnthropicProvider
+from git_llm_tool.providers.gemini import GeminiProvider
+from git_llm_tool.providers.factory import get_provider
+
+__all__ = [
+    "LlmProvider",
+    "OpenAiProvider",
+    "AzureOpenAiProvider",
+    "AnthropicProvider",
+    "GeminiProvider",
+    "get_provider"
+]

git_llm_tool/providers/anthropic.py

@@ -0,0 +1,90 @@
+"""Anthropic Claude LLM provider implementation."""
+
+from typing import Optional
+import anthropic
+
+from git_llm_tool.core.config import AppConfig
+from git_llm_tool.core.exceptions import ApiError
+from git_llm_tool.providers.base import LlmProvider
+
+
+class AnthropicProvider(LlmProvider):
+    """Anthropic Claude provider implementation."""
+
+    def __init__(self, config: AppConfig):
+        """Initialize Anthropic provider."""
+        super().__init__(config)
+
+        # Get API key
+        api_key = config.llm.api_keys.get("anthropic")
+        if not api_key:
+            raise ApiError("Anthropic API key not found in configuration")
+
+        # Initialize Anthropic client
+        self.client = anthropic.Anthropic(api_key=api_key)
+
+        # Determine model
+        model = config.llm.default_model
+        if not model.startswith("claude-"):
+            # Fallback to Claude 3.5 Sonnet if model doesn't look like Anthropic model
+            model = "claude-3-5-sonnet-20241024"
+        self.model = model
+
+    def generate_commit_message(
+        self,
+        diff: str,
+        jira_ticket: Optional[str] = None,
+        work_hours: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """Generate commit message using Anthropic API."""
+        prompt = self._build_commit_prompt(diff, jira_ticket, work_hours)
+        return self._make_api_call(prompt, **kwargs)
+
+    def generate_changelog(
+        self,
+        commit_messages: list[str],
+        **kwargs
+    ) -> str:
+        """Generate changelog using Anthropic API."""
+        prompt = self._build_changelog_prompt(commit_messages)
+        return self._make_api_call(prompt, **kwargs)
+
+    def _make_api_call(self, prompt: str, **kwargs) -> str:
+        """Make API call to Anthropic."""
+        try:
+            # Default parameters
+            api_params = {
+                "model": self.model,
+                "max_tokens": kwargs.get("max_tokens", 150),
+                "temperature": kwargs.get("temperature", 0.7),
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ]
+            }
+
+            # Make API call
+            response = self.client.messages.create(**api_params)
+
+            # Extract response text
+            if response.content and len(response.content) > 0:
+                # Anthropic returns a list of content blocks
+                content = response.content[0]
+                if hasattr(content, 'text'):
+                    return content.text.strip()
+
+            raise ApiError("Empty response from Anthropic API")
+
+        except anthropic.AuthenticationError:
+            raise ApiError("Invalid Anthropic API key")
+        except anthropic.RateLimitError:
+            raise ApiError("Anthropic API rate limit exceeded")
+        except anthropic.APIConnectionError:
+            raise ApiError("Failed to connect to Anthropic API")
+        except anthropic.APIError as e:
+            raise ApiError(f"Anthropic API error: {e}")
+        except Exception as e:
+            raise ApiError(f"Unexpected error calling Anthropic API: {e}")

git_llm_tool/providers/azure_openai.py

@@ -0,0 +1,112 @@
+"""Azure OpenAI LLM provider implementation."""
+
+from typing import Optional
+import openai
+
+from git_llm_tool.core.config import AppConfig
+from git_llm_tool.core.exceptions import ApiError
+from git_llm_tool.providers.base import LlmProvider
+
+
+class AzureOpenAiProvider(LlmProvider):
+    """Azure OpenAI provider implementation."""
+
+    def __init__(self, config: AppConfig):
+        """Initialize Azure OpenAI provider."""
+        super().__init__(config)
+
+        # Get Azure OpenAI configuration
+        azure_config = config.llm.azure_openai
+        if not azure_config.get("endpoint"):
+            raise ApiError("Azure OpenAI endpoint not found in configuration")
+
+        api_key = config.llm.api_keys.get("azure_openai")
+        if not api_key:
+            raise ApiError("Azure OpenAI API key not found in configuration")
+
+        # Default values for Azure OpenAI
+        api_version = azure_config.get("api_version", "2024-02-15-preview")
+        deployment_name = azure_config.get("deployment_name")
+
+        # Initialize Azure OpenAI client
+        self.client = openai.AzureOpenAI(
+            api_key=api_key,
+            api_version=api_version,
+            azure_endpoint=azure_config["endpoint"]
+        )
+
+        # Use deployment name if provided, otherwise use model name
+        if deployment_name:
+            self.model = deployment_name
+        else:
+            # For Azure, we typically use deployment names instead of model names
+            model = config.llm.default_model
+            if model.startswith(("gpt-", "o1-")):
+                self.model = model
+            else:
+                # Default to gpt-4o deployment if model doesn't look like OpenAI model
+                self.model = "gpt-4o"
+
+    def generate_commit_message(
+        self,
+        diff: str,
+        jira_ticket: Optional[str] = None,
+        work_hours: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """Generate commit message using Azure OpenAI API."""
+        prompt = self._build_commit_prompt(diff, jira_ticket, work_hours)
+        return self._make_api_call(prompt, **kwargs)
+
+    def generate_changelog(
+        self,
+        commit_messages: list[str],
+        **kwargs
+    ) -> str:
+        """Generate changelog using Azure OpenAI API."""
+        prompt = self._build_changelog_prompt(commit_messages)
+        return self._make_api_call(prompt, **kwargs)
+
+    def _make_api_call(self, prompt: str, **kwargs) -> str:
+        """Make API call to Azure OpenAI."""
+        try:
+            # Default parameters
+            api_params = {
+                "model": self.model,
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": "You are a helpful assistant that generates git commit messages and changelogs."
+                    },
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                "max_tokens": kwargs.get("max_tokens", 150),
+                "temperature": kwargs.get("temperature", 0.7),
+            }
+
+            # Make API call
+            response = self.client.chat.completions.create(**api_params)
+
+            # Extract response text
+            if response.choices and len(response.choices) > 0:
+                content = response.choices[0].message.content
+                if content:
+                    return content.strip()
+
+            raise ApiError("Empty response from Azure OpenAI API")
+
+        except openai.AuthenticationError:
+            raise ApiError("Invalid Azure OpenAI API key")
+        except openai.RateLimitError:
+            raise ApiError("Azure OpenAI API rate limit exceeded")
+        except openai.APIConnectionError:
+            raise ApiError("Failed to connect to Azure OpenAI API")
+        except openai.NotFoundError:
+            raise ApiError(f"Azure OpenAI deployment '{self.model}' not found. Check your deployment name.")
+        except openai.APIError as e:
+            raise ApiError(f"Azure OpenAI API error: {e}")
+        except Exception as e:
+            raise ApiError(f"Unexpected error calling Azure OpenAI API: {e}")