full code

Dockerfile

@@ -0,0 +1,26 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p uploads instance
+
+ENV FLASK_APP=app.py
+
+EXPOSE 7860
+
+CMD ["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=7860"]
+
+

README.md

@@ -1,60 +1,33 @@
----
-title: EvalAI
-emoji: 🔥
-colorFrom: pink
-colorTo: gray
-sdk: static
-pinned: false
-app_build_command: npm run build
-app_file: dist/index.html
-license: mit
-short_description: AI-Powered Project Evaluator
----
-
-# Svelte + TS + Vite
-
-This template should help get you started developing with Svelte and TypeScript in Vite.
-
-## Recommended IDE Setup
-
-[VS Code](https://code.visualstudio.com/) + [Svelte](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode).
-
-## Need an official Svelte framework?
-
-Check out [SvelteKit](https://github.com/sveltejs/kit#readme), which is also powered by Vite. Deploy anywhere with its serverless-first approach and adapt to various platforms, with out of the box support for TypeScript, SCSS, and Less, and easily-added support for mdsvex, GraphQL, PostCSS, Tailwind CSS, and more.
-
-## Technical considerations
-
-**Why use this over SvelteKit?**
-
-- It brings its own routing solution which might not be preferable for some users.
-- It is first and foremost a framework that just happens to use Vite under the hood, not a Vite app.
-
-This template contains as little as possible to get started with Vite + TypeScript + Svelte, while taking into account the developer experience with regards to HMR and intellisense. It demonstrates capabilities on par with the other `create-vite` templates and is a good starting point for beginners dipping their toes into a Vite + Svelte project.
-
-Should you later need the extended capabilities and extensibility provided by SvelteKit, the template has been structured similarly to SvelteKit so that it is easy to migrate.
-
-**Why `global.d.ts` instead of `compilerOptions.types` inside `jsconfig.json` or `tsconfig.json`?**
-
-Setting `compilerOptions.types` shuts out all other types not explicitly listed in the configuration. Using triple-slash references keeps the default TypeScript setting of accepting type information from the entire workspace, while also adding `svelte` and `vite/client` type information.
-
-**Why include `.vscode/extensions.json`?**
-
-Other templates indirectly recommend extensions via the README, but this file allows VS Code to prompt the user to install the recommended extension upon opening the project.
-
-**Why enable `allowJs` in the TS template?**
-
-While `allowJs: false` would indeed prevent the use of `.js` files in the project, it does not prevent the use of JavaScript syntax in `.svelte` files. In addition, it would force `checkJs: false`, bringing the worst of both worlds: not being able to guarantee the entire codebase is TypeScript, and also having worse typechecking for the existing JavaScript. In addition, there are valid use cases in which a mixed codebase may be relevant.
-
-**Why is HMR not preserving my local component state?**
-
-HMR state preservation comes with a number of gotchas! It has been disabled by default in both `svelte-hmr` and `@sveltejs/vite-plugin-svelte` due to its often surprising behavior. You can read the details [here](https://github.com/rixo/svelte-hmr#svelte-hmr).
+Deploying the Eval backend to Hugging Face Spaces (Docker)
+
+Prerequisites
+- A Hugging Face account and a new Space (set type to Docker)
+- Your OpenAI API key (if using OpenAI evaluation)
+
+Files included
+- app.py: Flask API exposing endpoints under /api
+- models.py, utils.py, evaluator.py, chunking_utils.py, config.py
+- requirements.txt: minimal dependencies for CPU deployment
+- Dockerfile: builds and runs the Flask API on port 7860
+
+Environment variables
+- OPENAI_API_KEY: set in the Space Secrets if Config.EVALUATION_MODEL is 'openai'
+- FLASK_SECRET_KEY (optional)
+- DATABASE_URL (optional; defaults to sqlite:///evalai_new.db)
+
+Build and run (locally)
+```bash
+docker build -t eval-backend ./Eval
+docker run -p 7860:7860 -e OPENAI_API_KEY=YOUR_KEY eval-backend
+```
 
-If you have state that's important to retain within a component, consider creating an external store which would not be replaced by HMR.
+Deploy on Spaces
+1) Create a new Space, select Docker as the SDK
+2) Upload the contents of the Eval/ folder to the Space root
+3) In the Space Settings, add a Secret named OPENAI_API_KEY
+4) Spaces will build using the Dockerfile and expose the API at / on port 7860
 
-```ts
-// store.ts
-// An extremely simple external store
-import { writable } from "svelte/store";
-export default writable(0);
+API quick check
+```bash
+curl -s https://<your-space>.hf.space/ | jq
 ```

app.py

@@ -0,0 +1,270 @@
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+from models import db, Hackathon, Submission, Evaluation
+from utils import allowed_file, save_uploaded_file, extract_code_from_files, extract_documentation
+from config import Config
+import json
+from datetime import datetime
+
+app = Flask(__name__)
+app.config.from_object(Config)
+app.config['MAX_CONTENT_LENGTH'] = Config.MAX_CONTENT_LENGTH  # Explicitly set the upload limit
+CORS(app)
+
+# Initialize database
+db.init_app(app)
+
+# Initialize AI evaluator (will load models on first use)
+evaluator = None
+
+def get_evaluator():
+    global evaluator
+    if evaluator is None:
+        print(f"Initializing AI evaluator (mode: {Config.EVALUATION_MODEL})...")
+        
+        if Config.EVALUATION_MODEL == 'openai':
+            from evaluator import AIEvaluator
+            evaluator = AIEvaluator()
+            print("✅ Using OpenAI GPT-4o for evaluation")
+        else:
+            from evaluator_opensource import OpenSourceEvaluator
+            evaluator = OpenSourceEvaluator()
+            print("✅ Using Open-Source LLM for evaluation")
+    
+    return evaluator
+
+# Create tables
+with app.app_context():
+    db.create_all()
+    print("Database initialized with productivity_score column!")
+
+# Routes
+@app.route('/')
+def index():
+    """API server info - Frontend is served separately on port 5173"""
+    return jsonify({
+        'name': 'EvalAI API',
+        'version': '1.0',
+        'status': 'running',
+        'frontend_url': 'http://localhost:5173',
+        'message': 'API is running. Access the UI at http://localhost:5173'
+    })
+
+# API Endpoints
+@app.route('/api/hackathons', methods=['GET'])
+def get_hackathons():
+    """Get all hackathons"""
+    hackathons = Hackathon.query.order_by(Hackathon.created_at.desc()).all()
+    return jsonify([h.to_dict() for h in hackathons])
+
+@app.route('/api/hackathon', methods=['POST'])
+def create_hackathon():
+    """Create a new hackathon"""
+    try:
+        data = request.json
+        
+        # Default criteria if not provided
+        default_criteria = [
+            {'name': 'Relevance', 'weight': 0.20, 'description': 'Alignment with theme'},
+            {'name': 'Technical Complexity', 'weight': 0.20, 'description': 'Code quality and sophistication'},
+            {'name': 'Creativity', 'weight': 0.20, 'description': 'Innovation and uniqueness'},
+            {'name': 'Documentation', 'weight': 0.20, 'description': 'Quality and completeness'},
+            {'name': 'Productivity', 'weight': 0.20, 'description': 'Code organization and efficiency'}
+        ]
+        
+        hackathon = Hackathon(
+            name=data['name'],
+            description=data['description'],
+            evaluation_prompt=data.get('evaluation_prompt', 'Evaluate this hackathon project.'),
+            criteria=json.dumps(data.get('criteria', default_criteria)),
+            host_email=data.get('host_email', ''),
+            deadline=datetime.fromisoformat(data['deadline']) if data.get('deadline') else None
+        )
+        
+        db.session.add(hackathon)
+        db.session.commit()
+        
+        return jsonify(hackathon.to_dict()), 201
+        
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': str(e)}), 400
+
+
+@app.route('/api/submissions', methods=['POST'])
+def create_submission():
+    """Create a single submission and evaluate it"""
+    try:
+        # Get form data
+        hackathon_id = request.form.get('hackathon_id')
+        team_name = request.form.get('team_name', 'Team')
+        participant_email = request.form.get('participant_email', 'participant@autoeval.ai')
+        project_name = request.form.get('project_name')
+        project_description = request.form.get('project_description', '')
+        
+        if not hackathon_id or not project_name:
+            return jsonify({'error': 'Hackathon ID and project name are required'}), 400
+        
+        # Get hackathon
+        hackathon = Hackathon.query.get(int(hackathon_id))
+        if not hackathon:
+            return jsonify({'error': 'Hackathon not found'}), 404
+        
+        # Get uploaded files
+        files = request.files.getlist('project_files')
+        if not files:
+            return jsonify({'error': 'At least one file is required'}), 400
+        
+        # Create submission
+        submission = Submission(
+            hackathon_id=hackathon.id,
+            team_name=team_name,
+            participant_email=participant_email,
+            project_name=project_name,
+            project_description=project_description
+        )
+        db.session.add(submission)
+        db.session.flush()
+        
+        # Save files
+        file_paths = []
+        for file in files:
+            if file and allowed_file(file.filename):
+                file_path = save_uploaded_file(file, submission.id)
+                file_paths.append(file_path)
+        
+        if not file_paths:
+            db.session.rollback()
+            return jsonify({'error': 'No valid files uploaded'}), 400
+        
+        # Extract content
+        submission.file_paths = json.dumps(file_paths)
+        submission.code_content = extract_code_from_files(file_paths)
+        submission.documentation_content = extract_documentation(file_paths, project_description)
+        
+        # Evaluate
+        print(f"🎯 Starting AI evaluation for project: {project_name}")
+        print(f"📁 Files uploaded: {len(file_paths)}")
+        print(f"📝 Code content length: {len(submission.code_content)} characters")
+        print(f"📄 Documentation length: {len(submission.documentation_content)} characters")
+        
+        eval_engine = get_evaluator()
+        scores = eval_engine.evaluate_submission(submission, hackathon)
+        
+        print("🎉 AI evaluation completed!")
+        print(f"⭐ Overall score: {scores['overall_score']}/10")
+        
+        # Create evaluation
+        evaluation = Evaluation(
+            submission_id=submission.id,
+            relevance_score=scores['relevance_score'],
+            technical_complexity_score=scores['technical_complexity_score'],
+            creativity_score=scores['creativity_score'],
+            documentation_score=scores['documentation_score'],
+            productivity_score=scores['productivity_score'],
+            overall_score=scores['overall_score'],
+            feedback=scores['feedback'],
+            detailed_scores=scores['detailed_scores']
+        )
+        
+        submission.evaluated = True
+        db.session.add(evaluation)
+        db.session.commit()
+        
+        response_data = {
+            'success': True,
+            'id': submission.id,
+            'hackathon_id': hackathon.id,
+            'overall_score': scores['overall_score']
+        }
+        
+        print("📤 Sending response to frontend:")
+        print(f"   ✅ Success: {response_data['success']}")
+        print(f"   🆔 Submission ID: {response_data['id']}")
+        print(f"   🏆 Hackathon ID: {response_data['hackathon_id']}")
+        print(f"   ⭐ Overall Score: {response_data['overall_score']}")
+        print("=" * 50)
+        
+        return jsonify(response_data), 201
+        
+    except Exception as e:
+        db.session.rollback()
+        print(f"Error creating submission: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/hackathon/<int:hackathon_id>/submissions', methods=['GET'])
+def get_hackathon_submissions(hackathon_id):
+    """Get all submissions for a hackathon"""
+    try:
+        hackathon = Hackathon.query.get_or_404(hackathon_id)
+        submissions = Submission.query.filter_by(hackathon_id=hackathon_id).order_by(Submission.submitted_at.desc()).all()
+        
+        result = []
+        for submission in submissions:
+            sub_dict = submission.to_dict()
+            if submission.evaluation:
+                sub_dict['evaluation'] = submission.evaluation.to_dict()
+            result.append(sub_dict)
+        
+        return jsonify(result)
+        
+    except Exception as e:
+        print(f"Error getting hackathon submissions: {str(e)}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/debug/submissions', methods=['GET'])
+def debug_submissions():
+    """Debug endpoint to list all submissions"""
+    try:
+        submissions = Submission.query.all()
+        result = []
+        for sub in submissions:
+            result.append({
+                'id': sub.id,
+                'project_name': sub.project_name,
+                'team_name': sub.team_name,
+                'evaluated': sub.evaluated,
+                'has_evaluation': sub.evaluation is not None,
+                'submitted_at': sub.submitted_at.isoformat() if sub.submitted_at else None
+            })
+        return jsonify(result)
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/results/<int:submission_id>', methods=['GET'])
+def get_individual_result(submission_id):
+    """Get evaluation results for a specific submission"""
+    try:
+        print(f"🔍 Looking for submission ID: {submission_id}")
+        submission = Submission.query.get(submission_id)
+        
+        if not submission:
+            print(f"❌ Submission {submission_id} not found")
+            return jsonify({'error': f'Submission {submission_id} not found'}), 404
+        
+        print(f"✅ Found submission: {submission.project_name}")
+        
+        if not submission.evaluation:
+            print(f"⚠️ Submission {submission_id} not yet evaluated")
+            return jsonify({'error': 'Submission not yet evaluated'}), 404
+        
+        print(f"✅ Evaluation found for submission {submission_id}")
+        
+        result = submission.to_dict()
+        result['evaluation'] = submission.evaluation.to_dict()
+        result['hackathon'] = submission.hackathon.to_dict()
+        
+        return jsonify(result)
+        
+    except Exception as e:
+        print(f"❌ Error getting individual result: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)
+
+

chunking_utils.py

@@ -0,0 +1,214 @@
+"""
+Utilities for chunking large code content for AI evaluation
+"""
+
+def chunk_text(text, max_chunk_size=3000, overlap=200):
+    """
+    Split text into overlapping chunks
+    
+    Args:
+        text (str): Text to chunk
+        max_chunk_size (int): Maximum characters per chunk
+        overlap (int): Number of characters to overlap between chunks
+    
+    Returns:
+        list: List of text chunks
+    """
+    if len(text) <= max_chunk_size:
+        return [text]
+    
+    chunks = []
+    start = 0
+    
+    while start < len(text):
+        # Calculate end position
+        end = start + max_chunk_size
+        
+        # If this is not the last chunk, try to break at a natural boundary
+        if end < len(text):
+            # Look for line breaks near the end
+            for i in range(min(100, max_chunk_size // 10)):  # Look back up to 100 chars
+                if text[end - i] == '\n':
+                    end = end - i + 1  # Include the newline
+                    break
+        
+        # Extract chunk
+        chunk = text[start:end].strip()
+        if chunk:
+            chunks.append(chunk)
+        
+        # Move start position (with overlap)
+        start = end - overlap if end < len(text) else end
+        
+        # Prevent infinite loop
+        if start >= len(text):
+            break
+    
+    return chunks
+
+def chunk_code_content(code_content, max_chunk_size=3000):
+    """
+    Intelligently chunk code content, trying to preserve function/class boundaries
+    
+    Args:
+        code_content (str): Code content to chunk
+        max_chunk_size (int): Maximum characters per chunk
+    
+    Returns:
+        list: List of code chunks with metadata
+    """
+    if len(code_content) <= max_chunk_size:
+        return [{
+            'content': code_content,
+            'chunk_id': 1,
+            'total_chunks': 1,
+            'size': len(code_content)
+        }]
+    
+    # Split by files first (if multiple files are concatenated)
+    file_sections = []
+    current_section = ""
+    
+    lines = code_content.split('\n')
+    for line in lines:
+        # Look for file separators or headers
+        if line.startswith('===') or line.startswith('---') or 'File:' in line:
+            if current_section.strip():
+                file_sections.append(current_section.strip())
+            current_section = line + '\n'
+        else:
+            current_section += line + '\n'
+    
+    # Add the last section
+    if current_section.strip():
+        file_sections.append(current_section.strip())
+    
+    # If no file sections found, treat as single content
+    if len(file_sections) <= 1:
+        file_sections = [code_content]
+    
+    # Chunk each file section
+    all_chunks = []
+    chunk_counter = 1
+    
+    for section in file_sections:
+        if len(section) <= max_chunk_size:
+            all_chunks.append({
+                'content': section,
+                'chunk_id': chunk_counter,
+                'size': len(section)
+            })
+            chunk_counter += 1
+        else:
+            # Split large sections into smaller chunks
+            text_chunks = chunk_text(section, max_chunk_size, overlap=300)
+            for chunk_text in text_chunks:
+                all_chunks.append({
+                    'content': chunk_text,
+                    'chunk_id': chunk_counter,
+                    'size': len(chunk_text)
+                })
+                chunk_counter += 1
+    
+    # Add total_chunks to all chunks
+    total_chunks = len(all_chunks)
+    for chunk in all_chunks:
+        chunk['total_chunks'] = total_chunks
+    
+    return all_chunks
+
+def create_chunk_summary(chunks):
+    """
+    Create a summary of all chunks for context
+    
+    Args:
+        chunks (list): List of chunk dictionaries
+    
+    Returns:
+        str: Summary of chunks
+    """
+    total_size = sum(chunk['size'] for chunk in chunks)
+    
+    summary = f"""
+Code Analysis Summary:
+- Total chunks: {len(chunks)}
+- Total content size: {total_size:,} characters
+- Average chunk size: {total_size // len(chunks):,} characters
+
+Chunk breakdown:
+"""
+    
+    for i, chunk in enumerate(chunks, 1):
+        preview = chunk['content'][:100].replace('\n', ' ')
+        summary += f"  Chunk {i}: {chunk['size']:,} chars - {preview}...\n"
+    
+    return summary
+
+def combine_chunk_evaluations(chunk_results):
+    """
+    Combine evaluation results from multiple chunks
+    
+    Args:
+        chunk_results (list): List of evaluation results from each chunk
+    
+    Returns:
+        dict: Combined evaluation result
+    """
+    if not chunk_results:
+        return {
+            'relevance_score': 5.0,
+            'technical_complexity_score': 5.0,
+            'creativity_score': 5.0,
+            'documentation_score': 5.0,
+            'productivity_score': 5.0,
+            'overall_score': 5.0,
+            'feedback': 'No evaluation results to combine.',
+            'detailed_scores': '{}'
+        }
+    
+    if len(chunk_results) == 1:
+        return chunk_results[0]
+    
+    # Calculate weighted averages based on chunk sizes
+    total_weight = sum(result.get('chunk_weight', 1) for result in chunk_results)
+    
+    combined_scores = {
+        'relevance_score': 0,
+        'technical_complexity_score': 0,
+        'creativity_score': 0,
+        'documentation_score': 0,
+        'productivity_score': 0
+    }
+    
+    feedbacks = []
+    
+    for result in chunk_results:
+        weight = result.get('chunk_weight', 1) / total_weight
+        
+        for score_key in combined_scores:
+            combined_scores[score_key] += result.get(score_key, 5.0) * weight
+        
+        if result.get('feedback'):
+            feedbacks.append(f"Chunk {result.get('chunk_id', '?')}: {result['feedback']}")
+    
+    # Calculate overall score
+    overall_score = sum(combined_scores.values()) / len(combined_scores)
+    
+    # Combine feedback
+    combined_feedback = f"""
+Multi-chunk evaluation completed ({len(chunk_results)} chunks analyzed):
+
+""" + "\n\n".join(feedbacks)
+    
+    return {
+        'relevance_score': round(combined_scores['relevance_score'], 1),
+        'technical_complexity_score': round(combined_scores['technical_complexity_score'], 1),
+        'creativity_score': round(combined_scores['creativity_score'], 1),
+        'documentation_score': round(combined_scores['documentation_score'], 1),
+        'productivity_score': round(combined_scores['productivity_score'], 1),
+        'overall_score': round(overall_score, 1),
+        'feedback': combined_feedback,
+        'detailed_scores': '{"note": "Combined from multiple chunks"}'
+    }
+
+

config.py

@@ -0,0 +1,63 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Config:
+    SECRET_KEY = os.getenv('FLASK_SECRET_KEY', 'dev-secret-key-change-in-production')
+    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL', 'sqlite:///evalai_new.db')
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    UPLOAD_FOLDER = 'uploads'
+    MAX_CONTENT_LENGTH = 5 * 1024 * 1024 * 1024  # 5GB max file size
+    ALLOWED_EXTENSIONS = {
+        # Core programming languages
+        'py', 'js', 'ts', 'jsx', 'tsx', 'java', 'cpp', 'c', 'h', 'hpp', 'cs', 'php', 'rb', 'go', 'rs', 'swift', 'kt', 'scala', 'r', 'matlab', 'm',
+        
+        # Web technologies
+        'html', 'htm', 'css', 'scss', 'sass', 'less', 'vue', 'svelte', 'jsx', 'tsx',
+        
+        # Configuration and data
+        'json', 'xml', 'yml', 'yaml', 'toml', 'ini', 'cfg', 'conf', 'env', 'properties',
+        
+        # Documentation
+        'md', 'txt', 'rst', 'adoc', 'tex',
+        
+        # Scripts and automation
+        'sh', 'bash', 'zsh', 'fish', 'ps1', 'bat', 'cmd',
+        
+        # Database and queries
+        'sql', 'sqlite', 'db',
+        
+        # Mobile development
+        'dart', 'flutter', 'xaml',
+        
+        # Data science and ML
+        'ipynb', 'rmd', 'py', 'r',
+        
+        # Build and deployment
+        'dockerfile', 'docker-compose', 'makefile', 'cmake', 'gradle', 'maven',
+        
+        # Archives
+        'zip', 'tar', 'gz',
+        
+        # Office documents (for documentation)
+        'pdf', 'doc', 'docx', 'ppt', 'pptx', 'xls', 'xlsx'
+    }
+    
+    # RAG Configuration
+    # EVALUATION_MODEL = 'opensource'  # 'opensource' (Llama-3-8B) or 'openai' (GPT-4) ⭐ USING OPENAI
+    EVALUATION_MODEL = 'openai'  # 'opensource' (Llama-3-8B) or 'openai' (GPT-4) ⭐ USING OPENAI
+    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', '')  # Set in environment or .env file
+    EMBEDDING_MODEL = 'all-MiniLM-L6-v2'  # Can use 'microsoft/unixcoder-base' for code-specific
+    CHUNK_SIZE = 512  # Token size for chunks
+    CHUNK_OVERLAP = 128  # Overlap between chunks
+    RETRIEVAL_TOP_K = 8  # Number of chunks to retrieve
+    MAX_CONTEXT_TOKENS = 2000  # Max tokens to send to LLM
+    
+    # LLM Configuration
+    LLM_MODEL = 'meta-llama/Meta-Llama-3-8B-Instruct'  # Main evaluation model
+    LLM_TEMPERATURE = 0.3  # Lower = more deterministic
+    LLM_MAX_TOKENS = 512  # Max tokens in response
+    USE_QUANTIZATION = True  # Use 4-bit quantization (faster & uses ~4GB VRAM instead of 16GB)
+
+

evaluator.py

@@ -0,0 +1,384 @@
+import os
+import openai
+from openai import OpenAI
+import json
+import re
+from config import Config
+from chunking_utils import chunk_code_content, combine_chunk_evaluations, create_chunk_summary
+
+class AIEvaluator:
+    def __init__(self):
+        self.model = Config.EVALUATION_MODEL
+        if self.model == 'openai':
+            # Set API key for OpenAI
+            if not Config.OPENAI_API_KEY:
+                raise ValueError("OpenAI API key not found. Please set OPENAI_API_KEY in your environment or .env file.")
+            
+            try:
+                # Initialize OpenAI client (v1.0+ style)
+                self.client = OpenAI(api_key=Config.OPENAI_API_KEY)
+                print("✅ OpenAI client initialized successfully")
+            except Exception as e:
+                print(f"❌ Error initializing OpenAI client: {e}")
+                raise e
+    
+    def evaluate_submission(self, submission, hackathon):
+        """
+        Evaluate a submission based on the hackathon criteria
+        """
+        if self.model == 'openai':
+            # Check if content is too large and needs chunking
+            code_content = submission.code_content or ""
+            doc_content = submission.documentation_content or ""
+            total_content = code_content + doc_content
+            
+            # If content is large, use chunked evaluation
+            if len(total_content) > 3000:  # 3K characters threshold (force chunking earlier)
+                print(f"📊 Large content detected ({len(total_content):,} chars), using chunked evaluation...")
+                return self._evaluate_with_chunking(submission, hackathon)
+            else:
+                print(f"📊 Standard evaluation for content ({len(total_content):,} chars)...")
+                return self._evaluate_with_openai(submission, hackathon)
+        else:
+            return self._evaluate_with_unixcoder(submission, hackathon)
+    
+    def _evaluate_with_openai(self, submission, hackathon):
+        """
+        Use OpenAI GPT-4 to evaluate the submission
+        """
+        evaluation_prompt = self._build_evaluation_prompt(submission, hackathon)
+        
+        print("📋 EVALUATION PROMPT BEING SENT:")
+        print("=" * 60)
+        print(evaluation_prompt[:500] + "..." if len(evaluation_prompt) > 500 else evaluation_prompt)
+        print("=" * 60)
+        
+        try:
+            print("🚀 Sending request to OpenAI GPT-4o...")
+            print(f"📝 Evaluation prompt length: {len(evaluation_prompt)} characters")
+            
+            # Use OpenAI client to generate evaluation
+            response = self.client.chat.completions.create(
+                model="gpt-4o",  # Using GPT-4o for best quality and speed
+                messages=[
+                    {"role": "system", "content": "You are a STRICT technical evaluator and hackathon judge. You must be critical, use the full scoring range 0-10, and provide differentiated scores. DO NOT give grade inflation. Most projects should score in the 4-7 range. Be harsh but fair."},
+                    {"role": "user", "content": evaluation_prompt}
+                ],
+                temperature=0.1,  # Lower temperature for more consistent, strict evaluation
+                max_tokens=2000
+            )
+            
+            result_text = response.choices[0].message.content
+            print("✅ OpenAI Response received!")
+            print("=" * 80)
+            print("🤖 OPENAI GPT-4o RESPONSE:")
+            print("=" * 80)
+            print(result_text)
+            print("=" * 80)
+            print(f"📊 Response length: {len(result_text)} characters")
+            print(f"💰 Tokens used: {response.usage.total_tokens if hasattr(response, 'usage') else 'Unknown'}")
+            
+            parsed_result = self._parse_evaluation_result(result_text)
+            print("✅ Response parsed successfully!")
+            print(f"📈 Parsed scores: {parsed_result}")
+            
+            return parsed_result
+            
+        except Exception as e:
+            print(f"❌ Error in OpenAI evaluation: {str(e)}")
+            print("🔄 Falling back to default scores...")
+            return self._generate_fallback_scores()
+    
+    def _evaluate_with_chunking(self, submission, hackathon):
+        """
+        Evaluate large submissions by chunking the content
+        """
+        try:
+            # Chunk the code content
+            code_content = submission.code_content or ""
+            chunks = chunk_code_content(code_content, max_chunk_size=4000)
+            
+            print(f"📦 Created {len(chunks)} chunks for evaluation")
+            print(create_chunk_summary(chunks))
+            
+            chunk_results = []
+            
+            for i, chunk in enumerate(chunks, 1):
+                print(f"🔍 Evaluating chunk {i}/{len(chunks)} ({chunk['size']:,} chars)...")
+                
+                # Create a temporary submission object for this chunk
+                chunk_submission = type('ChunkSubmission', (), {
+                    'code_content': chunk['content'],
+                    'documentation_content': submission.documentation_content or "",
+                    'project_name': f"{submission.project_name} (Chunk {i})",
+                    'project_description': submission.project_description,
+                    'team_name': submission.team_name,
+                    'participant_email': submission.participant_email
+                })()
+                
+                # Evaluate this chunk
+                chunk_result = self._evaluate_with_openai(chunk_submission, hackathon)
+                
+                # Add chunk metadata
+                chunk_result['chunk_id'] = i
+                chunk_result['chunk_weight'] = chunk['size']  # Weight by content size
+                
+                chunk_results.append(chunk_result)
+                
+                print(f"✅ Chunk {i} evaluated: {chunk_result['overall_score']}/10")
+            
+            # Combine results from all chunks
+            print("🔄 Combining results from all chunks...")
+            combined_result = combine_chunk_evaluations(chunk_results)
+            
+            print(f"🎯 Final combined score: {combined_result['overall_score']}/10")
+            return combined_result
+            
+        except Exception as e:
+            print(f"❌ Error in chunked evaluation: {str(e)}")
+            print("🔄 Falling back to standard evaluation...")
+            # Fallback to standard evaluation with truncated content
+            return self._evaluate_with_openai_truncated(submission, hackathon)
+    
+    def _evaluate_with_openai_truncated(self, submission, hackathon):
+        """
+        Evaluate with truncated content as fallback
+        """
+        # Truncate content to manageable size
+        code_content = (submission.code_content or "")[:4000]
+        doc_content = (submission.documentation_content or "")[:2000]
+        
+        # Create truncated submission
+        truncated_submission = type('TruncatedSubmission', (), {
+            'code_content': code_content,
+            'documentation_content': doc_content,
+            'project_name': submission.project_name,
+            'project_description': submission.project_description,
+            'team_name': submission.team_name,
+            'participant_email': submission.participant_email
+        })()
+        
+        print("⚠️ Using truncated content for evaluation")
+        result = self._evaluate_with_openai(truncated_submission, hackathon)
+        
+        # Keep feedback as-is without prefixing a truncation note
+        return result
+    
+    def _build_evaluation_prompt(self, submission, hackathon):
+        """
+        Build the prompt for AI evaluation
+        """
+        criteria = json.loads(hackathon.criteria) if hackathon.criteria else self._get_default_criteria()
+        
+        prompt = f"""
+# STRICT Hackathon Evaluation - NO GRADE INFLATION
+
+## Hackathon Information
+**Name**: {hackathon.name}
+**Theme/Description**: {hackathon.description}
+
+## Evaluation Criteria
+{hackathon.evaluation_prompt}
+
+## Submission to Evaluate
+**Team**: {submission.team_name}
+**Project Name**: {submission.project_name}
+**Description**: {submission.project_description}
+
+### Code Content
+```
+{self._truncate_content(submission.code_content, 3000)}
+```
+
+### Documentation
+```
+{self._truncate_content(submission.documentation_content, 2000)}
+```
+
+## CRITICAL EVALUATION INSTRUCTIONS
+
+You are a STRICT technical evaluator. Use the FULL range of scores 0-10. DO NOT give similar scores to different projects.
+
+### SCORING GUIDELINES (BE HARSH AND REALISTIC):
+
+**0-2: Poor/Failing**
+- Major issues, non-functional, or completely irrelevant
+- Severe security vulnerabilities or broken code
+- No documentation or completely unclear
+
+**3-4: Below Average**
+- Basic functionality but significant flaws
+- Poor code quality, structure, or practices
+- Minimal effort or incomplete implementation
+
+**5-6: Average/Acceptable**
+- Works as intended with minor issues
+- Standard implementation, nothing special
+- Adequate documentation and code quality
+
+**7-8: Good/Above Average**
+- Well-implemented with good practices
+- Shows clear understanding and effort
+- Good documentation and structure
+
+**9-10: Excellent/Outstanding**
+- Exceptional quality, innovative approach
+- Production-ready code with best practices
+- Comprehensive documentation and testing
+
+        ## STRICT EVALUATION CRITERIA:
+
+1. **Relevance (0-10)**: Does it ACTUALLY solve the problem stated? Is it directly related to the theme?
+2. **Technical Complexity (0-10)**: How sophisticated is the implementation? Rate based on actual technical depth, not just lines of code.
+3. **Creativity (0-10)**: Is this a unique approach or just a standard tutorial implementation?
+4. **Documentation (0-10)**: Is there proper README, comments, setup instructions? Can someone else run this?
+5. **Productivity (0-10)**: Code organization, error handling, scalability, maintainability.
+
+        ## ADDITIONAL KEY-POINT ANALYSIS (brief, 1-2 sentences each):
+        - Out of the box thinking: How original/novel is the approach?
+        - Problem-solving skills: How effectively does the code decompose and solve the problem?
+        - Research capabilities: Evidence of learning, citations, comparisons, benchmarking, or exploration
+        - Understanding the business: Does it align with real user/business needs and constraints?
+        - Use of non-famous tools or frameworks: Any lesser-known tech used purposefully
+
+        ## MANDATORY REQUIREMENTS:
+- VARY your scores significantly between projects
+- Use decimals (e.g., 3.2, 6.7, 8.1) for precision
+- Be CRITICAL and identify real weaknesses
+- NO GRADE INFLATION - most projects should score 4-7 range
+- Only exceptional projects deserve 8-10
+- Don't hesitate to give low scores (1-3) for poor work
+
+        ## Response Format (STRICT JSON):
+
+```json
+{{
+  "relevance_score": <precise score 0-10 with 1 decimal>,
+  "technical_complexity_score": <precise score 0-10 with 1 decimal>,
+  "creativity_score": <precise score 0-10 with 1 decimal>,
+  "documentation_score": <precise score 0-10 with 1 decimal>,
+  "productivity_score": <precise score 0-10 with 1 decimal>,
+  "overall_score": <calculated average with 1 decimal>,
+  "feedback": "<HONEST, CRITICAL feedback. Point out specific flaws, missing features, and areas for improvement. Don't sugarcoat.>",
+  "detailed_scores": {{
+    "relevance_justification": "<specific reasons for this score>",
+    "technical_justification": "<specific technical assessment>",
+    "creativity_justification": "<specific creativity assessment>",
+    "documentation_justification": "<specific documentation assessment>",
+            "productivity_justification": "<specific code quality assessment>",
+            
+            "out_of_box_thinking": "<1-2 sentence assessment>",
+            "problem_solving_skills": "<1-2 sentence assessment>",
+            "research_capabilities": "<1-2 sentence assessment>",
+            "business_understanding": "<1-2 sentence assessment>",
+            "non_famous_tools_usage": "<1-2 sentence assessment>"
+  }}
+}}
+```
+
+REMEMBER: Be a tough but fair judge. Real-world projects have flaws - identify them!
+"""
+        return prompt
+    
+    def _truncate_content(self, content, max_length=2000):
+        """
+        Truncate content to fit within token limits
+        """
+        if not content:
+            return "No content provided"
+        
+        if len(content) > max_length:
+            return content[:max_length] + "\n... [content truncated]"
+        return content
+    
+    def _parse_evaluation_result(self, result_text):
+        """
+        Parse the AI response into structured scores
+        """
+        try:
+            # Try to extract JSON from the response
+            json_match = re.search(r'```json\s*(.*?)\s*```', result_text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1)
+            else:
+                # Try to find any JSON object in the response
+                json_match = re.search(r'\{.*\}', result_text, re.DOTALL)
+                json_str = json_match.group(0) if json_match else result_text
+            
+            scores = json.loads(json_str)
+            
+            # Validate and normalize scores
+            return {
+                'relevance_score': self._normalize_score(scores.get('relevance_score', 5.0)),
+                'technical_complexity_score': self._normalize_score(scores.get('technical_complexity_score', 5.0)),
+                'creativity_score': self._normalize_score(scores.get('creativity_score', 5.0)),
+                'documentation_score': self._normalize_score(scores.get('documentation_score', 5.0)),
+                'productivity_score': self._normalize_score(scores.get('productivity_score', 5.0)),
+                'overall_score': self._normalize_score(scores.get('overall_score', 5.0)),
+                'feedback': scores.get('feedback', 'Evaluation completed.'),
+                'detailed_scores': json.dumps(scores.get('detailed_scores', {}))
+            }
+        except Exception as e:
+            print(f"Error parsing evaluation result: {str(e)}")
+            # Return fallback scores if parsing fails
+            return self._generate_fallback_scores()
+    
+    def _normalize_score(self, score):
+        """
+        Ensure score is between 0 and 10
+        """
+        try:
+            score = float(score)
+            return max(0.0, min(10.0, score))
+        except:
+            return 5.0
+    
+    def _generate_fallback_scores(self):
+        """
+        Generate varied fallback scores when evaluation fails
+        """
+        import random
+        
+        # Generate varied scores in the 4-6 range (realistic fallback)
+        scores = {
+            'relevance_score': round(random.uniform(4.0, 6.5), 1),
+            'technical_complexity_score': round(random.uniform(3.5, 6.0), 1),
+            'creativity_score': round(random.uniform(3.0, 5.5), 1),
+            'documentation_score': round(random.uniform(2.5, 5.0), 1),
+            'productivity_score': round(random.uniform(3.5, 6.0), 1)
+        }
+        
+        # Calculate overall as average
+        overall = sum(scores.values()) / len(scores)
+        
+        return {
+            **scores,
+            'overall_score': round(overall, 1),
+            'feedback': 'Automatic evaluation completed due to technical issue. Scores are estimated based on basic analysis. Manual review strongly recommended for accurate assessment.',
+            'detailed_scores': json.dumps({
+                'note': 'Fallback scores - technical evaluation failed',
+                'recommendation': 'Manual review required for accurate scoring'
+            })
+        }
+    
+    def _get_default_criteria(self):
+        """
+        Get default evaluation criteria
+        """
+        return [
+            {'name': 'Relevance', 'weight': 0.20},
+            {'name': 'Technical Complexity', 'weight': 0.20},
+            {'name': 'Creativity', 'weight': 0.20},
+            {'name': 'Documentation', 'weight': 0.20},
+            {'name': 'Productivity', 'weight': 0.20}
+        ]
+    
+    def _evaluate_with_unixcoder(self, submission, hackathon):
+        """
+        Use UniXCoder for evaluation (placeholder for future implementation)
+        """
+        # This would use UniXCoder embeddings and similarity scoring
+        # For MVP, we'll fall back to OpenAI
+        return self._evaluate_with_openai(submission, hackathon)
+
+

index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Vite + Svelte + TS</title>
+    <title>EvalAI - AI Project Evaluator</title>
   </head>
   <body>
     <div id="app"></div>

models.py

@@ -0,0 +1,101 @@
+from flask_sqlalchemy import SQLAlchemy
+from datetime import datetime, timezone
+import json
+
+db = SQLAlchemy()
+
+class Hackathon(db.Model):
+    __tablename__ = 'hackathons'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(200), nullable=False)
+    description = db.Column(db.Text, nullable=False)
+    evaluation_prompt = db.Column(db.Text, nullable=False)
+    criteria = db.Column(db.Text, nullable=False)  # JSON string of criteria
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    deadline = db.Column(db.DateTime)
+    host_email = db.Column(db.String(200))
+    
+    submissions = db.relationship('Submission', backref='hackathon', lazy=True, cascade='all, delete-orphan')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'description': self.description,
+            'evaluation_prompt': self.evaluation_prompt,
+            'criteria': json.loads(self.criteria) if self.criteria else [],
+            'created_at': self.created_at.isoformat(),
+            'deadline': self.deadline.isoformat() if self.deadline else None,
+            'host_email': self.host_email,
+            'submission_count': len(self.submissions)
+        }
+
+
+class Submission(db.Model):
+    __tablename__ = 'submissions'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    hackathon_id = db.Column(db.Integer, db.ForeignKey('hackathons.id'), nullable=False)
+    team_name = db.Column(db.String(200), nullable=False)
+    participant_email = db.Column(db.String(200), nullable=False)
+    project_name = db.Column(db.String(200), nullable=False)
+    project_description = db.Column(db.Text)
+    code_content = db.Column(db.Text)  # Extracted code content
+    documentation_content = db.Column(db.Text)  # Extracted documentation
+    file_paths = db.Column(db.Text)  # JSON string of uploaded file paths
+    submitted_at = db.Column(db.DateTime, default=datetime.utcnow)
+    evaluated = db.Column(db.Boolean, default=False)
+    
+    evaluation = db.relationship('Evaluation', backref='submission', uselist=False, cascade='all, delete-orphan')
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'hackathon_id': self.hackathon_id,
+            'team_name': self.team_name,
+            'participant_email': self.participant_email,
+            'project_name': self.project_name,
+            'project_description': self.project_description,
+            'submitted_at': self.submitted_at.isoformat(),
+            'evaluated': self.evaluated,
+            'file_count': len(json.loads(self.file_paths)) if self.file_paths else 0
+        }
+
+
+class Evaluation(db.Model):
+    __tablename__ = 'evaluations'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    submission_id = db.Column(db.Integer, db.ForeignKey('submissions.id'), nullable=False)
+    relevance_score = db.Column(db.Float, default=0.0)
+    technical_complexity_score = db.Column(db.Float, default=0.0)
+    creativity_score = db.Column(db.Float, default=0.0)
+    documentation_score = db.Column(db.Float, default=0.0)
+    productivity_score = db.Column(db.Float, default=0.0)  # NEW: 5th evaluation metric
+    overall_score = db.Column(db.Float, default=0.0)
+    feedback = db.Column(db.Text)  # AI-generated feedback
+    detailed_scores = db.Column(db.Text)  # JSON string of detailed criteria scores
+    evaluated_at = db.Column(db.DateTime, default=datetime.utcnow)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'submission_id': self.submission_id,
+            'relevance_score': self.relevance_score,
+            'technical_complexity_score': self.technical_complexity_score,
+            'creativity_score': self.creativity_score,
+            'documentation_score': self.documentation_score,
+            'productivity_score': self.productivity_score,
+            'overall_score': self.overall_score,
+            'feedback': self.feedback,
+            'detailed_scores': json.loads(self.detailed_scores) if self.detailed_scores else {},
+                    # Ensure UTC marker so clients can convert correctly
+                    'evaluated_at': (
+                        (self.evaluated_at.replace(tzinfo=timezone.utc) if self.evaluated_at.tzinfo is None else self.evaluated_at.astimezone(timezone.utc))
+                        .isoformat()
+                        .replace('+00:00', 'Z')
+                    )
+        }
+
+

package.json

@@ -1,7 +1,7 @@
 {
-  "name": "svelte",
+  "name": "evalai-frontend",
   "private": true,
-  "version": "0.0.0",
+  "version": "1.0.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -9,11 +9,18 @@
     "preview": "vite preview",
     "check": "svelte-check --tsconfig ./tsconfig.app.json && tsc -p tsconfig.node.json"
   },
+  "dependencies": {
+    "axios": "^1.6.2",
+    "svelte-routing": "^2.13.0"
+  },
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^5.0.3",
     "@tsconfig/svelte": "^5.0.4",
+    "autoprefixer": "^10.4.16",
+    "postcss": "^8.4.32",
     "svelte": "^5.28.1",
     "svelte-check": "^4.1.6",
+    "tailwindcss": "^3.3.6",
     "typescript": "~5.8.3",
     "vite": "^6.3.5"
   }

postcss.config.js

@@ -0,0 +1,7 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}
+

requirements.txt

@@ -0,0 +1,10 @@
+flask
+flask-cors
+flask-sqlalchemy
+python-dotenv
+werkzeug
+openai>=1.0.0
+
+# Optional utilities
+json-repair
+

src/App.svelte

@@ -1,47 +1,35 @@
 <script lang="ts">
-  import svelteLogo from './assets/svelte.svg'
-  import viteLogo from '/vite.svg'
-  import Counter from './lib/Counter.svelte'
-</script>
-
-<main>
-  <div>
-    <a href="https://vite.dev" target="_blank" rel="noreferrer">
-      <img src={viteLogo} class="logo" alt="Vite Logo" />
-    </a>
-    <a href="https://svelte.dev" target="_blank" rel="noreferrer">
-      <img src={svelteLogo} class="logo svelte" alt="Svelte Logo" />
-    </a>
-  </div>
-  <h1>Vite + Svelte</h1>
+  import { currentPath } from './lib/router';
+  import ProjectEvaluator from './pages/ProjectEvaluator.svelte';
+  import AllResults from './pages/AllResults.svelte';
+  import IndividualResult from './pages/IndividualResult.svelte';
+  import { onMount } from 'svelte';
 
-  <div class="card">
-    <Counter />
-  </div>
+  let path = $state('/');
+  let submissionId = $state<string | undefined>(undefined);
 
-  <p>
-    Check out <a href="https://github.com/sveltejs/kit#readme" target="_blank" rel="noreferrer">SvelteKit</a>, the official Svelte app framework powered by Vite!
-  </p>
+  // Robustly subscribe to router changes (works in Svelte 5 runes)
+  onMount(() => {
+    const unsubscribe = currentPath.subscribe((p: string) => {
+      path = p;
 
-  <p class="read-the-docs">
-    Click on the Vite and Svelte logos to learn more
-  </p>
-</main>
+      // Parse submission ID from path like /result/123
+      const resultMatch = p.match(/^\/result\/(\d+)$/);
+      if (resultMatch) {
+        submissionId = resultMatch[1];
+        path = '/result';
+      } else {
+        submissionId = undefined;
+      }
+    });
+    return () => unsubscribe();
+  });
+</script>
 
-<style>
-  .logo {
-    height: 6em;
-    padding: 1.5em;
-    will-change: filter;
-    transition: filter 300ms;
-  }
-  .logo:hover {
-    filter: drop-shadow(0 0 2em #646cffaa);
-  }
-  .logo.svelte:hover {
-    filter: drop-shadow(0 0 2em #ff3e00aa);
-  }
-  .read-the-docs {
-    color: #888;
-  }
-</style>
+{#if path === '/results'}
+  <AllResults />
+{:else if path === '/result' && submissionId}
+  <IndividualResult {submissionId} />
+{:else}
+  <ProjectEvaluator />
+{/if}

src/app.css

@@ -1,79 +1,18 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
 :root {
-  font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
   line-height: 1.5;
   font-weight: 400;
-
-  color-scheme: light dark;
-  color: rgba(255, 255, 255, 0.87);
-  background-color: #242424;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}
-
-a {
-  font-weight: 500;
-  color: #646cff;
-  text-decoration: inherit;
-}
-a:hover {
-  color: #535bf2;
 }
 
 body {
   margin: 0;
-  display: flex;
-  place-items: center;
-  min-width: 320px;
   min-height: 100vh;
 }
 
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}
-
-.card {
-  padding: 2em;
-}
-
 #app {
-  max-width: 1280px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-button {
-  border-radius: 8px;
-  border: 1px solid transparent;
-  padding: 0.6em 1.2em;
-  font-size: 1em;
-  font-weight: 500;
-  font-family: inherit;
-  background-color: #1a1a1a;
-  cursor: pointer;
-  transition: border-color 0.25s;
-}
-button:hover {
-  border-color: #646cff;
-}
-button:focus,
-button:focus-visible {
-  outline: 4px auto -webkit-focus-ring-color;
-}
-
-@media (prefers-color-scheme: light) {
-  :root {
-    color: #213547;
-    background-color: #ffffff;
-  }
-  a:hover {
-    color: #747bff;
-  }
-  button {
-    background-color: #f9f9f9;
-  }
+  min-height: 100vh;
 }

src/components/BarChart.svelte

@@ -0,0 +1,44 @@
+<script lang="ts">
+  interface Props {
+    score: number;
+    label: string;
+    maxScore?: number;
+    color?: string;
+  }
+
+  let { score, label, maxScore = 10, color }: Props = $props();
+  
+  const percentage = (score / maxScore) * 100;
+  
+  // Color scheme based on score
+  const getColor = (s: number) => {
+    if (color) return color;
+    if (s >= 8) return 'bg-green-500';
+    if (s >= 6) return 'bg-blue-500';
+    if (s >= 4) return 'bg-orange-500';
+    return 'bg-red-500';
+  };
+  
+  const barColor = getColor(score);
+</script>
+
+<div class="space-y-2">
+  <div class="flex justify-between items-center">
+    <span class="text-sm font-semibold text-gray-700">{label}</span>
+    <span class="text-sm font-bold text-gray-900">{score.toFixed(1)} / {maxScore}</span>
+  </div>
+  
+  <div class="relative h-8 bg-gray-200 rounded-full overflow-hidden">
+    <div 
+      class="{barColor} h-full rounded-full transition-all duration-1000 ease-out flex items-center justify-end pr-3"
+      style="width: {percentage}%"
+    >
+      {#if percentage > 15}
+        <span class="text-xs font-semibold text-white">
+          {percentage.toFixed(0)}%
+        </span>
+      {/if}
+    </div>
+  </div>
+</div>
+

src/components/RadialChart.svelte

@@ -0,0 +1,71 @@
+<script lang="ts">
+  interface Props {
+    score: number;
+    label: string;
+    color?: string;
+  }
+
+  let { score, label, color = '#3b82f6' }: Props = $props();
+  
+  // Calculate percentage and circle properties
+  const percentage = (score / 10) * 100;
+  const radius = 45;
+  const circumference = 2 * Math.PI * radius;
+  const dashOffset = circumference - (percentage / 100) * circumference;
+  
+  // Color scheme based on score
+  const getColor = (s: number) => {
+    if (color !== '#3b82f6') return color;
+    if (s >= 8) return '#10b981'; // Green
+    if (s >= 6) return '#3b82f6'; // Blue
+    if (s >= 4) return '#f59e0b'; // Orange
+    return '#ef4444'; // Red
+  };
+  
+  const chartColor = getColor(score);
+</script>
+
+<div class="flex flex-col items-center">
+  <svg class="transform -rotate-90" width="120" height="120">
+    <!-- Background circle -->
+    <circle
+      cx="60"
+      cy="60"
+      r={radius}
+      stroke="#e5e7eb"
+      stroke-width="8"
+      fill="none"
+    />
+    <!-- Progress circle -->
+    <circle
+      cx="60"
+      cy="60"
+      r={radius}
+      stroke={chartColor}
+      stroke-width="8"
+      fill="none"
+      stroke-dasharray={circumference}
+      stroke-dashoffset={dashOffset}
+      stroke-linecap="round"
+      class="transition-all duration-1000 ease-out"
+    />
+    <!-- Center text -->
+    <text
+      x="60"
+      y="60"
+      text-anchor="middle"
+      dy="7"
+      class="transform rotate-90 origin-center text-2xl font-bold"
+      fill={chartColor}
+      style="transform-origin: 60px 60px;"
+    >
+      {score.toFixed(1)}
+    </text>
+  </svg>
+  
+  <div class="mt-3 text-center">
+    <p class="text-sm font-semibold text-gray-700">{label}</p>
+    <p class="text-xs text-gray-500">{percentage.toFixed(0)}%</p>
+  </div>
+</div>
+

src/lib/Counter.svelte

@@ -1,10 +0,0 @@
-<script lang="ts">
-  let count: number = $state(0)
-  const increment = () => {
-    count += 1
-  }
-</script>
-
-<button onclick={increment}>
-  count is {count}
-</button>

src/lib/api.ts

@@ -0,0 +1,144 @@
+/**
+ * API Service for Flask Backend Communication
+ * Base URL: http://localhost:5000 (proxied via Vite)
+ */
+
+import axios from 'axios';
+
+const API_BASE = '/api';
+
+const api = axios.create({
+  baseURL: API_BASE,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Types
+export interface Hackathon {
+  id?: number;
+  name: string;
+  description: string;
+  evaluation_prompt: string;
+  criteria?: any[];
+  host_email?: string;
+  deadline?: string;
+  created_at?: string;
+}
+
+export interface Submission {
+  id?: number;
+  hackathon_id: number;
+  team_name: string;
+  project_name: string;
+  code_content?: string;
+  documentation_content?: string;
+  github_url?: string;
+  status?: string;
+  created_at?: string;
+}
+
+export interface Evaluation {
+  id?: number;
+  submission_id: number;
+  overall_score: number;
+  relevance_score: number;
+  technical_complexity_score: number;
+  creativity_score: number;
+  documentation_score: number;
+  feedback: string;
+  detailed_scores?: string;
+  created_at?: string;
+}
+
+// Hackathon API
+export const hackathonApi = {
+  // Get all hackathons
+  getAll: async (): Promise<Hackathon[]> => {
+    const response = await api.get('/hackathons');
+    return response.data;
+  },
+
+  // Get single hackathon
+  getById: async (id: number): Promise<Hackathon> => {
+    const response = await api.get(`/hackathon/${id}`);
+    return response.data;
+  },
+
+  // Create new hackathon
+  create: async (hackathon: Hackathon): Promise<Hackathon> => {
+    const response = await api.post('/hackathon', hackathon);
+    return response.data;
+  },
+
+  // Update hackathon
+  update: async (id: number, hackathon: Partial<Hackathon>): Promise<Hackathon> => {
+    const response = await api.put(`/hackathon/${id}`, hackathon);
+    return response.data;
+  },
+
+  // Delete hackathon
+  delete: async (id: number): Promise<void> => {
+    await api.delete(`/hackathon/${id}`);
+  },
+};
+
+// Submission API
+export const submissionApi = {
+  // Get all submissions for a hackathon
+  getByHackathon: async (hackathonId: number): Promise<Submission[]> => {
+    const response = await api.get(`/hackathon/${hackathonId}/submissions`);
+    return response.data;
+  },
+
+  // Get single submission
+  getById: async (hackathonId: number, submissionId: number): Promise<Submission> => {
+    const response = await api.get(`/hackathon/${hackathonId}/submission/${submissionId}`);
+    return response.data;
+  },
+
+  // Submit with files (multipart/form-data)
+  submitWithFiles: async (hackathonId: number, formData: FormData): Promise<Submission> => {
+    const response = await api.post(`/hackathon/${hackathonId}/submit`, formData, {
+      headers: {
+        'Content-Type': 'multipart/form-data',
+      },
+    });
+    return response.data;
+  },
+
+  // Submit with GitHub URL
+  submitWithGithub: async (hackathonId: number, data: {
+    team_name: string;
+    project_name: string;
+    github_url: string;
+  }): Promise<Submission> => {
+    const response = await api.post(`/hackathon/${hackathonId}/submit/github`, data);
+    return response.data;
+  },
+};
+
+// Evaluation API
+export const evaluationApi = {
+  // Get evaluation for a submission
+  getBySubmission: async (submissionId: number): Promise<Evaluation> => {
+    const response = await api.get(`/submission/${submissionId}/evaluation`);
+    return response.data;
+  },
+
+  // Get all evaluations for a hackathon (for leaderboard)
+  getByHackathon: async (hackathonId: number): Promise<any[]> => {
+    const response = await api.get(`/hackathon/${hackathonId}/results`);
+    return response.data;
+  },
+
+  // Trigger evaluation (if manual trigger is needed)
+  triggerEvaluation: async (submissionId: number): Promise<Evaluation> => {
+    const response = await api.post(`/submission/${submissionId}/evaluate`);
+    return response.data;
+  },
+};
+
+// Export axios instance for custom requests
+export default api;
+

src/lib/router.ts

@@ -0,0 +1,24 @@
+// Simple hash-based router for Svelte 5
+import { writable } from 'svelte/store';
+
+function getPath() {
+  return window.location.hash.slice(1) || '/';
+}
+
+function createRouter() {
+  const { subscribe, set } = writable(getPath());
+
+  window.addEventListener('hashchange', () => {
+    set(getPath());
+  });
+
+  return {
+    subscribe,
+    navigate: (path: string) => {
+      window.location.hash = path;
+    }
+  };
+}
+
+export const currentPath = createRouter();
+

src/pages/AllResults.svelte

@@ -0,0 +1,407 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { fly, fade, scale, slide } from 'svelte/transition';
+  import { elasticOut, quintOut, backOut } from 'svelte/easing';
+
+  let allResults = $state<any[]>([]);
+  let loading = $state(false);
+  let error = $state('');
+  let mounted = $state(false);
+  let selectedResult = $state<any>(null);
+  let showFeedbackModal = $state(false);
+
+  onMount(() => {
+    mounted = true;
+    loadAllResults();
+  });
+
+  async function loadAllResults() {
+    try {
+      loading = true;
+      error = '';
+      
+      // Get all hackathons first
+      const hackathonsResponse = await fetch('/api/hackathons');
+      if (!hackathonsResponse.ok) {
+        throw new Error('Failed to load hackathons');
+      }
+      const hackathons = await hackathonsResponse.json();
+      
+      // Get submissions for each hackathon
+      const allSubmissions = [];
+      for (const hackathon of hackathons) {
+        try {
+          const submissionsResponse = await fetch(`/api/hackathon/${hackathon.id}/submissions`);
+          if (submissionsResponse.ok) {
+            const submissions = await submissionsResponse.json();
+            // Add hackathon info to each submission
+            submissions.forEach(submission => {
+              submission.hackathon = hackathon;
+            });
+            allSubmissions.push(...submissions);
+          }
+        } catch (err) {
+          console.warn(`Failed to load submissions for hackathon ${hackathon.id}:`, err);
+        }
+      }
+      
+      // Filter only evaluated submissions and sort by most recent first
+      allResults = allSubmissions
+        .filter(submission => submission.evaluated && submission.evaluation)
+        .sort((a, b) => new Date(b.evaluation.evaluated_at).getTime() - new Date(a.evaluation.evaluated_at).getTime());
+      
+    } catch (err: any) {
+      error = err.message || 'Failed to load results';
+      console.error('Error loading results:', err);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function viewResult(submissionId: number) {
+    window.location.hash = `/result/${submissionId}`;
+  }
+
+  function showFeedback(result: any, event: Event) {
+    event.stopPropagation(); // Prevent the row click
+    selectedResult = result;
+    showFeedbackModal = true;
+  }
+
+  function closeFeedbackModal() {
+    showFeedbackModal = false;
+    selectedResult = null;
+  }
+
+  function goToUpload() {
+    window.location.hash = '/';
+  }
+
+  // Format a UTC/DB timestamp into India Standard Time
+  function formatIST(dateStr: string): string {
+    try {
+      // Treat missing timezone as UTC
+      const normalized = /([zZ]|[+\-]\d{2}:\d{2})$/.test(dateStr) ? dateStr : `${dateStr}Z`;
+      const s = new Date(normalized).toLocaleString('en-IN', {
+        timeZone: 'Asia/Kolkata',
+        year: 'numeric', month: 'short', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', hour12: true,
+        timeZoneName: 'short'
+      });
+      return s.replace(' am', ' AM').replace(' pm', ' PM');
+    } catch {
+      return dateStr;
+    }
+  }
+
+  function getMedalEmoji(rank: number): string {
+    if (rank === 0) return '🥇';
+    if (rank === 1) return '🥈';
+    if (rank === 2) return '🥉';
+    return '🏅';
+  }
+
+  function getScoreColor(score: number): string {
+    if (score >= 8) return 'text-green-600';
+    if (score >= 6) return 'text-blue-600';
+    if (score >= 4) return 'text-yellow-600';
+    return 'text-red-600';
+  }
+
+  function getScoreBgColor(score: number): string {
+    if (score >= 8) return 'bg-green-100';
+    if (score >= 6) return 'bg-blue-100';
+    if (score >= 4) return 'bg-yellow-100';
+    return 'bg-red-100';
+  }
+</script>
+
+<div class="min-h-screen bg-gradient-to-br from-indigo-50 via-purple-50 to-pink-50 overflow-hidden">
+  {#if mounted}
+    <header 
+      class="bg-white shadow-md backdrop-blur-sm bg-opacity-95"
+      in:fly={{ y: -50, duration: 600, easing: quintOut }}
+    >
+      <div class="max-w-6xl mx-auto px-6 py-6">
+        <div class="flex justify-between items-center">
+          <div>
+            <h1 
+              class="text-4xl font-bold bg-gradient-to-r from-indigo-600 via-purple-600 to-pink-600 bg-clip-text text-transparent animate-gradient"
+              style="background-size: 200% auto;"
+            >
+              🏆 All Evaluation Results
+            </h1>
+            <p 
+              class="mt-2 text-gray-600"
+              in:fade={{ delay: 200, duration: 400 }}
+            >
+              Leaderboard of all evaluated projects
+            </p>
+          </div>
+          <button 
+            onclick={goToUpload}
+            class="px-5 py-2 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-lg hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+            in:scale={{ delay: 300, duration: 400, easing: elasticOut }}
+          >
+            ➕ Upload New Project
+          </button>
+        </div>
+      </div>
+    </header>
+  {/if}
+
+  <main class="max-w-6xl mx-auto px-6 py-12">
+    {#if error}
+      <div 
+        class="mb-6 p-4 bg-red-50 border-l-4 border-red-500 text-red-700 rounded-lg flex items-start gap-3"
+        in:slide={{ duration: 300 }}
+      >
+        <span class="text-2xl">❌</span>
+        <div>
+          <p class="font-semibold">Error</p>
+          <p>{error}</p>
+        </div>
+      </div>
+    {/if}
+
+    {#if loading}
+      <div 
+        class="text-center py-12"
+        in:fade={{ duration: 400 }}
+      >
+        <div class="inline-block animate-spin rounded-full h-12 w-12 border-b-2 border-indigo-600"></div>
+        <p class="mt-4 text-gray-600">Loading all evaluation results...</p>
+      </div>
+    {:else if allResults.length === 0}
+      <div 
+        class="text-center py-12"
+        in:fade={{ duration: 400 }}
+      >
+        <div class="text-6xl mb-4">📊</div>
+        <h2 class="text-2xl font-bold text-gray-900 mb-2">No Results Yet</h2>
+        <p class="text-gray-600 mb-6">No projects have been evaluated yet. Upload your first project to get started!</p>
+        <button
+          onclick={goToUpload}
+          class="px-6 py-3 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-lg hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+        >
+          🚀 Upload First Project
+        </button>
+      </div>
+    {:else}
+      <div 
+        class="bg-white rounded-2xl shadow-xl p-8 hover:shadow-2xl transition-shadow duration-300"
+        in:fly={{ y: 50, duration: 600, delay: 200, easing: quintOut }}
+      >
+        <div class="mb-6">
+          <h2 class="text-2xl font-bold text-gray-900 mb-2">📋 Evaluation Leaderboard</h2>
+          <p class="text-gray-600">Total Projects Evaluated: {allResults.length}</p>
+        </div>
+
+        <div class="space-y-4">
+          {#each allResults as result, index}
+            <div 
+              class="border border-gray-200 rounded-lg p-6 hover:border-indigo-300 hover:shadow-lg transition-all duration-300"
+              in:fly={{ x: -20, duration: 400, delay: index * 100 }}
+            >
+              <div class="flex items-center justify-between">
+                <div class="flex items-center gap-4">
+                  <!-- Rank -->
+                  <div class="text-3xl">
+                    {getMedalEmoji(index)}
+                  </div>
+                  
+                  <!-- Project Info -->
+                  <div 
+                    class="cursor-pointer hover:text-indigo-600 transition-colors duration-200"
+                    onclick={() => viewResult(result.id)}
+                    title="Click to view detailed analysis"
+                  >
+                    <h3 class="text-xl font-semibold text-gray-900 hover:text-indigo-600">{result.project_name}</h3>
+                    <p class="text-xs text-gray-500 mt-1">
+                      Evaluated: {formatIST(result.evaluation.evaluated_at)}
+                    </p>
+                  </div>
+                </div>
+
+                <!-- Scores -->
+                <div class="flex items-center gap-6">
+                  <!-- Overall Score -->
+                  <div class="text-center">
+                    <div class="text-2xl font-bold {getScoreColor(result.evaluation.overall_score)} px-4 py-2 rounded-lg {getScoreBgColor(result.evaluation.overall_score)}">
+                      {result.evaluation.overall_score.toFixed(1)}
+                    </div>
+                    <div class="text-xs text-gray-500 mt-1">Overall</div>
+                  </div>
+
+                  <!-- Feedback Button -->
+                  <button 
+                    onclick={(e) => showFeedback(result, e)}
+                    class="text-indigo-600 hover:text-indigo-800 hover:bg-indigo-50 p-2 rounded-lg transition-all duration-200"
+                    title="View AI Feedback"
+                  >
+                    <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5l7 7-7 7"></path>
+                    </svg>
+                  </button>
+                </div>
+              </div>
+
+              <!-- Project Description -->
+              {#if result.project_description}
+                <div class="mt-3 text-sm text-gray-600 line-clamp-2">
+                  {result.project_description}
+                </div>
+              {/if}
+            </div>
+          {/each}
+        </div>
+
+        <!-- Action Buttons -->
+        <div class="mt-8 text-center">
+          <button
+            onclick={goToUpload}
+            class="px-6 py-3 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-lg hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+          >
+            🚀 Upload Another Project
+          </button>
+        </div>
+      </div>
+    {/if}
+  </main>
+</div>
+
+<!-- Feedback Modal -->
+{#if showFeedbackModal && selectedResult}
+  <div 
+    class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4"
+    onclick={closeFeedbackModal}
+    in:fade={{ duration: 200 }}
+    out:fade={{ duration: 200 }}
+  >
+    <div 
+      class="bg-white rounded-2xl shadow-2xl max-w-4xl w-full max-h-[90vh] overflow-y-auto"
+      onclick={(e) => e.stopPropagation()}
+      in:scale={{ duration: 300, easing: elasticOut }}
+      out:scale={{ duration: 200 }}
+    >
+      <!-- Modal Header -->
+      <div class="sticky top-0 bg-white border-b border-gray-200 px-6 py-4 rounded-t-2xl">
+        <div class="flex justify-between items-center">
+          <div>
+            <h2 class="text-2xl font-bold text-gray-900">{selectedResult.project_name}</h2>
+            <p class="text-sm text-gray-600">AI Evaluation Feedback</p>
+          </div>
+          <button 
+            onclick={closeFeedbackModal}
+            class="text-gray-400 hover:text-gray-600 hover:bg-gray-100 p-2 rounded-lg transition-all duration-200"
+          >
+            <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
+            </svg>
+          </button>
+        </div>
+      </div>
+
+      <!-- Modal Content -->
+      <div class="p-6">
+        <!-- Project Info -->
+        <div class="mb-6 p-4 bg-gradient-to-r from-indigo-50 to-purple-50 rounded-lg">
+          <div class="flex justify-between items-center mb-2">
+            <span class="text-sm font-medium text-gray-700">Team: {selectedResult.team_name}</span>
+            <span class="text-sm text-gray-500">Evaluated: {formatIST(selectedResult.evaluation.evaluated_at)}</span>
+          </div>
+          {#if selectedResult.project_description}
+            <p class="text-sm text-gray-600">{selectedResult.project_description}</p>
+          {/if}
+        </div>
+
+        <!-- Overall Score -->
+        <div class="text-center mb-6 p-4 bg-gray-50 rounded-lg">
+          <h3 class="text-lg font-semibold text-gray-900 mb-2">Overall Score</h3>
+          <div class="text-4xl font-bold {getScoreColor(selectedResult.evaluation.overall_score)}">
+            {selectedResult.evaluation.overall_score.toFixed(1)}/10
+          </div>
+        </div>
+
+        <!-- Score Breakdown -->
+        <div class="grid grid-cols-5 gap-4 mb-6">
+          <div class="text-center p-3 bg-gray-50 rounded-lg">
+            <div class="text-lg font-bold {getScoreColor(selectedResult.evaluation.relevance_score)}">
+              {selectedResult.evaluation.relevance_score.toFixed(1)}
+            </div>
+            <div class="text-xs text-gray-600">Relevance</div>
+          </div>
+          <div class="text-center p-3 bg-gray-50 rounded-lg">
+            <div class="text-lg font-bold {getScoreColor(selectedResult.evaluation.technical_complexity_score)}">
+              {selectedResult.evaluation.technical_complexity_score.toFixed(1)}
+            </div>
+            <div class="text-xs text-gray-600">Technical</div>
+          </div>
+          <div class="text-center p-3 bg-gray-50 rounded-lg">
+            <div class="text-lg font-bold {getScoreColor(selectedResult.evaluation.creativity_score)}">
+              {selectedResult.evaluation.creativity_score.toFixed(1)}
+            </div>
+            <div class="text-xs text-gray-600">Creativity</div>
+          </div>
+          <div class="text-center p-3 bg-gray-50 rounded-lg">
+            <div class="text-lg font-bold {getScoreColor(selectedResult.evaluation.documentation_score)}">
+              {selectedResult.evaluation.documentation_score.toFixed(1)}
+            </div>
+            <div class="text-xs text-gray-600">Documentation</div>
+          </div>
+          <div class="text-center p-3 bg-gray-50 rounded-lg">
+            <div class="text-lg font-bold {getScoreColor(selectedResult.evaluation.productivity_score)}">
+              {selectedResult.evaluation.productivity_score.toFixed(1)}
+            </div>
+            <div class="text-xs text-gray-600">Productivity</div>
+          </div>
+        </div>
+
+        <!-- AI Feedback -->
+        <div class="bg-gradient-to-r from-blue-50 to-indigo-50 rounded-lg p-6">
+          <h3 class="text-lg font-semibold text-gray-900 mb-4 flex items-center gap-2">
+            🤖 AI Generated Feedback
+          </h3>
+          <div class="prose prose-sm max-w-none">
+            <p class="text-gray-700 leading-relaxed whitespace-pre-wrap">{selectedResult.evaluation.feedback}</p>
+          </div>
+        </div>
+
+        <!-- Action Buttons -->
+        <div class="mt-6 flex justify-center gap-4">
+          <button
+            onclick={() => viewResult(selectedResult.id)}
+            class="px-6 py-2 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-lg hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+          >
+            📊 View Detailed Analysis
+          </button>
+          <button
+            onclick={closeFeedbackModal}
+            class="px-6 py-2 bg-gray-600 text-white rounded-lg hover:bg-gray-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+          >
+            Close
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+{/if}
+
+<style>
+  @keyframes gradient {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+  }
+  
+  .animate-gradient {
+    animation: gradient 3s ease infinite;
+  }
+
+  .line-clamp-2 {
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+  }
+</style>

src/pages/IndividualResult.svelte

@@ -0,0 +1,319 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import BarChart from '../components/BarChart.svelte';
+  import { fly, fade, scale, slide } from 'svelte/transition';
+  import { elasticOut, quintOut, backOut } from 'svelte/easing';
+
+  interface Props {
+    submissionId: string;
+  }
+
+  let { submissionId }: Props = $props();
+
+  let result = $state<any>(null);
+  let loading = $state(true);
+  let error = $state('');
+  let mounted = $state(false);
+
+  onMount(() => {
+    mounted = true;
+    loadResult();
+  });
+
+  // Format a UTC/DB timestamp into India Standard Time
+  function formatIST(dateStr: string): string {
+    try {
+      const normalized = /([zZ]|[+\-]\d{2}:\d{2})$/.test(dateStr) ? dateStr : `${dateStr}Z`;
+      const s = new Date(normalized).toLocaleString('en-IN', {
+        timeZone: 'Asia/Kolkata',
+        year: 'numeric', month: 'short', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', hour12: true,
+        timeZoneName: 'short'
+      });
+      return s.replace(' am', ' AM').replace(' pm', ' PM');
+    } catch {
+      return dateStr;
+    }
+  }
+
+  // Keys we expect from detailed_scores for hackathon criteria
+  const hackathonKeys = [
+    { label: 'Productivity', key: 'productivity_justification' },
+    { label: 'Out of the box thinking', key: 'out_of_box_thinking' },
+    { label: 'Problem-solving skills', key: 'problem_solving_skills' },
+    { label: 'Creativity', key: 'creativity_justification' },
+    { label: 'Research capabilities', key: 'research_capabilities' },
+    { label: 'Understanding the business', key: 'business_understanding' },
+    { label: 'Use of non-famous tools', key: 'non_famous_tools_usage' }
+  ];
+
+  async function loadResult() {
+    try {
+      loading = true;
+      error = '';
+      
+      console.log('Loading result for submission ID:', submissionId);
+      const response = await fetch(`/api/results/${submissionId}`);
+      console.log('Response status:', response.status);
+      
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error('Response error:', errorText);
+        throw new Error(`Failed to load result: ${response.status} ${errorText}`);
+      }
+      
+      result = await response.json();
+      console.log('Loaded result:', result);
+    } catch (err: any) {
+      error = err.message || 'Failed to load result';
+      console.error('Error loading result:', err);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function goBack() {
+    window.location.hash = '/';
+  }
+
+  function viewAllResults() {
+    window.location.hash = '/results';
+  }
+</script>
+
+<div class="min-h-screen bg-gradient-to-br from-indigo-50 via-purple-50 to-pink-50 overflow-hidden">
+  {#if mounted}
+    <header 
+      class="bg-white shadow-md backdrop-blur-sm bg-opacity-95"
+      in:fly={{ y: -50, duration: 600, easing: quintOut }}
+    >
+      <div class="max-w-5xl mx-auto px-6 py-6">
+        <div class="flex justify-between items-center">
+          <div>
+            <h1 
+              class="text-4xl font-bold bg-gradient-to-r from-indigo-600 via-purple-600 to-pink-600 bg-clip-text text-transparent animate-gradient"
+              style="background-size: 200% auto;"
+            >
+              📊 Project Evaluation Results
+            </h1>
+            <p 
+              class="mt-2 text-gray-600"
+              in:fade={{ delay: 200, duration: 400 }}
+            >
+              Detailed AI-powered analysis and scoring
+            </p>
+          </div>
+          <div class="flex gap-3">
+            <button 
+              onclick={goBack}
+              class="px-5 py-2 bg-gray-600 text-white rounded-lg hover:bg-gray-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+              in:scale={{ delay: 300, duration: 400, easing: elasticOut }}
+            >
+              ← Back to Upload
+            </button>
+            <button 
+              onclick={viewAllResults}
+              class="px-5 py-2 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-lg hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+              in:scale={{ delay: 400, duration: 400, easing: elasticOut }}
+            >
+              📋 All Results
+            </button>
+          </div>
+        </div>
+      </div>
+    </header>
+  {/if}
+
+  <main class="max-w-5xl mx-auto px-6 py-12">
+    {#if error}
+      <div
+        class="mb-6 p-4 bg-red-50 border-l-4 border-red-500 text-red-700 rounded-lg flex items-start gap-3"
+        in:slide={{ duration: 300 }}
+      >
+        <span class="text-2xl">❌</span>
+        <div>
+          <p class="font-semibold">Error Loading Result</p>
+          <p>{error}</p>
+          <p class="text-sm mt-2">Submission ID: {submissionId}</p>
+          <div class="mt-4 space-x-4">
+            <button 
+              onclick={goBack}
+              class="px-4 py-2 bg-indigo-600 text-white rounded-lg hover:bg-indigo-700 transition-colors duration-200"
+            >
+              ← Back to Upload
+            </button>
+            <button 
+              onclick={viewAllResults}
+              class="px-4 py-2 bg-gray-600 text-white rounded-lg hover:bg-gray-700 transition-colors duration-200"
+            >
+              View All Results
+            </button>
+          </div>
+        </div>
+      </div>
+    {/if}
+
+    {#if loading}
+      <div 
+        class="text-center py-12"
+        in:fade={{ duration: 400 }}
+      >
+        <div class="inline-block animate-spin rounded-full h-12 w-12 border-b-2 border-indigo-600"></div>
+        <p class="mt-4 text-gray-600">Loading evaluation results...</p>
+      </div>
+    {:else if result}
+      <div 
+        class="bg-white rounded-2xl shadow-xl p-8 hover:shadow-2xl transition-shadow duration-300"
+        in:fly={{ y: 50, duration: 600, delay: 200, easing: quintOut }}
+      >
+        <!-- Project Info -->
+        <div class="mb-8 text-center">
+          <h2 class="text-3xl font-bold text-gray-900 mb-2">{result.project_name}</h2>
+          <p class="text-gray-600">{result.project_description}</p>
+          <div class="mt-4 flex justify-center items-center gap-4">
+            <span class="text-sm text-gray-500">Team: {result.team_name}</span>
+            <span class="text-sm text-gray-500">•</span>
+            <span class="text-sm text-gray-500">Evaluated: {formatIST(result.evaluation.evaluated_at)}</span>
+          </div>
+        </div>
+
+        <!-- Overall Score -->
+        <div 
+          class="text-center mb-8 p-6 bg-gradient-to-r from-indigo-50 to-purple-50 rounded-xl"
+          in:scale={{ delay: 400, duration: 500, easing: backOut }}
+        >
+          <h3 class="text-xl font-semibold text-gray-900 mb-2">Overall Score</h3>
+          <div class="text-5xl font-bold bg-gradient-to-r from-indigo-600 to-purple-600 bg-clip-text text-transparent">
+            {result.evaluation.overall_score.toFixed(1)}/10
+          </div>
+        </div>
+
+        <!-- Score Breakdown (Bars only for clarity and accessibility) -->
+        <div class="mb-2"></div>
+
+        <!-- Bar Charts -->
+        <div 
+          class="bg-gray-50 rounded-lg p-6 mb-8"
+          in:fly={{ y: 20, delay: 1100, duration: 400 }}
+        >
+          <h3 class="text-lg font-semibold text-gray-900 mb-4">📈 Detailed Scores</h3>
+          <div class="space-y-4">
+            <div in:fly={{ x: -20, delay: 1200, duration: 300 }}>
+              <BarChart score={result.evaluation.relevance_score} label="Relevance" />
+            </div>
+            <div in:fly={{ x: -20, delay: 1300, duration: 300 }}>
+              <BarChart score={result.evaluation.technical_complexity_score} label="Technical Complexity" />
+            </div>
+            <div in:fly={{ x: -20, delay: 1400, duration: 300 }}>
+              <BarChart score={result.evaluation.creativity_score} label="Creativity" />
+            </div>
+            <div in:fly={{ x: -20, delay: 1500, duration: 300 }}>
+              <BarChart score={result.evaluation.documentation_score} label="Documentation" />
+            </div>
+            <div in:fly={{ x: -20, delay: 1600, duration: 300 }}>
+              <BarChart score={result.evaluation.productivity_score} label="Productivity" />
+            </div>
+          </div>
+        </div>
+
+        <!-- Hackathon Key Points (before feedback) -->
+        {#if result.evaluation.detailed_scores}
+        <div 
+          class="bg-white rounded-xl p-6 shadow-lg border-2 border-indigo-50 mb-8"
+          in:fly={{ y: 16, delay: 1550, duration: 350 }}
+        >
+          <h3 class="text-2xl font-bold text-gray-900 mb-4 flex items-center gap-2">
+            📚 Hackathon Key Points
+          </h3>
+          <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+            {#each hackathonKeys as item, i}
+              {#if result.evaluation.detailed_scores[item.key]}
+                <div class="bg-gradient-to-r from-slate-50 to-white rounded-lg p-4 shadow-sm border-l-4 border-indigo-400" in:fly={{ x: -12, delay: 1560 + i*90, duration: 250 }}>
+                  <div class="text-sm text-gray-500 mb-1">{item.label}</div>
+                  <div class="text-gray-700">{result.evaluation.detailed_scores[item.key]}</div>
+                </div>
+              {/if}
+            {/each}
+          </div>
+        </div>
+        {/if}
+
+        <!-- AI Feedback -->
+        <div 
+          class="bg-gradient-to-r from-blue-50 to-indigo-50 rounded-xl p-6 shadow-lg mb-8"
+          in:scale={{ delay: 1700, duration: 400, easing: elasticOut }}
+        >
+          <h3 class="text-2xl font-bold text-gray-900 mb-4 flex items-center gap-2">
+            🤖 AI Evaluation Feedback
+          </h3>
+          <div class="bg-white rounded-lg p-5 shadow-inner border-l-4 border-indigo-500">
+            <p class="text-gray-700 leading-relaxed whitespace-pre-wrap">{result.evaluation.feedback}</p>
+          </div>
+        </div>
+
+        <!-- Detailed Justifications -->
+        {#if result.evaluation.detailed_scores && typeof result.evaluation.detailed_scores === 'object' && Object.keys(result.evaluation.detailed_scores).length > 0}
+          <div 
+            class="bg-gradient-to-r from-purple-50 to-pink-50 rounded-xl p-6 shadow-lg mb-8"
+            in:scale={{ delay: 1800, duration: 400, easing: elasticOut }}
+          >
+            <h3 class="text-2xl font-bold text-gray-900 mb-4 flex items-center gap-2">
+              📋 Detailed Score Justifications
+            </h3>
+            <div class="space-y-4">
+              {#each Object.entries(result.evaluation.detailed_scores) as [key, value], i}
+                <div 
+                  class="bg-white rounded-lg p-4 shadow-sm border-l-4 border-purple-400"
+                  in:fly={{ x: -20, delay: 1900 + (i * 100), duration: 300 }}
+                >
+                  <h4 class="font-semibold text-gray-800 capitalize mb-2 text-lg">
+                    {key.replace('_justification', '').replace('_', ' ')}
+                  </h4>
+                  <p class="text-gray-600">{value}</p>
+                </div>
+              {/each}
+            </div>
+          </div>
+        {/if}
+
+        <!-- Enhanced Action Buttons -->
+        <div 
+          class="mt-12 flex flex-col sm:flex-row gap-6 justify-center items-center"
+          in:scale={{ delay: 2000, duration: 400, easing: elasticOut }}
+        >
+          <button
+            onclick={goBack}
+            class="w-full sm:w-auto px-8 py-4 bg-gradient-to-r from-indigo-600 to-purple-600 text-white text-lg font-bold rounded-xl hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform flex items-center justify-center gap-3"
+          >
+            <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6"></path>
+            </svg>
+            🚀 Evaluate Another Project
+          </button>
+          
+          <button
+            onclick={viewAllResults}
+            class="w-full sm:w-auto px-8 py-4 bg-gradient-to-r from-pink-600 to-red-600 text-white text-lg font-bold rounded-xl hover:from-pink-700 hover:to-red-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform flex items-center justify-center gap-3"
+          >
+            <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z"></path>
+            </svg>
+            🏆 View Leaderboard
+          </button>
+        </div>
+      </div>
+    {/if}
+  </main>
+</div>
+
+<style>
+  @keyframes gradient {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+  }
+  
+  .animate-gradient {
+    animation: gradient 3s ease infinite;
+  }
+</style>

src/pages/ProjectEvaluator.svelte

@@ -0,0 +1,402 @@
+<script lang="ts">
+  import { hackathonApi, submissionApi } from '../lib/api';
+  import { fly, fade, scale, slide } from 'svelte/transition';
+  import { elasticOut, quintOut } from 'svelte/easing';
+
+  let projectName = $state('');
+  let evaluationQuery = $state('Evaluate this project for technical quality, innovation, and best practices');
+  let projectFiles = $state<FileList | null>(null);
+  let uploading = $state(false);
+  let error = $state('');
+  let success = $state('');
+  let evaluationId = $state<number | null>(null);
+
+  let dragActive = $state(false);
+  let mounted = $state(false);
+
+  $effect(() => {
+    mounted = true;
+  });
+
+  function handleDrop(e: DragEvent) {
+    e.preventDefault();
+    dragActive = false;
+    
+    if (e.dataTransfer?.files) {
+      projectFiles = e.dataTransfer.files;
+    }
+  }
+
+  function handleDragOver(e: DragEvent) {
+    e.preventDefault();
+    dragActive = true;
+  }
+
+  function handleDragLeave() {
+    dragActive = false;
+  }
+
+  function handleFileChange(e: Event) {
+    const target = e.target as HTMLInputElement;
+    if (target.files) {
+      projectFiles = target.files;
+    }
+  }
+
+  async function evaluateProject() {
+    if (!projectName.trim()) {
+      error = 'Please enter a project name';
+      return;
+    }
+
+    if (!projectFiles || projectFiles.length === 0) {
+      error = 'Please upload at least one file';
+      return;
+    }
+
+    try {
+      uploading = true;
+      error = '';
+      success = '';
+
+      // Create a temporary hackathon for this evaluation
+      const hackathon = await hackathonApi.create({
+        name: `Project: ${projectName}`,
+        description: evaluationQuery,
+        evaluation_prompt: evaluationQuery,
+        host_email: 'host@autoeval.ai',
+        deadline: ''
+      });
+
+      // Upload files as a submission
+      const formData = new FormData();
+      formData.append('hackathon_id', hackathon.id.toString());
+      formData.append('team_name', 'Evaluation Team');
+      formData.append('participant_email', 'participant@autoeval.ai');
+      formData.append('project_name', projectName);
+      formData.append('project_description', evaluationQuery);
+
+      // Add all files
+      for (let i = 0; i < projectFiles.length; i++) {
+        formData.append('project_files', projectFiles[i]);
+      }
+
+      const response = await fetch('/api/submissions', {
+        method: 'POST',
+        body: formData
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to upload project');
+      }
+
+              const submission = await response.json();
+              evaluationId = submission.id;
+
+              // Show brief success message then redirect
+              success = `✅ Project evaluated successfully! Overall Score: ${submission.overall_score}/10`;
+              console.log(`✅ Project evaluated successfully! Redirecting to result page...`);
+              
+              // Redirect after a brief moment to show success
+              setTimeout(() => {
+                window.location.hash = `/result/${submission.id}`;
+              }, 1500);
+
+    } catch (err: any) {
+      error = err.message || 'Failed to evaluate project';
+      console.error('Error evaluating project:', err);
+    } finally {
+      uploading = false;
+    }
+  }
+
+  function clearFiles() {
+    projectFiles = null;
+    const fileInput = document.getElementById('file-input') as HTMLInputElement;
+    if (fileInput) fileInput.value = '';
+  }
+
+  function getFileIcon(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    const icons: Record<string, string> = {
+      'py': '🐍',
+      'js': '📜',
+      'ts': '📘',
+      'html': '🌐',
+      'css': '🎨',
+      'json': '📋',
+      'md': '📝',
+      'txt': '📄',
+      'zip': '📦',
+      'pdf': '📕',
+      'png': '🖼️',
+      'jpg': '🖼️',
+      'jpeg': '🖼️',
+      'gif': '🖼️',
+      'svg': '🎭'
+    };
+    return icons[ext || ''] || '📄';
+  }
+
+  function formatFileSize(bytes: number): string {
+    if (bytes < 1024) return bytes + ' B';
+    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+    return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+  }
+</script>
+
+<div class="min-h-screen bg-gradient-to-br from-indigo-50 via-purple-50 to-pink-50 overflow-hidden">
+  <!-- Header -->
+  {#if mounted}
+    <header 
+      class="bg-white shadow-md backdrop-blur-sm bg-opacity-95"
+      in:fly={{ y: -50, duration: 600, easing: quintOut }}
+    >
+      <div class="max-w-5xl mx-auto px-6 py-6">
+        <div class="flex justify-between items-center">
+          <div>
+            <h1 
+              class="text-4xl font-bold bg-gradient-to-r from-indigo-600 via-purple-600 to-pink-600 bg-clip-text text-transparent animate-gradient"
+              style="background-size: 200% auto;"
+            >
+              🤖 EvalAI
+            </h1>
+            <p 
+              class="mt-2 text-gray-600"
+              in:fade={{ delay: 200, duration: 400 }}
+            >
+              Upload your project and get instant AI-powered evaluation
+            </p>
+          </div>
+          <a 
+            href="#/results" 
+            class="px-5 py-2 bg-gradient-to-r from-indigo-600 to-purple-600 text-white rounded-lg hover:from-indigo-700 hover:to-purple-700 transition-all duration-300 shadow-lg hover:shadow-xl hover:scale-105 transform"
+            in:scale={{ delay: 300, duration: 400, easing: elasticOut }}
+          >
+            📊 View Results
+          </a>
+        </div>
+      </div>
+    </header>
+  {/if}
+
+  <main class="max-w-5xl mx-auto px-6 py-12">
+    {#if error}
+      <div 
+        class="mb-6 p-4 bg-red-50 border-l-4 border-red-500 text-red-700 rounded-lg flex items-start gap-3"
+        in:slide={{ duration: 300 }}
+        out:fade={{ duration: 200 }}
+      >
+        <span class="text-2xl">❌</span>
+        <div>
+          <p class="font-semibold">Error</p>
+          <p>{error}</p>
+        </div>
+      </div>
+    {/if}
+
+    {#if success}
+      <div 
+        class="mb-6 p-4 bg-green-50 border-l-4 border-green-500 text-green-700 rounded-lg flex items-start gap-3"
+        in:scale={{ duration: 400, easing: elasticOut }}
+        out:fade={{ duration: 200 }}
+      >
+        <span class="text-2xl animate-bounce">✅</span>
+        <div>
+          <p class="font-semibold">Success!</p>
+          <p>{success}</p>
+          <p class="text-sm mt-1 text-green-600">Redirecting to results page...</p>
+        </div>
+      </div>
+    {/if}
+
+    <!-- Evaluation Form -->
+    {#if mounted}
+      <div 
+        class="bg-white rounded-2xl shadow-xl p-8 hover:shadow-2xl transition-shadow duration-300"
+        in:fly={{ y: 50, duration: 600, delay: 400, easing: quintOut }}
+      >
+      <div class="space-y-8">
+        <!-- Project Name -->
+        <div>
+          <label for="project-name" class="block text-lg font-semibold text-gray-900 mb-3">
+            📁 Project Name
+          </label>
+          <input
+            id="project-name"
+            type="text"
+            bind:value={projectName}
+            placeholder="e.g., AI Chatbot, E-commerce Platform, Portfolio Website"
+            class="w-full px-5 py-4 border-2 border-gray-300 rounded-xl focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 text-lg transition"
+            disabled={uploading}
+          />
+        </div>
+
+        <!-- Evaluation Query -->
+        <div>
+          <label for="eval-query" class="block text-lg font-semibold text-gray-900 mb-3">
+            🎯 Evaluation Criteria
+          </label>
+          <textarea
+            id="eval-query"
+            bind:value={evaluationQuery}
+            placeholder="Describe what you want to evaluate... (e.g., 'Evaluate for an AI hackathon focusing on innovation and code quality')"
+            rows="4"
+            class="w-full px-5 py-4 border-2 border-gray-300 rounded-xl focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 text-lg transition resize-none"
+            disabled={uploading}
+          ></textarea>
+          <p class="mt-2 text-sm text-gray-500">
+            💡 Be specific! The AI will evaluate your project based on this criteria.
+          </p>
+        </div>
+
+        <!-- File Upload Area -->
+        <div>
+          <label for="file-input" class="block text-lg font-semibold text-gray-900 mb-3">
+            📤 Upload Project Files
+          </label>
+          
+          <div
+            role="button"
+            tabindex="0"
+            class="relative border-4 border-dashed rounded-xl transition-all duration-200 {dragActive ? 'border-indigo-500 bg-indigo-50' : 'border-gray-300 bg-gray-50'}"
+            ondrop={handleDrop}
+            ondragover={handleDragOver}
+            ondragleave={handleDragLeave}
+          >
+            <input
+              id="file-input"
+              type="file"
+              multiple
+              onchange={handleFileChange}
+              class="absolute inset-0 w-full h-full opacity-0 cursor-pointer"
+              disabled={uploading}
+              accept=".py,.js,.ts,.html,.css,.json,.md,.txt,.zip,.pdf,.png,.jpg,.jpeg,.gif,.svg,.java,.cpp,.c,.go,.rb,.php,.swift,.kt,.rs"
+            />
+            
+            <div class="p-12 text-center">
+              <div class="text-6xl mb-4">
+                {#if dragActive}
+                  📥
+                {:else}
+                  📦
+                {/if}
+              </div>
+              <p class="text-xl font-semibold text-gray-700 mb-2">
+                {#if dragActive}
+                  Drop your files here!
+                {:else}
+                  Drag & drop files or click to browse
+                {/if}
+              </p>
+              <p class="text-sm text-gray-500">
+                Supports: Code files, docs, images, PDFs, ZIP archives
+              </p>
+              <p class="text-xs text-gray-400 mt-2">
+                Max size: 50MB per file
+              </p>
+            </div>
+          </div>
+
+          <!-- Uploaded Files List -->
+          {#if projectFiles && projectFiles.length > 0}
+            <div class="mt-4 space-y-2">
+              <div class="flex justify-between items-center mb-3">
+                <p class="text-sm font-semibold text-gray-700">
+                  📎 {projectFiles.length} file{projectFiles.length > 1 ? 's' : ''} selected
+                </p>
+                <button
+                  onclick={clearFiles}
+                  class="text-sm text-red-600 hover:text-red-700 font-medium"
+                  disabled={uploading}
+                >
+                  Clear all
+                </button>
+              </div>
+              
+              <div class="max-h-64 overflow-y-auto space-y-2">
+                {#each Array.from(projectFiles) as file, i}
+                  <div 
+                    class="flex items-center gap-3 p-3 bg-gray-50 rounded-lg hover:bg-gray-100 transition-all duration-200 hover:scale-102 hover:shadow-md"
+                    in:fly={{ x: -20, duration: 300, delay: i * 50 }}
+                  >
+                    <span class="text-2xl">{getFileIcon(file.name)}</span>
+                    <div class="flex-1 min-w-0">
+                      <p class="text-sm font-medium text-gray-900 truncate">{file.name}</p>
+                      <p class="text-xs text-gray-500">{formatFileSize(file.size)}</p>
+                    </div>
+                  </div>
+                {/each}
+              </div>
+            </div>
+          {/if}
+        </div>
+
+        <!-- Submit Button -->
+        <div class="pt-4">
+          <button
+            onclick={evaluateProject}
+            disabled={uploading || !projectName.trim() || !projectFiles || projectFiles.length === 0}
+            class="w-full py-5 px-6 bg-gradient-to-r from-indigo-600 to-purple-600 text-white text-xl font-bold rounded-xl hover:from-indigo-700 hover:to-purple-700 disabled:from-gray-400 disabled:to-gray-500 disabled:cursor-not-allowed transition-all duration-200 shadow-lg hover:shadow-xl transform hover:-translate-y-0.5"
+          >
+            {#if uploading}
+              <span class="flex items-center justify-center gap-3">
+                <svg class="animate-spin h-6 w-6 text-white" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                  <circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+                  <path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                </svg>
+                Evaluating with AI...
+              </span>
+            {:else}
+              🚀 Start AI Evaluation
+            {/if}
+          </button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Info Cards -->
+    <div class="mt-12 grid grid-cols-1 md:grid-cols-3 gap-6">
+      <div 
+        class="bg-white rounded-xl p-6 shadow-lg border-2 border-indigo-100 hover:border-indigo-300 hover:shadow-xl transition-all duration-300 hover:-translate-y-1 transform"
+        in:scale={{ duration: 400, delay: 600, easing: elasticOut }}
+      >
+        <div class="text-4xl mb-3 animate-bounce">⚡</div>
+        <h3 class="text-lg font-bold text-gray-900 mb-2">Instant Analysis</h3>
+        <p class="text-sm text-gray-600">Get AI-powered evaluation results in seconds</p>
+      </div>
+      
+      <div 
+        class="bg-white rounded-xl p-6 shadow-lg border-2 border-purple-100 hover:border-purple-300 hover:shadow-xl transition-all duration-300 hover:-translate-y-1 transform"
+        in:scale={{ duration: 400, delay: 700, easing: elasticOut }}
+      >
+        <div class="text-4xl mb-3 animate-pulse">📊</div>
+        <h3 class="text-lg font-bold text-gray-900 mb-2">5 Key Metrics</h3>
+        <p class="text-sm text-gray-600">Relevance, Technical, Creativity, Documentation, Productivity</p>
+      </div>
+      
+      <div 
+        class="bg-white rounded-xl p-6 shadow-lg border-2 border-pink-100 hover:border-pink-300 hover:shadow-xl transition-all duration-300 hover:-translate-y-1 transform"
+        in:scale={{ duration: 400, delay: 800, easing: elasticOut }}
+      >
+        <div class="text-4xl mb-3">💡</div>
+        <h3 class="text-lg font-bold text-gray-900 mb-2">AI Feedback</h3>
+        <p class="text-sm text-gray-600">Detailed insights and improvement suggestions</p>
+      </div>
+    </div>
+    {/if}
+  </main>
+</div>
+
+<style>
+  @keyframes gradient {
+    0% { background-position: 0% 50%; }
+    50% { background-position: 100% 50%; }
+    100% { background-position: 0% 50%; }
+  }
+  
+  .animate-gradient {
+    animation: gradient 3s ease infinite;
+  }
+</style>
+

src/pages/Results.svelte

@@ -0,0 +1,402 @@
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { hackathonApi, evaluationApi, type Hackathon } from '../lib/api';
+  import RadialChart from '../components/RadialChart.svelte';
+  import BarChart from '../components/BarChart.svelte';
+  import { fly, fade, scale, slide } from 'svelte/transition';
+  import { elasticOut, quintOut, backOut } from 'svelte/easing';
+
+  interface Props {
+    hackathonId?: string;
+  }
+
+  let { hackathonId }: Props = $props();
+
+  let hackathons = $state<Hackathon[]>([]);
+  let selectedHackathonId = $state<number | null>(hackathonId ? parseInt(hackathonId) : null);
+  let selectedHackathon = $state<Hackathon | null>(null);
+  let results = $state<any[]>([]);
+  let loading = $state(false);
+  let error = $state('');
+  let expandedResultId = $state<number | null>(null);
+  let mounted = $state(false);
+
+  onMount(() => {
+    mounted = true;
+  });
+
+  onMount(async () => {
+    await loadHackathons();
+    if (selectedHackathonId) {
+      await loadResults();
+    }
+  });
+
+  async function loadHackathons() {
+    try {
+      loading = true;
+      error = '';
+      hackathons = await hackathonApi.getAll();
+      if (selectedHackathonId) {
+        selectedHackathon = hackathons.find(h => h.id === selectedHackathonId) || null;
+      }
+    } catch (err: any) {
+      error = err.message || 'Failed to load hackathons';
+      console.error('Error loading hackathons:', err);
+    } finally {
+      loading = false;
+    }
+  }
+
+  async function loadResults() {
+    if (!selectedHackathonId) return;
+
+    try {
+      loading = true;
+      error = '';
+      results = await evaluationApi.getByHackathon(selectedHackathonId);
+      selectedHackathon = hackathons.find(h => h.id === selectedHackathonId) || null;
+      
+      // Sort by overall score
+      results.sort((a, b) => (b.evaluation?.overall_score || 0) - (a.evaluation?.overall_score || 0));
+    } catch (err: any) {
+      error = err.message || 'Failed to load results';
+      console.error('Error loading results:', err);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function getMedalEmoji(rank: number): string {
+    if (rank === 0) return '🥇';
+    if (rank === 1) return '🥈';
+    if (rank === 2) return '🥉';
+    return '🏅';
+  }
+
+  function getScoreColor(score: number): string {
+    if (score >= 8) return 'text-green-600';
+    if (score >= 6) return 'text-blue-600';
+    if (score >= 4) return 'text-yellow-600';
+    return 'text-red-600';
+  }
+
+  function getScoreBarColor(score: number): string {
+    if (score >= 8) return 'bg-green-500';
+    if (score >= 6) return 'bg-blue-500';
+    if (score >= 4) return 'bg-yellow-500';
+    return 'bg-red-500';
+  }
+
+  function toggleDetails(resultId: number) {
+    expandedResultId = expandedResultId === resultId ? null : resultId;
+  }
+</script>
+
+<div class="min-h-screen bg-gradient-to-br from-purple-50 to-pink-100">
+  <!-- Header -->
+  <header class="bg-white shadow">
+    <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
+      <div class="flex justify-between items-center">
+        <div>
+          <h1 class="text-3xl font-bold text-gray-900">🏆 Leaderboard & Results</h1>
+          <p class="mt-1 text-sm text-gray-500">View AI evaluation results and rankings</p>
+        </div>
+        <div class="flex gap-3">
+          <a href="#/" class="px-4 py-2 bg-gray-600 text-white rounded-lg hover:bg-gray-700 transition">
+            Dashboard
+          </a>
+          <a href="#/submit" class="px-4 py-2 bg-primary-600 text-white rounded-lg hover:bg-primary-700 transition">
+            Submit Project
+          </a>
+        </div>
+      </div>
+    </div>
+  </header>
+
+  <main class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+    {#if error}
+      <div class="mb-4 p-4 bg-red-50 border border-red-200 rounded-lg">
+        <p class="text-red-800">{error}</p>
+      </div>
+    {/if}
+
+    <!-- Hackathon Selector -->
+    <div class="bg-white rounded-lg shadow p-6 mb-6">
+      <label for="hackathon-select" class="block text-sm font-medium text-gray-700 mb-3">
+        Select Hackathon
+      </label>
+      {#if loading && hackathons.length === 0}
+        <div class="text-gray-500">Loading...</div>
+      {:else if hackathons.length === 0}
+        <p class="text-gray-500">No hackathons found</p>
+      {:else}
+        <select
+          id="hackathon-select"
+          bind:value={selectedHackathonId}
+          onchange={loadResults}
+          class="w-full px-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-primary-500 focus:border-primary-500"
+        >
+          <option value={null}>Choose a hackathon...</option>
+          {#each hackathons as hackathon}
+            <option value={hackathon.id}>{hackathon.name}</option>
+          {/each}
+        </select>
+      {/if}
+    </div>
+
+    {#if !selectedHackathonId}
+      <div class="bg-white rounded-lg shadow p-12 text-center">
+        <div class="text-6xl mb-4">🎯</div>
+        <h3 class="text-xl font-semibold text-gray-700 mb-2">Select a Hackathon</h3>
+        <p class="text-gray-500">Choose a hackathon to view its evaluation results and leaderboard</p>
+      </div>
+    {:else}
+      <!-- Hackathon Info -->
+      {#if selectedHackathon}
+        <div class="bg-gradient-to-r from-primary-600 to-indigo-600 rounded-lg shadow-lg p-6 mb-6 text-white">
+          <h2 class="text-2xl font-bold mb-2">{selectedHackathon.name}</h2>
+          <p class="text-primary-100">{selectedHackathon.description}</p>
+          <div class="mt-4 flex items-center gap-4 text-sm">
+            <span>📊 {results.length} Submissions</span>
+            <span>📅 Created: {new Date(selectedHackathon.created_at || '').toLocaleDateString()}</span>
+          </div>
+        </div>
+      {/if}
+
+      <!-- Results Table -->
+      {#if loading}
+        <div class="bg-white rounded-lg shadow p-12 text-center">
+          <div class="text-gray-500">Loading results...</div>
+        </div>
+      {:else if results.length === 0}
+        <div class="bg-white rounded-lg shadow p-12 text-center">
+          <div class="text-6xl mb-4">📭</div>
+          <h3 class="text-xl font-semibold text-gray-700 mb-2">No Results Yet</h3>
+          <p class="text-gray-500">Submissions are still being evaluated or no submissions have been made.</p>
+        </div>
+      {:else}
+        <div class="bg-white rounded-lg shadow overflow-hidden">
+          <!-- Summary Stats -->
+          <div class="p-6 bg-gray-50 border-b border-gray-200">
+            <div class="grid grid-cols-1 md:grid-cols-4 gap-4">
+              <div class="text-center">
+                <div class="text-3xl font-bold text-primary-600">
+                  {results.filter(r => r.evaluation).length}
+                </div>
+                <div class="text-sm text-gray-600">Evaluated</div>
+              </div>
+              <div class="text-center">
+                <div class="text-3xl font-bold text-green-600">
+                  {(results.reduce((acc, r) => acc + (r.evaluation?.overall_score || 0), 0) / results.filter(r => r.evaluation).length).toFixed(1)}
+                </div>
+                <div class="text-sm text-gray-600">Avg Score</div>
+              </div>
+              <div class="text-center">
+                <div class="text-3xl font-bold text-blue-600">
+                  {Math.max(...results.map(r => r.evaluation?.overall_score || 0)).toFixed(1)}
+                </div>
+                <div class="text-sm text-gray-600">Highest</div>
+              </div>
+              <div class="text-center">
+                <div class="text-3xl font-bold text-yellow-600">
+                  {results.filter(r => !r.evaluation).length}
+                </div>
+                <div class="text-sm text-gray-600">Pending</div>
+              </div>
+            </div>
+          </div>
+
+          <!-- Leaderboard -->
+          <div class="p-6">
+            <h3 class="text-lg font-semibold mb-4">🏆 Rankings</h3>
+            <div class="space-y-4">
+              {#each results as result, index}
+                {@const evaluation = result.evaluation}
+                <div class="border border-gray-200 rounded-lg p-4 hover:border-primary-300 transition {index < 3 ? 'bg-gradient-to-r from-yellow-50 to-orange-50' : ''}">
+                  <div class="flex items-start gap-4">
+                    <!-- Rank -->
+                    <div class="flex-shrink-0 text-center">
+                      <div class="text-3xl">{getMedalEmoji(index)}</div>
+                      <div class="text-sm font-semibold text-gray-600 mt-1">#{index + 1}</div>
+                    </div>
+
+                    <!-- Project Info -->
+                    <div class="flex-1">
+                      <div class="flex justify-between items-start mb-3">
+                        <div>
+                          <h4 class="text-lg font-bold text-gray-900">{result.project_name}</h4>
+                          <p class="text-sm text-gray-600">Team: {result.team_name}</p>
+                        </div>
+                        {#if evaluation}
+                          <div class="text-right">
+                            <div class="text-3xl font-bold {getScoreColor(evaluation.overall_score)}">
+                              {evaluation.overall_score.toFixed(1)}
+                            </div>
+                            <div class="text-xs text-gray-500">/ 10</div>
+                          </div>
+                        {:else}
+                          <span class="px-3 py-1 bg-yellow-100 text-yellow-800 rounded-full text-sm">
+                            ⏳ Evaluating...
+                          </span>
+                        {/if}
+                      </div>
+
+                      {#if evaluation}
+                        <!-- Score Breakdown -->
+                        <div class="grid grid-cols-2 md:grid-cols-5 gap-3 mb-3">
+                          <div>
+                            <div class="text-xs text-gray-600 mb-1">Relevance</div>
+                            <div class="flex items-center gap-2">
+                              <div class="flex-1 bg-gray-200 rounded-full h-2">
+                                <div class="{getScoreBarColor(evaluation.relevance_score)} h-2 rounded-full" style="width: {evaluation.relevance_score * 10}%"></div>
+                              </div>
+                              <span class="text-sm font-semibold {getScoreColor(evaluation.relevance_score)}">
+                                {evaluation.relevance_score.toFixed(1)}
+                              </span>
+                            </div>
+                          </div>
+
+                          <div>
+                            <div class="text-xs text-gray-600 mb-1">Technical</div>
+                            <div class="flex items-center gap-2">
+                              <div class="flex-1 bg-gray-200 rounded-full h-2">
+                                <div class="{getScoreBarColor(evaluation.technical_complexity_score)} h-2 rounded-full" style="width: {evaluation.technical_complexity_score * 10}%"></div>
+                              </div>
+                              <span class="text-sm font-semibold {getScoreColor(evaluation.technical_complexity_score)}">
+                                {evaluation.technical_complexity_score.toFixed(1)}
+                              </span>
+                            </div>
+                          </div>
+
+                          <div>
+                            <div class="text-xs text-gray-600 mb-1">Creativity</div>
+                            <div class="flex items-center gap-2">
+                              <div class="flex-1 bg-gray-200 rounded-full h-2">
+                                <div class="{getScoreBarColor(evaluation.creativity_score)} h-2 rounded-full" style="width: {evaluation.creativity_score * 10}%"></div>
+                              </div>
+                              <span class="text-sm font-semibold {getScoreColor(evaluation.creativity_score)}">
+                                {evaluation.creativity_score.toFixed(1)}
+                              </span>
+                            </div>
+                          </div>
+
+                          <div>
+                            <div class="text-xs text-gray-600 mb-1">Documentation</div>
+                            <div class="flex items-center gap-2">
+                              <div class="flex-1 bg-gray-200 rounded-full h-2">
+                                <div class="{getScoreBarColor(evaluation.documentation_score)} h-2 rounded-full" style="width: {evaluation.documentation_score * 10}%"></div>
+                              </div>
+                              <span class="text-sm font-semibold {getScoreColor(evaluation.documentation_score)}">
+                                {evaluation.documentation_score.toFixed(1)}
+                              </span>
+                            </div>
+                          </div>
+
+                          <div>
+                            <div class="text-xs text-gray-600 mb-1">Productivity</div>
+                            <div class="flex items-center gap-2">
+                              <div class="flex-1 bg-gray-200 rounded-full h-2">
+                                <div class="{getScoreBarColor(evaluation.productivity_score)} h-2 rounded-full" style="width: {evaluation.productivity_score * 10}%"></div>
+                              </div>
+                              <span class="text-sm font-semibold {getScoreColor(evaluation.productivity_score)}">
+                                {evaluation.productivity_score.toFixed(1)}
+                              </span>
+                            </div>
+                          </div>
+                        </div>
+
+                        <!-- View Details Button -->
+                        <button
+                          onclick={() => toggleDetails(result.id)}
+                          class="mt-4 w-full px-4 py-2 bg-gradient-to-r from-primary-600 to-indigo-600 text-white rounded-lg hover:from-primary-700 hover:to-indigo-700 transition flex items-center justify-center gap-2"
+                        >
+                          {#if expandedResultId === result.id}
+                            📊 Hide Detailed Analysis
+                          {:else}
+                            📊 View Detailed Analysis with Charts
+                          {/if}
+                        </button>
+
+                        <!-- Expanded Detailed View -->
+                        {#if expandedResultId === result.id}
+                          <div 
+                            class="mt-6 p-6 bg-gradient-to-br from-gray-50 to-blue-50 rounded-lg border-2 border-primary-200"
+                            in:slide={{ duration: 400, easing: quintOut }}
+                          >
+                            <h4 
+                              class="text-lg font-bold text-gray-900 mb-6 flex items-center gap-2"
+                              in:fade={{ delay: 100, duration: 300 }}
+                            >
+                              📊 Detailed Score Analysis
+                            </h4>
+
+                            <!-- Radial Charts -->
+                            <div class="grid grid-cols-2 md:grid-cols-5 gap-6 mb-6">
+                              <div in:scale={{ delay: 200, duration: 500, easing: backOut }}>
+                                <RadialChart score={evaluation.relevance_score} label="Relevance" />
+                              </div>
+                              <div in:scale={{ delay: 300, duration: 500, easing: backOut }}>
+                                <RadialChart score={evaluation.technical_complexity_score} label="Technical" />
+                              </div>
+                              <div in:scale={{ delay: 400, duration: 500, easing: backOut }}>
+                                <RadialChart score={evaluation.creativity_score} label="Creativity" />
+                              </div>
+                              <div in:scale={{ delay: 500, duration: 500, easing: backOut }}>
+                                <RadialChart score={evaluation.documentation_score} label="Documentation" />
+                              </div>
+                              <div in:scale={{ delay: 600, duration: 500, easing: backOut }}>
+                                <RadialChart score={evaluation.productivity_score} label="Productivity" />
+                              </div>
+                            </div>
+
+                            <!-- Bar Charts -->
+                            <div 
+                              class="bg-white rounded-lg p-6 shadow-sm mb-6"
+                              in:fly={{ y: 20, delay: 700, duration: 400 }}
+                            >
+                              <h5 class="text-md font-semibold text-gray-900 mb-4">📈 Score Breakdown</h5>
+                              <div class="space-y-4">
+                                <div in:fly={{ x: -20, delay: 800, duration: 300 }}>
+                                  <BarChart score={evaluation.relevance_score} label="Relevance" />
+                                </div>
+                                <div in:fly={{ x: -20, delay: 900, duration: 300 }}>
+                                  <BarChart score={evaluation.technical_complexity_score} label="Technical Complexity" />
+                                </div>
+                                <div in:fly={{ x: -20, delay: 1000, duration: 300 }}>
+                                  <BarChart score={evaluation.creativity_score} label="Creativity" />
+                                </div>
+                                <div in:fly={{ x: -20, delay: 1100, duration: 300 }}>
+                                  <BarChart score={evaluation.documentation_score} label="Documentation" />
+                                </div>
+                                <div in:fly={{ x: -20, delay: 1200, duration: 300 }}>
+                                  <BarChart score={evaluation.productivity_score} label="Productivity" />
+                                </div>
+                              </div>
+                            </div>
+
+                            <!-- AI Feedback -->
+                            <div 
+                              class="bg-white rounded-lg p-6 shadow-sm"
+                              in:scale={{ delay: 1300, duration: 400, easing: elasticOut }}
+                            >
+                              <h5 class="text-md font-semibold text-gray-900 mb-3 flex items-center gap-2">
+                                💬 AI Evaluation Feedback
+                              </h5>
+                              <p class="text-sm text-gray-700 leading-relaxed">{evaluation.feedback}</p>
+                            </div>
+                          </div>
+                        {/if}
+                      {/if}
+                    </div>
+                  </div>
+                </div>
+              {/each}
+            </div>
+          </div>
+        </div>
+      {/if}
+    {/if}
+  </main>
+</div>
+

tailwind.config.js

@@ -0,0 +1,27 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    './index.html',
+    './src/**/*.{svelte,js,ts,jsx,tsx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        primary: {
+          50: '#eff6ff',
+          100: '#dbeafe',
+          200: '#bfdbfe',
+          300: '#93c5fd',
+          400: '#60a5fa',
+          500: '#3b82f6',
+          600: '#2563eb',
+          700: '#1d4ed8',
+          800: '#1e40af',
+          900: '#1e3a8a',
+        },
+      },
+    },
+  },
+  plugins: [],
+}
+

utils.py

@@ -0,0 +1,220 @@
+import os
+import zipfile
+import shutil
+from werkzeug.utils import secure_filename
+from config import Config
+
+def allowed_file(filename):
+    """Check if file extension is allowed"""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in Config.ALLOWED_EXTENSIONS
+
+def extract_code_from_files(file_paths):
+    """Extract code content from uploaded files with smart filtering"""
+    code_content = []
+    total_size = 0
+    max_total_size = 100 * 1024 * 1024  # 10MB limit for code content
+    
+    for file_path in file_paths:
+        if not os.path.exists(file_path):
+            continue
+            
+        try:
+            # Handle zip files
+            if file_path.endswith('.zip'):
+                zip_content, zip_size = extract_from_zip_smart(file_path, max_total_size - total_size)
+                code_content.extend(zip_content)
+                total_size += zip_size
+            else:
+                # Check file size before reading - be more generous for project code
+                file_size = os.path.getsize(file_path)
+                if file_size > 5 * 1024 * 1024:  # Skip files larger than 5MB (very generous)
+                    code_content.append(f"# File: {os.path.basename(file_path)} (SKIPPED - too large: {file_size//1024}KB)\n")
+                    continue
+                
+                if total_size + file_size > max_total_size:
+                    code_content.append(f"# Remaining files skipped - size limit reached ({max_total_size//1024//1024}MB)\n")
+                    break
+                
+                # Try to read as text
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                    code_content.append(f"# File: {os.path.basename(file_path)}\n{content}\n")
+                    total_size += len(content)
+                    
+        except Exception as e:
+            print(f"Error reading file {file_path}: {str(e)}")
+            code_content.append(f"# File: {os.path.basename(file_path)} (ERROR: {str(e)})\n")
+    
+    print(f"📊 Code extraction complete: {len(code_content)} files, {total_size//1024}KB total")
+    return "\n\n".join(code_content)
+
+def should_skip_directory(dir_path):
+    """Check if directory should be skipped - only skip truly irrelevant directories"""
+    skip_dirs = {
+        # Dependencies and package managers
+        'node_modules', 'vendor', 'packages', '.pnpm-store',
+        
+        # Version control
+        '.git', '.svn', '.hg',
+        
+        # Build outputs and artifacts
+        'build', 'dist', 'out', '.next', '.nuxt', 'target', 'bin', 'obj',
+        'public/build', 'static/build', 'assets/build',
+        
+        # Cache and temporary files
+        '__pycache__', '.pytest_cache', '.cache', '.parcel-cache',
+        '.nyc_output', 'coverage', 'htmlcov',
+        'tmp', 'temp', 'logs', 'log',
+        
+        # IDE and editor files
+        '.vscode', '.idea', '.vs', '.sublime-project',
+        
+        # OS generated files
+        '.ds_store', 'thumbs.db',
+        
+        # Environment and secrets (but keep example files)
+        '.env.local', '.env.production'
+    }
+    
+    dir_name = os.path.basename(dir_path).lower()
+    
+    # Skip hidden directories except important ones
+    if dir_name.startswith('.'):
+        important_hidden = {'.github', '.gitlab', '.docker', '.vscode', '.idea'}
+        return dir_name not in important_hidden
+    
+    return dir_name in skip_dirs
+
+def should_prioritize_file(file_path):
+    """Check if file should be prioritized for extraction"""
+    filename = os.path.basename(file_path).lower()
+    priority_files = {
+        'readme.md', 'readme.txt', 'readme', 'main.py', 'index.js', 
+        'app.py', 'server.js', 'package.json', 'requirements.txt',
+        'dockerfile', 'docker-compose.yml', 'config.py', 'settings.py'
+    }
+    return filename in priority_files
+
+def extract_from_zip_smart(zip_path, max_size_remaining):
+    """Smart extraction from ZIP with filtering and prioritization"""
+    extracted_content = []
+    extract_dir = zip_path + '_extracted'
+    total_size = 0
+    
+    try:
+        with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+            zip_ref.extractall(extract_dir)
+        
+        # First pass: collect and prioritize files
+        all_files = []
+        priority_files = []
+        
+        for root, dirs, files in os.walk(extract_dir):
+            # Skip unwanted directories
+            dirs[:] = [d for d in dirs if not should_skip_directory(os.path.join(root, d))]
+            
+            for file in files:
+                file_path = os.path.join(root, file)
+                if allowed_file(file):
+                    relative_path = os.path.relpath(file_path, extract_dir)
+                    
+                    # Check file size
+                    try:
+                        file_size = os.path.getsize(file_path)
+                        if file_size > 500 * 1024:  # Skip files larger than 500KB
+                            continue
+                            
+                        file_info = (file_path, relative_path, file_size)
+                        
+                        if should_prioritize_file(file_path):
+                            priority_files.append(file_info)
+                        else:
+                            all_files.append(file_info)
+                    except:
+                        continue
+        
+        # Process priority files first
+        for file_path, relative_path, file_size in priority_files:
+            if total_size + file_size > max_size_remaining:
+                break
+                
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                    extracted_content.append(f"# File: {relative_path} [PRIORITY]\n{content}\n")
+                    total_size += len(content)
+            except Exception as e:
+                print(f"Error reading priority file {file_path}: {str(e)}")
+        
+        # Process remaining files
+        for file_path, relative_path, file_size in all_files:
+            if total_size + file_size > max_size_remaining:
+                extracted_content.append(f"# Remaining files skipped - size limit reached\n")
+                break
+                
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                    extracted_content.append(f"# File: {relative_path}\n{content}\n")
+                    total_size += len(content)
+            except Exception as e:
+                print(f"Error reading file {file_path}: {str(e)}")
+        
+        # Clean up extracted directory
+        shutil.rmtree(extract_dir, ignore_errors=True)
+        
+        print(f"📦 ZIP extraction: {len(extracted_content)} files, {total_size//1024}KB")
+        
+    except Exception as e:
+        print(f"Error extracting zip file {zip_path}: {str(e)}")
+    
+    return extracted_content, total_size
+
+def extract_from_zip(zip_path):
+    """Legacy function for backward compatibility"""
+    content, _ = extract_from_zip_smart(zip_path, 10 * 1024 * 1024)
+    return content
+
+def extract_documentation(file_paths, project_description):
+    """Extract documentation from files (README, .md files, etc.)"""
+    doc_content = [f"Project Description:\n{project_description}\n\n"]
+    
+    for file_path in file_paths:
+        if not os.path.exists(file_path):
+            continue
+            
+        filename = os.path.basename(file_path).lower()
+        
+        # Look for documentation files
+        if any(doc in filename for doc in ['readme', '.md', 'doc', '.txt']):
+            try:
+                with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                    content = f.read()
+                    doc_content.append(f"# {os.path.basename(file_path)}\n{content}\n")
+            except Exception as e:
+                print(f"Error reading doc file {file_path}: {str(e)}")
+    
+    return "\n\n".join(doc_content)
+
+def create_upload_folder():
+    """Create upload folder if it doesn't exist"""
+    if not os.path.exists(Config.UPLOAD_FOLDER):
+        os.makedirs(Config.UPLOAD_FOLDER)
+
+def save_uploaded_file(file, submission_id):
+    """Save uploaded file and return path"""
+    create_upload_folder()
+    
+    filename = secure_filename(file.filename)
+    submission_folder = os.path.join(Config.UPLOAD_FOLDER, f'submission_{submission_id}')
+    
+    if not os.path.exists(submission_folder):
+        os.makedirs(submission_folder)
+    
+    file_path = os.path.join(submission_folder, filename)
+    file.save(file_path)
+    
+    return file_path
+
+

vite.config.ts

@@ -4,4 +4,13 @@ import { svelte } from '@sveltejs/vite-plugin-svelte'
 // https://vite.dev/config/
 export default defineConfig({
   plugins: [svelte()],
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:5000',
+        changeOrigin: true,
+      }
+    }
+  }
 })