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

git_llm_tool/providers/base.py

@@ -0,0 +1,203 @@
+"""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 this **exact format**:
+<summary>
+- 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:
+Implement user authentication system
+- 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 = """
+
+Example format:
+{jira_ticket} Implement user authentication system
+- 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,85 @@
+"""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
+
+# LangChain providers (now the only supported providers)
+from git_llm_tool.providers.openai_langchain import OpenAiLangChainProvider
+from git_llm_tool.providers.anthropic_langchain import AnthropicLangChainProvider
+from git_llm_tool.providers.azure_openai_langchain import AzureOpenAiLangChainProvider
+from git_llm_tool.providers.ollama_langchain import OllamaLangChainProvider
+from git_llm_tool.providers.gemini_langchain import GeminiLangChainProvider
+
+
+def get_provider(config: AppConfig) -> LlmProvider:
+    """Get appropriate LLM provider based on model name in config.
+
+    Args:
+        config: Application configuration
+
+    Returns:
+        Initialized LLM provider (LangChain-based only)
+
+    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 AzureOpenAiLangChainProvider(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 OpenAiLangChainProvider(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 AnthropicLangChainProvider(config)
+
+    # Google Gemini models
+    elif model.startswith("gemini-"):
+        if "google" not in config.llm.api_keys:
+            raise ApiError("Google API key required for Gemini models")
+        return GeminiLangChainProvider(config)
+
+    # Ollama models (local)
+    elif model.startswith(("llama", "codellama", "mistral", "qwen", "phi")):
+        return OllamaLangChainProvider(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 AzureOpenAiLangChainProvider(config)
+
+        # Try OpenAI second (most common)
+        elif "openai" in config.llm.api_keys:
+            return OpenAiLangChainProvider(config)
+
+        # Try Anthropic third
+        elif "anthropic" in config.llm.api_keys:
+            return AnthropicLangChainProvider(config)
+
+        # Try Google fourth
+        elif "google" in config.llm.api_keys:
+            return GeminiLangChainProvider(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\n"
+                "Or use Ollama for local processing (no API key needed)"
+            )

git_llm_tool/providers/gemini_langchain.py

@@ -0,0 +1,57 @@
+"""Gemini LangChain provider implementation."""
+
+from typing import Optional
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+from git_llm_tool.core.config import AppConfig
+from git_llm_tool.core.exceptions import ApiError
+from git_llm_tool.providers.langchain_base import LangChainProvider
+
+
+class GeminiLangChainProvider(LangChainProvider):
+    """Google Gemini provider using LangChain."""
+
+    def __init__(self, config: AppConfig):
+        """Initialize Gemini provider."""
+        try:
+            # Get API key
+            api_key = config.llm.api_keys.get("google")
+            if not api_key:
+                raise ApiError("Google API key not found in configuration")
+
+            # Determine model
+            model = config.llm.default_model
+            if not model.startswith("gemini-"):
+                # Fallback to Gemini 1.5 Pro if model doesn't look like Gemini model
+                model = "gemini-1.5-pro"
+
+            # Initialize the Gemini LLM
+            llm = ChatGoogleGenerativeAI(
+                model=model,
+                google_api_key=api_key,
+                temperature=0.1,  # Keep it deterministic for commit messages
+                convert_system_message_to_human=True  # Required for Gemini
+            )
+
+            super().__init__(config, llm)
+
+        except Exception as e:
+            raise ApiError(f"Failed to initialize Gemini provider: {e}")
+
+    def validate_config(self) -> bool:
+        """Validate Gemini configuration."""
+        try:
+            # Test with a simple request
+            response = self.llm.invoke("test")
+            return True
+        except Exception as e:
+            raise ApiError(f"Gemini validation failed: {e}")
+
+    def get_model_info(self) -> dict:
+        """Get information about the current model."""
+        return {
+            "provider": "google",
+            "model": self.config.llm.default_model,
+            "service": "Google Generative AI",
+            "local": False
+        }