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

git_llm_tool/providers/base.py

@@ -0,0 +1,202 @@
+"""Base LLM provider interface."""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+from git_llm_tool.core.config import AppConfig
+
+
+class PromptTemplates:
+    """Centralized prompt templates for better code readability."""
+
+    # Base prompt with conventional commit types
+    BASE_COMMIT_PROMPT = """Based on the following git diff, generate a concise commit message in {language}.
+
+**Conventional Commit types**:
+- feat: new feature
+- fix: bug fix
+- docs: documentation changes
+- style: formatting, missing semicolons, etc
+- refactor: code restructuring without changing functionality
+- test: adding or modifying tests
+- chore: maintenance tasks
+
+Git diff:
+```
+{diff}
+```"""
+
+    # Format for commits without Jira tickets
+    NO_JIRA_FORMAT = """
+Generate the commit message in **bulleted format**:
+- feat: description of new features
+- fix: description of bug fixes
+- docs: description of documentation changes
+(include only the types that apply to your changes)
+
+Example format:
+- feat: add user authentication endpoints
+- fix: resolve login validation issue"""
+
+    # Format for commits with Jira tickets
+    JIRA_FORMAT = """
+**Jira ticket found**: {jira_ticket}
+
+Generate the commit message in this **exact format**:
+{jira_ticket} <summary> #time <time_spent>
+- feat: detailed description of new features
+- fix: detailed description of bug fixes
+- docs: detailed description of documentation changes
+(include only the types that apply to your changes)
+
+Where:
+- First line: {jira_ticket} <brief_summary> #time <time_spent>
+- Following lines: List each change type with "- type: description" format
+- Only include the conventional commit types that actually apply to the changes"""
+
+    # Time tracking instructions
+    EXACT_TIME_INSTRUCTION = """
+**Use exact time**: #time {work_hours}
+
+Example format:
+{jira_ticket} Implement user authentication system #time {work_hours}
+- feat: add login and registration endpoints
+- feat: implement JWT token validation
+- docs: update API documentation"""
+
+    ESTIMATE_TIME_INSTRUCTION = """
+**Estimate appropriate time** (e.g., #time 2h, #time 45m, #time 30m)
+
+Example format:
+{jira_ticket} Implement user authentication system #time 2h
+- feat: add login and registration endpoints
+- feat: implement JWT token validation
+- docs: update API documentation"""
+
+    # Final instruction
+    FINAL_INSTRUCTION = "\n\nGenerate ONLY the commit message in the specified format, no additional text or explanation."
+
+
+class LlmProvider(ABC):
+    """Abstract base class for LLM providers."""
+
+    def __init__(self, config: AppConfig):
+        """Initialize the provider with configuration."""
+        self.config = config
+
+    @abstractmethod
+    def generate_commit_message(
+        self,
+        diff: str,
+        jira_ticket: Optional[str] = None,
+        work_hours: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        """Generate commit message from git diff and optional Jira information.
+
+        Args:
+            diff: Git diff output
+            jira_ticket: Jira ticket number (optional)
+            work_hours: Work hours spent (optional)
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            Generated commit message
+
+        Raises:
+            ApiError: If API call fails
+        """
+        pass
+
+    @abstractmethod
+    def generate_changelog(self, commit_messages: list[str], **kwargs) -> str:
+        """Generate changelog from commit messages.
+
+        Args:
+            commit_messages: List of commit messages
+            **kwargs: Additional provider-specific arguments
+
+        Returns:
+            Generated changelog in markdown format
+
+        Raises:
+            ApiError: If API call fails
+        """
+        pass
+
+    def _build_commit_prompt(
+        self,
+        diff: str,
+        jira_ticket: Optional[str] = None,
+        work_hours: Optional[str] = None,
+    ) -> str:
+        """Build prompt for commit message generation."""
+
+        # Prepare all template variables
+        template_vars = {
+            'language': self.config.llm.language,
+            'diff': diff,
+            'jira_ticket': jira_ticket or '',
+            'work_hours': work_hours or ''
+        }
+
+        # Build prompt components
+        prompt_parts = [PromptTemplates.BASE_COMMIT_PROMPT]
+
+        # Add format-specific instructions
+        if jira_ticket:
+            prompt_parts.append(PromptTemplates.JIRA_FORMAT)
+
+            # Add time tracking instructions
+            if work_hours:
+                prompt_parts.append(PromptTemplates.EXACT_TIME_INSTRUCTION)
+            else:
+                prompt_parts.append(PromptTemplates.ESTIMATE_TIME_INSTRUCTION)
+        else:
+            prompt_parts.append(PromptTemplates.NO_JIRA_FORMAT)
+
+        # Add final instruction
+        prompt_parts.append(PromptTemplates.FINAL_INSTRUCTION)
+
+        # Combine and format all parts at once
+        full_template = ''.join(prompt_parts)
+        return full_template.format(**template_vars)
+
+    def _build_changelog_prompt(self, commit_messages: list[str]) -> str:
+        """Build prompt for changelog generation."""
+        commits_text = "\n".join([f"- {msg}" for msg in commit_messages])
+
+        return f"""Generate a structured changelog in {self.config.llm.language} from the following commit messages.
+
+Organize by categories:
+✨ **Features**
+🐛 **Bug Fixes**
+📚 **Documentation**
+🎨 **Style**
+♻️ **Refactoring**
+🧪 **Tests**
+🔧 **Chores**
+💥 **Breaking Changes**
+
+Only include categories that have items. Use markdown format.
+
+Commit messages:
+{commits_text}
+
+Generate the changelog:"""
+
+    @abstractmethod
+    def _make_api_call(self, prompt: str, **kwargs) -> str:
+        """Make API call to the LLM provider.
+
+        Args:
+            prompt: The prompt to send
+            **kwargs: Provider-specific arguments
+
+        Returns:
+            Generated text response
+
+        Raises:
+            ApiError: If API call fails
+        """
+        pass

git_llm_tool/providers/factory.py

@@ -0,0 +1,77 @@
+"""LLM Provider factory for automatic provider selection."""
+
+from git_llm_tool.core.config import AppConfig
+from git_llm_tool.core.exceptions import ApiError
+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
+
+
+def get_provider(config: AppConfig) -> LlmProvider:
+    """Get appropriate LLM provider based on model name in config.
+
+    Args:
+        config: Application configuration
+
+    Returns:
+        Initialized LLM provider
+
+    Raises:
+        ApiError: If no suitable provider is found or API key is missing
+    """
+    model = config.llm.default_model.lower()
+
+    # Check if Azure OpenAI is configured (highest priority for OpenAI-compatible models)
+    if config.llm.azure_openai and config.llm.azure_openai.get("endpoint"):
+        if model.startswith(("gpt-", "o1-")) or "azure" in model:
+            if "azure_openai" not in config.llm.api_keys:
+                raise ApiError("Azure OpenAI API key required for Azure OpenAI models")
+            return AzureOpenAiProvider(config)
+
+    # OpenAI models (regular OpenAI API)
+    if model.startswith(("gpt-", "o1-")):
+        if "openai" not in config.llm.api_keys:
+            raise ApiError("OpenAI API key required for GPT models")
+        return OpenAiProvider(config)
+
+    # Anthropic models
+    elif model.startswith("claude-"):
+        if "anthropic" not in config.llm.api_keys:
+            raise ApiError("Anthropic API key required for Claude models")
+        return AnthropicProvider(config)
+
+    # Google models
+    elif model.startswith("gemini-"):
+        if "google" not in config.llm.api_keys:
+            raise ApiError("Google API key required for Gemini models")
+        return GeminiProvider(config)
+
+    # Fallback logic - try providers in order of preference
+    else:
+        # Try Azure OpenAI first if configured
+        if config.llm.azure_openai and config.llm.azure_openai.get("endpoint") and "azure_openai" in config.llm.api_keys:
+            return AzureOpenAiProvider(config)
+
+        # Try OpenAI second (most common)
+        elif "openai" in config.llm.api_keys:
+            return OpenAiProvider(config)
+
+        # Try Anthropic third
+        elif "anthropic" in config.llm.api_keys:
+            return AnthropicProvider(config)
+
+        # Try Google last
+        elif "google" in config.llm.api_keys:
+            return GeminiProvider(config)
+
+        # No API keys available
+        else:
+            raise ApiError(
+                "No API keys configured. Please set at least one API key:\n"
+                "  git-llm config set llm.api_keys.openai sk-your-key\n"
+                "  git-llm config set llm.api_keys.azure_openai your-azure-key\n"
+                "  git-llm config set llm.api_keys.anthropic sk-ant-your-key\n"
+                "  git-llm config set llm.api_keys.google your-google-key"
+            )

git_llm_tool/providers/gemini.py

@@ -0,0 +1,83 @@
+"""Google Gemini LLM provider implementation."""
+
+from typing import Optional
+import google.generativeai as genai
+
+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 GeminiProvider(LlmProvider):
+    """Google Gemini provider implementation."""
+
+    def __init__(self, config: AppConfig):
+        """Initialize Gemini provider."""
+        super().__init__(config)
+
+        # Get API key
+        api_key = config.llm.api_keys.get("google")
+        if not api_key:
+            raise ApiError("Google API key not found in configuration")
+
+        # Configure Gemini
+        genai.configure(api_key=api_key)
+
+        # Determine model
+        model = config.llm.default_model
+        if not model.startswith("gemini-"):
+            # Fallback to Gemini Pro if model doesn't look like Google model
+            model = "gemini-1.5-pro"
+        self.model = genai.GenerativeModel(model)
+
+    def generate_commit_message(
+        self,
+        diff: str,
+        jira_ticket: Optional[str] = None,
+        work_hours: Optional[str] = None,
+        **kwargs
+    ) -> str:
+        """Generate commit message using Gemini 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 Gemini 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 Gemini."""
+        try:
+            # Configure generation parameters
+            generation_config = genai.types.GenerationConfig(
+                max_output_tokens=kwargs.get("max_tokens", 150),
+                temperature=kwargs.get("temperature", 0.7),
+            )
+
+            # Make API call
+            response = self.model.generate_content(
+                prompt,
+                generation_config=generation_config
+            )
+
+            # Extract response text
+            if response.text:
+                return response.text.strip()
+
+            raise ApiError("Empty response from Gemini API")
+
+        except Exception as e:
+            # Gemini exceptions are not well documented, so catch all
+            if "API_KEY" in str(e).upper():
+                raise ApiError("Invalid Google API key")
+            elif "QUOTA" in str(e).upper() or "RATE" in str(e).upper():
+                raise ApiError("Google API rate limit exceeded")
+            elif "CONNECTION" in str(e).upper() or "NETWORK" in str(e).upper():
+                raise ApiError("Failed to connect to Google API")
+            else:
+                raise ApiError(f"Google API error: {e}")

git_llm_tool/providers/openai.py

@@ -0,0 +1,93 @@
+"""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 OpenAiProvider(LlmProvider):
+    """OpenAI GPT provider implementation."""
+
+    def __init__(self, config: AppConfig):
+        """Initialize OpenAI provider."""
+        super().__init__(config)
+
+        # Get API key
+        api_key = config.llm.api_keys.get("openai")
+        if not api_key:
+            raise ApiError("OpenAI API key not found in configuration")
+
+        # Initialize OpenAI client
+        self.client = openai.OpenAI(api_key=api_key)
+
+        # Determine model
+        model = config.llm.default_model
+        if not model.startswith(("gpt-", "o1-")):
+            # Fallback to GPT-4o if model doesn't look like OpenAI model
+            model = "gpt-4o"
+        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 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 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 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 OpenAI API")
+
+        except openai.AuthenticationError:
+            raise ApiError("Invalid OpenAI API key")
+        except openai.RateLimitError:
+            raise ApiError("OpenAI API rate limit exceeded")
+        except openai.APIConnectionError:
+            raise ApiError("Failed to connect to OpenAI API")
+        except openai.APIError as e:
+            raise ApiError(f"OpenAI API error: {e}")
+        except Exception as e:
+            raise ApiError(f"Unexpected error calling OpenAI API: {e}")

git_llm_tool-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 skyler-gogolook
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.