Review Agent: first commit

.gitignore

@@ -0,0 +1,126 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+reports/
+temp_repos/
+logs/
+
+# Environment variables
+.env
+
+# Temporary files
+*.tmp
+
+# OS specific
+.DS_Store
+Thumbs.db
+
+# Costume files
+DEPLOYMENT_GUIDE.md
+setup.py
+reports
+run.py

Dockerfile

@@ -0,0 +1,39 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=off \
+    PIP_DISABLE_PIP_VERSION_CHECK=on
+
+# Set the working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    wkhtmltopdf \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the project code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p reports logs temp_repos
+
+# Make the run script executable
+RUN chmod +x run.py
+
+# Expose the port the app runs on
+EXPOSE 7860
+
+# Command to run the application
+CMD ["python", "run.py"]

LICENSE

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

README.md

@@ -1,12 +1,172 @@
 ---
-title: CodeReviewAgent
+title: Code Review Agent
 emoji: 🏆
 colorFrom: yellow
-colorTo: purple
+colorTo: green
 sdk: gradio
-sdk_version: 5.33.1
+sdk_version: 5.33.0
 app_file: app.py
-pinned: false
+pinned: true
+short_description: An AI-powered code review agent that analyzes Github Repos
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Code Review Agent
+
+[![agent-demo-track](https://img.shields.io/badge/Gradio-agent--demo--track-orange)](https://huggingface.co/Agents-MCP-Hackathon)
+[![MCP-Server](https://img.shields.io/badge/MCP-Server-blue)](https://www.gradio.app/guides/building-mcp-server-with-gradio)
+
+A professional-grade code review agent that leverages AI to provide comprehensive code analysis and actionable recommendations. Built for the Gradio MCP Hackathon, this tool helps developers improve code quality through automated reviews powered by advanced AI models.
+
+![Gradio MCP Hackathon](https://cdn-uploads.huggingface.co/production/uploads/60d2dc1007da9c17c72708f8/4HXPmk3CW5zQmVLBxh2Nx.png)
+
+## 🚀 Features
+
+- **Multi-Language Support**: Analyzes code in 15+ programming languages including Python, JavaScript, TypeScript, Java, C++, and more
+- **Enterprise-Grade UI**: Professional Gradio interface with modern design and intuitive workflow
+- **Advanced Analysis**: Comprehensive insights on security vulnerabilities, performance bottlenecks, and code quality issues
+- **GitHub Integration**: Support for both public and private GitHub repositories with secure token authentication
+- **MCP Server**: Functions as a Model Context Protocol (MCP) server, allowing LLMs to use this tool for code review operations
+- **Professional Reporting**: Detailed reports with actionable recommendations organized by priority
+- **Customizable Reviews**: Select specific languages to focus the review on parts of your codebase that matter most
+
+## 🏗️ Architecture
+
+The system follows a robust 4-layer architecture designed for extensibility and maintainability:
+
+1. **Presentation Layer**: Gradio-based UI with professional dashboard and intuitive controls
+2. **Application Layer**: Core business logic and review engine with modular components
+3. **Service Layer**: External integrations and analysis services with clean interfaces
+4. **MCP Layer**: Implements the Model Context Protocol (MCP) server functionality, allowing LLMs to use this tool for code review operations through standardized communication
+
+## 📋 Requirements
+
+- Python 3.8+
+- Git
+- Internet connection for AI model access
+- GitHub token (optional, for private repositories)
+
+## 🔧 Installation
+
+```bash
+# Clone the repository
+git clone https://huggingface.co/spaces/c1r3x/code-review-agent
+cd code-review-agent
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set up environment variables (optional)
+cp sample.env .env
+# Edit .env with your configuration
+```
+
+## 🚀 Usage
+
+```bash
+python src/main.py
+```
+
+Then open your browser to http://localhost:7860 to access the Code Review Agent.
+
+### Analyzing a Repository
+
+1. Enter the GitHub repository URL in the input field
+2. Optionally enter your GitHub token for private repositories
+3. Select the programming languages to focus the review on
+4. Click "Submit" to start the analysis
+5. View the comprehensive report with actionable recommendations
+
+## 🐳 Docker Deployment
+
+```bash
+# Build and run with Docker Compose
+docker-compose up -d
+```
+
+Access the application at http://localhost:7860
+
+## 🔌 MCP Server Functionality
+
+This application functions as a Model Context Protocol (MCP) server, allowing Large Language Models (LLMs) to use it as a tool for code review operations:
+
+- **MCP Integration**: Exposes code review capabilities through standardized MCP endpoints
+- **LLM Tool Usage**: Can be called by LLMs like Claude, GPT-4, and others that support the MCP protocol
+- **Tool Operations**: Provides repository analysis, code review, and report generation as MCP operations
+- **Structured Responses**: Returns analysis results in structured formats compatible with LLM processing
+
+To use this as an MCP server with your LLM:
+
+1. Deploy the application using the instructions above
+2. Configure your MCP client to connect to the server endpoint
+3. The LLM can then use the code review capabilities through MCP tool calls
+
+## 🧪 Testing
+
+```bash
+# Run the test suite
+python -m pytest tests/
+```
+
+## 📁 Project Structure
+
+```
+├── .env                    # Environment variables configuration
+├── .gitignore              # Git ignore file
+├── DEPLOYMENT_GUIDE.md     # Guide for deploying to Hugging Face and Modal
+├── Dockerfile              # Docker configuration
+├── LICENSE                 # MIT License file
+├── README.md               # Project documentation
+├── app.py                  # Entry point for Hugging Face Spaces
+├── docker-compose.yml      # Docker Compose configuration
+├── modal_deploy.py         # Modal deployment configuration
+├── prompt.txt              # AI prompt templates
+├── requirements.txt        # Python dependencies
+├── run.py                  # Alternative entry script
+├── sample.env              # Sample environment variables
+├── setup.py                # Package setup configuration
+├── src/                    # Source code directory
+│   ├── __init__.py         # Package initialization
+│   ├── core/               # Core application logic
+│   │   ├── __init__.py
+│   │   ├── agent_manager.py    # Agent orchestration
+│   │   └── language_detector.py # Language detection
+│   ├── main.py             # Main application entry point
+│   ├── mcp/                # MCP server implementation
+│   │   ├── __init__.py
+│   │   └── ai_review.py    # AI review integration
+│   ├── services/           # Service layer components
+│   │   ├── __init__.py
+│   │   ├── code_analyzer.py       # Code analysis
+│   │   ├── performance_analyzer.py # Performance analysis
+│   │   ├── report_generator.py     # Report generation
+│   │   ├── repository_service.py   # Repository operations
+│   │   └── security_scanner.py     # Security scanning
+│   └── ui/                 # User interface components
+│       ├── __init__.py
+│       ├── components/     # UI components
+│       ├── gradio_app.py   # Gradio application
+│       └── styles/         # UI styling
+└── tests/                  # Test directory
+    ├── test_agent_manager.py
+    ├── test_ai_review.py
+    ├── test_code_analyzer.py
+    ├── test_language_detector.py
+    ├── test_performance_analyzer.py
+    ├── test_report_generator.py
+    ├── test_repository_service.py
+    └── test_security_scanner.py
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

app.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Code Review Agent - Hugging Face Spaces Entry Point
+
+This module serves as the entry point for the Code Review Agent application
+when deployed to Hugging Face Spaces.
+"""
+
+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.dirname(__file__)))
+
+# Import application modules
+from src.ui.gradio_app import create_gradio_app
+from src.core.agent_manager import AgentManager
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+
+logger = logging.getLogger(__name__)
+
+# 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 the Gradio app
+app = create_gradio_app(agent_manager)
+
+# Launch the app with specific server configuration for Hugging Face Spaces
+app.launch(server_name="0.0.0.0", server_port=7860, share=False)

docker-compose.yml

@@ -0,0 +1,17 @@
+version: '3.8'
+
+services:
+  code-review-agent:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: code-review-agent
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./reports:/app/reports
+      - ./logs:/app/logs
+      - ./.env:/app/.env
+    environment:
+      - LOG_LEVEL=INFO
+    restart: unless-stopped

modal_deploy.py

@@ -0,0 +1,64 @@
+# modal_deploy.py
+from modal import Image, Stub, asgi_app
+import sys
+
+# Create a Modal image with the required dependencies
+image = Image.debian_slim().pip_install_from_requirements("requirements.txt")
+
+# Create a Modal Stub
+stub = Stub("code-review-agent")
+
+@stub.function(image=image, timeout=600)
+@asgi_app()
+def app():
+    """
+    Deploy the Code Review Agent as an ASGI app on Modal.
+    
+    This function sets up the Gradio application and returns it as an ASGI app
+    that Modal can serve. The app will be accessible via a URL provided by Modal
+    after deployment.
+    
+    Returns:
+        ASGI application: The Gradio app as an ASGI application
+    """
+    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.dirname(__file__)))
+
+    # Import application modules
+    from src.ui.gradio_app import create_gradio_app
+    from src.core.agent_manager import AgentManager
+
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+
+    # 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 the Gradio app
+    gradio_app = create_gradio_app(agent_manager)
+    
+    # Return the Gradio app as an ASGI app
+    return gradio_app.app
+
+
+if __name__ == "__main__":
+    # For local testing
+    stub.serve()
+    
+    # For deployment
+    # Run: modal deploy modal_deploy.py

requirements.txt

@@ -0,0 +1,37 @@
+# Code Review Agent Dependencies
+
+# Core Dependencies
+gradio
+requests
+gitpython
+python-dotenv
+
+# UI Dependencies
+markdown
+pydantic
+
+# Code Analysis
+astroid  # Python AST parsing
+pylint  # Python linting
+esprima  # JavaScript parsing
+jsbeautifier  # JavaScript formatting
+# Note: javascript-obfuscator was removed as it's not available on PyPI
+pyright  # TypeScript type checking
+
+# Security Analysis
+bandit  # Python security scanning
+safety  # Dependency vulnerability checking
+
+# Performance Analysis
+psutil  # System utilization
+memory-profiler  # Memory profiling
+
+# MCP Integration
+openai  # OpenAI API client for Nebius integration
+
+# Deployment
+modal
+
+
+pdfkit
+wkhtmltopdf

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,415 @@
+#!/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
+import threading
+import concurrent.futures
+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, progress_components=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.
+            progress_components (tuple, optional): Tuple containing (progress_group, overall_progress, status_message, step_progress)
+                                                  from create_progress_tracker().
+        
+        Returns:
+            tuple: (progress_group, overall_progress, status_message, results_dashboard) - Updated UI components.
+        """
+        # Initialize or use provided progress components
+        if progress_components:
+            progress_group, overall_progress, status_message, step_progress = progress_components
+        else:
+            progress_group = gr.Group(visible=True)
+            overall_progress = gr.Slider(value=0)
+            status_message = gr.Markdown("*Starting review...*")
+            step_progress = {}
+        
+        try:
+            # Initialize state
+            self.state = {
+                'repo_url': repo_url,
+                'progress': {},
+                'results': {},
+                'current_step': None
+            }
+            # Store step progress components
+            self.step_progress = step_progress
+            
+            # 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)
+            
+            # Initialize progress for all steps
+            self._update_progress("Code Analysis", 0, overall_progress, status_message)
+            self._update_progress("Security Scanning", 0, overall_progress, status_message)
+            self._update_progress("Performance Analysis", 0, overall_progress, status_message)
+            self._update_progress("AI Review", 0, overall_progress, status_message)
+            
+            # Create a thread lock for updating shared state
+            lock = threading.Lock()
+            results = {}
+            
+            # Define worker functions for each analysis type
+            def run_code_analysis():
+                try:
+                    code_results = self.code_analyzer.analyze_repository(repo_path, languages)
+                    with lock:
+                        results['code_analysis'] = code_results
+                    self._update_progress("Code Analysis", 100, overall_progress, status_message)
+                except Exception as e:
+                    logger.error(f"Error in code analysis thread: {e}")
+                    with lock:
+                        results['code_analysis'] = {'status': 'error', 'error': str(e)}
+                    self._update_progress("Code Analysis", 100, overall_progress, status_message)
+            
+            def run_security_scan():
+                try:
+                    security_results = self.security_scanner.scan_repository(repo_path, languages)
+                    with lock:
+                        results['security'] = security_results
+                    self._update_progress("Security Scanning", 100, overall_progress, status_message)
+                except Exception as e:
+                    logger.error(f"Error in security scanning thread: {e}")
+                    with lock:
+                        results['security'] = {'status': 'error', 'error': str(e)}
+                    self._update_progress("Security Scanning", 100, overall_progress, status_message)
+            
+            def run_performance_analysis():
+                try:
+                    perf_results = self.performance_analyzer.analyze_repository(repo_path, languages)
+                    with lock:
+                        results['performance'] = perf_results
+                    self._update_progress("Performance Analysis", 100, overall_progress, status_message)
+                except Exception as e:
+                    logger.error(f"Error in performance analysis thread: {e}")
+                    with lock:
+                        results['performance'] = {'status': 'error', 'error': str(e)}
+                    self._update_progress("Performance Analysis", 100, overall_progress, status_message)
+            
+            def run_ai_review():
+                try:
+                    ai_results = self._perform_ai_review(repo_path, languages)
+                    with lock:
+                        results['ai_review'] = ai_results
+                    self._update_progress("AI Review", 100, overall_progress, status_message)
+                except Exception as e:
+                    logger.error(f"Error in AI review thread: {e}")
+                    with lock:
+                        results['ai_review'] = {'status': 'error', 'error': str(e)}
+                    self._update_progress("AI Review", 100, overall_progress, status_message)
+            
+            # Run all analysis tasks in parallel using ThreadPoolExecutor
+            with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
+                executor.submit(run_code_analysis)
+                executor.submit(run_security_scan)
+                executor.submit(run_performance_analysis)
+                executor.submit(run_ai_review)
+                
+                # Wait for all tasks to complete
+                executor.shutdown(wait=True)
+            
+            # Update the state with all results
+            with lock:
+                self.state['results'].update(results)
+            
+            # Get repository info
+            repo_info = self.repository_service.get_repository_info(repo_path)
+            self.state['results']['repository_info'] = repo_info
+            
+            # 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.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.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 with parallel processing.
+        
+        Args:
+            repo_path (str): The path to the repository.
+            languages (list): List of programming languages to analyze.
+        
+        Returns:
+            dict: AI review results.
+        """
+        try:
+            # Import and use the AI review service
+            from src.mcp.ai_review import AIReviewService
+            import os
+            
+            ai_reviewer = AIReviewService()
+            
+            # Check if AI review is available
+            if not ai_reviewer.is_available():
+                logger.warning("AI review service is not available. Please set NEBIUS_API_KEY in environment variables.")
+                return {
+                    'error': 'AI review service is not available. Please set NEBIUS_API_KEY in environment variables.',
+                    'suggestions': [],
+                    'issues': []
+                }
+            
+            # Get all files in the repository
+            all_files = []
+            language_extensions = {
+                'Python': ['.py'],
+                'JavaScript': ['.js'],
+                'TypeScript': ['.ts', '.tsx'],
+                'Java': ['.java'],
+                'Go': ['.go'],
+                'Rust': ['.rs']
+            }
+            
+            # Create a list of extensions to look for based on selected languages
+            extensions_to_check = []
+            for lang in languages:
+                if lang in language_extensions:
+                    extensions_to_check.extend(language_extensions[lang])
+            
+            # Find all files with the specified extensions
+            for root, _, files in os.walk(repo_path):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    _, ext = os.path.splitext(file_path)
+                    if ext in extensions_to_check:
+                        all_files.append(file_path)
+            
+            # Limit the number of files to review to avoid excessive processing
+            max_files = 20
+            if len(all_files) > max_files:
+                logger.warning(f"Too many files to review ({len(all_files)}). Limiting to {max_files} files.")
+                all_files = all_files[:max_files]
+            
+            # Process files in parallel
+            # Pass None for the optional analysis_results parameter
+            results = ai_reviewer.review_repository(repo_path, all_files, languages, None)
+            
+            logger.info(f"AI review completed for {len(all_files)} files across {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=None, status_message=None):
+        """Update progress for a specific step and overall progress."""
+        # Update state
+        self.state['current_step'] = step
+        self.state['progress'][step] = value
+        
+        # Calculate overall progress
+        total_steps = len(self.state['progress'])
+        if total_steps > 0:
+            overall = sum(self.state['progress'].values()) / total_steps
+        else:
+            overall = 0
+        
+        # Update UI components if provided
+        if overall_progress is not None:
+            overall_progress.value = overall
+        if status_message is not None:
+            status_message.value = f"*Progress update: {step} - {value}% (Overall: {overall:.1f}%)*"
+        
+        # Update step progress if available
+        if hasattr(self, 'step_progress') and step in self.step_progress:
+            self.step_progress[step].value = value
+        
+        # Log progress
+        logger.info(f"Progress update: {step} - {value}% (Overall: {overall:.1f}%)")
+    
+    def _create_results_dashboard(self, report):
+        """
+        Create a results dashboard component for the UI.
+        
+        Args:
+            report (dict): The code review report.
+        
+        Returns:
+            gr.Tabs: A Gradio results dashboard component.
+            
+        """
+        # Import the create_results_dashboard function from the UI components
+        from src.ui.components.results_dashboard import create_results_dashboard
+        
+        # Create a new results dashboard component
+        results_dashboard = create_results_dashboard()
+        
+        # Set the visibility to True
+        results_dashboard.visible = True
+        
+        # In a full implementation, we would populate the dashboard with data from the report
+        # For now, we're just returning the empty dashboard component
+        
+        return results_dashboard

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,479 @@
+#!/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
+import concurrent.futures
+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 with parallel processing.
+        
+        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} with {len(files)} files")
+        
+        # Limit the number of files to review to avoid excessive API usage
+        max_files = 20
+        if len(files) > max_files:
+            logger.warning(f"Too many files to review ({len(files)}). Limiting to {max_files} files.")
+            files = files[:max_files]
+        
+        # Function to review a single file
+        def review_file(file_path):
+            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)
+                    return file_path, review_result
+                return file_path, {
+                    'status': 'error',
+                    'error': f'Unsupported language for file {file_path}',
+                    'suggestions': [],
+                }
+            
+            except Exception as e:
+                logger.error(f"Error reviewing file {file_path}: {e}")
+                return file_path, {
+                    'status': 'error',
+                    'error': str(e),
+                    'suggestions': [],
+                }
+        
+        # Review files in parallel using ThreadPoolExecutor
+        reviews = {}
+        with concurrent.futures.ThreadPoolExecutor(max_workers=min(5, len(files))) as executor:
+            # Submit all file review tasks
+            future_to_file = {executor.submit(review_file, file_path): file_path for file_path in files}
+            
+            # Process results as they complete
+            for future in concurrent.futures.as_completed(future_to_file):
+                file_path = future_to_file[future]
+                try:
+                    path, result = future.result()
+                    reviews[path] = result
+                    logger.info(f"Completed review for {path}")
+                except Exception as e:
+                    logger.error(f"Exception occurred during review of {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
+    
+    # The review_repository method is already implemented above
+
+    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,773 @@
+#!/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
+import concurrent.futures
+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 using parallel processing.
+        
+        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 = {}
+        
+        # Define a function to analyze a single language
+        def analyze_language(language):
+            if language in self.analyzers:
+                try:
+                    logger.info(f"Analyzing {language} code in {repo_path}")
+                    return language, self.analyzers[language](repo_path)
+                except Exception as e:
+                    logger.error(f"Error analyzing {language} code: {e}")
+                    return language, {
+                        'status': 'error',
+                        'error': str(e),
+                        'issues': [],
+                    }
+            else:
+                logger.warning(f"No analyzer available for {language}")
+                return language, {
+                    'status': 'not_supported',
+                    'message': f"Analysis for {language} is not supported yet.",
+                    'issues': [],
+                }
+        
+        # Use ThreadPoolExecutor to analyze languages in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=min(len(languages), 5)) as executor:
+            # Submit all language analysis tasks
+            future_to_language = {executor.submit(analyze_language, language): language for language in languages}
+            
+            # Process results as they complete
+            for future in concurrent.futures.as_completed(future_to_language):
+                language = future_to_language[future]
+                try:
+                    lang, result = future.result()
+                    results[lang] = result
+                    logger.info(f"Completed analysis for {lang}")
+                except Exception as e:
+                    logger.error(f"Exception occurred during analysis of {language}: {e}")
+                    results[language] = {
+                        'status': 'error',
+                        'error': str(e),
+                        '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 = [
+                'python',
+                '-m',
+                '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,774 @@
+#!/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
+import subprocess
+import json
+import concurrent.futures
+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 using parallel processing.
+        
+        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 = {}
+        
+        # Define a function to analyze a single language
+        def analyze_language(language):
+            if language in self.analyzers:
+                try:
+                    logger.info(f"Analyzing {language} code performance in {repo_path}")
+                    return language, self.analyzers[language](repo_path)
+                except Exception as e:
+                    logger.error(f"Error analyzing {language} code performance: {e}")
+                    return language, {
+                        'status': 'error',
+                        'error': str(e),
+                        'issues': [],
+                    }
+            else:
+                logger.warning(f"No performance analyzer available for {language}")
+                return language, {
+                    'status': 'not_supported',
+                    'message': f"Performance analysis for {language} is not supported yet.",
+                    'issues': [],
+                }
+        
+        # Use ThreadPoolExecutor to analyze languages in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=min(len(languages), 5)) as executor:
+            # Submit all language analysis tasks
+            future_to_language = {executor.submit(analyze_language, language): language for language in languages}
+            
+            # Process results as they complete
+            for future in concurrent.futures.as_completed(future_to_language):
+                language = future_to_language[future]
+                try:
+                    lang, result = future.result()
+                    results[lang] = result
+                    logger.info(f"Completed performance analysis for {lang}")
+                except Exception as e:
+                    logger.error(f"Exception occurred during performance analysis of {language}: {e}")
+                    results[language] = {
+                        'status': 'error',
+                        'error': str(e),
+                        '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,782 @@
+#!/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 and metrics
+        repo_info = results.get("repository_info", {})
+        total_files = repo_info.get("file_count", 0)
+        repo_size = repo_info.get("size_bytes", 0)
+        
+        # Extract code analysis results
+        code_analysis = results.get("code_analysis", {})
+        total_code_issues = sum(len(lang_result.get("issues", [])) for lang_result in code_analysis.values())
+        critical_code_issues = sum(1 for lang_result in code_analysis.values()
+                                 for issue in lang_result.get("issues", [])
+                                 if issue.get("severity", "").lower() == "critical")
+        
+        # Extract security scan results
+        security_scan = results.get("security", {})
+        total_vulnerabilities = sum(len(lang_result.get("vulnerabilities", []))
+                                   for lang_result in security_scan.get("vulnerabilities_by_language", {}).values())
+        critical_vulnerabilities = len(security_scan.get("critical_vulnerabilities", []))
+        
+        # Extract performance analysis results
+        performance_analysis = results.get("performance", {})
+        total_performance_issues = sum(len(lang_result.get("issues", []))
+                                      for lang_result in performance_analysis.get("issues_by_language", {}).values())
+        performance_hotspots = len(performance_analysis.get("hotspots", []))
+        
+        # Calculate overall score and rating
+        max_score = 100
+        deductions = {
+            "code_issues": total_code_issues * 2,
+            "critical_code_issues": critical_code_issues * 5,
+            "vulnerabilities": total_vulnerabilities * 3,
+            "critical_vulnerabilities": critical_vulnerabilities * 10,
+            "performance_issues": total_performance_issues * 2,
+            "performance_hotspots": performance_hotspots * 3
+        }
+        overall_score = max(0, max_score - sum(deductions.values()))
+        
+        quality_ratings = [
+            (95, "Excellent"),
+            (85, "Very Good"),
+            (75, "Good"),
+            (65, "Fair"),
+            (0, "Poor")
+        ]
+        quality_rating = next(rating for threshold, rating in quality_ratings if overall_score >= threshold)
+        
+        # Extract language breakdown
+        language_breakdown = {}
+        for language in code_analysis.keys():
+            if code_analysis[language].get("status") != "error":
+                language_breakdown[language] = {
+                    "files": len([f for f in code_analysis[language].get("issues", []) if "file" in f]),
+                    "lines": code_analysis[language].get("total_lines", 0),
+                    "percentage": code_analysis[language].get("percentage", 0),
+                    "issues": len(code_analysis[language].get("issues", []))
+                }
+        
+        # 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)?$',        # [email protected]: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('[email protected]:'):
+            user_repo = url[len('[email protected]:'):]
+            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,831 @@
+#!/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
+import concurrent.futures
+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 using parallel processing.
+        
+        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)
+        
+        # Define a function to scan a single language
+        def scan_language(language):
+            if language in self.scanners:
+                try:
+                    logger.info(f"Scanning {language} code in {repo_path} for security vulnerabilities")
+                    return language, self.scanners[language](repo_path)
+                except Exception as e:
+                    logger.error(f"Error scanning {language} code for security vulnerabilities: {e}")
+                    return language, {
+                        'status': 'error',
+                        'error': str(e),
+                        'vulnerabilities': [],
+                    }
+            else:
+                logger.warning(f"No security scanner available for {language}")
+                return language, {
+                    'status': 'not_supported',
+                    'message': f"Security scanning for {language} is not supported yet.",
+                    'vulnerabilities': [],
+                }
+        
+        # Use ThreadPoolExecutor to scan languages in parallel
+        with concurrent.futures.ThreadPoolExecutor(max_workers=min(len(languages), 5)) as executor:
+            # Submit all language scanning tasks
+            future_to_language = {executor.submit(scan_language, language): language for language in languages}
+            
+            # Process results as they complete
+            for future in concurrent.futures.as_completed(future_to_language):
+                language = future_to_language[future]
+                try:
+                    lang, result = future.result()
+                    results[lang] = result
+                    logger.info(f"Completed security scanning for {lang}")
+                except Exception as e:
+                    logger.error(f"Exception occurred during security scanning of {language}: {e}")
+                    results[language] = {
+                        'status': 'error',
+                        'error': str(e),
+                        '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,110 @@
+#!/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.Tabs: The results dashboard component tabs.
+    """
+    # Create a Tabs component directly instead of wrapping in a Group
+    results_tabs = gr.Tabs(visible=False)
+    
+    # Executive Summary Tab
+    with results_tabs:
+        with gr.TabItem("Executive Summary"):
+            gr.Markdown("### 📊 Analysis Results")
+            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.TabItem("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.TabItem("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.TabItem("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.TabItem("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_tabs

src/ui/gradio_app.py

@@ -0,0 +1,130 @@
+#!/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
+        def start_review_with_progress(repo_url, github_token, selected_languages):
+            # We can't use Group objects as outputs, so we'll handle visibility differently
+            # First, make progress group visible and results dashboard invisible
+            progress_group.visible = True
+            results_dashboard.visible = False
+            
+            # Start review process
+            progress_components = (progress_group, overall_progress, status_message, step_progress)
+            try:
+                _, _, _, results = agent_manager.start_review(repo_url, github_token, selected_languages, progress_components)
+                
+                # Hide progress group and show results dashboard when done
+                progress_group.visible = False
+                results_dashboard.visible = True
+                
+                return [
+                    0,     # reset overall_progress value
+                    "*Analysis complete!*",  # status_message value
+                    results  # results dashboard with data
+                ]
+            except Exception as e:
+                # Show error message but keep progress group visible
+                return [
+                    0,      # reset overall_progress value
+                    f"*Error: {str(e)}*",  # error message
+                    results_dashboard  # keep current dashboard
+                ]
+
+        submit_btn.click(
+            fn=start_review_with_progress,
+            inputs=[repo_url, github_token, selected_languages],
+            outputs=[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("[email protected]: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("[email protected]:user/repo.git"),
+            "https://github.com/user/repo.git"
+        )
+        self.assertEqual(
+            normalize_github_url("[email protected]: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("[email protected]: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()