Review Agent: Uploaded remaining files

src/__init__.py

@@ -0,0 +1 @@
+# Code Review Agent Package

src/core/__init__.py

@@ -0,0 +1 @@
+# Core Package for Code Review Agent

src/core/agent_manager.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Agent Manager
+
+This module provides the main orchestrator for the Code Review Agent.
+It coordinates the review process and manages the state of the application.
+"""
+
+import os
+import time
+import logging
+import tempfile
+import json
+from datetime import datetime
+import gradio as gr
+
+from src.core.language_detector import LanguageDetector
+from src.services.code_analyzer import CodeAnalyzer
+from src.services.report_generator import ReportGenerator
+from src.services.repository_service import RepositoryService
+from src.services.security_scanner import SecurityScanner
+from src.services.performance_analyzer import PerformanceAnalyzer
+
+logger = logging.getLogger(__name__)
+
+
+class AgentManager:
+    """
+    Main orchestrator for the Code Review Agent.
+    
+    This class coordinates the review process, manages the application state,
+    and provides the interface between the UI and the business logic.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the AgentManager.
+        """
+        # Initialize state management
+        self.state = {
+            'repo_url': None,
+            'progress': {},
+            'results': {},
+            'current_step': None
+        }
+        
+        # Initialize services
+        self.language_detector = LanguageDetector()
+        self.code_analyzer = CodeAnalyzer()
+        self.report_generator = ReportGenerator()
+        self.repository_service = RepositoryService()
+        self.security_scanner = SecurityScanner()
+        self.performance_analyzer = PerformanceAnalyzer()
+        self.temp_dir = tempfile.mkdtemp(prefix="code_review_agent_")
+        
+        logger.info(f"Initialized AgentManager with temp directory: {self.temp_dir}")
+    
+    def start_review(self, repo_url, github_token=None, selected_languages=None):
+        """
+        Start the code review process for a GitHub repository.
+        
+        Args:
+            repo_url (str): The URL of the GitHub repository to review.
+            github_token (str, optional): GitHub authentication token for private repositories.
+            selected_languages (list, optional): List of languages to analyze. If None,
+                                                languages will be auto-detected.
+        
+        Returns:
+            tuple: (progress_group, overall_progress, status_message, results_dashboard) - Updated UI components.
+        """
+        # Initialize progress components outside the try block
+        progress_group = gr.Group(visible=True)
+        overall_progress = gr.Slider(value=0)
+        status_message = gr.Markdown("*Starting review...*")
+        
+        try:
+            # Initialize state for new review
+            self.state = {
+                'repo_url': repo_url,
+                'progress': {},
+                'results': {},
+                'current_step': None
+            }
+            
+            # Clone repository
+            self._update_progress("Repository Cloning", 0, overall_progress, status_message)
+            repo_path = self._clone_repository(repo_url, github_token)
+            self._update_progress("Repository Cloning", 100, overall_progress, status_message)
+            
+            # Detect languages
+            self._update_progress("Language Detection", 0, overall_progress, status_message)
+            if selected_languages and len(selected_languages) > 0:
+                languages = selected_languages
+                logger.info(f"Using selected languages: {languages}")
+            else:
+                languages = self.language_detector.detect_languages(repo_path)
+                logger.info(f"Auto-detected languages: {languages}")
+            
+            self.state['languages'] = languages
+            self._update_progress("Language Detection", 100, overall_progress, status_message)
+            
+            # Perform code analysis
+            self._update_progress("Code Analysis", 0, overall_progress, status_message)
+            code_analysis_results = self.code_analyzer.analyze_repository(repo_path, languages)
+            self.state['results']['code_analysis'] = code_analysis_results
+            self._update_progress("Code Analysis", 100, overall_progress, status_message)
+            
+            # Perform security scanning
+            self._update_progress("Security Scanning", 0, overall_progress, status_message)
+            security_results = self.security_scanner.scan_repository(repo_path, languages)
+            self.state['results']['security'] = security_results
+            self._update_progress("Security Scanning", 100, overall_progress, status_message)
+            
+            # Perform performance analysis
+            self._update_progress("Performance Analysis", 0, overall_progress, status_message)
+            performance_results = self.performance_analyzer.analyze_repository(repo_path, languages)
+            self.state['results']['performance'] = performance_results
+            self._update_progress("Performance Analysis", 100, overall_progress, status_message)
+            
+            # Perform AI review
+            self._update_progress("AI Review", 0, overall_progress, status_message)
+            ai_review_results = self._perform_ai_review(repo_path, languages)
+            self.state['results']['ai_review'] = ai_review_results
+            self._update_progress("AI Review", 100, overall_progress, status_message)
+            
+            # Generate report
+            self._update_progress("Report Generation", 0, overall_progress, status_message)
+            repo_name = repo_url.split('/')[-1].replace('.git', '')
+            report_paths = self.report_generator.generate_report(
+                repo_name, self.state['results']
+            )
+            self.state['report_paths'] = report_paths
+            self._update_progress("Report Generation", 100, overall_progress, status_message)
+            
+            # Update results dashboard
+            results_dashboard = self._create_results_dashboard(self.state['results'])
+            results_dashboard.update(visible=True)
+            
+            return progress_group, overall_progress, status_message, results_dashboard
+            
+        except Exception as e:
+            logger.exception(f"Error during code review: {e}")
+            # Update progress components with error
+            status_message.update(value=f"*Error: {str(e)}*")
+            return progress_group, overall_progress, status_message, None
+    
+    def export_report(self, results_dashboard, export_format):
+        """
+        Export the code review report in the specified format.
+        
+        Args:
+            results_dashboard: The results dashboard component.
+            export_format (str): The format to export the report in ('pdf', 'json', 'html', 'csv').
+        
+        Returns:
+            str: The path to the exported file.
+        """
+        try:
+            if not self.state.get('results'):
+                logger.warning("No results available to export")
+                return None
+            
+            # Get the actual format value from the textbox component
+            format_value = export_format.value if hasattr(export_format, 'value') else export_format
+            
+            # Create exports directory if it doesn't exist
+            exports_dir = os.path.join(os.path.dirname(__file__), '..', '..', 'exports')
+            os.makedirs(exports_dir, exist_ok=True)
+            
+            # Generate filename with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            repo_name = self.state['repo_url'].split('/')[-1].replace('.git', '')
+            filename = f"{repo_name}_review_{timestamp}.{format_value}"
+            filepath = os.path.join(exports_dir, filename)
+            
+            # Export report in the specified format using report_generator
+            report_paths = self.report_generator.generate_report(
+                repo_name, self.state['results'], format_value
+            )
+            
+            if format_value in report_paths:
+                return report_paths[format_value]
+            else:
+                logger.warning(f"Unsupported export format: {format_value}")
+                return None
+            
+            logger.info(f"Exported report to {filepath}")
+            return filepath
+            
+        except Exception as e:
+            logger.exception(f"Error exporting report: {e}")
+            return None
+    
+    def _clone_repository(self, repo_url, github_token=None):
+        """
+        Clone the GitHub repository to a temporary directory.
+        
+        Args:
+            repo_url (str): The URL of the GitHub repository to clone.
+            github_token (str, optional): GitHub authentication token for private repositories.
+        
+        Returns:
+            str: The path to the cloned repository.
+        """
+        # Import the repository service here to avoid circular imports
+        from src.services.repository_service import RepositoryService
+        
+        # Create a repository service instance
+        repo_service = RepositoryService(base_temp_dir=self.temp_dir)
+        
+        # Clone the repository using the service
+        try:
+            # If a GitHub token is provided, use it for authentication
+            if github_token and github_token.strip():
+                # Modify the URL to include the token for authentication
+                auth_url = repo_url.replace('https://', f'https://{github_token}@')
+                repo_path = repo_service.clone_repository(auth_url)
+                logger.info(f"Cloned repository using GitHub token authentication")
+            else:
+                # Clone without authentication (for public repositories)
+                repo_path = repo_service.clone_repository(repo_url)
+                logger.info(f"Cloned repository without authentication")
+            
+            return repo_path
+        except Exception as e:
+            logger.error(f"Error cloning repository: {e}")
+            raise
+    
+    def _perform_ai_review(self, repo_path, languages):
+        """
+        Perform AI-powered code review.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            languages (list): List of programming languages to analyze.
+        
+        Returns:
+            dict: AI review results.
+        """
+        try:
+            # This is a placeholder for AI review functionality
+            # In a real implementation, this would use the MCP AI review service
+            from src.mcp.ai_review import AIReviewMCP
+            
+            ai_reviewer = AIReviewMCP()
+            results = ai_reviewer.review_repository(repo_path, languages)
+            
+            logger.info(f"AI review completed for {len(languages)} languages")
+            return results
+        except Exception as e:
+            logger.error(f"Error during AI review: {e}")
+            return {
+                'error': str(e),
+                'suggestions': [],
+                'issues': []
+            }
+    
+    def _update_progress(self, step, value, overall_progress, status_message):
+        """
+        Update the progress components for a specific step.
+        
+        Args:
+            step (str): The step to update.
+            value (int): The progress value (0-100).
+            overall_progress: The overall progress slider component.
+            status_message: The status message markdown component.
+        """
+        # Update state
+        self.state['progress'][step] = value
+        self.state['current_step'] = step
+        
+        # Calculate overall progress
+        total_steps = 7  # Total number of steps in the review process
+        completed_steps = sum(1 for v in self.state['progress'].values() if v == 100)
+        current_step_progress = value if step in self.state['progress'] else 0
+        overall_value = (completed_steps * 100 + current_step_progress) / total_steps
+        
+        # Update UI components
+        overall_progress.update(value=overall_value)
+        status_message.update(value=f"*{step}: {value}%*")
+        
+        logger.info(f"Progress update: {step} - {value}% (Overall: {overall_value:.1f}%)")
+        time.sleep(0.5)  # Simulate progress update time
+    
+    def _create_results_dashboard(self, report):
+        """
+        Create a results dashboard component for the UI.
+        
+        Args:
+            report (dict): The code review report.
+        
+        Returns:
+            object: A results dashboard component.
+        """
+        # This is a placeholder. In a real implementation, this would create a
+        # results dashboard component for the UI.
+        class ResultsDashboard:
+            def __init__(self):
+                self.visible = False
+            
+            def update(self, visible=None):
+                if visible is not None:
+                    self.visible = visible
+                return self
+        
+        return ResultsDashboard()

src/core/language_detector.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Language Detector
+
+This module provides functionality for detecting programming languages in a repository.
+"""
+
+import os
+import logging
+from collections import Counter
+
+logger = logging.getLogger(__name__)
+
+# File extension to language mapping
+EXTENSION_TO_LANGUAGE = {
+    '.py': 'Python',
+    '.js': 'JavaScript',
+    '.jsx': 'JavaScript',
+    '.ts': 'TypeScript',
+    '.tsx': 'TypeScript',
+    '.java': 'Java',
+    '.go': 'Go',
+    '.rs': 'Rust',
+    '.cpp': 'C++',
+    '.cc': 'C++',
+    '.cxx': 'C++',
+    '.c': 'C',
+    '.h': 'C',
+    '.hpp': 'C++',
+    '.cs': 'C#',
+    '.php': 'PHP',
+    '.rb': 'Ruby',
+    '.swift': 'Swift',
+    '.kt': 'Kotlin',
+    '.scala': 'Scala',
+    '.r': 'R',
+    '.sh': 'Shell',
+    '.bash': 'Shell',
+    '.zsh': 'Shell',
+    '.html': 'HTML',
+    '.htm': 'HTML',
+    '.css': 'CSS',
+    '.scss': 'SCSS',
+    '.sass': 'SCSS',
+    '.less': 'Less',
+    '.md': 'Markdown',
+    '.json': 'JSON',
+    '.xml': 'XML',
+    '.yaml': 'YAML',
+    '.yml': 'YAML',
+    '.sql': 'SQL',
+    '.graphql': 'GraphQL',
+    '.gql': 'GraphQL',
+}
+
+# Special files to language mapping
+SPECIAL_FILES_TO_LANGUAGE = {
+    'Dockerfile': 'Docker',
+    'docker-compose.yml': 'Docker',
+    'docker-compose.yaml': 'Docker',
+    'Makefile': 'Make',
+    'CMakeLists.txt': 'CMake',
+    'package.json': 'JavaScript',
+    'tsconfig.json': 'TypeScript',
+    'requirements.txt': 'Python',
+    'setup.py': 'Python',
+    'pom.xml': 'Java',
+    'build.gradle': 'Java',
+    'Cargo.toml': 'Rust',
+    'go.mod': 'Go',
+}
+
+
+class LanguageDetector:
+    """
+    Detects programming languages in a repository.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the LanguageDetector.
+        """
+        logger.info("Initialized LanguageDetector")
+    
+    def detect_languages(self, repo_path):
+        """
+        Detect programming languages in a repository.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            list: A list of detected programming languages, sorted by prevalence.
+        """
+        logger.info(f"Detecting languages in repository: {repo_path}")
+        
+        language_counter = Counter()
+        
+        for root, dirs, files in os.walk(repo_path):
+            # Skip hidden directories and common non-code directories
+            dirs[:] = [d for d in dirs if not d.startswith('.') and 
+                      d not in ['node_modules', 'venv', '.git', '__pycache__', 'dist', 'build']]
+            
+            for file in files:
+                file_path = os.path.join(root, file)
+                
+                # Check if it's a special file
+                if file in SPECIAL_FILES_TO_LANGUAGE:
+                    language = SPECIAL_FILES_TO_LANGUAGE[file]
+                    language_counter[language] += 1
+                    continue
+                
+                # Check file extension
+                _, ext = os.path.splitext(file)
+                if ext in EXTENSION_TO_LANGUAGE:
+                    language = EXTENSION_TO_LANGUAGE[ext]
+                    language_counter[language] += 1
+        
+        # Get the top languages (limit to supported languages)
+        supported_languages = [
+            "Python", "JavaScript", "TypeScript", "Java", 
+            "Go", "Rust", "C++", "C#", "PHP", "Ruby",
+            "Swift", "Kotlin", "Scala", "R", "Shell"
+        ]
+        
+        detected_languages = [lang for lang, _ in language_counter.most_common() 
+                            if lang in supported_languages]
+        
+        logger.info(f"Detected languages: {detected_languages}")
+        return detected_languages
+    
+    def get_language_breakdown(self, repo_path):
+        """
+        Get a breakdown of programming languages in a repository by lines of code.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: A dictionary mapping languages to lines of code.
+        """
+        logger.info(f"Getting language breakdown for repository: {repo_path}")
+        
+        language_loc = {}
+        
+        for root, dirs, files in os.walk(repo_path):
+            # Skip hidden directories and common non-code directories
+            dirs[:] = [d for d in dirs if not d.startswith('.') and 
+                      d not in ['node_modules', 'venv', '.git', '__pycache__', 'dist', 'build']]
+            
+            for file in files:
+                file_path = os.path.join(root, file)
+                
+                # Determine the language
+                language = None
+                
+                # Check if it's a special file
+                if file in SPECIAL_FILES_TO_LANGUAGE:
+                    language = SPECIAL_FILES_TO_LANGUAGE[file]
+                else:
+                    # Check file extension
+                    _, ext = os.path.splitext(file)
+                    if ext in EXTENSION_TO_LANGUAGE:
+                        language = EXTENSION_TO_LANGUAGE[ext]
+                
+                if language:
+                    # Count lines of code
+                    try:
+                        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                            line_count = sum(1 for _ in f)
+                        
+                        if language in language_loc:
+                            language_loc[language] += line_count
+                        else:
+                            language_loc[language] = line_count
+                    except Exception as e:
+                        logger.warning(f"Error counting lines in {file_path}: {e}")
+        
+        logger.info(f"Language breakdown: {language_loc}")
+        return language_loc

src/main.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Code Review Agent - Main Entry Point
+
+This module serves as the entry point for the Code Review Agent application.
+It initializes the Gradio interface and starts the web server.
+"""
+
+import os
+import sys
+import logging
+from dotenv import load_dotenv
+
+# Add the project root to the Python path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Import application modules
+from src.ui.gradio_app import create_gradio_app
+from src.core.agent_manager import AgentManager
+
+# Configure logging
+# Create logs directory if it doesn't exist
+logs_dir = os.path.join(os.path.dirname(__file__), '..', 'logs')
+os.makedirs(logs_dir, exist_ok=True)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler(os.path.join(logs_dir, 'app.log'), mode='a')
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+
+def main():
+    """Main function to start the Code Review Agent application."""
+    # Load environment variables
+    load_dotenv()
+    
+    # Create logs directory if it doesn't exist
+    logs_dir = os.path.join(os.path.dirname(__file__), '..', 'logs')
+    os.makedirs(logs_dir, exist_ok=True)
+    
+    # Initialize the agent manager
+    agent_manager = AgentManager()
+    
+    # Create and launch the Gradio app
+    app = create_gradio_app(agent_manager)
+    
+    # Start the Gradio server
+    app.launch(server_name="0.0.0.0", server_port=7860)
+
+
+if __name__ == "__main__":
+    try:
+        logger.info("Starting Code Review Agent application")
+        main()
+    except Exception as e:
+        logger.exception(f"Error starting application: {e}")
+        sys.exit(1)

src/mcp/__init__.py

@@ -0,0 +1 @@
+# MCP Integration Package for Code Review Agent

src/mcp/ai_review.py

@@ -0,0 +1,451 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+AI Review Service
+
+This module provides functionality for AI-powered code review using Nebius Qwen2.5-72B-Instruct model.
+"""
+
+import os
+import logging
+import json
+import re
+from openai import OpenAI
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+class AIReviewService:
+    """
+    Service for AI-powered code review using Nebius Qwen2.5-72B-Instruct model.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the AIReviewService.
+        """
+        self.api_key = os.getenv('NEBIUS_API_KEY')
+        if not self.api_key:
+            logger.warning("NEBIUS_API_KEY not found in environment variables. AI review will not be available.")
+        else:
+            self.client = OpenAI(
+                base_url="https://api.studio.nebius.com/v1/",
+                api_key=self.api_key
+            )
+        
+        logger.info("Initialized AIReviewService")
+    
+    def is_available(self):
+        """
+        Check if the AI review service is available.
+        
+        Returns:
+            bool: True if the service is available, False otherwise.
+        """
+        return self.api_key is not None
+    
+    def review_code(self, file_path, file_content, language, context=None):
+        """
+        Review code using Qwen.
+        
+        Args:
+            file_path (str): The path to the file being reviewed.
+            file_content (str): The content of the file being reviewed.
+            language (str): The programming language of the file.
+            context (dict, optional): Additional context for the review.
+        
+        Returns:
+            dict: The review results.
+        """
+        if not self.is_available():
+            return {
+                'status': 'error',
+                'error': 'AI review service is not available. Please set NEBIUS_API_KEY in environment variables.',
+                'suggestions': [],
+            }
+        
+        logger.info(f"Reviewing {language} code in {file_path}")
+        
+        # Prepare the prompt for Qwen
+        prompt = self._prepare_prompt(file_path, file_content, language, context)
+        
+        try:
+            # Call Nebius API with Qwen2.5-72B-Instruct model
+            response = self.client.chat.completions.create(
+                model="Qwen/Qwen2.5-72B-Instruct",
+                max_tokens=4000,
+                temperature=0,
+                messages=[
+                    {"role": "system", "content": self._get_system_prompt(language)},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            # Parse the response
+            review_text = response.choices[0].message.content
+            suggestions = self._parse_review(review_text)
+            
+            return {
+                'status': 'success',
+                'review_text': review_text,
+                'suggestions': suggestions,
+            }
+        
+        except Exception as e:
+            logger.error(f"Error calling Qwen API: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'suggestions': [],
+            }
+    
+    def review_repository(self, repo_path, files, languages, analysis_results=None):
+        """
+        Review a repository using Qwen.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            files (list): A list of files to review.
+            languages (list): A list of programming languages in the repository.
+            analysis_results (dict, optional): Results from other analysis tools.
+        
+        Returns:
+            dict: The review results.
+        """
+        if not self.is_available():
+            return {
+                'status': 'error',
+                'error': 'AI review service is not available. Please set NEBIUS_API_KEY in environment variables.',
+                'reviews': {},
+                'summary': '',
+            }
+        
+        logger.info(f"Reviewing repository at {repo_path}")
+        
+        # Limit the number of files to review to avoid excessive API usage
+        max_files = 10
+        if len(files) > max_files:
+            logger.warning(f"Too many files to review ({len(files)}). Limiting to {max_files} files.")
+            files = files[:max_files]
+        
+        # Review each file
+        reviews = {}
+        for file_path in files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    file_content = f.read()
+                
+                # Determine the language based on file extension
+                _, ext = os.path.splitext(file_path)
+                language = self._get_language_from_extension(ext)
+                
+                if language:
+                    # Provide context from analysis results if available
+                    context = None
+                    if analysis_results:
+                        context = self._extract_context_for_file(file_path, analysis_results)
+                    
+                    # Review the file
+                    review_result = self.review_code(file_path, file_content, language, context)
+                    reviews[file_path] = review_result
+            
+            except Exception as e:
+                logger.error(f"Error reviewing file {file_path}: {e}")
+                reviews[file_path] = {
+                    'status': 'error',
+                    'error': str(e),
+                    'suggestions': [],
+                }
+        
+        # Generate a summary of the review
+        summary = self._generate_repository_summary(repo_path, reviews, languages, analysis_results)
+        
+        return {
+            'status': 'success',
+            'reviews': reviews,
+            'summary': summary,
+        }
+    
+    def _prepare_prompt(self, file_path, file_content, language, context=None):
+        """
+        Prepare a prompt for Qwen.
+        
+        Args:
+            file_path (str): The path to the file being reviewed.
+            file_content (str): The content of the file being reviewed.
+            language (str): The programming language of the file.
+            context (dict, optional): Additional context for the review.
+        
+        Returns:
+            str: The prompt for Qwen.
+        """
+        prompt = f"""Please review the following {language} code and provide constructive feedback:
+
+        File: {file_path}
+
+        ```{language}
+        {file_content}
+        ```
+
+        """
+        
+        if context:
+            prompt += "Additional context:\n"
+            if 'issues' in context:
+                prompt += "\nIssues detected by other tools:\n"
+                for issue in context['issues']:
+                    prompt += f"- {issue.get('issue', 'Unknown issue')} at line {issue.get('line', 'unknown')}: {issue.get('description', '')}\n"
+            
+            if 'vulnerabilities' in context:
+                prompt += "\nSecurity vulnerabilities detected:\n"
+                for vuln in context['vulnerabilities']:
+                    prompt += f"- {vuln.get('issue', 'Unknown vulnerability')} at line {vuln.get('line', 'unknown')}: {vuln.get('description', '')}\n"
+        
+        prompt += "\nPlease provide your review with the following sections:\n"
+        prompt += "1. Code Quality: Assess the overall quality, readability, and maintainability.\n"
+        prompt += "2. Potential Issues: Identify any bugs, edge cases, or potential problems.\n"
+        prompt += "3. Security Concerns: Highlight any security vulnerabilities or risks.\n"
+        prompt += "4. Performance Considerations: Note any performance bottlenecks or inefficiencies.\n"
+        prompt += "5. Specific Suggestions: Provide concrete, actionable suggestions for improvement.\n"
+        
+        return prompt
+    
+    def _get_system_prompt(self, language):
+        """
+        Get the system prompt for Qwen based on the programming language.
+        
+        Args:
+            language (str): The programming language.
+        
+        Returns:
+            str: The system prompt for Qwen.
+        """
+        base_prompt = """You are an expert code reviewer with deep knowledge of software development best practices, design patterns, and security. 
+        Your task is to review code and provide constructive, actionable feedback. 
+        Be thorough but prioritize the most important issues. 
+        Format your response in markdown with clear sections. 
+        For each suggestion, include the line number, the issue, and a recommended solution.
+        Focus on:
+        - Code quality and readability
+        - Potential bugs and edge cases
+        - Security vulnerabilities
+        - Performance optimizations
+        - Adherence to best practices
+        
+        Your feedback should be specific, actionable, and educational. Explain why each suggestion matters.
+        Do not hallucinate vulnerabilities. Base claims on code patterns.
+        """
+        
+        # Add language-specific guidance
+        if language == 'Python':
+            base_prompt += "\nFor Python code, pay special attention to PEP 8 compliance, proper exception handling, and Pythonic idioms."
+        elif language in ['JavaScript', 'TypeScript']:
+            base_prompt += "\nFor JavaScript/TypeScript code, focus on modern ES6+ practices, proper async handling, and potential type issues."
+        elif language == 'Java':
+            base_prompt += "\nFor Java code, examine object-oriented design, proper exception handling, and resource management."
+        elif language == 'Go':
+            base_prompt += "\nFor Go code, check for idiomatic Go patterns, proper error handling, and concurrency issues."
+        elif language == 'Rust':
+            base_prompt += "\nFor Rust code, verify memory safety, proper use of ownership/borrowing, and idiomatic Rust patterns."
+        
+        return base_prompt
+    
+    def _parse_review(self, review_text):
+        """
+        Parse the review text from Qwen to extract structured suggestions.
+        
+        Args:
+            review_text (str): The review text from Qwen.
+        
+        Returns:
+            list: A list of structured suggestions.
+        """
+        suggestions = []
+        
+        # Split the review into sections
+        sections = review_text.split('##')
+        
+        for section in sections:
+            if not section.strip():
+                continue            
+            # Extract suggestions from the section
+            lines = section.strip().split('\n')
+            section_title = lines[0].strip()
+            
+            current_suggestion = None
+            for line in lines[1:]:
+                line = line.strip()
+                if not line:
+                    continue
+                
+                # Check if this line starts a new suggestion (often contains line numbers)
+                line_number_match = re.search(r'line\s+(\d+)', line, re.IGNORECASE)
+                if line_number_match or line.startswith('- ') or line.startswith('* '):
+                    # Save the previous suggestion if it exists
+                    if current_suggestion:
+                        suggestions.append(current_suggestion)
+                    
+                    # Start a new suggestion
+                    line_number = int(line_number_match.group(1)) if line_number_match else None
+                    current_suggestion = {
+                        'section': section_title,
+                        'line': line_number,
+                        'description': line,
+                        'details': '',
+                    }
+                elif current_suggestion:
+                    # Add to the details of the current suggestion
+                    current_suggestion['details'] += line + '\n'
+            
+            # Add the last suggestion in the section
+            if current_suggestion:
+                suggestions.append(current_suggestion)
+        
+        return suggestions
+    
+    def _get_language_from_extension(self, extension):
+        """
+        Get the programming language from a file extension.
+        
+        Args:
+            extension (str): The file extension.
+        
+        Returns:
+            str: The programming language, or None if unknown.
+        """
+        extension_to_language = {
+            '.py': 'Python',
+            '.js': 'JavaScript',
+            '.jsx': 'JavaScript',
+            '.ts': 'TypeScript',
+            '.tsx': 'TypeScript',
+            '.java': 'Java',
+            '.go': 'Go',
+            '.rs': 'Rust',
+            '.cpp': 'C++',
+            '.cc': 'C++',
+            '.c': 'C',
+            '.h': 'C',
+            '.hpp': 'C++',
+            '.cs': 'C#',
+            '.php': 'PHP',
+            '.rb': 'Ruby',
+        }
+        
+        return extension_to_language.get(extension.lower())
+    
+    def _extract_context_for_file(self, file_path, analysis_results):
+        """
+        Extract relevant context for a file from analysis results.
+        
+        Args:
+            file_path (str): The path to the file.
+            analysis_results (dict): Results from other analysis tools.
+        
+        Returns:
+            dict: Context for the file.
+        """
+        context = {
+            'issues': [],
+            'vulnerabilities': [],
+        }
+        
+        # Extract code quality issues
+        if 'code_analysis' in analysis_results:
+            for language, language_results in analysis_results['code_analysis'].items():
+                for issue in language_results.get('issues', []):
+                    if issue.get('file', '') == file_path:
+                        context['issues'].append(issue)
+        
+        # Extract security vulnerabilities
+        if 'security_scan' in analysis_results:
+            for language, language_results in analysis_results['security_scan'].items():
+                for vuln in language_results.get('vulnerabilities', []):
+                    if vuln.get('file', '') == file_path:
+                        context['vulnerabilities'].append(vuln)
+        
+        # Extract performance issues
+        if 'performance_analysis' in analysis_results:
+            for language, language_results in analysis_results['performance_analysis'].get('language_results', {}).items():
+                for issue in language_results.get('issues', []):
+                    if issue.get('file', '') == file_path:
+                        context['issues'].append(issue)
+        
+        return context
+    
+    def _generate_repository_summary(self, repo_path, reviews, languages, analysis_results=None):
+        """
+        Generate a summary of the repository review.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            reviews (dict): The review results for each file.
+            languages (list): A list of programming languages in the repository.
+            analysis_results (dict, optional): Results from other analysis tools.
+        
+        Returns:
+            str: A summary of the repository review.
+        """
+        if not self.is_available():
+            return "AI review service is not available. Please set ANTHROPIC_API_KEY in environment variables."
+        
+        # Prepare the prompt for Qwen
+        prompt = f"""Please provide a summary of the code review for the repository at {repo_path}.
+
+        Languages used in the repository: {', '.join(languages)}
+
+        """
+        
+        # Add information about the files reviewed
+        prompt += "\nFiles reviewed:\n"
+        for file_path, review in reviews.items():
+            if review.get('status') == 'success':
+                suggestion_count = len(review.get('suggestions', []))
+                prompt += f"- {file_path}: {suggestion_count} suggestions\n"
+            else:
+                prompt += f"- {file_path}: Error - {review.get('error', 'Unknown error')}\n"
+        
+        # Add summary of analysis results if available
+        if analysis_results:
+            prompt += "\nAnalysis results summary:\n"
+            
+            if 'code_analysis' in analysis_results:
+                total_issues = sum(result.get('issue_count', 0) for result in analysis_results['code_analysis'].values())
+                prompt += f"- Code quality issues: {total_issues}\n"
+            
+            if 'security_scan' in analysis_results:
+                total_vulns = sum(result.get('vulnerability_count', 0) for result in analysis_results['security_scan'].values())
+                prompt += f"- Security vulnerabilities: {total_vulns}\n"
+            
+            if 'performance_analysis' in analysis_results:
+                total_perf_issues = sum(result.get('issue_count', 0) for result in analysis_results['performance_analysis'].get('language_results', {}).values())
+                prompt += f"- Performance issues: {total_perf_issues}\n"
+        
+        prompt += "\nPlease provide a comprehensive summary of the code review, including:\n"
+        prompt += "1. Overall code quality assessment\n"
+        prompt += "2. Common patterns and issues found across the codebase\n"
+        prompt += "3. Strengths of the codebase\n"
+        prompt += "4. Areas for improvement\n"
+        prompt += "5. Prioritized recommendations\n"
+        
+        try:
+            # Call Nebius API with Qwen2.5-72B-Instruct model
+            response = self.client.chat.completions.create(
+                model="Qwen/Qwen2.5-72B-Instruct",
+                max_tokens=4000,
+                temperature=0,
+                messages=[
+                    {"role": "system", "content": "You are an expert code reviewer providing a summary of a repository review. Be concise, insightful, and actionable in your feedback. Format your response in markdown with clear sections."},
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            return response.choices[0].message.content
+        
+        except Exception as e:
+            logger.error(f"Error generating repository summary: {e}")
+            return f"Error generating repository summary: {e}"

src/services/__init__.py

@@ -0,0 +1 @@
+# Services Package for Code Review Agent

src/services/code_analyzer.py

@@ -0,0 +1,749 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Code Analyzer Service
+
+This module provides functionality for analyzing code quality across different languages.
+"""
+
+import os
+import subprocess
+import logging
+import json
+import tempfile
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+class CodeAnalyzer:
+    """
+    Service for analyzing code quality across different languages.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the CodeAnalyzer.
+        """
+        logger.info("Initialized CodeAnalyzer")
+        self.analyzers = {
+            'Python': self._analyze_python,
+            'JavaScript': self._analyze_javascript,
+            'TypeScript': self._analyze_typescript,
+            'Java': self._analyze_java,
+            'Go': self._analyze_go,
+            'Rust': self._analyze_rust,
+        }
+    
+    def analyze_repository(self, repo_path, languages):
+        """
+        Analyze code quality in a repository for the specified languages.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            languages (list): A list of programming languages to analyze.
+        
+        Returns:
+            dict: A dictionary containing analysis results for each language.
+        """
+        logger.info(f"Analyzing repository at {repo_path} for languages: {languages}")
+        
+        results = {}
+        
+        for language in languages:
+            if language in self.analyzers:
+                try:
+                    logger.info(f"Analyzing {language} code in {repo_path}")
+                    results[language] = self.analyzers[language](repo_path)
+                except Exception as e:
+                    logger.error(f"Error analyzing {language} code: {e}")
+                    results[language] = {
+                        'status': 'error',
+                        'error': str(e),
+                        'issues': [],
+                    }
+            else:
+                logger.warning(f"No analyzer available for {language}")
+                results[language] = {
+                    'status': 'not_supported',
+                    'message': f"Analysis for {language} is not supported yet.",
+                    'issues': [],
+                }
+        
+        return results
+    
+    def _analyze_python(self, repo_path):
+        """
+        Analyze Python code using pylint.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Analysis results.
+        """
+        logger.info(f"Analyzing Python code in {repo_path}")
+        
+        # Find Python files
+        python_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.py'):
+                    python_files.append(os.path.join(root, file))
+        
+        if not python_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Python files found in the repository.',
+                'issues': [],
+            }
+        
+        # Create a temporary file to store pylint output
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_file:
+            temp_path = temp_file.name
+        
+        try:
+            # Run pylint with JSON reporter
+            cmd = [
+                'pylint',
+                '--output-format=json',
+                '--reports=n',
+            ] + python_files
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse pylint output
+            if process.stdout.strip():
+                try:
+                    issues = json.loads(process.stdout)
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing pylint output: {process.stdout}")
+                    issues = []
+            else:
+                issues = []
+            
+            # Group issues by type
+            issues_by_type = defaultdict(list)
+            for issue in issues:
+                issue_type = issue.get('type', 'unknown')
+                issues_by_type[issue_type].append(issue)
+            
+            return {
+                'status': 'success',
+                'issues': issues,
+                'issues_by_type': dict(issues_by_type),
+                'issue_count': len(issues),
+                'files_analyzed': len(python_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running pylint: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'issues': [],
+            }
+        
+        finally:
+            # Clean up the temporary file
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+    
+    def _analyze_javascript(self, repo_path):
+        """
+        Analyze JavaScript code using ESLint.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Analysis results.
+        """
+        logger.info(f"Analyzing JavaScript code in {repo_path}")
+        
+        # Find JavaScript files
+        js_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith(('.js', '.jsx')) and not 'node_modules' in root:
+                    js_files.append(os.path.join(root, file))
+        
+        if not js_files:
+            return {
+                'status': 'no_files',
+                'message': 'No JavaScript files found in the repository.',
+                'issues': [],
+            }
+        
+        # Create a temporary ESLint configuration file
+        eslint_config = {
+            "env": {
+                "browser": True,
+                "es2021": True,
+                "node": True
+            },
+            "extends": "eslint:recommended",
+            "parserOptions": {
+                "ecmaVersion": 12,
+                "sourceType": "module",
+                "ecmaFeatures": {
+                    "jsx": True
+                }
+            },
+            "rules": {}
+        }
+        
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_config:
+            json.dump(eslint_config, temp_config)
+            temp_config_path = temp_config.name
+        
+        try:
+            # Run ESLint with JSON formatter
+            cmd = [
+                'npx',
+                'eslint',
+                '--config', temp_config_path,
+                '--format', 'json',
+            ] + js_files
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse ESLint output
+            if process.stdout.strip():
+                try:
+                    eslint_results = json.loads(process.stdout)
+                    
+                    # Extract issues from ESLint results
+                    issues = []
+                    for result in eslint_results:
+                        file_path = result.get('filePath', '')
+                        for message in result.get('messages', []):
+                            issues.append({
+                                'path': file_path,
+                                'line': message.get('line', 0),
+                                'column': message.get('column', 0),
+                                'message': message.get('message', ''),
+                                'severity': message.get('severity', 0),
+                                'ruleId': message.get('ruleId', ''),
+                            })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing ESLint output: {process.stdout}")
+                    issues = []
+            else:
+                issues = []
+            
+            # Group issues by severity
+            issues_by_severity = defaultdict(list)
+            for issue in issues:
+                severity = issue.get('severity', 0)
+                severity_name = {0: 'off', 1: 'warning', 2: 'error'}.get(severity, 'unknown')
+                issues_by_severity[severity_name].append(issue)
+            
+            return {
+                'status': 'success',
+                'issues': issues,
+                'issues_by_severity': dict(issues_by_severity),
+                'issue_count': len(issues),
+                'files_analyzed': len(js_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running ESLint: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'issues': [],
+            }
+        
+        finally:
+            # Clean up the temporary configuration file
+            if os.path.exists(temp_config_path):
+                os.unlink(temp_config_path)
+    
+    def _analyze_typescript(self, repo_path):
+        """
+        Analyze TypeScript code using ESLint and TSC.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Analysis results.
+        """
+        logger.info(f"Analyzing TypeScript code in {repo_path}")
+        
+        # Find TypeScript files
+        ts_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith(('.ts', '.tsx')) and not 'node_modules' in root:
+                    ts_files.append(os.path.join(root, file))
+        
+        if not ts_files:
+            return {
+                'status': 'no_files',
+                'message': 'No TypeScript files found in the repository.',
+                'issues': [],
+            }
+        
+        # Create a temporary ESLint configuration file for TypeScript
+        eslint_config = {
+            "env": {
+                "browser": True,
+                "es2021": True,
+                "node": True
+            },
+            "extends": [
+                "eslint:recommended",
+                "plugin:@typescript-eslint/recommended"
+            ],
+            "parser": "@typescript-eslint/parser",
+            "parserOptions": {
+                "ecmaVersion": 12,
+                "sourceType": "module",
+                "ecmaFeatures": {
+                    "jsx": True
+                }
+            },
+            "plugins": [
+                "@typescript-eslint"
+            ],
+            "rules": {}
+        }
+        
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_config:
+            json.dump(eslint_config, temp_config)
+            temp_config_path = temp_config.name
+        
+        # Create a temporary tsconfig.json file
+        tsconfig = {
+            "compilerOptions": {
+                "target": "es2020",
+                "module": "commonjs",
+                "strict": True,
+                "esModuleInterop": True,
+                "skipLibCheck": True,
+                "forceConsistentCasingInFileNames": True,
+                "noEmit": True
+            },
+            "include": ts_files
+        }
+        
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_tsconfig:
+            json.dump(tsconfig, temp_tsconfig)
+            temp_tsconfig_path = temp_tsconfig.name
+        
+        try:
+            # Run ESLint with TypeScript support
+            eslint_cmd = [
+                'npx',
+                'eslint',
+                '--config', temp_config_path,
+                '--format', 'json',
+                '--ext', '.ts,.tsx',
+            ] + ts_files
+            
+            eslint_process = subprocess.run(
+                eslint_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse ESLint output
+            eslint_issues = []
+            if eslint_process.stdout.strip():
+                try:
+                    eslint_results = json.loads(eslint_process.stdout)
+                    
+                    # Extract issues from ESLint results
+                    for result in eslint_results:
+                        file_path = result.get('filePath', '')
+                        for message in result.get('messages', []):
+                            eslint_issues.append({
+                                'path': file_path,
+                                'line': message.get('line', 0),
+                                'column': message.get('column', 0),
+                                'message': message.get('message', ''),
+                                'severity': message.get('severity', 0),
+                                'ruleId': message.get('ruleId', ''),
+                                'source': 'eslint',
+                            })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing ESLint output: {eslint_process.stdout}")
+            
+            # Run TypeScript compiler for type checking
+            tsc_cmd = [
+                'npx',
+                'tsc',
+                '--project', temp_tsconfig_path,
+                '--noEmit',
+            ]
+            
+            tsc_process = subprocess.run(
+                tsc_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse TSC output
+            tsc_issues = []
+            if tsc_process.stderr.strip():
+                # TSC error format: file.ts(line,col): error TS2551: message
+                for line in tsc_process.stderr.splitlines():
+                    if ': error ' in line or ': warning ' in line:
+                        try:
+                            file_info, error_info = line.split(':', 1)
+                            file_path, line_col = file_info.rsplit('(', 1)
+                            line_num, col_num = line_col.rstrip(')').split(',')
+                            
+                            error_type, error_message = error_info.split(':', 1)
+                            error_type = error_type.strip()
+                            error_message = error_message.strip()
+                            
+                            tsc_issues.append({
+                                'path': file_path,
+                                'line': int(line_num),
+                                'column': int(col_num),
+                                'message': error_message,
+                                'severity': 2 if 'error' in error_type else 1,
+                                'ruleId': error_type,
+                                'source': 'tsc',
+                            })
+                        except Exception as e:
+                            logger.warning(f"Error parsing TSC output line: {line}, error: {e}")
+            
+            # Combine issues from both tools
+            all_issues = eslint_issues + tsc_issues
+            
+            # Group issues by source and severity
+            issues_by_source = defaultdict(list)
+            issues_by_severity = defaultdict(list)
+            
+            for issue in all_issues:
+                source = issue.get('source', 'unknown')
+                issues_by_source[source].append(issue)
+                
+                severity = issue.get('severity', 0)
+                severity_name = {0: 'off', 1: 'warning', 2: 'error'}.get(severity, 'unknown')
+                issues_by_severity[severity_name].append(issue)
+            
+            return {
+                'status': 'success',
+                'issues': all_issues,
+                'issues_by_source': dict(issues_by_source),
+                'issues_by_severity': dict(issues_by_severity),
+                'issue_count': len(all_issues),
+                'files_analyzed': len(ts_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error analyzing TypeScript code: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'issues': [],
+            }
+        
+        finally:
+            # Clean up temporary files
+            for temp_file in [temp_config_path, temp_tsconfig_path]:
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+    
+    def _analyze_java(self, repo_path):
+        """
+        Analyze Java code using PMD.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Analysis results.
+        """
+        logger.info(f"Analyzing Java code in {repo_path}")
+        
+        # Find Java files
+        java_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.java'):
+                    java_files.append(os.path.join(root, file))
+        
+        if not java_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Java files found in the repository.',
+                'issues': [],
+            }
+        
+        # Create a temporary file to store PMD output
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_file:
+            temp_path = temp_file.name
+        
+        try:
+            # Run PMD with JSON reporter
+            cmd = [
+                'pmd',
+                'check',
+                '--dir', repo_path,
+                '--format', 'json',
+                '--rulesets', 'category/java/bestpractices.xml,category/java/codestyle.xml,category/java/design.xml,category/java/errorprone.xml,category/java/multithreading.xml,category/java/performance.xml,category/java/security.xml',
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse PMD output
+            if process.stdout.strip():
+                try:
+                    pmd_results = json.loads(process.stdout)
+                    
+                    # Extract issues from PMD results
+                    issues = []
+                    for file_result in pmd_results.get('files', []):
+                        file_path = file_result.get('filename', '')
+                        for violation in file_result.get('violations', []):
+                            issues.append({
+                                'path': file_path,
+                                'line': violation.get('beginline', 0),
+                                'endLine': violation.get('endline', 0),
+                                'column': violation.get('begincolumn', 0),
+                                'endColumn': violation.get('endcolumn', 0),
+                                'message': violation.get('description', ''),
+                                'rule': violation.get('rule', ''),
+                                'ruleset': violation.get('ruleset', ''),
+                                'priority': violation.get('priority', 0),
+                            })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing PMD output: {process.stdout}")
+                    issues = []
+            else:
+                issues = []
+            
+            # Group issues by ruleset
+            issues_by_ruleset = defaultdict(list)
+            for issue in issues:
+                ruleset = issue.get('ruleset', 'unknown')
+                issues_by_ruleset[ruleset].append(issue)
+            
+            return {
+                'status': 'success',
+                'issues': issues,
+                'issues_by_ruleset': dict(issues_by_ruleset),
+                'issue_count': len(issues),
+                'files_analyzed': len(java_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running PMD: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'issues': [],
+            }
+        
+        finally:
+            # Clean up the temporary file
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+    
+    def _analyze_go(self, repo_path):
+        """
+        Analyze Go code using golangci-lint.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Analysis results.
+        """
+        logger.info(f"Analyzing Go code in {repo_path}")
+        
+        # Find Go files
+        go_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.go'):
+                    go_files.append(os.path.join(root, file))
+        
+        if not go_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Go files found in the repository.',
+                'issues': [],
+            }
+        
+        try:
+            # Run golangci-lint with JSON output
+            cmd = [
+                'golangci-lint',
+                'run',
+                '--out-format=json',
+                repo_path,
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+                cwd=repo_path,  # Run in the repository directory
+            )
+            
+            # Parse golangci-lint output
+            if process.stdout.strip():
+                try:
+                    lint_results = json.loads(process.stdout)
+                    
+                    # Extract issues from golangci-lint results
+                    issues = []
+                    for issue in lint_results.get('Issues', []):
+                        issues.append({
+                            'path': issue.get('Pos', {}).get('Filename', ''),
+                            'line': issue.get('Pos', {}).get('Line', 0),
+                            'column': issue.get('Pos', {}).get('Column', 0),
+                            'message': issue.get('Text', ''),
+                            'linter': issue.get('FromLinter', ''),
+                            'severity': 'error' if issue.get('Severity', '') == 'error' else 'warning',
+                        })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing golangci-lint output: {process.stdout}")
+                    issues = []
+            else:
+                issues = []
+            
+            # Group issues by linter
+            issues_by_linter = defaultdict(list)
+            for issue in issues:
+                linter = issue.get('linter', 'unknown')
+                issues_by_linter[linter].append(issue)
+            
+            return {
+                'status': 'success',
+                'issues': issues,
+                'issues_by_linter': dict(issues_by_linter),
+                'issue_count': len(issues),
+                'files_analyzed': len(go_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running golangci-lint: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'issues': [],
+            }
+    
+    def _analyze_rust(self, repo_path):
+        """
+        Analyze Rust code using clippy.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Analysis results.
+        """
+        logger.info(f"Analyzing Rust code in {repo_path}")
+        
+        # Find Rust files
+        rust_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.rs'):
+                    rust_files.append(os.path.join(root, file))
+        
+        if not rust_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Rust files found in the repository.',
+                'issues': [],
+            }
+        
+        try:
+            # Run clippy with JSON output
+            cmd = [
+                'cargo',
+                'clippy',
+                '--message-format=json',
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+                cwd=repo_path,  # Run in the repository directory
+            )
+            
+            # Parse clippy output
+            issues = []
+            if process.stdout.strip():
+                for line in process.stdout.splitlines():
+                    try:
+                        message = json.loads(line)
+                        if message.get('reason') == 'compiler-message':
+                            msg = message.get('message', {})
+                            spans = msg.get('spans', [])
+                            
+                            if spans:
+                                primary_span = next((s for s in spans if s.get('is_primary')), spans[0])
+                                file_path = primary_span.get('file_name', '')
+                                line_num = primary_span.get('line_start', 0)
+                                column = primary_span.get('column_start', 0)
+                                
+                                issues.append({
+                                    'path': file_path,
+                                    'line': line_num,
+                                    'column': column,
+                                    'message': msg.get('message', ''),
+                                    'level': msg.get('level', ''),
+                                    'code': msg.get('code', {}).get('code', ''),
+                                })
+                    except json.JSONDecodeError:
+                        continue
+            
+            # Group issues by level
+            issues_by_level = defaultdict(list)
+            for issue in issues:
+                level = issue.get('level', 'unknown')
+                issues_by_level[level].append(issue)
+            
+            return {
+                'status': 'success',
+                'issues': issues,
+                'issues_by_level': dict(issues_by_level),
+                'issue_count': len(issues),
+                'files_analyzed': len(rust_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running clippy: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'issues': [],
+            }

src/services/performance_analyzer.py

@@ -0,0 +1,750 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Performance Analyzer Service
+
+This module provides functionality for analyzing code performance across different languages.
+"""
+
+import os
+import re
+import logging
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+class PerformanceAnalyzer:
+    """
+    Service for analyzing code performance across different languages.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the PerformanceAnalyzer.
+        """
+        logger.info("Initialized PerformanceAnalyzer")
+        self.analyzers = {
+            'Python': self._analyze_python_performance,
+            'JavaScript': self._analyze_javascript_performance,
+            'TypeScript': self._analyze_typescript_performance,
+            'Java': self._analyze_java_performance,
+            'Go': self._analyze_go_performance,
+            'Rust': self._analyze_rust_performance,
+        }
+        
+        # Initialize performance patterns for different languages
+        self._init_performance_patterns()
+    
+    def _init_performance_patterns(self):
+        """
+        Initialize performance patterns for different languages.
+        """
+        # Python performance patterns
+        self.python_patterns = [
+            {
+                'name': 'Inefficient list comprehension',
+                'pattern': r'\[.*?for.*?in.*?for.*?in.*?\]',
+                'severity': 'medium',
+                'description': 'Nested list comprehensions can be inefficient for large datasets.',
+                'suggestion': 'Consider using itertools or breaking into separate operations.',
+            },
+            {
+                'name': 'String concatenation in loop',
+                'pattern': r'for.*?\+\=\s*[\'\"](.*?)[\'\"]',
+                'severity': 'medium',
+                'description': 'String concatenation in loops is inefficient in Python.',
+                'suggestion': 'Use string join() or a list of strings with join() at the end.',
+            },
+            {
+                'name': 'Global variable in loop',
+                'pattern': r'global\s+\w+.*?for\s+\w+\s+in',
+                'severity': 'medium',
+                'description': 'Modifying global variables in loops can be inefficient.',
+                'suggestion': 'Use local variables and return values instead.',
+            },
+            {
+                'name': 'Inefficient dict/list access in loop',
+                'pattern': r'for.*?in.*?:\s*.*?\[.*?\]\s*=',
+                'severity': 'medium',
+                'description': 'Repeatedly accessing dictionary or list elements in a loop can be inefficient.',
+                'suggestion': 'Consider using a local variable to store the accessed element.',
+            },
+            {
+                'name': 'Using range(len())',
+                'pattern': r'for\s+\w+\s+in\s+range\(len\(',
+                'severity': 'low',
+                'description': 'Using range(len()) is less readable than using enumerate().',
+                'suggestion': 'Use enumerate() instead of range(len()).',
+            },
+            {
+                'name': 'Inefficient regular expression',
+                'pattern': r're\.compile\([\'\"].*?[\+\*].*?[\'\"]\)',
+                'severity': 'medium',
+                'description': 'Complex regular expressions can be inefficient.',
+                'suggestion': 'Simplify the regular expression or use more specific patterns.',
+            },
+            {
+                'name': 'Large memory allocation',
+                'pattern': r'\[.*?for.*?in\s+range\(\d{7,}\)\]',
+                'severity': 'high',
+                'description': 'Creating large lists in memory can cause performance issues.',
+                'suggestion': 'Use generators or iterators instead of creating large lists.',
+            },
+            {
+                'name': 'Inefficient database query in loop',
+                'pattern': r'for.*?in.*?:\s*.*?\.execute\(',
+                'severity': 'high',
+                'description': 'Executing database queries in a loop can be very inefficient.',
+                'suggestion': 'Use batch operations or join queries instead of querying in a loop.',
+            },
+        ]
+        
+        # JavaScript performance patterns
+        self.javascript_patterns = [
+            {
+                'name': 'DOM manipulation in loop',
+                'pattern': r'for\s*\(.*?\)\s*\{.*?document\..*?\}',
+                'severity': 'high',
+                'description': 'Manipulating the DOM inside loops can cause performance issues.',
+                'suggestion': 'Batch DOM updates or use DocumentFragment.',
+            },
+            {
+                'name': 'Inefficient array manipulation',
+                'pattern': r'for\s*\(.*?\)\s*\{.*?splice\(.*?\}',
+                'severity': 'medium',
+                'description': 'Using splice() in loops can be inefficient for large arrays.',
+                'suggestion': 'Consider using filter() or other array methods.',
+            },
+            {
+                'name': 'Creating functions in loops',
+                'pattern': r'for\s*\(.*?\)\s*\{.*?function\s*\(.*?\)\s*\{.*?\}.*?\}',
+                'severity': 'medium',
+                'description': 'Creating functions inside loops can lead to performance issues.',
+                'suggestion': 'Define the function outside the loop and reference it.',
+            },
+            {
+                'name': 'Inefficient string concatenation',
+                'pattern': r'for\s*\(.*?\)\s*\{.*?\+\=\s*[\'\"](.*?)[\'\"].*?\}',
+                'severity': 'medium',
+                'description': 'String concatenation in loops can be inefficient.',
+                'suggestion': 'Use array join() or template literals.',
+            },
+            {
+                'name': 'Using eval()',
+                'pattern': r'eval\(',
+                'severity': 'high',
+                'description': 'Using eval() is slow and can introduce security vulnerabilities.',
+                'suggestion': 'Avoid using eval() and use safer alternatives.',
+            },
+            {
+                'name': 'Inefficient event handling',
+                'pattern': r'addEventListener\([\'\"].*?[\'\"],\s*function',
+                'severity': 'medium',
+                'description': 'Anonymous functions in event listeners can lead to memory leaks.',
+                'suggestion': 'Use named functions for event handlers to allow proper cleanup.',
+            },
+        ]
+        
+        # TypeScript performance patterns (extends JavaScript patterns)
+        self.typescript_patterns = self.javascript_patterns + [
+            {
+                'name': 'Inefficient type assertion',
+                'pattern': r'<.*?>\s*\(.*?\)',
+                'severity': 'low',
+                'description': 'Excessive type assertions can impact runtime performance.',
+                'suggestion': 'Use proper typing and interfaces instead of frequent type assertions.',
+            },
+            {
+                'name': 'Complex type definitions',
+                'pattern': r'type\s+\w+\s*=\s*\{[^\}]{500,}\}',
+                'severity': 'medium',
+                'description': 'Overly complex type definitions can slow down the TypeScript compiler.',
+                'suggestion': 'Break complex types into smaller, reusable interfaces.',
+            },
+        ]
+        
+        # Java performance patterns
+        self.java_patterns = [
+            {
+                'name': 'Inefficient string concatenation',
+                'pattern': r'for\s*\(.*?\)\s*\{.*?\+\=\s*[\'\"](.*?)[\'\"].*?\}',
+                'severity': 'medium',
+                'description': 'String concatenation in loops is inefficient in Java.',
+                'suggestion': 'Use StringBuilder or StringBuffer instead.',
+            },
+            {
+                'name': 'Creating objects in loops',
+                'pattern': r'for\s*\(.*?\)\s*\{.*?new\s+\w+\(.*?\).*?\}',
+                'severity': 'medium',
+                'description': 'Creating objects inside loops can lead to excessive garbage collection.',
+                'suggestion': 'Create objects outside the loop or use object pooling.',
+            },
+            {
+                'name': 'Inefficient collection iteration',
+                'pattern': r'for\s*\(int\s+i\s*=\s*0.*?i\s*<\s*\w+\.size\(\).*?\)',
+                'severity': 'low',
+                'description': 'Calling size() in each iteration can be inefficient for some collections.',
+                'suggestion': 'Store the size in a variable before the loop.',
+            },
+            {
+                'name': 'Using boxed primitives in performance-critical code',
+                'pattern': r'(Integer|Boolean|Double|Float|Long)\s+\w+\s*=',
+                'severity': 'low',
+                'description': 'Using boxed primitives can be less efficient than primitive types.',
+                'suggestion': 'Use primitive types (int, boolean, etc.) in performance-critical code.',
+            },
+            {
+                'name': 'Inefficient exception handling',
+                'pattern': r'try\s*\{.*?\}\s*catch\s*\(Exception\s+\w+\)\s*\{',
+                'severity': 'medium',
+                'description': 'Catching generic exceptions can hide issues and impact performance.',
+                'suggestion': 'Catch specific exceptions and handle them appropriately.',
+            },
+        ]
+        
+        # Go performance patterns
+        self.go_patterns = [
+            {
+                'name': 'Inefficient string concatenation',
+                'pattern': r'for\s+.*?\{.*?\+\=\s*[\'\"](.*?)[\'\"].*?\}',
+                'severity': 'medium',
+                'description': 'String concatenation in loops can be inefficient.',
+                'suggestion': 'Use strings.Builder for string concatenation in loops.',
+            },
+            {
+                'name': 'Inefficient slice operations',
+                'pattern': r'for\s+.*?\{.*?append\(.*?\}',
+                'severity': 'medium',
+                'description': 'Repeatedly appending to a slice can cause multiple allocations.',
+                'suggestion': 'Pre-allocate slices with make() when the size is known.',
+            },
+            {
+                'name': 'Mutex in hot path',
+                'pattern': r'func\s+\(.*?\)\s+\w+\(.*?\)\s+\{.*?Lock\(\).*?Unlock\(\)',
+                'severity': 'medium',
+                'description': 'Using mutexes in frequently called functions can impact performance.',
+                'suggestion': 'Consider using atomic operations or redesigning for less contention.',
+            },
+            {
+                'name': 'Inefficient map iteration',
+                'pattern': r'for\s+\w+,\s*_\s*:=\s*range',
+                'severity': 'low',
+                'description': 'Iterating over maps when only keys are needed can be inefficient.',
+                'suggestion': 'Use a slice for ordered data when possible.',
+            },
+        ]
+        
+        # Rust performance patterns
+        self.rust_patterns = [
+            {
+                'name': 'Inefficient string operations',
+                'pattern': r'for\s+.*?\{.*?\.push_str\(.*?\}',
+                'severity': 'medium',
+                'description': 'Repeatedly pushing to strings can be inefficient.',
+                'suggestion': 'Use string concatenation with the format! macro or String::with_capacity().',
+            },
+            {
+                'name': 'Excessive cloning',
+                'pattern': r'\.clone\(\)',
+                'severity': 'medium',
+                'description': 'Excessive cloning can impact performance.',
+                'suggestion': 'Use references or ownership transfer where possible.',
+            },
+            {
+                'name': 'Inefficient vector operations',
+                'pattern': r'for\s+.*?\{.*?\.push\(.*?\}',
+                'severity': 'medium',
+                'description': 'Repeatedly pushing to vectors can cause multiple allocations.',
+                'suggestion': 'Pre-allocate vectors with Vec::with_capacity() when the size is known.',
+            },
+            {
+                'name': 'Box allocation in loops',
+                'pattern': r'for\s+.*?\{.*?Box::new\(.*?\}',
+                'severity': 'medium',
+                'description': 'Allocating boxes in loops can be inefficient.',
+                'suggestion': 'Allocate memory outside the loop when possible.',
+            },
+        ]
+    
+    def analyze_repository(self, repo_path, languages):
+        """
+        Analyze code performance in a repository for the specified languages.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            languages (list): A list of programming languages to analyze.
+        
+        Returns:
+            dict: A dictionary containing performance analysis results for each language.
+        """
+        logger.info(f"Analyzing performance in repository at {repo_path} for languages: {languages}")
+        
+        results = {}
+        
+        for language in languages:
+            if language in self.analyzers:
+                try:
+                    logger.info(f"Analyzing {language} code performance in {repo_path}")
+                    results[language] = self.analyzers[language](repo_path)
+                except Exception as e:
+                    logger.error(f"Error analyzing {language} code performance: {e}")
+                    results[language] = {
+                        'status': 'error',
+                        'error': str(e),
+                        'issues': [],
+                    }
+            else:
+                logger.warning(f"No performance analyzer available for {language}")
+                results[language] = {
+                    'status': 'not_supported',
+                    'message': f"Performance analysis for {language} is not supported yet.",
+                    'issues': [],
+                }
+        
+        # Identify hotspots (files with multiple performance issues)
+        hotspots = self._identify_hotspots(results)
+        
+        return {
+            'language_results': results,
+            'hotspots': hotspots,
+        }
+    
+    def _identify_hotspots(self, results):
+        """
+        Identify performance hotspots across all languages.
+        
+        Args:
+            results (dict): Performance analysis results for each language.
+        
+        Returns:
+            list: A list of hotspot files with multiple performance issues.
+        """
+        # Count issues per file across all languages
+        file_issue_count = defaultdict(int)
+        file_issues = defaultdict(list)
+        
+        for language, language_result in results.items():
+            for issue in language_result.get('issues', []):
+                file_path = issue.get('file', '')
+                if file_path:
+                    file_issue_count[file_path] += 1
+                    file_issues[file_path].append(issue)
+        
+        # Identify hotspots (files with multiple issues)
+        hotspots = []
+        for file_path, count in sorted(file_issue_count.items(), key=lambda x: x[1], reverse=True):
+            if count >= 2:  # Files with at least 2 issues are considered hotspots
+                hotspots.append({
+                    'file': file_path,
+                    'issue_count': count,
+                    'issues': file_issues[file_path],
+                })
+        
+        return hotspots[:10]  # Return top 10 hotspots
+    
+    def _analyze_python_performance(self, repo_path):
+        """
+        Analyze Python code for performance issues.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Performance analysis results for Python code.
+        """
+        logger.info(f"Analyzing Python code performance in {repo_path}")
+        
+        # Find Python files
+        python_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.py'):
+                    python_files.append(os.path.join(root, file))
+        
+        if not python_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Python files found in the repository.',
+                'issues': [],
+            }
+        
+        # Analyze each Python file
+        issues = []
+        for file_path in python_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Check for performance patterns
+                for pattern in self.python_patterns:
+                    matches = re.finditer(pattern['pattern'], content)
+                    for match in matches:
+                        line_number = content[:match.start()].count('\n') + 1
+                        code_snippet = match.group(0)
+                        
+                        issues.append({
+                            'file': file_path,
+                            'line': line_number,
+                            'code': code_snippet,
+                            'issue': pattern['name'],
+                            'description': pattern['description'],
+                            'suggestion': pattern['suggestion'],
+                            'severity': pattern['severity'],
+                            'language': 'Python',
+                        })
+            except Exception as e:
+                logger.error(f"Error analyzing Python file {file_path}: {e}")
+        
+        # Group issues by severity
+        issues_by_severity = defaultdict(list)
+        for issue in issues:
+            severity = issue.get('severity', 'unknown')
+            issues_by_severity[severity].append(issue)
+        
+        return {
+            'status': 'success',
+            'issues': issues,
+            'issues_by_severity': dict(issues_by_severity),
+            'issue_count': len(issues),
+            'files_analyzed': len(python_files),
+        }
+    
+    def _analyze_javascript_performance(self, repo_path):
+        """
+        Analyze JavaScript code for performance issues.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Performance analysis results for JavaScript code.
+        """
+        logger.info(f"Analyzing JavaScript code performance in {repo_path}")
+        
+        # Find JavaScript files
+        js_files = []
+        for root, _, files in os.walk(repo_path):
+            if 'node_modules' in root:
+                continue
+            for file in files:
+                if file.endswith(('.js', '.jsx')):
+                    js_files.append(os.path.join(root, file))
+        
+        if not js_files:
+            return {
+                'status': 'no_files',
+                'message': 'No JavaScript files found in the repository.',
+                'issues': [],
+            }
+        
+        # Analyze each JavaScript file
+        issues = []
+        for file_path in js_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Check for performance patterns
+                for pattern in self.javascript_patterns:
+                    matches = re.finditer(pattern['pattern'], content)
+                    for match in matches:
+                        line_number = content[:match.start()].count('\n') + 1
+                        code_snippet = match.group(0)
+                        
+                        issues.append({
+                            'file': file_path,
+                            'line': line_number,
+                            'code': code_snippet,
+                            'issue': pattern['name'],
+                            'description': pattern['description'],
+                            'suggestion': pattern['suggestion'],
+                            'severity': pattern['severity'],
+                            'language': 'JavaScript',
+                        })
+            except Exception as e:
+                logger.error(f"Error analyzing JavaScript file {file_path}: {e}")
+        
+        # Group issues by severity
+        issues_by_severity = defaultdict(list)
+        for issue in issues:
+            severity = issue.get('severity', 'unknown')
+            issues_by_severity[severity].append(issue)
+        
+        return {
+            'status': 'success',
+            'issues': issues,
+            'issues_by_severity': dict(issues_by_severity),
+            'issue_count': len(issues),
+            'files_analyzed': len(js_files),
+        }
+    
+    def _analyze_typescript_performance(self, repo_path):
+        """
+        Analyze TypeScript code for performance issues.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Performance analysis results for TypeScript code.
+        """
+        logger.info(f"Analyzing TypeScript code performance in {repo_path}")
+        
+        # Find TypeScript files
+        ts_files = []
+        for root, _, files in os.walk(repo_path):
+            if 'node_modules' in root:
+                continue
+            for file in files:
+                if file.endswith(('.ts', '.tsx')):
+                    ts_files.append(os.path.join(root, file))
+        
+        if not ts_files:
+            return {
+                'status': 'no_files',
+                'message': 'No TypeScript files found in the repository.',
+                'issues': [],
+            }
+        
+        # Analyze each TypeScript file
+        issues = []
+        for file_path in ts_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Check for performance patterns
+                for pattern in self.typescript_patterns:
+                    matches = re.finditer(pattern['pattern'], content)
+                    for match in matches:
+                        line_number = content[:match.start()].count('\n') + 1
+                        code_snippet = match.group(0)
+                        
+                        issues.append({
+                            'file': file_path,
+                            'line': line_number,
+                            'code': code_snippet,
+                            'issue': pattern['name'],
+                            'description': pattern['description'],
+                            'suggestion': pattern['suggestion'],
+                            'severity': pattern['severity'],
+                            'language': 'TypeScript',
+                        })
+            except Exception as e:
+                logger.error(f"Error analyzing TypeScript file {file_path}: {e}")
+        
+        # Group issues by severity
+        issues_by_severity = defaultdict(list)
+        for issue in issues:
+            severity = issue.get('severity', 'unknown')
+            issues_by_severity[severity].append(issue)
+        
+        return {
+            'status': 'success',
+            'issues': issues,
+            'issues_by_severity': dict(issues_by_severity),
+            'issue_count': len(issues),
+            'files_analyzed': len(ts_files),
+        }
+    
+    def _analyze_java_performance(self, repo_path):
+        """
+        Analyze Java code for performance issues.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Performance analysis results for Java code.
+        """
+        logger.info(f"Analyzing Java code performance in {repo_path}")
+        
+        # Find Java files
+        java_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.java'):
+                    java_files.append(os.path.join(root, file))
+        
+        if not java_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Java files found in the repository.',
+                'issues': [],
+            }
+        
+        # Analyze each Java file
+        issues = []
+        for file_path in java_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Check for performance patterns
+                for pattern in self.java_patterns:
+                    matches = re.finditer(pattern['pattern'], content)
+                    for match in matches:
+                        line_number = content[:match.start()].count('\n') + 1
+                        code_snippet = match.group(0)
+                        
+                        issues.append({
+                            'file': file_path,
+                            'line': line_number,
+                            'code': code_snippet,
+                            'issue': pattern['name'],
+                            'description': pattern['description'],
+                            'suggestion': pattern['suggestion'],
+                            'severity': pattern['severity'],
+                            'language': 'Java',
+                        })
+            except Exception as e:
+                logger.error(f"Error analyzing Java file {file_path}: {e}")
+        
+        # Group issues by severity
+        issues_by_severity = defaultdict(list)
+        for issue in issues:
+            severity = issue.get('severity', 'unknown')
+            issues_by_severity[severity].append(issue)
+        
+        return {
+            'status': 'success',
+            'issues': issues,
+            'issues_by_severity': dict(issues_by_severity),
+            'issue_count': len(issues),
+            'files_analyzed': len(java_files),
+        }
+    
+    def _analyze_go_performance(self, repo_path):
+        """
+        Analyze Go code for performance issues.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Performance analysis results for Go code.
+        """
+        logger.info(f"Analyzing Go code performance in {repo_path}")
+        
+        # Find Go files
+        go_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.go'):
+                    go_files.append(os.path.join(root, file))
+        
+        if not go_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Go files found in the repository.',
+                'issues': [],
+            }
+        
+        # Analyze each Go file
+        issues = []
+        for file_path in go_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Check for performance patterns
+                for pattern in self.go_patterns:
+                    matches = re.finditer(pattern['pattern'], content)
+                    for match in matches:
+                        line_number = content[:match.start()].count('\n') + 1
+                        code_snippet = match.group(0)
+                        
+                        issues.append({
+                            'file': file_path,
+                            'line': line_number,
+                            'code': code_snippet,
+                            'issue': pattern['name'],
+                            'description': pattern['description'],
+                            'suggestion': pattern['suggestion'],
+                            'severity': pattern['severity'],
+                            'language': 'Go',
+                        })
+            except Exception as e:
+                logger.error(f"Error analyzing Go file {file_path}: {e}")
+        
+        # Group issues by severity
+        issues_by_severity = defaultdict(list)
+        for issue in issues:
+            severity = issue.get('severity', 'unknown')
+            issues_by_severity[severity].append(issue)
+        
+        return {
+            'status': 'success',
+            'issues': issues,
+            'issues_by_severity': dict(issues_by_severity),
+            'issue_count': len(issues),
+            'files_analyzed': len(go_files),
+        }
+    
+    def _analyze_rust_performance(self, repo_path):
+        """
+        Analyze Rust code for performance issues.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Performance analysis results for Rust code.
+        """
+        logger.info(f"Analyzing Rust code performance in {repo_path}")
+        
+        # Find Rust files
+        rust_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.rs'):
+                    rust_files.append(os.path.join(root, file))
+        
+        if not rust_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Rust files found in the repository.',
+                'issues': [],
+            }
+        
+        # Analyze each Rust file
+        issues = []
+        for file_path in rust_files:
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                
+                # Check for performance patterns
+                for pattern in self.rust_patterns:
+                    matches = re.finditer(pattern['pattern'], content)
+                    for match in matches:
+                        line_number = content[:match.start()].count('\n') + 1
+                        code_snippet = match.group(0)
+                        
+                        issues.append({
+                            'file': file_path,
+                            'line': line_number,
+                            'code': code_snippet,
+                            'issue': pattern['name'],
+                            'description': pattern['description'],
+                            'suggestion': pattern['suggestion'],
+                            'severity': pattern['severity'],
+                            'language': 'Rust',
+                        })
+            except Exception as e:
+                logger.error(f"Error analyzing Rust file {file_path}: {e}")
+        
+        # Group issues by severity
+        issues_by_severity = defaultdict(list)
+        for issue in issues:
+            severity = issue.get('severity', 'unknown')
+            issues_by_severity[severity].append(issue)
+        
+        return {
+            'status': 'success',
+            'issues': issues,
+            'issues_by_severity': dict(issues_by_severity),
+            'issue_count': len(issues),
+            'files_analyzed': len(rust_files),
+        }

src/services/report_generator.py

@@ -0,0 +1,741 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Report Generator Service
+
+This module provides functionality for generating comprehensive code review reports
+in various formats based on the analysis results.
+"""
+
+import os
+import json
+import logging
+import datetime
+from pathlib import Path
+import markdown
+import pdfkit
+import csv
+
+logger = logging.getLogger(__name__)
+
+class ReportGenerator:
+    """
+    Service for generating code review reports in various formats.
+    """
+    
+    def __init__(self, output_dir="reports"):
+        """
+        Initialize the ReportGenerator.
+        
+        Args:
+            output_dir (str): Directory to save generated reports.
+        """
+        self.output_dir = output_dir
+        os.makedirs(output_dir, exist_ok=True)
+        logger.info(f"Initialized ReportGenerator with output directory: {output_dir}")
+    
+    def generate_report(self, repo_name, results, format_type="all"):
+        """
+        Generate a report based on the analysis results.
+        
+        Args:
+            repo_name (str): Name of the repository.
+            results (dict): Analysis results.
+            format_type (str): Report format type (json, html, pdf, csv, or all).
+        
+        Returns:
+            dict: Paths to the generated reports.
+        """
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        report_name = f"{repo_name}_{timestamp}"
+        report_paths = {}
+        
+        # Create report content
+        report_content = self._create_report_content(repo_name, results)
+        
+        # Generate reports in requested formats
+        if format_type in ["json", "all"]:
+            json_path = self._generate_json_report(report_name, report_content)
+            report_paths["json"] = json_path
+        
+        if format_type in ["html", "all"]:
+            html_path = self._generate_html_report(report_name, report_content)
+            report_paths["html"] = html_path
+        
+        if format_type in ["pdf", "all"]:
+            pdf_path = self._generate_pdf_report(report_name, report_content)
+            report_paths["pdf"] = pdf_path
+        
+        if format_type in ["csv", "all"]:
+            csv_path = self._generate_csv_report(report_name, report_content)
+            report_paths["csv"] = csv_path
+        
+        logger.info(f"Generated {len(report_paths)} report(s) for {repo_name}")
+        return report_paths
+    
+    def _create_report_content(self, repo_name, results):
+        """
+        Create the content for the report.
+        
+        Args:
+            repo_name (str): Name of the repository.
+            results (dict): Analysis results.
+        
+        Returns:
+            dict: Structured report content.
+        """
+        # Extract repository info
+        repo_info = results.get("repository_info", {})
+        
+        # Extract language breakdown
+        language_breakdown = results.get("language_breakdown", {})
+        
+        # Extract code analysis results
+        code_analysis = results.get("code_analysis", {})
+        
+        # Extract security scan results
+        security_scan = results.get("security_scan", {})
+        
+        # Extract performance analysis results
+        performance_analysis = results.get("performance_analysis", {})
+        
+        # Extract AI review results
+        ai_review = results.get("ai_review", {})
+        
+        # Calculate summary metrics
+        summary_metrics = self._calculate_summary_metrics(results)
+        
+        # Create report structure
+        report = {
+            "metadata": {
+                "repository_name": repo_name,
+                "report_date": datetime.datetime.now().isoformat(),
+                "repository_info": repo_info,
+            },
+            "summary": {
+                "metrics": summary_metrics,
+                "language_breakdown": language_breakdown,
+                "executive_summary": ai_review.get("summary", "No AI review summary available."),
+            },
+            "code_quality": {
+                "issues_by_language": code_analysis,
+                "top_issues": self._extract_top_issues(code_analysis),
+            },
+            "security": {
+                "vulnerabilities_by_language": security_scan,
+                "critical_vulnerabilities": self._extract_critical_vulnerabilities(security_scan),
+            },
+            "performance": {
+                "issues_by_language": performance_analysis.get("language_results", {}),
+                "hotspots": performance_analysis.get("hotspots", []),
+            },
+            "ai_review": {
+                "file_reviews": ai_review.get("reviews", {}),
+                "summary": ai_review.get("summary", "No AI review summary available."),
+            },
+            "recommendations": self._generate_recommendations(results),
+        }
+        
+        return report
+    
+    def _calculate_summary_metrics(self, results):
+        """
+        Calculate summary metrics from the analysis results.
+        
+        Args:
+            results (dict): Analysis results.
+        
+        Returns:
+            dict: Summary metrics.
+        """
+        metrics = {
+            "total_files": results.get("repository_info", {}).get("file_count", 0),
+            "repository_size": results.get("repository_info", {}).get("size", 0),
+        }
+        
+        # Count code quality issues
+        code_analysis = results.get("code_analysis", {})
+        total_issues = 0
+        critical_issues = 0
+        for language, language_results in code_analysis.items():
+            total_issues += language_results.get("issue_count", 0)
+            for issue in language_results.get("issues", []):
+                if issue.get("severity", "").lower() in ["critical", "high"]:
+                    critical_issues += 1
+        
+        metrics["total_code_issues"] = total_issues
+        metrics["critical_code_issues"] = critical_issues
+        
+        # Count security vulnerabilities
+        security_scan = results.get("security_scan", {})
+        total_vulnerabilities = 0
+        critical_vulnerabilities = 0
+        for language, language_results in security_scan.items():
+            total_vulnerabilities += language_results.get("vulnerability_count", 0)
+            for vuln in language_results.get("vulnerabilities", []):
+                if vuln.get("severity", "").lower() in ["critical", "high"]:
+                    critical_vulnerabilities += 1
+        
+        metrics["total_vulnerabilities"] = total_vulnerabilities
+        metrics["critical_vulnerabilities"] = critical_vulnerabilities
+        
+        # Count performance issues
+        performance_analysis = results.get("performance_analysis", {})
+        total_performance_issues = 0
+        for language, language_results in performance_analysis.get("language_results", {}).items():
+            total_performance_issues += language_results.get("issue_count", 0)
+        
+        metrics["total_performance_issues"] = total_performance_issues
+        metrics["performance_hotspots"] = len(performance_analysis.get("hotspots", []))
+        
+        # Calculate overall score (0-100)
+        # This is a simple scoring algorithm that can be refined
+        base_score = 100
+        deductions = 0
+        
+        # Deduct for code issues (more weight for critical issues)
+        if metrics["total_files"] > 0:
+            code_issue_ratio = metrics["total_code_issues"] / metrics["total_files"]
+            deductions += min(30, code_issue_ratio * 100)
+            deductions += min(20, (metrics["critical_code_issues"] / metrics["total_files"]) * 200)
+        
+        # Deduct for security vulnerabilities (heavy weight for critical vulnerabilities)
+        if metrics["total_files"] > 0:
+            deductions += min(30, (metrics["total_vulnerabilities"] / metrics["total_files"]) * 150)
+            deductions += min(40, (metrics["critical_vulnerabilities"] / metrics["total_files"]) * 300)
+        
+        # Deduct for performance issues
+        if metrics["total_files"] > 0:
+            deductions += min(20, (metrics["total_performance_issues"] / metrics["total_files"]) * 80)
+            deductions += min(10, (metrics["performance_hotspots"] / metrics["total_files"]) * 100)
+        
+        metrics["overall_score"] = max(0, min(100, base_score - deductions))
+        
+        # Determine quality rating based on score
+        if metrics["overall_score"] >= 90:
+            metrics["quality_rating"] = "Excellent"
+        elif metrics["overall_score"] >= 80:
+            metrics["quality_rating"] = "Good"
+        elif metrics["overall_score"] >= 70:
+            metrics["quality_rating"] = "Satisfactory"
+        elif metrics["overall_score"] >= 50:
+            metrics["quality_rating"] = "Needs Improvement"
+        else:
+            metrics["quality_rating"] = "Poor"
+        
+        return metrics
+    
+    def _extract_top_issues(self, code_analysis, limit=10):
+        """
+        Extract the top code quality issues from the analysis results.
+        
+        Args:
+            code_analysis (dict): Code analysis results.
+            limit (int): Maximum number of issues to extract.
+        
+        Returns:
+            list: Top code quality issues.
+        """
+        all_issues = []
+        
+        for language, language_results in code_analysis.items():
+            for issue in language_results.get("issues", []):
+                # Add language to the issue
+                issue["language"] = language
+                all_issues.append(issue)
+        
+        # Sort issues by severity and then by line count if available
+        severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+        
+        def issue_sort_key(issue):
+            severity = issue.get("severity", "").lower()
+            severity_value = severity_order.get(severity, 5)
+            return (severity_value, -issue.get("line_count", 0))
+        
+        sorted_issues = sorted(all_issues, key=issue_sort_key)
+        
+        return sorted_issues[:limit]
+    
+    def _extract_critical_vulnerabilities(self, security_scan, limit=10):
+        """
+        Extract critical security vulnerabilities from the scan results.
+        
+        Args:
+            security_scan (dict): Security scan results.
+            limit (int): Maximum number of vulnerabilities to extract.
+        
+        Returns:
+            list: Critical security vulnerabilities.
+        """
+        all_vulnerabilities = []
+        
+        for language, language_results in security_scan.items():
+            for vuln in language_results.get("vulnerabilities", []):
+                # Add language to the vulnerability
+                vuln["language"] = language
+                all_vulnerabilities.append(vuln)
+        
+        # Sort vulnerabilities by severity
+        severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+        
+        def vuln_sort_key(vuln):
+            severity = vuln.get("severity", "").lower()
+            severity_value = severity_order.get(severity, 5)
+            return severity_value
+        
+        sorted_vulnerabilities = sorted(all_vulnerabilities, key=vuln_sort_key)
+        
+        return sorted_vulnerabilities[:limit]
+    
+    def _generate_recommendations(self, results):
+        """
+        Generate recommendations based on the analysis results.
+        
+        Args:
+            results (dict): Analysis results.
+        
+        Returns:
+            dict: Recommendations categorized by priority.
+        """
+        recommendations = {
+            "high_priority": [],
+            "medium_priority": [],
+            "low_priority": [],
+        }
+        
+        # Extract critical security vulnerabilities as high priority recommendations
+        security_scan = results.get("security_scan", {})
+        for language, language_results in security_scan.items():
+            for vuln in language_results.get("vulnerabilities", []):
+                if vuln.get("severity", "").lower() in ["critical", "high"]:
+                    recommendations["high_priority"].append({
+                        "type": "security",
+                        "language": language,
+                        "issue": vuln.get("issue", "Unknown vulnerability"),
+                        "description": vuln.get("description", ""),
+                        "file": vuln.get("file", ""),
+                        "line": vuln.get("line", ""),
+                        "recommendation": vuln.get("recommendation", "Fix this security vulnerability."),
+                    })
+        
+        # Extract critical code quality issues as medium priority recommendations
+        code_analysis = results.get("code_analysis", {})
+        for language, language_results in code_analysis.items():
+            for issue in language_results.get("issues", []):
+                if issue.get("severity", "").lower() in ["critical", "high"]:
+                    recommendations["medium_priority"].append({
+                        "type": "code_quality",
+                        "language": language,
+                        "issue": issue.get("issue", "Unknown issue"),
+                        "description": issue.get("description", ""),
+                        "file": issue.get("file", ""),
+                        "line": issue.get("line", ""),
+                        "recommendation": issue.get("recommendation", "Address this code quality issue."),
+                    })
+        
+        # Extract performance hotspots as medium priority recommendations
+        performance_analysis = results.get("performance_analysis", {})
+        for hotspot in performance_analysis.get("hotspots", []):
+            recommendations["medium_priority"].append({
+                "type": "performance",
+                "language": hotspot.get("language", ""),
+                "issue": "Performance Hotspot",
+                "description": f"File contains {hotspot.get('issue_count', 0)} performance issues",
+                "file": hotspot.get("file", ""),
+                "recommendation": "Optimize this file to improve performance.",
+            })
+        
+        # Extract other performance issues as low priority recommendations
+        for language, language_results in performance_analysis.get("language_results", {}).items():
+            for issue in language_results.get("issues", []):
+                # Skip issues that are already part of hotspots
+                if any(hotspot.get("file", "") == issue.get("file", "") for hotspot in performance_analysis.get("hotspots", [])):
+                    continue
+                
+                recommendations["low_priority"].append({
+                    "type": "performance",
+                    "language": language,
+                    "issue": issue.get("issue", "Unknown issue"),
+                    "description": issue.get("description", ""),
+                    "file": issue.get("file", ""),
+                    "line": issue.get("line", ""),
+                    "recommendation": issue.get("recommendation", "Consider optimizing this code."),
+                })
+        
+        # Extract AI review suggestions as recommendations
+        ai_review = results.get("ai_review", {})
+        for file_path, review in ai_review.get("reviews", {}).items():
+            for suggestion in review.get("suggestions", []):
+                priority = "medium_priority"
+                if "security" in suggestion.get("section", "").lower():
+                    priority = "high_priority"
+                elif "performance" in suggestion.get("section", "").lower():
+                    priority = "low_priority"
+                
+                recommendations[priority].append({
+                    "type": "ai_review",
+                    "language": "",  # AI review doesn't specify language
+                    "issue": suggestion.get("section", "AI Suggestion"),
+                    "description": suggestion.get("description", ""),
+                    "file": file_path,
+                    "line": suggestion.get("line", ""),
+                    "recommendation": suggestion.get("details", ""),
+                })
+        
+        # Limit the number of recommendations in each category
+        limit = 15
+        recommendations["high_priority"] = recommendations["high_priority"][:limit]
+        recommendations["medium_priority"] = recommendations["medium_priority"][:limit]
+        recommendations["low_priority"] = recommendations["low_priority"][:limit]
+        
+        return recommendations
+    
+    def _generate_json_report(self, report_name, report_content):
+        """
+        Generate a JSON report.
+        
+        Args:
+            report_name (str): Name of the report.
+            report_content (dict): Report content.
+        
+        Returns:
+            str: Path to the generated report.
+        """
+        report_path = os.path.join(self.output_dir, f"{report_name}.json")
+        
+        with open(report_path, "w", encoding="utf-8") as f:
+            json.dump(report_content, f, indent=2, ensure_ascii=False)
+        
+        logger.info(f"Generated JSON report: {report_path}")
+        return report_path
+    
+    def _generate_html_report(self, report_name, report_content):
+        """
+        Generate an HTML report.
+        
+        Args:
+            report_name (str): Name of the report.
+            report_content (dict): Report content.
+        
+        Returns:
+            str: Path to the generated report.
+        """
+        report_path = os.path.join(self.output_dir, f"{report_name}.html")
+        
+        # Convert report content to markdown
+        md_content = self._convert_to_markdown(report_content)
+        
+        # Convert markdown to HTML
+        html_content = markdown.markdown(md_content, extensions=["tables", "fenced_code"])
+        
+        # Add CSS styling
+        html_content = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1">
+            <title>Code Review Report: {report_content['metadata']['repository_name']}</title>
+            <style>
+                body {{font-family: Arial, sans-serif; line-height: 1.6; max-width: 1200px; margin: 0 auto; padding: 20px;}}
+                h1, h2, h3, h4 {{color: #333; margin-top: 30px;}}
+                h1 {{border-bottom: 2px solid #333; padding-bottom: 10px;}}
+                h2 {{border-bottom: 1px solid #ccc; padding-bottom: 5px;}}
+                table {{border-collapse: collapse; width: 100%; margin: 20px 0;}}
+                th, td {{text-align: left; padding: 12px; border-bottom: 1px solid #ddd;}}
+                th {{background-color: #f2f2f2;}}
+                tr:hover {{background-color: #f5f5f5;}}
+                .metric-card {{background-color: #f9f9f9; border-radius: 5px; padding: 15px; margin: 10px 0; box-shadow: 0 2px 4px rgba(0,0,0,0.1);}}
+                .metric-value {{font-size: 24px; font-weight: bold; color: #333;}}
+                .metric-label {{font-size: 14px; color: #666;}}
+                .severity-critical {{color: #d9534f; font-weight: bold;}}
+                .severity-high {{color: #f0ad4e; font-weight: bold;}}
+                .severity-medium {{color: #5bc0de; font-weight: bold;}}
+                .severity-low {{color: #5cb85c; font-weight: bold;}}
+                .metrics-container {{display: flex; flex-wrap: wrap; gap: 20px; justify-content: space-between;}}
+                .metric-card {{flex: 1; min-width: 200px;}}
+                pre {{background-color: #f5f5f5; padding: 15px; border-radius: 5px; overflow-x: auto;}}
+                code {{font-family: Consolas, Monaco, 'Andale Mono', monospace; font-size: 14px;}}
+                .recommendation {{background-color: #f9f9f9; border-left: 4px solid #5bc0de; padding: 10px; margin: 10px 0;}}
+                .high-priority {{border-left-color: #d9534f;}}
+                .medium-priority {{border-left-color: #f0ad4e;}}
+                .low-priority {{border-left-color: #5cb85c;}}
+            </style>
+        </head>
+        <body>
+            {html_content}
+        </body>
+        </html>
+        """
+        
+        with open(report_path, "w", encoding="utf-8") as f:
+            f.write(html_content)
+        
+        logger.info(f"Generated HTML report: {report_path}")
+        return report_path
+    
+    def _generate_pdf_report(self, report_name, report_content):
+        """
+        Generate a PDF report.
+        
+        Args:
+            report_name (str): Name of the report.
+            report_content (dict): Report content.
+        
+        Returns:
+            str: Path to the generated report.
+        """
+        report_path = os.path.join(self.output_dir, f"{report_name}.pdf")
+        
+        # First generate HTML report
+        html_path = self._generate_html_report(f"{report_name}_temp", report_content)
+        
+        try:
+            # Convert HTML to PDF using pdfkit
+            pdfkit.from_file(html_path, report_path)
+            
+            # Remove temporary HTML file
+            os.remove(html_path)
+            
+            logger.info(f"Generated PDF report: {report_path}")
+            return report_path
+        
+        except Exception as e:
+            logger.error(f"Error generating PDF report: {e}")
+            return html_path
+    
+    def _generate_csv_report(self, report_name, report_content):
+        """
+        Generate a CSV report with issues and recommendations.
+        
+        Args:
+            report_name (str): Name of the report.
+            report_content (dict): Report content.
+        
+        Returns:
+            str: Path to the generated report.
+        """
+        report_path = os.path.join(self.output_dir, f"{report_name}.csv")
+        
+        # Collect all issues and recommendations
+        rows = []
+        
+        # Add code quality issues
+        for language, language_results in report_content["code_quality"]["issues_by_language"].items():
+            for issue in language_results.get("issues", []):
+                rows.append({
+                    "Type": "Code Quality",
+                    "Language": language,
+                    "Severity": issue.get("severity", ""),
+                    "Issue": issue.get("issue", ""),
+                    "Description": issue.get("description", ""),
+                    "File": issue.get("file", ""),
+                    "Line": issue.get("line", ""),
+                    "Recommendation": issue.get("recommendation", ""),
+                })
+        
+        # Add security vulnerabilities
+        for language, language_results in report_content["security"]["vulnerabilities_by_language"].items():
+            for vuln in language_results.get("vulnerabilities", []):
+                rows.append({
+                    "Type": "Security",
+                    "Language": language,
+                    "Severity": vuln.get("severity", ""),
+                    "Issue": vuln.get("issue", ""),
+                    "Description": vuln.get("description", ""),
+                    "File": vuln.get("file", ""),
+                    "Line": vuln.get("line", ""),
+                    "Recommendation": vuln.get("recommendation", ""),
+                })
+        
+        # Add performance issues
+        for language, language_results in report_content["performance"]["issues_by_language"].items():
+            for issue in language_results.get("issues", []):
+                rows.append({
+                    "Type": "Performance",
+                    "Language": language,
+                    "Severity": issue.get("severity", "Medium"),
+                    "Issue": issue.get("issue", ""),
+                    "Description": issue.get("description", ""),
+                    "File": issue.get("file", ""),
+                    "Line": issue.get("line", ""),
+                    "Recommendation": issue.get("recommendation", ""),
+                })
+        
+        # Add AI review suggestions
+        for file_path, review in report_content["ai_review"]["file_reviews"].items():
+            for suggestion in review.get("suggestions", []):
+                rows.append({
+                    "Type": "AI Review",
+                    "Language": "",
+                    "Severity": "",
+                    "Issue": suggestion.get("section", ""),
+                    "Description": suggestion.get("description", ""),
+                    "File": file_path,
+                    "Line": suggestion.get("line", ""),
+                    "Recommendation": suggestion.get("details", ""),
+                })
+        
+        # Write to CSV
+        with open(report_path, "w", newline="", encoding="utf-8") as f:
+            fieldnames = ["Type", "Language", "Severity", "Issue", "Description", "File", "Line", "Recommendation"]
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            writer.writerows(rows)
+        
+        logger.info(f"Generated CSV report: {report_path}")
+        return report_path
+    
+    def _convert_to_markdown(self, report_content):
+        """
+        Convert report content to markdown format.
+        
+        Args:
+            report_content (dict): Report content.
+        
+        Returns:
+            str: Markdown formatted report.
+        """
+        md = []
+        
+        # Title and metadata
+        md.append(f"# Code Review Report: {report_content['metadata']['repository_name']}")
+        md.append(f"**Report Date:** {report_content['metadata']['report_date']}")
+        md.append("")
+        
+        # Repository info
+        repo_info = report_content['metadata']['repository_info']
+        md.append("## Repository Information")
+        md.append(f"**Branch:** {repo_info.get('branch', 'N/A')}")
+        md.append(f"**Commit:** {repo_info.get('commit', 'N/A')}")
+        md.append(f"**Remote URL:** {repo_info.get('remote_url', 'N/A')}")
+        md.append(f"**Size:** {repo_info.get('size', 0)} bytes")
+        md.append(f"**File Count:** {repo_info.get('file_count', 0)}")
+        md.append("")
+        
+        # Summary metrics
+        md.append("## Executive Summary")
+        metrics = report_content['summary']['metrics']
+        md.append(f"**Overall Score:** {metrics.get('overall_score', 0)}/100")
+        md.append(f"**Quality Rating:** {metrics.get('quality_rating', 'N/A')}")
+        md.append("")
+        md.append("### Key Metrics")
+        md.append("| Metric | Value |")
+        md.append("| ------ | ----- |")
+        md.append(f"| Total Files | {metrics.get('total_files', 0)} |")
+        md.append(f"| Code Quality Issues | {metrics.get('total_code_issues', 0)} |")
+        md.append(f"| Critical Code Issues | {metrics.get('critical_code_issues', 0)} |")
+        md.append(f"| Security Vulnerabilities | {metrics.get('total_vulnerabilities', 0)} |")
+        md.append(f"| Critical Vulnerabilities | {metrics.get('critical_vulnerabilities', 0)} |")
+        md.append(f"| Performance Issues | {metrics.get('total_performance_issues', 0)} |")
+        md.append(f"| Performance Hotspots | {metrics.get('performance_hotspots', 0)} |")
+        md.append("")
+        
+        # Language breakdown
+        md.append("### Language Breakdown")
+        language_breakdown = report_content['summary']['language_breakdown']
+        md.append("| Language | Files | Lines | Percentage |")
+        md.append("| -------- | ----- | ----- | ---------- |")
+        for language, stats in language_breakdown.items():
+            md.append(f"| {language} | {stats.get('files', 0)} | {stats.get('lines', 0)} | {stats.get('percentage', 0)}% |")
+        md.append("")
+        
+        # Executive summary from AI review
+        md.append("### Executive Summary")
+        md.append(report_content['summary']['executive_summary'])
+        md.append("")
+        
+        # Code quality issues
+        md.append("## Code Quality Analysis")
+        md.append("### Top Issues")
+        top_issues = report_content['code_quality']['top_issues']
+        if top_issues:
+            md.append("| Severity | Language | Issue | File | Line |")
+            md.append("| -------- | -------- | ----- | ---- | ---- |")
+            for issue in top_issues:
+                md.append(f"| {issue.get('severity', 'N/A')} | {issue.get('language', 'N/A')} | {issue.get('issue', 'N/A')} | {issue.get('file', 'N/A')} | {issue.get('line', 'N/A')} |")
+        else:
+            md.append("No code quality issues found.")
+        md.append("")
+        
+        # Security vulnerabilities
+        md.append("## Security Analysis")
+        md.append("### Critical Vulnerabilities")
+        critical_vulnerabilities = report_content['security']['critical_vulnerabilities']
+        if critical_vulnerabilities:
+            md.append("| Severity | Language | Vulnerability | File | Line |")
+            md.append("| -------- | -------- | ------------- | ---- | ---- |")
+            for vuln in critical_vulnerabilities:
+                md.append(f"| {vuln.get('severity', 'N/A')} | {vuln.get('language', 'N/A')} | {vuln.get('issue', 'N/A')} | {vuln.get('file', 'N/A')} | {vuln.get('line', 'N/A')} |")
+        else:
+            md.append("No critical security vulnerabilities found.")
+        md.append("")
+        
+        # Performance analysis
+        md.append("## Performance Analysis")
+        md.append("### Performance Hotspots")
+        hotspots = report_content['performance']['hotspots']
+        if hotspots:
+            md.append("| Language | File | Issue Count |")
+            md.append("| -------- | ---- | ----------- |")
+            for hotspot in hotspots:
+                md.append(f"| {hotspot.get('language', 'N/A')} | {hotspot.get('file', 'N/A')} | {hotspot.get('issue_count', 0)} |")
+        else:
+            md.append("No performance hotspots found.")
+        md.append("")
+        
+        # Recommendations
+        md.append("## Recommendations")
+        
+        # High priority recommendations
+        md.append("### High Priority")
+        high_priority = report_content['recommendations']['high_priority']
+        if high_priority:
+            for i, rec in enumerate(high_priority, 1):
+                md.append(f"**{i}. {rec.get('issue', 'Recommendation')}**")
+                md.append(f"- **Type:** {rec.get('type', 'N/A')}")
+                md.append(f"- **File:** {rec.get('file', 'N/A')}")
+                if rec.get('line'):
+                    md.append(f"- **Line:** {rec.get('line')}")
+                md.append(f"- **Description:** {rec.get('description', 'N/A')}")
+                md.append(f"- **Recommendation:** {rec.get('recommendation', 'N/A')}")
+                md.append("")
+        else:
+            md.append("No high priority recommendations.")
+        md.append("")
+        
+        # Medium priority recommendations
+        md.append("### Medium Priority")
+        medium_priority = report_content['recommendations']['medium_priority']
+        if medium_priority:
+            for i, rec in enumerate(medium_priority, 1):
+                md.append(f"**{i}. {rec.get('issue', 'Recommendation')}**")
+                md.append(f"- **Type:** {rec.get('type', 'N/A')}")
+                md.append(f"- **File:** {rec.get('file', 'N/A')}")
+                if rec.get('line'):
+                    md.append(f"- **Line:** {rec.get('line')}")
+                md.append(f"- **Description:** {rec.get('description', 'N/A')}")
+                md.append(f"- **Recommendation:** {rec.get('recommendation', 'N/A')}")
+                md.append("")
+        else:
+            md.append("No medium priority recommendations.")
+        md.append("")
+        
+        # Low priority recommendations
+        md.append("### Low Priority")
+        low_priority = report_content['recommendations']['low_priority']
+        if low_priority:
+            for i, rec in enumerate(low_priority, 1):
+                md.append(f"**{i}. {rec.get('issue', 'Recommendation')}**")
+                md.append(f"- **Type:** {rec.get('type', 'N/A')}")
+                md.append(f"- **File:** {rec.get('file', 'N/A')}")
+                if rec.get('line'):
+                    md.append(f"- **Line:** {rec.get('line')}")
+                md.append(f"- **Description:** {rec.get('description', 'N/A')}")
+                md.append(f"- **Recommendation:** {rec.get('recommendation', 'N/A')}")
+                md.append("")
+        else:
+            md.append("No low priority recommendations.")
+        
+        return "\n".join(md)

src/services/repository_service.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Repository Service
+
+This module provides functionality for cloning and managing Git repositories.
+"""
+
+import os
+import shutil
+import tempfile
+import logging
+import re
+from git import Repo
+from git.exc import GitCommandError
+
+logger = logging.getLogger(__name__)
+
+class RepositoryService:
+    """
+    Service for cloning and managing Git repositories.
+    """
+    
+    def __init__(self, base_temp_dir=None):
+        """
+        Initialize the RepositoryService.
+        
+        Args:
+            base_temp_dir (str, optional): Base directory for temporary repositories.
+                If None, system temp directory will be used.
+        """
+        self.base_temp_dir = base_temp_dir or tempfile.gettempdir()
+        self.repos = {}
+        logger.info(f"Initialized RepositoryService with base temp dir: {self.base_temp_dir}")
+    
+    def validate_github_url(self, url):
+        """
+        Validate if the provided URL is a valid GitHub repository URL.
+        
+        Args:
+            url (str): The GitHub repository URL to validate.
+        
+        Returns:
+            bool: True if the URL is valid, False otherwise.
+        """
+        # GitHub URL patterns
+        patterns = [
+            r'^https?://github\.com/[\w.-]+/[\w.-]+(\.git)?$',  # https://github.com/user/repo[.git]
+            r'^git@github\.com:[\w.-]+/[\w.-]+(\.git)?$',        # git@github.com:user/repo[.git]
+        ]
+        
+        for pattern in patterns:
+            if re.match(pattern, url):
+                return True
+        
+        return False
+    
+    def normalize_github_url(self, url):
+        """
+        Normalize a GitHub URL to a consistent format.
+        
+        Args:
+            url (str): The GitHub repository URL to normalize.
+        
+        Returns:
+            str: The normalized URL.
+        """
+        # Convert SSH URL to HTTPS URL
+        if url.startswith('git@github.com:'):
+            user_repo = url[len('git@github.com:'):]
+            if user_repo.endswith('.git'):
+                user_repo = user_repo[:-4]
+            return f"https://github.com/{user_repo}"
+        
+        # Ensure HTTPS URL ends without .git
+        if url.startswith('http'):
+            if url.endswith('.git'):
+                return url[:-4]
+        
+        return url
+    
+    def extract_repo_name(self, url):
+        """
+        Extract repository name from a GitHub URL.
+        
+        Args:
+            url (str): The GitHub repository URL.
+        
+        Returns:
+            str: The repository name.
+        """
+        normalized_url = self.normalize_github_url(url)
+        return normalized_url.split('/')[-1]
+    
+    def clone_repository(self, url, branch=None):
+        """
+        Clone a Git repository from the provided URL.
+        
+        Args:
+            url (str): The repository URL to clone.
+            branch (str, optional): The branch to checkout. If None, the default branch is used.
+        
+        Returns:
+            str: The path to the cloned repository.
+        
+        Raises:
+            ValueError: If the URL is not a valid GitHub repository URL.
+            GitCommandError: If there's an error during the Git operation.
+        """
+        if not self.validate_github_url(url):
+            raise ValueError(f"Invalid GitHub repository URL: {url}")
+        
+        repo_name = self.extract_repo_name(url)
+        repo_dir = os.path.join(self.base_temp_dir, f"codereview_{repo_name}_{os.urandom(4).hex()}")
+        
+        logger.info(f"Cloning repository {url} to {repo_dir}")
+        
+        try:
+            # Clone the repository
+            if branch:
+                repo = Repo.clone_from(url, repo_dir, branch=branch)
+                logger.info(f"Cloned repository {url} (branch: {branch}) to {repo_dir}")
+            else:
+                repo = Repo.clone_from(url, repo_dir)
+                logger.info(f"Cloned repository {url} (default branch) to {repo_dir}")
+            
+            # Store the repository instance
+            self.repos[repo_dir] = repo
+            
+            return repo_dir
+        
+        except GitCommandError as e:
+            logger.error(f"Error cloning repository {url}: {e}")
+            # Clean up the directory if it was created
+            if os.path.exists(repo_dir):
+                shutil.rmtree(repo_dir, ignore_errors=True)
+            raise
+    
+    def get_repository_info(self, repo_path):
+        """
+        Get information about a repository.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: A dictionary containing repository information.
+        """
+        if repo_path not in self.repos:
+            try:
+                self.repos[repo_path] = Repo(repo_path)
+            except Exception as e:
+                logger.error(f"Error opening repository at {repo_path}: {e}")
+                return {}
+        
+        repo = self.repos[repo_path]
+        
+        try:
+            # Get the active branch
+            try:
+                active_branch = repo.active_branch.name
+            except TypeError:
+                # Detached HEAD state
+                active_branch = 'HEAD detached'
+            
+            # Get the latest commit
+            latest_commit = repo.head.commit
+            
+            # Get remote URL
+            try:
+                remote_url = repo.remotes.origin.url
+            except AttributeError:
+                remote_url = 'No remote URL found'
+            
+            # Get repository size (approximate)
+            repo_size = sum(os.path.getsize(os.path.join(dirpath, filename))
+                           for dirpath, _, filenames in os.walk(repo_path)
+                           for filename in filenames)
+            
+            # Count files
+            file_count = sum(len(files) for _, _, files in os.walk(repo_path))
+            
+            return {
+                'path': repo_path,
+                'active_branch': active_branch,
+                'latest_commit': {
+                    'hash': latest_commit.hexsha,
+                    'author': f"{latest_commit.author.name} <{latest_commit.author.email}>",
+                    'date': latest_commit.committed_datetime.isoformat(),
+                    'message': latest_commit.message.strip(),
+                },
+                'remote_url': remote_url,
+                'size_bytes': repo_size,
+                'file_count': file_count,
+            }
+        
+        except Exception as e:
+            logger.error(f"Error getting repository info for {repo_path}: {e}")
+            return {
+                'path': repo_path,
+                'error': str(e),
+            }
+    
+    def cleanup_repository(self, repo_path):
+        """
+        Clean up a cloned repository.
+        
+        Args:
+            repo_path (str): The path to the repository to clean up.
+        
+        Returns:
+            bool: True if the cleanup was successful, False otherwise.
+        """
+        logger.info(f"Cleaning up repository at {repo_path}")
+        
+        # Remove the repository from the tracked repos
+        if repo_path in self.repos:
+            del self.repos[repo_path]
+        
+        # Remove the directory
+        try:
+            if os.path.exists(repo_path):
+                shutil.rmtree(repo_path, ignore_errors=True)
+            return True
+        except Exception as e:
+            logger.error(f"Error cleaning up repository at {repo_path}: {e}")
+            return False
+    
+    def cleanup_all_repositories(self):
+        """
+        Clean up all cloned repositories.
+        
+        Returns:
+            bool: True if all cleanups were successful, False otherwise.
+        """
+        logger.info("Cleaning up all repositories")
+        
+        success = True
+        for repo_path in list(self.repos.keys()):
+            if not self.cleanup_repository(repo_path):
+                success = False
+        
+        return success

src/services/security_scanner.py

@@ -0,0 +1,810 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Security Scanner Service
+
+This module provides functionality for scanning code for security vulnerabilities.
+"""
+
+import os
+import subprocess
+import logging
+import json
+import tempfile
+from collections import defaultdict
+
+logger = logging.getLogger(__name__)
+
+class SecurityScanner:
+    """
+    Service for scanning code for security vulnerabilities.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the SecurityScanner.
+        """
+        logger.info("Initialized SecurityScanner")
+        self.scanners = {
+            'Python': self._scan_python,
+            'JavaScript': self._scan_javascript,
+            'TypeScript': self._scan_javascript,  # TypeScript uses the same scanner as JavaScript
+            'Java': self._scan_java,
+            'Go': self._scan_go,
+            'Rust': self._scan_rust,
+        }
+    
+    def scan_repository(self, repo_path, languages):
+        """
+        Scan a repository for security vulnerabilities in the specified languages.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            languages (list): A list of programming languages to scan.
+        
+        Returns:
+            dict: A dictionary containing scan results for each language.
+        """
+        logger.info(f"Scanning repository at {repo_path} for security vulnerabilities in languages: {languages}")
+        
+        results = {}
+        
+        # Scan dependencies first (language-agnostic)
+        results['dependencies'] = self._scan_dependencies(repo_path)
+        
+        # Scan each language
+        for language in languages:
+            if language in self.scanners:
+                try:
+                    logger.info(f"Scanning {language} code in {repo_path} for security vulnerabilities")
+                    results[language] = self.scanners[language](repo_path)
+                except Exception as e:
+                    logger.error(f"Error scanning {language} code for security vulnerabilities: {e}")
+                    results[language] = {
+                        'status': 'error',
+                        'error': str(e),
+                        'vulnerabilities': [],
+                    }
+            else:
+                logger.warning(f"No security scanner available for {language}")
+                results[language] = {
+                    'status': 'not_supported',
+                    'message': f"Security scanning for {language} is not supported yet.",
+                    'vulnerabilities': [],
+                }
+        
+        return results
+    
+    def _scan_dependencies(self, repo_path):
+        """
+        Scan dependencies for known vulnerabilities.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Dependency scan results.
+        """
+        logger.info(f"Scanning dependencies in {repo_path}")
+        
+        results = {
+            'python': self._scan_python_dependencies(repo_path),
+            'javascript': self._scan_javascript_dependencies(repo_path),
+            'java': self._scan_java_dependencies(repo_path),
+            'go': self._scan_go_dependencies(repo_path),
+            'rust': self._scan_rust_dependencies(repo_path),
+        }
+        
+        # Aggregate vulnerabilities
+        all_vulnerabilities = []
+        for lang_result in results.values():
+            all_vulnerabilities.extend(lang_result.get('vulnerabilities', []))
+        
+        return {
+            'status': 'success',
+            'vulnerabilities': all_vulnerabilities,
+            'vulnerability_count': len(all_vulnerabilities),
+            'language_results': results,
+        }
+    
+    def _scan_python_dependencies(self, repo_path):
+        """
+        Scan Python dependencies for known vulnerabilities using safety.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Python dependencies.
+        """
+        logger.info(f"Scanning Python dependencies in {repo_path}")
+        
+        # Find requirements files
+        requirements_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file == 'requirements.txt' or file == 'Pipfile' or file == 'Pipfile.lock' or file == 'setup.py':
+                    requirements_files.append(os.path.join(root, file))
+        
+        if not requirements_files:
+            return {
+                'status': 'no_dependencies',
+                'message': 'No Python dependency files found.',
+                'vulnerabilities': [],
+            }
+        
+        vulnerabilities = []
+        
+        for req_file in requirements_files:
+            try:
+                # Run safety check
+                cmd = [
+                    'safety',
+                    'check',
+                    '--file', req_file,
+                    '--json',
+                ]
+                
+                process = subprocess.run(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    check=False,
+                )
+                
+                # Parse safety output
+                if process.stdout.strip():
+                    try:
+                        safety_results = json.loads(process.stdout)
+                        
+                        for vuln in safety_results.get('vulnerabilities', []):
+                            vulnerabilities.append({
+                                'package': vuln.get('package_name', ''),
+                                'installed_version': vuln.get('installed_version', ''),
+                                'affected_versions': vuln.get('vulnerable_spec', ''),
+                                'description': vuln.get('advisory', ''),
+                                'severity': vuln.get('severity', ''),
+                                'file': req_file,
+                                'language': 'Python',
+                            })
+                    except json.JSONDecodeError:
+                        logger.error(f"Error parsing safety output: {process.stdout}")
+            except Exception as e:
+                logger.error(f"Error running safety on {req_file}: {e}")
+        
+        return {
+            'status': 'success',
+            'vulnerabilities': vulnerabilities,
+            'vulnerability_count': len(vulnerabilities),
+            'files_scanned': requirements_files,
+        }
+    
+    def _scan_javascript_dependencies(self, repo_path):
+        """
+        Scan JavaScript/TypeScript dependencies for known vulnerabilities using npm audit.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for JavaScript dependencies.
+        """
+        logger.info(f"Scanning JavaScript dependencies in {repo_path}")
+        
+        # Find package.json files
+        package_files = []
+        for root, _, files in os.walk(repo_path):
+            if 'package.json' in files:
+                package_files.append(os.path.join(root, 'package.json'))
+        
+        if not package_files:
+            return {
+                'status': 'no_dependencies',
+                'message': 'No JavaScript dependency files found.',
+                'vulnerabilities': [],
+            }
+        
+        vulnerabilities = []
+        
+        for pkg_file in package_files:
+            pkg_dir = os.path.dirname(pkg_file)
+            try:
+                # Run npm audit
+                cmd = [
+                    'npm',
+                    'audit',
+                    '--json',
+                ]
+                
+                process = subprocess.run(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    check=False,
+                    cwd=pkg_dir,  # Run in the directory containing package.json
+                )
+                
+                # Parse npm audit output
+                if process.stdout.strip():
+                    try:
+                        audit_results = json.loads(process.stdout)
+                        
+                        # Extract vulnerabilities from npm audit results
+                        for vuln_id, vuln_info in audit_results.get('vulnerabilities', {}).items():
+                            vulnerabilities.append({
+                                'package': vuln_info.get('name', ''),
+                                'installed_version': vuln_info.get('version', ''),
+                                'affected_versions': vuln_info.get('range', ''),
+                                'description': vuln_info.get('overview', ''),
+                                'severity': vuln_info.get('severity', ''),
+                                'file': pkg_file,
+                                'language': 'JavaScript',
+                                'cwe': vuln_info.get('cwe', ''),
+                                'recommendation': vuln_info.get('recommendation', ''),
+                            })
+                    except json.JSONDecodeError:
+                        logger.error(f"Error parsing npm audit output: {process.stdout}")
+            except Exception as e:
+                logger.error(f"Error running npm audit on {pkg_file}: {e}")
+        
+        return {
+            'status': 'success',
+            'vulnerabilities': vulnerabilities,
+            'vulnerability_count': len(vulnerabilities),
+            'files_scanned': package_files,
+        }
+    
+    def _scan_java_dependencies(self, repo_path):
+        """
+        Scan Java dependencies for known vulnerabilities.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Java dependencies.
+        """
+        logger.info(f"Scanning Java dependencies in {repo_path}")
+        
+        # Find pom.xml or build.gradle files
+        dependency_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file == 'pom.xml' or file == 'build.gradle':
+                    dependency_files.append(os.path.join(root, file))
+        
+        if not dependency_files:
+            return {
+                'status': 'no_dependencies',
+                'message': 'No Java dependency files found.',
+                'vulnerabilities': [],
+            }
+        
+        # For now, we'll just return a placeholder since we don't have a direct tool
+        # In a real implementation, you might use OWASP Dependency Check or similar
+        return {
+            'status': 'not_implemented',
+            'message': 'Java dependency scanning is not fully implemented yet.',
+            'vulnerabilities': [],
+            'files_scanned': dependency_files,
+        }
+    
+    def _scan_go_dependencies(self, repo_path):
+        """
+        Scan Go dependencies for known vulnerabilities using govulncheck.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Go dependencies.
+        """
+        logger.info(f"Scanning Go dependencies in {repo_path}")
+        
+        # Check if go.mod exists
+        go_mod_path = os.path.join(repo_path, 'go.mod')
+        if not os.path.exists(go_mod_path):
+            return {
+                'status': 'no_dependencies',
+                'message': 'No Go dependency files found.',
+                'vulnerabilities': [],
+            }
+        
+        try:
+            # Run govulncheck
+            cmd = [
+                'govulncheck',
+                '-json',
+                './...',
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+                cwd=repo_path,  # Run in the repository directory
+            )
+            
+            # Parse govulncheck output
+            vulnerabilities = []
+            if process.stdout.strip():
+                for line in process.stdout.splitlines():
+                    try:
+                        result = json.loads(line)
+                        if 'vulnerability' in result:
+                            vuln = result['vulnerability']
+                            vulnerabilities.append({
+                                'package': vuln.get('package', ''),
+                                'description': vuln.get('details', ''),
+                                'severity': 'high',  # govulncheck doesn't provide severity
+                                'file': go_mod_path,
+                                'language': 'Go',
+                                'cve': vuln.get('osv', {}).get('id', ''),
+                                'affected_versions': vuln.get('osv', {}).get('affected', ''),
+                            })
+                    except json.JSONDecodeError:
+                        continue
+            
+            return {
+                'status': 'success',
+                'vulnerabilities': vulnerabilities,
+                'vulnerability_count': len(vulnerabilities),
+                'files_scanned': [go_mod_path],
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running govulncheck: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'vulnerabilities': [],
+            }
+    
+    def _scan_rust_dependencies(self, repo_path):
+        """
+        Scan Rust dependencies for known vulnerabilities using cargo-audit.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Rust dependencies.
+        """
+        logger.info(f"Scanning Rust dependencies in {repo_path}")
+        
+        # Check if Cargo.toml exists
+        cargo_toml_path = os.path.join(repo_path, 'Cargo.toml')
+        if not os.path.exists(cargo_toml_path):
+            return {
+                'status': 'no_dependencies',
+                'message': 'No Rust dependency files found.',
+                'vulnerabilities': [],
+            }
+        
+        try:
+            # Run cargo-audit
+            cmd = [
+                'cargo',
+                'audit',
+                '--json',
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+                cwd=repo_path,  # Run in the repository directory
+            )
+            
+            # Parse cargo-audit output
+            vulnerabilities = []
+            if process.stdout.strip():
+                try:
+                    audit_results = json.loads(process.stdout)
+                    
+                    for vuln in audit_results.get('vulnerabilities', {}).get('list', []):
+                        vulnerabilities.append({
+                            'package': vuln.get('package', {}).get('name', ''),
+                            'installed_version': vuln.get('package', {}).get('version', ''),
+                            'description': vuln.get('advisory', {}).get('description', ''),
+                            'severity': vuln.get('advisory', {}).get('severity', ''),
+                            'file': cargo_toml_path,
+                            'language': 'Rust',
+                            'cve': vuln.get('advisory', {}).get('id', ''),
+                        })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing cargo-audit output: {process.stdout}")
+            
+            return {
+                'status': 'success',
+                'vulnerabilities': vulnerabilities,
+                'vulnerability_count': len(vulnerabilities),
+                'files_scanned': [cargo_toml_path],
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running cargo-audit: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'vulnerabilities': [],
+            }
+    
+    def _scan_python(self, repo_path):
+        """
+        Scan Python code for security vulnerabilities using bandit.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Python code.
+        """
+        logger.info(f"Scanning Python code in {repo_path} for security vulnerabilities")
+        
+        # Find Python files
+        python_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.py'):
+                    python_files.append(os.path.join(root, file))
+        
+        if not python_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Python files found in the repository.',
+                'vulnerabilities': [],
+            }
+        
+        try:
+            # Run bandit
+            cmd = [
+                'bandit',
+                '-r',
+                '-f', 'json',
+                repo_path,
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse bandit output
+            vulnerabilities = []
+            if process.stdout.strip():
+                try:
+                    bandit_results = json.loads(process.stdout)
+                    
+                    for result in bandit_results.get('results', []):
+                        vulnerabilities.append({
+                            'file': result.get('filename', ''),
+                            'line': result.get('line_number', 0),
+                            'code': result.get('code', ''),
+                            'issue': result.get('issue_text', ''),
+                            'severity': result.get('issue_severity', ''),
+                            'confidence': result.get('issue_confidence', ''),
+                            'cwe': result.get('cwe', ''),
+                            'test_id': result.get('test_id', ''),
+                            'test_name': result.get('test_name', ''),
+                            'language': 'Python',
+                        })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing bandit output: {process.stdout}")
+            
+            # Group vulnerabilities by severity
+            vulns_by_severity = defaultdict(list)
+            for vuln in vulnerabilities:
+                severity = vuln.get('severity', 'unknown')
+                vulns_by_severity[severity].append(vuln)
+            
+            return {
+                'status': 'success',
+                'vulnerabilities': vulnerabilities,
+                'vulnerabilities_by_severity': dict(vulns_by_severity),
+                'vulnerability_count': len(vulnerabilities),
+                'files_scanned': len(python_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running bandit: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'vulnerabilities': [],
+            }
+    
+    def _scan_javascript(self, repo_path):
+        """
+        Scan JavaScript/TypeScript code for security vulnerabilities using NodeJSScan.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for JavaScript/TypeScript code.
+        """
+        logger.info(f"Scanning JavaScript/TypeScript code in {repo_path} for security vulnerabilities")
+        
+        # Find JavaScript/TypeScript files
+        js_files = []
+        for root, _, files in os.walk(repo_path):
+            if 'node_modules' in root:
+                continue
+            for file in files:
+                if file.endswith(('.js', '.jsx', '.ts', '.tsx')):
+                    js_files.append(os.path.join(root, file))
+        
+        if not js_files:
+            return {
+                'status': 'no_files',
+                'message': 'No JavaScript/TypeScript files found in the repository.',
+                'vulnerabilities': [],
+            }
+        
+        # For now, we'll use a simplified approach since NodeJSScan might not be available
+        # In a real implementation, you might use NodeJSScan or similar
+        
+        # Create a temporary ESLint configuration file with security rules
+        eslint_config = {
+            "env": {
+                "browser": True,
+                "es2021": True,
+                "node": True
+            },
+            "extends": [
+                "eslint:recommended",
+                "plugin:security/recommended"
+            ],
+            "plugins": [
+                "security"
+            ],
+            "parserOptions": {
+                "ecmaVersion": 12,
+                "sourceType": "module",
+                "ecmaFeatures": {
+                    "jsx": True
+                }
+            },
+            "rules": {}
+        }
+        
+        with tempfile.NamedTemporaryFile(suffix='.json', delete=False) as temp_config:
+            json.dump(eslint_config, temp_config)
+            temp_config_path = temp_config.name
+        
+        try:
+            # Run ESLint with security plugin
+            cmd = [
+                'npx',
+                'eslint',
+                '--config', temp_config_path,
+                '--format', 'json',
+                '--plugin', 'security',
+            ] + js_files
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+            )
+            
+            # Parse ESLint output
+            vulnerabilities = []
+            if process.stdout.strip():
+                try:
+                    eslint_results = json.loads(process.stdout)
+                    
+                    for result in eslint_results:
+                        file_path = result.get('filePath', '')
+                        for message in result.get('messages', []):
+                            # Only include security-related issues
+                            rule_id = message.get('ruleId', '')
+                            if rule_id and ('security' in rule_id or 'no-eval' in rule_id or 'no-implied-eval' in rule_id):
+                                vulnerabilities.append({
+                                    'file': file_path,
+                                    'line': message.get('line', 0),
+                                    'column': message.get('column', 0),
+                                    'issue': message.get('message', ''),
+                                    'severity': 'high' if message.get('severity', 0) == 2 else 'medium',
+                                    'rule': rule_id,
+                                    'language': 'JavaScript',
+                                })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing ESLint output: {process.stdout}")
+            
+            # Group vulnerabilities by severity
+            vulns_by_severity = defaultdict(list)
+            for vuln in vulnerabilities:
+                severity = vuln.get('severity', 'unknown')
+                vulns_by_severity[severity].append(vuln)
+            
+            return {
+                'status': 'success',
+                'vulnerabilities': vulnerabilities,
+                'vulnerabilities_by_severity': dict(vulns_by_severity),
+                'vulnerability_count': len(vulnerabilities),
+                'files_scanned': len(js_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error scanning JavaScript/TypeScript code: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'vulnerabilities': [],
+            }
+        
+        finally:
+            # Clean up the temporary configuration file
+            if os.path.exists(temp_config_path):
+                os.unlink(temp_config_path)
+    
+    def _scan_java(self, repo_path):
+        """
+        Scan Java code for security vulnerabilities.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Java code.
+        """
+        logger.info(f"Scanning Java code in {repo_path} for security vulnerabilities")
+        
+        # Find Java files
+        java_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.java'):
+                    java_files.append(os.path.join(root, file))
+        
+        if not java_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Java files found in the repository.',
+                'vulnerabilities': [],
+            }
+        
+        # For now, we'll just return a placeholder since we don't have a direct tool
+        # In a real implementation, you might use FindSecBugs or similar
+        return {
+            'status': 'not_implemented',
+            'message': 'Java security scanning is not fully implemented yet.',
+            'vulnerabilities': [],
+            'files_scanned': java_files,
+        }
+    
+    def _scan_go(self, repo_path):
+        """
+        Scan Go code for security vulnerabilities using gosec.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Go code.
+        """
+        logger.info(f"Scanning Go code in {repo_path} for security vulnerabilities")
+        
+        # Find Go files
+        go_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.go'):
+                    go_files.append(os.path.join(root, file))
+        
+        if not go_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Go files found in the repository.',
+                'vulnerabilities': [],
+            }
+        
+        try:
+            # Run gosec
+            cmd = [
+                'gosec',
+                '-fmt', 'json',
+                '-quiet',
+                './...',
+            ]
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                check=False,
+                cwd=repo_path,  # Run in the repository directory
+            )
+            
+            # Parse gosec output
+            vulnerabilities = []
+            if process.stdout.strip():
+                try:
+                    gosec_results = json.loads(process.stdout)
+                    
+                    for issue in gosec_results.get('Issues', []):
+                        vulnerabilities.append({
+                            'file': issue.get('file', ''),
+                            'line': issue.get('line', ''),
+                            'code': issue.get('code', ''),
+                            'issue': issue.get('details', ''),
+                            'severity': issue.get('severity', ''),
+                            'confidence': issue.get('confidence', ''),
+                            'cwe': issue.get('cwe', {}).get('ID', ''),
+                            'rule_id': issue.get('rule_id', ''),
+                            'language': 'Go',
+                        })
+                except json.JSONDecodeError:
+                    logger.error(f"Error parsing gosec output: {process.stdout}")
+            
+            # Group vulnerabilities by severity
+            vulns_by_severity = defaultdict(list)
+            for vuln in vulnerabilities:
+                severity = vuln.get('severity', 'unknown')
+                vulns_by_severity[severity].append(vuln)
+            
+            return {
+                'status': 'success',
+                'vulnerabilities': vulnerabilities,
+                'vulnerabilities_by_severity': dict(vulns_by_severity),
+                'vulnerability_count': len(vulnerabilities),
+                'files_scanned': len(go_files),
+            }
+        
+        except Exception as e:
+            logger.error(f"Error running gosec: {e}")
+            return {
+                'status': 'error',
+                'error': str(e),
+                'vulnerabilities': [],
+            }
+    
+    def _scan_rust(self, repo_path):
+        """
+        Scan Rust code for security vulnerabilities.
+        
+        Args:
+            repo_path (str): The path to the repository.
+        
+        Returns:
+            dict: Scan results for Rust code.
+        """
+        logger.info(f"Scanning Rust code in {repo_path} for security vulnerabilities")
+        
+        # Find Rust files
+        rust_files = []
+        for root, _, files in os.walk(repo_path):
+            for file in files:
+                if file.endswith('.rs'):
+                    rust_files.append(os.path.join(root, file))
+        
+        if not rust_files:
+            return {
+                'status': 'no_files',
+                'message': 'No Rust files found in the repository.',
+                'vulnerabilities': [],
+            }
+        
+        # For now, we'll just return a placeholder since we don't have a direct tool
+        # In a real implementation, you might use cargo-audit or similar for code scanning
+        return {
+            'status': 'not_implemented',
+            'message': 'Rust security scanning is not fully implemented yet.',
+            'vulnerabilities': [],
+            'files_scanned': rust_files,
+        }

src/ui/__init__.py

@@ -0,0 +1 @@
+# UI Package for Code Review Agent

src/ui/components/__init__.py

@@ -0,0 +1 @@
+# UI Components Package for Code Review Agent

src/ui/components/export_manager.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Export Manager Component
+
+This module provides the UI component for exporting the code review results in various formats.
+"""
+
+import gradio as gr
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def create_export_manager():
+    """
+    Create the export manager component.
+    
+    Returns:
+        list: A list of tuples containing (export_button, export_format).
+    """
+    export_buttons = []
+    export_formats = []
+    
+    with gr.Group():
+        gr.Markdown("### 📤 Export Results")
+        
+        with gr.Row():
+            # PDF Export
+            pdf_btn = gr.Button("Export as PDF", variant="secondary")
+            pdf_format = gr.Textbox(value="pdf", visible=False)
+            export_buttons.append((pdf_btn, pdf_format))
+            export_formats.append(pdf_format)
+            
+            # JSON Export
+            json_btn = gr.Button("Export as JSON", variant="secondary")
+            json_format = gr.Textbox(value="json", visible=False)
+            export_buttons.append((json_btn, json_format))
+            export_formats.append(json_format)
+            
+            # HTML Export
+            html_btn = gr.Button("Export as HTML", variant="secondary")
+            html_format = gr.Textbox(value="html", visible=False)
+            export_buttons.append((html_btn, html_format))
+            export_formats.append(html_format)
+            
+            # CSV Export
+            csv_btn = gr.Button("Export as CSV", variant="secondary")
+            csv_format = gr.Textbox(value="csv", visible=False)
+            export_buttons.append((csv_btn, csv_format))
+            export_formats.append(csv_format)
+    
+    return export_buttons

src/ui/components/language_selector.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Language Selector Component
+
+This module provides the UI component for selecting programming languages to analyze.
+"""
+
+import gradio as gr
+import logging
+
+logger = logging.getLogger(__name__)
+
+# List of supported programming languages
+SUPPORTED_LANGUAGES = [
+    "Python", "JavaScript", "TypeScript", "Java", 
+    "Go", "Rust", "C++", "C#", "PHP", "Ruby",
+    "Swift", "Kotlin", "Scala", "R", "Shell"
+]
+
+
+def create_language_selector():
+    """
+    Create the language selector component.
+    
+    Returns:
+        gr.CheckboxGroup: The language selector component.
+    """
+    with gr.Group():
+        gr.Markdown("### 🔤 Languages (Optional)")
+        
+        language_selector = gr.CheckboxGroup(
+            choices=SUPPORTED_LANGUAGES,
+            label="Select languages to analyze",
+            info="Leave empty to auto-detect languages",
+            value=[],
+        )
+        
+        gr.Markdown(
+            "*Note: If no languages are selected, the agent will automatically detect languages in the repository.*",
+            elem_classes=["small-text"]
+        )
+    
+    return language_selector

src/ui/components/progress_tracker.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Progress Tracker Component
+
+This module provides the UI component for tracking the progress of the code review process.
+"""
+
+import gradio as gr
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def create_progress_tracker():
+    """
+    Create the progress tracker component.
+    
+    Returns:
+        tuple: A tuple containing (overall_progress, status_message, step_progress_dict)
+    """
+    # Overall progress bar
+    overall_progress = gr.Slider(
+        minimum=0,
+        maximum=100,
+        value=0,
+        label="Overall Progress",
+        interactive=False,
+    )
+    
+    # Status message
+    status_message = gr.Markdown(
+        "*Initializing...*"
+    )
+    
+    # Detailed progress steps
+    steps = [
+        "Repository Cloning",
+        "Language Detection",
+        "Code Analysis",
+        "Security Scanning",
+        "Performance Analysis",
+        "AI Review",
+        "Report Generation"
+    ]
+    
+    with gr.Accordion("Detailed Progress", open=False):
+        step_progress = {}
+        for step in steps:
+            with gr.Row(variant="panel"):
+                with gr.Column(scale=1, min_width=150):
+                    gr.Markdown(f"**{step}**")
+                with gr.Column(scale=4):
+                    step_progress[step] = gr.Slider(
+                        minimum=0,
+                        maximum=100,
+                        value=0,
+                        label="",
+                        interactive=False,
+                        scale=2
+                    )
+    
+    return overall_progress, status_message, step_progress

src/ui/components/repo_input.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Repository Input Component
+
+This module provides the UI component for entering a GitHub repository URL.
+"""
+
+import gradio as gr
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def validate_github_url(url):
+    """
+    Validate that the input is a proper GitHub repository URL.
+    
+    Args:
+        url (str): The URL to validate.
+        
+    Returns:
+        str or None: Error message if invalid, None if valid.
+    """
+    if not url:
+        return None
+    
+    # Basic GitHub URL pattern
+    pattern = r'^https?://github\.com/[\w.-]+/[\w.-]+/?$'
+    if not re.match(pattern, url):
+        return "Please enter a valid GitHub repository URL"
+    return None
+
+
+def create_repo_input():
+    """
+    Create the repository input component.
+    
+    Returns:
+        tuple: (repo_url, github_token, submit_btn) - The repository URL input, GitHub token input, and submit button.
+    """
+    with gr.Group():
+        gr.Markdown("### 📂 GitHub Repository")
+        
+        repo_url = gr.Textbox(
+            label="Repository URL",
+            placeholder="https://github.com/username/repository",
+            info="Enter the URL of a GitHub repository",
+        )
+        
+        github_token = gr.Textbox(
+            label="GitHub Token (Optional)",
+            placeholder="For private repositories only",
+            info="Required only for private repositories",
+            type="password",
+            visible=True
+        )
+        
+        submit_btn = gr.Button(
+            value="Analyze Repository",
+            variant="primary",
+            scale=0,
+        )
+        
+        # Add validation for GitHub URL format
+        error_box = gr.Textbox(
+            label="Error",
+            visible=True,
+            interactive=False,
+            container=False,
+            show_label=False
+        )
+        
+        repo_url.change(
+            fn=validate_github_url,
+            inputs=[repo_url],
+            outputs=[error_box],
+            show_progress=False
+        )
+    
+    return repo_url, github_token, submit_btn

src/ui/components/results_dashboard.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Results Dashboard Component
+
+This module provides the UI component for displaying the code review results.
+"""
+
+import gradio as gr
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def create_results_dashboard():
+    """
+    Create the results dashboard component.
+    
+    Returns:
+        gr.Group: The results dashboard component group.
+    """
+    with gr.Group(visible=False) as results_group:
+        gr.Markdown("### 📊 Analysis Results")
+        
+        # Executive Summary Tab
+        with gr.Tab("Executive Summary"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    gr.Markdown("#### 📝 Overview")
+                    summary_text = gr.Markdown("")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("#### 📈 Key Metrics")
+                    with gr.Row():
+                        gr.Label("Code Quality Score", value="N/A")
+                    with gr.Row():
+                        gr.Label("Security Score", value="N/A")
+                    with gr.Row():
+                        gr.Label("Performance Score", value="N/A")
+        
+        # Technical Details Tab
+        with gr.Tab("Technical Details"):
+            with gr.Accordion("Repository Structure", open=True):
+                repo_structure = gr.Markdown("")
+            
+            with gr.Accordion("Language Breakdown", open=True):
+                language_breakdown = gr.BarPlot(
+                    x="Language",
+                    y="Lines of Code",
+                    title="Language Distribution",
+                    tooltip=["Language", "Lines of Code"],
+                    height=300,
+                )
+            
+            with gr.Accordion("Code Quality Issues", open=True):
+                quality_issues = gr.Dataframe(
+                    headers=["File", "Line", "Issue", "Severity", "Description"],
+                    datatype=["str", "number", "str", "str", "str"],
+                    row_count=10,
+                )
+        
+        # Security Analysis Tab
+        with gr.Tab("Security Analysis"):
+            with gr.Accordion("Vulnerabilities", open=True):
+                vulnerabilities = gr.Dataframe(
+                    headers=["File", "Line", "Vulnerability", "Severity", "Description", "Recommendation"],
+                    datatype=["str", "number", "str", "str", "str", "str"],
+                    row_count=10,
+                )
+            
+            with gr.Accordion("Dependency Issues", open=True):
+                dependency_issues = gr.Dataframe(
+                    headers=["Package", "Current Version", "Recommended Version", "Vulnerability", "Severity"],
+                    datatype=["str", "str", "str", "str", "str"],
+                    row_count=10,
+                )
+        
+        # Performance Analysis Tab
+        with gr.Tab("Performance Analysis"):
+            with gr.Accordion("Performance Hotspots", open=True):
+                performance_hotspots = gr.Dataframe(
+                    headers=["File", "Function", "Issue", "Impact", "Recommendation"],
+                    datatype=["str", "str", "str", "str", "str"],
+                    row_count=10,
+                )
+            
+            with gr.Accordion("Resource Usage", open=True):
+                resource_usage = gr.BarPlot(
+                    x="Component",
+                    y="Usage",
+                    title="Resource Usage",
+                    tooltip=["Component", "Usage"],
+                    height=300,
+                )
+        
+        # Recommendations Tab
+        with gr.Tab("Recommendations"):
+            with gr.Accordion("High Priority", open=True):
+                high_priority_recs = gr.Markdown("")
+            
+            with gr.Accordion("Medium Priority", open=True):
+                medium_priority_recs = gr.Markdown("")
+            
+            with gr.Accordion("Low Priority", open=True):
+                low_priority_recs = gr.Markdown("")
+    
+    return results_group

src/ui/gradio_app.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Gradio Application for Code Review Agent
+
+This module defines the Gradio web interface for the Code Review Agent.
+It creates a professional UI with components for repository input, language selection,
+progress tracking, and results display.
+"""
+
+import os
+import gradio as gr
+import logging
+
+from src.ui.components.repo_input import create_repo_input
+from src.ui.components.language_selector import create_language_selector
+from src.ui.components.progress_tracker import create_progress_tracker
+from src.ui.components.results_dashboard import create_results_dashboard
+from src.ui.components.export_manager import create_export_manager
+from src.ui.styles.themes import get_theme
+
+logger = logging.getLogger(__name__)
+
+
+def create_gradio_app(agent_manager):
+    """
+    Create and configure the Gradio application.
+    
+    Args:
+        agent_manager: The AgentManager instance that handles the business logic.
+        
+    Returns:
+        gr.Blocks: The configured Gradio application.
+    """
+    # Load custom CSS
+    css_path = os.path.join(os.path.dirname(__file__), 'styles', 'custom.css')
+    with open(css_path, 'r') as f:
+        custom_css = f.read()
+    
+    # Create the Gradio app with custom theme
+    theme = get_theme()
+    
+    with gr.Blocks(css=custom_css, theme=theme, title="Code Review Agent") as app:
+        gr.Markdown(
+            """
+            # 🔍 Professional Code Review Agent
+            
+            Upload a GitHub repository URL and get comprehensive code analysis with actionable recommendations.
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=3):
+                # Repository input component
+                repo_url, github_token, submit_btn = create_repo_input()
+                
+                # Language selector component
+                selected_languages = create_language_selector()
+                
+            with gr.Column(scale=1):
+                # Information panel
+                gr.Markdown(
+                    """
+                    ### 📋 Features
+                    - Multi-language support (15+ languages)
+                    - Security vulnerability detection
+                    - Performance analysis
+                    - Code quality metrics
+                    - Actionable recommendations
+                    """
+                )
+        
+        # Progress tracker component
+        with gr.Group(visible=False) as progress_group:
+            gr.Markdown("### ⏳ Analysis Progress")
+            overall_progress, status_message, step_progress = create_progress_tracker()
+        
+        # Results dashboard component
+        results_dashboard = create_results_dashboard()
+        
+        # Export options component
+        export_buttons = create_export_manager()
+        
+        # Set up event handlers
+        submit_btn.click(
+            fn=agent_manager.start_review,
+            inputs=[repo_url, github_token, selected_languages],
+            outputs=[progress_group, overall_progress, status_message, results_dashboard]
+        )
+        
+        for export_btn, export_format in export_buttons:
+            export_btn.click(
+                fn=agent_manager.export_report,
+                inputs=[results_dashboard, export_format],
+                outputs=[]
+            )
+        
+        # Add WebSocket for real-time updates
+        app.queue()
+    
+    return app

src/ui/styles/__init__.py

@@ -0,0 +1 @@
+# UI Styles Package for Code Review Agent

src/ui/styles/custom.css

@@ -0,0 +1,116 @@
+/* Custom CSS for Code Review Agent */
+
+/* Global Styles */
+body {
+    font-family: 'Inter', sans-serif;
+}
+
+/* Glass-morphism effect for containers */
+.glass-container {
+    background: rgba(255, 255, 255, 0.7);
+    backdrop-filter: blur(10px);
+    border-radius: 10px;
+    border: 1px solid rgba(255, 255, 255, 0.2);
+    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.1);
+}
+
+/* Animations */
+.fade-in {
+    animation: fadeIn 0.5s ease-in-out;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+/* Typography */
+.small-text {
+    font-size: 0.8rem;
+    color: #6b7280;
+}
+
+/* Custom Scrollbar */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: #f1f1f1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: #c1c1c1;
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: #a1a1a1;
+}
+
+/* Progress Bar Styling */
+.progress-step-complete {
+    color: #10b981;
+    font-weight: bold;
+}
+
+.progress-step-current {
+    color: #3b82f6;
+    font-weight: bold;
+}
+
+.progress-step-pending {
+    color: #6b7280;
+}
+
+/* Results Dashboard Styling */
+.metric-card {
+    border-radius: 8px;
+    padding: 16px;
+    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+    margin-bottom: 16px;
+}
+
+.metric-card-good {
+    background-color: rgba(16, 185, 129, 0.1);
+    border-left: 4px solid #10b981;
+}
+
+.metric-card-warning {
+    background-color: rgba(245, 158, 11, 0.1);
+    border-left: 4px solid #f59e0b;
+}
+
+.metric-card-critical {
+    background-color: rgba(239, 68, 68, 0.1);
+    border-left: 4px solid #ef4444;
+}
+
+/* Code Snippet Styling */
+.code-snippet {
+    font-family: 'Fira Code', monospace;
+    background-color: #f8f9fa;
+    border-radius: 4px;
+    padding: 12px;
+    overflow-x: auto;
+    margin: 8px 0;
+    border-left: 3px solid #3b82f6;
+}
+
+.code-line-highlight {
+    background-color: rgba(59, 130, 246, 0.1);
+    display: block;
+}
+
+/* Responsive Design Adjustments */
+@media (max-width: 768px) {
+    .hide-on-mobile {
+        display: none;
+    }
+    
+    .mobile-full-width {
+        width: 100% !important;
+    }
+}

src/ui/styles/themes.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+UI Themes
+
+This module provides theme configuration for the Gradio interface.
+"""
+
+import gradio as gr
+
+
+def get_theme():
+    """
+    Create a custom theme for the Gradio interface.
+    
+    Returns:
+        gr.Theme: A custom Gradio theme.
+    """
+    return gr.Theme(
+        primary_hue="blue",
+        secondary_hue="indigo",
+        neutral_hue="slate",
+        font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"]
+    )

tests/test_agent_manager.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Agent Manager
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.core.agent_manager import AgentManager
+
+
+class TestAgentManager(unittest.TestCase):
+    """Test cases for the AgentManager class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Create mock components
+        self.mock_progress_tracker = MagicMock()
+        self.mock_results_dashboard = MagicMock()
+        
+        # Create the agent manager with mocked components
+        with patch('src.core.agent_manager.LanguageDetector'), \
+             patch('src.services.repository_service'), \
+             patch('src.services.code_analyzer.CodeAnalyzer'), \
+             patch('src.services.security_scanner.SecurityScanner'), \
+             patch('src.services.performance_analyzer.PerformanceAnalyzer'), \
+             patch('src.mcp.ai_review.AIReviewService'), \
+             patch('src.services.report_generator.ReportGenerator'):
+            
+            self.agent_manager = AgentManager()
+            
+            # Replace the UI components with mocks
+            self.agent_manager._progress_tracker = self.mock_progress_tracker
+            self.agent_manager._results_dashboard = self.mock_results_dashboard
+    
+    @patch('src.services.repository_service.validate_github_url')
+    @patch('src.services.repository_service.clone_repository')
+    @patch('src.services.repository_service.get_repository_info')
+    @patch('src.core.language_detector.LanguageDetector.detect_languages')
+    @patch('src.core.language_detector.LanguageDetector.get_language_breakdown')
+    def test_start_review(self, mock_get_breakdown, mock_detect_languages, 
+                          mock_get_repo_info, mock_clone_repo, mock_validate_url):
+        """Test start_review method"""
+        # Set up the mocks
+        mock_validate_url.return_value = True
+        mock_clone_repo.return_value = "/test/repo"
+        mock_get_repo_info.return_value = {"branch": "main", "commit": "abc123"}
+        mock_detect_languages.return_value = ["Python", "JavaScript"]
+        mock_get_breakdown.return_value = {
+            "Python": {"files": 5, "lines": 500, "percentage": 70},
+            "JavaScript": {"files": 3, "lines": 200, "percentage": 30}
+        }
+        
+        # Mock the analysis methods
+        self.agent_manager._analyze_code = MagicMock()
+        self.agent_manager._scan_security = MagicMock()
+        self.agent_manager._analyze_performance = MagicMock()
+        self.agent_manager._perform_ai_review = MagicMock()
+        self.agent_manager._generate_report = MagicMock()
+        
+        # Call the method
+        result = self.agent_manager.start_review(
+            repo_url="https://github.com/user/repo",
+            languages=["Python", "JavaScript"],
+            features=["code_analysis", "security_scan", "performance_analysis", "ai_review"]
+        )
+        
+        # Verify the result
+        self.assertTrue(result["success"])
+        self.assertEqual(result["repo_path"], "/test/repo")
+        
+        # Verify the method calls
+        mock_validate_url.assert_called_once_with("https://github.com/user/repo")
+        mock_clone_repo.assert_called_once()
+        mock_get_repo_info.assert_called_once_with("/test/repo")
+        mock_detect_languages.assert_called_once_with("/test/repo")
+        mock_get_breakdown.assert_called_once_with("/test/repo")
+        
+        # Verify the analysis method calls
+        self.agent_manager._analyze_code.assert_called_once()
+        self.agent_manager._scan_security.assert_called_once()
+        self.agent_manager._analyze_performance.assert_called_once()
+        self.agent_manager._perform_ai_review.assert_called_once()
+        self.agent_manager._generate_report.assert_called_once()
+        
+        # Verify the progress updates
+        self.assertEqual(self.mock_progress_tracker.update.call_count, 8)  # Initial + 7 steps
+    
+    @patch('src.services.repository_service.validate_github_url')
+    def test_start_review_invalid_url(self, mock_validate_url):
+        """Test start_review method with invalid URL"""
+        # Set up the mock
+        mock_validate_url.return_value = False
+        
+        # Call the method
+        result = self.agent_manager.start_review(
+            repo_url="invalid_url",
+            languages=["Python"],
+            features=["code_analysis"]
+        )
+        
+        # Verify the result
+        self.assertFalse(result["success"])
+        self.assertIn("Invalid GitHub URL", result["error"])
+    
+    @patch('src.services.repository_service.validate_github_url')
+    @patch('src.services.repository_service.clone_repository')
+    def test_start_review_clone_error(self, mock_clone_repo, mock_validate_url):
+        """Test start_review method with clone error"""
+        # Set up the mocks
+        mock_validate_url.return_value = True
+        mock_clone_repo.side_effect = Exception("Clone error")
+        
+        # Call the method
+        result = self.agent_manager.start_review(
+            repo_url="https://github.com/user/repo",
+            languages=["Python"],
+            features=["code_analysis"]
+        )
+        
+        # Verify the result
+        self.assertFalse(result["success"])
+        self.assertIn("Failed to clone repository", result["error"])
+    
+    @patch('src.services.code_analyzer.CodeAnalyzer.analyze_code')
+    def test_analyze_code(self, mock_analyze_code):
+        """Test _analyze_code method"""
+        # Set up the mock
+        mock_analyze_code.return_value = {"Python": {"issues": [], "issue_count": 0}}
+        
+        # Call the method
+        self.agent_manager._repo_path = "/test/repo"
+        self.agent_manager._languages = ["Python"]
+        self.agent_manager._results = {}
+        
+        self.agent_manager._analyze_code()
+        
+        # Verify the result
+        self.assertIn("code_analysis", self.agent_manager._results)
+        mock_analyze_code.assert_called_once_with("/test/repo", ["Python"])
+    
+    @patch('src.services.security_scanner.SecurityScanner.scan_repository')
+    def test_scan_security(self, mock_scan_repo):
+        """Test _scan_security method"""
+        # Set up the mock
+        mock_scan_repo.return_value = {"Python": {"vulnerabilities": [], "vulnerability_count": 0}}
+        
+        # Call the method
+        self.agent_manager._repo_path = "/test/repo"
+        self.agent_manager._languages = ["Python"]
+        self.agent_manager._results = {}
+        
+        self.agent_manager._scan_security()
+        
+        # Verify the result
+        self.assertIn("security_scan", self.agent_manager._results)
+        mock_scan_repo.assert_called_once_with("/test/repo", ["Python"])
+    
+    @patch('src.services.performance_analyzer.PerformanceAnalyzer.analyze_repository')
+    def test_analyze_performance(self, mock_analyze_repo):
+        """Test _analyze_performance method"""
+        # Set up the mock
+        mock_analyze_repo.return_value = {
+            "language_results": {"Python": {"issues": [], "issue_count": 0}},
+            "hotspots": []
+        }
+        
+        # Call the method
+        self.agent_manager._repo_path = "/test/repo"
+        self.agent_manager._languages = ["Python"]
+        self.agent_manager._results = {}
+        
+        self.agent_manager._analyze_performance()
+        
+        # Verify the result
+        self.assertIn("performance_analysis", self.agent_manager._results)
+        mock_analyze_repo.assert_called_once_with("/test/repo", ["Python"])
+    
+    @patch('src.mcp.ai_review.AIReviewService.is_available')
+    @patch('src.mcp.ai_review.AIReviewService.review_repository')
+    def test_perform_ai_review(self, mock_review_repo, mock_is_available):
+        """Test _perform_ai_review method"""
+        # Set up the mocks
+        mock_is_available.return_value = True
+        mock_review_repo.return_value = {
+            "status": "success",
+            "reviews": {},
+            "summary": "AI review summary"
+        }
+        
+        # Call the method
+        self.agent_manager._repo_path = "/test/repo"
+        self.agent_manager._languages = ["Python"]
+        self.agent_manager._results = {}
+        
+        self.agent_manager._perform_ai_review()
+        
+        # Verify the result
+        self.assertIn("ai_review", self.agent_manager._results)
+        mock_review_repo.assert_called_once()
+    
+    @patch('src.mcp.ai_review.AIReviewService.is_available')
+    def test_perform_ai_review_unavailable(self, mock_is_available):
+        """Test _perform_ai_review method when AI review is unavailable"""
+        # Set up the mock
+        mock_is_available.return_value = False
+        
+        # Call the method
+        self.agent_manager._repo_path = "/test/repo"
+        self.agent_manager._languages = ["Python"]
+        self.agent_manager._results = {}
+        
+        self.agent_manager._perform_ai_review()
+        
+        # Verify the result
+        self.assertIn("ai_review", self.agent_manager._results)
+        self.assertEqual(self.agent_manager._results["ai_review"]["status"], "error")
+        self.assertIn("AI review service is not available", self.agent_manager._results["ai_review"]["error"])
+    
+    @patch('src.services.report_generator.ReportGenerator.generate_report')
+    def test_generate_report(self, mock_generate_report):
+        """Test _generate_report method"""
+        # Set up the mock
+        mock_generate_report.return_value = {
+            "json": "/test/reports/report.json",
+            "html": "/test/reports/report.html"
+        }
+        
+        # Call the method
+        self.agent_manager._repo_name = "repo"
+        self.agent_manager._results = {"test": "data"}
+        
+        self.agent_manager._generate_report()
+        
+        # Verify the result
+        self.assertIn("report_paths", self.agent_manager._results)
+        mock_generate_report.assert_called_once_with("repo", {"test": "data"}, "all")
+    
+    @patch('src.services.report_generator.ReportGenerator.generate_report')
+    def test_export_report(self, mock_generate_report):
+        """Test export_report method"""
+        # Set up the mock
+        mock_generate_report.return_value = {
+            "json": "/test/reports/report.json"
+        }
+        
+        # Call the method
+        self.agent_manager._repo_name = "repo"
+        self.agent_manager._results = {"test": "data"}
+        
+        result = self.agent_manager.export_report("json")
+        
+        # Verify the result
+        self.assertTrue(result["success"])
+        self.assertEqual(result["report_path"], "/test/reports/report.json")
+        mock_generate_report.assert_called_once_with("repo", {"test": "data"}, "json")
+    
+    @patch('src.services.report_generator.ReportGenerator.generate_report')
+    def test_export_report_error(self, mock_generate_report):
+        """Test export_report method with error"""
+        # Set up the mock
+        mock_generate_report.side_effect = Exception("Export error")
+        
+        # Call the method
+        self.agent_manager._repo_name = "repo"
+        self.agent_manager._results = {"test": "data"}
+        
+        result = self.agent_manager.export_report("json")
+        
+        # Verify the result
+        self.assertFalse(result["success"])
+        self.assertIn("Failed to export report", result["error"])
+    
+    @patch('src.services.repository_service.clone_repository')
+    def test_clone_repository(self, mock_clone_repo):
+        """Test _clone_repository method"""
+        # Set up the mock
+        mock_clone_repo.return_value = "/test/repo"
+        
+        # Call the method
+        repo_path = self.agent_manager._clone_repository("https://github.com/user/repo")
+        
+        # Verify the result
+        self.assertEqual(repo_path, "/test/repo")
+        mock_clone_repo.assert_called_once()
+    
+    def test_update_progress(self):
+        """Test _update_progress method"""
+        # Call the method
+        self.agent_manager._update_progress("Test step", 50, "Test message")
+        
+        # Verify the result
+        self.mock_progress_tracker.update.assert_called_once_with(
+            "Test step", 50, "Test message"
+        )
+    
+    def test_create_progress_tracker(self):
+        """Test _create_progress_tracker method"""
+        # Mock the gradio components
+        with patch('gradio.Markdown'), patch('gradio.Slider'), patch('gradio.Accordion'), patch('gradio.Group'):
+            # Call the method
+            progress_tracker = self.agent_manager._create_progress_tracker()
+            
+            # Verify the result
+            self.assertIsNotNone(progress_tracker)
+    
+    def test_create_results_dashboard(self):
+        """Test _create_results_dashboard method"""
+        # Mock the gradio components
+        with patch('gradio.Markdown'), patch('gradio.Dataframe'), patch('gradio.HighlightedText'), \
+             patch('gradio.Code'), patch('gradio.Accordion'), patch('gradio.Tab'), patch('gradio.Tabs'), \
+             patch('gradio.Group'):
+            
+            # Call the method
+            results_dashboard = self.agent_manager._create_results_dashboard()
+            
+            # Verify the result
+            self.assertIsNotNone(results_dashboard)
+    
+    def test_create_error_progress_tracker(self):
+        """Test _create_error_progress_tracker method"""
+        # Mock the gradio components
+        with patch('gradio.Markdown'), patch('gradio.Group'):
+            # Call the method
+            error_tracker = self.agent_manager._create_error_progress_tracker("Test error")
+            
+            # Verify the result
+            self.assertIsNotNone(error_tracker)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_ai_review.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the AI Review Service
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.mcp.ai_review import AIReviewService
+
+
+class TestAIReviewService(unittest.TestCase):
+    """Test cases for the AIReviewService class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Mock environment variables
+        self.env_patcher = patch.dict('os.environ', {'ANTHROPIC_API_KEY': 'test_api_key'})
+        self.env_patcher.start()
+        
+        # Create the service
+        self.service = AIReviewService()
+    
+    def tearDown(self):
+        """Tear down test fixtures"""
+        self.env_patcher.stop()
+    
+    def test_init(self):
+        """Test initialization of the service"""
+        self.assertIsNotNone(self.service)
+        self.assertEqual(self.service.api_key, 'test_api_key')
+        self.assertTrue(self.service.is_available())
+    
+    def test_is_available(self):
+        """Test is_available method"""
+        # With API key
+        self.assertTrue(self.service.is_available())
+        
+        # Without API key
+        with patch.dict('os.environ', {}, clear=True):
+            service = AIReviewService()
+            self.assertFalse(service.is_available())
+    
+    @patch('anthropic.Anthropic')
+    def test_review_code(self, mock_anthropic):
+        """Test review_code method"""
+        # Mock the Anthropic client
+        mock_client = MagicMock()
+        mock_anthropic.return_value = mock_client
+        
+        # Mock the response
+        mock_response = MagicMock()
+        mock_content = MagicMock()
+        mock_content.text = "# Code Review\n\n## Code Quality\nThe code is well-structured.\n\n## Potential Issues\nLine 10: Variable 'x' is not used."
+        mock_response.content = [mock_content]
+        mock_client.messages.create.return_value = mock_response
+        
+        # Test the method
+        result = self.service.review_code(
+            file_path="test.py",
+            file_content="def test():\n    x = 1\n    return 2",
+            language="Python"
+        )
+        
+        # Verify the result
+        self.assertEqual(result['status'], 'success')
+        self.assertEqual(result['review_text'], mock_content.text)
+        self.assertIn('suggestions', result)
+    
+    @patch('anthropic.Anthropic')
+    def test_review_code_error(self, mock_anthropic):
+        """Test review_code method with error"""
+        # Mock the Anthropic client
+        mock_client = MagicMock()
+        mock_anthropic.return_value = mock_client
+        
+        # Mock an error
+        mock_client.messages.create.side_effect = Exception("API error")
+        
+        # Test the method
+        result = self.service.review_code(
+            file_path="test.py",
+            file_content="def test():\n    return 1",
+            language="Python"
+        )
+        
+        # Verify the result
+        self.assertEqual(result['status'], 'error')
+        self.assertEqual(result['error'], 'API error')
+        self.assertEqual(result['suggestions'], [])
+    
+    def test_review_code_unavailable(self):
+        """Test review_code method when service is unavailable"""
+        # Create a service without API key
+        with patch.dict('os.environ', {}, clear=True):
+            service = AIReviewService()
+            
+            # Test the method
+            result = service.review_code(
+                file_path="test.py",
+                file_content="def test():\n    return 1",
+                language="Python"
+            )
+            
+            # Verify the result
+            self.assertEqual(result['status'], 'error')
+            self.assertIn('AI review service is not available', result['error'])
+            self.assertEqual(result['suggestions'], [])
+    
+    @patch('anthropic.Anthropic')
+    @patch('builtins.open', new_callable=unittest.mock.mock_open, read_data="def test():\n    return 1")
+    def test_review_repository(self, mock_open, mock_anthropic):
+        """Test review_repository method"""
+        # Mock the Anthropic client
+        mock_client = MagicMock()
+        mock_anthropic.return_value = mock_client
+        
+        # Mock the response for file review
+        mock_file_response = MagicMock()
+        mock_file_content = MagicMock()
+        mock_file_content.text = "# Code Review\n\n## Code Quality\nThe code is well-structured."
+        mock_file_response.content = [mock_file_content]
+        
+        # Mock the response for repository summary
+        mock_summary_response = MagicMock()
+        mock_summary_content = MagicMock()
+        mock_summary_content.text = "# Repository Review\n\nOverall, the code quality is good."
+        mock_summary_response.content = [mock_summary_content]
+        
+        # Set up the mock to return different responses
+        mock_client.messages.create.side_effect = [mock_file_response, mock_summary_response]
+        
+        # Test the method
+        result = self.service.review_repository(
+            repo_path="/test/repo",
+            files=["test.py"],
+            languages=["Python"]
+        )
+        
+        # Verify the result
+        self.assertEqual(result['status'], 'success')
+        self.assertIn('reviews', result)
+        self.assertIn('test.py', result['reviews'])
+        self.assertEqual(result['summary'], mock_summary_content.text)
+    
+    def test_get_language_from_extension(self):
+        """Test _get_language_from_extension method"""
+        self.assertEqual(self.service._get_language_from_extension(".py"), "Python")
+        self.assertEqual(self.service._get_language_from_extension(".js"), "JavaScript")
+        self.assertEqual(self.service._get_language_from_extension(".ts"), "TypeScript")
+        self.assertEqual(self.service._get_language_from_extension(".java"), "Java")
+        self.assertEqual(self.service._get_language_from_extension(".go"), "Go")
+        self.assertEqual(self.service._get_language_from_extension(".rs"), "Rust")
+        self.assertIsNone(self.service._get_language_from_extension(".unknown"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_code_analyzer.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Code Analyzer service
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock, mock_open
+import os
+import sys
+import json
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.services.code_analyzer import CodeAnalyzer
+
+
+class TestCodeAnalyzer(unittest.TestCase):
+    """Test cases for the CodeAnalyzer class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.analyzer = CodeAnalyzer()
+        self.test_repo_path = "/test/repo"
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_analyze_python_code(self, mock_run, mock_exists):
+        """Test analyze_python_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "messages": [
+                {
+                    "type": "convention",
+                    "module": "test_module",
+                    "obj": "",
+                    "line": 10,
+                    "column": 0,
+                    "path": "test.py",
+                    "symbol": "missing-docstring",
+                    "message": "Missing module docstring",
+                    "message-id": "C0111"
+                }
+            ]
+        })
+        mock_run.return_value = mock_process
+        
+        # Mock the file discovery
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/test.py']):
+            # Call the method
+            result = self.analyzer.analyze_python_code(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['issues']), 1)
+            self.assertEqual(result['issue_count'], 1)
+            self.assertEqual(result['issues'][0]['type'], 'convention')
+            self.assertEqual(result['issues'][0]['file'], 'test.py')
+            self.assertEqual(result['issues'][0]['line'], 10)
+            self.assertEqual(result['issues'][0]['message'], 'Missing module docstring')
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_analyze_javascript_code(self, mock_run, mock_exists):
+        """Test analyze_javascript_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps([
+            {
+                "filePath": "/test/repo/test.js",
+                "messages": [
+                    {
+                        "ruleId": "semi",
+                        "severity": 2,
+                        "message": "Missing semicolon.",
+                        "line": 5,
+                        "column": 20,
+                        "nodeType": "ExpressionStatement"
+                    }
+                ],
+                "errorCount": 1,
+                "warningCount": 0,
+                "fixableErrorCount": 1,
+                "fixableWarningCount": 0
+            }
+        ])
+        mock_run.return_value = mock_process
+        
+        # Mock the file discovery
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/test.js']):
+            # Call the method
+            result = self.analyzer.analyze_javascript_code(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['issues']), 1)
+            self.assertEqual(result['issue_count'], 1)
+            self.assertEqual(result['issues'][0]['type'], 'error')
+            self.assertEqual(result['issues'][0]['file'], 'test.js')
+            self.assertEqual(result['issues'][0]['line'], 5)
+            self.assertEqual(result['issues'][0]['message'], 'Missing semicolon.')
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_analyze_typescript_code(self, mock_run, mock_exists):
+        """Test analyze_typescript_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run results
+        # First for ESLint
+        eslint_process = MagicMock()
+        eslint_process.returncode = 0
+        eslint_process.stdout = json.dumps([
+            {
+                "filePath": "/test/repo/test.ts",
+                "messages": [
+                    {
+                        "ruleId": "@typescript-eslint/no-unused-vars",
+                        "severity": 1,
+                        "message": "'x' is defined but never used.",
+                        "line": 3,
+                        "column": 7,
+                        "nodeType": "Identifier"
+                    }
+                ],
+                "errorCount": 0,
+                "warningCount": 1,
+                "fixableErrorCount": 0,
+                "fixableWarningCount": 0
+            }
+        ])
+        
+        # Then for TSC
+        tsc_process = MagicMock()
+        tsc_process.returncode = 2  # Error code for TypeScript compiler
+        tsc_process.stderr = "test.ts(10,15): error TS2339: Property 'foo' does not exist on type 'Bar'."
+        
+        # Set up the mock to return different values on consecutive calls
+        mock_run.side_effect = [eslint_process, tsc_process]
+        
+        # Mock the file discovery
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/test.ts']):
+            # Call the method
+            result = self.analyzer.analyze_typescript_code(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['issues']), 2)  # One from ESLint, one from TSC
+            self.assertEqual(result['issue_count'], 2)
+            
+            # Check the ESLint issue
+            eslint_issue = next(issue for issue in result['issues'] if issue['source'] == 'eslint')
+            self.assertEqual(eslint_issue['type'], 'warning')
+            self.assertEqual(eslint_issue['file'], 'test.ts')
+            self.assertEqual(eslint_issue['line'], 3)
+            self.assertEqual(eslint_issue['message'], "'x' is defined but never used.")
+            
+            # Check the TSC issue
+            tsc_issue = next(issue for issue in result['issues'] if issue['source'] == 'tsc')
+            self.assertEqual(tsc_issue['type'], 'error')
+            self.assertEqual(tsc_issue['file'], 'test.ts')
+            self.assertEqual(tsc_issue['line'], 10)
+            self.assertEqual(tsc_issue['message'], "Property 'foo' does not exist on type 'Bar'.")
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_analyze_java_code(self, mock_run, mock_exists):
+        """Test analyze_java_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = """
+<?xml version="1.0" encoding="UTF-8"?>
+<pmd version="6.55.0" timestamp="2023-06-01T12:00:00.000">
+<file name="/test/repo/Test.java">
+<violation beginline="10" endline="10" begincolumn="5" endcolumn="20" rule="UnusedLocalVariable" ruleset="Best Practices" class="Test" method="main" variable="unusedVar" externalInfoUrl="https://pmd.github.io/pmd-6.55.0/pmd_rules_java_bestpractices.html#unusedlocalvariable" priority="3">
+Avoid unused local variables such as 'unusedVar'.
+</violation>
+</file>
+</pmd>
+        """
+        mock_run.return_value = mock_process
+        
+        # Mock the file discovery
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/Test.java']):
+            # Call the method
+            result = self.analyzer.analyze_java_code(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['issues']), 1)
+            self.assertEqual(result['issue_count'], 1)
+            self.assertEqual(result['issues'][0]['type'], 'warning')  # Priority 3 maps to warning
+            self.assertEqual(result['issues'][0]['file'], 'Test.java')
+            self.assertEqual(result['issues'][0]['line'], 10)
+            self.assertEqual(result['issues'][0]['message'], "Avoid unused local variables such as 'unusedVar'.")
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_analyze_go_code(self, mock_run, mock_exists):
+        """Test analyze_go_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "Issues": [
+                {
+                    "FromLinter": "gosimple",
+                    "Text": "S1000: should use a simple channel send/receive instead of select with a single case",
+                    "Pos": {
+                        "Filename": "test.go",
+                        "Line": 15,
+                        "Column": 2
+                    },
+                    "Severity": "warning"
+                }
+            ]
+        })
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        result = self.analyzer.analyze_go_code(self.test_repo_path)
+        
+        # Verify the result
+        self.assertEqual(len(result['issues']), 1)
+        self.assertEqual(result['issue_count'], 1)
+        self.assertEqual(result['issues'][0]['type'], 'warning')
+        self.assertEqual(result['issues'][0]['file'], 'test.go')
+        self.assertEqual(result['issues'][0]['line'], 15)
+        self.assertEqual(result['issues'][0]['message'], 'S1000: should use a simple channel send/receive instead of select with a single case')
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_analyze_rust_code(self, mock_run, mock_exists):
+        """Test analyze_rust_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "reason": "compiler-message",
+            "message": {
+                "rendered": "warning: unused variable: `x`\n --> src/main.rs:2:9\n  |\n2 |     let x = 5;\n  |         ^ help: if this is intentional, prefix it with an underscore: `_x`\n  |\n  = note: `#[warn(unused_variables)]` on by default\n\n",
+                "children": [],
+                "code": {
+                    "code": "unused_variables",
+                    "explanation": null
+                },
+                "level": "warning",
+                "message": "unused variable: `x`",
+                "spans": [
+                    {
+                        "byte_end": 26,
+                        "byte_start": 25,
+                        "column_end": 10,
+                        "column_start": 9,
+                        "expansion": null,
+                        "file_name": "src/main.rs",
+                        "is_primary": true,
+                        "label": "help: if this is intentional, prefix it with an underscore: `_x`",
+                        "line_end": 2,
+                        "line_start": 2,
+                        "suggested_replacement": "_x",
+                        "suggestion_applicability": "MachineApplicable",
+                        "text": [
+                            {
+                                "highlight_end": 10,
+                                "highlight_start": 9,
+                                "text": "    let x = 5;"
+                            }
+                        ]
+                    }
+                ]
+            }
+        })
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        result = self.analyzer.analyze_rust_code(self.test_repo_path)
+        
+        # Verify the result
+        self.assertEqual(len(result['issues']), 1)
+        self.assertEqual(result['issue_count'], 1)
+        self.assertEqual(result['issues'][0]['type'], 'warning')
+        self.assertEqual(result['issues'][0]['file'], 'src/main.rs')
+        self.assertEqual(result['issues'][0]['line'], 2)
+        self.assertEqual(result['issues'][0]['message'], 'unused variable: `x`')
+    
+    def test_analyze_code(self):
+        """Test analyze_code method"""
+        # Mock the language-specific analysis methods
+        self.analyzer.analyze_python_code = MagicMock(return_value={
+            'issues': [{'type': 'convention', 'file': 'test.py', 'line': 10, 'message': 'Test issue'}],
+            'issue_count': 1
+        })
+        self.analyzer.analyze_javascript_code = MagicMock(return_value={
+            'issues': [{'type': 'error', 'file': 'test.js', 'line': 5, 'message': 'Test issue'}],
+            'issue_count': 1
+        })
+        
+        # Call the method
+        result = self.analyzer.analyze_code(self.test_repo_path, ['Python', 'JavaScript'])
+        
+        # Verify the result
+        self.assertEqual(len(result), 2)  # Two languages
+        self.assertIn('Python', result)
+        self.assertIn('JavaScript', result)
+        self.assertEqual(result['Python']['issue_count'], 1)
+        self.assertEqual(result['JavaScript']['issue_count'], 1)
+        
+        # Verify the method calls
+        self.analyzer.analyze_python_code.assert_called_once_with(self.test_repo_path)
+        self.analyzer.analyze_javascript_code.assert_called_once_with(self.test_repo_path)
+    
+    @patch('os.walk')
+    def test_find_files(self, mock_walk):
+        """Test _find_files method"""
+        # Set up the mock
+        mock_walk.return_value = [
+            ('/test/repo', ['dir1'], ['file1.py', 'file2.js']),
+            ('/test/repo/dir1', [], ['file3.py'])
+        ]
+        
+        # Call the method
+        python_files = self.analyzer._find_files(self.test_repo_path, '.py')
+        
+        # Verify the result
+        self.assertEqual(len(python_files), 2)
+        self.assertIn('/test/repo/file1.py', python_files)
+        self.assertIn('/test/repo/dir1/file3.py', python_files)
+    
+    @patch('os.path.exists')
+    def test_check_tool_availability(self, mock_exists):
+        """Test _check_tool_availability method"""
+        # Set up the mock
+        mock_exists.side_effect = [True, False]  # First tool exists, second doesn't
+        
+        # Call the method
+        result1 = self.analyzer._check_tool_availability('tool1')
+        result2 = self.analyzer._check_tool_availability('tool2')
+        
+        # Verify the result
+        self.assertTrue(result1)
+        self.assertFalse(result2)
+    
+    @patch('subprocess.run')
+    def test_run_command(self, mock_run):
+        """Test _run_command method"""
+        # Set up the mock
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = "Test output"
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        returncode, output = self.analyzer._run_command(['test', 'command'])
+        
+        # Verify the result
+        self.assertEqual(returncode, 0)
+        self.assertEqual(output, "Test output")
+        mock_run.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_language_detector.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Language Detector
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock, mock_open
+import os
+import sys
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.core.language_detector import LanguageDetector
+
+
+class TestLanguageDetector(unittest.TestCase):
+    """Test cases for the LanguageDetector class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.detector = LanguageDetector()
+        
+        # Create a mock repository structure
+        self.repo_path = "/test/repo"
+        self.mock_files = [
+            "/test/repo/main.py",
+            "/test/repo/utils.py",
+            "/test/repo/static/script.js",
+            "/test/repo/static/style.css",
+            "/test/repo/src/app.js",
+            "/test/repo/src/components/Button.jsx",
+            "/test/repo/src/components/Form.tsx",
+            "/test/repo/docs/index.html",
+            "/test/repo/README.md",
+            "/test/repo/package.json",
+            "/test/repo/Dockerfile",
+            "/test/repo/.gitignore"
+        ]
+    
+    def test_get_language_from_extension(self):
+        """Test _get_language_from_extension method"""
+        # Test common extensions
+        self.assertEqual(self.detector._get_language_from_extension(".py"), "Python")
+        self.assertEqual(self.detector._get_language_from_extension(".js"), "JavaScript")
+        self.assertEqual(self.detector._get_language_from_extension(".jsx"), "JavaScript")
+        self.assertEqual(self.detector._get_language_from_extension(".ts"), "TypeScript")
+        self.assertEqual(self.detector._get_language_from_extension(".tsx"), "TypeScript")
+        self.assertEqual(self.detector._get_language_from_extension(".java"), "Java")
+        self.assertEqual(self.detector._get_language_from_extension(".go"), "Go")
+        self.assertEqual(self.detector._get_language_from_extension(".rs"), "Rust")
+        self.assertEqual(self.detector._get_language_from_extension(".html"), "HTML")
+        self.assertEqual(self.detector._get_language_from_extension(".css"), "CSS")
+        self.assertEqual(self.detector._get_language_from_extension(".md"), "Markdown")
+        
+        # Test unknown extension
+        self.assertEqual(self.detector._get_language_from_extension(".unknown"), "Other")
+    
+    def test_get_language_from_filename(self):
+        """Test _get_language_from_filename method"""
+        # Test common filenames
+        self.assertEqual(self.detector._get_language_from_filename("Dockerfile"), "Dockerfile")
+        self.assertEqual(self.detector._get_language_from_filename(".gitignore"), "Git")
+        self.assertEqual(self.detector._get_language_from_filename("package.json"), "JSON")
+        self.assertEqual(self.detector._get_language_from_filename("README.md"), "Markdown")
+        
+        # Test unknown filename
+        self.assertEqual(self.detector._get_language_from_filename("unknown"), None)
+    
+    @patch('os.walk')
+    def test_detect_languages(self, mock_walk):
+        """Test detect_languages method"""
+        # Mock os.walk to return our mock files
+        mock_walk.return_value = [
+            ("/test/repo", ["static", "src", "docs"], ["main.py", "utils.py", "README.md", "package.json", ".gitignore"]),
+            ("/test/repo/static", [], ["script.js", "style.css"]),
+            ("/test/repo/src", ["components"], ["app.js"]),
+            ("/test/repo/src/components", [], ["Button.jsx", "Form.tsx"]),
+            ("/test/repo/docs", [], ["index.html"]),
+        ]
+        
+        # Test the method
+        languages = self.detector.detect_languages(self.repo_path)
+        
+        # Verify the result
+        self.assertIn("Python", languages)
+        self.assertIn("JavaScript", languages)
+        self.assertIn("TypeScript", languages)
+        self.assertIn("HTML", languages)
+        self.assertIn("CSS", languages)
+        self.assertIn("Markdown", languages)
+        self.assertIn("JSON", languages)
+        self.assertIn("Git", languages)
+    
+    @patch('os.walk')
+    @patch('builtins.open', new_callable=mock_open, read_data="line1\nline2\nline3\n")
+    def test_get_language_breakdown(self, mock_file, mock_walk):
+        """Test get_language_breakdown method"""
+        # Mock os.walk to return our mock files
+        mock_walk.return_value = [
+            ("/test/repo", ["static", "src"], ["main.py", "utils.py", "README.md"]),
+            ("/test/repo/static", [], ["script.js"]),
+            ("/test/repo/src", [], ["app.js"]),
+        ]
+        
+        # Test the method
+        breakdown = self.detector.get_language_breakdown(self.repo_path)
+        
+        # Verify the result
+        self.assertIn("Python", breakdown)
+        self.assertIn("JavaScript", breakdown)
+        self.assertIn("Markdown", breakdown)
+        
+        # Each file has 4 lines (including the newline at the end)
+        self.assertEqual(breakdown["Python"]["files"], 2)
+        self.assertEqual(breakdown["Python"]["lines"], 8)  # 2 files * 4 lines
+        self.assertEqual(breakdown["JavaScript"]["files"], 2)
+        self.assertEqual(breakdown["JavaScript"]["lines"], 8)  # 2 files * 4 lines
+        self.assertEqual(breakdown["Markdown"]["files"], 1)
+        self.assertEqual(breakdown["Markdown"]["lines"], 4)  # 1 file * 4 lines
+        
+        # Check percentages
+        total_lines = 20  # 5 files * 4 lines
+        self.assertEqual(breakdown["Python"]["percentage"], 40)  # 8/20 * 100
+        self.assertEqual(breakdown["JavaScript"]["percentage"], 40)  # 8/20 * 100
+        self.assertEqual(breakdown["Markdown"]["percentage"], 20)  # 4/20 * 100
+    
+    @patch('os.path.isfile')
+    def test_is_binary_file(self, mock_isfile):
+        """Test _is_binary_file method"""
+        # Mock isfile to always return True
+        mock_isfile.return_value = True
+        
+        # Test with text file extensions
+        self.assertFalse(self.detector._is_binary_file("test.py"))
+        self.assertFalse(self.detector._is_binary_file("test.js"))
+        self.assertFalse(self.detector._is_binary_file("test.html"))
+        self.assertFalse(self.detector._is_binary_file("test.css"))
+        self.assertFalse(self.detector._is_binary_file("test.md"))
+        
+        # Test with binary file extensions
+        self.assertTrue(self.detector._is_binary_file("test.png"))
+        self.assertTrue(self.detector._is_binary_file("test.jpg"))
+        self.assertTrue(self.detector._is_binary_file("test.gif"))
+        self.assertTrue(self.detector._is_binary_file("test.pdf"))
+        self.assertTrue(self.detector._is_binary_file("test.zip"))
+        
+        # Test with non-existent file
+        mock_isfile.return_value = False
+        self.assertFalse(self.detector._is_binary_file("nonexistent.py"))
+    
+    @patch('os.path.isdir')
+    def test_should_ignore_directory(self, mock_isdir):
+        """Test _should_ignore_directory method"""
+        # Mock isdir to always return True
+        mock_isdir.return_value = True
+        
+        # Test with common directories to ignore
+        self.assertTrue(self.detector._should_ignore_directory("/test/repo/node_modules"))
+        self.assertTrue(self.detector._should_ignore_directory("/test/repo/.git"))
+        self.assertTrue(self.detector._should_ignore_directory("/test/repo/__pycache__"))
+        self.assertTrue(self.detector._should_ignore_directory("/test/repo/venv"))
+        self.assertTrue(self.detector._should_ignore_directory("/test/repo/.vscode"))
+        
+        # Test with directories not to ignore
+        self.assertFalse(self.detector._should_ignore_directory("/test/repo/src"))
+        self.assertFalse(self.detector._should_ignore_directory("/test/repo/app"))
+        self.assertFalse(self.detector._should_ignore_directory("/test/repo/docs"))
+        
+        # Test with non-existent directory
+        mock_isdir.return_value = False
+        self.assertFalse(self.detector._should_ignore_directory("/test/repo/nonexistent"))
+    
+    def test_should_ignore_file(self):
+        """Test _should_ignore_file method"""
+        # Test with common files to ignore
+        self.assertTrue(self.detector._should_ignore_file("/test/repo/.DS_Store"))
+        self.assertTrue(self.detector._should_ignore_file("/test/repo/Thumbs.db"))
+        self.assertTrue(self.detector._should_ignore_file("/test/repo/.env"))
+        
+        # Test with files not to ignore
+        self.assertFalse(self.detector._should_ignore_file("/test/repo/main.py"))
+        self.assertFalse(self.detector._should_ignore_file("/test/repo/app.js"))
+        self.assertFalse(self.detector._should_ignore_file("/test/repo/README.md"))
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_performance_analyzer.py

@@ -0,0 +1,442 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Performance Analyzer service
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock, mock_open
+import os
+import sys
+import re
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.services.performance_analyzer import PerformanceAnalyzer
+
+
+class TestPerformanceAnalyzer(unittest.TestCase):
+    """Test cases for the PerformanceAnalyzer class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.analyzer = PerformanceAnalyzer()
+        self.test_repo_path = "/test/repo"
+    
+    def test_analyze_python_performance(self):
+        """Test analyze_python_performance method"""
+        # Create a sample Python file content with performance issues
+        python_code = """
+        def slow_function():
+            # This is a slow list comprehension with nested loops
+            result = [x * y for x in range(1000) for y in range(1000)]
+            
+            # Inefficient string concatenation in a loop
+            s = ""
+            for i in range(1000):
+                s += str(i)
+            
+            # Using a list where a set would be more efficient
+            items = [1, 2, 3, 4, 5]
+            if 3 in items:  # O(n) operation
+                print("Found")
+        """
+        
+        # Mock the file discovery and reading
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/test.py']), \
+             patch('builtins.open', mock_open(read_data=python_code)):
+            
+            # Call the method
+            result = self.analyzer.analyze_python_performance(self.test_repo_path)
+            
+            # Verify the result
+            self.assertGreater(len(result['issues']), 0)
+            self.assertGreater(result['issue_count'], 0)
+            
+            # Check for specific issues
+            nested_loop_issue = next((issue for issue in result['issues'] 
+                                     if 'nested loop' in issue['message'].lower()), None)
+            string_concat_issue = next((issue for issue in result['issues'] 
+                                      if 'string concatenation' in issue['message'].lower()), None)
+            list_vs_set_issue = next((issue for issue in result['issues'] 
+                                    if 'list' in issue['message'].lower() and 'set' in issue['message'].lower()), None)
+            
+            self.assertIsNotNone(nested_loop_issue)
+            self.assertIsNotNone(string_concat_issue)
+            self.assertIsNotNone(list_vs_set_issue)
+    
+    def test_analyze_javascript_performance(self):
+        """Test analyze_javascript_performance method"""
+        # Create a sample JavaScript file content with performance issues
+        js_code = """
+        function slowFunction() {
+            // Inefficient DOM manipulation in a loop
+            for (let i = 0; i < 1000; i++) {
+                document.getElementById('myElement').innerHTML += 'item ' + i;
+            }
+            
+            // Memory leak with event listeners
+            document.getElementById('button').addEventListener('click', function() {
+                console.log('clicked');
+            });
+            
+            // Blocking the main thread
+            let start = Date.now();
+            while (Date.now() - start < 1000) {
+                // Busy wait for 1 second
+            }
+        }
+        """
+        
+        # Mock the file discovery and reading
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/test.js']), \
+             patch('builtins.open', mock_open(read_data=js_code)):
+            
+            # Call the method
+            result = self.analyzer.analyze_javascript_performance(self.test_repo_path)
+            
+            # Verify the result
+            self.assertGreater(len(result['issues']), 0)
+            self.assertGreater(result['issue_count'], 0)
+            
+            # Check for specific issues
+            dom_issue = next((issue for issue in result['issues'] 
+                             if 'dom' in issue['message'].lower()), None)
+            memory_leak_issue = next((issue for issue in result['issues'] 
+                                    if 'memory leak' in issue['message'].lower() or 'event listener' in issue['message'].lower()), None)
+            blocking_issue = next((issue for issue in result['issues'] 
+                                 if 'blocking' in issue['message'].lower() or 'main thread' in issue['message'].lower()), None)
+            
+            self.assertIsNotNone(dom_issue)
+            self.assertIsNotNone(memory_leak_issue)
+            self.assertIsNotNone(blocking_issue)
+    
+    def test_analyze_typescript_performance(self):
+        """Test analyze_typescript_performance method"""
+        # Create a sample TypeScript file content with performance issues
+        ts_code = """
+        function slowFunction(): void {
+            // Inefficient array operations
+            const array: number[] = [];
+            for (let i = 0; i < 1000; i++) {
+                array.unshift(i);  // O(n) operation
+            }
+            
+            // Excessive type casting
+            let value: any = "123";
+            let num: number = <number><any>value;
+            
+            // Inefficient async/await usage
+            async function fetchData(): Promise<void> {
+                const promises = [];
+                for (let i = 0; i < 10; i++) {
+                    const result = await fetch(`https://api.example.com/data/${i}`);  // Sequential fetches
+                    promises.push(result);
+                }
+            }
+        }
+        """
+        
+        # Mock the file discovery and reading
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/test.ts']), \
+             patch('builtins.open', mock_open(read_data=ts_code)):
+            
+            # Call the method
+            result = self.analyzer.analyze_typescript_performance(self.test_repo_path)
+            
+            # Verify the result
+            self.assertGreater(len(result['issues']), 0)
+            self.assertGreater(result['issue_count'], 0)
+            
+            # Check for specific issues
+            array_issue = next((issue for issue in result['issues'] 
+                               if 'array' in issue['message'].lower() and 'unshift' in issue['message'].lower()), None)
+            type_casting_issue = next((issue for issue in result['issues'] 
+                                     if 'type casting' in issue['message'].lower()), None)
+            async_issue = next((issue for issue in result['issues'] 
+                               if 'async' in issue['message'].lower() or 'await' in issue['message'].lower()), None)
+            
+            self.assertIsNotNone(array_issue)
+            self.assertIsNotNone(type_casting_issue)
+            self.assertIsNotNone(async_issue)
+    
+    def test_analyze_java_performance(self):
+        """Test analyze_java_performance method"""
+        # Create a sample Java file content with performance issues
+        java_code = """
+        public class SlowClass {
+            public void slowMethod() {
+                // Inefficient string concatenation
+                String result = "";
+                for (int i = 0; i < 1000; i++) {
+                    result += i;  // Creates a new string each time
+                }
+                
+                // Using ArrayList where HashSet would be more efficient for lookups
+                ArrayList<Integer> list = new ArrayList<>();
+                for (int i = 0; i < 1000; i++) {
+                    list.add(i);
+                }
+                boolean contains = list.contains(500);  // O(n) operation
+                
+                // Excessive object creation
+                for (int i = 0; i < 1000; i++) {
+                    Integer obj = new Integer(i);  // Creates 1000 objects
+                }
+            }
+        }
+        """
+        
+        # Mock the file discovery and reading
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/SlowClass.java']), \
+             patch('builtins.open', mock_open(read_data=java_code)):
+            
+            # Call the method
+            result = self.analyzer.analyze_java_performance(self.test_repo_path)
+            
+            # Verify the result
+            self.assertGreater(len(result['issues']), 0)
+            self.assertGreater(result['issue_count'], 0)
+            
+            # Check for specific issues
+            string_concat_issue = next((issue for issue in result['issues'] 
+                                      if 'string concatenation' in issue['message'].lower()), None)
+            collection_issue = next((issue for issue in result['issues'] 
+                                   if 'arraylist' in issue['message'].lower() and 'hashset' in issue['message'].lower()), None)
+            object_creation_issue = next((issue for issue in result['issues'] 
+                                        if 'object creation' in issue['message'].lower()), None)
+            
+            self.assertIsNotNone(string_concat_issue)
+            self.assertIsNotNone(collection_issue)
+            self.assertIsNotNone(object_creation_issue)
+    
+    def test_analyze_go_performance(self):
+        """Test analyze_go_performance method"""
+        # Create a sample Go file content with performance issues
+        go_code = """
+        package main
+
+        import (
+            "fmt"
+            "sync"
+        )
+
+        func slowFunction() {
+            // Inefficient slice operations
+            slice := []int{}
+            for i := 0; i < 1000; i++ {
+                slice = append(slice, i)  // May cause reallocation
+            }
+            
+            // Mutex instead of atomic operations
+            var mu sync.Mutex
+            counter := 0
+            for i := 0; i < 1000; i++ {
+                mu.Lock()
+                counter++
+                mu.Unlock()
+            }
+            
+            // Inefficient string concatenation
+            result := ""
+            for i := 0; i < 1000; i++ {
+                result += fmt.Sprintf("%d", i)  // Creates a new string each time
+            }
+        }
+        """
+        
+        # Mock the file discovery and reading
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/main.go']), \
+             patch('builtins.open', mock_open(read_data=go_code)):
+            
+            # Call the method
+            result = self.analyzer.analyze_go_performance(self.test_repo_path)
+            
+            # Verify the result
+            self.assertGreater(len(result['issues']), 0)
+            self.assertGreater(result['issue_count'], 0)
+            
+            # Check for specific issues
+            slice_issue = next((issue for issue in result['issues'] 
+                               if 'slice' in issue['message'].lower() and 'append' in issue['message'].lower()), None)
+            mutex_issue = next((issue for issue in result['issues'] 
+                               if 'mutex' in issue['message'].lower() or 'atomic' in issue['message'].lower()), None)
+            string_concat_issue = next((issue for issue in result['issues'] 
+                                      if 'string concatenation' in issue['message'].lower()), None)
+            
+            self.assertIsNotNone(slice_issue)
+            self.assertIsNotNone(mutex_issue)
+            self.assertIsNotNone(string_concat_issue)
+    
+    def test_analyze_rust_performance(self):
+        """Test analyze_rust_performance method"""
+        # Create a sample Rust file content with performance issues
+        rust_code = """
+        fn slow_function() {
+            // Inefficient string operations
+            let mut result = String::new();
+            for i in 0..1000 {
+                result.push_str(&i.to_string());  // Allocates a new string each time
+            }
+            
+            // Excessive cloning
+            let data = vec![1, 2, 3, 4, 5];
+            let copied = data.clone();  // Clones the entire vector
+            
+            // Inefficient iteration
+            let mut sum = 0;
+            for i in 0..data.len() {
+                sum += data[i];  // Bounds checking on each access
+            }
+        }
+        """
+        
+        # Mock the file discovery and reading
+        with patch.object(self.analyzer, '_find_files', return_value=['/test/repo/main.rs']), \
+             patch('builtins.open', mock_open(read_data=rust_code)):
+            
+            # Call the method
+            result = self.analyzer.analyze_rust_performance(self.test_repo_path)
+            
+            # Verify the result
+            self.assertGreater(len(result['issues']), 0)
+            self.assertGreater(result['issue_count'], 0)
+            
+            # Check for specific issues
+            string_issue = next((issue for issue in result['issues'] 
+                                if 'string' in issue['message'].lower()), None)
+            clone_issue = next((issue for issue in result['issues'] 
+                               if 'clone' in issue['message'].lower()), None)
+            iteration_issue = next((issue for issue in result['issues'] 
+                                  if 'iteration' in issue['message'].lower() or 'bounds checking' in issue['message'].lower()), None)
+            
+            self.assertIsNotNone(string_issue)
+            self.assertIsNotNone(clone_issue)
+            self.assertIsNotNone(iteration_issue)
+    
+    def test_analyze_repository(self):
+        """Test analyze_repository method"""
+        # Mock the language-specific analysis methods
+        self.analyzer.analyze_python_performance = MagicMock(return_value={
+            'issues': [
+                {'file': 'file1.py', 'line': 10, 'message': 'Inefficient list comprehension'},
+                {'file': 'file1.py', 'line': 20, 'message': 'Inefficient string concatenation'}
+            ],
+            'issue_count': 2
+        })
+        self.analyzer.analyze_javascript_performance = MagicMock(return_value={
+            'issues': [
+                {'file': 'file1.js', 'line': 15, 'message': 'DOM manipulation in loop'}
+            ],
+            'issue_count': 1
+        })
+        
+        # Call the method
+        result = self.analyzer.analyze_repository(self.test_repo_path, ['Python', 'JavaScript'])
+        
+        # Verify the result
+        self.assertEqual(len(result['language_results']), 2)  # Two languages
+        self.assertIn('Python', result['language_results'])
+        self.assertIn('JavaScript', result['language_results'])
+        self.assertEqual(result['language_results']['Python']['issue_count'], 2)
+        self.assertEqual(result['language_results']['JavaScript']['issue_count'], 1)
+        
+        # Check hotspots
+        self.assertEqual(len(result['hotspots']), 1)  # One file with multiple issues
+        self.assertEqual(result['hotspots'][0]['file'], 'file1.py')
+        self.assertEqual(result['hotspots'][0]['issue_count'], 2)
+        
+        # Verify the method calls
+        self.analyzer.analyze_python_performance.assert_called_once_with(self.test_repo_path)
+        self.analyzer.analyze_javascript_performance.assert_called_once_with(self.test_repo_path)
+    
+    def test_identify_hotspots(self):
+        """Test _identify_hotspots method"""
+        # Create sample language results
+        language_results = {
+            'Python': {
+                'issues': [
+                    {'file': 'file1.py', 'line': 10, 'message': 'Issue 1'},
+                    {'file': 'file1.py', 'line': 20, 'message': 'Issue 2'},
+                    {'file': 'file2.py', 'line': 5, 'message': 'Issue 3'}
+                ],
+                'issue_count': 3
+            },
+            'JavaScript': {
+                'issues': [
+                    {'file': 'file1.js', 'line': 15, 'message': 'Issue 4'},
+                    {'file': 'file3.js', 'line': 25, 'message': 'Issue 5'},
+                    {'file': 'file3.js', 'line': 30, 'message': 'Issue 6'}
+                ],
+                'issue_count': 3
+            }
+        }
+        
+        # Call the method
+        hotspots = self.analyzer._identify_hotspots(language_results)
+        
+        # Verify the result
+        self.assertEqual(len(hotspots), 2)  # Two files with multiple issues
+        
+        # Find the hotspots by file
+        file1_py_hotspot = next((h for h in hotspots if h['file'] == 'file1.py'), None)
+        file3_js_hotspot = next((h for h in hotspots if h['file'] == 'file3.js'), None)
+        
+        self.assertIsNotNone(file1_py_hotspot)
+        self.assertIsNotNone(file3_js_hotspot)
+        self.assertEqual(file1_py_hotspot['issue_count'], 2)
+        self.assertEqual(file3_js_hotspot['issue_count'], 2)
+    
+    @patch('os.walk')
+    def test_find_files(self, mock_walk):
+        """Test _find_files method"""
+        # Set up the mock
+        mock_walk.return_value = [
+            ('/test/repo', ['dir1'], ['file1.py', 'file2.js']),
+            ('/test/repo/dir1', [], ['file3.py'])
+        ]
+        
+        # Call the method
+        python_files = self.analyzer._find_files(self.test_repo_path, '.py')
+        
+        # Verify the result
+        self.assertEqual(len(python_files), 2)
+        self.assertIn('/test/repo/file1.py', python_files)
+        self.assertIn('/test/repo/dir1/file3.py', python_files)
+    
+    def test_analyze_file_with_patterns(self):
+        """Test _analyze_file_with_patterns method"""
+        # Create sample file content and patterns
+        file_content = """
+        def slow_function():
+            # This is a slow list comprehension
+            result = [x * y for x in range(1000) for y in range(1000)]
+            
+            # Inefficient string concatenation
+            s = ""
+            for i in range(1000):
+                s += str(i)
+        """
+        
+        patterns = [
+            (re.compile(r'\[.*for.*for.*\]', re.MULTILINE), "Nested list comprehension can be inefficient"),
+            (re.compile(r'\s+s\s\+=\s', re.MULTILINE), "String concatenation in a loop is inefficient")
+        ]
+        
+        # Call the method
+        issues = self.analyzer._analyze_file_with_patterns('/test/repo/test.py', file_content, patterns)
+        
+        # Verify the result
+        self.assertEqual(len(issues), 2)  # Two patterns matched
+        self.assertEqual(issues[0]['file'], 'test.py')  # Should be relative path
+        self.assertEqual(issues[1]['file'], 'test.py')
+        self.assertIn('Nested list comprehension', issues[0]['message'])
+        self.assertIn('String concatenation', issues[1]['message'])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_report_generator.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Report Generator Service
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock, mock_open
+import os
+import sys
+import json
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.services.report_generator import ReportGenerator
+
+
+class TestReportGenerator(unittest.TestCase):
+    """Test cases for the ReportGenerator class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        # Create a temporary output directory for testing
+        self.test_output_dir = "test_reports"
+        self.generator = ReportGenerator(output_dir=self.test_output_dir)
+        
+        # Sample test data
+        self.repo_name = "test-repo"
+        self.test_results = {
+            "repository_info": {
+                "branch": "main",
+                "commit": "abc123",
+                "remote_url": "https://github.com/test/test-repo",
+                "size": 1024,
+                "file_count": 10
+            },
+            "language_breakdown": {
+                "Python": {"files": 5, "lines": 500, "percentage": 70},
+                "JavaScript": {"files": 3, "lines": 200, "percentage": 30}
+            },
+            "code_analysis": {
+                "Python": {
+                    "issue_count": 3,
+                    "issues": [
+                        {"severity": "high", "issue": "Unused variable", "file": "test.py", "line": 10, "description": "Variable 'x' is not used"},
+                        {"severity": "medium", "issue": "Missing docstring", "file": "test.py", "line": 5, "description": "Function missing docstring"}
+                    ]
+                },
+                "JavaScript": {
+                    "issue_count": 2,
+                    "issues": [
+                        {"severity": "medium", "issue": "Unused variable", "file": "test.js", "line": 15, "description": "Variable 'y' is not used"}
+                    ]
+                }
+            },
+            "security_scan": {
+                "Python": {
+                    "vulnerability_count": 1,
+                    "vulnerabilities": [
+                        {"severity": "critical", "issue": "SQL Injection", "file": "db.py", "line": 25, "description": "Unsanitized SQL query"}
+                    ]
+                },
+                "JavaScript": {
+                    "vulnerability_count": 0,
+                    "vulnerabilities": []
+                }
+            },
+            "performance_analysis": {
+                "language_results": {
+                    "Python": {
+                        "issue_count": 2,
+                        "issues": [
+                            {"issue": "Inefficient loop", "file": "test.py", "line": 20, "description": "Use list comprehension instead"}
+                        ]
+                    }
+                },
+                "hotspots": [
+                    {"file": "test.py", "language": "Python", "issue_count": 2}
+                ]
+            },
+            "ai_review": {
+                "reviews": {
+                    "test.py": {
+                        "status": "success",
+                        "review_text": "Code review for test.py",
+                        "suggestions": [
+                            {"section": "Code Quality", "line": 10, "description": "Variable 'x' is not used", "details": "Remove unused variable"}
+                        ]
+                    }
+                },
+                "summary": "Overall, the code quality is good but there are some issues to address."
+            }
+        }
+    
+    def tearDown(self):
+        """Tear down test fixtures"""
+        # Clean up the test output directory
+        if os.path.exists(self.test_output_dir):
+            for file in os.listdir(self.test_output_dir):
+                os.remove(os.path.join(self.test_output_dir, file))
+            os.rmdir(self.test_output_dir)
+    
+    def test_init(self):
+        """Test initialization of the generator"""
+        self.assertIsNotNone(self.generator)
+        self.assertEqual(self.generator.output_dir, self.test_output_dir)
+        self.assertTrue(os.path.exists(self.test_output_dir))
+    
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('json.dump')
+    def test_generate_json_report(self, mock_json_dump, mock_file_open):
+        """Test _generate_json_report method"""
+        # Call the method
+        report_content = {"test": "content"}
+        report_path = self.generator._generate_json_report("test_report", report_content)
+        
+        # Verify the result
+        expected_path = os.path.join(self.test_output_dir, "test_report.json")
+        self.assertEqual(report_path, expected_path)
+        mock_file_open.assert_called_once_with(expected_path, "w", encoding="utf-8")
+        mock_json_dump.assert_called_once()
+    
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('markdown.markdown')
+    def test_generate_html_report(self, mock_markdown, mock_file_open):
+        """Test _generate_html_report method"""
+        # Mock markdown conversion
+        mock_markdown.return_value = "<h1>Test</h1>"
+        
+        # Call the method
+        report_content = {"metadata": {"repository_name": "test-repo"}}
+        report_path = self.generator._generate_html_report("test_report", report_content)
+        
+        # Verify the result
+        expected_path = os.path.join(self.test_output_dir, "test_report.html")
+        self.assertEqual(report_path, expected_path)
+        mock_file_open.assert_called_once_with(expected_path, "w", encoding="utf-8")
+        mock_markdown.assert_called_once()
+    
+    @patch('pdfkit.from_file')
+    @patch('os.remove')
+    def test_generate_pdf_report(self, mock_remove, mock_pdfkit):
+        """Test _generate_pdf_report method"""
+        # Mock the HTML report generation
+        with patch.object(self.generator, '_generate_html_report') as mock_html_report:
+            mock_html_report.return_value = os.path.join(self.test_output_dir, "test_report_temp.html")
+            
+            # Call the method
+            report_content = {"test": "content"}
+            report_path = self.generator._generate_pdf_report("test_report", report_content)
+            
+            # Verify the result
+            expected_path = os.path.join(self.test_output_dir, "test_report.pdf")
+            self.assertEqual(report_path, expected_path)
+            mock_html_report.assert_called_once_with("test_report_temp", report_content)
+            mock_pdfkit.assert_called_once_with(
+                os.path.join(self.test_output_dir, "test_report_temp.html"),
+                expected_path
+            )
+            mock_remove.assert_called_once_with(os.path.join(self.test_output_dir, "test_report_temp.html"))
+    
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('csv.DictWriter')
+    def test_generate_csv_report(self, mock_csv_writer, mock_file_open):
+        """Test _generate_csv_report method"""
+        # Mock CSV writer
+        mock_writer = MagicMock()
+        mock_csv_writer.return_value = mock_writer
+        
+        # Call the method
+        report_content = {
+            "code_quality": {"issues_by_language": {}},
+            "security": {"vulnerabilities_by_language": {}},
+            "performance": {"issues_by_language": {}},
+            "ai_review": {"file_reviews": {}}
+        }
+        report_path = self.generator._generate_csv_report("test_report", report_content)
+        
+        # Verify the result
+        expected_path = os.path.join(self.test_output_dir, "test_report.csv")
+        self.assertEqual(report_path, expected_path)
+        mock_file_open.assert_called_once_with(expected_path, "w", newline="", encoding="utf-8")
+        mock_writer.writeheader.assert_called_once()
+        mock_writer.writerows.assert_called_once()
+    
+    def test_calculate_summary_metrics(self):
+        """Test _calculate_summary_metrics method"""
+        # Call the method
+        metrics = self.generator._calculate_summary_metrics(self.test_results)
+        
+        # Verify the result
+        self.assertEqual(metrics["total_files"], 10)
+        self.assertEqual(metrics["repository_size"], 1024)
+        self.assertEqual(metrics["total_code_issues"], 5)  # 3 Python + 2 JavaScript
+        self.assertEqual(metrics["critical_code_issues"], 1)  # 1 high severity issue
+        self.assertEqual(metrics["total_vulnerabilities"], 1)  # 1 Python vulnerability
+        self.assertEqual(metrics["critical_vulnerabilities"], 1)  # 1 critical vulnerability
+        self.assertEqual(metrics["total_performance_issues"], 2)  # 2 Python performance issues
+        self.assertEqual(metrics["performance_hotspots"], 1)  # 1 hotspot
+        self.assertIn("overall_score", metrics)
+        self.assertIn("quality_rating", metrics)
+    
+    def test_extract_top_issues(self):
+        """Test _extract_top_issues method"""
+        # Call the method
+        top_issues = self.generator._extract_top_issues(self.test_results["code_analysis"])
+        
+        # Verify the result
+        self.assertEqual(len(top_issues), 3)  # Total issues in the test data
+        self.assertEqual(top_issues[0]["severity"], "high")  # First issue should be high severity
+    
+    def test_extract_critical_vulnerabilities(self):
+        """Test _extract_critical_vulnerabilities method"""
+        # Call the method
+        critical_vulns = self.generator._extract_critical_vulnerabilities(self.test_results["security_scan"])
+        
+        # Verify the result
+        self.assertEqual(len(critical_vulns), 1)  # Only one vulnerability in the test data
+        self.assertEqual(critical_vulns[0]["severity"], "critical")
+    
+    def test_generate_recommendations(self):
+        """Test _generate_recommendations method"""
+        # Call the method
+        recommendations = self.generator._generate_recommendations(self.test_results)
+        
+        # Verify the result
+        self.assertIn("high_priority", recommendations)
+        self.assertIn("medium_priority", recommendations)
+        self.assertIn("low_priority", recommendations)
+        self.assertEqual(len(recommendations["high_priority"]), 1)  # One critical security vulnerability
+        self.assertGreaterEqual(len(recommendations["medium_priority"]), 1)  # At least one high code issue
+    
+    @patch('os.path.exists')
+    @patch('os.listdir')
+    def test_generate_report(self, mock_listdir, mock_exists):
+        """Test generate_report method"""
+        # Mock the report generation methods
+        with patch.object(self.generator, '_create_report_content') as mock_create_content, \
+             patch.object(self.generator, '_generate_json_report') as mock_json_report, \
+             patch.object(self.generator, '_generate_html_report') as mock_html_report, \
+             patch.object(self.generator, '_generate_pdf_report') as mock_pdf_report, \
+             patch.object(self.generator, '_generate_csv_report') as mock_csv_report:
+            
+            # Set up the mocks
+            mock_create_content.return_value = {"test": "content"}
+            mock_json_report.return_value = "json_path"
+            mock_html_report.return_value = "html_path"
+            mock_pdf_report.return_value = "pdf_path"
+            mock_csv_report.return_value = "csv_path"
+            
+            # Call the method with all formats
+            report_paths = self.generator.generate_report(self.repo_name, self.test_results, "all")
+            
+            # Verify the result
+            self.assertEqual(report_paths["json"], "json_path")
+            self.assertEqual(report_paths["html"], "html_path")
+            self.assertEqual(report_paths["pdf"], "pdf_path")
+            self.assertEqual(report_paths["csv"], "csv_path")
+            mock_create_content.assert_called_once_with(self.repo_name, self.test_results)
+            
+            # Call the method with specific format
+            report_paths = self.generator.generate_report(self.repo_name, self.test_results, "json")
+            
+            # Verify the result
+            self.assertEqual(len(report_paths), 1)
+            self.assertEqual(report_paths["json"], "json_path")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_repository_service.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Repository Service
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+import os
+import sys
+import shutil
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.services.repository_service import (
+    validate_github_url,
+    normalize_github_url,
+    extract_repo_name,
+    clone_repository,
+    get_repository_info,
+    cleanup_repository,
+    cleanup_all_repositories
+)
+
+
+class TestRepositoryService(unittest.TestCase):
+    """Test cases for the repository service functions"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.test_repo_dir = "test_repos"
+        os.makedirs(self.test_repo_dir, exist_ok=True)
+    
+    def tearDown(self):
+        """Tear down test fixtures"""
+        if os.path.exists(self.test_repo_dir):
+            shutil.rmtree(self.test_repo_dir)
+    
+    def test_validate_github_url(self):
+        """Test validate_github_url function"""
+        # Valid URLs
+        self.assertTrue(validate_github_url("https://github.com/user/repo"))
+        self.assertTrue(validate_github_url("https://github.com/user/repo.git"))
+        self.assertTrue(validate_github_url("git@github.com:user/repo.git"))
+        self.assertTrue(validate_github_url("https://github.com/user/repo-with-dash"))
+        self.assertTrue(validate_github_url("https://github.com/user/repo_with_underscore"))
+        
+        # Invalid URLs
+        self.assertFalse(validate_github_url("https://gitlab.com/user/repo"))
+        self.assertFalse(validate_github_url("https://github.com"))
+        self.assertFalse(validate_github_url("https://github.com/user"))
+        self.assertFalse(validate_github_url("not a url"))
+    
+    def test_normalize_github_url(self):
+        """Test normalize_github_url function"""
+        # HTTPS URLs
+        self.assertEqual(
+            normalize_github_url("https://github.com/user/repo"),
+            "https://github.com/user/repo.git"
+        )
+        self.assertEqual(
+            normalize_github_url("https://github.com/user/repo.git"),
+            "https://github.com/user/repo.git"
+        )
+        
+        # SSH URLs
+        self.assertEqual(
+            normalize_github_url("git@github.com:user/repo.git"),
+            "https://github.com/user/repo.git"
+        )
+        self.assertEqual(
+            normalize_github_url("git@github.com:user/repo"),
+            "https://github.com/user/repo.git"
+        )
+        
+        # URLs with trailing slashes
+        self.assertEqual(
+            normalize_github_url("https://github.com/user/repo/"),
+            "https://github.com/user/repo.git"
+        )
+        
+        # Invalid URLs should return None
+        self.assertIsNone(normalize_github_url("https://gitlab.com/user/repo"))
+        self.assertIsNone(normalize_github_url("not a url"))
+    
+    def test_extract_repo_name(self):
+        """Test extract_repo_name function"""
+        self.assertEqual(extract_repo_name("https://github.com/user/repo"), "repo")
+        self.assertEqual(extract_repo_name("https://github.com/user/repo.git"), "repo")
+        self.assertEqual(extract_repo_name("git@github.com:user/repo.git"), "repo")
+        self.assertEqual(extract_repo_name("https://github.com/user/repo-with-dash"), "repo-with-dash")
+        
+        # Invalid URLs should return None
+        self.assertIsNone(extract_repo_name("https://github.com"))
+        self.assertIsNone(extract_repo_name("not a url"))
+    
+    @patch('git.Repo.clone_from')
+    def test_clone_repository(self, mock_clone_from):
+        """Test clone_repository function"""
+        # Mock the Git clone operation
+        mock_repo = MagicMock()
+        mock_clone_from.return_value = mock_repo
+        
+        # Test with default branch
+        repo_path = clone_repository(
+            "https://github.com/user/repo",
+            output_dir=self.test_repo_dir
+        )
+        
+        # Verify the result
+        expected_path = os.path.join(self.test_repo_dir, "repo")
+        self.assertEqual(repo_path, expected_path)
+        mock_clone_from.assert_called_once()
+        
+        # Test with specific branch
+        mock_clone_from.reset_mock()
+        repo_path = clone_repository(
+            "https://github.com/user/repo",
+            branch="dev",
+            output_dir=self.test_repo_dir
+        )
+        
+        # Verify the result
+        self.assertEqual(repo_path, expected_path)
+        mock_clone_from.assert_called_once()
+        
+        # Test with invalid URL
+        with self.assertRaises(ValueError):
+            clone_repository(
+                "not a url",
+                output_dir=self.test_repo_dir
+            )
+    
+    @patch('git.Repo')
+    @patch('os.path.getsize')
+    @patch('os.walk')
+    def test_get_repository_info(self, mock_walk, mock_getsize, mock_repo):
+        """Test get_repository_info function"""
+        # Mock the Git repository
+        mock_repo_instance = MagicMock()
+        mock_repo.return_value = mock_repo_instance
+        
+        # Mock the active branch
+        mock_branch = MagicMock()
+        mock_branch.name = "main"
+        mock_repo_instance.active_branch = mock_branch
+        
+        # Mock the head commit
+        mock_commit = MagicMock()
+        mock_commit.hexsha = "abc123"
+        mock_repo_instance.head.commit = mock_commit
+        
+        # Mock the remote URL
+        mock_remote = MagicMock()
+        mock_remote.url = "https://github.com/user/repo.git"
+        mock_repo_instance.remotes.origin = mock_remote
+        
+        # Mock the repository size
+        mock_getsize.return_value = 1024
+        
+        # Mock the file count
+        mock_walk.return_value = [
+            ("/test/repo", ["dir1"], ["file1.py", "file2.py"]),
+            ("/test/repo/dir1", [], ["file3.py"])
+        ]
+        
+        # Test the function
+        repo_info = get_repository_info("/test/repo")
+        
+        # Verify the result
+        self.assertEqual(repo_info["branch"], "main")
+        self.assertEqual(repo_info["commit"], "abc123")
+        self.assertEqual(repo_info["remote_url"], "https://github.com/user/repo.git")
+        self.assertEqual(repo_info["size"], 1024)
+        self.assertEqual(repo_info["file_count"], 3)
+    
+    @patch('shutil.rmtree')
+    @patch('os.path.exists')
+    def test_cleanup_repository(self, mock_exists, mock_rmtree):
+        """Test cleanup_repository function"""
+        # Mock the path exists check
+        mock_exists.return_value = True
+        
+        # Test the function
+        cleanup_repository("/test/repo")
+        
+        # Verify the result
+        mock_exists.assert_called_once_with("/test/repo")
+        mock_rmtree.assert_called_once_with("/test/repo")
+        
+        # Test with non-existent path
+        mock_exists.reset_mock()
+        mock_rmtree.reset_mock()
+        mock_exists.return_value = False
+        
+        cleanup_repository("/test/repo")
+        
+        mock_exists.assert_called_once_with("/test/repo")
+        mock_rmtree.assert_not_called()
+    
+    @patch('os.listdir')
+    @patch('os.path.isdir')
+    @patch('shutil.rmtree')
+    def test_cleanup_all_repositories(self, mock_rmtree, mock_isdir, mock_listdir):
+        """Test cleanup_all_repositories function"""
+        # Mock the directory listing
+        mock_listdir.return_value = ["repo1", "repo2", "file.txt"]
+        
+        # Mock the isdir check
+        mock_isdir.side_effect = lambda path: path.endswith("repo1") or path.endswith("repo2")
+        
+        # Test the function
+        cleanup_all_repositories(self.test_repo_dir)
+        
+        # Verify the result
+        mock_listdir.assert_called_once_with(self.test_repo_dir)
+        self.assertEqual(mock_isdir.call_count, 3)  # Called for each item in the directory
+        self.assertEqual(mock_rmtree.call_count, 2)  # Called for each directory
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_security_scanner.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Unit tests for the Security Scanner service
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock, mock_open
+import os
+import sys
+import json
+from pathlib import Path
+
+# Add the project root directory to the Python path
+project_root = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.services.security_scanner import SecurityScanner
+
+
+class TestSecurityScanner(unittest.TestCase):
+    """Test cases for the SecurityScanner class"""
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.scanner = SecurityScanner()
+        self.test_repo_path = "/test/repo"
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_scan_python_dependencies(self, mock_run, mock_exists):
+        """Test scan_python_dependencies method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the requirements.txt file
+        with patch('builtins.open', mock_open(read_data="requests==2.25.1\ndjango==2.2.0\n")):
+            # Mock the subprocess.run result
+            mock_process = MagicMock()
+            mock_process.returncode = 0
+            mock_process.stdout = json.dumps({
+                "vulnerabilities": [
+                    {
+                        "package_name": "django",
+                        "vulnerable_spec": "<2.2.28",
+                        "installed_version": "2.2.0",
+                        "description": "Django before 2.2.28 has a potential directory traversal via ../ in the file name.",
+                        "id": "CVE-2022-34265",
+                        "cvss_v3_score": "7.5"
+                    }
+                ]
+            })
+            mock_run.return_value = mock_process
+            
+            # Call the method
+            result = self.scanner.scan_python_dependencies(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['vulnerabilities']), 1)
+            self.assertEqual(result['vulnerability_count'], 1)
+            self.assertEqual(result['vulnerabilities'][0]['package'], 'django')
+            self.assertEqual(result['vulnerabilities'][0]['installed_version'], '2.2.0')
+            self.assertEqual(result['vulnerabilities'][0]['vulnerability_id'], 'CVE-2022-34265')
+            self.assertEqual(result['vulnerabilities'][0]['severity'], 'high')  # 7.5 maps to high
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_scan_javascript_dependencies(self, mock_run, mock_exists):
+        """Test scan_javascript_dependencies method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "vulnerabilities": {
+                "lodash": [
+                    {
+                        "name": "lodash",
+                        "severity": "high",
+                        "via": [
+                            {
+                                "source": 1065,
+                                "name": "lodash",
+                                "dependency": "lodash",
+                                "title": "Prototype Pollution",
+                                "url": "https://npmjs.com/advisories/1065",
+                                "severity": "high",
+                                "range": "<4.17.12"
+                            }
+                        ],
+                        "effects": [],
+                        "range": "<4.17.12",
+                        "nodes": ["node_modules/lodash"],
+                        "fixAvailable": true
+                    }
+                ]
+            }
+        })
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        result = self.scanner.scan_javascript_dependencies(self.test_repo_path)
+        
+        # Verify the result
+        self.assertEqual(len(result['vulnerabilities']), 1)
+        self.assertEqual(result['vulnerability_count'], 1)
+        self.assertEqual(result['vulnerabilities'][0]['package'], 'lodash')
+        self.assertEqual(result['vulnerabilities'][0]['severity'], 'high')
+        self.assertEqual(result['vulnerabilities'][0]['title'], 'Prototype Pollution')
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_scan_go_dependencies(self, mock_run, mock_exists):
+        """Test scan_go_dependencies method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "Vulns": [
+                {
+                    "ID": "GO-2020-0015",
+                    "Details": "Improper certificate validation in crypto/x509",
+                    "Affected": [
+                        {
+                            "Module": {
+                                "Path": "golang.org/x/crypto",
+                                "Versions": [
+                                    {
+                                        "Fixed": "v0.0.0-20200221170555-0f29369cfe45"
+                                    }
+                                ]
+                            },
+                            "Packages": [
+                                {
+                                    "Path": "golang.org/x/crypto/cryptobyte",
+                                    "Symbols": ["String.ReadASN1"]
+                                }
+                            ]
+                        }
+                    ],
+                    "References": [
+                        {
+                            "Type": "FIX",
+                            "URL": "https://go.dev/cl/219877"
+                        },
+                        {
+                            "Type": "REPORT",
+                            "URL": "https://go.dev/issue/36837"
+                        },
+                        {
+                            "Type": "WEB",
+                            "URL": "https://nvd.nist.gov/vuln/detail/CVE-2020-7919"
+                        }
+                    ],
+                    "Description": "Due to improper bounds checking, maliciously crafted X.509 certificates can cause a panic in certificate verification.",
+                    "CVEs": ["CVE-2020-7919"],
+                    "Severity": "MODERATE"
+                }
+            ]
+        })
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        result = self.scanner.scan_go_dependencies(self.test_repo_path)
+        
+        # Verify the result
+        self.assertEqual(len(result['vulnerabilities']), 1)
+        self.assertEqual(result['vulnerability_count'], 1)
+        self.assertEqual(result['vulnerabilities'][0]['package'], 'golang.org/x/crypto')
+        self.assertEqual(result['vulnerabilities'][0]['vulnerability_id'], 'GO-2020-0015')
+        self.assertEqual(result['vulnerabilities'][0]['severity'], 'medium')  # MODERATE maps to medium
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_scan_rust_dependencies(self, mock_run, mock_exists):
+        """Test scan_rust_dependencies method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "vulnerabilities": {
+                "RUSTSEC-2020-0071": {
+                    "advisory": {
+                        "id": "RUSTSEC-2020-0071",
+                        "package": "smallvec",
+                        "title": "Buffer overflow in SmallVec::insert_many",
+                        "description": "Affected versions of smallvec did not properly calculate capacity when inserting multiple elements, which could result in a buffer overflow.",
+                        "date": "2020-12-02",
+                        "aliases": ["CVE-2021-25900"],
+                        "categories": ["memory-corruption"],
+                        "keywords": ["buffer-overflow", "heap-overflow"],
+                        "cvss": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
+                        "related": []
+                    },
+                    "versions": {
+                        "patched": [">=1.6.1"],
+                        "unaffected": ["<1.0.0"]
+                    },
+                    "affected": {
+                        "arch": [],
+                        "os": [],
+                        "functions": ["smallvec::SmallVec::insert_many"]
+                    }
+                }
+            },
+            "warnings": []
+        })
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        result = self.scanner.scan_rust_dependencies(self.test_repo_path)
+        
+        # Verify the result
+        self.assertEqual(len(result['vulnerabilities']), 1)
+        self.assertEqual(result['vulnerability_count'], 1)
+        self.assertEqual(result['vulnerabilities'][0]['package'], 'smallvec')
+        self.assertEqual(result['vulnerabilities'][0]['vulnerability_id'], 'RUSTSEC-2020-0071')
+        self.assertEqual(result['vulnerabilities'][0]['title'], 'Buffer overflow in SmallVec::insert_many')
+        self.assertEqual(result['vulnerabilities'][0]['severity'], 'critical')  # CVSS 9.8 maps to critical
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_scan_python_code(self, mock_run, mock_exists):
+        """Test scan_python_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps({
+            "results": [
+                {
+                    "filename": "test.py",
+                    "line_number": 42,
+                    "issue_severity": "HIGH",
+                    "issue_confidence": "HIGH",
+                    "issue_text": "Possible hardcoded password: 'super_secret'",
+                    "test_id": "B105",
+                    "test_name": "hardcoded_password_string"
+                }
+            ]
+        })
+        mock_run.return_value = mock_process
+        
+        # Mock the file discovery
+        with patch.object(self.scanner, '_find_files', return_value=['/test/repo/test.py']):
+            # Call the method
+            result = self.scanner.scan_python_code(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['vulnerabilities']), 1)
+            self.assertEqual(result['vulnerability_count'], 1)
+            self.assertEqual(result['vulnerabilities'][0]['file'], 'test.py')
+            self.assertEqual(result['vulnerabilities'][0]['line'], 42)
+            self.assertEqual(result['vulnerabilities'][0]['severity'], 'high')
+            self.assertEqual(result['vulnerabilities'][0]['message'], "Possible hardcoded password: 'super_secret'")
+    
+    @patch('os.path.exists')
+    @patch('subprocess.run')
+    def test_scan_javascript_code(self, mock_run, mock_exists):
+        """Test scan_javascript_code method"""
+        # Set up the mocks
+        mock_exists.return_value = True
+        
+        # Mock the subprocess.run result
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = json.dumps([
+            {
+                "filePath": "/test/repo/test.js",
+                "messages": [
+                    {
+                        "ruleId": "security/detect-eval-with-expression",
+                        "severity": 2,
+                        "message": "eval() with variable content can allow an attacker to run arbitrary code.",
+                        "line": 10,
+                        "column": 1,
+                        "nodeType": "CallExpression"
+                    }
+                ],
+                "errorCount": 1,
+                "warningCount": 0,
+                "fixableErrorCount": 0,
+                "fixableWarningCount": 0
+            }
+        ])
+        mock_run.return_value = mock_process
+        
+        # Mock the file discovery
+        with patch.object(self.scanner, '_find_files', return_value=['/test/repo/test.js']):
+            # Call the method
+            result = self.scanner.scan_javascript_code(self.test_repo_path)
+            
+            # Verify the result
+            self.assertEqual(len(result['vulnerabilities']), 1)
+            self.assertEqual(result['vulnerability_count'], 1)
+            self.assertEqual(result['vulnerabilities'][0]['file'], 'test.js')
+            self.assertEqual(result['vulnerabilities'][0]['line'], 10)
+            self.assertEqual(result['vulnerabilities'][0]['severity'], 'high')  # Severity 2 maps to high
+            self.assertEqual(result['vulnerabilities'][0]['message'], "eval() with variable content can allow an attacker to run arbitrary code.")
+    
+    def test_scan_repository(self):
+        """Test scan_repository method"""
+        # Mock the language-specific scanning methods
+        self.scanner.scan_python_dependencies = MagicMock(return_value={
+            'vulnerabilities': [{'package': 'django', 'vulnerability_id': 'CVE-2022-34265', 'severity': 'high'}],
+            'vulnerability_count': 1
+        })
+        self.scanner.scan_python_code = MagicMock(return_value={
+            'vulnerabilities': [{'file': 'test.py', 'line': 42, 'severity': 'high'}],
+            'vulnerability_count': 1
+        })
+        self.scanner.scan_javascript_dependencies = MagicMock(return_value={
+            'vulnerabilities': [{'package': 'lodash', 'severity': 'high'}],
+            'vulnerability_count': 1
+        })
+        self.scanner.scan_javascript_code = MagicMock(return_value={
+            'vulnerabilities': [{'file': 'test.js', 'line': 10, 'severity': 'high'}],
+            'vulnerability_count': 1
+        })
+        
+        # Call the method
+        result = self.scanner.scan_repository(self.test_repo_path, ['Python', 'JavaScript'])
+        
+        # Verify the result
+        self.assertEqual(len(result), 2)  # Two languages
+        self.assertIn('Python', result)
+        self.assertIn('JavaScript', result)
+        
+        # Check Python results
+        self.assertEqual(result['Python']['dependency_vulnerabilities']['vulnerability_count'], 1)
+        self.assertEqual(result['Python']['code_vulnerabilities']['vulnerability_count'], 1)
+        self.assertEqual(result['Python']['total_vulnerabilities'], 2)
+        
+        # Check JavaScript results
+        self.assertEqual(result['JavaScript']['dependency_vulnerabilities']['vulnerability_count'], 1)
+        self.assertEqual(result['JavaScript']['code_vulnerabilities']['vulnerability_count'], 1)
+        self.assertEqual(result['JavaScript']['total_vulnerabilities'], 2)
+        
+        # Verify the method calls
+        self.scanner.scan_python_dependencies.assert_called_once_with(self.test_repo_path)
+        self.scanner.scan_python_code.assert_called_once_with(self.test_repo_path)
+        self.scanner.scan_javascript_dependencies.assert_called_once_with(self.test_repo_path)
+        self.scanner.scan_javascript_code.assert_called_once_with(self.test_repo_path)
+    
+    @patch('os.walk')
+    def test_find_files(self, mock_walk):
+        """Test _find_files method"""
+        # Set up the mock
+        mock_walk.return_value = [
+            ('/test/repo', ['dir1'], ['file1.py', 'file2.js']),
+            ('/test/repo/dir1', [], ['file3.py'])
+        ]
+        
+        # Call the method
+        python_files = self.scanner._find_files(self.test_repo_path, '.py')
+        
+        # Verify the result
+        self.assertEqual(len(python_files), 2)
+        self.assertIn('/test/repo/file1.py', python_files)
+        self.assertIn('/test/repo/dir1/file3.py', python_files)
+    
+    @patch('os.path.exists')
+    def test_check_tool_availability(self, mock_exists):
+        """Test _check_tool_availability method"""
+        # Set up the mock
+        mock_exists.side_effect = [True, False]  # First tool exists, second doesn't
+        
+        # Call the method
+        result1 = self.scanner._check_tool_availability('tool1')
+        result2 = self.scanner._check_tool_availability('tool2')
+        
+        # Verify the result
+        self.assertTrue(result1)
+        self.assertFalse(result2)
+    
+    @patch('subprocess.run')
+    def test_run_command(self, mock_run):
+        """Test _run_command method"""
+        # Set up the mock
+        mock_process = MagicMock()
+        mock_process.returncode = 0
+        mock_process.stdout = "Test output"
+        mock_run.return_value = mock_process
+        
+        # Call the method
+        returncode, output = self.scanner._run_command(['test', 'command'])
+        
+        # Verify the result
+        self.assertEqual(returncode, 0)
+        self.assertEqual(output, "Test output")
+        mock_run.assert_called_once()
+    
+    def test_map_cvss_to_severity(self):
+        """Test _map_cvss_to_severity method"""
+        # Call the method with different CVSS scores
+        low = self.scanner._map_cvss_to_severity(3.5)
+        medium = self.scanner._map_cvss_to_severity(5.5)
+        high = self.scanner._map_cvss_to_severity(8.0)
+        critical = self.scanner._map_cvss_to_severity(9.5)
+        
+        # Verify the results
+        self.assertEqual(low, 'low')
+        self.assertEqual(medium, 'medium')
+        self.assertEqual(high, 'high')
+        self.assertEqual(critical, 'critical')
+
+
+if __name__ == "__main__":
+    unittest.main()