Initial commit: LLM Code Analyzer with multi-model support

.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+env/
+
+# Environment variables
+.env
+.env.local
+.env.production
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Streamlit
+.streamlit/secrets.toml
+
+# Test files
+test_analyzer.py
+test_results.txt
+
+# Deployment
+render.yaml.bak
+netlify.toml.bak 

.streamlit/config.toml

@@ -0,0 +1,11 @@
+[server]
+headless = true
+port = 8501
+enableCORS = false
+enableXsrfProtection = false
+
+[theme]
+primaryColor = "#FF6B6B"
+backgroundColor = "#0E1117"
+secondaryBackgroundColor = "#262730"
+textColor = "#FAFAFA" 

API_SETUP.md

@@ -0,0 +1,44 @@
+# API Setup Guide
+
+## Setting up DeepSeek API Key
+
+1. **Get your DeepSeek API Key**:
+   - Go to [DeepSeek Console](https://platform.deepseek.com/)
+   - Sign up or log in
+   - Navigate to API Keys section
+   - Create a new API key
+
+2. **Add the key to your environment**:
+   - Create a `.env` file in your project root
+   - Add: `DEEPSEEK_API_KEY=your_actual_api_key_here`
+   - **Important**: Use your real API key, not placeholder text like `****`
+
+3. **Other supported APIs**:
+   ```
+   OPENAI_API_KEY=your_openai_key_here
+   ANTHROPIC_API_KEY=your_claude_key_here
+   GEMINI_API_KEY=your_gemini_key_here
+   ```
+
+## Common Issues & Solutions
+
+### DeepSeek Authentication Error (401)
+- **Problem**: Error message "Authentication Fails, Your api key: ****here is invalid"
+- **Solution**: 
+  1. Double-check your API key is correct
+  2. Make sure there are no extra spaces or quotes
+  3. Verify the key is active in DeepSeek console
+  4. Try regenerating the API key
+
+### Button Not Clickable
+- **Fixed**: The "Analyze Code" button is now always clickable
+- **Usage**: Just paste your code and click "Analyze Code"
+- No need to wait for any delays
+
+## Running the Application
+
+```bash
+python -m streamlit run matrix_final.py --server.port 8500
+```
+
+Access at: http://localhost:8500 

Procfile

@@ -0,0 +1 @@
+web: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0 

README.md

@@ -0,0 +1,234 @@
+# LLM Code Analyzer
+
+A professional code analysis tool that leverages multiple Large Language Models (LLMs) to provide comprehensive code reviews, identify issues, and suggest improvements.
+
+![LLM Code Analyzer](https://img.shields.io/badge/Python-3.11+-blue.svg)
+![Streamlit](https://img.shields.io/badge/Streamlit-1.36.0-red.svg)
+![License](https://img.shields.io/badge/License-MIT-green.svg)
+
+## ✨ Features
+
+- **🤖 Multi-Model Analysis**: Compare insights from OpenAI GPT-4, Anthropic Claude, Google Gemini, and DeepSeek
+- **📊 Comprehensive Code Review**: Get quality scores, identify bugs, security issues, and performance concerns
+- **🔍 Language Auto-Detection**: Automatically detects programming language or manually specify
+- **🎨 Clean Professional UI**: Built with Streamlit for a modern, responsive interface
+- **⚡ Lightweight & Fast**: Optimized for deployment on platforms like Render
+- **🔒 Secure**: API keys are securely managed through environment variables
+- **📈 Real-time Metrics**: Track analysis time, quality scores, and model comparisons
+- **🤝 Consensus Analysis**: Identify issues that multiple models agree on
+
+## 🌐 Live Demo
+
+[Try it on Render](https://your-app-name.onrender.com) *(Coming Soon)*
+
+## 🛠️ Tech Stack
+
+- **Frontend**: Streamlit
+- **LLM Integration**: OpenAI, Anthropic, Google Gemini, DeepSeek APIs
+- **Language**: Python 3.11+
+- **Deployment**: Render (or any Python hosting platform)
+
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.11 or higher
+- API keys for at least one LLM provider:
+  - OpenAI API Key
+  - Anthropic API Key
+  - Google Gemini API Key
+  - DeepSeek API Key
+
+### Installation
+
+1. **Clone the repository:**
+```bash
+git clone https://github.com/yourusername/llm-code-analyzer.git
+cd llm-code-analyzer
+```
+
+2. **Create a virtual environment:**
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+3. **Install dependencies:**
+```bash
+pip install -r requirements.txt
+```
+
+4. **Configure environment variables:**
+   
+   Copy the `.env` file and add your API keys:
+```bash
+cp .env .env.local
+```
+
+Edit `.env.local` with your actual API keys:
+```env
+# API Keys - Replace with your actual API keys
+OPENAI_API_KEY=your_openai_api_key_here
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+GEMINI_API_KEY=your_google_api_key_here
+DEEPSEEK_API_KEY=your_deepseek_api_key_here
+```
+
+5. **Run the application:**
+```bash
+streamlit run app.py
+```
+
+The application will be available at `http://localhost:8501`
+
+## 📋 Usage
+
+### Single Model Analysis
+1. Paste your code in the left panel
+2. Select a specific LLM model from the dropdown
+3. Choose the programming language (or use auto-detect)
+4. Click "🚀 Analyze Code"
+
+### Multi-Model Comparison
+1. Paste your code in the left panel
+2. Check "Compare All Models"
+3. Click "🚀 Analyze Code"
+4. View results in separate tabs for each model
+5. See consensus issues identified by multiple models
+
+### Sample Code
+Use the "Sample Code" section in the sidebar to quickly load example Python or JavaScript code for testing.
+
+## 🏗️ Project Structure
+
+```
+llm-code-analyzer/
+├── .env                    # Environment variables template
+├── .gitignore             # Git ignore patterns
+├── requirements.txt       # Python dependencies
+├── README.md             # This file
+├── app.py                # Main Streamlit application
+└── analyzer/
+    ├── __init__.py       # Package initialization
+    ├── llm_clients.py    # LLM API client implementations
+    ├── code_analyzer.py  # Main analysis engine
+    ├── prompts.py        # Analysis prompt templates
+    └── utils.py          # Utility functions
+```
+
+## 🔧 Configuration
+
+### Supported LLM Providers
+
+| Provider | Model | API Key Environment Variable |
+|----------|-------|------------------------------|
+| OpenAI | GPT-4o-mini | `OPENAI_API_KEY` |
+| Anthropic | Claude 3 Haiku | `ANTHROPIC_API_KEY` |
+| Google | Gemini Pro | `GEMINI_API_KEY` |
+| DeepSeek | DeepSeek Chat | `DEEPSEEK_API_KEY` |
+
+### Supported Programming Languages
+
+- Python
+- JavaScript
+- Java
+- C++
+- C#
+- Go
+- Rust
+- And more (auto-detection available)
+
+## 🚀 Deployment
+
+### Deploy to Render
+
+1. Fork this repository
+2. Create a new Web Service on [Render](https://render.com)
+3. Connect your GitHub repository
+4. Configure environment variables in Render dashboard
+5. Deploy with these settings:
+   - **Build Command**: `pip install -r requirements.txt`
+   - **Start Command**: `streamlit run app.py --server.port=$PORT --server.address=0.0.0.0`
+
+### Deploy to Heroku
+
+1. Install the Heroku CLI
+2. Create a `Procfile`:
+```
+web: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+```
+3. Deploy:
+```bash
+heroku create your-app-name
+heroku config:set OPENAI_API_KEY=your_key_here
+heroku config:set ANTHROPIC_API_KEY=your_key_here
+# ... add other API keys
+git push heroku main
+```
+
+### Deploy to Railway
+
+1. Connect your GitHub repository to Railway
+2. Set environment variables in Railway dashboard
+3. Deploy automatically on push
+
+## 🧪 Development
+
+### Running Tests
+```bash
+python -m pytest tests/
+```
+
+### Code Formatting
+```bash
+black analyzer/ app.py
+```
+
+### Type Checking
+```bash
+mypy analyzer/
+```
+
+## 📊 Analysis Output
+
+The tool provides structured analysis including:
+
+- **Quality Score**: 0-100 rating of code quality
+- **Summary**: Brief description of the code's purpose
+- **Strengths**: What the code does well
+- **Issues**: Potential bugs and problems
+- **Suggestions**: Specific improvement recommendations
+- **Security Concerns**: Potential security vulnerabilities
+- **Performance Notes**: Performance optimization opportunities
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add 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.
+
+## 🙏 Acknowledgments
+
+- [Streamlit](https://streamlit.io/) for the amazing framework
+- [OpenAI](https://openai.com/) for GPT models
+- [Anthropic](https://anthropic.com/) for Claude
+- [Google](https://ai.google.dev/) for Gemini
+- [DeepSeek](https://www.deepseek.com/) for DeepSeek Coder
+
+## 📞 Support
+
+If you encounter any issues or have questions:
+
+1. Check the [Issues](https://github.com/yourusername/llm-code-analyzer/issues) page
+2. Create a new issue with detailed information
+3. Contact the maintainers
+
+---
+
+**Built with ❤️ by [Your Name](https://github.com/yourusername)** 

analyzer/__init__.py

@@ -0,0 +1,4 @@
+from .code_analyzer import CodeAnalyzer
+from .llm_clients import LLMClientManager
+
+__all__ = ['CodeAnalyzer', 'LLMClientManager'] 

analyzer/code_analyzer.py

@@ -0,0 +1,335 @@
+from typing import Dict, Any, List, Optional
+import time
+import requests
+import os
+import re
+from .llm_clients import LLMClientManager, LLMResponse
+from .prompts import get_code_analysis_prompt, get_comparison_prompt, get_github_analysis_prompt
+from .utils import detect_language, parse_analysis_result
+
+class CodeAnalyzer:
+    """Main code analysis engine with GitHub integration."""
+    
+    def __init__(self):
+        self.llm_manager = LLMClientManager()
+        self.available_models = self.llm_manager.get_available_models()
+    
+    def analyze_code(self, code: str, model: str, language: Optional[str] = None) -> Dict[str, Any]:
+        """Analyze code using a specific model with focused output."""
+        start_time = time.time()
+        
+        # Detect language if not provided
+        if not language:
+            language = detect_language(code)
+        
+        # Generate focused prompt
+        prompt = get_code_analysis_prompt(code, language)
+        
+        # Query LLM
+        response = self.llm_manager.query(model, prompt)
+        
+        # Process response
+        if response.success:
+            analysis = parse_analysis_result(response.content)
+            analysis['raw_response'] = response.content
+        else:
+            analysis = {
+                'error': response.error,
+                'quality_score': 0,
+                'summary': f"Analysis failed: {response.error}",
+                'bugs': [],
+                'quality_issues': [],
+                'security_vulnerabilities': [],
+                'quick_fixes': [],
+                # Legacy fields
+                'strengths': [],
+                'issues': [],
+                'suggestions': [],
+                'security_concerns': [],
+                'performance_notes': []
+            }
+        
+        # Add metadata
+        analysis['model'] = response.model
+        analysis['language'] = language
+        analysis['execution_time'] = round(time.time() - start_time, 2)
+        analysis['code_length'] = len(code)
+        analysis['line_count'] = len(code.splitlines())
+        
+        return analysis
+    
+    def analyze_github_repo(self, repo_url: str, model: str = None) -> Dict[str, Any]:
+        """Analyze a GitHub repository."""
+        start_time = time.time()
+        
+        # Use first available model if none specified
+        if not model or model not in self.available_models:
+            model = list(self.available_models.keys())[0]
+        
+        try:
+            # Parse GitHub URL
+            if not repo_url.startswith('https://github.com/'):
+                return {'error': 'Please provide a valid GitHub repository URL'}
+            
+            # Extract owner and repo
+            parts = repo_url.replace('https://github.com/', '').split('/')
+            if len(parts) < 2:
+                return {'error': 'Invalid GitHub repository URL format'}
+            
+            owner, repo = parts[0], parts[1]
+            
+            # Get repository structure and key files
+            repo_data = self._fetch_github_repo_data(owner, repo)
+            if 'error' in repo_data:
+                return repo_data
+            
+            # Generate analysis prompt
+            prompt = get_github_analysis_prompt(
+                repo_data['structure'], 
+                repo_data['main_files']
+            )
+            
+            # Query LLM
+            response = self.llm_manager.query(model, prompt)
+            
+            if response.success:
+                analysis = self._parse_github_analysis(response.content)
+                analysis['raw_response'] = response.content
+                analysis['repository_info'] = repo_data['info']
+            else:
+                analysis = {
+                    'error': response.error,
+                    'project_overview': f"Analysis failed: {response.error}",
+                    'architecture_quality': [],
+                    'critical_issues': [],
+                    'improvement_priorities': []
+                }
+            
+            # Add metadata
+            analysis['model'] = response.model
+            analysis['execution_time'] = round(time.time() - start_time, 2)
+            analysis['repo_url'] = repo_url
+            
+            return analysis
+            
+        except Exception as e:
+            return {
+                'error': f"GitHub analysis failed: {str(e)}",
+                'execution_time': round(time.time() - start_time, 2)
+            }
+    
+    def _fetch_github_repo_data(self, owner: str, repo: str) -> Dict[str, Any]:
+        """Fetch repository data from GitHub API."""
+        try:
+            # GitHub API endpoints
+            api_base = f"https://api.github.com/repos/{owner}/{repo}"
+            
+            # Get repository info
+            headers = {}
+            if os.getenv('GITHUB_TOKEN'):
+                headers['Authorization'] = f"token {os.getenv('GITHUB_TOKEN')}"
+            
+            repo_response = requests.get(api_base, headers=headers)
+            if repo_response.status_code != 200:
+                return {'error': f'Repository not found or private: {owner}/{repo}'}
+            
+            repo_info = repo_response.json()
+            
+            # Get file tree
+            tree_response = requests.get(f"{api_base}/git/trees/main?recursive=1", headers=headers)
+            if tree_response.status_code != 200:
+                # Try master branch
+                tree_response = requests.get(f"{api_base}/git/trees/master?recursive=1", headers=headers)
+            
+            if tree_response.status_code != 200:
+                return {'error': 'Could not fetch repository structure'}
+            
+            tree_data = tree_response.json()
+            
+            # Build structure and get key files
+            structure = self._build_repo_structure(tree_data['tree'])
+            main_files = self._get_key_files(owner, repo, tree_data['tree'], headers)
+            
+            return {
+                'info': {
+                    'name': repo_info['name'],
+                    'description': repo_info.get('description', 'No description'),
+                    'language': repo_info.get('language', 'Unknown'),
+                    'stars': repo_info.get('stargazers_count', 0),
+                    'forks': repo_info.get('forks_count', 0),
+                    'size': repo_info.get('size', 0)
+                },
+                'structure': structure,
+                'main_files': main_files
+            }
+            
+        except Exception as e:
+            return {'error': f'Failed to fetch repository data: {str(e)}'}
+    
+    def _build_repo_structure(self, tree: List[Dict]) -> str:
+        """Build a readable repository structure."""
+        structure_lines = []
+        dirs = set()
+        
+        for item in tree[:50]:  # Limit to first 50 items
+            if item['type'] == 'tree':
+                dirs.add(item['path'])
+            else:
+                structure_lines.append(f"📄 {item['path']}")
+        
+        for dir_path in sorted(dirs):
+            structure_lines.append(f"📁 {dir_path}/")
+        
+        return '\n'.join(structure_lines[:30])  # Limit output
+    
+    def _get_key_files(self, owner: str, repo: str, tree: List[Dict], headers: Dict) -> str:
+        """Get content of key files like README, main source files."""
+        key_files = []
+        
+        # Priority files to analyze
+        priority_patterns = [
+            'README.md', 'readme.md', 'README.txt',
+            'package.json', 'requirements.txt', 'Cargo.toml', 'go.mod',
+            'main.py', 'index.js', 'main.js', 'app.py', 'server.js'
+        ]
+        
+        for item in tree:
+            if item['type'] == 'blob':
+                filename = item['path'].split('/')[-1]
+                
+                # Check if it's a priority file
+                if filename in priority_patterns or any(
+                    pattern in filename.lower() for pattern in ['main', 'index', 'app']
+                ):
+                    try:
+                        file_response = requests.get(
+                            f"https://api.github.com/repos/{owner}/{repo}/contents/{item['path']}", 
+                            headers=headers
+                        )
+                        if file_response.status_code == 200:
+                            file_data = file_response.json()
+                            if file_data.get('encoding') == 'base64':
+                                import base64
+                                content = base64.b64decode(file_data['content']).decode('utf-8', errors='ignore')
+                                key_files.append(f"\n--- {item['path']} ---\n{content[:1000]}")  # First 1000 chars
+                    except:
+                        continue
+                
+                if len(key_files) >= 5:  # Limit to 5 key files
+                    break
+        
+        return '\n'.join(key_files)
+    
+    def _parse_github_analysis(self, text: str) -> Dict[str, Any]:
+        """Parse GitHub repository analysis results."""
+        result = {
+            'project_overview': '',
+            'architecture_quality': [],
+            'critical_issues': [],
+            'improvement_priorities': []
+        }
+        
+        sections = {
+            'project_overview': r'(?:PROJECT_OVERVIEW|project\s+overview)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+            'architecture_quality': r'(?:ARCHITECTURE_QUALITY|architecture|structure)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+            'critical_issues': r'(?:CRITICAL_ISSUES|critical|major\s+issue)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+            'improvement_priorities': r'(?:IMPROVEMENT_PRIORITIES|improvement|priorit)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)'
+        }
+        
+        for key, pattern in sections.items():
+            match = re.search(pattern, text, re.IGNORECASE | re.DOTALL)
+            if match:
+                content = match.group(1).strip()
+                
+                if key == 'project_overview':
+                    # Clean project overview
+                    clean_overview = content.split('\n')[0].strip()
+                    clean_overview = re.sub(r'#+\s*', '', clean_overview)  # Remove ### symbols
+                    clean_overview = re.sub(r'^\*+\s*', '', clean_overview)  # Remove ** symbols
+                    result[key] = clean_overview
+                else:
+                    # Extract and clean bullet points
+                    items = []
+                    lines = content.split('\n')
+                    for line in lines:
+                        line = line.strip()
+                        if line and not line.lower() in ['none', 'none found']:
+                            # Clean up markdown symbols and extra characters
+                            line = re.sub(r'#+\s*', '', line)  # Remove ### symbols
+                            line = re.sub(r'^\*+\s*', '', line)  # Remove ** symbols
+                            line = re.sub(r'^[-•*]\s*', '', line)  # Remove bullet markers
+                            line = re.sub(r'^[:\-\s]*', '', line)  # Remove colons and dashes
+                            
+                            if len(line) > 10:  # Only include substantial content
+                                items.append(line)
+                    
+                    # If no structured items found, try to extract sentences
+                    if not items and content.strip():
+                        sentences = re.split(r'[.!?]+', content)
+                        for sentence in sentences:
+                            clean_sentence = sentence.strip()
+                            clean_sentence = re.sub(r'#+\s*', '', clean_sentence)  # Remove ### symbols
+                            clean_sentence = re.sub(r'^\*+\s*', '', clean_sentence)  # Remove ** symbols
+                            if clean_sentence and len(clean_sentence) > 15:
+                                items.append(clean_sentence)
+                    
+                    result[key] = items[:4]  # Limit to 4 items per section
+        
+        return result
+    
+    def analyze_with_all_models(self, code: str, language: Optional[str] = None) -> Dict[str, Dict[str, Any]]:
+        """Analyze code using all available models."""
+        results = {}
+        
+        for model_key in self.available_models:
+            results[model_key] = self.analyze_code(code, model_key, language)
+        
+        return results
+    
+    def compare_analyses(self, results: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+        """Compare results from different models with focus on critical issues."""
+        comparison = {
+            'average_score': 0,
+            'consensus_bugs': [],
+            'consensus_security': [],
+            'model_scores': {},
+            'best_model': None,
+            'analysis_time': sum(r['execution_time'] for r in results.values())
+        }
+        
+        # Calculate average score and find best model
+        scores = []
+        for model, result in results.items():
+            if 'error' not in result:
+                score = result['quality_score']
+                scores.append(score)
+                comparison['model_scores'][model] = score
+        
+        if scores:
+            comparison['average_score'] = round(sum(scores) / len(scores), 1)
+            best_model = max(comparison['model_scores'].items(), key=lambda x: x[1])
+            comparison['best_model'] = best_model[0]
+        
+        # Find consensus on critical issues
+        all_bugs = []
+        all_security = []
+        
+        for result in results.values():
+            if 'error' not in result:
+                all_bugs.extend(result.get('bugs', []))
+                all_security.extend(result.get('security_vulnerabilities', []))
+        
+        # Simple consensus: issues mentioned by multiple models
+        def find_consensus(items):
+            consensus = []
+            for item in items:
+                if any(item.lower() in other.lower() or other.lower() in item.lower() 
+                      for other in items if other != item):
+                    if item not in consensus:
+                        consensus.append(item)
+            return consensus[:3]  # Top 3 consensus items
+        
+        comparison['consensus_bugs'] = find_consensus(all_bugs)
+        comparison['consensus_security'] = find_consensus(all_security)
+        
+        return comparison 

analyzer/llm_clients.py

@@ -0,0 +1,143 @@
+import os
+from typing import Optional, Dict, Any
+from dataclasses import dataclass
+import openai
+import anthropic
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+load_dotenv()
+
+@dataclass
+class LLMResponse:
+    content: str
+    model: str
+    success: bool
+    error: Optional[str] = None
+
+class LLMClientManager:
+    """Manages connections to different LLM providers."""
+    
+    def __init__(self):
+        self.clients = {}
+        self._initialize_clients()
+    
+    def _initialize_clients(self):
+        """Initialize available LLM clients based on API keys."""
+        # OpenAI
+        if os.getenv("OPENAI_API_KEY"):
+            self.clients["openai"] = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        
+        # Anthropic
+        if os.getenv("ANTHROPIC_API_KEY"):
+            self.clients["anthropic"] = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+        
+        # Google Gemini
+        if os.getenv("GEMINI_API_KEY"):
+            genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+            self.clients["gemini"] = genai.GenerativeModel('gemini-pro')
+        
+        # DeepSeek (uses OpenAI-compatible API)
+        if os.getenv("DEEPSEEK_API_KEY"):
+            self.clients["deepseek"] = openai.OpenAI(
+                api_key=os.getenv("DEEPSEEK_API_KEY"),
+                base_url="https://api.deepseek.com/v1"
+            )
+    
+    def get_available_models(self) -> Dict[str, str]:
+        """Return available models with display names."""
+        models = {}
+        if "openai" in self.clients:
+            models["openai"] = "OpenAI GPT-4"
+        if "anthropic" in self.clients:
+            models["anthropic"] = "Claude 3"
+        if "gemini" in self.clients:
+            models["gemini"] = "Google Gemini"
+        if "deepseek" in self.clients:
+            models["deepseek"] = "DeepSeek Coder"
+        return models
+    
+    def query(self, model: str, prompt: str, temperature: float = 0.1) -> LLMResponse:
+        """Query a specific LLM model."""
+        try:
+            if model == "openai" and "openai" in self.clients:
+                response = self.clients["openai"].chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=temperature
+                )
+                return LLMResponse(
+                    content=response.choices[0].message.content,
+                    model="OpenAI GPT-4",
+                    success=True
+                )
+            
+            elif model == "anthropic" and "anthropic" in self.clients:
+                response = self.clients["anthropic"].messages.create(
+                    model="claude-3-haiku-20240307",
+                    messages=[{"role": "user", "content": prompt}],
+                    max_tokens=2000,
+                    temperature=temperature
+                )
+                return LLMResponse(
+                    content=response.content[0].text,
+                    model="Claude 3 Haiku",
+                    success=True
+                )
+            
+            elif model == "gemini" and "gemini" in self.clients:
+                response = self.clients["gemini"].generate_content(prompt)
+                return LLMResponse(
+                    content=response.text,
+                    model="Google Gemini",
+                    success=True
+                )
+            
+            elif model == "deepseek" and "deepseek" in self.clients:
+                try:
+                    response = self.clients["deepseek"].chat.completions.create(
+                        model="deepseek-coder",
+                        messages=[{"role": "user", "content": prompt}],
+                        temperature=temperature
+                    )
+                    return LLMResponse(
+                        content=response.choices[0].message.content,
+                        model="DeepSeek Coder",
+                        success=True
+                    )
+                except Exception as deepseek_error:
+                    # Try with alternative model name if the first one fails
+                    try:
+                        response = self.clients["deepseek"].chat.completions.create(
+                            model="deepseek-chat",
+                            messages=[{"role": "user", "content": prompt}],
+                            temperature=temperature
+                        )
+                        return LLMResponse(
+                            content=response.choices[0].message.content,
+                            model="DeepSeek Coder",
+                            success=True
+                        )
+                    except Exception as second_error:
+                        return LLMResponse(
+                            content="",
+                            model="DeepSeek Coder",
+                            success=False,
+                            error=f"DeepSeek API Error: {str(deepseek_error)}. Also tried alternative model: {str(second_error)}"
+                        )
+            
+            else:
+                return LLMResponse(
+                    content="",
+                    model=model,
+                    success=False,
+                    error=f"Model {model} not available or not configured"
+                )
+                
+        except Exception as e:
+            return LLMResponse(
+                content="",
+                model=model,
+                success=False,
+                error=str(e)
+            ) 

analyzer/prompts.py

@@ -0,0 +1,88 @@
+def get_code_analysis_prompt(code: str, language: str = "auto-detect") -> str:
+    """Generate a focused prompt for practical code analysis."""
+    return f"""
+You are an expert code reviewer. Analyze this {language} code for practical issues that matter to developers.
+
+Code to analyze:
+{code}
+
+Provide a focused analysis with complete, readable sentences. Do NOT use markdown symbols like ### or ** in your response.
+
+1. QUALITY_SCORE: Rate 0-100 (consider bugs, readability, maintainability)
+
+2. SUMMARY: One complete sentence describing what this code does
+
+3. BUG_DETECTION: 
+   - List actual bugs or logical errors found
+   - Include potential crashes or exceptions
+   - Mention edge cases not handled
+   (Write complete sentences, skip if none found)
+
+4. CODE_QUALITY_ISSUES:
+   - Poor naming or structure problems
+   - Code readability issues  
+   - Maintainability concerns
+   (Focus on practical fixes, write complete sentences)
+
+5. SECURITY_VULNERABILITIES:
+   - Injection risks (SQL, XSS, etc.)
+   - Insecure data handling
+   - Authentication/authorization flaws
+   (Only include actual security risks, write complete sentences)
+
+6. QUICK_FIXES: 
+   - Top 3 specific improvements with examples
+   - Focus on high-impact, easy changes
+   - Write complete actionable sentences
+
+Format each section as clear, complete sentences. Be specific and actionable. Skip sections if no issues found.
+"""
+
+def get_github_analysis_prompt(repo_structure: str, main_files: str) -> str:
+    """Generate prompt for GitHub repository analysis."""
+    return f"""
+Analyze this GitHub repository structure and key files. Provide clear, complete analysis without using markdown symbols.
+
+Repository Structure:
+{repo_structure}
+
+Main Files Content:
+{main_files}
+
+Provide analysis focusing on:
+
+1. PROJECT_OVERVIEW: Write one clear sentence about what this project does
+
+2. ARCHITECTURE_QUALITY: 
+   - Project structure assessment (write complete sentences)
+   - Code organization quality (write complete sentences)
+   - Missing important files like tests, docs, etc. (write complete sentences)
+
+3. CRITICAL_ISSUES:
+   - Security vulnerabilities across files (write complete sentences)
+   - Major bugs or design flaws (write complete sentences)
+   - Dependencies/configuration problems (write complete sentences)
+
+4. IMPROVEMENT_PRIORITIES:
+   - Top 5 specific things to fix first (write complete sentences)
+   - Missing features or best practices (write complete sentences)
+   - Code quality improvements needed (write complete sentences)
+
+Write clear, complete sentences without markdown symbols. Be practical and focus on actionable feedback for the repository owner.
+"""
+
+def get_comparison_prompt(code: str, language: str = "auto-detect") -> str:
+    """Generate a prompt for multi-model comparison."""
+    return f"""
+As an expert code reviewer, analyze this {language} code:
+{code}
+
+Provide a concise but thorough analysis covering:
+- Main functionality
+- Code quality (rate 0-100)
+- Critical issues
+- Top 3 improvements
+- Security/performance concerns
+
+Be specific and actionable in your feedback.
+""" 

analyzer/utils.py

@@ -0,0 +1,232 @@
+import re
+from typing import Dict, Any, Tuple
+
+def detect_language(code: str) -> str:
+    """Simple language detection based on syntax patterns."""
+    patterns = {
+        'python': [r'def\s+\w+\(', r'import\s+\w+', r'if\s+__name__\s*==\s*["\']__main__["\']'],
+        'javascript': [r'function\s+\w+\(', r'const\s+\w+\s*=', r'console\.log\('],
+        'java': [r'public\s+class\s+\w+', r'public\s+static\s+void\s+main'],
+        'cpp': [r'#include\s*<\w+>', r'int\s+main\s*\(', r'std::'],
+        'csharp': [r'using\s+System', r'namespace\s+\w+', r'public\s+class\s+\w+'],
+        'go': [r'package\s+\w+', r'func\s+\w+\(', r'import\s+\('],
+        'rust': [r'fn\s+main\s*\(', r'use\s+\w+', r'let\s+mut\s+\w+'],
+    }
+    
+    for lang, patterns_list in patterns.items():
+        for pattern in patterns_list:
+            if re.search(pattern, code):
+                return lang
+    
+    return 'unknown'
+
+def parse_analysis_result(text: str) -> Dict[str, Any]:
+    """Parse LLM response into structured format with new focused categories."""
+    result = {
+        'quality_score': 75,  # default
+        'summary': '',
+        'bugs': [],
+        'quality_issues': [],
+        'security_vulnerabilities': [],
+        'quick_fixes': [],
+        # Legacy fields for compatibility
+        'strengths': [],
+        'issues': [],
+        'suggestions': [],
+        'security_concerns': [],
+        'performance_notes': []
+    }
+    
+    # Extract quality score
+    score_patterns = [
+        r'(?:QUALITY_SCORE|quality[_\s]*score)[:\s]*(\d+)(?:/100)?',
+        r'(?:score|rating)[:\s]*(\d+)(?:/100)?'
+    ]
+    
+    for pattern in score_patterns:
+        score_match = re.search(pattern, text, re.IGNORECASE)
+        if score_match:
+            result['quality_score'] = int(score_match.group(1))
+            break
+    
+    # Extract sections with new focused format
+    sections = {
+        # New focused sections
+        'summary': r'(?:SUMMARY|summary)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'bugs': r'(?:BUG_DETECTION|bug[s]?|logical\s+error)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'quality_issues': r'(?:CODE_QUALITY_ISSUES|quality\s+issue|readability)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'security_vulnerabilities': r'(?:SECURITY_VULNERABILITIES|security\s+vulnerabilit|security\s+risk)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'quick_fixes': r'(?:QUICK_FIXES|improvement|suggestion)[s]?[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        
+        # Legacy sections for backward compatibility
+        'strengths': r'(?:strength|positive|good)[s]?[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'issues': r'(?:issue|problem)[s]?[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'suggestions': r'(?:suggestion|recommendation)[s]?[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'security_concerns': r'(?:security\s+concern)[s]?[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)',
+        'performance_notes': r'(?:performance|optimization)[:\s]*(.+?)(?=\n\s*(?:\d+\.|[A-Z_]+:)|$)'
+    }
+    
+    for key, pattern in sections.items():
+        match = re.search(pattern, text, re.IGNORECASE | re.DOTALL)
+        if match:
+            content = match.group(1).strip()
+            if key == 'summary':
+                # Clean up summary and remove markdown symbols
+                clean_summary = re.sub(r'^[:\-\s]*', '', content).split('\n')[0].strip()
+                clean_summary = re.sub(r'#+\s*', '', clean_summary)  # Remove ### symbols
+                result[key] = clean_summary
+            else:
+                # Extract bullet points and clean them
+                items = []
+                
+                # Try different bullet point patterns
+                bullet_patterns = [
+                    r'^\s*[-•*]\s*(.+)$',  # Standard bullets
+                    r'^\s*\d+\.\s*(.+)$',  # Numbered lists
+                    r'^\s*[◦▪▫]\s*(.+)$',  # Alternative bullets
+                ]
+                
+                lines = content.split('\n')
+                for line in lines:
+                    line = line.strip()
+                    if not line or line.lower() in ['none', 'none found', 'skip if none found']:
+                        continue
+                    
+                    # Clean up markdown symbols and extra characters
+                    line = re.sub(r'#+\s*', '', line)  # Remove ### symbols
+                    line = re.sub(r'^\*+\s*', '', line)  # Remove ** symbols
+                    line = re.sub(r'^[:\-\s]*', '', line)  # Remove colons and dashes
+                        
+                    # Try each bullet pattern
+                    item_found = False
+                    for bullet_pattern in bullet_patterns:
+                        bullet_match = re.match(bullet_pattern, line)
+                        if bullet_match:
+                            clean_item = bullet_match.group(1).strip()
+                            clean_item = re.sub(r'#+\s*', '', clean_item)  # Remove ### from items
+                            if clean_item and len(clean_item) > 5:  # Avoid very short items
+                                items.append(clean_item)
+                            item_found = True
+                            break
+                    
+                    # If no bullet pattern, treat as potential item if it's substantial
+                    if not item_found and len(line) > 15:  # Increased minimum length
+                        clean_line = re.sub(r'#+\s*', '', line)  # Remove ### symbols
+                        items.append(clean_line)
+                
+                # If no bullet points found, split by sentences and clean
+                if not items and content.strip():
+                    sentences = re.split(r'[.!?]+', content)
+                    for sentence in sentences:
+                        clean_sentence = sentence.strip()
+                        clean_sentence = re.sub(r'#+\s*', '', clean_sentence)  # Remove ### symbols
+                        if clean_sentence and len(clean_sentence) > 15:
+                            items.append(clean_sentence)
+                
+                result[key] = items[:4]  # Limit to 4 items per section
+    
+    return result
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format."""
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"
+
+def validate_code(code: str, language: str) -> Dict[str, Any]:
+    """
+    Perform basic validation on the code.
+    
+    Args:
+        code (str): The code to validate
+        language (str): The programming language
+        
+    Returns:
+        dict: Validation result with 'is_valid' and 'message' keys
+    """
+    if not code.strip():
+        return {"is_valid": False, "message": "Code is empty"}
+    
+    # Basic validation rules
+    validation_rules = {
+        'python': [
+            (r'^[ \t]*[^\s#]', "Code appears to have inconsistent indentation"),
+        ],
+        'javascript': [
+            (r'\{[^}]*$', "Unclosed curly braces detected"),
+            (r'\([^)]*$', "Unclosed parentheses detected"),
+        ],
+        'java': [
+            (r'public\s+class\s+\w+', "Should contain a public class"),
+        ],
+        'cpp': [
+            (r'#include', "Should contain include statements"),
+        ],
+        'c': [
+            (r'#include', "Should contain include statements"),
+        ]
+    }
+    
+    # Check for common issues
+    lines = code.split('\n')
+    
+    # Check for extremely long lines
+    max_line_length = 200
+    for i, line in enumerate(lines):
+        if len(line) > max_line_length:
+            return {
+                "is_valid": False, 
+                "message": f"Line {i+1} is very long ({len(line)} characters). Consider breaking it up."
+            }
+    
+    # Language-specific validation
+    if language in validation_rules:
+        for pattern, message in validation_rules[language]:
+            if language == 'python' and pattern == r'^[ \t]*[^\s#]':
+                # Check indentation consistency for Python
+                indentation_types = set()
+                for line in lines:
+                    if line.strip() and line[0] in [' ', '\t']:
+                        if line.startswith(' '):
+                            indentation_types.add('spaces')
+                        elif line.startswith('\t'):
+                            indentation_types.add('tabs')
+                
+                if len(indentation_types) > 1:
+                    return {"is_valid": False, "message": "Mixed tabs and spaces for indentation"}
+            
+            elif not re.search(pattern, code, re.MULTILINE):
+                return {"is_valid": False, "message": message}
+    
+    return {"is_valid": True, "message": "Code appears to be well-formed"}
+
+def clean_response(response: str) -> str:
+    """
+    Clean and format the LLM response.
+    
+    Args:
+        response (str): Raw response from LLM
+        
+    Returns:
+        str: Cleaned and formatted response
+    """
+    if not response:
+        return "No response generated"
+    
+    # Remove excessive whitespace
+    cleaned = re.sub(r'\n\s*\n\s*\n', '\n\n', response)
+    cleaned = cleaned.strip()
+    
+    # Ensure proper markdown formatting
+    # Fix bullet points
+    cleaned = re.sub(r'^\s*[-*]\s*', '- ', cleaned, flags=re.MULTILINE)
+    
+    # Fix numbered lists
+    cleaned = re.sub(r'^\s*(\d+)\.\s*', r'\1. ', cleaned, flags=re.MULTILINE)
+    
+    # Ensure code blocks are properly formatted
+    cleaned = re.sub(r'```(\w+)?\s*\n', r'```\1\n', cleaned)
+    
+    return cleaned 

app.py

@@ -0,0 +1,293 @@
+import streamlit as st
+import os
+from dotenv import load_dotenv
+from analyzer import CodeAnalyzer
+import json
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="LLM Code Analyzer",
+    page_icon="🔍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for professional look
+st.markdown("""
+<style>
+    .main { padding-top: 2rem; }
+    .stButton > button {
+        width: 100%;
+        background-color: #0e1117;
+        border: 1px solid #262730;
+        font-weight: 500;
+    }
+    .stButton > button:hover {
+        border-color: #4a4b5e;
+    }
+    .code-editor {
+        font-family: 'Monaco', 'Menlo', monospace;
+    }
+    .metric-card {
+        background-color: #1e1e1e;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        border: 1px solid #262730;
+    }
+    .analysis-section {
+        background-color: #1e1e1e;
+        padding: 1.5rem;
+        border-radius: 0.5rem;
+        margin: 1rem 0;
+        border: 1px solid #262730;
+    }
+    .quality-score {
+        font-size: 2rem;
+        font-weight: bold;
+    }
+    .model-badge {
+        background-color: #262730;
+        padding: 0.25rem 0.75rem;
+        border-radius: 1rem;
+        display: inline-block;
+        margin: 0.25rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize analyzer
+@st.cache_resource
+def get_analyzer():
+    return CodeAnalyzer()
+
+analyzer = get_analyzer()
+
+def display_analysis_result(result: dict, model_name: str):
+    """Display analysis result in a formatted way."""
+    if 'error' in result:
+        st.error(f"Analysis failed: {result['error']}")
+        return
+    
+    # Quality score with color
+    score = result['quality_score']
+    score_color = "#00ff00" if score >= 80 else "#ffaa00" if score >= 60 else "#ff4444"
+    
+    st.markdown(f"""
+    <div class="analysis-section">
+        <h3>{model_name}</h3>
+        <div style="display: flex; justify-content: space-between; align-items: center;">
+            <div>
+                <span class="quality-score" style="color: {score_color};">{score}/100</span>
+                <p style="margin: 0; color: #888;">Quality Score</p>
+            </div>
+            <div style="text-align: right;">
+                <p style="margin: 0;"><strong>Language:</strong> {result['language']}</p>
+                <p style="margin: 0;"><strong>Analysis Time:</strong> {result['execution_time']}s</p>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Summary
+    if result.get('summary'):
+        st.markdown("#### 📋 Summary")
+        st.info(result['summary'])
+    
+    # Create columns for different sections
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Strengths
+        if result.get('strengths'):
+            st.markdown("#### ✅ Strengths")
+            for strength in result['strengths']:
+                st.success(f"• {strength}")
+        
+        # Suggestions
+        if result.get('suggestions'):
+            st.markdown("#### 💡 Suggestions")
+            for suggestion in result['suggestions']:
+                st.info(f"• {suggestion}")
+    
+    with col2:
+        # Issues
+        if result.get('issues'):
+            st.markdown("#### ⚠️ Issues")
+            for issue in result['issues']:
+                st.warning(f"• {issue}")
+        
+        # Security concerns
+        if result.get('security_concerns'):
+            st.markdown("#### 🔒 Security")
+            for concern in result['security_concerns']:
+                st.error(f"• {concern}")
+    
+    # Performance notes
+    if result.get('performance_notes'):
+        st.markdown("#### ⚡ Performance")
+        for note in result['performance_notes']:
+            st.info(f"• {note}")
+    
+    # Expandable raw response
+    with st.expander("View Raw Response"):
+        st.code(result.get('raw_response', 'No raw response available'))
+
+# Header
+st.title("🔍 Professional Code Analyzer")
+st.markdown("Analyze your code with multiple state-of-the-art LLMs")
+
+# Sidebar
+with st.sidebar:
+    st.header("⚙️ Configuration")
+    
+    # Model status
+    st.subheader("Available Models")
+    available_models = analyzer.available_models
+    
+    if not available_models:
+        st.error("No models available. Please check your API keys in .env file")
+        st.stop()
+    
+    for model, display_name in available_models.items():
+        st.success(f"✅ {display_name}")
+    
+    st.divider()
+    
+    # Analysis options
+    st.subheader("Analysis Options")
+    selected_model = st.selectbox(
+        "Select Model",
+        options=list(available_models.keys()),
+        format_func=lambda x: available_models[x]
+    )
+    
+    analyze_all = st.checkbox("Compare All Models", value=False)
+    
+    # Language selection
+    languages = ["auto-detect", "python", "javascript", "java", "cpp", "csharp", "go", "rust"]
+    selected_language = st.selectbox("Language", languages)
+    
+    st.divider()
+    
+    # Sample code
+    st.subheader("Sample Code")
+    if st.button("Load Python Example"):
+        st.session_state.code_input = """def fibonacci(n):
+    if n <= 1:
+        return n
+    else:
+        return fibonacci(n-1) + fibonacci(n-2)
+
+# Calculate fibonacci numbers
+for i in range(10):
+    print(f"F({i}) = {fibonacci(i)}")
+"""
+    
+    if st.button("Load JavaScript Example"):
+        st.session_state.code_input = """function findDuplicates(arr) {
+    let duplicates = [];
+    for (let i = 0; i < arr.length; i++) {
+        for (let j = i + 1; j < arr.length; j++) {
+            if (arr[i] === arr[j]) {
+                duplicates.push(arr[i]);
+            }
+        }
+    }
+    return duplicates;
+}
+
+console.log(findDuplicates([1, 2, 3, 2, 4, 3, 5]));
+"""
+
+# Main content
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    st.subheader("📝 Code Input")
+    code_input = st.text_area(
+        "Paste your code here",
+        value=st.session_state.get('code_input', ''),
+        height=400,
+        key="code_input",
+        help="Paste the code you want to analyze"
+    )
+    
+    # Analysis button
+    analyze_button = st.button(
+        "🚀 Analyze Code",
+        type="primary",
+        disabled=not code_input.strip()
+    )
+
+# Results column
+with col2:
+    st.subheader("📊 Analysis Results")
+    
+    if analyze_button and code_input.strip():
+        with st.spinner("Analyzing code..."):
+            if analyze_all:
+                # Multi-model analysis
+                results = analyzer.analyze_with_all_models(
+                    code_input,
+                    selected_language if selected_language != "auto-detect" else None
+                )
+                
+                # Display comparison
+                comparison = analyzer.compare_analyses(results)
+                
+                # Metrics row
+                metrics_cols = st.columns(4)
+                with metrics_cols[0]:
+                    st.metric("Average Score", f"{comparison['average_score']}/100")
+                with metrics_cols[1]:
+                    st.metric("Models Used", len(results))
+                with metrics_cols[2]:
+                    st.metric("Best Score", f"{max(comparison['model_scores'].values())}/100")
+                with metrics_cols[3]:
+                    st.metric("Analysis Time", f"{comparison['analysis_time']:.1f}s")
+                
+                # Tabs for each model
+                tabs = st.tabs(list(available_models.values()))
+                for idx, (model_key, result) in enumerate(results.items()):
+                    with tabs[idx]:
+                        display_analysis_result(result, available_models[model_key])
+                
+                # Consensus findings
+                if comparison['consensus_issues']:
+                    st.markdown("### 🤝 Consensus Issues")
+                    for issue in comparison['consensus_issues']:
+                        st.warning(f"• {issue}")
+                
+            else:
+                # Single model analysis
+                result = analyzer.analyze_code(
+                    code_input,
+                    selected_model,
+                    selected_language if selected_language != "auto-detect" else None
+                )
+                display_analysis_result(result, available_models[selected_model])
+
+# Instructions for empty state
+if not code_input.strip() and not analyze_button:
+    st.info("""
+    👋 **Welcome to the Professional Code Analyzer!**
+    
+    To get started:
+    1. Paste your code in the left panel
+    2. Select a model or choose "Compare All Models"
+    3. Click "Analyze Code" to get comprehensive insights
+    
+    You can also load sample code from the sidebar to try it out!
+    """)
+
+# Footer
+st.divider()
+st.markdown("""
+<div style="text-align: center; color: #888; padding: 2rem;">
+    <p>Built with Streamlit • Powered by OpenAI, Anthropic, Google, and DeepSeek</p>
+    <p>Professional Code Analysis Tool</p>
+</div>
+""", unsafe_allow_html=True) 

launch.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""
+Launch script for LLM Code Analyzer
+Checks system requirements and starts the Streamlit app
+"""
+
+import sys
+import os
+import subprocess
+from pathlib import Path
+
+def check_requirements():
+    """Check if all requirements are met."""
+    print("🔍 Checking system requirements...")
+    
+    # Check Python version
+    if sys.version_info < (3, 11):
+        print(f"❌ Python 3.11+ required, found {sys.version}")
+        return False
+    print(f"✅ Python {sys.version.split()[0]}")
+    
+    # Check if we're in the right directory
+    if not Path("app.py").exists():
+        print("❌ app.py not found. Please run from project root directory.")
+        return False
+    print("✅ Project structure verified")
+    
+    # Check if analyzer module can be imported
+    try:
+        from analyzer import CodeAnalyzer
+        analyzer = CodeAnalyzer()
+        models = analyzer.available_models
+        print(f"✅ Analyzer module loaded successfully")
+        print(f"📊 Available models: {len(models)}")
+        
+        if not models:
+            print("⚠️  No API keys configured in .env file")
+            print("   Add at least one API key to use the analyzer")
+        else:
+            for key, name in models.items():
+                print(f"   • {name}")
+        
+    except Exception as e:
+        print(f"❌ Failed to load analyzer: {e}")
+        return False
+    
+    # Check Streamlit
+    try:
+        import streamlit
+        print(f"✅ Streamlit {streamlit.__version__}")
+    except ImportError:
+        print("❌ Streamlit not installed")
+        return False
+    
+    return True
+
+def launch_app():
+    """Launch the Streamlit application."""
+    print("\n🚀 Starting LLM Code Analyzer...")
+    print("=" * 50)
+    
+    try:
+        # Start Streamlit
+        cmd = [
+            sys.executable, "-m", "streamlit", "run", "app.py",
+            "--server.headless", "true",
+            "--server.port", "8501",
+            "--server.address", "0.0.0.0"
+        ]
+        
+        print("📱 Application will be available at:")
+        print("   • Local: http://localhost:8501")
+        print("   • Network: http://0.0.0.0:8501")
+        print("\n💡 Press Ctrl+C to stop the application")
+        print("=" * 50)
+        
+        subprocess.run(cmd, check=True)
+        
+    except KeyboardInterrupt:
+        print("\n👋 Application stopped by user")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to start application: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ Unexpected error: {e}")
+        return False
+    
+    return True
+
+def main():
+    """Main entry point."""
+    print("🔍 LLM Code Analyzer - Launcher")
+    print("=" * 40)
+    
+    # Check requirements first
+    if not check_requirements():
+        print("\n❌ Requirements check failed")
+        print("\nTo fix issues:")
+        print("1. Ensure Python 3.11+ is installed")
+        print("2. Run: pip install -r requirements.txt")
+        print("3. Configure API keys in .env file")
+        sys.exit(1)
+    
+    print("\n✅ All requirements satisfied!")
+    
+    # Launch the app
+    if not launch_app():
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

launch_matrix.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""
+🟢 MATRIX CODE ANALYZER LAUNCHER 🟢
+Enter the Matrix... if you dare.
+"""
+
+import sys
+import os
+import subprocess
+from pathlib import Path
+
+def matrix_banner():
+    """Display Matrix-style banner."""
+    print("""
+🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢
+   
+   ███╗   ███╗ █████╗ ████████╗██████╗ ██╗██╗  ██╗    
+   ████╗ ████║██╔══██╗╚══██╔══╝██╔══██╗██║╚██╗██╔╝    
+   ██╔████╔██║███████║   ██║   ██████╔╝██║ ╚███╔╝     
+   ██║╚██╔╝██║██╔══██║   ██║   ██╔══██╗██║ ██╔██╗     
+   ██║ ╚═╝ ██║██║  ██║   ██║   ██║  ██║██║██╔╝ ██╗    
+   ╚═╝     ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝╚═╝  ╚═╝    
+                                                        
+        █████╗ ███╗   ██╗ █████╗ ██╗  ██╗   ██╗███████╗███████╗██████╗ 
+       ██╔══██╗████╗  ██║██╔══██╗██║  ╚██╗ ██╔╝╚══███╔╝██╔════╝██╔══██╗
+       ███████║██╔██╗ ██║███████║██║   ╚████╔╝   ███╔╝ █████╗  ██████╔╝
+       ██╔══██║██║╚██╗██║██╔══██║██║    ╚██╔╝   ███╔╝  ██╔══╝  ██╔══██╗
+       ██║  ██║██║ ╚████║██║  ██║███████╗██║   ███████╗███████╗██║  ██║
+       ╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝  ╚═╝╚══════╝╚═╝   ╚══════╝╚══════╝╚═╝  ╚═╝
+                                                                        
+🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢
+    """)
+    print("🟢 NEURAL NETWORK INITIALIZATION SEQUENCE STARTING...")
+    print("🟢 'There is no spoon... only code.'")
+    print("🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢")
+
+def check_matrix_requirements():
+    """Check if the Matrix is ready."""
+    print("\n🟢 SCANNING MATRIX REQUIREMENTS...")
+    
+    # Check Python version
+    if sys.version_info < (3, 11):
+        print(f"❌ INCOMPATIBLE_PYTHON_VERSION: {sys.version}")
+        print("🟢 UPGRADE_TO_PYTHON_3.11+_REQUIRED")
+        return False
+    print(f"✅ PYTHON_VERSION: {sys.version.split()[0]} [COMPATIBLE]")
+    
+    # Check if we're in the right dimension
+    if not Path("matrix_app.py").exists():
+        print("❌ MATRIX_APP_NOT_FOUND")
+        print("🟢 ENSURE_YOU_ARE_IN_THE_CORRECT_DIRECTORY")
+        return False
+    print("✅ MATRIX_APPLICATION: LOCATED")
+    
+    # Check if analyzer module is accessible
+    try:
+        from analyzer import CodeAnalyzer
+        analyzer = CodeAnalyzer()
+        models = analyzer.available_models
+        print(f"✅ NEURAL_NETWORKS: ONLINE")
+        print(f"🟢 AVAILABLE_AI_MODELS: {len(models)}")
+        
+        if not models:
+            print("⚠️  NO_API_KEYS_DETECTED")
+            print("🟢 CONFIGURE_NEURAL_NETWORK_ACCESS_CODES")
+            print("🟢 REQUIRED: OPENAI • ANTHROPIC • GEMINI • DEEPSEEK")
+        else:
+            for key, name in models.items():
+                print(f"   🤖 {name} [READY]")
+        
+    except Exception as e:
+        print(f"❌ NEURAL_NETWORK_ERROR: {e}")
+        return False
+    
+    # Check Streamlit
+    try:
+        import streamlit
+        print(f"✅ MATRIX_INTERFACE: v{streamlit.__version__} [OPERATIONAL]")
+    except ImportError:
+        print("❌ MATRIX_INTERFACE_NOT_FOUND")
+        print("🟢 RUN: pip install streamlit")
+        return False
+    
+    return True
+
+def enter_matrix():
+    """Enter the Matrix."""
+    print("\n🟢 INITIATING_MATRIX_SEQUENCE...")
+    print("🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢")
+    
+    try:
+        # Start the Matrix interface
+        cmd = [
+            sys.executable, "-m", "streamlit", "run", "matrix_app.py",
+            "--server.headless", "true",
+            "--server.port", "8503",
+            "--server.address", "0.0.0.0"
+        ]
+        
+        print("🟢 MATRIX_PORTAL_COORDINATES:")
+        print("   🌐 LOCAL_ACCESS: http://localhost:8503")
+        print("   🌐 NETWORK_ACCESS: http://0.0.0.0:8503")
+        print("\n🟢 MATRIX_ACTIVATED...")
+        print("🟢 'Welcome to the real world, Neo.'")
+        print("🟢 [Press Ctrl+C to exit the Matrix]")
+        print("🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢🟢")
+        
+        subprocess.run(cmd, check=True)
+        
+    except KeyboardInterrupt:
+        print("\n🟢 MATRIX_SESSION_TERMINATED")
+        print("🟢 'Until we meet again in the Matrix...'")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ MATRIX_INITIALIZATION_FAILED: {e}")
+        return False
+    except Exception as e:
+        print(f"❌ UNEXPECTED_MATRIX_ERROR: {e}")
+        return False
+    
+    return True
+
+def main():
+    """Main entry point to the Matrix."""
+    matrix_banner()
+    
+    # Check if the Matrix is ready
+    if not check_matrix_requirements():
+        print("\n❌ MATRIX_REQUIREMENTS_NOT_MET")
+        print("\n🟢 TROUBLESHOOTING_PROTOCOL:")
+        print("1. ENSURE_PYTHON_3.11+_INSTALLED")
+        print("2. RUN: pip install -r requirements.txt")
+        print("3. CONFIGURE_API_KEYS_IN_.ENV_FILE")
+        print("4. RETRY_MATRIX_INITIALIZATION")
+        sys.exit(1)
+    
+    print("\n✅ ALL_MATRIX_SYSTEMS_OPERATIONAL")
+    print("🟢 READY_TO_ENTER_THE_MATRIX...")
+    
+    # Enter the Matrix
+    if not enter_matrix():
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

matrix_app.py

@@ -0,0 +1,562 @@
+import streamlit as st
+import os
+import time
+import random
+import sys
+from dotenv import load_dotenv
+from analyzer import CodeAnalyzer
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="Matrix Code Analyzer",
+    page_icon="🟢",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Matrix CSS - Cyberpunk Theme
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Share+Tech+Mono:wght@400&display=swap');
+    @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&display=swap');
+    
+    /* Matrix Background */
+    .stApp {
+        background: linear-gradient(135deg, #0d1b0d 0%, #000000 50%, #0d1b0d 100%);
+        color: #00ff41;
+        font-family: 'Share Tech Mono', monospace;
+    }
+    
+    /* Matrix Code Rain Animation */
+    .matrix-bg {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        z-index: -1;
+        opacity: 0.1;
+    }
+    
+    .matrix-char {
+        position: absolute;
+        color: #00ff41;
+        font-family: 'Share Tech Mono', monospace;
+        font-size: 14px;
+        animation: matrix-fall linear infinite;
+    }
+    
+    @keyframes matrix-fall {
+        0% { transform: translateY(-100vh); opacity: 1; }
+        100% { transform: translateY(100vh); opacity: 0; }
+    }
+    
+    /* Main Content Styling */
+    .main .block-container {
+        padding-top: 2rem;
+        background: rgba(0, 0, 0, 0.8);
+        border: 1px solid #00ff41;
+        border-radius: 10px;
+        box-shadow: 0 0 20px rgba(0, 255, 65, 0.3);
+    }
+    
+    /* Title Styling */
+    h1 {
+        font-family: 'Orbitron', monospace !important;
+        color: #00ff41 !important;
+        text-align: center !important;
+        text-shadow: 0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41;
+        font-weight: 900 !important;
+        margin-bottom: 2rem !important;
+        animation: glow 2s ease-in-out infinite alternate;
+    }
+    
+    @keyframes glow {
+        from { text-shadow: 0 0 5px #00ff41, 0 0 10px #00ff41, 0 0 15px #00ff41; }
+        to { text-shadow: 0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41; }
+    }
+    
+    /* Sidebar Styling */
+    .css-1d391kg {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        border-radius: 10px !important;
+    }
+    
+    /* Buttons */
+    .stButton > button {
+        background: linear-gradient(45deg, #003300, #006600) !important;
+        color: #00ff41 !important;
+        border: 2px solid #00ff41 !important;
+        border-radius: 5px !important;
+        font-family: 'Orbitron', monospace !important;
+        font-weight: bold !important;
+        text-transform: uppercase !important;
+        transition: all 0.3s ease !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.3) !important;
+    }
+    
+    .stButton > button:hover {
+        background: linear-gradient(45deg, #006600, #00aa00) !important;
+        box-shadow: 0 0 20px rgba(0, 255, 65, 0.6) !important;
+        transform: translateY(-2px) !important;
+    }
+    
+    /* Select boxes */
+    .stSelectbox > div > div {
+        background: rgba(0, 51, 0, 0.8) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* Text areas */
+    .stTextArea > div > div > textarea {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+        font-family: 'Share Tech Mono', monospace !important;
+    }
+    
+    /* Metrics */
+    .css-1xarl3l {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 1px solid #00ff41 !important;
+        border-radius: 5px !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.2) !important;
+    }
+    
+    /* Success/Info/Warning messages */
+    .stSuccess {
+        background: rgba(0, 255, 65, 0.1) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    .stInfo {
+        background: rgba(0, 255, 255, 0.1) !important;
+        border: 1px solid #00ffff !important;
+        color: #00ffff !important;
+    }
+    
+    .stWarning {
+        background: rgba(255, 255, 0, 0.1) !important;
+        border: 1px solid #ffff00 !important;
+        color: #ffff00 !important;
+    }
+    
+    .stError {
+        background: rgba(255, 0, 0, 0.1) !important;
+        border: 1px solid #ff0000 !important;
+        color: #ff0000 !important;
+    }
+    
+    /* Code blocks */
+    .stCode {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        background: rgba(0, 0, 0, 0.8) !important;
+        border-bottom: 2px solid #00ff41 !important;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        background: rgba(0, 51, 0, 0.3) !important;
+        color: #00ff41 !important;
+        border: 1px solid #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+    }
+    
+    .stTabs [aria-selected="true"] {
+        background: rgba(0, 255, 65, 0.2) !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.5) !important;
+    }
+    
+    /* Matrix Terminal Effect */
+    .matrix-terminal {
+        background: rgba(0, 0, 0, 0.95) !important;
+        border: 2px solid #00ff41 !important;
+        border-radius: 10px !important;
+        padding: 20px !important;
+        font-family: 'Share Tech Mono', monospace !important;
+        color: #00ff41 !important;
+        box-shadow: 0 0 30px rgba(0, 255, 65, 0.4) !important;
+        position: relative !important;
+    }
+    
+    .matrix-terminal::before {
+        content: "MATRIX_ANALYZER_v2.0 > ACTIVE" !important;
+        position: absolute !important;
+        top: -15px !important;
+        left: 20px !important;
+        background: #000000 !important;
+        padding: 0 10px !important;
+        color: #00ff41 !important;
+        font-size: 12px !important;
+        font-weight: bold !important;
+    }
+    
+    /* Scrollbar */
+    ::-webkit-scrollbar {
+        width: 8px;
+    }
+    
+    ::-webkit-scrollbar-track {
+        background: #000000;
+    }
+    
+    ::-webkit-scrollbar-thumb {
+        background: #00ff41;
+        border-radius: 4px;
+    }
+    
+    ::-webkit-scrollbar-thumb:hover {
+        background: #00aa00;
+    }
+    
+    /* Loading spinner */
+    .stSpinner > div {
+        border-color: #00ff41 transparent #00ff41 transparent !important;
+    }
+    
+    /* Expander */
+    .streamlit-expanderHeader {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+</style>
+
+<div class="matrix-bg" id="matrix-bg"></div>
+
+<script>
+function createMatrixRain() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()_+-=[]{}|;:,.<>?";
+    const container = document.getElementById('matrix-bg');
+    
+    for (let i = 0; i < 50; i++) {
+        const char = document.createElement('div');
+        char.className = 'matrix-char';
+        char.textContent = chars[Math.floor(Math.random() * chars.length)];
+        char.style.left = Math.random() * 100 + '%';
+        char.style.animationDuration = (Math.random() * 3 + 2) + 's';
+        char.style.animationDelay = Math.random() * 2 + 's';
+        container.appendChild(char);
+    }
+}
+
+// Create matrix rain effect
+setTimeout(createMatrixRain, 100);
+</script>
+""", unsafe_allow_html=True)
+
+# Initialize analyzer
+@st.cache_resource
+def get_analyzer():
+    return CodeAnalyzer()
+
+analyzer = get_analyzer()
+
+def display_matrix_analysis_result(result: dict, model_name: str):
+    """Display analysis result in Matrix terminal style."""
+    if 'error' in result:
+        st.error(f"🚨 SYSTEM ERROR: {result['error']}")
+        return
+    
+    # Quality score with Matrix styling
+    score = result['quality_score']
+    if score >= 80:
+        score_color = "#00ff41"
+        status = "OPTIMAL"
+    elif score >= 60:
+        score_color = "#ffff00"
+        status = "ACCEPTABLE"
+    else:
+        score_color = "#ff0000"
+        status = "CRITICAL"
+    
+    st.markdown(f"""
+    <div class="matrix-terminal">
+        <h3 style="color: {score_color}; font-family: 'Orbitron', monospace; text-align: center;">
+            [{model_name}] ANALYSIS COMPLETE
+        </h3>
+        <div style="display: flex; justify-content: space-between; margin: 20px 0;">
+            <div>
+                <span style="font-size: 2.5rem; color: {score_color}; font-weight: bold;">
+                    {score}/100
+                </span>
+                <p style="margin: 0; color: {score_color}; font-weight: bold;">
+                    STATUS: {status}
+                </p>
+            </div>
+            <div style="text-align: right; color: #00ff41;">
+                <p style="margin: 0;"><strong>LANGUAGE:</strong> {result['language'].upper()}</p>
+                <p style="margin: 0;"><strong>SCAN_TIME:</strong> {result['execution_time']}s</p>
+                <p style="margin: 0;"><strong>CODE_LINES:</strong> {result['line_count']}</p>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Summary in terminal style
+    if result.get('summary'):
+        st.markdown("#### 📋 SYSTEM ANALYSIS")
+        st.markdown(f"""
+        <div style="background: rgba(0,0,0,0.8); border: 1px solid #00ff41; padding: 15px; border-radius: 5px; font-family: 'Share Tech Mono', monospace;">
+        > {result['summary']}
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Create columns for different sections
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Strengths
+        if result.get('strengths'):
+            st.markdown("#### ✅ SYSTEM STRENGTHS")
+            for strength in result['strengths']:
+                st.success(f"[+] {strength}")
+        
+        # Suggestions
+        if result.get('suggestions'):
+            st.markdown("#### 💡 ENHANCEMENT_PROTOCOLS")
+            for suggestion in result['suggestions']:
+                st.info(f"[*] {suggestion}")
+    
+    with col2:
+        # Issues
+        if result.get('issues'):
+            st.markdown("#### ⚠️ SYSTEM_VULNERABILITIES")
+            for issue in result['issues']:
+                st.warning(f"[!] {issue}")
+        
+        # Security concerns
+        if result.get('security_concerns'):
+            st.markdown("#### 🔒 SECURITY_BREACH_DETECTED")
+            for concern in result['security_concerns']:
+                st.error(f"[ALERT] {concern}")
+    
+    # Performance notes
+    if result.get('performance_notes'):
+        st.markdown("#### ⚡ PERFORMANCE_OPTIMIZATION")
+        for note in result['performance_notes']:
+            st.info(f"[PERF] {note}")
+    
+    # Expandable raw response
+    with st.expander("VIEW RAW_DATA_STREAM"):
+        st.code(result.get('raw_response', 'NO_DATA_AVAILABLE'), language='text')
+
+# Header with Matrix effect
+st.markdown("""
+<h1 style="text-align: center;">
+🟢 MATRIX CODE ANALYZER 🟢
+</h1>
+<p style="text-align: center; color: #00ff41; font-family: 'Share Tech Mono', monospace; font-size: 18px;">
+[NEURAL_NETWORK_ACTIVATED] • [MULTI_AI_ANALYSIS_ONLINE] • [SECURITY_LEVEL_9]
+</p>
+""", unsafe_allow_html=True)
+
+# Sidebar - The Matrix Control Panel
+with st.sidebar:
+    st.markdown("### 🟢 CONTROL_PANEL")
+    
+    # Model status
+    st.markdown("#### AVAILABLE_NEURAL_NETWORKS")
+    available_models = analyzer.available_models
+    
+    if not available_models:
+        st.error("❌ NO_NETWORKS_DETECTED")
+        st.info("CONFIGURE_API_KEYS_IN_ENV_FILE")
+        st.stop()
+    
+    # Display available models with Matrix styling
+    for model, display_name in available_models.items():
+        st.markdown(f"""
+        <div style="background: rgba(0, 255, 65, 0.1); border: 1px solid #00ff41; padding: 5px; margin: 5px 0; border-radius: 3px;">
+        🟢 <strong>{display_name}</strong> [ONLINE]
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # Analysis options
+    st.markdown("#### ANALYSIS_PARAMETERS")
+    
+    # Model selector with Matrix styling
+    selected_model = st.selectbox(
+        "SELECT_NEURAL_NETWORK",
+        options=list(available_models.keys()),
+        format_func=lambda x: f"🤖 {available_models[x]}"
+    )
+    
+    # Multi-model analysis toggle
+    analyze_all = st.checkbox("🔄 MULTI_NETWORK_SCAN", value=False)
+    
+    # Language selection
+    languages = ["auto-detect", "python", "javascript", "java", "cpp", "csharp", "go", "rust"]
+    selected_language = st.selectbox(
+        "TARGET_LANGUAGE", 
+        languages,
+        format_func=lambda x: x.upper().replace("-", "_")
+    )
+    
+    st.markdown("---")
+    
+    # Sample code injection
+    st.markdown("#### CODE_INJECTION_SAMPLES")
+    
+    if st.button("🐍 INJECT_PYTHON_SAMPLE"):
+        st.session_state.code_input = """def matrix_hack():
+    # The Matrix has you...
+    reality = "simulation"
+    if reality == "simulation":
+        print("Wake up, Neo...")
+        return True
+    return False
+
+# Take the red pill
+choice = matrix_hack()
+for i in range(10):
+    print(f"Level {i}: {'🟢' if choice else '🔴'}")
+"""
+    
+    if st.button("🟨 INJECT_JAVASCRIPT_SAMPLE"):
+        st.session_state.code_input = """function followTheWhiteRabbit(choice) {
+    const matrix = {
+        red_pill: "truth",
+        blue_pill: "ignorance"
+    };
+    
+    if (choice === "red_pill") {
+        console.log("Welcome to the real world");
+        return matrix[choice];
+    }
+    
+    return "The story ends, you wake up in your bed...";
+}
+
+// The choice is yours
+const reality = followTheWhiteRabbit("red_pill");
+console.log(`Reality: ${reality}`);
+"""
+
+# Main Terminal Interface
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    st.markdown("### 📟 CODE_INPUT_TERMINAL")
+    
+    # Code input with Matrix styling
+    code_input = st.text_area(
+        "PASTE_TARGET_CODE",
+        value=st.session_state.get('code_input', ''),
+        height=400,
+        key="code_input",
+        help="Insert code for neural network analysis..."
+    )
+    
+    # Matrix-styled analyze button
+    analyze_button = st.button(
+        "🚀 INITIATE_SCAN",
+        type="primary",
+        disabled=not code_input.strip(),
+        help="Begin deep neural analysis of target code"
+    )
+
+# Results Terminal
+with col2:
+    st.markdown("### 📊 ANALYSIS_OUTPUT_TERMINAL")
+    
+    if analyze_button and code_input.strip():
+        with st.spinner("🟢 SCANNING... NEURAL_NETWORKS_PROCESSING..."):
+            if analyze_all:
+                # Multi-model analysis
+                st.markdown("#### 🔄 MULTI_NETWORK_ANALYSIS_INITIATED")
+                
+                results = analyzer.analyze_with_all_models(
+                    code_input,
+                    selected_language if selected_language != "auto-detect" else None
+                )
+                
+                # Display comparison metrics
+                comparison = analyzer.compare_analyses(results)
+                
+                # Matrix-styled metrics
+                metrics_cols = st.columns(4)
+                with metrics_cols[0]:
+                    st.metric("AVG_SCORE", f"{comparison['average_score']}/100")
+                with metrics_cols[1]:
+                    st.metric("NETWORKS", len(results))
+                with metrics_cols[2]:
+                    st.metric("PEAK_SCORE", f"{max(comparison['model_scores'].values())}/100")
+                with metrics_cols[3]:
+                    st.metric("SCAN_TIME", f"{comparison['analysis_time']:.1f}s")
+                
+                # Create tabs for each neural network
+                tab_names = [f"🤖 {available_models[key]}" for key in results.keys()]
+                tabs = st.tabs(tab_names)
+                
+                for idx, (model_key, result) in enumerate(results.items()):
+                    with tabs[idx]:
+                        display_matrix_analysis_result(result, available_models[model_key])
+                
+                # Consensus findings with Matrix styling
+                if comparison['consensus_issues']:
+                    st.markdown("### 🤝 NEURAL_CONSENSUS_DETECTED")
+                    st.markdown("""
+                    <div style="background: rgba(255, 0, 0, 0.1); border: 2px solid #ff0000; padding: 15px; border-radius: 10px;">
+                    <strong>CRITICAL_PATTERNS_IDENTIFIED_BY_MULTIPLE_NETWORKS:</strong>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    for issue in comparison['consensus_issues']:
+                        st.error(f"🚨 CONSENSUS_ALERT: {issue}")
+                
+            else:
+                # Single model analysis
+                st.markdown(f"#### 🤖 {available_models[selected_model].upper()}_ANALYSIS")
+                
+                result = analyzer.analyze_code(
+                    code_input,
+                    selected_model,
+                    selected_language if selected_language != "auto-detect" else None
+                )
+                display_matrix_analysis_result(result, available_models[selected_model])
+
+# Instructions for new users
+if not code_input.strip() and not analyze_button:
+    st.markdown("""
+    <div class="matrix-terminal" style="margin: 20px 0;">
+        <h3 style="color: #00ff41; text-align: center;">🟢 WELCOME TO THE MATRIX 🟢</h3>
+        <p style="color: #00ff41; font-family: 'Share Tech Mono', monospace;">
+        > SYSTEM_STATUS: ONLINE<br>
+        > NEURAL_NETWORKS: READY<br>
+        > AWAITING_CODE_INPUT...<br><br>
+        
+        <strong>INITIALIZATION_PROTOCOL:</strong><br>
+        1. PASTE_CODE → Left terminal<br>
+        2. SELECT_NEURAL_NETWORK → Control panel<br>
+        3. INITIATE_SCAN → Begin analysis<br>
+        4. REVIEW_RESULTS → Right terminal<br><br>
+        
+        <em>The Matrix has you... but now you have the power to analyze it. 🟢</em>
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Footer with Matrix signature
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #00ff41; font-family: 'Share Tech Mono', monospace; padding: 20px;">
+    <p>🟢 POWERED_BY_NEURAL_NETWORKS • OPENAI • ANTHROPIC • DEEPSEEK • GOOGLE 🟢</p>
+    <p><em>"There is no spoon... only code."</em></p>
+    <p style="font-size: 12px;">MATRIX_ANALYZER_v2.0 • BUILD_2024 • SECURITY_CLEARANCE_OMEGA</p>
+</div>
+""", unsafe_allow_html=True) 

matrix_final.py

@@ -0,0 +1,978 @@
+import streamlit as st
+import os
+import time
+import random
+import sys
+from dotenv import load_dotenv
+from analyzer import CodeAnalyzer
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="Matrix Code Analyzer - Final",
+    page_icon="🟢",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Matrix CSS - Enhanced with file upload styling
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Share+Tech+Mono:wght@400&display=swap');
+    @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&display=swap');
+    
+    /* Matrix Background */
+    .stApp {
+        background: linear-gradient(135deg, #0d1b0d 0%, #000000 50%, #0d1b0d 100%);
+        color: #00ff41;
+        font-family: 'Share Tech Mono', monospace;
+    }
+    
+    /* Matrix Code Rain Animation */
+    .matrix-bg {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        z-index: -1;
+        opacity: 0.1;
+    }
+    
+    .matrix-char {
+        position: absolute;
+        color: #00ff41;
+        font-family: 'Share Tech Mono', monospace;
+        font-size: 14px;
+        animation: matrix-fall linear infinite;
+    }
+    
+    @keyframes matrix-fall {
+        0% { transform: translateY(-100vh); opacity: 1; }
+        100% { transform: translateY(100vh); opacity: 0; }
+    }
+    
+    /* Main Content Styling */
+    .main .block-container {
+        padding-top: 2rem;
+        background: rgba(0, 0, 0, 0.8);
+        border: 1px solid #00ff41;
+        border-radius: 10px;
+        box-shadow: 0 0 20px rgba(0, 255, 65, 0.3);
+    }
+    
+    /* Title Styling */
+    h1 {
+        font-family: 'Orbitron', monospace !important;
+        color: #00ff41 !important;
+        text-align: center !important;
+        text-shadow: 0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41;
+        font-weight: 900 !important;
+        margin-bottom: 2rem !important;
+        animation: glow 2s ease-in-out infinite alternate;
+    }
+    
+    @keyframes glow {
+        from { text-shadow: 0 0 5px #00ff41, 0 0 10px #00ff41, 0 0 15px #00ff41; }
+        to { text-shadow: 0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41; }
+    }
+    
+    /* Sidebar Styling */
+    .css-1d391kg {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        border-radius: 10px !important;
+    }
+    
+    /* Buttons */
+    .stButton > button {
+        background: linear-gradient(45deg, #003300, #006600) !important;
+        color: #00ff41 !important;
+        border: 2px solid #00ff41 !important;
+        border-radius: 5px !important;
+        font-family: 'Orbitron', monospace !important;
+        font-weight: bold !important;
+        text-transform: uppercase !important;
+        transition: all 0.3s ease !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.3) !important;
+    }
+    
+    .stButton > button:hover {
+        background: linear-gradient(45deg, #006600, #00aa00) !important;
+        box-shadow: 0 0 20px rgba(0, 255, 65, 0.6) !important;
+        transform: translateY(-2px) !important;
+    }
+    
+    /* File uploader styling */
+    .stFileUploader > div {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 2px dashed #00ff41 !important;
+        border-radius: 10px !important;
+        padding: 20px !important;
+    }
+    
+    .stFileUploader label {
+        color: #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+        font-weight: bold !important;
+    }
+    
+    /* Select boxes */
+    .stSelectbox > div > div {
+        background: rgba(0, 51, 0, 0.8) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* Text areas */
+    .stTextArea > div > div > textarea {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+        font-family: 'Share Tech Mono', monospace !important;
+    }
+    
+    /* Metrics */
+    .css-1xarl3l {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 1px solid #00ff41 !important;
+        border-radius: 5px !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.2) !important;
+    }
+    
+    /* Success/Info/Warning messages */
+    .stSuccess {
+        background: rgba(0, 255, 65, 0.1) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    .stInfo {
+        background: rgba(0, 255, 255, 0.1) !important;
+        border: 1px solid #00ffff !important;
+        color: #00ffff !important;
+    }
+    
+    .stWarning {
+        background: rgba(255, 255, 0, 0.1) !important;
+        border: 1px solid #ffff00 !important;
+        color: #ffff00 !important;
+    }
+    
+    .stError {
+        background: rgba(255, 0, 0, 0.1) !important;
+        border: 1px solid #ff0000 !important;
+        color: #ff0000 !important;
+    }
+    
+    /* Code blocks */
+    .stCode {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        background: rgba(0, 0, 0, 0.8) !important;
+        border-bottom: 2px solid #00ff41 !important;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        background: rgba(0, 51, 0, 0.3) !important;
+        color: #00ff41 !important;
+        border: 1px solid #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+    }
+    
+    .stTabs [aria-selected="true"] {
+        background: rgba(0, 255, 65, 0.2) !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.5) !important;
+    }
+    
+    /* Matrix Terminal Effect */
+    .matrix-terminal {
+        background: rgba(0, 0, 0, 0.95) !important;
+        border: 2px solid #00ff41 !important;
+        border-radius: 10px !important;
+        padding: 20px !important;
+        font-family: 'Share Tech Mono', monospace !important;
+        color: #00ff41 !important;
+        box-shadow: 0 0 30px rgba(0, 255, 65, 0.4) !important;
+        position: relative !important;
+    }
+    
+    .matrix-terminal::before {
+        content: "MATRIX_ANALYZER_v3.0 > OPERATIONAL" !important;
+        position: absolute !important;
+        top: -15px !important;
+        left: 20px !important;
+        background: #000000 !important;
+        padding: 0 10px !important;
+        color: #00ff41 !important;
+        font-size: 12px !important;
+        font-weight: bold !important;
+    }
+    
+    /* Checkbox styling */
+    .stCheckbox > label {
+        color: #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+    }
+    
+    /* Loading spinner */
+    .stSpinner > div {
+        border-color: #00ff41 transparent #00ff41 transparent !important;
+    }
+    
+    /* Expander */
+    .streamlit-expanderHeader {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* File info styling */
+    .file-info {
+        background: rgba(0, 255, 65, 0.1);
+        border: 1px solid #00ff41;
+        padding: 10px;
+        border-radius: 5px;
+        margin: 10px 0;
+        font-family: 'Share Tech Mono', monospace;
+    }
+</style>
+
+<div class="matrix-bg" id="matrix-bg"></div>
+
+<script>
+function createMatrixRain() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()_+-=[]{}|;:,.<>?";
+    const container = document.getElementById('matrix-bg');
+    
+    for (let i = 0; i < 50; i++) {
+        const char = document.createElement('div');
+        char.className = 'matrix-char';
+        char.textContent = chars[Math.floor(Math.random() * chars.length)];
+        char.style.left = Math.random() * 100 + '%';
+        char.style.animationDuration = (Math.random() * 3 + 2) + 's';
+        char.style.animationDelay = Math.random() * 2 + 's';
+        container.appendChild(char);
+    }
+}
+
+// Create matrix rain effect
+setTimeout(createMatrixRain, 100);
+</script>
+""", unsafe_allow_html=True)
+
+# Initialize analyzer
+def get_analyzer():
+    # Force reimport to ensure latest code
+    import importlib
+    import analyzer.code_analyzer
+    importlib.reload(analyzer.code_analyzer)
+    from analyzer.code_analyzer import CodeAnalyzer
+    return CodeAnalyzer()
+
+analyzer = get_analyzer()
+
+def display_matrix_analysis_result(result: dict, model_name: str):
+    """Display analysis result in clean, readable horizontal blocks."""
+    if 'error' in result:
+        st.error(f"🚨 SYSTEM ERROR: {result['error']}")
+        return
+    
+    # Quality score with modern styling
+    score = result['quality_score']
+    if score >= 80:
+        score_color = "#00ff41"
+        status = "EXCELLENT"
+    elif score >= 60:
+        score_color = "#ffff00"
+        status = "ACCEPTABLE"
+    else:
+        score_color = "#ff0000"
+        status = "NEEDS_WORK"
+    
+    # Header with score
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(0,255,65,0.15), rgba(0,255,65,0.05)); 
+               border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 20px 0; 
+               text-align: center;">
+        <h2 style="color: {score_color}; margin-bottom: 15px; font-size: 1.8rem;">
+            {model_name} Analysis
+        </h2>
+        <div style="display: flex; justify-content: center; gap: 30px; flex-wrap: wrap; color: #ffffff;">
+            <div style="text-align: center;">
+                <div style="font-size: 2rem; color: {score_color}; font-weight: bold;">{score}/100</div>
+                <div style="font-size: 0.9rem; opacity: 0.8;">{status}</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 1.2rem; color: #00ff41; font-weight: bold;">{result['language'].upper()}</div>
+                <div style="font-size: 0.9rem; opacity: 0.8;">Language</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 1.2rem; color: #00ff41; font-weight: bold;">{result['line_count']}</div>
+                <div style="font-size: 0.9rem; opacity: 0.8;">Lines</div>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Summary
+    if result.get('summary'):
+        st.markdown("### 📋 Code Overview")
+        st.markdown(f"""
+        <div style="background: rgba(0,0,0,0.6); border: 1px solid #00ff41; border-radius: 10px; 
+                   padding: 20px; margin: 20px 0;">
+            <p style="color: #ffffff; font-size: 18px; line-height: 1.6; text-align: center; margin: 0;">
+                {result['summary']}
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Analysis results in horizontal blocks
+    st.markdown("### 📊 Analysis Results")
+    
+    # Bug Detection Block (Full width)
+    bug_items = result.get('bugs', [])
+    if bug_items:
+        bug_text = " • ".join(bug_items[:3])  # Join with bullets for horizontal reading
+    else:
+        bug_text = "No critical bugs detected • Code logic appears sound • Edge cases handled well"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(255,100,100,0.1), rgba(150,0,0,0.1)); 
+               border: 2px solid #ff6b6b; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ff6b6b; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🐛 Bug Detection
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {bug_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Security Vulnerabilities Block (Full width)
+    security_items = result.get('security_vulnerabilities', [])
+    if security_items:
+        security_text = " • ".join(security_items[:3])  # Join with bullets for horizontal reading
+    else:
+        security_text = "No security vulnerabilities found • Follows security best practices • Input validation looks good"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(200,0,200,0.1), rgba(100,0,100,0.1)); 
+               border: 2px solid #ff00ff; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ff00ff; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🔒 Security Check
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {security_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Code Quality & Quick Fixes Block (Full width)
+    quality_items = result.get('quality_issues', []) + result.get('quick_fixes', [])
+    if quality_items:
+        quality_text = " • ".join(quality_items[:3])  # Join with bullets for horizontal reading
+    else:
+        quality_text = "Code is well-structured • Good naming conventions • Easy to read and maintain"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(0,200,255,0.1), rgba(0,100,150,0.1)); 
+               border: 2px solid #00ccff; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #00ccff; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            📝 Code Quality
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {quality_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Legacy sections (only if new sections are empty)
+    if not result.get('bugs') and not result.get('security_vulnerabilities') and not result.get('quality_issues'):
+        legacy_col1, legacy_col2 = st.columns(2)
+        
+        with legacy_col1:
+            # Legacy strengths
+            if result.get('strengths'):
+                st.markdown("#### ✅ Strengths")
+                for strength in result['strengths'][:3]:
+                    st.success(f"✓ {strength}")
+            
+            # Legacy issues
+        if result.get('issues'):
+                st.markdown("#### ⚠️ Issues")
+                for issue in result['issues'][:3]:
+                    st.warning(f"! {issue}")
+        
+        with legacy_col2:
+            # Legacy suggestions
+            if result.get('suggestions'):
+                st.markdown("#### 💡 Suggestions")
+                for suggestion in result['suggestions'][:3]:
+                    st.info(f"→ {suggestion}")
+            
+            # Legacy security concerns
+        if result.get('security_concerns'):
+                st.markdown("#### 🔒 Security Concerns")
+                for concern in result['security_concerns'][:3]:
+                    st.error(f"⚠ {concern}")
+    
+    # Expandable raw response (moved to bottom and less prominent)
+    with st.expander("🔍 View Detailed Analysis", expanded=False):
+        st.code(result.get('raw_response', 'NO_DATA_AVAILABLE'), language='text')
+
+def display_github_analysis_result(result: dict, model_name: str):
+    """Display GitHub repository analysis result in clean, readable horizontal blocks."""
+    if 'error' in result:
+        st.error(f"🚨 GITHUB ANALYSIS ERROR: {result['error']}")
+        return
+    
+    # Repository info in a clean header
+    if result.get('repository_info'):
+        repo_info = result['repository_info']
+        st.markdown(f"""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.15), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 20px 0; 
+                   text-align: center;">
+            <h2 style="color: #00ff41; margin-bottom: 20px; font-size: 1.8rem;">
+                📦 {repo_info['name']}
+            </h2>
+            <div style="display: flex; justify-content: center; gap: 30px; flex-wrap: wrap; color: #ffffff;">
+                <div style="text-align: center;">
+                    <div style="font-size: 1.5rem; color: #00ff41; font-weight: bold;">{repo_info['language']}</div>
+                    <div style="font-size: 0.9rem; opacity: 0.8;">Language</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-size: 1.5rem; color: #00ff41; font-weight: bold;">⭐ {repo_info['stars']}</div>
+                    <div style="font-size: 0.9rem; opacity: 0.8;">Stars</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-size: 1.5rem; color: #00ff41; font-weight: bold;">🔀 {repo_info['forks']}</div>
+                    <div style="font-size: 0.9rem; opacity: 0.8;">Forks</div>
+                </div>
+            </div>
+            <p style="color: #ffffff; margin-top: 15px; font-style: italic;">
+                "{repo_info['description']}"
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Analysis results in horizontal blocks
+    st.markdown("### 📊 Analysis Results")
+    
+    # Architecture Quality Block (Full width)
+    arch_items = result.get('architecture_quality', [])
+    if arch_items:
+        arch_text = " • ".join(arch_items[:3])  # Join with bullets for horizontal reading
+    else:
+        arch_text = "Well-structured repository • Good organization • Follows best practices"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,100,30,0.1)); 
+               border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #00ff41; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🏗️ Code Architecture
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {arch_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Critical Issues Block (Full width)
+    critical_items = result.get('critical_issues', [])
+    if critical_items:
+        critical_text = " • ".join(critical_items[:3])  # Join with bullets for horizontal reading
+    else:
+        critical_text = "No major security vulnerabilities found • Code appears well-maintained • No critical bugs detected"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(255,100,100,0.1), rgba(150,0,0,0.1)); 
+               border: 2px solid #ff6b6b; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ff6b6b; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🚨 Critical Issues
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {critical_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Improvement Priorities Block (Full width)
+    improvement_items = result.get('improvement_priorities', [])
+    if improvement_items:
+        improvement_text = " • ".join(improvement_items[:3])  # Join with bullets for horizontal reading
+    else:
+        improvement_text = "Add more comprehensive documentation • Consider adding automated tests • Enhance error handling"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(255,200,0,0.1), rgba(150,100,0,0.1)); 
+               border: 2px solid #ffd700; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ffd700; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🎯 Priority Improvements
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {improvement_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Summary section at the bottom (if available)
+    if result.get('project_overview'):
+        st.markdown("### 💡 Key Insights")
+        st.markdown(f"""
+        <div style="background: rgba(0,0,0,0.6); border: 1px solid #00ff41; border-radius: 10px; 
+                   padding: 20px; margin: 20px 0;">
+            <p style="color: #ffffff; font-size: 18px; line-height: 1.6; text-align: center; margin: 0;">
+                {result['project_overview']}
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Expandable raw response (moved to bottom and less prominent)
+    with st.expander("🔍 View Detailed Analysis", expanded=False):
+        st.code(result.get('raw_response', 'NO_DATA_AVAILABLE'), language='text')
+
+# Header with Matrix effect
+st.markdown("""
+<h1 style="text-align: center;">
+🤖 AI Code Analyzer
+</h1>
+<div style="text-align: center; margin-bottom: 30px;">
+    <p style="color: #00ff41; font-family: 'Orbitron', monospace; font-size: 20px; margin-bottom: 10px;">
+        <strong>Powered by Advanced AI Models</strong>
+    </p>
+    <div style="display: flex; justify-content: center; gap: 20px; flex-wrap: wrap;">
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            ✨ Bug Detection
+        </span>
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            🔒 Security Analysis
+        </span>
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            📦 GitHub Integration
+        </span>
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            ⚡ Instant Results
+        </span>
+    </div>
+</div>
+""", unsafe_allow_html=True)
+
+# Sidebar - The Matrix Control Panel
+with st.sidebar:
+    st.markdown("### 🎛️ Control Panel")
+    
+    # Model status
+    st.markdown("#### Available AI Models")
+    available_models = analyzer.available_models
+    
+    if not available_models:
+        st.error("❌ No AI models detected")
+        st.info("Please configure API keys in .env file")
+        st.stop()
+    
+    # Display available models with modern styling
+    for model, display_name in available_models.items():
+        st.markdown(f"""
+        <div style="background: rgba(0, 255, 65, 0.1); border: 1px solid #00ff41; padding: 10px; margin: 8px 0; border-radius: 8px;">
+        ✅ <strong>{display_name}</strong> <span style="color: #00ff41; font-size: 12px;">[Ready]</span>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # Analysis Mode Selection
+    st.markdown("#### Analysis Mode")
+    analysis_mode = st.radio(
+        "Choose what to analyze",
+        ["Code Analysis", "GitHub Repository"],
+        format_func=lambda x: f"📝 {x}" if x == "Code Analysis" else f"📦 {x}"
+    )
+    
+    if analysis_mode == "GitHub Repository":
+        st.markdown("#### Repository Analysis")
+        github_url = st.text_input(
+            "GitHub URL",
+            placeholder="https://github.com/owner/repo",
+            help="Enter a GitHub repository URL for analysis"
+        )
+        
+        analyze_github_button = st.button(
+            "🔍 Analyze Repository",
+            type="primary",
+            help="Analyze GitHub repository structure and code"
+        )
+    
+    st.markdown("---")
+    
+    # Analysis options
+    st.markdown("#### Analysis Settings")
+    
+    # Model selector with modern styling
+    selected_model = st.selectbox(
+        "Choose AI Model",
+        options=list(available_models.keys()),
+        format_func=lambda x: f"🤖 {available_models[x]}"
+    )
+    
+    # Multi-model analysis toggle
+    analyze_all = st.checkbox("🔄 Compare Multiple Models", value=False)
+    
+    # Language selection
+    languages = ["auto-detect", "python", "javascript", "java", "cpp", "csharp", "go", "rust", "php", "ruby", "swift", "kotlin"]
+    selected_language = st.selectbox(
+        "Programming Language", 
+        languages,
+        format_func=lambda x: "🔍 Auto-Detect" if x == "auto-detect" else f"💻 {x.upper()}"
+    )
+    
+    st.markdown("---")
+    
+    # Sample code injection
+    st.markdown("#### Quick Start Examples")
+    
+    if st.button("🐍 Try Python Example"):
+        st.session_state.code_input = """def calculate_total(items):
+    total = 0
+    for item in items:
+        total += item.price  # Potential AttributeError
+    return total
+
+# Missing validation
+items = None
+result = calculate_total(items)  # This will crash
+print(f"Total: {result}")
+"""
+    
+    if st.button("🌐 Try JavaScript Example"):
+        st.session_state.code_input = """function processUser(user) {
+    // Security issue: no input validation
+    document.innerHTML = user.name;  // XSS vulnerability
+    
+    // Logic error: undefined check
+    if (user.age > 18) {
+        return user.permissions.admin;  // Potential TypeError
+    }
+    
+    return false;
+}
+
+// Missing error handling
+const userData = getUser();  // Could be undefined
+processUser(userData);
+"""
+
+# Main Terminal Interface
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    if analysis_mode == "Code Analysis":
+        st.markdown("### 📝 Code Input")
+    
+    # File upload section
+        st.markdown("#### 📁 Upload File")
+    uploaded_file = st.file_uploader(
+            "Choose a code file",
+        type=['py', 'js', 'java', 'cpp', 'c', 'cs', 'go', 'rs', 'php', 'rb', 'swift', 'kt', 'txt'],
+            help="Upload code files for AI analysis"
+    )
+    
+    code_from_file = ""
+    if uploaded_file is not None:
+        # Read file content
+        try:
+            code_from_file = str(uploaded_file.read(), "utf-8")
+            file_size = len(code_from_file)
+            file_lines = len(code_from_file.splitlines())
+            
+            st.markdown(f"""
+            <div class="file-info">
+                ✅ <strong>File Uploaded Successfully</strong><br>
+                📄 <strong>Name:</strong> {uploaded_file.name}<br>
+                📏 <strong>Size:</strong> {file_size} bytes<br>
+                📊 <strong>Lines:</strong> {file_lines}<br>
+                🔍 <strong>Status:</strong> Ready for analysis
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Auto-populate the text area
+            st.session_state.code_input = code_from_file
+            
+        except UnicodeDecodeError:
+                st.error("🚨 File encoding error: Please use UTF-8 encoded files")
+        except Exception as e:
+                st.error(f"🚨 File read error: {str(e)}")
+    
+    # Code input with modern styling
+    code_input = st.text_area(
+            "Or paste your code here",
+        value=st.session_state.get('code_input', ''),
+        height=350,
+        key="code_input",
+        help="Paste code directly or upload file above"
+    )
+    
+    # Modern analyze button
+    analyze_button = st.button(
+        "🚀 Analyze Code",
+        type="primary",
+        help="Analyze your code with AI"
+    )
+    
+    else:  # GitHub Repository mode
+        st.markdown("### 📦 GitHub Analysis")
+        
+        if 'github_url' in locals():
+            if github_url:
+                st.markdown(f"""
+                <div class="file-info">
+                ✅ <strong>Repository Detected</strong><br>
+                📦 <strong>URL:</strong> {github_url}<br>
+                🔍 <strong>Status:</strong> Ready for analysis
+                </div>
+                """, unsafe_allow_html=True)
+            
+            st.markdown("""
+            #### 📋 What We'll Analyze
+            
+            **Repository Analysis includes:**
+            - 🏗️ Project structure and organization
+            - 📄 Key files (README, package.json, main source files)
+            - 🎯 Code quality and architecture assessment
+            - 🔒 Security vulnerabilities across the codebase
+            - 💡 Best practices and improvement suggestions
+            
+            **Note:** Only public repositories can be analyzed.
+            """)
+        
+        # Show sample repos
+        st.markdown("#### 📚 Try These Sample Repositories")
+        sample_repos = [
+            "https://github.com/microsoft/vscode",
+            "https://github.com/facebook/react",
+            "https://github.com/python/cpython"
+        ]
+        
+        for repo in sample_repos:
+            if st.button(f"📦 {repo.split('/')[-1]}", key=repo):
+                st.session_state.github_url_input = repo
+
+# Results Terminal
+with col2:
+    st.markdown("### 📊 Analysis Results")
+    
+    # Code Analysis Results
+    if analysis_mode == "Code Analysis":
+        if analyze_button:
+            if not code_input.strip():
+                st.error("🚨 Please enter some code to analyze or upload a file!")
+            else:
+                with st.spinner("🟢 Analyzing your code... Please wait..."):
+                    if analyze_all:
+                        # Multi-model analysis
+                        st.markdown("#### 🔄 MULTI_NETWORK_ANALYSIS_INITIATED")
+                        
+                        results = analyzer.analyze_with_all_models(
+                            code_input,
+                            selected_language if selected_language != "auto-detect" else None
+                        )
+                        
+                        # Display comparison metrics
+                        comparison = analyzer.compare_analyses(results)
+                        
+                        # Matrix-styled metrics
+                        metrics_cols = st.columns(4)
+                        with metrics_cols[0]:
+                            st.metric("AVG_SCORE", f"{comparison['average_score']}/100")
+                        with metrics_cols[1]:
+                            st.metric("NETWORKS", len(results))
+                        with metrics_cols[2]:
+                            st.metric("PEAK_SCORE", f"{max(comparison['model_scores'].values())}/100")
+                        with metrics_cols[3]:
+                            st.metric("SCAN_TIME", f"{comparison['analysis_time']:.1f}s")
+                        
+                        # Create tabs for each neural network
+                        tab_names = [f"🤖 {available_models[key]}" for key in results.keys()]
+                        tabs = st.tabs(tab_names)
+                        
+                        for idx, (model_key, result) in enumerate(results.items()):
+                            with tabs[idx]:
+                                display_matrix_analysis_result(result, available_models[model_key])
+                        
+                        # Consensus findings with Matrix styling
+                        if comparison.get('consensus_bugs') or comparison.get('consensus_security'):
+                            st.markdown("### 🤝 NEURAL_CONSENSUS_DETECTED")
+                            st.markdown("""
+                            <div style="background: rgba(255, 0, 0, 0.1); border: 2px solid #ff0000; padding: 15px; border-radius: 10px;">
+                            <strong>CRITICAL_PATTERNS_IDENTIFIED_BY_MULTIPLE_NETWORKS:</strong>
+                            </div>
+                            """, unsafe_allow_html=True)
+                            
+                            if comparison.get('consensus_bugs'):
+                                st.markdown("#### 🐛 CONSENSUS_BUGS")
+                                for bug in comparison['consensus_bugs']:
+                                    st.error(f"🚨 MULTIPLE_MODELS: {bug}")
+                            
+                            if comparison.get('consensus_security'):
+                                st.markdown("#### 🔒 CONSENSUS_SECURITY")
+                                for vuln in comparison['consensus_security']:
+                                    st.error(f"🚨 SECURITY_ALERT: {vuln}")
+                
+            else:
+                # Single model analysis
+                st.markdown(f"#### 🤖 {available_models[selected_model].upper()}_ANALYSIS")
+                
+                result = analyzer.analyze_code(
+                    code_input,
+                    selected_model,
+                    selected_language if selected_language != "auto-detect" else None
+                )
+                display_matrix_analysis_result(result, available_models[selected_model])
+    
+    # GitHub Analysis Results
+    else:  # GitHub Repository mode
+        if 'analyze_github_button' in locals() and analyze_github_button:
+            if not github_url.strip():
+                st.error("🚨 Please enter a GitHub repository URL!")
+            else:
+                with st.spinner("🟢 Analyzing GitHub repository... Please wait..."):
+                    result = analyzer.analyze_github_repo(github_url, selected_model)
+                    display_github_analysis_result(result, available_models[selected_model])
+
+# Instructions for new users
+if (analysis_mode == "Code Analysis" and not code_input.strip() and not analyze_button) or \
+   (analysis_mode == "GitHub Repository" and ('github_url' not in locals() or not github_url.strip()) and ('analyze_github_button' not in locals() or not analyze_github_button)):
+    
+    st.markdown("""
+    <div class="matrix-terminal" style="margin: 20px 0; text-align: center;">
+        <h2 style="color: #00ff41; margin-bottom: 30px; font-size: 2.5rem;">
+            🤖 AI Code Analyzer
+        </h2>
+        <p style="color: #00ff41; font-size: 1.3rem; margin-bottom: 30px;">
+            <strong>What can I do for you?</strong>
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Feature cards in columns
+    feature_col1, feature_col2 = st.columns(2)
+    
+    with feature_col1:
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">🐛 Find Bugs Instantly</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Spot crashes, logical errors, and edge cases before they hit production.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">🔒 Security Scanner</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Detect vulnerabilities like SQL injection, XSS, and insecure data handling.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with feature_col2:
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">📝 Code Quality Check</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Improve readability, maintainability, and follow best practices.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">📦 Repository Analysis</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Analyze entire GitHub repos for structure, issues, and improvements.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # How to get started section
+    st.markdown("""
+    <div style="background: rgba(0,0,0,0.7); border: 1px solid #00ff41; border-radius: 10px; 
+               padding: 20px; margin: 30px 0; text-align: center;">
+        <h3 style="color: #00ff41; margin-bottom: 20px;">🚀 Get Started in 3 Steps</h3>
+        <div style="display: flex; justify-content: space-around; flex-wrap: wrap;">
+            <div style="margin: 10px; color: #ffffff;">
+                <div style="background: #00ff41; color: #000; border-radius: 50%; width: 40px; height: 40px; 
+                           display: flex; align-items: center; justify-content: center; margin: 0 auto 10px; 
+                           font-weight: bold; font-size: 20px;">1</div>
+                <p><strong>Upload</strong><br>Paste code or GitHub URL</p>
+            </div>
+            <div style="margin: 10px; color: #ffffff;">
+                <div style="background: #00ff41; color: #000; border-radius: 50%; width: 40px; height: 40px; 
+                           display: flex; align-items: center; justify-content: center; margin: 0 auto 10px; 
+                           font-weight: bold; font-size: 20px;">2</div>
+                <p><strong>Choose AI</strong><br>Pick your preferred model</p>
+            </div>
+            <div style="margin: 10px; color: #ffffff;">
+                <div style="background: #00ff41; color: #000; border-radius: 50%; width: 40px; height: 40px; 
+                           display: flex; align-items: center; justify-content: center; margin: 0 auto 10px; 
+                           font-weight: bold; font-size: 20px;">3</div>
+                <p><strong>Analyze</strong><br>Get instant results</p>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Supported languages as badges
+    st.markdown("""
+    <div style="text-align: center; margin: 20px 0;">
+        <p style="color: #00ff41; font-size: 18px; margin-bottom: 15px;"><strong>Supported Languages:</strong></p>
+        <div style="display: flex; justify-content: center; flex-wrap: wrap; gap: 10px;">
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Python</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">JavaScript</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Java</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">C++</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Go</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Rust</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">+ More</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Footer with Matrix signature
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #00ff41; font-family: 'Share Tech Mono', monospace; padding: 20px;">
+    <p>🟢 POWERED_BY_NEURAL_NETWORKS • OPENAI • ANTHROPIC • DEEPSEEK • GOOGLE 🟢</p>
+    <p><em>"There is no spoon... only code to analyze."</em></p>
+    <p style="font-size: 12px;">MATRIX_ANALYZER_v3.0 • BUILD_2024 • SECURITY_CLEARANCE_OMEGA • FILE_UPLOAD_ENABLED</p>
+</div>
+""", unsafe_allow_html=True) 

matrix_final_backup.py

@@ -0,0 +1,978 @@
+import streamlit as st
+import os
+import time
+import random
+import sys
+from dotenv import load_dotenv
+from analyzer import CodeAnalyzer
+
+# Load environment variables
+load_dotenv()
+
+# Page config
+st.set_page_config(
+    page_title="Matrix Code Analyzer - Final",
+    page_icon="🟢",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Matrix CSS - Enhanced with file upload styling
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Share+Tech+Mono:wght@400&display=swap');
+    @import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@400;700;900&display=swap');
+    
+    /* Matrix Background */
+    .stApp {
+        background: linear-gradient(135deg, #0d1b0d 0%, #000000 50%, #0d1b0d 100%);
+        color: #00ff41;
+        font-family: 'Share Tech Mono', monospace;
+    }
+    
+    /* Matrix Code Rain Animation */
+    .matrix-bg {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+        z-index: -1;
+        opacity: 0.1;
+    }
+    
+    .matrix-char {
+        position: absolute;
+        color: #00ff41;
+        font-family: 'Share Tech Mono', monospace;
+        font-size: 14px;
+        animation: matrix-fall linear infinite;
+    }
+    
+    @keyframes matrix-fall {
+        0% { transform: translateY(-100vh); opacity: 1; }
+        100% { transform: translateY(100vh); opacity: 0; }
+    }
+    
+    /* Main Content Styling */
+    .main .block-container {
+        padding-top: 2rem;
+        background: rgba(0, 0, 0, 0.8);
+        border: 1px solid #00ff41;
+        border-radius: 10px;
+        box-shadow: 0 0 20px rgba(0, 255, 65, 0.3);
+    }
+    
+    /* Title Styling */
+    h1 {
+        font-family: 'Orbitron', monospace !important;
+        color: #00ff41 !important;
+        text-align: center !important;
+        text-shadow: 0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41;
+        font-weight: 900 !important;
+        margin-bottom: 2rem !important;
+        animation: glow 2s ease-in-out infinite alternate;
+    }
+    
+    @keyframes glow {
+        from { text-shadow: 0 0 5px #00ff41, 0 0 10px #00ff41, 0 0 15px #00ff41; }
+        to { text-shadow: 0 0 10px #00ff41, 0 0 20px #00ff41, 0 0 30px #00ff41; }
+    }
+    
+    /* Sidebar Styling */
+    .css-1d391kg {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        border-radius: 10px !important;
+    }
+    
+    /* Buttons */
+    .stButton > button {
+        background: linear-gradient(45deg, #003300, #006600) !important;
+        color: #00ff41 !important;
+        border: 2px solid #00ff41 !important;
+        border-radius: 5px !important;
+        font-family: 'Orbitron', monospace !important;
+        font-weight: bold !important;
+        text-transform: uppercase !important;
+        transition: all 0.3s ease !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.3) !important;
+    }
+    
+    .stButton > button:hover {
+        background: linear-gradient(45deg, #006600, #00aa00) !important;
+        box-shadow: 0 0 20px rgba(0, 255, 65, 0.6) !important;
+        transform: translateY(-2px) !important;
+    }
+    
+    /* File uploader styling */
+    .stFileUploader > div {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 2px dashed #00ff41 !important;
+        border-radius: 10px !important;
+        padding: 20px !important;
+    }
+    
+    .stFileUploader label {
+        color: #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+        font-weight: bold !important;
+    }
+    
+    /* Select boxes */
+    .stSelectbox > div > div {
+        background: rgba(0, 51, 0, 0.8) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* Text areas */
+    .stTextArea > div > div > textarea {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+        font-family: 'Share Tech Mono', monospace !important;
+    }
+    
+    /* Metrics */
+    .css-1xarl3l {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 1px solid #00ff41 !important;
+        border-radius: 5px !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.2) !important;
+    }
+    
+    /* Success/Info/Warning messages */
+    .stSuccess {
+        background: rgba(0, 255, 65, 0.1) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    .stInfo {
+        background: rgba(0, 255, 255, 0.1) !important;
+        border: 1px solid #00ffff !important;
+        color: #00ffff !important;
+    }
+    
+    .stWarning {
+        background: rgba(255, 255, 0, 0.1) !important;
+        border: 1px solid #ffff00 !important;
+        color: #ffff00 !important;
+    }
+    
+    .stError {
+        background: rgba(255, 0, 0, 0.1) !important;
+        border: 1px solid #ff0000 !important;
+        color: #ff0000 !important;
+    }
+    
+    /* Code blocks */
+    .stCode {
+        background: rgba(0, 0, 0, 0.9) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        background: rgba(0, 0, 0, 0.8) !important;
+        border-bottom: 2px solid #00ff41 !important;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        background: rgba(0, 51, 0, 0.3) !important;
+        color: #00ff41 !important;
+        border: 1px solid #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+    }
+    
+    .stTabs [aria-selected="true"] {
+        background: rgba(0, 255, 65, 0.2) !important;
+        box-shadow: 0 0 10px rgba(0, 255, 65, 0.5) !important;
+    }
+    
+    /* Matrix Terminal Effect */
+    .matrix-terminal {
+        background: rgba(0, 0, 0, 0.95) !important;
+        border: 2px solid #00ff41 !important;
+        border-radius: 10px !important;
+        padding: 20px !important;
+        font-family: 'Share Tech Mono', monospace !important;
+        color: #00ff41 !important;
+        box-shadow: 0 0 30px rgba(0, 255, 65, 0.4) !important;
+        position: relative !important;
+    }
+    
+    .matrix-terminal::before {
+        content: "MATRIX_ANALYZER_v3.0 > OPERATIONAL" !important;
+        position: absolute !important;
+        top: -15px !important;
+        left: 20px !important;
+        background: #000000 !important;
+        padding: 0 10px !important;
+        color: #00ff41 !important;
+        font-size: 12px !important;
+        font-weight: bold !important;
+    }
+    
+    /* Checkbox styling */
+    .stCheckbox > label {
+        color: #00ff41 !important;
+        font-family: 'Orbitron', monospace !important;
+    }
+    
+    /* Loading spinner */
+    .stSpinner > div {
+        border-color: #00ff41 transparent #00ff41 transparent !important;
+    }
+    
+    /* Expander */
+    .streamlit-expanderHeader {
+        background: rgba(0, 51, 0, 0.3) !important;
+        border: 1px solid #00ff41 !important;
+        color: #00ff41 !important;
+    }
+    
+    /* File info styling */
+    .file-info {
+        background: rgba(0, 255, 65, 0.1);
+        border: 1px solid #00ff41;
+        padding: 10px;
+        border-radius: 5px;
+        margin: 10px 0;
+        font-family: 'Share Tech Mono', monospace;
+    }
+</style>
+
+<div class="matrix-bg" id="matrix-bg"></div>
+
+<script>
+function createMatrixRain() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789@#$%^&*()_+-=[]{}|;:,.<>?";
+    const container = document.getElementById('matrix-bg');
+    
+    for (let i = 0; i < 50; i++) {
+        const char = document.createElement('div');
+        char.className = 'matrix-char';
+        char.textContent = chars[Math.floor(Math.random() * chars.length)];
+        char.style.left = Math.random() * 100 + '%';
+        char.style.animationDuration = (Math.random() * 3 + 2) + 's';
+        char.style.animationDelay = Math.random() * 2 + 's';
+        container.appendChild(char);
+    }
+}
+
+// Create matrix rain effect
+setTimeout(createMatrixRain, 100);
+</script>
+""", unsafe_allow_html=True)
+
+# Initialize analyzer
+def get_analyzer():
+    # Force reimport to ensure latest code
+    import importlib
+    import analyzer.code_analyzer
+    importlib.reload(analyzer.code_analyzer)
+    from analyzer.code_analyzer import CodeAnalyzer
+    return CodeAnalyzer()
+
+analyzer = get_analyzer()
+
+def display_matrix_analysis_result(result: dict, model_name: str):
+    """Display analysis result in clean, readable horizontal blocks."""
+    if 'error' in result:
+        st.error(f"🚨 SYSTEM ERROR: {result['error']}")
+        return
+    
+    # Quality score with modern styling
+    score = result['quality_score']
+    if score >= 80:
+        score_color = "#00ff41"
+        status = "EXCELLENT"
+    elif score >= 60:
+        score_color = "#ffff00"
+        status = "ACCEPTABLE"
+    else:
+        score_color = "#ff0000"
+        status = "NEEDS_WORK"
+    
+    # Header with score
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(0,255,65,0.15), rgba(0,255,65,0.05)); 
+               border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 20px 0; 
+               text-align: center;">
+        <h2 style="color: {score_color}; margin-bottom: 15px; font-size: 1.8rem;">
+            {model_name} Analysis
+        </h2>
+        <div style="display: flex; justify-content: center; gap: 30px; flex-wrap: wrap; color: #ffffff;">
+            <div style="text-align: center;">
+                <div style="font-size: 2rem; color: {score_color}; font-weight: bold;">{score}/100</div>
+                <div style="font-size: 0.9rem; opacity: 0.8;">{status}</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 1.2rem; color: #00ff41; font-weight: bold;">{result['language'].upper()}</div>
+                <div style="font-size: 0.9rem; opacity: 0.8;">Language</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 1.2rem; color: #00ff41; font-weight: bold;">{result['line_count']}</div>
+                <div style="font-size: 0.9rem; opacity: 0.8;">Lines</div>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Summary
+    if result.get('summary'):
+        st.markdown("### 📋 Code Overview")
+        st.markdown(f"""
+        <div style="background: rgba(0,0,0,0.6); border: 1px solid #00ff41; border-radius: 10px; 
+                   padding: 20px; margin: 20px 0;">
+            <p style="color: #ffffff; font-size: 18px; line-height: 1.6; text-align: center; margin: 0;">
+                {result['summary']}
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Analysis results in horizontal blocks
+    st.markdown("### 📊 Analysis Results")
+    
+    # Bug Detection Block (Full width)
+    bug_items = result.get('bugs', [])
+    if bug_items:
+        bug_text = " • ".join(bug_items[:3])  # Join with bullets for horizontal reading
+    else:
+        bug_text = "No critical bugs detected • Code logic appears sound • Edge cases handled well"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(255,100,100,0.1), rgba(150,0,0,0.1)); 
+               border: 2px solid #ff6b6b; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ff6b6b; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🐛 Bug Detection
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {bug_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Security Vulnerabilities Block (Full width)
+    security_items = result.get('security_vulnerabilities', [])
+    if security_items:
+        security_text = " • ".join(security_items[:3])  # Join with bullets for horizontal reading
+    else:
+        security_text = "No security vulnerabilities found • Follows security best practices • Input validation looks good"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(200,0,200,0.1), rgba(100,0,100,0.1)); 
+               border: 2px solid #ff00ff; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ff00ff; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🔒 Security Check
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {security_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Code Quality & Quick Fixes Block (Full width)
+    quality_items = result.get('quality_issues', []) + result.get('quick_fixes', [])
+    if quality_items:
+        quality_text = " • ".join(quality_items[:3])  # Join with bullets for horizontal reading
+    else:
+        quality_text = "Code is well-structured • Good naming conventions • Easy to read and maintain"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(0,200,255,0.1), rgba(0,100,150,0.1)); 
+               border: 2px solid #00ccff; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #00ccff; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            📝 Code Quality
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {quality_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Legacy sections (only if new sections are empty)
+    if not result.get('bugs') and not result.get('security_vulnerabilities') and not result.get('quality_issues'):
+        legacy_col1, legacy_col2 = st.columns(2)
+        
+        with legacy_col1:
+            # Legacy strengths
+            if result.get('strengths'):
+                st.markdown("#### ✅ Strengths")
+                for strength in result['strengths'][:3]:
+                    st.success(f"✓ {strength}")
+            
+            # Legacy issues
+        if result.get('issues'):
+                st.markdown("#### ⚠️ Issues")
+                for issue in result['issues'][:3]:
+                    st.warning(f"! {issue}")
+        
+        with legacy_col2:
+            # Legacy suggestions
+            if result.get('suggestions'):
+                st.markdown("#### 💡 Suggestions")
+                for suggestion in result['suggestions'][:3]:
+                    st.info(f"→ {suggestion}")
+            
+            # Legacy security concerns
+        if result.get('security_concerns'):
+                st.markdown("#### 🔒 Security Concerns")
+                for concern in result['security_concerns'][:3]:
+                    st.error(f"⚠ {concern}")
+    
+    # Expandable raw response (moved to bottom and less prominent)
+    with st.expander("🔍 View Detailed Analysis", expanded=False):
+        st.code(result.get('raw_response', 'NO_DATA_AVAILABLE'), language='text')
+
+def display_github_analysis_result(result: dict, model_name: str):
+    """Display GitHub repository analysis result in clean, readable horizontal blocks."""
+    if 'error' in result:
+        st.error(f"🚨 GITHUB ANALYSIS ERROR: {result['error']}")
+        return
+    
+    # Repository info in a clean header
+    if result.get('repository_info'):
+        repo_info = result['repository_info']
+        st.markdown(f"""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.15), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 20px 0; 
+                   text-align: center;">
+            <h2 style="color: #00ff41; margin-bottom: 20px; font-size: 1.8rem;">
+                📦 {repo_info['name']}
+            </h2>
+            <div style="display: flex; justify-content: center; gap: 30px; flex-wrap: wrap; color: #ffffff;">
+                <div style="text-align: center;">
+                    <div style="font-size: 1.5rem; color: #00ff41; font-weight: bold;">{repo_info['language']}</div>
+                    <div style="font-size: 0.9rem; opacity: 0.8;">Language</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-size: 1.5rem; color: #00ff41; font-weight: bold;">⭐ {repo_info['stars']}</div>
+                    <div style="font-size: 0.9rem; opacity: 0.8;">Stars</div>
+                </div>
+                <div style="text-align: center;">
+                    <div style="font-size: 1.5rem; color: #00ff41; font-weight: bold;">🔀 {repo_info['forks']}</div>
+                    <div style="font-size: 0.9rem; opacity: 0.8;">Forks</div>
+                </div>
+            </div>
+            <p style="color: #ffffff; margin-top: 15px; font-style: italic;">
+                "{repo_info['description']}"
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Analysis results in horizontal blocks
+    st.markdown("### 📊 Analysis Results")
+    
+    # Architecture Quality Block (Full width)
+    arch_items = result.get('architecture_quality', [])
+    if arch_items:
+        arch_text = " • ".join(arch_items[:3])  # Join with bullets for horizontal reading
+    else:
+        arch_text = "Well-structured repository • Good organization • Follows best practices"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,100,30,0.1)); 
+               border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #00ff41; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🏗️ Code Architecture
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {arch_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Critical Issues Block (Full width)
+    critical_items = result.get('critical_issues', [])
+    if critical_items:
+        critical_text = " • ".join(critical_items[:3])  # Join with bullets for horizontal reading
+    else:
+        critical_text = "No major security vulnerabilities found • Code appears well-maintained • No critical bugs detected"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(255,100,100,0.1), rgba(150,0,0,0.1)); 
+               border: 2px solid #ff6b6b; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ff6b6b; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🚨 Critical Issues
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {critical_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Improvement Priorities Block (Full width)
+    improvement_items = result.get('improvement_priorities', [])
+    if improvement_items:
+        improvement_text = " • ".join(improvement_items[:3])  # Join with bullets for horizontal reading
+    else:
+        improvement_text = "Add more comprehensive documentation • Consider adding automated tests • Enhance error handling"
+    
+    st.markdown(f"""
+    <div style="background: linear-gradient(135deg, rgba(255,200,0,0.1), rgba(150,100,0,0.1)); 
+               border: 2px solid #ffd700; border-radius: 15px; padding: 25px; margin: 15px 0;">
+        <h3 style="color: #ffd700; margin-bottom: 15px; text-align: center; font-size: 1.4rem;">
+            🎯 Priority Improvements
+        </h3>
+        <p style="color: #ffffff; font-size: 16px; line-height: 1.6; text-align: center; margin: 0;">
+            {improvement_text}
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Summary section at the bottom (if available)
+    if result.get('project_overview'):
+        st.markdown("### 💡 Key Insights")
+        st.markdown(f"""
+        <div style="background: rgba(0,0,0,0.6); border: 1px solid #00ff41; border-radius: 10px; 
+                   padding: 20px; margin: 20px 0;">
+            <p style="color: #ffffff; font-size: 18px; line-height: 1.6; text-align: center; margin: 0;">
+                {result['project_overview']}
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Expandable raw response (moved to bottom and less prominent)
+    with st.expander("🔍 View Detailed Analysis", expanded=False):
+        st.code(result.get('raw_response', 'NO_DATA_AVAILABLE'), language='text')
+
+# Header with Matrix effect
+st.markdown("""
+<h1 style="text-align: center;">
+🤖 AI Code Analyzer
+</h1>
+<div style="text-align: center; margin-bottom: 30px;">
+    <p style="color: #00ff41; font-family: 'Orbitron', monospace; font-size: 20px; margin-bottom: 10px;">
+        <strong>Powered by Advanced AI Models</strong>
+    </p>
+    <div style="display: flex; justify-content: center; gap: 20px; flex-wrap: wrap;">
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            ✨ Bug Detection
+        </span>
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            🔒 Security Analysis
+        </span>
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            📦 GitHub Integration
+        </span>
+        <span style="background: rgba(0,255,65,0.2); border: 1px solid #00ff41; padding: 8px 16px; 
+                    border-radius: 25px; font-size: 14px; color: #00ff41;">
+            ⚡ Instant Results
+        </span>
+    </div>
+</div>
+""", unsafe_allow_html=True)
+
+# Sidebar - The Matrix Control Panel
+with st.sidebar:
+    st.markdown("### 🎛️ Control Panel")
+    
+    # Model status
+    st.markdown("#### Available AI Models")
+    available_models = analyzer.available_models
+    
+    if not available_models:
+        st.error("❌ No AI models detected")
+        st.info("Please configure API keys in .env file")
+        st.stop()
+    
+    # Display available models with modern styling
+    for model, display_name in available_models.items():
+        st.markdown(f"""
+        <div style="background: rgba(0, 255, 65, 0.1); border: 1px solid #00ff41; padding: 10px; margin: 8px 0; border-radius: 8px;">
+        ✅ <strong>{display_name}</strong> <span style="color: #00ff41; font-size: 12px;">[Ready]</span>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # Analysis Mode Selection
+    st.markdown("#### Analysis Mode")
+    analysis_mode = st.radio(
+        "Choose what to analyze",
+        ["Code Analysis", "GitHub Repository"],
+        format_func=lambda x: f"📝 {x}" if x == "Code Analysis" else f"📦 {x}"
+    )
+    
+    if analysis_mode == "GitHub Repository":
+        st.markdown("#### Repository Analysis")
+        github_url = st.text_input(
+            "GitHub URL",
+            placeholder="https://github.com/owner/repo",
+            help="Enter a GitHub repository URL for analysis"
+        )
+        
+        analyze_github_button = st.button(
+            "🔍 Analyze Repository",
+            type="primary",
+            help="Analyze GitHub repository structure and code"
+        )
+    
+    st.markdown("---")
+    
+    # Analysis options
+    st.markdown("#### Analysis Settings")
+    
+    # Model selector with modern styling
+    selected_model = st.selectbox(
+        "Choose AI Model",
+        options=list(available_models.keys()),
+        format_func=lambda x: f"🤖 {available_models[x]}"
+    )
+    
+    # Multi-model analysis toggle
+    analyze_all = st.checkbox("🔄 Compare Multiple Models", value=False)
+    
+    # Language selection
+    languages = ["auto-detect", "python", "javascript", "java", "cpp", "csharp", "go", "rust", "php", "ruby", "swift", "kotlin"]
+    selected_language = st.selectbox(
+        "Programming Language", 
+        languages,
+        format_func=lambda x: "🔍 Auto-Detect" if x == "auto-detect" else f"💻 {x.upper()}"
+    )
+    
+    st.markdown("---")
+    
+    # Sample code injection
+    st.markdown("#### Quick Start Examples")
+    
+    if st.button("🐍 Try Python Example"):
+        st.session_state.code_input = """def calculate_total(items):
+    total = 0
+    for item in items:
+        total += item.price  # Potential AttributeError
+    return total
+
+# Missing validation
+items = None
+result = calculate_total(items)  # This will crash
+print(f"Total: {result}")
+"""
+    
+    if st.button("🌐 Try JavaScript Example"):
+        st.session_state.code_input = """function processUser(user) {
+    // Security issue: no input validation
+    document.innerHTML = user.name;  // XSS vulnerability
+    
+    // Logic error: undefined check
+    if (user.age > 18) {
+        return user.permissions.admin;  // Potential TypeError
+    }
+    
+    return false;
+}
+
+// Missing error handling
+const userData = getUser();  // Could be undefined
+processUser(userData);
+"""
+
+# Main Terminal Interface
+col1, col2 = st.columns([1, 1])
+
+with col1:
+    if analysis_mode == "Code Analysis":
+        st.markdown("### 📝 Code Input")
+    
+    # File upload section
+        st.markdown("#### 📁 Upload File")
+    uploaded_file = st.file_uploader(
+            "Choose a code file",
+        type=['py', 'js', 'java', 'cpp', 'c', 'cs', 'go', 'rs', 'php', 'rb', 'swift', 'kt', 'txt'],
+            help="Upload code files for AI analysis"
+    )
+    
+    code_from_file = ""
+    if uploaded_file is not None:
+        # Read file content
+        try:
+            code_from_file = str(uploaded_file.read(), "utf-8")
+            file_size = len(code_from_file)
+            file_lines = len(code_from_file.splitlines())
+            
+            st.markdown(f"""
+            <div class="file-info">
+                ✅ <strong>File Uploaded Successfully</strong><br>
+                📄 <strong>Name:</strong> {uploaded_file.name}<br>
+                📏 <strong>Size:</strong> {file_size} bytes<br>
+                📊 <strong>Lines:</strong> {file_lines}<br>
+                🔍 <strong>Status:</strong> Ready for analysis
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Auto-populate the text area
+            st.session_state.code_input = code_from_file
+            
+        except UnicodeDecodeError:
+                st.error("🚨 File encoding error: Please use UTF-8 encoded files")
+        except Exception as e:
+                st.error(f"🚨 File read error: {str(e)}")
+    
+    # Code input with modern styling
+    code_input = st.text_area(
+            "Or paste your code here",
+        value=st.session_state.get('code_input', ''),
+        height=350,
+        key="code_input",
+        help="Paste code directly or upload file above"
+    )
+    
+    # Modern analyze button
+    analyze_button = st.button(
+        "🚀 Analyze Code",
+        type="primary",
+        help="Analyze your code with AI"
+    )
+    
+else:  # GitHub Repository mode
+        st.markdown("### 📦 GitHub Analysis")
+        
+        if 'github_url' in locals():
+            if github_url:
+                st.markdown(f"""
+                <div class="file-info">
+                ✅ <strong>Repository Detected</strong><br>
+                📦 <strong>URL:</strong> {github_url}<br>
+                🔍 <strong>Status:</strong> Ready for analysis
+                </div>
+                """, unsafe_allow_html=True)
+            
+            st.markdown("""
+            #### 📋 What We'll Analyze
+            
+            **Repository Analysis includes:**
+            - 🏗️ Project structure and organization
+            - 📄 Key files (README, package.json, main source files)
+            - 🎯 Code quality and architecture assessment
+            - 🔒 Security vulnerabilities across the codebase
+            - 💡 Best practices and improvement suggestions
+            
+            **Note:** Only public repositories can be analyzed.
+            """)
+        
+        # Show sample repos
+        st.markdown("#### 📚 Try These Sample Repositories")
+        sample_repos = [
+            "https://github.com/microsoft/vscode",
+            "https://github.com/facebook/react",
+            "https://github.com/python/cpython"
+        ]
+        
+        for repo in sample_repos:
+            if st.button(f"📦 {repo.split('/')[-1]}", key=repo):
+                st.session_state.github_url_input = repo
+
+# Results Terminal
+with col2:
+    st.markdown("### 📊 Analysis Results")
+    
+    # Code Analysis Results
+    if analysis_mode == "Code Analysis":
+        if analyze_button:
+            if not code_input.strip():
+                st.error("🚨 Please enter some code to analyze or upload a file!")
+            else:
+                with st.spinner("🟢 Analyzing your code... Please wait..."):
+                    if analyze_all:
+                        # Multi-model analysis
+                        st.markdown("#### 🔄 MULTI_NETWORK_ANALYSIS_INITIATED")
+                        
+                        results = analyzer.analyze_with_all_models(
+                            code_input,
+                            selected_language if selected_language != "auto-detect" else None
+                        )
+                        
+                        # Display comparison metrics
+                        comparison = analyzer.compare_analyses(results)
+                        
+                        # Matrix-styled metrics
+                        metrics_cols = st.columns(4)
+                        with metrics_cols[0]:
+                            st.metric("AVG_SCORE", f"{comparison['average_score']}/100")
+                        with metrics_cols[1]:
+                            st.metric("NETWORKS", len(results))
+                        with metrics_cols[2]:
+                            st.metric("PEAK_SCORE", f"{max(comparison['model_scores'].values())}/100")
+                        with metrics_cols[3]:
+                            st.metric("SCAN_TIME", f"{comparison['analysis_time']:.1f}s")
+                        
+                        # Create tabs for each neural network
+                        tab_names = [f"🤖 {available_models[key]}" for key in results.keys()]
+                        tabs = st.tabs(tab_names)
+                        
+                        for idx, (model_key, result) in enumerate(results.items()):
+                            with tabs[idx]:
+                                display_matrix_analysis_result(result, available_models[model_key])
+                        
+                        # Consensus findings with Matrix styling
+                        if comparison.get('consensus_bugs') or comparison.get('consensus_security'):
+                            st.markdown("### 🤝 NEURAL_CONSENSUS_DETECTED")
+                            st.markdown("""
+                            <div style="background: rgba(255, 0, 0, 0.1); border: 2px solid #ff0000; padding: 15px; border-radius: 10px;">
+                            <strong>CRITICAL_PATTERNS_IDENTIFIED_BY_MULTIPLE_NETWORKS:</strong>
+                            </div>
+                            """, unsafe_allow_html=True)
+                            
+                            if comparison.get('consensus_bugs'):
+                                st.markdown("#### 🐛 CONSENSUS_BUGS")
+                                for bug in comparison['consensus_bugs']:
+                                    st.error(f"🚨 MULTIPLE_MODELS: {bug}")
+                            
+                            if comparison.get('consensus_security'):
+                                st.markdown("#### 🔒 CONSENSUS_SECURITY")
+                                for vuln in comparison['consensus_security']:
+                                    st.error(f"🚨 SECURITY_ALERT: {vuln}")
+                
+            else:
+                # Single model analysis
+                st.markdown(f"#### 🤖 {available_models[selected_model].upper()}_ANALYSIS")
+                
+                result = analyzer.analyze_code(
+                    code_input,
+                    selected_model,
+                    selected_language if selected_language != "auto-detect" else None
+                )
+                display_matrix_analysis_result(result, available_models[selected_model])
+    
+    # GitHub Analysis Results
+    else:  # GitHub Repository mode
+        if 'analyze_github_button' in locals() and analyze_github_button:
+            if not github_url.strip():
+                st.error("🚨 Please enter a GitHub repository URL!")
+            else:
+                with st.spinner("🟢 Analyzing GitHub repository... Please wait..."):
+                    result = analyzer.analyze_github_repo(github_url, selected_model)
+                    display_github_analysis_result(result, available_models[selected_model])
+
+# Instructions for new users
+if (analysis_mode == "Code Analysis" and not code_input.strip() and not analyze_button) or \
+   (analysis_mode == "GitHub Repository" and ('github_url' not in locals() or not github_url.strip()) and ('analyze_github_button' not in locals() or not analyze_github_button)):
+    
+    st.markdown("""
+    <div class="matrix-terminal" style="margin: 20px 0; text-align: center;">
+        <h2 style="color: #00ff41; margin-bottom: 30px; font-size: 2.5rem;">
+            🤖 AI Code Analyzer
+        </h2>
+        <p style="color: #00ff41; font-size: 1.3rem; margin-bottom: 30px;">
+            <strong>What can I do for you?</strong>
+        </p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Feature cards in columns
+    feature_col1, feature_col2 = st.columns(2)
+    
+    with feature_col1:
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">🐛 Find Bugs Instantly</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Spot crashes, logical errors, and edge cases before they hit production.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">🔒 Security Scanner</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Detect vulnerabilities like SQL injection, XSS, and insecure data handling.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with feature_col2:
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">📝 Code Quality Check</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Improve readability, maintainability, and follow best practices.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        st.markdown("""
+        <div style="background: linear-gradient(135deg, rgba(0,255,65,0.1), rgba(0,255,65,0.05)); 
+                   border: 2px solid #00ff41; border-radius: 15px; padding: 25px; margin: 10px 0; 
+                   box-shadow: 0 0 20px rgba(0,255,65,0.3);">
+            <h3 style="color: #00ff41; margin-bottom: 15px;">📦 Repository Analysis</h3>
+            <p style="color: #ffffff; font-size: 16px; line-height: 1.6;">
+                Analyze entire GitHub repos for structure, issues, and improvements.
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # How to get started section
+    st.markdown("""
+    <div style="background: rgba(0,0,0,0.7); border: 1px solid #00ff41; border-radius: 10px; 
+               padding: 20px; margin: 30px 0; text-align: center;">
+        <h3 style="color: #00ff41; margin-bottom: 20px;">🚀 Get Started in 3 Steps</h3>
+        <div style="display: flex; justify-content: space-around; flex-wrap: wrap;">
+            <div style="margin: 10px; color: #ffffff;">
+                <div style="background: #00ff41; color: #000; border-radius: 50%; width: 40px; height: 40px; 
+                           display: flex; align-items: center; justify-content: center; margin: 0 auto 10px; 
+                           font-weight: bold; font-size: 20px;">1</div>
+                <p><strong>Upload</strong><br>Paste code or GitHub URL</p>
+            </div>
+            <div style="margin: 10px; color: #ffffff;">
+                <div style="background: #00ff41; color: #000; border-radius: 50%; width: 40px; height: 40px; 
+                           display: flex; align-items: center; justify-content: center; margin: 0 auto 10px; 
+                           font-weight: bold; font-size: 20px;">2</div>
+                <p><strong>Choose AI</strong><br>Pick your preferred model</p>
+            </div>
+            <div style="margin: 10px; color: #ffffff;">
+                <div style="background: #00ff41; color: #000; border-radius: 50%; width: 40px; height: 40px; 
+                           display: flex; align-items: center; justify-content: center; margin: 0 auto 10px; 
+                           font-weight: bold; font-size: 20px;">3</div>
+                <p><strong>Analyze</strong><br>Get instant results</p>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Supported languages as badges
+    st.markdown("""
+    <div style="text-align: center; margin: 20px 0;">
+        <p style="color: #00ff41; font-size: 18px; margin-bottom: 15px;"><strong>Supported Languages:</strong></p>
+        <div style="display: flex; justify-content: center; flex-wrap: wrap; gap: 10px;">
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Python</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">JavaScript</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Java</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">C++</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Go</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">Rust</span>
+            <span style="background: linear-gradient(45deg, #00ff41, #00cc33); color: #000; padding: 8px 15px; 
+                        border-radius: 20px; font-weight: bold; font-size: 14px;">+ More</span>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+# Footer with Matrix signature
+st.markdown("---")
+st.markdown("""
+<div style="text-align: center; color: #00ff41; font-family: 'Share Tech Mono', monospace; padding: 20px;">
+    <p>🟢 POWERED_BY_NEURAL_NETWORKS • OPENAI • ANTHROPIC • DEEPSEEK • GOOGLE 🟢</p>
+    <p><em>"There is no spoon... only code to analyze."</em></p>
+    <p style="font-size: 12px;">MATRIX_ANALYZER_v3.0 • BUILD_2024 • SECURITY_CLEARANCE_OMEGA • FILE_UPLOAD_ENABLED</p>
+</div>
+""", unsafe_allow_html=True) 

netlify.toml

@@ -0,0 +1,9 @@
+[build]
+  command = "echo 'This is a Python Streamlit app - deploy to Render, Railway, or Heroku instead'"
+  publish = "."
+
+[[redirects]]
+  from = "/*"
+  to = "https://your-app-name.onrender.com/:splat"
+  status = 301
+  force = true 

render.yaml

@@ -0,0 +1,18 @@
+services:
+  - type: web
+    name: llm-code-analyzer
+    env: python
+    repo: https://github.com/arun3676/ai-code-analyzer.git
+    branch: main
+    buildCommand: pip install -r requirements.txt
+    startCommand: streamlit run app.py --server.port=$PORT --server.address=0.0.0.0
+    plan: free
+    envVars:
+      - key: OPENAI_API_KEY
+        sync: false
+      - key: ANTHROPIC_API_KEY
+        sync: false
+      - key: GEMINI_API_KEY
+        sync: false
+      - key: DEEPSEEK_API_KEY
+        sync: false 

requirements.txt

@@ -0,0 +1,6 @@
+streamlit==1.36.0
+openai>=1.0.0
+anthropic>=0.25.0
+google-generativeai>=0.6.0
+python-dotenv>=1.0.0
+requests>=2.32.0 

runtime.txt

@@ -0,0 +1 @@
+python-3.11.9 

streamlit.bat

@@ -0,0 +1,2 @@
+@echo off
+python -m streamlit %* 

test_app.py

@@ -0,0 +1,34 @@
+import streamlit as st
+from analyzer import CodeAnalyzer
+
+# Simple test app
+st.title("🔍 LLM Code Analyzer - Test")
+
+try:
+    analyzer = CodeAnalyzer()
+    available_models = analyzer.available_models
+    
+    st.success(f"✅ Analyzer loaded successfully!")
+    st.info(f"📊 Available models: {len(available_models)}")
+    
+    for model_key, model_name in available_models.items():
+        st.write(f"• {model_name}")
+    
+    # Simple code input
+    code_input = st.text_area("Enter code to analyze:", 
+                             value="def hello():\n    print('Hello, World!')",
+                             height=150)
+    
+    if st.button("Analyze"):
+        if code_input.strip():
+            with st.spinner("Analyzing..."):
+                result = analyzer.analyze_code(code_input, list(available_models.keys())[0])
+                st.json(result)
+        else:
+            st.warning("Please enter some code")
+            
+except Exception as e:
+    st.error(f"Error: {str(e)}")
+    st.write("Debug info:")
+    st.write(f"Python version: {sys.version}")
+    st.write(f"Working directory: {os.getcwd()}")