Initial deploy

.gitignore

@@ -0,0 +1,81 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+.db-journal
+
+# Uploads and results
+backend/uploads/
+backend/results/
+backend/.model_cache/
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Flask
+instance/
+.webassets-cache
+
+# Model cache
+.model_cache/
+models/
+*.bin
+*.pt
+*.pth
+
+# Logs
+*.log
+logs/
+
+# TMP
+tmp/
+.tmp/
+
+# Local data (not for repo/HF Space)
+submissions.jsonl
+slop_detect.db
+
+# HuggingFace model/hub cache
+.cache/

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+# System deps needed by pypdf, python-docx, torch
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc \
+    libgomp1 \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install Python dependencies (cached as a separate layer)
+COPY backend/requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source
+COPY backend/ ./backend/
+COPY frontend/ ./frontend/
+
+# Runtime directories
+RUN mkdir -p uploads results .cache
+
+# HF Spaces requires port 7860 and runs containers as uid 1000
+RUN useradd -m -u 1000 user && chown -R user:user /app
+USER user
+
+# PYTHONPATH=/app lets `from backend.X import ...` resolve correctly
+ENV PORT=7860 \
+    HOST=0.0.0.0 \
+    DEBUG=False \
+    PYTHONPATH=/app \
+    HF_HOME=/app/.cache/huggingface \
+    MODEL_CACHE_DIR=/app/.cache/models
+
+EXPOSE 7860
+
+CMD ["python", "backend/main.py"]

README.md

@@ -1,12 +1,503 @@
 ---
-title: Screencomply Documents
-emoji: 🔥
-colorFrom: red
-colorTo: pink
+title: AI Slop Detector
+emoji: 🔍
+colorFrom: purple
+colorTo: blue
 sdk: docker
+app_port: 7860
 pinned: false
-license: mit
-short_description: Document AI Detector
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔍 AI Slop Detector
+
+A comprehensive Python API and web UI for detecting AI-generated content in PDFs, DOCX files, and raw text. Uses an ensemble of multiple state-of-the-art detection methods.
+
+## Features
+
+✨ **Multi-Detector Ensemble**
+- **RoBERTa Classifier** - Fine-tuned RoBERTa model for AI text detection
+- **Perplexity Analysis** - Detects statistical anomalies and repetitive patterns
+- **LLMDet** - Entropy and log-probability based detection
+- **HuggingFace Classifier** - Generic transformer-based classification
+- **OUTFOX Statistical** - Word/sentence length and vocabulary analysis
+
+✨ **Easy Feature Flags**
+- Enable/disable each detector with a single config change
+- Adjust detector weights for ensemble averaging
+- Environment variable overrides
+
+✨ **Multiple File Formats**
+- PDF documents
+- DOCX/DOC files
+- Plain text files
+- Raw text input
+
+✨ **Persistent Storage**
+- SQLite database (default, configurable)
+- Upload history with timestamps
+- Detailed result tracking and statistics
+
+✨ **Web UI**
+- Beautiful, responsive interface
+- Drag-and-drop file upload
+- Real-time analysis results
+- History and statistics views
+
+✨ **REST API**
+- Analyze text and files via HTTP
+- Get historical results
+- Query statistics
+- Full result management
+
+## Installation
+
+### Prerequisites
+- Python 3.8+
+- pip or conda
+
+### Setup
+
+1. **Clone/Navigate to the project:**
+```bash
+cd slop-detect
+```
+
+2. **Create a Python virtual environment:**
+```bash
+python -m venv venv
+
+# On Windows:
+venv\Scripts\activate
+
+# On macOS/Linux:
+source venv/bin/activate
+```
+
+3. **Install dependencies:**
+```bash
+pip install -r backend/requirements.txt
+```
+
+## Configuration
+
+### Enable/Disable Detectors
+
+Edit `backend/config/detectors_config.py`:
+
+```python
+ENABLED_DETECTORS: Dict[str, bool] = {
+    "roberta": True,           # Enable RoBERTa
+    "perplexity": True,        # Enable Perplexity
+    "llmdet": True,            # Enable LLMDet
+    "hf_classifier": True,     # Enable HF Classifier
+    "outfox": False,           # Disable OUTFOX
+}
+```
+
+### Set Detector Weights
+
+```python
+DETECTOR_WEIGHTS: Dict[str, float] = {
+    "roberta": 0.30,           # 30% weight
+    "perplexity": 0.25,        # 25% weight
+    "llmdet": 0.25,            # 25% weight
+    "hf_classifier": 0.20,     # 20% weight
+    "outfox": 0.00,            # 0% weight (not used)
+}
+```
+
+### Environment-based Configuration
+
+You can also use environment variables to override config:
+
+```bash
+# Enable/disable detectors
+export ENABLE_ROBERTA=true
+export ENABLE_PERPLEXITY=true
+export ENABLE_LLMDET=true
+export ENABLE_HF_CLASSIFIER=true
+export ENABLE_OUTFOX=false
+
+# Database
+export DATABASE_URL=sqlite:///slop_detect.db
+export UPLOAD_FOLDER=./uploads
+
+# Flask
+export HOST=0.0.0.0
+export PORT=5000
+export DEBUG=False
+```
+
+## Running the Application
+
+### Start the Flask Server
+
+```bash
+cd backend
+python main.py
+```
+
+The API will be available at `http://localhost:5000`
+
+### API Endpoints
+
+#### Health Check
+```
+GET /api/health
+```
+
+#### Analyze Text
+```
+POST /api/analyze/text
+Content-Type: application/json
+
+{
+    "text": "Your text here...",
+    "filename": "optional_name.txt",
+    "user_id": "optional_user_id"
+}
+
+Response:
+{
+    "status": "success",
+    "result_id": 1,
+    "overall_ai_score": 0.78,
+    "overall_ai_score_percentage": "78.0%",
+    "overall_confidence": "high",
+    "status_label": "Likely AI",
+    "detector_results": {
+        "roberta": {
+            "detector_name": "roberta",
+            "score": 0.85,
+            "confidence": "high",
+            "explanation": "Very strong indicators of AI-generated text..."
+        },
+        ...
+    },
+    "enabled_detectors": ["roberta", "perplexity", "llmdet", "hf_classifier"],
+    "text_stats": {
+        "character_count": 1500,
+        "word_count": 250,
+        "sentence_count": 15,
+        "average_word_length": 4.8
+    }
+}
+```
+
+#### Analyze File
+```
+POST /api/analyze/file
+FormData:
+- file: <file>
+- user_id: <optional_user_id>
+
+Response: (same as analyze/text)
+```
+
+#### Get All Results
+```
+GET /api/results?page=1&limit=10&sort=recent
+
+Response:
+{
+    "status": "success",
+    "page": 1,
+    "limit": 10,
+    "total_count": 42,
+    "results": [...]
+}
+```
+
+#### Get Specific Result
+```
+GET /api/results/{result_id}
+
+Response:
+{
+    "status": "success",
+    "result": {
+        "id": 1,
+        "filename": "document.pdf",
+        "overall_ai_score": 0.78,
+        "overall_ai_score_percentage": "78.0%",
+        ...
+    }
+}
+```
+
+#### Delete Result
+```
+DELETE /api/results/{result_id}
+```
+
+#### Update Result
+```
+PUT /api/results/{result_id}
+Content-Type: application/json
+
+{
+    "notes": "Manual review: likely AI",
+    "is_flagged": true
+}
+```
+
+#### Get Statistics
+```
+GET /api/statistics/summary
+
+Response:
+{
+    "status": "success",
+    "summary": {
+        "total_analyses": 42,
+        "average_ai_score": 0.65,
+        "total_text_analyzed": 125000,
+        "likely_human": 15,
+        "suspicious": 12,
+        "likely_ai": 15
+    }
+}
+```
+
+#### Get Configuration
+```
+GET /api/config
+
+Response:
+{
+    "status": "success",
+    "config": {
+        "enabled_detectors": [
+            "roberta", "perplexity", "llmdet", "hf_classifier"
+        ],
+        "aggregation_method": "weighted_average",
+        "detector_weights": {...},
+        "detector_info": {...}
+    }
+}
+```
+
+## Web Interface
+
+Open `http://localhost:5000` in your browser to access the web UI.
+
+### Features:
+- **Upload Section** - Drag-and-drop or click to upload files
+- **Text Analysis** - Paste text directly
+- **Results Dashboard** - View detailed analysis results
+- **History Tab** - See all previous analyses
+- **Statistics Tab** - View aggregate statistics
+
+## How It Works
+
+### Detection Process
+
+1. **File Parsing** - Extracts text from PDF/DOCX/TXT files
+2. **Text Cleaning** - Normalizes whitespace and formatting
+3. **Detector Ensemble** - Runs enabled detectors in parallel
+4. **Score Aggregation** - Combines detector scores using weighted average, max, or voting
+5. **Result Storage** - Saves to database with full metadata
+6. **Response** - Returns overall score and per-detector breakdown
+
+### Detector Details
+
+#### RoBERTa Detector
+- **Model**: roberta-base-openai-detector
+- **Type**: Transformer-based classification
+- **Output**: 0-1 probability score
+- **Speed**: Medium
+
+#### Perplexity Detector
+- **Model**: GPT-2
+- **Method**: Analyzes token probability distributions
+- **Detects**: Repetitive patterns, unusual word choices
+- **Output**: 0-1 score based on perplexity, repetition, AI phrases
+
+#### LLMDet Detector
+- **Model**: BERT
+- **Method**: Entropy and log-probability analysis
+- **Detects**: Predictable sequences, unusual statistical patterns
+- **Output**: 0-1 score from combined metrics
+
+#### HF Classifier
+- **Model**: Configurable (default: BERT)
+- **Type**: Generic sequence classification
+- **Output**: 0-1 probability score
+
+#### OUTFOX Statistical
+- **Type**: Statistical signature analysis
+- **Detects**: Unusual word length distributions, sentence structure patterns, vocabulary diversity
+- **Output**: 0-1 score from multiple statistical metrics
+
+### Scoring
+
+Default aggregation: **Weighted Average**
+```
+Overall Score = Σ (normalized_detector_score × weight)
+```
+
+Each detector's score is normalized to 0-1 range, then multiplied by its configured weight. The sum is clamped to [0, 1].
+
+### Confidence Levels
+
+- **Very Low** (< 20%) - Almost certainly human-written
+- **Low** (20-40%) - Probably human-written
+- **Medium** (40-60%) - Uncertain
+- **High** (60-80%) - Probably AI-generated
+- **Very High** (> 80%) - Almost certainly AI-generated
+
+## Project Structure
+
+```
+slop-detect/
+├── backend/
+│   ├── config/
+│   │   ├── settings.py          # App settings
+│   │   └── detectors_config.py  # Detector configuration (FEATURE FLAGS HERE)
+│   ├── detectors/
+│   │   ├── base.py              # Base detector class
+│   │   ├── roberta.py           # RoBERTa detector
+│   │   ├── perplexity.py        # Perplexity detector
+│   │   ├── llmdet.py            # LLMDet detector
+│   │   ├── hf_classifier.py     # HF classifier
+│   │   ├── outfox.py            # OUTFOX detector
+│   │   └── ensemble.py          # Ensemble manager
+│   ├── database/
+│   │   ├── models.py            # SQLAlchemy models
+│   │   └── db.py                # Database manager
+│   ├── api/
+│   │   ├── routes.py            # Flask API routes
+│   │   └── models.py            # Pydantic request/response models
+│   ├── utils/
+│   │   ├── file_parser.py       # PDF/DOCX/TXT parsing
+│   │   └── highlighter.py       # Text highlighting utilities
+│   ├── main.py                  # Flask app entry point
+│   └── requirements.txt          # Python dependencies
+├── frontend/
+│   └── index.html               # Web UI (HTML + CSS + JS)
+└── README.md                    # This file
+```
+
+## Customization
+
+### Change Detector Weights
+
+In `backend/config/detectors_config.py`:
+
+```python
+DETECTOR_WEIGHTS: Dict[str, float] = {
+    "roberta": 0.40,           # Increase weight
+    "perplexity": 0.30,
+    "llmdet": 0.20,
+    "hf_classifier": 0.10,
+}
+```
+
+### Change Aggregation Method
+
+In `backend/config/detectors_config.py`:
+
+```python
+AGGREGATION_METHOD = "max"  # Options: weighted_average, max, voting
+```
+
+### Use Different Models
+
+In `backend/config/detectors_config.py`:
+
+```python
+ROBERTA_MODEL = "distilbert-base-uncased"
+PERPLEXITY_MODEL = "gpt2-medium"
+HF_CLASSIFIER_MODEL = "your-custom-model"
+```
+
+### Add Custom Detectors
+
+1. Create a new file in `backend/detectors/`
+2. Inherit from `BaseDetector`
+3. Implement `detect()` method
+4. Add to `ensemble.py` initialization
+5. Add to `ENABLED_DETECTORS` in config
+
+Example:
+
+```python
+from detectors.base import BaseDetector, DetectorResult
+
+class CustomDetector(BaseDetector):
+    def __init__(self):
+        super().__init__(name="custom")
+    
+    def detect(self, text: str) -> DetectorResult:
+        # Your detection logic here
+        score = calculate_ai_score(text)
+        return DetectorResult(
+            detector_name=self.name,
+            score=score,
+            explanation="Custom detection result"
+        )
+```
+
+## Performance Tips
+
+1. **Model Caching** - Models are lazy-loaded and cached in memory
+2. **Parallel Detection** - Detectors can run in parallel (future enhancement)
+3. **Batch Processing** - Configure batch size for GPU processing
+4. **Disable Unused Detectors** - Reduce load by disabling detectors you don't need
+
+## Troubleshooting
+
+### Slow First Run
+- Models need to be downloaded from Hugging Face Hub
+- Subsequent runs will use cached models
+- First model download can take 1-5 minutes
+
+### Out of Memory
+- Reduce batch size in config
+- Disable memory-intensive detectors
+- Run on a machine with more RAM
+
+### Model Not Found
+```
+transformers.utils.RepositoryNotFoundError: Model not found
+```
+- Model name is incorrect in config
+- Check Hugging Face Hub for correct model name
+
+### Database Locked
+```
+sqlite3.OperationalError: database is locked
+```
+- Close other connections to the database
+- Ensure only one Flask instance is running
+- Delete `.db-journal` file if present
+
+## Future Enhancements
+
+- [ ] Parallel detector execution
+- [ ] GPU support optimization
+- [ ] Custom model fine-tuning
+- [ ] Batch analysis API
+- [ ] User authentication/authorization
+- [ ] Document highlighting with suspicious sections
+- [ ] Advanced filtering and search
+- [ ] Export results to PDF/Excel
+- [ ] API rate limiting
+- [ ] Webhook notifications
+
+## License
+
+MIT License - feel free to use and modify
+
+## References
+
+- [LLMDet](https://github.com/TrustedLLM/LLMDet)
+- [RAID](https://github.com/liamdugan/raid)
+- [OUTFOX](https://github.com/ryuryukke/OUTFOX)
+- [AIGTD Survey](https://github.com/Nicozwy/AIGTD-Survey)
+- [Plagiarism Detection](https://github.com/Kyle6012/plagiarism-detection)
+- [Hugging Face Transformers](https://huggingface.co/transformers/)
+
+## Support
+
+For issues, questions, or suggestions, please open an issue on the project repository.

backend/__init__.py

@@ -0,0 +1,6 @@
+"""
+AI Slop Detection Backend
+"""
+
+__version__ = "1.0.0"
+__author__ = "AI Slop Detection Team"

backend/api/__init__.py

@@ -0,0 +1,3 @@
+from .routes import api
+
+__all__ = ["api"]

backend/api/models.py

@@ -0,0 +1,73 @@
+from pydantic import BaseModel
+from typing import Optional, Dict, List, Any
+from datetime import datetime
+
+# Request Models
+
+class AnalyzeTextRequest(BaseModel):
+    """Request model for analyzing raw text"""
+    text: str
+    user_id: Optional[str] = None
+    filename: Optional[str] = "untitled.txt"
+
+class GetResultRequest(BaseModel):
+    """Request model for getting a specific result"""
+    result_id: int
+
+class DeleteResultRequest(BaseModel):
+    """Request model for deleting a result"""
+    result_id: int
+
+class UpdateResultRequest(BaseModel):
+    """Request model for updating a result"""
+    result_id: int
+    notes: Optional[str] = None
+    is_flagged: Optional[bool] = None
+
+# Response Models
+
+class DetectorResultResponse(BaseModel):
+    """Response model for single detector result"""
+    detector_name: str
+    score: float
+    confidence: Optional[str] = None
+    explanation: Optional[str] = None
+    suspicious_spans: List[Dict[str, Any]] = []
+    metadata: Dict[str, Any] = {}
+
+class AnalysisResponse(BaseModel):
+    """Response model for analysis result"""
+    status: str  # success, error
+    message: str
+    result_id: Optional[int] = None
+    file_id: Optional[str] = None
+    overall_ai_score: Optional[float] = None
+    overall_ai_score_percentage: Optional[str] = None
+    overall_confidence: Optional[str] = None
+    status_label: Optional[str] = None
+    detector_results: Optional[Dict[str, DetectorResultResponse]] = None
+    enabled_detectors: Optional[List[str]] = None
+    text_stats: Optional[Dict[str, Any]] = None
+    error_details: Optional[str] = None
+
+class ResultListResponse(BaseModel):
+    """Response model for list of results"""
+    status: str
+    message: str
+    total_count: int
+    results: List[Dict[str, Any]] = []
+    page: int = 1
+    page_size: int = 10
+
+class SummaryResponse(BaseModel):
+    """Response model for summary statistics"""
+    status: str
+    message: str
+    summary: Dict[str, Any] = {}
+
+class StatusResponse(BaseModel):
+    """Response model for system status"""
+    status: str
+    message: str
+    detector_status: Dict[str, Any] = {}
+    config_summary: Optional[str] = None

backend/api/routes.py

@@ -0,0 +1,528 @@
+from flask import Blueprint, request, jsonify, send_file
+from werkzeug.utils import secure_filename
+from typing import Tuple
+import os
+import uuid
+from datetime import datetime
+
+from .models import (
+    AnalyzeTextRequest, AnalysisResponse, ResultListResponse,
+    SummaryResponse, StatusResponse
+)
+from backend.detectors import DetectorEnsemble
+from backend.utils import FileParser, TextCleaner
+from backend.database import DatabaseManager, Session
+from backend.config.detectors_config import DetectorsConfig
+from backend.config.settings import settings
+from backend.utils.submission_logger import log_submission
+
+# Create blueprint
+api = Blueprint('api', __name__, url_prefix='/api')
+
+# Global detector ensemble
+_detector_ensemble = None
+
+def get_detector_ensemble():
+    """Get or initialize detector ensemble"""
+    global _detector_ensemble
+    if _detector_ensemble is None:
+        _detector_ensemble = DetectorEnsemble()
+    return _detector_ensemble
+
+# ============================================================================
+# Health & Status Endpoints
+# ============================================================================
+
+@api.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        "status": "healthy",
+        "timestamp": datetime.utcnow().isoformat()
+    }), 200
+
+@api.route('/status', methods=['GET'])
+def get_status():
+    """Get system and detector status"""
+    try:
+        ensemble = get_detector_ensemble()
+        status_info = ensemble.get_status()
+        
+        return jsonify({
+            "status": "ok",
+            "detectors": status_info,
+            "config": {
+                "database_url": settings.DATABASE_URL[:20] + "***",
+                "upload_folder": settings.UPLOAD_FOLDER,
+            }
+        }), 200
+    
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": str(e)
+        }), 500
+
+# ============================================================================
+# Analysis Endpoints
+# ============================================================================
+
+@api.route('/analyze/text', methods=['POST'])
+def analyze_text():
+    """
+    Analyze raw text for AI-generated content.
+    
+    POST /api/analyze/text
+    {
+        "text": "Your text here...",
+        "filename": "optional_name.txt"
+    }
+    """
+    try:
+        data = request.get_json()
+        
+        if not data or 'text' not in data:
+            return jsonify({
+                "status": "error",
+                "message": "Missing 'text' field in request"
+            }), 400
+        
+        text = data.get('text', '').strip()
+        filename = data.get('filename', 'untitled.txt')
+        user_id = data.get('user_id')
+        
+        # Validate text
+        if not text:
+            return jsonify({
+                "status": "error",
+                "message": "Text cannot be empty"
+            }), 400
+        
+        if len(text) < 10:
+            return jsonify({
+                "status": "error",
+                "message": "Text must be at least 10 characters"
+            }), 400
+        
+        # Clean text
+        text = TextCleaner.clean(text)
+        
+        # Get text stats
+        text_stats = TextCleaner.get_text_stats(text)
+        
+        # Run detection
+        ensemble = get_detector_ensemble()
+        ensemble_result = ensemble.detect(text)
+        
+        # Save to database
+        detector_results_dict = ensemble_result.to_dict()
+        
+        db_result = DatabaseManager.save_analysis_result(
+            filename=filename,
+            file_format="raw",
+            file_size=len(text),
+            text_length=len(text),
+            word_count=text_stats['word_count'],
+            overall_ai_score=ensemble_result.overall_score,
+            overall_confidence=ensemble_result.overall_confidence,
+            detector_results=detector_results_dict,
+            text_preview=text[:500],
+            user_id=user_id,
+        )
+        
+        if not db_result:
+            return jsonify({
+                "status": "error",
+                "message": "Failed to save analysis result"
+            }), 500
+        
+        status_label = db_result.get_status_label(ensemble_result.overall_score)
+        log_submission(
+            filename=filename,
+            overall_ai_score=ensemble_result.overall_score,
+            overall_confidence=ensemble_result.overall_confidence,
+            status_label=status_label,
+            detector_results=detector_results_dict["detector_results"],
+            text_stats=text_stats,
+            text_preview=text[:200],
+        )
+
+        return jsonify({
+            "status": "success",
+            "message": "Text analyzed successfully",
+            "result_id": db_result.id,
+            "file_id": db_result.file_id,
+            "overall_ai_score": round(ensemble_result.overall_score, 4),
+            "overall_ai_score_percentage": f"{ensemble_result.overall_score * 100:.1f}%",
+            "overall_confidence": ensemble_result.overall_confidence,
+            "status_label": status_label,
+            "detector_results": detector_results_dict["detector_results"],
+            "enabled_detectors": ensemble_result.enabled_detectors,
+            "text_stats": text_stats,
+        }), 200
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "status": "error",
+            "message": "Error during analysis",
+            "error_details": str(e)
+        }), 500
+
+@api.route('/analyze/file', methods=['POST'])
+def analyze_file():
+    """
+    Upload and analyze a file (PDF, DOCX, or TXT).
+    
+    POST /api/analyze/file
+    FormData:
+    - file: (required) File to upload
+    """
+    try:
+        # Check if file is in request
+        if 'file' not in request.files:
+            return jsonify({
+                "status": "error",
+                "message": "No file provided"
+            }), 400
+        
+        file = request.files['file']
+        user_id = request.form.get('user_id')
+        
+        if not file or not file.filename:
+            return jsonify({
+                "status": "error",
+                "message": "Invalid file"
+            }), 400
+        
+        # Validate file format
+        filename = secure_filename(file.filename)
+        file_ext = os.path.splitext(filename)[1].lower()
+        
+        if file_ext not in {'.pdf', '.docx', '.doc', '.txt'}:
+            return jsonify({
+                "status": "error",
+                "message": f"Unsupported file format: {file_ext}. Supported: PDF, DOCX, TXT"
+            }), 400
+        
+        # Save uploaded file temporarily
+        temp_filename = f"{uuid.uuid4()}{file_ext}"
+        temp_filepath = os.path.join(settings.UPLOAD_FOLDER, temp_filename)
+        file.save(temp_filepath)
+        
+        file_size = os.path.getsize(temp_filepath)
+        
+        # Validate file size
+        if file_size > settings.MAX_FILE_SIZE:
+            os.remove(temp_filepath)
+            return jsonify({
+                "status": "error",
+                "message": f"File too large. Max size: {settings.MAX_FILE_SIZE / (1024*1024):.1f}MB"
+            }), 400
+        
+        # Parse file
+        text, file_format, parse_error = FileParser.parse_file(temp_filepath)
+        
+        if parse_error:
+            os.remove(temp_filepath)
+            return jsonify({
+                "status": "error",
+                "message": f"Error parsing file: {str(parse_error)}"
+            }), 400
+        
+        # Validate extracted text
+        if not text or len(text) < 10:
+            os.remove(temp_filepath)
+            return jsonify({
+                "status": "error",
+                "message": "Could not extract sufficient text from file"
+            }), 400
+        
+        # Clean text
+        text = TextCleaner.clean(text)
+        text_stats = TextCleaner.get_text_stats(text)
+        
+        # Run detection
+        ensemble = get_detector_ensemble()
+        ensemble_result = ensemble.detect(text)
+        
+        # Save to database
+        detector_results_dict = ensemble_result.to_dict()
+        
+        db_result = DatabaseManager.save_analysis_result(
+            filename=filename,
+            file_format=file_format,
+            file_size=file_size,
+            text_length=len(text),
+            word_count=text_stats['word_count'],
+            overall_ai_score=ensemble_result.overall_score,
+            overall_confidence=ensemble_result.overall_confidence,
+            detector_results=detector_results_dict,
+            text_preview=text[:500],
+            user_id=user_id,
+        )
+        
+        # Clean up temp file
+        os.remove(temp_filepath)
+        
+        if not db_result:
+            return jsonify({
+                "status": "error",
+                "message": "Failed to save analysis result"
+            }), 500
+        
+        status_label = db_result.get_status_label(ensemble_result.overall_score)
+        log_submission(
+            filename=filename,
+            overall_ai_score=ensemble_result.overall_score,
+            overall_confidence=ensemble_result.overall_confidence,
+            status_label=status_label,
+            detector_results=detector_results_dict["detector_results"],
+            text_stats=text_stats,
+            text_preview=text[:200],
+        )
+
+        return jsonify({
+            "status": "success",
+            "message": "File analyzed successfully",
+            "result_id": db_result.id,
+            "file_id": db_result.file_id,
+            "filename": filename,
+            "overall_ai_score": round(ensemble_result.overall_score, 4),
+            "overall_ai_score_percentage": f"{ensemble_result.overall_score * 100:.1f}%",
+            "overall_confidence": ensemble_result.overall_confidence,
+            "status_label": status_label,
+            "detector_results": detector_results_dict["detector_results"],
+            "enabled_detectors": ensemble_result.enabled_detectors,
+            "text_stats": text_stats,
+        }), 200
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "status": "error",
+            "message": "Error analyzing file",
+            "error_details": str(e)
+        }), 500
+
+# ============================================================================
+# Results Endpoints
+# ============================================================================
+
+@api.route('/results', methods=['GET'])
+def list_results():
+    """
+    Get list of all analysis results with pagination.
+    
+    GET /api/results?page=1&limit=10&sort=recent
+    """
+    try:
+        page = request.args.get('page', 1, type=int)
+        limit = request.args.get('limit', 10, type=int)
+        sort = request.args.get('sort', 'recent')
+        
+        # Validate pagination
+        if page < 1:
+            page = 1
+        if limit < 1 or limit > 100:
+            limit = 10
+        
+        # Map sort parameter
+        order_by = "upload_timestamp_desc" if sort == "recent" else "score_desc"
+        
+        # Calculate offset
+        offset = (page - 1) * limit
+        
+        # Get results
+        results = DatabaseManager.get_all_results(
+            limit=limit,
+            offset=offset,
+            order_by=order_by
+        )
+        
+        # Get total count
+        session = Session.get_session()
+        total_count = session.query(DatabaseManager).count() if hasattr(DatabaseManager, '__table__') else 0
+        from backend.database import AnalysisResult
+        total_count = session.query(AnalysisResult).count()
+        session.close()
+        
+        result_dicts = [result.to_dict() for result in results]
+        
+        return jsonify({
+            "status": "success",
+            "message": "Results retrieved",
+            "page": page,
+            "limit": limit,
+            "total_count": total_count,
+            "results": result_dicts
+        }), 200
+    
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            "status": "error",
+            "message": "Error retrieving results",
+            "error_details": str(e)
+        }), 500
+
+@api.route('/results/<int:result_id>', methods=['GET'])
+def get_result(result_id):
+    """Get a specific analysis result"""
+    try:
+        result = DatabaseManager.get_result_by_id(result_id)
+        
+        if not result:
+            return jsonify({
+                "status": "error",
+                "message": "Result not found"
+            }), 404
+        
+        return jsonify({
+            "status": "success",
+            "message": "Result retrieved",
+            "result": result.to_dict()
+        }), 200
+    
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": "Error retrieving result",
+            "error_details": str(e)
+        }), 500
+
+@api.route('/results/<int:result_id>', methods=['DELETE'])
+def delete_result(result_id):
+    """Delete an analysis result"""
+    try:
+        success = DatabaseManager.delete_result(result_id)
+        
+        if not success:
+            return jsonify({
+                "status": "error",
+                "message": "Result not found"
+            }), 404
+        
+        return jsonify({
+            "status": "success",
+            "message": "Result deleted"
+        }), 200
+    
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": "Error deleting result",
+            "error_details": str(e)
+        }), 500
+
+@api.route('/results/<int:result_id>', methods=['PUT'])
+def update_result(result_id):
+    """Update analysis result (notes, flags)"""
+    try:
+        data = request.get_json()
+        
+        updates = {}
+        if 'notes' in data:
+            updates['notes'] = data['notes']
+        if 'is_flagged' in data:
+            updates['is_flagged'] = data['is_flagged']
+        
+        if not updates:
+            return jsonify({
+                "status": "error",
+                "message": "No fields to update"
+            }), 400
+        
+        result = DatabaseManager.update_result(result_id, **updates)
+        
+        if not result:
+            return jsonify({
+                "status": "error",
+                "message": "Result not found"
+            }), 404
+        
+        return jsonify({
+            "status": "success",
+            "message": "Result updated",
+            "result": result.to_dict()
+        }), 200
+    
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": "Error updating result",
+            "error_details": str(e)
+        }), 500
+
+# ============================================================================
+# Statistics Endpoints
+# ============================================================================
+
+@api.route('/statistics/summary', methods=['GET'])
+def get_summary():
+    """Get summary statistics"""
+    try:
+        summary = DatabaseManager.get_results_summary()
+        
+        return jsonify({
+            "status": "success",
+            "message": "Summary retrieved",
+            "summary": summary
+        }), 200
+    
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": "Error getting summary",
+            "error_details": str(e)
+        }), 500
+
+@api.route('/config', methods=['GET'])
+def get_config():
+    """Get detector configuration"""
+    try:
+        config = {
+            "enabled_detectors": DetectorsConfig.get_enabled_detectors(),
+            "aggregation_method": DetectorsConfig.AGGREGATION_METHOD,
+            "detector_weights": DetectorsConfig.DETECTOR_WEIGHTS,
+            "detector_info": {
+                "roberta": {
+                    "name": "RoBERTa Detector",
+                    "description": "Fine-tuned RoBERTa model for AI text detection",
+                    "model": DetectorsConfig.ROBERTA_MODEL,
+                },
+                "perplexity": {
+                    "name": "Perplexity-based Detector",
+                    "description": "Detects AI patterns through perplexity and repetition analysis",
+                    "model": DetectorsConfig.PERPLEXITY_MODEL,
+                },
+                "llmdet": {
+                    "name": "LLMDet Detector",
+                    "description": "Combines entropy and classification metrics",
+                },
+                "hf_classifier": {
+                    "name": "HuggingFace Classifier",
+                    "description": "Generic HF-based sequence classification",
+                    "model": DetectorsConfig.HF_CLASSIFIER_MODEL,
+                },
+                "outfox": {
+                    "name": "OUTFOX Statistical Detector",
+                    "description": "Statistical signature-based detection",
+                },
+            }
+        }
+        
+        return jsonify({
+            "status": "success",
+            "config": config
+        }), 200
+    
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": "Error getting config",
+            "error_details": str(e)
+        }), 500

backend/config/__init__.py

@@ -0,0 +1,4 @@
+from .settings import Settings
+from .detectors_config import DetectorsConfig
+
+__all__ = ["Settings", "DetectorsConfig"]

backend/config/detectors_config.py

@@ -0,0 +1,115 @@
+"""
+Detector Configuration - Enable/Disable detectors easily here
+Toggle any detector by changing True/False
+"""
+import os
+from typing import Dict
+
+class DetectorsConfig:
+    """Configuration for AI detection methods"""
+    
+    # ===========================================
+    # FEATURE FLAGS - Toggle detectors here
+    # ===========================================
+    # Set to True to enable, False to disable
+    # Use environment variables to override: ENABLE_<DETECTOR_NAME>=true/false
+    
+    ENABLED_DETECTORS: Dict[str, bool] = {
+        # RoBERTa-based detector (fine-tuned on OpenAI detector dataset)
+        "roberta": os.getenv("ENABLE_ROBERTA", "False").lower() == "true",
+        
+        # Perplexity-based baseline (detects repetitive patterns)
+        "perplexity": os.getenv("ENABLE_PERPLEXITY", "False").lower() == "true",
+        
+        # LLMDet - Detectron perplexity + classifier
+        "llmdet": os.getenv("ENABLE_LLMDET", "False").lower() == "true",
+        
+        # Simple HuggingFace classifier for AI detection
+        "hf_classifier": os.getenv("ENABLE_HF_CLASSIFIER", "False").lower() == "true",
+        
+        # OUTFOX method (statistical signature detection)
+        "outfox": os.getenv("ENABLE_OUTFOX", "False").lower() == "true",
+
+        # TMR AI text detector
+        "tmr_detector": os.getenv("ENABLE_TMR_DETECTOR", "True").lower() == "true",
+
+        # Pattern heuristics (em-dash index + emoji index)
+        "pattern": os.getenv("ENABLE_PATTERN", "True").lower() == "true",
+    }
+    
+    # ===========================================
+    # Detector weights for ensemble averaging
+    # ===========================================
+    DETECTOR_WEIGHTS: Dict[str, float] = {
+        "roberta": 0.30,
+        "perplexity": 0.25,
+        "llmdet": 0.25,
+        "hf_classifier": 0.20,
+        "outfox": 0.00,  # Not in use by default
+        "tmr_detector": 0.80,
+        "pattern": 0.20,
+    }
+    
+    # ===========================================
+    # Detector-specific settings
+    # ===========================================
+    
+    # RoBERTa detector settings
+    ROBERTA_MODEL = "roberta-base-openai-detector"
+    ROBERTA_THRESHOLD = 0.5
+    ROBERTA_BATCH_SIZE = 16
+    
+    # Perplexity settings
+    PERPLEXITY_MODEL = "gpt2"
+    PERPLEXITY_THRESHOLD = 50  # Words with higher perplexity are suspicious
+    PERPLEXITY_WINDOW_SIZE = 5  # tokens to consider
+    
+    # LLMDet settings
+    LLMDET_THRESHOLD = 0.5
+    LLMDET_BATCH_SIZE = 32
+    
+    # HF Classifier settings
+    HF_CLASSIFIER_MODEL = "cardiffnlp/twitter-roberta-base-sentiment-latest"  # Valid classification model
+    HF_CLASSIFIER_THRESHOLD = 0.5
+    
+    # OUTFOX settings
+    OUTFOX_THRESHOLD = 0.5
+    
+    # General
+    MIN_TEXT_LENGTH = 50  # Minimum characters to analyze
+    AGGREGATION_METHOD = "weighted_average"  # Options: weighted_average, max, voting
+    
+    @classmethod
+    def get_enabled_detectors(cls) -> Dict[str, bool]:
+        """Return dict of enabled detectors"""
+        return cls.ENABLED_DETECTORS.copy()
+    
+    @classmethod
+    def is_detector_enabled(cls, detector_name: str) -> bool:
+        """Check if a specific detector is enabled"""
+        return cls.ENABLED_DETECTORS.get(detector_name.lower(), False)
+    
+    @classmethod
+    def get_weight(cls, detector_name: str) -> float:
+        """Get weight for a detector"""
+        return cls.DETECTOR_WEIGHTS.get(detector_name.lower(), 0.0)
+    
+    @classmethod
+    def normalize_weights(cls) -> Dict[str, float]:
+        """Normalize weights for enabled detectors only"""
+        enabled_weights = {
+            d: w for d, w in cls.DETECTOR_WEIGHTS.items()
+            if cls.is_detector_enabled(d)
+        }
+        total = sum(enabled_weights.values())
+        if total == 0:
+            return {}
+        return {d: w/total for d, w in enabled_weights.items()}
+    
+    @classmethod
+    def summary(cls) -> str:
+        """Print configuration summary"""
+        enabled = [d for d, enabled in cls.ENABLED_DETECTORS.items() if enabled]
+        return f"Enabled Detectors: {', '.join(enabled)}"
+
+detectors_config = DetectorsConfig()

backend/config/settings.py

@@ -0,0 +1,32 @@
+import os
+from pathlib import Path
+
+class Settings:
+    """Application Settings"""
+    
+    BASE_DIR = Path(__file__).parent.parent
+    DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///slop_detect.db")
+    UPLOAD_FOLDER = os.getenv("UPLOAD_FOLDER", str(BASE_DIR / "uploads"))
+    RESULTS_FOLDER = os.getenv("RESULTS_FOLDER", str(BASE_DIR / "results"))
+    
+    # Flask settings
+    DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+    HOST = os.getenv("HOST", "0.0.0.0")
+    PORT = int(os.getenv("PORT", 5000))
+    
+    # Model cache
+    MODEL_CACHE_DIR = os.getenv("MODEL_CACHE_DIR", str(BASE_DIR / ".model_cache"))
+    
+    # Max file size (50MB)
+    MAX_FILE_SIZE = 50 * 1024 * 1024
+    
+    # Batch processing
+    BATCH_SIZE = 32
+    
+    def __init__(self):
+        # Create upload and results folders
+        os.makedirs(self.UPLOAD_FOLDER, exist_ok=True)
+        os.makedirs(self.RESULTS_FOLDER, exist_ok=True)
+        os.makedirs(self.MODEL_CACHE_DIR, exist_ok=True)
+
+settings = Settings()

backend/database/__init__.py

@@ -0,0 +1,4 @@
+from .models import AnalysisResult, Session, Base
+from .db import DatabaseManager
+
+__all__ = ["AnalysisResult", "Session", "Base", "DatabaseManager"]

backend/database/db.py

@@ -0,0 +1,241 @@
+import uuid
+from datetime import datetime
+from typing import Optional, List
+from .models import AnalysisResult, Session
+import json
+
+class DatabaseManager:
+    """Manager for database operations"""
+    
+    @staticmethod
+    def save_analysis_result(
+        filename: str,
+        file_format: str,
+        file_size: int,
+        text_length: int,
+        word_count: int,
+        overall_ai_score: float,
+        overall_confidence: str,
+        detector_results: dict,
+        text_preview: str = "",
+        user_id: Optional[str] = None,
+        analysis_status: str = "completed",
+        error_message: Optional[str] = None,
+        report_html_path: Optional[str] = None
+    ) -> Optional[AnalysisResult]:
+        """
+        Save an analysis result to the database.
+        
+        Returns:
+            AnalysisResult object or None if save failed
+        """
+        try:
+            session = Session.get_session()
+            
+            # Generate unique file ID
+            file_id = str(uuid.uuid4())
+            
+            result = AnalysisResult(
+                file_id=file_id,
+                filename=filename,
+                file_format=file_format,
+                file_size=file_size,
+                text_length=text_length,
+                word_count=word_count,
+                overall_ai_score=overall_ai_score,
+                overall_confidence=overall_confidence,
+                detector_results=detector_results,
+                text_preview=text_preview[:500],
+                user_id=user_id,
+                analysis_status=analysis_status,
+                error_message=error_message,
+                report_html_path=report_html_path,
+                upload_timestamp=datetime.utcnow()
+            )
+            
+            session.add(result)
+            session.commit()
+            
+            # Refresh to get ID
+            session.refresh(result)
+            return result
+        
+        except Exception as e:
+            print(f"Error saving analysis result: {e}")
+            return None
+        
+        finally:
+            session.close()
+    
+    @staticmethod
+    def get_result_by_id(result_id: int) -> Optional[AnalysisResult]:
+        """Get analysis result by ID"""
+        try:
+            session = Session.get_session()
+            result = session.query(AnalysisResult).filter(
+                AnalysisResult.id == result_id
+            ).first()
+            return result
+        except Exception as e:
+            print(f"Error retrieving result: {e}")
+            return None
+        finally:
+            session.close()
+    
+    @staticmethod
+    def get_result_by_file_id(file_id: str) -> Optional[AnalysisResult]:
+        """Get analysis result by file ID"""
+        try:
+            session = Session.get_session()
+            result = session.query(AnalysisResult).filter(
+                AnalysisResult.file_id == file_id
+            ).first()
+            return result
+        except Exception as e:
+            print(f"Error retrieving result: {e}")
+            return None
+        finally:
+            session.close()
+    
+    @staticmethod
+    def get_all_results(
+        limit: int = 100,
+        offset: int = 0,
+        order_by: str = "upload_timestamp_desc"
+    ) -> List[AnalysisResult]:
+        """
+        Get all analysis results with pagination.
+        
+        Args:
+            limit: Number of results to return
+            offset: Number of results to skip
+            order_by: Sort order (upload_timestamp_desc, upload_timestamp_asc, score_desc, score_asc)
+            
+        Returns:
+            List of AnalysisResult objects
+        """
+        try:
+            session = Session.get_session()
+            query = session.query(AnalysisResult)
+            
+            # Apply ordering
+            if order_by == "upload_timestamp_desc":
+                query = query.order_by(AnalysisResult.upload_timestamp.desc())
+            elif order_by == "upload_timestamp_asc":
+                query = query.order_by(AnalysisResult.upload_timestamp.asc())
+            elif order_by == "score_desc":
+                query = query.order_by(AnalysisResult.overall_ai_score.desc())
+            elif order_by == "score_asc":
+                query = query.order_by(AnalysisResult.overall_ai_score.asc())
+            
+            results = query.limit(limit).offset(offset).all()
+            return results
+        
+        except Exception as e:
+            print(f"Error retrieving results: {e}")
+            return []
+        
+        finally:
+            session.close()
+    
+    @staticmethod
+    def get_results_summary() -> dict:
+        """Get summary statistics of all results"""
+        try:
+            session = Session.get_session()
+            
+            total = session.query(AnalysisResult).count()
+            
+            if total == 0:
+                return {
+                    "total_analyses": 0,
+                    "average_ai_score": 0,
+                    "total_text_analyzed": 0,
+                    "likely_human": 0,
+                    "suspicious": 0,
+                    "likely_ai": 0,
+                }
+            
+            from sqlalchemy import func
+            
+            # Calculate averages
+            avg_score = session.query(func.avg(AnalysisResult.overall_ai_score)).scalar() or 0
+            total_text = session.query(func.sum(AnalysisResult.text_length)).scalar() or 0
+            
+            # Count by confidence
+            likely_human = session.query(AnalysisResult).filter(
+                AnalysisResult.overall_ai_score < 0.3
+            ).count()
+            
+            suspicious = session.query(AnalysisResult).filter(
+                (AnalysisResult.overall_ai_score >= 0.3) &
+                (AnalysisResult.overall_ai_score < 0.7)
+            ).count()
+            
+            likely_ai = session.query(AnalysisResult).filter(
+                AnalysisResult.overall_ai_score >= 0.7
+            ).count()
+            
+            return {
+                "total_analyses": total,
+                "average_ai_score": round(avg_score, 3),
+                "total_text_analyzed": total_text,
+                "likely_human": likely_human,
+                "suspicious": suspicious,
+                "likely_ai": likely_ai,
+            }
+        
+        except Exception as e:
+            print(f"Error getting summary: {e}")
+            return {}
+        
+        finally:
+            session.close()
+    
+    @staticmethod
+    def delete_result(result_id: int) -> bool:
+        """Delete an analysis result"""
+        try:
+            session = Session.get_session()
+            result = session.query(AnalysisResult).filter(
+                AnalysisResult.id == result_id
+            ).first()
+            
+            if result:
+                session.delete(result)
+                session.commit()
+                return True
+            return False
+        
+        except Exception as e:
+            print(f"Error deleting result: {e}")
+            return False
+        
+        finally:
+            session.close()
+    
+    @staticmethod
+    def update_result(result_id: int, **kwargs) -> Optional[AnalysisResult]:
+        """Update an analysis result"""
+        try:
+            session = Session.get_session()
+            result = session.query(AnalysisResult).filter(
+                AnalysisResult.id == result_id
+            ).first()
+            
+            if result:
+                for key, value in kwargs.items():
+                    if hasattr(result, key):
+                        setattr(result, key, value)
+                
+                session.commit()
+                session.refresh(result)
+            
+            return result
+        
+        except Exception as e:
+            print(f"Error updating result: {e}")
+            return None
+        
+        finally:
+            session.close()

backend/database/models.py

@@ -0,0 +1,114 @@
+from sqlalchemy import create_engine, Column, String, Float, DateTime, Integer, JSON, Text, Boolean
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+import json
+import os
+
+Base = declarative_base()
+
+class AnalysisResult(Base):
+    """Database model for storing analysis results"""
+    
+    __tablename__ = "analysis_results"
+    
+    id = Column(Integer, primary_key=True)
+    
+    # File information
+    file_id = Column(String(50), unique=True, nullable=False, index=True)
+    filename = Column(String(255), nullable=False)
+    file_format = Column(String(10), nullable=False)  # pdf, docx, txt, raw
+    file_size = Column(Integer, nullable=True)  # in bytes
+    
+    # Upload information
+    upload_timestamp = Column(DateTime, nullable=False, default=datetime.utcnow, index=True)
+    user_id = Column(String(100), nullable=True)  # For future auth integration
+    
+    # Text analysis
+    text_preview = Column(String(500), nullable=True)  # First 500 chars
+    text_length = Column(Integer, nullable=False)  # Total character count
+    word_count = Column(Integer, nullable=False)
+    
+    # Overall detection results
+    overall_ai_score = Column(Float, nullable=False)  # 0-1
+    overall_confidence = Column(String(20), nullable=False)  # very_low, low, medium, high, very_high
+    
+    # Detector results (JSON)
+    detector_results = Column(JSON, nullable=False)  # Full detector results
+    
+    # Status
+    analysis_status = Column(String(20), default="completed")  # completed, failed, pending
+    error_message = Column(Text, nullable=True)
+    
+    # Report storage
+    report_html_path = Column(String(500), nullable=True)
+    
+    # Metadata
+    notes = Column(Text, nullable=True)
+    is_flagged = Column(Boolean, default=False)  # For manual flagging
+    
+    def to_dict(self):
+        """Convert to dictionary"""
+        return {
+            "id": self.id,
+            "file_id": self.file_id,
+            "filename": self.filename,
+            "file_format": self.file_format,
+            "file_size": self.file_size,
+            "upload_timestamp": self.upload_timestamp.isoformat() if self.upload_timestamp else None,
+            "text_length": self.text_length,
+            "word_count": self.word_count,
+            "overall_ai_score": self.overall_ai_score,
+            "overall_ai_score_percentage": f"{self.overall_ai_score * 100:.1f}%",
+            "overall_confidence": self.overall_confidence,
+            "detector_results": self.detector_results,
+            "analysis_status": self.analysis_status,
+            "error_message": self.error_message,
+            "is_flagged": self.is_flagged,
+            "notes": self.notes,
+        }
+    
+    @staticmethod
+    def get_status_label(score: float) -> str:
+        """Get human-readable status based on AI score"""
+        if score < 0.3:
+            return "Likely Human"
+        elif score < 0.6:
+            return "Suspicious"
+        else:
+            return "Likely AI"
+
+class Session:
+    """Database session manager"""
+    
+    _engine = None
+    _SessionLocal = None
+    
+    @classmethod
+    def init(cls):
+        """Initialize database connection"""
+        # Get DATABASE_URL from environment or use SQLite default
+        database_url = os.getenv('DATABASE_URL', 'sqlite:///./analysis_results.db')
+        
+        cls._engine = create_engine(
+            database_url,
+            connect_args={"check_same_thread": False} if "sqlite" in database_url else {}
+        )
+        
+        # Create tables
+        Base.metadata.create_all(cls._engine)
+        
+        cls._SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=cls._engine)
+    
+    @classmethod
+    def get_session(cls):
+        """Get a new database session"""
+        if cls._SessionLocal is None:
+            cls.init()
+        return cls._SessionLocal()
+    
+    @classmethod
+    def close(cls):
+        """Close database connection"""
+        if cls._engine:
+            cls._engine.dispose()

backend/detectors/__init__.py

@@ -0,0 +1,13 @@
+from .base import BaseDetector, DetectorResult, SuspiciousSpan, DetectionConfidence
+from .tmr_detector import TMRDetector
+from .ensemble import DetectorEnsemble, EnsembleResult
+
+__all__ = [
+    "BaseDetector",
+    "DetectorResult",
+    "SuspiciousSpan",
+    "DetectionConfidence",
+    "TMRDetector",
+    "DetectorEnsemble",
+    "EnsembleResult",
+]

backend/detectors/base.py

@@ -0,0 +1,111 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field, asdict
+from typing import Optional, List, Dict, Any
+from enum import Enum
+
+class DetectionConfidence(Enum):
+    """Confidence levels for detection"""
+    VERY_LOW = "very_low"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    VERY_HIGH = "very_high"
+
+@dataclass
+class SuspiciousSpan:
+    """Represents a suspicious text span"""
+    text: str
+    start: int
+    end: int
+    reason: str
+    confidence: float
+
+@dataclass
+class DetectorResult:
+    """Result from a single detector"""
+    detector_name: str
+    score: float  # 0-1 or 0-100 (standardized to 0-1 later)
+    confidence: Optional[str] = None
+    explanation: Optional[str] = None
+    suspicious_spans: List[SuspiciousSpan] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary"""
+        return {
+            "detector_name": self.detector_name,
+            "score": self.score,
+            "confidence": self.confidence,
+            "explanation": self.explanation,
+            "suspicious_spans": [
+                {
+                    "text": span.text,
+                    "start": span.start,
+                    "end": span.end,
+                    "reason": span.reason,
+                    "confidence": span.confidence,
+                }
+                for span in self.suspicious_spans
+            ],
+            "metadata": self.metadata,
+        }
+
+    def normalize_score(self) -> float:
+        """Ensure score is 0-1"""
+        if self.score > 1:
+            # Assume 0-100 scale
+            return self.score / 100.0
+        return self.score
+
+class BaseDetector(ABC):
+    """Base class for all AI detection methods"""
+    
+    def __init__(self, name: str, model_name: Optional[str] = None):
+        self.name = name
+        self.model_name = model_name
+        self.model = None
+        self.tokenizer = None
+        self._is_loaded = False
+    
+    @abstractmethod
+    def detect(self, text: str) -> DetectorResult:
+        """
+        Detect if text is AI-generated
+        
+        Args:
+            text: Input text to analyze
+            
+        Returns:
+            DetectorResult with score, explanation, and optional flagged spans
+        """
+        pass
+    
+    def load_model(self):
+        """Load model resources (override in subclasses)"""
+        self._is_loaded = True
+    
+    def is_loaded(self) -> bool:
+        """Check if model is loaded"""
+        return self._is_loaded
+    
+    def cleanup(self):
+        """Clean up resources"""
+        if self.model:
+            del self.model
+        if self.tokenizer:
+            del self.tokenizer
+        self._is_loaded = False
+    
+    @staticmethod
+    def get_confidence_level(score: float) -> str:
+        """Convert numeric score to confidence level"""
+        if score < 0.2:
+            return DetectionConfidence.VERY_LOW.value
+        elif score < 0.4:
+            return DetectionConfidence.LOW.value
+        elif score < 0.6:
+            return DetectionConfidence.MEDIUM.value
+        elif score < 0.8:
+            return DetectionConfidence.HIGH.value
+        else:
+            return DetectionConfidence.VERY_HIGH.value

backend/detectors/ensemble.py

@@ -0,0 +1,205 @@
+from typing import Dict, List, Optional, Tuple
+import numpy as np
+import math
+from dataclasses import dataclass
+from .base import DetectorResult, BaseDetector
+from .tmr_detector import TMRDetector
+from .pattern_detector import PatternDetector
+from backend.config.detectors_config import DetectorsConfig
+
+@dataclass
+class EnsembleResult:
+    """Result from ensemble of detectors"""
+    overall_score: float  # 0-1
+    overall_confidence: str
+    detector_results: Dict[str, DetectorResult]
+    weighted_scores: Dict[str, float]
+    enabled_detectors: List[str]
+    
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for JSON serialization"""
+        return {
+            "overall_score": round(self.overall_score, 4),
+            "overall_confidence": self.overall_confidence,
+            "overall_score_percentage": f"{self.overall_score * 100:.1f}%",
+            "enabled_detectors": self.enabled_detectors,
+            "detector_results": {
+                name: result.to_dict()
+                for name, result in self.detector_results.items()
+            },
+            "weighted_scores": {
+                name: round(score, 4)
+                for name, score in self.weighted_scores.items()
+            }
+        }
+
+class DetectorEnsemble:
+    """
+    Manages multiple AI detectors and combines their results.
+    Easily enable/disable detectors via config.
+    """
+    
+    def __init__(self):
+        self.detectors: Dict[str, any] = {}
+        self.loaded_detectors: set = set()
+        self._initialize_detectors()
+    
+    def _initialize_detectors(self):
+        """Initialize all available detectors"""
+        detector_classes = {
+            "tmr_detector": TMRDetector,
+            "pattern": PatternDetector,
+        }
+        
+        for name, detector_class in detector_classes.items():
+            try:
+                self.detectors[name] = detector_class()
+            except Exception as e:
+                print(f"Warning: Could not initialize {name} detector: {e}")
+    
+    def load_detector(self, detector_name: str) -> bool:
+        """
+        Lazy load a detector when needed.
+        Returns True if successful, False otherwise.
+        """
+        if detector_name in self.loaded_detectors:
+            return True
+        
+        if detector_name not in self.detectors:
+            return False
+        
+        try:
+            self.detectors[detector_name].load_model()
+            self.loaded_detectors.add(detector_name)
+            return True
+        except Exception as e:
+            print(f"Error loading detector {detector_name}: {e}")
+            return False
+    
+    def get_enabled_detectors(self) -> List[str]:
+        """Get list of enabled detectors"""
+        return [
+            name for name in self.detectors.keys()
+            if DetectorsConfig.is_detector_enabled(name)
+        ]
+    
+    def detect(self, text: str) -> EnsembleResult:
+        """
+        Run all enabled detectors and combine results.
+        
+        Args:
+            text: Input text to analyze
+            
+        Returns:
+            EnsembleResult with combined scores and per-detector results
+        """
+        enabled_detectors = self.get_enabled_detectors()
+        
+        if not enabled_detectors:
+            raise ValueError("No detectors are enabled!")
+        
+        results: Dict[str, DetectorResult] = {}
+        weighted_scores: Dict[str, float] = {}
+        
+        # Run each enabled detector
+        for detector_name in enabled_detectors:
+            # Skip if detector not initialized
+            if detector_name not in self.detectors:
+                continue
+            
+            # Load detector if not already loaded
+            if not self.load_detector(detector_name):
+                print(f"Warning: Could not load detector {detector_name}")
+                continue
+            
+            try:
+                result = self.detectors[detector_name].detect(text)
+                results[detector_name] = result
+                
+                # Normalize score to 0-1
+                normalized_score = result.normalize_score()
+                
+                # Handle NaN scores
+                if math.isnan(normalized_score):
+                    normalized_score = 0.5
+                
+                # Apply weight
+                weight = DetectorsConfig.get_weight(detector_name)
+                weighted_scores[detector_name] = normalized_score * weight
+                
+            except Exception as e:
+                print(f"Error running detector {detector_name}: {e}")
+        
+        # Calculate overall score using selected aggregation method
+        overall_score = self._aggregate_scores(results, weighted_scores, enabled_detectors)
+        
+        # Determine confidence level
+        confidence = BaseDetector.get_confidence_level(overall_score)
+        
+        return EnsembleResult(
+            overall_score=overall_score,
+            overall_confidence=confidence,
+            detector_results=results,
+            weighted_scores=weighted_scores,
+            enabled_detectors=enabled_detectors
+        )
+    
+    def _aggregate_scores(
+        self,
+        results: Dict[str, DetectorResult],
+        weighted_scores: Dict[str, float],
+        enabled_detectors: List[str]
+    ) -> float:
+        """
+        Aggregate detector scores based on configured method.
+        
+        Args:
+            results: DetectorResult objects from each detector
+            weighted_scores: Pre-calculated weighted scores
+            enabled_detectors: List of enabled detector names
+            
+        Returns:
+            Overall AI detection score (0-1)
+        """
+        method = DetectorsConfig.AGGREGATION_METHOD
+        
+        if method == "weighted_average":
+            # Use weighted average (sum of weighted scores)
+            total = sum(weighted_scores.values())
+            return total if not math.isnan(total) else 0.5
+        
+        elif method == "max":
+            # Use maximum score (most confident detector)
+            scores = [result.normalize_score() for result in results.values()]
+            max_score = max(scores) if scores else 0.5
+            return max_score if not math.isnan(max_score) else 0.5
+        
+        elif method == "voting":
+            # Simple voting: count how many detectors say AI
+            threshold = 0.5
+            votes = sum(
+                1 for result in results.values()
+                if result.normalize_score() > threshold
+            )
+            return min(1.0, votes / len(results)) if results else 0.5
+        
+        else:
+            # Default: weighted average
+            return sum(weighted_scores.values())
+    
+    def cleanup(self):
+        """Clean up all detector resources"""
+        for detector in self.detectors.values():
+            try:
+                detector.cleanup()
+            except:
+                pass
+    
+    def get_status(self) -> Dict[str, any]:
+        """Get status of all detectors"""
+        return {
+            "total_detectors": len(self.detectors),
+            "enabled_detectors": self.get_enabled_detectors(),
+            "loaded_detectors": list(self.loaded_detectors),
+            "config_summary": DetectorsConfig.summary()
+        }

backend/detectors/pattern_detector.py

@@ -0,0 +1,92 @@
+from .base import BaseDetector, DetectorResult
+
+# Thresholds at which the index reaches a score of 1.0
+_EM_DASH_RATE_MAX = 0.03   # 3 em-dashes per 100 words → fully "AI"
+_EMOJI_RATE_MAX   = 0.05   # 5 emojis per 100 words → fully "AI"
+
+# Weight split between the two signals
+_EM_DASH_WEIGHT = 0.70
+_EMOJI_WEIGHT   = 0.30
+
+
+class PatternDetector(BaseDetector):
+    """
+    Heuristic detector based on stylometric patterns known to be
+    over-represented in AI-generated text:
+
+      - EM Dash Index  : em-dashes (—) per word
+      - Emoji Index    : emojis per word
+
+    No model download required — loads instantly.
+    """
+
+    def __init__(self):
+        super().__init__(name="pattern", model_name=None)
+
+    def load_model(self):
+        self._is_loaded = True
+
+    def detect(self, text: str) -> DetectorResult:
+        if not self._is_loaded:
+            self.load_model()
+
+        words = text.split()
+        word_count = max(len(words), 1)
+
+        em_dash_count = text.count('\u2014')
+        # Reuse the same emoji regex logic inline to avoid circular imports
+        import re
+        _EMOJI_RE = re.compile(
+            "[\U0001F600-\U0001F64F"
+            "\U0001F300-\U0001F5FF"
+            "\U0001F680-\U0001F6FF"
+            "\U0001F1E0-\U0001F1FF"
+            "\U0001F900-\U0001F9FF"
+            "\U0001FA00-\U0001FA6F"
+            "\U0001FA70-\U0001FAFF"
+            "]+",
+            flags=re.UNICODE,
+        )
+        emoji_count = sum(len(m) for m in _EMOJI_RE.findall(text))
+
+        em_dash_rate  = em_dash_count / word_count
+        emoji_rate    = emoji_count   / word_count
+
+        em_dash_index = min(1.0, em_dash_rate / _EM_DASH_RATE_MAX)
+        emoji_index   = min(1.0, emoji_rate   / _EMOJI_RATE_MAX)
+
+        combined_score = (_EM_DASH_WEIGHT * em_dash_index
+                          + _EMOJI_WEIGHT  * emoji_index)
+
+        confidence  = self.get_confidence_level(combined_score)
+        em_dash_pct = f"{em_dash_rate * 100:.2f}%"
+        emoji_pct   = f"{emoji_rate   * 100:.2f}%"
+
+        explanation = (
+            f"Pattern signals — "
+            f"EM Dash index: {em_dash_index:.2f} ({em_dash_count} dashes, {em_dash_pct} of words); "
+            f"Emoji index: {emoji_index:.2f} ({emoji_count} emojis, {emoji_pct} of words)"
+        )
+
+        return DetectorResult(
+            detector_name=self.name,
+            score=combined_score,
+            confidence=confidence,
+            explanation=explanation,
+            metadata={
+                "model": "Heuristic (no ML)",
+                "prediction": "AI-generated" if combined_score >= 0.5 else "Human-written",
+                "ai_probability": combined_score,
+                "human_probability": 1.0 - combined_score,
+                "em_dash_count": em_dash_count,
+                "em_dash_rate": round(em_dash_rate, 4),
+                "em_dash_index": round(em_dash_index, 4),
+                "emoji_count": emoji_count,
+                "emoji_rate": round(emoji_rate, 4),
+                "emoji_index": round(emoji_index, 4),
+                "word_count": word_count,
+            },
+        )
+
+    def cleanup(self):
+        self._is_loaded = False

backend/detectors/tmr_detector.py

@@ -0,0 +1,106 @@
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+from .base import BaseDetector, DetectorResult
+from backend.config.detectors_config import DetectorsConfig
+
+class TMRDetector(BaseDetector):
+    """
+    Text detector using Oxidane/tmr-ai-text-detector model.
+    A fine-tuned model for detecting AI-generated text.
+    """
+
+    def __init__(self):
+        super().__init__(
+            name="tmr_detector",
+            model_name="Oxidane/tmr-ai-text-detector"
+        )
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    def load_model(self):
+        """Load the TMR model and tokenizer"""
+        if self._is_loaded:
+            return
+
+        try:
+            print(f"Loading tokenizer from: {self.model_name}")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+
+            print(f"Loading model from: {self.model_name}")
+            self.model = AutoModelForSequenceClassification.from_pretrained(self.model_name)
+            self.model.to(self.device)
+            self.model.eval()
+            self._is_loaded = True
+            print("TMR model and tokenizer loaded successfully.")
+        except Exception as e:
+            print(f"Error loading TMR model or tokenizer: {e}")
+            raise
+
+    def detect(self, text: str) -> DetectorResult:
+        """
+        Detect if text is AI-generated using TMR model.
+
+        Args:
+            text: Input text to analyze
+
+        Returns:
+            DetectorResult with AI detection score
+        """
+        if not self._is_loaded:
+            self.load_model()
+
+        if len(text) < 10:
+            return DetectorResult(
+                detector_name=self.name,
+                score=0.5,
+                explanation="Text too short for reliable detection",
+                confidence=self.get_confidence_level(0.5)
+            )
+
+        try:
+            # Tokenize the text
+            inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=512, padding=True)
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            # Perform inference
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                logits = outputs.logits
+                probs = torch.softmax(logits, dim=-1)
+
+            # Probability that text is AI-generated (class 1)
+            ai_probability = probs[0][1].item()
+
+            # Binary classification
+            is_ai = ai_probability > 0.5
+            prediction = "AI-generated" if is_ai else "Human-written"
+
+            confidence = self.get_confidence_level(ai_probability)
+
+            explanation = f"TMR model predicts: {prediction} with probability {ai_probability:.4f}"
+
+            return DetectorResult(
+                detector_name=self.name,
+                score=ai_probability,
+                confidence=confidence,
+                explanation=explanation,
+                metadata={
+                    "model": self.model_name,
+                    "prediction": prediction,
+                    "ai_probability": ai_probability,
+                    "human_probability": probs[0][0].item(),
+                }
+            )
+
+        except Exception as e:
+            return DetectorResult(
+                detector_name=self.name,
+                score=0.5,
+                explanation=f"Error during TMR detection: {str(e)}",
+                confidence=self.get_confidence_level(0.5)
+            )
+
+    def cleanup(self):
+        """Clean up model resources"""
+        super().cleanup()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()

backend/main.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Main Flask application for AI Slop Detection API
+"""
+
+import os
+import sys
+from flask import Flask, send_from_directory
+from flask_cors import CORS
+from datetime import datetime
+
+# Add backend to path
+backend_dir = os.path.dirname(os.path.abspath(__file__))
+frontend_dir = os.path.join(os.path.dirname(backend_dir), 'frontend')
+sys.path.insert(0, backend_dir)
+
+from config.settings import settings
+from config.detectors_config import DetectorsConfig
+from database import Session
+from api import api
+
+def create_app():
+    """Create and configure Flask application"""
+    
+    app = Flask(__name__, static_folder=frontend_dir, static_url_path='/')
+    
+    # Enable CORS
+    CORS(app, resources={
+        r"/api/*": {
+            "origins": "*",
+            "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+            "allow_headers": ["Content-Type"]
+        }
+    })
+    
+    # Initialize database
+    Session.init()
+    
+    # Register blueprints
+    app.register_blueprint(api)
+    
+    # Serve static files
+    @app.route('/')
+    def index():
+        """Serve index.html"""
+        return send_from_directory(frontend_dir, 'index.html')
+    
+    @app.route('/<path:filename>')
+    def serve_static(filename):
+        """Serve static files from frontend"""
+        return send_from_directory(frontend_dir, filename)
+    
+    # Error handlers
+    @app.errorhandler(404)
+    def not_found(error):
+        return {"status": "error", "message": "Not found"}, 404
+    
+    @app.errorhandler(500)
+    def internal_error(error):
+        return {"status": "error", "message": "Internal server error"}, 500
+    
+    # Startup logging
+    with app.app_context():
+        print(f"\n{'='*60}")
+        print(f"AI Slop Detection API Started")
+        print(f"{'='*60}")
+        print(f"Timestamp: {datetime.utcnow().isoformat()}")
+        print(f"Database: {settings.DATABASE_URL[:30]}...")
+        print(f"Upload Folder: {settings.UPLOAD_FOLDER}")
+        print(f"\nDetector Configuration:")
+        print(f"{DetectorsConfig.summary()}")
+        print(f"\nEnabled Detectors:")
+        for detector, enabled in DetectorsConfig.get_enabled_detectors().items():
+            if enabled:
+                weight = DetectorsConfig.get_weight(detector)
+                print(f"  ✓ {detector.upper()} (weight: {weight})")
+        print(f"\nAggregation Method: {DetectorsConfig.AGGREGATION_METHOD}")
+        print(f"{'='*60}\n")
+    
+    return app
+
+if __name__ == '__main__':
+    app = create_app()
+    app.run(
+        host=settings.HOST,
+        port=settings.PORT,
+        debug=settings.DEBUG
+    )

backend/requirements.txt

@@ -0,0 +1,12 @@
+flask>=3.0.0
+flask-cors>=4.0.0
+transformers>=4.30.0
+torch>=2.0.0
+numpy>=1.21.0
+scipy>=1.7.0
+pypdf>=4.0.0
+python-docx>=0.8.0
+requests>=2.28.0
+pydantic>=2.0.0
+sqlalchemy>=2.0.0
+pydantic-settings>=2.0.0

backend/utils/__init__.py

@@ -0,0 +1,4 @@
+from .file_parser import FileParser, TextCleaner
+from .highlighter import TextHighlighter, Highlight
+
+__all__ = ["FileParser", "TextCleaner", "TextHighlighter", "Highlight"]

backend/utils/file_parser.py

@@ -0,0 +1,161 @@
+import os
+import re
+from typing import Tuple, Optional
+from pathlib import Path
+from pypdf import PdfReader
+from docx import Document
+
+_EMOJI_RE = re.compile(
+    "[\U0001F600-\U0001F64F"  # emoticons (😀 😂 🥹 etc.)
+    "\U0001F300-\U0001F5FF"  # misc symbols & pictographs (🌍 🎉 🔥 etc.)
+    "\U0001F680-\U0001F6FF"  # transport & map (🚀 ✈️ 🚗 etc.)
+    "\U0001F1E0-\U0001F1FF"  # regional indicator letters (flags 🇺🇸)
+    "\U0001F900-\U0001F9FF"  # supplemental symbols (🤔 🤣 🧠 etc.)
+    "\U0001FA00-\U0001FA6F"  # chess / extended pictographic
+    "\U0001FA70-\U0001FAFF"  # symbols & pictographs extended-A
+    "]+",
+    flags=re.UNICODE,
+)
+
+class FileParser:
+    """
+    Parse multiple file formats and extract text.
+    Supports: PDF, DOCX, TXT, and raw text input.
+    """
+    
+    SUPPORTED_FORMATS = {".pdf", ".docx", ".doc", ".txt"}
+    
+    @staticmethod
+    def parse_file(file_path: str) -> Tuple[str, str, Optional[Exception]]:
+        """
+        Parse a file and extract text.
+        
+        Args:
+            file_path: Path to the file
+            
+        Returns:
+            Tuple of (text, format, error)
+            - text: Extracted text content
+            - format: File format (pdf, docx, txt)
+            - error: Exception if parsing failed, None if successful
+        """
+        file_extension = Path(file_path).suffix.lower()
+        
+        if file_extension not in FileParser.SUPPORTED_FORMATS:
+            error = ValueError(f"Unsupported file format: {file_extension}")
+            return "", "", error
+        
+        if file_extension == ".pdf":
+            return FileParser.parse_pdf(file_path)
+        elif file_extension in {".docx", ".doc"}:
+            return FileParser.parse_docx(file_path)
+        elif file_extension == ".txt":
+            return FileParser.parse_txt(file_path)
+        
+        return "", "", ValueError("Unknown error")
+    
+    @staticmethod
+    def parse_pdf(file_path: str) -> Tuple[str, str, Optional[Exception]]:
+        """Extract text from PDF file"""
+        try:
+            text = ""
+            with open(file_path, 'rb') as pdf_file:
+                pdf_reader = PdfReader(pdf_file)
+                
+                # Extract text from all pages
+                for page_num in range(len(pdf_reader.pages)):
+                    page = pdf_reader.pages[page_num]
+                    text += page.extract_text() + "\n"
+            
+            return text.strip(), "pdf", None
+        
+        except Exception as e:
+            return "", "pdf", e
+    
+    @staticmethod
+    def parse_docx(file_path: str) -> Tuple[str, str, Optional[Exception]]:
+        """Extract text from DOCX file"""
+        try:
+            doc = Document(file_path)
+            text = ""
+            
+            # Extract text from all paragraphs
+            for paragraph in doc.paragraphs:
+                text += paragraph.text + "\n"
+            
+            # Also extract text from tables if present
+            for table in doc.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text += cell.text + "\n"
+            
+            return text.strip(), "docx", None
+        
+        except Exception as e:
+            return "", "docx", e
+    
+    @staticmethod
+    def parse_txt(file_path: str) -> Tuple[str, str, Optional[Exception]]:
+        """Extract text from plain text file"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as txt_file:
+                text = txt_file.read()
+            
+            return text.strip(), "txt", None
+        
+        except UnicodeDecodeError:
+            # Try with different encoding
+            try:
+                with open(file_path, 'r', encoding='latin-1') as txt_file:
+                    text = txt_file.read()
+                return text.strip(), "txt", None
+            except Exception as e:
+                return "", "txt", e
+        
+        except Exception as e:
+            return "", "txt", e
+    
+    @staticmethod
+    def parse_raw_text(text: str) -> Tuple[str, str, Optional[Exception]]:
+        """Process raw text input"""
+        try:
+            cleaned_text = text.strip()
+            if not cleaned_text:
+                return "", "raw", ValueError("Empty text provided")
+            return cleaned_text, "raw", None
+        except Exception as e:
+            return "", "raw", e
+
+class TextCleaner:
+    """Clean and normalize extracted text"""
+    
+    @staticmethod
+    def clean(text: str) -> str:
+        """
+        Clean and normalize text.
+        Removes extra whitespace, normalizes line breaks, etc.
+        """
+        # Remove extra whitespace
+        text = ' '.join(text.split())
+        
+        # Normalize line breaks
+        text = text.replace('\r\n', '\n').replace('\r', '\n')
+        
+        return text
+    
+    @staticmethod
+    def get_text_stats(text: str) -> dict:
+        """Get statistics about text"""
+        words = text.split()
+        sentences = text.split('.')
+
+        return {
+            "character_count": len(text),
+            "word_count": len(words),
+            "sentence_count": len([s for s in sentences if s.strip()]),
+            "average_word_length": len(text) / len(words) if words else 0,
+            "average_sentence_length": len(words) / len(sentences) if sentences else 0,
+            "emoji_count": sum(len(m) for m in _EMOJI_RE.findall(text)),
+            "em_dash_count": text.count('\u2014'),
+            "arrow_count": text.count('\u2192'),
+        }

backend/utils/highlighter.py

@@ -0,0 +1,207 @@
+from typing import List, Optional, Tuple
+from dataclasses import dataclass
+
+@dataclass
+class Highlight:
+    """Represents a highlighted section of text"""
+    start: int
+    end: int
+    text: str
+    reason: str
+    confidence: float
+    color: str = "yellow"
+    source_detector: str = ""
+
+class TextHighlighter:
+    """Utility for highlighting suspicious text sections"""
+    
+    # Color mapping for confidence levels
+    CONFIDENCE_COLORS = {
+        "very_low": "#90EE90",      # Light green
+        "low": "#FFE4B5",            # Moccasin
+        "medium": "#FFD700",         # Gold
+        "high": "#FF6347",           # Tomato
+        "very_high": "#DC143C",      # Crimson
+    }
+    
+    @staticmethod
+    def get_color_for_confidence(confidence: float) -> str:
+        """Get color for a confidence score"""
+        if confidence < 0.2:
+            return TextHighlighter.CONFIDENCE_COLORS["very_low"]
+        elif confidence < 0.4:
+            return TextHighlighter.CONFIDENCE_COLORS["low"]
+        elif confidence < 0.6:
+            return TextHighlighter.CONFIDENCE_COLORS["medium"]
+        elif confidence < 0.8:
+            return TextHighlighter.CONFIDENCE_COLORS["high"]
+        else:
+            return TextHighlighter.CONFIDENCE_COLORS["very_high"]
+    
+    @staticmethod
+    def create_html_report(
+        text: str,
+        highlights: List[Highlight],
+        title: str = "AI Detection Report"
+    ) -> str:
+        """
+        Create an HTML report with highlighted text.
+        
+        Args:
+            text: Original text
+            highlights: List of highlighted sections
+            title: Report title
+            
+        Returns:
+            HTML string
+        """
+        # Sort highlights by position
+        sorted_highlights = sorted(highlights, key=lambda h: h.start)
+        
+        # Build highlighted text
+        html_text = ""
+        last_pos = 0
+        
+        for highlight in sorted_highlights:
+            # Add text before highlight
+            if highlight.start > last_pos:
+                html_text += TextHighlighter._escape_html(
+                    text[last_pos:highlight.start]
+                )
+            
+            # Add highlighted section
+            color = TextHighlighter.get_color_for_confidence(highlight.confidence)
+            html_text += (
+                f'<span style="background-color: {color}; '
+                f'padding: 2px 4px; border-radius: 3px;" '
+                f'title="{highlight.reason}">'
+                f'{TextHighlighter._escape_html(highlight.text)}</span>'
+            )
+            
+            last_pos = highlight.end
+        
+        # Add remaining text
+        if last_pos < len(text):
+            html_text += TextHighlighter._escape_html(text[last_pos:])
+        
+        # Build full HTML document
+        html = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <title>{title}</title>
+            <style>
+                body {{
+                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                    margin: 20px;
+                    background-color: #f5f5f5;
+                }}
+                .report-container {{
+                    background-color: white;
+                    padding: 20px;
+                    border-radius: 8px;
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                    max-width: 900px;
+                    margin: 0 auto;
+                }}
+                h1 {{
+                    color: #333;
+                    border-bottom: 3px solid #007bff;
+                    padding-bottom: 10px;
+                }}
+                .highlighted-text {{
+                    line-height: 1.8;
+                    margin: 20px 0;
+                    padding: 15px;
+                    background-color: #fafafa;
+                    border-left: 4px solid #007bff;
+                    white-space: pre-wrap;
+                    word-wrap: break-word;
+                }}
+                .legend {{
+                    display: flex;
+                    gap: 20px;
+                    margin: 20px 0;
+                    flex-wrap: wrap;
+                }}
+                .legend-item {{
+                    display: flex;
+                    align-items: center;
+                    gap: 8px;
+                }}
+                .legend-color {{
+                    width: 20px;
+                    height: 20px;
+                    border-radius: 3px;
+                }}
+            </style>
+        </head>
+        <body>
+            <div class="report-container">
+                <h1>{title}</h1>
+                
+                <div class="legend">
+                    <div class="legend-item">
+                        <div class="legend-color" style="background-color: #90EE90;"></div>
+                        <span>Very Low Confidence (&lt;20%)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background-color: #FFE4B5;"></div>
+                        <span>Low Confidence (20-40%)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background-color: #FFD700;"></div>
+                        <span>Medium Confidence (40-60%)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background-color: #FF6347;"></div>
+                        <span>High Confidence (60-80%)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background-color: #DC143C;"></div>
+                        <span>Very High Confidence (&gt;80%)</span>
+                    </div>
+                </div>
+                
+                <div class="highlighted-text">
+                    {html_text}
+                </div>
+            </div>
+        </body>
+        </html>
+        """
+        
+        return html
+    
+    @staticmethod
+    def _escape_html(text: str) -> str:
+        """Escape HTML special characters"""
+        return (text
+                .replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace('"', "&quot;")
+                .replace("'", "&#39;"))
+    
+    @staticmethod
+    def create_text_report(
+        text: str,
+        highlights: List[Highlight]
+    ) -> str:
+        """
+        Create a plain text report with highlighted sections marked with [[ ]].
+        """
+        # Sort highlights by position (reverse to maintain positions)
+        sorted_highlights = sorted(highlights, key=lambda h: h.start, reverse=True)
+        
+        result = text
+        for highlight in sorted_highlights:
+            marked_text = f"[[{highlight.text}]]"
+            result = (
+                result[:highlight.start] +
+                marked_text +
+                result[highlight.end:]
+            )
+        
+        return result

backend/utils/submission_logger.py

@@ -0,0 +1,49 @@
+import json
+import os
+from datetime import datetime, timezone
+
+# Log file lives at the project root (next to run.bat / run.sh)
+_LOG_PATH = os.path.join(
+    os.path.dirname(__file__),   # backend/utils/
+    "..", "..",                   # → project root
+    "submissions.jsonl"
+)
+_LOG_PATH = os.path.normpath(_LOG_PATH)
+
+
+def log_submission(
+    filename: str,
+    overall_ai_score: float,
+    overall_confidence: str,
+    status_label: str,
+    detector_results: dict,
+    text_stats: dict,
+    text_preview: str = "",
+) -> None:
+    """
+    Append one JSON line to submissions.jsonl for every analysis.
+    Safe to call from multiple threads — each write is a single os.write.
+    """
+    record = {
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "filename": filename,
+        "overall_ai_score": round(overall_ai_score, 4),
+        "overall_confidence": overall_confidence,
+        "status_label": status_label,
+        "text_preview": text_preview[:200],
+        "text_stats": text_stats,
+        "detectors": {
+            name: {
+                "score": round(res.get("score", 0), 4),
+                "confidence": res.get("confidence"),
+                "prediction": res.get("metadata", {}).get("prediction"),
+                "ai_probability": round(res.get("metadata", {}).get("ai_probability", res.get("score", 0)), 4),
+                "human_probability": round(res.get("metadata", {}).get("human_probability", 1 - res.get("score", 0)), 4),
+            }
+            for name, res in detector_results.items()
+        },
+    }
+
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+    with open(_LOG_PATH, "a", encoding="utf-8") as f:
+        f.write(line)

frontend/index.html

@@ -0,0 +1,1099 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Slop Detector - Analyze AI-Generated Content</title>
+    <style>
+        :root {
+            --primary-color: #007bff;
+            --success-color: #28a745;
+            --danger-color: #dc3545;
+            --warning-color: #ffc107;
+            --info-color: #17a2b8;
+            --dark-color: #343a40;
+            --light-color: #f8f9fa;
+            --border-color: #dee2e6;
+            --shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+            --shadow-lg: 0 4px 16px rgba(0, 0, 0, 0.15);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+            color: #333;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+
+        header {
+            text-align: center;
+            color: white;
+            margin-bottom: 40px;
+            animation: slideDown 0.6s ease;
+        }
+
+        header h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            font-weight: 700;
+        }
+
+        header p {
+            font-size: 1.1rem;
+            opacity: 0.9;
+        }
+
+        .content {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 30px;
+            margin-bottom: 40px;
+        }
+
+        @media (max-width: 900px) {
+            .content {
+                grid-template-columns: 1fr;
+            }
+        }
+
+        .card {
+            background: white;
+            border-radius: 12px;
+            padding: 30px;
+            box-shadow: var(--shadow-lg);
+            animation: fadeIn 0.6s ease 0.2s backwards;
+        }
+
+        .card h2 {
+            font-size: 1.5rem;
+            margin-bottom: 20px;
+            color: var(--dark-color);
+            border-bottom: 3px solid var(--primary-color);
+            padding-bottom: 15px;
+        }
+
+        /* Upload Section */
+        .upload-area {
+            border: 3px dashed var(--primary-color);
+            border-radius: 8px;
+            padding: 40px 20px;
+            text-align: center;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            background: linear-gradient(135deg, rgba(0, 123, 255, 0.05) 0%, rgba(118, 75, 162, 0.05) 100%);
+        }
+
+        .upload-area:hover,
+        .upload-area.dragover {
+            border-color: var(--danger-color);
+            background: linear-gradient(135deg, rgba(220, 53, 69, 0.1) 0%, rgba(118, 75, 162, 0.1) 100%);
+            transform: translateY(-2px);
+        }
+
+        .upload-area p {
+            color: #666;
+            margin: 10px 0;
+            font-size: 0.95rem;
+        }
+
+        .upload-icon {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+        }
+
+        .file-input {
+            display: none;
+        }
+
+        .input-group {
+            margin-bottom: 20px;
+        }
+
+        label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 600;
+            color: var(--dark-color);
+        }
+
+        textarea,
+        input[type="text"],
+        input[type="file"] {
+            width: 100%;
+            padding: 12px;
+            border: 1px solid var(--border-color);
+            border-radius: 6px;
+            font-family: 'Segoe UI', sans-serif;
+            font-size: 0.95rem;
+            transition: border-color 0.3s ease;
+        }
+
+        textarea {
+            resize: vertical;
+            min-height: 150px;
+            font-family: 'Courier New', monospace;
+        }
+
+        textarea:focus,
+        input[type="text"]:focus {
+            outline: none;
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 3px rgba(0, 123, 255, 0.1);
+        }
+
+        .button {
+            background: var(--primary-color);
+            color: white;
+            padding: 12px 24px;
+            border: none;
+            border-radius: 6px;
+            font-size: 1rem;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            display: inline-block;
+            text-align: center;
+        }
+
+        .button:hover {
+            background: #0056b3;
+            transform: translateY(-2px);
+            box-shadow: var(--shadow-lg);
+        }
+
+        .button:active {
+            transform: translateY(0);
+        }
+
+        .button.secondary {
+            background: var(--dark-color);
+        }
+
+        .button.secondary:hover {
+            background: #212529;
+        }
+
+        .button:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        /* Results Section */
+        .results-container {
+            margin-top: 30px;
+        }
+
+        .result-item {
+            background: var(--light-color);
+            border-left: 5px solid var(--primary-color);
+            padding: 15px;
+            margin-bottom: 15px;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+        }
+
+        .result-item:hover {
+            transform: translateX(5px);
+            box-shadow: var(--shadow);
+        }
+
+        .result-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 10px;
+        }
+
+        .result-filename {
+            font-weight: 600;
+            color: var(--dark-color);
+        }
+
+        .score-badge {
+            display: inline-block;
+            padding: 6px 12px;
+            border-radius: 20px;
+            font-weight: 600;
+            font-size: 0.9rem;
+            color: white;
+        }
+
+        .score-human {
+            background: var(--success-color);
+        }
+
+        .score-suspicious {
+            background: var(--warning-color);
+            color: #333;
+        }
+
+        .score-ai {
+            background: var(--danger-color);
+        }
+
+        .result-meta {
+            font-size: 0.85rem;
+            color: #666;
+            display: flex;
+            gap: 20px;
+            flex-wrap: wrap;
+        }
+
+        /* Analysis Results Display */
+        .analysis-result {
+            background: white;
+            border-radius: 12px;
+            padding: 30px;
+            box-shadow: var(--shadow-lg);
+            margin-top: 20px;
+            animation: slideUp 0.5s ease;
+        }
+
+        .overall-score {
+            text-align: center;
+            padding: 30px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            border-radius: 8px;
+            color: white;
+            margin-bottom: 30px;
+        }
+
+        .overall-score h3 {
+            font-size: 1.2rem;
+            margin-bottom: 10px;
+            opacity: 0.9;
+        }
+
+        .score-percentage {
+            font-size: 3rem;
+            font-weight: 700;
+            margin: 10px 0;
+        }
+
+        .score-confidence {
+            font-size: 1.1rem;
+            opacity: 0.95;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+
+        .detector-results {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+            gap: 20px;
+            margin: 20px 0;
+        }
+
+        .detector-card {
+            background: var(--light-color);
+            border: 2px solid var(--border-color);
+            border-radius: 8px;
+            padding: 20px;
+            transition: all 0.3s ease;
+        }
+
+        .detector-card:hover {
+            border-color: var(--primary-color);
+            box-shadow: var(--shadow-lg);
+            transform: translateY(-3px);
+        }
+
+        .detector-name {
+            font-weight: 600;
+            font-size: 1.1rem;
+            margin-bottom: 4px;
+            color: var(--dark-color);
+        }
+
+        .detector-model {
+            font-size: 0.78rem;
+            color: #999;
+            margin-bottom: 14px;
+            font-style: italic;
+        }
+
+        .detector-score-row {
+            display: flex;
+            align-items: baseline;
+            gap: 10px;
+            margin-bottom: 6px;
+        }
+
+        .detector-score {
+            font-size: 2rem;
+            font-weight: 700;
+            line-height: 1;
+        }
+
+        .detector-prediction-badge {
+            display: inline-block;
+            padding: 3px 10px;
+            border-radius: 12px;
+            font-size: 0.78rem;
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        .prediction-ai {
+            background: rgba(220, 53, 69, 0.12);
+            color: #c82333;
+            border: 1px solid rgba(220, 53, 69, 0.3);
+        }
+
+        .prediction-human {
+            background: rgba(40, 167, 69, 0.12);
+            color: #1e7e34;
+            border: 1px solid rgba(40, 167, 69, 0.3);
+        }
+
+        .prob-bar-wrap {
+            margin: 12px 0 10px;
+        }
+
+        .prob-bar-labels {
+            display: flex;
+            justify-content: space-between;
+            font-size: 0.78rem;
+            color: #666;
+            margin-bottom: 4px;
+        }
+
+        .prob-bar-track {
+            height: 10px;
+            border-radius: 5px;
+            background: #e9ecef;
+            overflow: hidden;
+            display: flex;
+        }
+
+        .prob-bar-ai {
+            height: 100%;
+            background: linear-gradient(90deg, #f8645a, #dc3545);
+            transition: width 0.6s ease;
+            border-radius: 5px 0 0 5px;
+        }
+
+        .prob-bar-human {
+            height: 100%;
+            background: linear-gradient(90deg, #28a745, #20c963);
+            transition: width 0.6s ease;
+            border-radius: 0 5px 5px 0;
+        }
+
+        .prob-values {
+            display: flex;
+            justify-content: space-between;
+            margin-top: 4px;
+            font-size: 0.82rem;
+            font-weight: 600;
+        }
+
+        .prob-ai-val { color: #dc3545; }
+        .prob-human-val { color: #28a745; }
+
+        .detector-confidence {
+            font-size: 0.82rem;
+            color: #777;
+            margin-top: 10px;
+        }
+
+        .confidence-dot {
+            display: inline-block;
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            margin-right: 5px;
+            background: #aaa;
+        }
+
+        .conf-very_low .confidence-dot  { background: #adb5bd; }
+        .conf-low .confidence-dot        { background: #6c757d; }
+        .conf-medium .confidence-dot     { background: #ffc107; }
+        .conf-high .confidence-dot       { background: #fd7e14; }
+        .conf-very_high .confidence-dot  { background: #dc3545; }
+
+        .detector-explanation {
+            font-size: 0.85rem;
+            color: #666;
+            line-height: 1.5;
+            margin-top: 10px;
+            padding-top: 10px;
+            border-top: 1px solid var(--border-color);
+        }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 15px;
+            margin: 20px 0;
+        }
+
+        .stat-box {
+            background: var(--light-color);
+            padding: 15px;
+            border-radius: 8px;
+            text-align: center;
+            border: 1px solid var(--border-color);
+        }
+
+        .stat-label {
+            font-size: 0.85rem;
+            color: #666;
+            font-weight: 500;
+        }
+
+        .stat-value {
+            font-size: 1.8rem;
+            font-weight: 700;
+            color: var(--primary-color);
+            margin-top: 8px;
+        }
+
+        /* Tabs */
+        .tabs {
+            display: flex;
+            gap: 10px;
+            border-bottom: 2px solid var(--border-color);
+            margin: 20px 0;
+        }
+
+        .tab-button {
+            background: none;
+            border: none;
+            padding: 10px 20px;
+            cursor: pointer;
+            font-weight: 600;
+            color: #666;
+            border-bottom: 3px solid transparent;
+            transition: all 0.3s ease;
+        }
+
+        .tab-button.active {
+            color: var(--primary-color);
+            border-bottom-color: var(--primary-color);
+        }
+
+        .tab-content {
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+            animation: fadeIn 0.3s ease;
+        }
+
+        /* Status Messages */
+        .alert {
+            padding: 15px;
+            border-radius: 6px;
+            margin-bottom: 20px;
+            animation: slideDown 0.3s ease;
+        }
+
+        .alert-success {
+            background: rgba(40, 167, 69, 0.1);
+            color: #155724;
+            border-left: 4px solid var(--success-color);
+        }
+
+        .alert-error {
+            background: rgba(220, 53, 69, 0.1);
+            color: #721c24;
+            border-left: 4px solid var(--danger-color);
+        }
+
+        .alert-info {
+            background: rgba(23, 162, 184, 0.1);
+            color: #0c5460;
+            border-left: 4px solid var(--info-color);
+        }
+
+        .loading {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid rgba(255, 255, 255, 0.3);
+            border-radius: 50%;
+            border-top-color: white;
+            animation: spin 1s linear infinite;
+        }
+
+        .spinner {
+            text-align: center;
+            padding: 40px;
+        }
+
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+
+        @keyframes slideDown {
+            from {
+                opacity: 0;
+                transform: translateY(-20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        @keyframes slideUp {
+            from {
+                opacity: 0;
+                transform: translateY(20px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; }
+            to { opacity: 1; }
+        }
+
+        /* Empty State */
+        .empty-state {
+            text-align: center;
+            padding: 60px 20px;
+            color: #999;
+        }
+
+        .empty-state-icon {
+            font-size: 3rem;
+            margin-bottom: 20px;
+        }
+
+        .empty-state p {
+            font-size: 1.1rem;
+            margin-bottom: 20px;
+        }
+
+        /* Footer */
+        footer {
+            text-align: center;
+            color: white;
+            opacity: 0.8;
+            margin-top: 40px;
+            padding: 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>🔍 AI Slop Detector</h1>
+            <p>Analyze documents and text for AI-generated content</p>
+        </header>
+
+        <div class="content">
+            <!-- Upload Section -->
+            <div class="card" id="uploadCard">
+                <h2>📤 Upload File</h2>
+                <div class="upload-area" id="uploadArea">
+                    <div class="upload-icon">📄</div>
+                    <p><strong>Click or drag to upload</strong></p>
+                    <p style="font-size: 0.85rem;">Supported: PDF, DOCX, TXT (Max 50MB)</p>
+                </div>
+                <input type="file" id="fileInput" class="file-input" accept=".pdf,.docx,.doc,.txt">
+                
+                <div style="margin-top: 20px;">
+                    <div class="input-group">
+                        <label for="fileName">Optional: Custom Name</label>
+                        <input type="text" id="fileName" placeholder="e.g., document.pdf">
+                    </div>
+                    <button class="button" style="width: 100%;" id="uploadButton" disabled>
+                        Upload & Analyze
+                    </button>
+                </div>
+            </div>
+
+            <!-- Text Analysis Section -->
+            <div class="card" id="textCard">
+                <h2>✏️ Analyze Text</h2>
+                <div class="input-group">
+                    <label for="rawText">Paste your text here</label>
+                    <textarea id="rawText" placeholder="Enter or paste text to analyze..."></textarea>
+                </div>
+                <button class="button" style="width: 100%;" id="analyzeButton">
+                    Analyze Text
+                </button>
+            </div>
+        </div>
+
+        <!-- Loading Indicator -->
+        <div id="loadingIndicator" style="display: none;" class="spinner">
+            <div class="loading"></div>
+            <p style="margin-top: 10px; color: white;">Analyzing...</p>
+        </div>
+
+        <!-- Alert Messages -->
+        <div id="alertContainer"></div>
+
+        <!-- Results Section -->
+        <div id="resultsSection" style="display: none;">
+            <div class="card">
+                <h2>📊 Analysis Results</h2>
+                
+                <div class="tabs">
+                    <button class="tab-button active" data-tab="current">Current Analysis</button>
+                    <button class="tab-button" data-tab="history">History</button>
+                    <button class="tab-button" data-tab="statistics">Statistics</button>
+                </div>
+
+                <!-- Current Analysis Tab -->
+                <div class="tab-content active" id="currentTab">
+                    <div id="analysisResult"></div>
+                </div>
+
+                <!-- History Tab -->
+                <div class="tab-content" id="historyTab">
+                    <div id="historyList"></div>
+                </div>
+
+                <!-- Statistics Tab -->
+                <div class="tab-content" id="statisticsTab">
+                    <div id="statistics"></div>
+                </div>
+            </div>
+        </div>
+
+        <footer>
+            <p>🛡️ AI Slop Detector - Powered by Advanced AI Detection Algorithms</p>
+            <p style="font-size: 0.85rem; margin-top: 10px;">Multi-detector ensemble for accurate AI-generated content detection</p>
+        </footer>
+    </div>
+
+    <script>
+        // API Base URL
+        const API_BASE = '/api';
+
+        // State
+        let currentResult = null;
+        let selectedFile = null;
+
+        // ============================================================================
+        // File Upload Handler
+        // ============================================================================
+
+        const uploadArea = document.getElementById('uploadArea');
+        const fileInput = document.getElementById('fileInput');
+        const uploadButton = document.getElementById('uploadButton');
+        const fileName = document.getElementById('fileName');
+
+        // Click to upload
+        uploadArea.addEventListener('click', () => fileInput.click());
+
+        // Drag and drop
+        uploadArea.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadArea.classList.add('dragover');
+        });
+
+        uploadArea.addEventListener('dragleave', () => {
+            uploadArea.classList.remove('dragover');
+        });
+
+        uploadArea.addEventListener('drop', (e) => {
+            e.preventDefault();
+            uploadArea.classList.remove('dragover');
+            handleFileSelect(e.dataTransfer.files);
+        });
+
+        // File input change
+        fileInput.addEventListener('change', (e) => {
+            handleFileSelect(e.target.files);
+        });
+
+        function handleFileSelect(files) {
+            if (files.length === 0) return;
+            
+            selectedFile = files[0];
+            uploadArea.innerHTML = `<div style="color: #666;">✓ ${selectedFile.name} selected</div>`;
+            uploadButton.disabled = false;
+        }
+
+        // Upload and analyze file
+        uploadButton.addEventListener('click', async () => {
+            if (!selectedFile) return;
+            
+            showLoading(true);
+            hideAlert();
+
+            try {
+                const formData = new FormData();
+                formData.append('file', selectedFile);
+
+                const response = await fetch(`${API_BASE}/analyze/file`, {
+                    method: 'POST',
+                    body: formData
+                });
+
+                const data = await response.json();
+                
+                if (response.ok) {
+                    currentResult = data;
+                    displayAnalysisResult(data);
+                    showAlert('Analysis completed successfully!', 'success');
+                    loadHistory();
+                    loadStatistics();
+                } else {
+                    showAlert(data.message || 'Analysis failed', 'error');
+                }
+            } catch (error) {
+                showAlert(`Error: ${error.message}`, 'error');
+            } finally {
+                showLoading(false);
+            }
+        });
+
+        // ============================================================================
+        // Text Analysis Handler
+        // ============================================================================
+
+        const analyzeButton = document.getElementById('analyzeButton');
+        const rawText = document.getElementById('rawText');
+
+        analyzeButton.addEventListener('click', async () => {
+            const text = rawText.value.trim();
+            
+            if (!text) {
+                showAlert('Please enter some text to analyze', 'error');
+                return;
+            }
+
+            if (text.length < 10) {
+                showAlert('Text must be at least 10 characters', 'error');
+                return;
+            }
+
+            showLoading(true);
+            hideAlert();
+
+            try {
+                const response = await fetch(`${API_BASE}/analyze/text`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ text: text })
+                });
+
+                const data = await response.json();
+                
+                if (response.ok) {
+                    currentResult = data;
+                    displayAnalysisResult(data);
+                    showAlert('Analysis completed successfully!', 'success');
+                    loadHistory();
+                    loadStatistics();
+                } else {
+                    showAlert(data.message || 'Analysis failed', 'error');
+                }
+            } catch (error) {
+                showAlert(`Error: ${error.message}`, 'error');
+            } finally {
+                showLoading(false);
+            }
+        });
+
+        // ============================================================================
+        // Display Functions
+        // ============================================================================
+
+        function displayAnalysisResult(result) {
+            document.getElementById('resultsSection').style.display = 'block';
+            
+            const html = `
+                <div class="analysis-result">
+                    <div class="overall-score">
+                        <h3>Overall AI Likelihood</h3>
+                        <div class="score-percentage">${result.overall_ai_score_percentage}</div>
+                        <div class="score-confidence">${result.overall_confidence}</div>
+                        <div style="margin-top: 15px; font-size: 1rem;">${result.status_label}</div>
+                    </div>
+
+                    <h3 style="margin-bottom: 15px;">📈 Detector Results</h3>
+                    <div class="detector-results">
+                        ${Object.entries(result.detector_results).map(([name, detector]) => {
+                            const meta = detector.metadata || {};
+                            const aiProb = meta.ai_probability != null ? meta.ai_probability : detector.score;
+                            const humanProb = meta.human_probability != null ? meta.human_probability : (1 - detector.score);
+                            const prediction = meta.prediction || null;
+                            const isAI = prediction ? prediction.toLowerCase().includes('ai') : detector.score >= 0.5;
+                            const scoreColor = detector.score >= 0.7 ? '#dc3545' : detector.score >= 0.3 ? '#fd7e14' : '#28a745';
+                            const conf = detector.confidence || 'n/a';
+                            return `
+                            <div class="detector-card">
+                                <div class="detector-name">${formatDetectorName(name)}</div>
+                                <div class="detector-model">${meta.model || 'N/A'}</div>
+
+                                <div class="detector-score-row">
+                                    <div class="detector-score" style="color:${scoreColor}">${(detector.score * 100).toFixed(1)}%</div>
+                                    ${prediction ? `<span class="detector-prediction-badge ${isAI ? 'prediction-ai' : 'prediction-human'}">${prediction}</span>` : ''}
+                                </div>
+
+                                <div class="prob-bar-wrap">
+                                    <div class="prob-bar-labels">
+                                        <span>AI</span>
+                                        <span>Human</span>
+                                    </div>
+                                    <div class="prob-bar-track">
+                                        <div class="prob-bar-ai" style="width:${(aiProb * 100).toFixed(1)}%"></div>
+                                        <div class="prob-bar-human" style="width:${(humanProb * 100).toFixed(1)}%"></div>
+                                    </div>
+                                    <div class="prob-values">
+                                        <span class="prob-ai-val">${(aiProb * 100).toFixed(1)}%</span>
+                                        <span class="prob-human-val">${(humanProb * 100).toFixed(1)}%</span>
+                                    </div>
+                                </div>
+
+                                <div class="detector-confidence conf-${conf}">
+                                    <span class="confidence-dot"></span>Confidence: ${conf.replace('_', ' ')}
+                                </div>
+                                <div class="detector-explanation">${detector.explanation || 'No details'}</div>
+                            </div>`;
+                        }).join('')}
+                    </div>
+
+                    <h3 style="margin-top: 30px; margin-bottom: 15px;">📊 Text Statistics</h3>
+                    <div class="stats-grid">
+                        <div class="stat-box">
+                            <div class="stat-label">Characters</div>
+                            <div class="stat-value">${result.text_stats.character_count.toLocaleString()}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Words</div>
+                            <div class="stat-value">${result.text_stats.word_count.toLocaleString()}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Sentences</div>
+                            <div class="stat-value">${result.text_stats.sentence_count}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Avg Word Length</div>
+                            <div class="stat-value">${result.text_stats.average_word_length.toFixed(1)}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Emojis</div>
+                            <div class="stat-value">${result.text_stats.emoji_count ?? 0}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Em Dashes (—)</div>
+                            <div class="stat-value">${result.text_stats.em_dash_count ?? 0}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Arrows (→)</div>
+                            <div class="stat-value">${result.text_stats.arrow_count ?? 0}</div>
+                        </div>
+                    </div>
+
+                    <div style="margin-top: 20px;">
+                        <strong>Detectors Used:</strong> ${result.enabled_detectors.join(', ')}
+                    </div>
+                </div>
+            `;
+
+            document.getElementById('analysisResult').innerHTML = html;
+            document.querySelector('[data-tab="current"]').click();
+        }
+
+        function formatDetectorName(name) {
+            const names = {
+                'roberta': 'RoBERTa Detector',
+                'perplexity': 'Perplexity Analysis',
+                'llmdet': 'LLMDet Detector',
+                'hf_classifier': 'HF Classifier',
+                'outfox': 'OUTFOX Statistical',
+                'tmr_detector': 'TMR (Target Mining RoBERTa)',
+                'pattern': 'Pattern Signals (EM Dash + Emoji)',
+            };
+            return names[name] || name.toUpperCase();
+        }
+
+        async function loadHistory() {
+            try {
+                const response = await fetch(`${API_BASE}/results?limit=10&sort=recent`);
+                const data = await response.json();
+
+                if (!data.results || data.results.length === 0) {
+                    document.getElementById('historyList').innerHTML = `
+                        <div class="empty-state">
+                            <div class="empty-state-icon">📂</div>
+                            <p>No previous analyses yet</p>
+                        </div>
+                    `;
+                    return;
+                }
+
+                const html = data.results.map(result => `
+                    <div class="result-item" onclick="viewResult(${result.id})">
+                        <div class="result-header">
+                            <span class="result-filename">${result.filename}</span>
+                            <span class="score-badge ${getScoreBadgeClass(result.overall_ai_score)}">
+                                ${(result.overall_ai_score * 100).toFixed(1)}%
+                            </span>
+                        </div>
+                        <div class="result-meta">
+                            <span>📅 ${new Date(result.upload_timestamp).toLocaleDateString()}</span>
+                            <span>📝 ${result.word_count} words</span>
+                        </div>
+                    </div>
+                `).join('');
+
+                document.getElementById('historyList').innerHTML = html;
+            } catch (error) {
+                console.error('Error loading history:', error);
+            }
+        }
+
+        async function loadStatistics() {
+            try {
+                const response = await fetch(`${API_BASE}/statistics/summary`);
+                const data = await response.json();
+
+                if (!data.summary) {
+                    return;
+                }
+
+                const stats = data.summary;
+                const html = `
+                    <div class="stats-grid" style="margin-bottom: 20px;">
+                        <div class="stat-box">
+                            <div class="stat-label">Total Analyses</div>
+                            <div class="stat-value">${stats.total_analyses}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Average AI Score</div>
+                            <div class="stat-value">${(stats.average_ai_score * 100).toFixed(1)}%</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Text Analyzed</div>
+                            <div class="stat-value">${(stats.total_text_analyzed / 1000).toFixed(0)}K chars</div>
+                        </div>
+                    </div>
+                    <div class="stats-grid">
+                        <div class="stat-box">
+                            <div class="stat-label">Likely Human</div>
+                            <div class="stat-value" style="color: #28a745;">${stats.likely_human}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Suspicious</div>
+                            <div class="stat-value" style="color: #ffc107;">${stats.suspicious}</div>
+                        </div>
+                        <div class="stat-box">
+                            <div class="stat-label">Likely AI</div>
+                            <div class="stat-value" style="color: #dc3545;">${stats.likely_ai}</div>
+                        </div>
+                    </div>
+                `;
+
+                document.getElementById('statistics').innerHTML = html;
+            } catch (error) {
+                console.error('Error loading statistics:', error);
+            }
+        }
+
+        function getScoreBadgeClass(score) {
+            if (score < 0.3) return 'score-human';
+            if (score < 0.7) return 'score-suspicious';
+            return 'score-ai';
+        }
+
+        async function viewResult(resultId) {
+            try {
+                const response = await fetch(`${API_BASE}/results/${resultId}`);
+                const data = await response.json();
+
+                if (response.ok && data.result) {
+                    currentResult = data.result;
+                    displayAnalysisResult({
+                        ...data.result,
+                        detector_results: data.result.detector_results || {},
+                        enabled_detectors: [],
+                        overall_ai_score_percentage: `${(data.result.overall_ai_score * 100).toFixed(1)}%`,
+                        status_label: 'View from history',
+                        text_stats: {
+                            character_count: data.result.text_length,
+                            word_count: data.result.word_count,
+                            sentence_count: 0,
+                            average_word_length: 0
+                        }
+                    });
+                }
+            } catch (error) {
+                console.error('Error viewing result:', error);
+            }
+        }
+
+        // ============================================================================
+        // Utility Functions
+        // ============================================================================
+
+        function showLoading(show) {
+            document.getElementById('loadingIndicator').style.display = show ? 'block' : 'none';
+            uploadButton.disabled = show;
+            analyzeButton.disabled = show;
+        }
+
+        function showAlert(message, type = 'info') {
+            const alertHTML = `
+                <div class="alert alert-${type}">
+                    ${message}
+                </div>
+            `;
+            const container = document.getElementById('alertContainer');
+            container.innerHTML = alertHTML;
+            
+            // Auto-dismiss after 5 seconds
+            setTimeout(() => hideAlert(), 5000);
+        }
+
+        function hideAlert() {
+            document.getElementById('alertContainer').innerHTML = '';
+        }
+
+        // Tab switching
+        document.querySelectorAll('.tab-button').forEach(button => {
+            button.addEventListener('click', (e) => {
+                const tabName = e.target.dataset.tab;
+                
+                // Hide all tabs
+                document.querySelectorAll('.tab-content').forEach(tab => {
+                    tab.classList.remove('active');
+                });
+                
+                // Remove active class from all buttons
+                document.querySelectorAll('.tab-button').forEach(btn => {
+                    btn.classList.remove('active');
+                });
+                
+                // Show selected tab
+                document.getElementById(tabName + 'Tab').classList.add('active');
+                e.target.classList.add('active');
+            });
+        });
+
+        // Load initial data
+        loadHistory();
+        loadStatistics();
+    </script>
+</body>
+</html>