feat: migrate to LiteLLM for AI model support

- Replace OpenAI client with LiteLLM for broader model compatibility
- Remove OpenAI and Anthropic provider-specific code
- Update configuration to use AI_MODEL and AI_API_KEY environment variables
- Simplify setup command to configure model and API key

This change enhances the tool's flexibility by supporting a wider range of AI models through LiteLLM, simplifying configuration and removing provider-specific dependencies.

Author: subhayu99

README.md

@@ -71,7 +71,7 @@ Smart Commit turns your commit history into a valuable project resource that tel
 
 - Python 3.10 or higher
 - Git repository (for generating commit messages)
-- API key for your chosen AI provider (OpenAI or Anthropic)
+- API key for your chosen AI provider (100+ models supported thanks to [LiteLLM](https://litellm.ai))
 
 ### Using uv (Recommended)
 
@@ -100,12 +100,23 @@ pip install smart-commit-ai[all]
 
 ## Quick Setup
 
+`smart-commit` is configured primarily through environment variables, which is secure and flexible.
+
 ```bash
-# Quick setup with OpenAI
-smart-commit setup --provider openai --model gpt-4o --api-key your-api-key
+# Set your AI model and API key
+export AI_MODEL="openai/gpt-4o"  # Or "claude-3-sonnet-20240229", "gemini/gemini-1.5-pro", etc.
+export AI_API_KEY="your-super-secret-api-key"
+
+# You can add these to your .bashrc, .zshrc, or shell profile to make them permanent.
+```
 
-# Or use the short alias
-sc setup --provider openai --model gpt-4o --api-key your-api-key
+The `AI_MODEL` can be set to any model supported by `litellm`. For a full list of available providers and model names, please refer to the [LiteLLM Provider Documentation](https://docs.litellm.ai/docs/providers).
+
+You can also run the setup command to save a fallback configuration file:
+
+```bash
+# This will guide you through saving a config file.
+smart-commit setup
 ```
 
 ## Usage
@@ -168,7 +179,6 @@ The configuration now includes enhanced features for better commit message gener
 
 ```toml
 [ai]
-provider = "openai"
 model = "gpt-4o"
 api_key = "your-api-key"
 max_tokens = 500

pyproject.toml

@@ -35,7 +35,7 @@ classifiers = [
 ]
 dependencies = [
     "typer>=0.9.0",
-    "openai>=1.56.0",
+    "litellm>=1.73.6.post1",
     "pydantic>=2.0.0",
     "rich>=13.0.0",
     "toml>=0.10.2",
@@ -66,11 +66,8 @@ dev = [
     "twine>=4.0.0",
     "build>=0.10.0",
 ]
-anthropic = [
-    "anthropic>=0.25.0",
-]
 all = [
-    "smart-commit-ai[dev,anthropic]",
+    "smart-commit-ai[dev]",
 ]
 
 [tool.hatch.version]

smart_commit/ai_providers.py

@@ -1,9 +1,6 @@
 """AI provider implementations."""
-
 from abc import ABC, abstractmethod
-
-from openai import OpenAI
-
+import litellm
 from smart_commit.utils import remove_backticks
 
 
@@ -15,54 +12,39 @@ def generate_commit_message(self, prompt: str, **kwargs) -> str:
         """Generate a commit message using the AI provider."""
         pass
 
+class LiteLLMProvider(AIProvider):
+    """LiteLLM provider implementation."""
 
-class OpenAIProvider(AIProvider):
-    """OpenAI provider implementation."""
-    
-    def __init__(self, api_key: str, model: str = "gpt-4o", **kwargs):
-        self.client = OpenAI(api_key=api_key)
+    def __init__(self, api_key: str, model: str, **kwargs):
+        if not api_key:
+            raise ValueError("API_KEY is required for LiteLLMProvider.")
+        if not model:
+            raise ValueError("AI_MODEL is required for LiteLLMProvider.")
+        
+        self.api_key = api_key
         self.model = model
         self.kwargs = kwargs
-    
+
     def generate_commit_message(self, prompt: str, **kwargs) -> str:
-        """Generate commit message using OpenAI."""
+        """Generate commit message using LiteLLM."""
         merged_kwargs = {**self.kwargs, **kwargs}
 
-        response = self.client.chat.completions.create(
-            model=self.model,
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=merged_kwargs.get("max_tokens", 500),
-            temperature=merged_kwargs.get("temperature", 0.1),
-        )
-        
-        return remove_backticks((response.choices[0].message.content or "").strip())
-
-
-class AnthropicProvider(AIProvider):
-    """Anthropic provider implementation (placeholder)."""
-    
-    def __init__(self, api_key: str, model: str = "claude-3-sonnet-20240229", **kwargs):
-        # This would require the anthropic library
-        # import anthropic
-        # self.client = anthropic.Anthropic(api_key=api_key)
-        self.model = model
-        self.kwargs = kwargs
-        raise NotImplementedError("Anthropic provider not implemented yet")
-    
-    def generate_commit_message(self, prompt: str, **kwargs) -> str:
-        """Generate commit message using Anthropic."""
-        # Implementation would go here
-        raise NotImplementedError("Anthropic provider not implemented yet")
-
-
-def get_ai_provider(provider_name: str, api_key: str, model: str, **kwargs) -> AIProvider:
-    """Factory function to get AI provider."""
-    providers = {
-        "openai": OpenAIProvider,
-        "anthropic": AnthropicProvider,
-    }
-    
-    if provider_name not in providers:
-        raise ValueError(f"Unsupported AI provider: {provider_name}")
-    
-    return providers[provider_name](api_key=api_key, model=model, **kwargs)
+        try:
+            response = litellm.completion(
+                model=self.model,
+                messages=[{"role": "user", "content": prompt}],
+                api_key=self.api_key,
+                max_tokens=merged_kwargs.get("max_tokens", 500),
+                temperature=merged_kwargs.get("temperature", 0.1),
+            )
+            # The response object is a ModelResponse, which is dict-like
+            return remove_backticks((response.choices[0].message.content or "").strip())
+        except Exception as e:
+            # LiteLLM provides rich exception types, you can handle them specifically if needed
+            # For now, we'll just re-raise a generic error.
+            raise RuntimeError(f"LiteLLM failed to generate a response: {e}") from e
+
+def get_ai_provider(api_key: str, model: str, **kwargs) -> AIProvider:
+    """Factory function to get the LiteLLM AI provider."""
+    # The factory is now much simpler.
+    return LiteLLMProvider(api_key=api_key, model=model, **kwargs)

smart_commit/cli.py

@@ -44,6 +44,19 @@ def generate(
     try:
         # Load configuration
         config = config_manager.load_config()
+
+        # Get AI credentials from environment variables first, then from config
+        api_key = os.getenv("AI_API_KEY") or config.ai.api_key
+        model = os.getenv("AI_MODEL") or config.ai.model
+
+        if not api_key:
+            console.print("[red]Error: AI_API_KEY environment variable or api_key in config not set.[/red]")
+            console.print("Please run `smart-commit setup` or set the environment variable.")
+            raise typer.Exit(1)
+        
+        if not model:
+            console.print("[red]Error: AI_MODEL environment variable or model in config not set.[/red]")
+            raise typer.Exit(1)
 
         # Check for staged changes
         staged_changes = _get_staged_changes()
@@ -86,13 +99,11 @@ def generate(
 
         try:
             ai_provider = get_ai_provider(
-                provider_name=config.ai.provider,
-                api_key=config.ai.api_key or "",
-                model=config.ai.model,
+                api_key=api_key,
+                model=model,
                 max_tokens=config.ai.max_tokens,
                 temperature=config.ai.temperature
             )
-            
             raw_message = ai_provider.generate_commit_message(prompt)
 
             # Format message
@@ -180,28 +191,28 @@ def context(
 
 @app.command()
 def setup(
-    provider: str = typer.Option("openai", help="AI provider (openai, anthropic)"),
-    model: str = typer.Option("gpt-4o", help="Model to use"),
+    model: str = typer.Option("openai/gpt-4o", help="Model to use (e.g., 'openai/gpt-4o', 'claude-3-haiku-20240307')"),
     api_key: Optional[str] = typer.Option(None, help="API key (will prompt if not provided)"),
 ) -> None:
     """Quick setup for smart-commit."""
 
     console.print("[bold blue]Smart-Commit Setup[/bold blue]")
 
+    console.print("This will save your configuration globally. For best practice, use environment variables:")
+    console.print("  [cyan]export AI_MODEL='model_name'[/cyan]")
+    console.print("  [cyan]export AI_API_KEY='your_api_key'[/cyan]")
     if not api_key:
-        api_key = Prompt.ask(f"Enter your {provider.upper()} API key", password=True)
+        api_key = Prompt.ask("Enter your API key", password=True)
 
-    # Create basic config
+    # Save to global config as a fallback
     config = config_manager.load_config()
-    config.ai.provider = provider
     config.ai.model = model
     config.ai.api_key = api_key
 
     # Save global config
     config_manager.save_config(config, local=False)
 
     console.print("[green]✓ Configuration saved successfully![/green]")
-    console.print(f"Provider: {provider}")
     console.print(f"Model: {model}")
     console.print(f"Config saved to: {config_manager.global_config_path}")
 

smart_commit/config.py

@@ -70,11 +70,13 @@ class CommitTemplateConfig(BaseModel):
 
 class AIConfig(BaseModel):
     """Configuration for AI provider."""
-    provider: str = Field(default="openai", description="AI provider (openai, anthropic, etc.)")
-    model: str = Field(default="gpt-4o", description="Model to use")
-    api_key: Optional[str] = Field(default=None, description="API key (can be set via environment)")
+    # provider: str = Field(default="openai", description="AI provider (openai, anthropic, etc.)") <- REMOVE
+    model: str = Field(default="openai/gpt-4o", description="Model to use (e.g., 'openai/gpt-4o', 'claude-3-sonnet-20240229')")
+    api_key: Optional[str] = Field(default=None, description="API key (best set via AI_API_KEY environment variable)")
     max_tokens: int = Field(default=500, description="Maximum tokens for response")
     temperature: float = Field(default=0.1, description="Temperature for AI generation")
+    # this field is for backwards compatibility
+    provider: str = Field(default="openai", description="AI provider (openai, anthropic, etc.) [Deprecated]")
 
 
 class RepositoryConfig(BaseModel):

smart_commit/mcp.py

@@ -1,5 +1,6 @@
 """MCP (Model Context Protocol) server implementation using FastMCP."""
 
+import os
 import subprocess
 from pathlib import Path
 from typing import Optional
@@ -85,6 +86,18 @@ def generate_commit_message(
         show_prompt: Whether to include the generated prompt in the response
     """
     try:
+        # ...
+        # Load configuration
+        config_manager = ConfigManager()
+        config = config_manager.load_config()
+
+        # Get AI credentials from environment variables first, then from config
+        api_key = os.getenv("AI_API_KEY") or config.ai.api_key
+        model = os.getenv("AI_MODEL") or config.ai.model
+
+        if not api_key or not model:
+            return "Error: AI_MODEL and AI_API_KEY must be set as environment variables or in the config."
+        
         repo_path = Path(repository_path) if repository_path else None
 
         # Get staged changes
@@ -118,9 +131,8 @@ def generate_commit_message(
 
         # Generate commit message
         ai_provider = get_ai_provider(
-            provider_name=config.ai.provider,
-            api_key=config.ai.api_key or "",
-            model=config.ai.model,
+            api_key=api_key,
+            model=model,
             max_tokens=config.ai.max_tokens,
             temperature=config.ai.temperature
         )