feat: implement AI provider architecture with Gemini and Deepseek support

.env.example

@@ -0,0 +1,34 @@
+# AI Provider API Keys (Required)
+GEMINI_API_KEY=your_gemini_api_key_here
+DEEPSEEK_API_KEY=your_deepseek_api_key_here
+OPENAI_API_KEY=your_openai_api_key_here    # Optional
+ANTHROPIC_API_KEY=your_claude_api_key_here  # Optional
+
+# Provider Configuration
+ENABLED_AI_PROVIDERS=gemini,deepseek
+AI_PROVIDER_FALLBACK_CHAIN=gemini,deepseek
+
+# Gemini Settings
+GEMINI_MODEL=gemini-2.0-flash-001
+GEMINI_TEMPERATURE=0.8
+GEMINI_TOP_P=0.95
+GEMINI_MAX_TOKENS=8192
+
+# DeepSeek Settings
+DEEPSEEK_TEMPERATURE=0.7
+
+# ChatGPT Settings (Optional)
+OPENAI_MODEL=gpt-4
+OPENAI_TEMPERATURE=0.7
+OPENAI_MAX_TOKENS=4000
+OPENAI_TOP_P=0.95
+OPENAI_FREQ_PENALTY=0
+OPENAI_PRES_PENALTY=0
+
+# Claude Settings (Optional)
+CLAUDE_MODEL=claude-3-opus-20240229
+CLAUDE_TEMPERATURE=0.7
+CLAUDE_MAX_TOKENS=4000
+
+# GitHub Configuration
+GITHUB_TOKEN=your_github_token_here  # Required for GitHub API access

.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "go.goroot": "/Users/hung/.local/share/mise/installs/go/1.23.5",
+    "debug.javascript.defaultRuntimeExecutable": {
+        "pwa-node": "/Users/hung/.local/share/mise/shims/node"
+    },
+    "python.defaultInterpreterPath": "/Users/hung/.local/share/mise/installs/python/3.13.1/bin/python",
+    "go.alternateTools": {
+        "go": "/Users/hung/.local/share/mise/shims/go",
+        "dlv": "/Users/hung/.local/share/mise/shims/dlv"
+    }
+}

README.md

@@ -79,6 +79,28 @@ This GitHub Action uses the Gemini AI API to provide code review feedback. It wo
 3. **Providing feedback**: Gemini AI examines the code and generates review comments.
 4. **Delivering the review**: The Action adds the comments directly to your pull request on GitHub.
 
+## Using Deepseek AI for Code Review
+
+In addition to Gemini, this action now supports Deepseek AI for code review. To use Deepseek:
+
+1. Get your Deepseek API key from [Deepseek Platform](https://platform.deepseek.com/)
+2. Add the Deepseek API key as a GitHub Secret named `DEEPSEEK_API_KEY`
+3. Modify your workflow file to use Deepseek:
+
+```yaml
+      - uses: truongnh1992/gemini-ai-code-reviewer@main
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          AI_PROVIDER: deepseek
+          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
+          DEEPSEEK_MODEL: deepseek-coder-33b-instruct # Optional
+          EXCLUDE: "*.md,*.txt,package-lock.json,*.yml,*.yaml"
+```
+
+- The default model is `deepseek-coder-33b-instruct`
+- Trigger a Deepseek review by commenting `/deepseek-review` on your PR
+- See [CHANGELOG.md](docs/change_logs.md) for more details about the multi-provider support
+
 ## License
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more information.

action.yml

@@ -1,22 +1,34 @@
-name: "Gemini AI Code Reviewer"
-description: "This GitHub Action automatically reviews PRs using Google's Gemini AI model."
+name: "AI Code Reviewer"
+description: "This GitHub Action automatically reviews PRs using various AI models (Gemini, Deepseek, etc.)"
 author: 'truongnh1992'
 
 inputs:
   GITHUB_TOKEN:
     description: 'GitHub token to interact with the repository'
     required: true
+  AI_PROVIDER:
+    description: 'AI provider to use (gemini, deepseek)'
+    required: false
+    default: 'gemini'
   GEMINI_API_KEY:
-    description: 'Google Gemini API key'
-    required: true
+    description: 'Google Gemini API key (required if using Gemini)'
+    required: false
   GEMINI_MODEL:
     description: 'The Gemini model to use for code review'
     required: false
-    default: 'gemini-1.5-flash-002'
+    default: 'gemini-2.0-flash-001'
+  DEEPSEEK_API_KEY:
+    description: 'Deepseek API key (required if using Deepseek)'
+    required: false
+  DEEPSEEK_MODEL:
+    description: 'The Deepseek model to use for code review'
+    required: false
+    default: 'deepseek-coder-33b-instruct'
   EXCLUDE:
     description: 'Comma-separated list of file patterns to exclude'
     required: false
     default: ''
+
 runs:
   using: 'composite'
   steps:
@@ -30,12 +42,16 @@ runs:
       shell: bash
       run: |
         python -m pip install --upgrade pip
-        pip install google-generativeai PyGithub unidiff google-ai-generativelanguage==0.6.10 github3.py==1.3.0
+        pip install google-generativeai PyGithub unidiff requests
 
     - name: Run code review
       shell: bash
       env:
         GITHUB_TOKEN: ${{ inputs.GITHUB_TOKEN }}
+        AI_PROVIDER: ${{ inputs.AI_PROVIDER }}
         GEMINI_API_KEY: ${{ inputs.GEMINI_API_KEY }}
+        GEMINI_MODEL: ${{ inputs.GEMINI_MODEL }}
+        DEEPSEEK_API_KEY: ${{ inputs.DEEPSEEK_API_KEY }}
+        DEEPSEEK_MODEL: ${{ inputs.DEEPSEEK_MODEL }}
         EXCLUDE: ${{ inputs.EXCLUDE }}
-      run: python ${{ github.action_path }}/review_code_gemini.py
+      run: python ${{ github.action_path }}/review_code.py

ai_providers/__init__.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any
+
+class AIProvider(ABC):
+    """Abstract base class for AI code review providers."""
+
+    @abstractmethod
+    def configure(self) -> None:
+        """Configure the AI provider with necessary credentials and settings."""
+        pass
+
+    @abstractmethod
+    def generate_review(self, prompt: str) -> List[Dict[str, Any]]:
+        """Generate code review from the given prompt.
+
+        Args:
+            prompt (str): The code review prompt
+
+        Returns:
+            List[Dict[str, Any]]: List of review comments in the format:
+            [{"lineNumber": int, "reviewComment": str}]
+        """
+        pass
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """Get the name of the AI provider."""
+        pass

ai_providers/deepseek_provider.py

@@ -0,0 +1,74 @@
+import os
+import json
+from typing import List, Dict, Any
+import requests
+
+from ai_providers import AIProvider
+
+class DeepseekProvider(AIProvider):
+    """Deepseek AI provider implementation."""
+
+    def __init__(self):
+        self.api_url = "https://api.deepseek.com/v1/chat/completions"  # Example URL, adjust as needed
+        self.api_key = None
+        self.model = None
+        self.config = {
+            "temperature": 0.8,
+            "max_tokens": 8192
+        }
+
+    def configure(self) -> None:
+        """Configure Deepseek with API key and model."""
+        self.api_key = os.environ.get('DEEPSEEK_API_KEY')
+        if not self.api_key:
+            raise ValueError("DEEPSEEK_API_KEY environment variable is required")
+        self.model = os.environ.get('DEEPSEEK_MODEL', 'deepseek-coder-33b-instruct')
+
+    def generate_review(self, prompt: str) -> List[Dict[str, Any]]:
+        """Generate code review using Deepseek AI."""
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.api_key}"
+            }
+
+            data = {
+                "model": self.model,
+                "messages": [
+                    {"role": "user", "content": prompt}
+                ],
+                "temperature": self.config["temperature"],
+                "max_tokens": self.config["max_tokens"]
+            }
+
+            response = requests.post(self.api_url, headers=headers, json=data)
+            response.raise_for_status()
+
+            response_data = response.json()
+            response_text = response_data['choices'][0]['message']['content'].strip()
+
+            if response_text.startswith('```json'):
+                response_text = response_text[7:]
+            if response_text.endswith('```'):
+                response_text = response_text[:-3]
+            response_text = response_text.strip()
+
+            try:
+                data = json.loads(response_text)
+                if "reviews" in data and isinstance(data["reviews"], list):
+                    return [
+                        review for review in data["reviews"]
+                        if "lineNumber" in review and "reviewComment" in review
+                    ]
+            except json.JSONDecodeError as e:
+                print(f"Error decoding JSON response: {e}")
+                return []
+        except Exception as e:
+            print(f"Error during Deepseek API call: {e}")
+            return []
+
+        return []
+
+    def get_name(self) -> str:
+        """Get the provider name."""
+        return "Deepseek AI"

ai_providers/factory.py

@@ -0,0 +1,49 @@
+from typing import Dict, Type
+from ai_providers import AIProvider
+from ai_providers.gemini_provider import GeminiProvider
+from ai_providers.deepseek_provider import DeepseekProvider
+
+class AIProviderFactory:
+    """Factory class for creating and managing AI providers."""
+
+    _providers: Dict[str, Type[AIProvider]] = {
+        'gemini': GeminiProvider,
+        'deepseek': DeepseekProvider
+    }
+
+    @classmethod
+    def get_provider(cls, provider_name: str) -> AIProvider:
+        """Get an instance of the specified AI provider.
+        
+        Args:
+            provider_name (str): Name of the provider to use ('gemini', 'deepseek', etc.)
+            
+        Returns:
+            AIProvider: Configured instance of the specified provider
+            
+        Raises:
+            ValueError: If the specified provider is not supported
+        """
+        provider_class = cls._providers.get(provider_name.lower())
+        if not provider_class:
+            supported = list(cls._providers.keys())
+            raise ValueError(f"Unsupported AI provider: {provider_name}. Supported providers: {supported}")
+
+        provider = provider_class()
+        provider.configure()
+        return provider
+
+    @classmethod
+    def register_provider(cls, name: str, provider_class: Type[AIProvider]) -> None:
+        """Register a new AI provider.
+        
+        Args:
+            name (str): Name to register the provider under
+            provider_class (Type[AIProvider]): The provider class to register
+        """
+        cls._providers[name.lower()] = provider_class
+
+    @classmethod
+    def get_available_providers(cls) -> list[str]:
+        """Get list of available provider names."""
+        return list(cls._providers.keys())

ai_providers/gemini_provider.py

@@ -0,0 +1,55 @@
+import os
+import json
+from typing import List, Dict, Any
+import google.generativeai as Client
+
+from ai_providers import AIProvider
+
+class GeminiProvider(AIProvider):
+    """Gemini AI provider implementation."""
+
+    def __init__(self):
+        self.model = None
+        self.generation_config = {
+            "max_output_tokens": 8192,
+            "temperature": 0.8,
+            "top_p": 0.95,
+        }
+
+    def configure(self) -> None:
+        """Configure Gemini with API key and model."""
+        Client.configure(api_key=os.environ.get('GEMINI_API_KEY'))
+        model_name = os.environ.get('GEMINI_MODEL', 'gemini-2.0-flash-001')
+        self.model = Client.GenerativeModel(model_name)
+
+    def generate_review(self, prompt: str) -> List[Dict[str, Any]]:
+        """Generate code review using Gemini AI."""
+        try:
+            response = self.model.generate_content(prompt, generation_config=self.generation_config)
+
+            response_text = response.text.strip()
+            if response_text.startswith('```json'):
+                response_text = response_text[7:]
+            if response_text.endswith('```'):
+                response_text = response_text[:-3]
+            response_text = response_text.strip()
+
+            try:
+                data = json.loads(response_text)
+                if "reviews" in data and isinstance(data["reviews"], list):
+                    return [
+                        review for review in data["reviews"]
+                        if "lineNumber" in review and "reviewComment" in review
+                    ]
+            except json.JSONDecodeError as e:
+                print(f"Error decoding JSON response: {e}")
+                return []
+        except Exception as e:
+            print(f"Error during Gemini API call: {e}")
+            return []
+
+        return []
+
+    def get_name(self) -> str:
+        """Get the provider name."""
+        return "Gemini AI"