feat: improve architecture using React + Vite + FastAPI

ARCHITECTURE_V3.md

@@ -0,0 +1,199 @@
+# 🏗️ Architecture v3.0 - React + FastAPI + Docker
+
+## 🎯 Objectif
+Interface simple et intuitive, déployable sur Hugging Face Spaces via Docker.
+
+## 📐 Architecture
+
+```
+custom-cluedo/
+├── backend/              # FastAPI
+│   ├── main.py          # API principale
+│   ├── models.py        # Modèles Pydantic
+│   ├── game_engine.py   # Logique métier
+│   ├── game_manager.py  # Gestion parties
+│   └── requirements.txt
+│
+├── frontend/            # React
+│   ├── public/
+│   ├── src/
+│   │   ├── App.jsx
+│   │   ├── pages/
+│   │   │   ├── Home.jsx
+│   │   │   ├── Join.jsx
+│   │   │   └── Game.jsx
+│   │   ├── components/
+│   │   │   ├── Board.jsx
+│   │   │   ├── PlayerCards.jsx
+│   │   │   └── ActionPanel.jsx
+│   │   └── api.js
+│   ├── package.json
+│   └── vite.config.js
+│
+├── Dockerfile           # Multi-stage build
+├── docker-compose.yml   # Dev local
+└── README.md
+```
+
+## 🎮 Flux Simplifié
+
+### 1. Création (Valeurs par Défaut)
+```
+Titre: "Meurtre au Manoir"
+Tonalité: "Thriller"
+Lieux: ["Cuisine", "Salon", "Bureau", "Chambre", "Garage", "Jardin"]
+Armes: ["Poignard", "Revolver", "Corde", "Chandelier", "Clé anglaise", "Poison"]
+Suspects: ["Mme Leblanc", "Col. Moutarde", "Mlle Rose", "Prof. Violet", "Mme Pervenche", "M. Olive"]
+```
+
+**Personnalisation optionnelle** (accordéon replié par défaut)
+
+### 2. Interface de Jeu
+
+**Layout simple :**
+```
+┌─────────────────────────────────────┐
+│  Cluedo Custom - Code: AB7F         │
+├─────────────────────────────────────┤
+│                                     │
+│  [Plateau avec positions]           │
+│                                     │
+├─────────────────────────────────────┤
+│  Vos cartes: [🃏] [🃏] [🃏]         │
+├─────────────────────────────────────┤
+│  Tour de: Alice                     │
+│  [🎲 Lancer dés] ou [⏭️ Passer]    │
+│                                     │
+│  Si déplacé:                        │
+│  [💭 Suggérer] [⚡ Accuser]         │
+└─────────────────────────────────────┘
+```
+
+## 🐳 Docker pour Hugging Face
+
+### Dockerfile
+```dockerfile
+# Stage 1: Build frontend
+FROM node:18-alpine AS frontend-build
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: Run backend + serve frontend
+FROM python:3.11-slim
+WORKDIR /app
+
+# Install backend deps
+COPY backend/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy backend
+COPY backend/ ./backend/
+
+# Copy built frontend
+COPY --from=frontend-build /app/frontend/dist ./frontend/dist
+
+# Expose port
+EXPOSE 7860
+
+# Start FastAPI (serves both API and static frontend)
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]
+```
+
+## 🚀 Déploiement Hugging Face
+
+### README.md du Space
+```yaml
+---
+title: Cluedo Custom
+emoji: 🔍
+colorFrom: red
+colorTo: purple
+sdk: docker
+pinned: false
+---
+```
+
+## ⚙️ Configuration FastAPI pour Servir React
+
+```python
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+app = FastAPI()
+
+# API routes
+@app.get("/api/health")
+async def health():
+    return {"status": "ok"}
+
+# ... autres routes API ...
+
+# Serve React app
+app.mount("/", StaticFiles(directory="frontend/dist", html=True), name="static")
+
+@app.get("/{full_path:path}")
+async def serve_react(full_path: str):
+    return FileResponse("frontend/dist/index.html")
+```
+
+## 📦 Valeurs par Défaut
+
+### Thèmes Prédéfinis
+```python
+DEFAULT_THEMES = {
+    "classic": {
+        "name": "Meurtre au Manoir",
+        "rooms": ["Cuisine", "Salon", "Bureau", "Chambre", "Garage", "Jardin"],
+        "weapons": ["Poignard", "Revolver", "Corde", "Chandelier", "Clé anglaise", "Poison"],
+        "suspects": ["Mme Leblanc", "Col. Moutarde", "Mlle Rose", "Prof. Violet", "Mme Pervenche", "M. Olive"]
+    },
+    "office": {
+        "name": "Meurtre au Bureau",
+        "rooms": ["Open Space", "Salle de réunion", "Cafétéria", "Bureau CEO", "Toilettes", "Parking"],
+        "weapons": ["Clé USB", "Agrafeuse", "Câble", "Capsule café", "Souris", "Plante"],
+        "suspects": ["Claire", "Pierre", "Daniel", "Marie", "Thomas", "Sophie"]
+    }
+}
+```
+
+## 🎨 Design Simple (TailwindCSS)
+
+- **Palette** : Tons sombres mystérieux
+- **Composants** : shadcn/ui ou Chakra UI
+- **Animations** : Framer Motion (minimales)
+
+## 🔧 APIs Essentielles
+
+```
+POST   /api/games/create        # Créer (avec défauts)
+POST   /api/games/join          # Rejoindre
+POST   /api/games/{id}/start    # Démarrer
+GET    /api/games/{id}/state    # État du jeu
+POST   /api/games/{id}/roll     # Lancer dés
+POST   /api/games/{id}/suggest  # Suggestion
+POST   /api/games/{id}/accuse   # Accusation
+POST   /api/games/{id}/pass     # Passer tour
+```
+
+## ✨ Fonctionnalités Simplifiées
+
+### MVP (Version 1)
+- ✅ Création avec valeurs par défaut
+- ✅ Rejoindre avec code
+- ✅ Déplacement avec dés
+- ✅ Suggestions/Accusations
+- ✅ Desland (commentaires simples, pas d'IA)
+
+### Future (Version 2)
+- [ ] IA avec OpenAI
+- [ ] Personnalisation complète
+- [ ] Thèmes multiples
+- [ ] Animations avancées
+
+---
+
+**Cette architecture sera plus robuste, plus simple à utiliser et déployable facilement sur Hugging Face Spaces.**

SETUP_REACT.md

@@ -0,0 +1,252 @@
+# 🚀 Setup React + Docker - Cluedo Custom v3
+
+## ✅ Ce qui est fait
+
+### Backend
+- ✅ `backend/main.py` - API FastAPI complète
+- ✅ `backend/defaults.py` - 3 thèmes prédéfinis (classic, office, fantasy)
+- ✅ `backend/models.py`, `game_engine.py`, `game_manager.py` - Logique métier
+- ✅ `backend/requirements.txt` - Dépendances Python
+
+### Frontend (structure)
+- ✅ `frontend/package.json` - Config React + Vite + Tailwind
+- ✅ `frontend/vite.config.js` - Config Vite avec proxy API
+- ✅ `frontend/tailwind.config.js` - Theme sombre
+- ✅ `frontend/src/api.js` - Client API
+
+## 📋 Ce qu'il reste à faire
+
+### 1. Créer les composants React
+
+Créer ces fichiers dans `frontend/src/` :
+
+#### `main.jsx`
+```jsx
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)
+```
+
+#### `App.jsx`
+```jsx
+import { BrowserRouter, Routes, Route } from 'react-router-dom'
+import Home from './pages/Home'
+import Join from './pages/Join'
+import Game from './pages/Game'
+
+function App() {
+  return (
+    <BrowserRouter>
+      <div className="min-h-screen bg-gradient-to-br from-dark-950 via-dark-900 to-dark-950">
+        <Routes>
+          <Route path="/" element={<Home />} />
+          <Route path="/join" element={<Join />} />
+          <Route path="/game/:gameId/:playerId" element={<Game />} />
+        </Routes>
+      </div>
+    </BrowserRouter>
+  )
+}
+
+export default App
+```
+
+#### `pages/Home.jsx` - Page d'accueil
+- Bouton "Créer une partie" (thème classic par défaut)
+- Input nom du joueur
+- Lien vers "Rejoindre une partie"
+
+#### `pages/Join.jsx` - Rejoindre une partie
+- Input code de partie (4 caractères)
+- Input nom du joueur
+- Bouton rejoindre
+
+#### `pages/Game.jsx` - Interface de jeu
+- Plateau avec positions
+- Cartes du joueur
+- Actions (Dés, Suggestion, Accusation, Passer)
+- Historique
+- Bouton "Démarrer" (si créateur et 3+ joueurs)
+
+### 2. Créer le Dockerfile
+
+```dockerfile
+# Stage 1: Build frontend
+FROM node:18-alpine AS frontend-build
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: Python backend
+FROM python:3.11-slim
+WORKDIR /app
+
+# Install backend deps
+COPY backend/requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy backend
+COPY backend/ ./backend/
+
+# Copy built frontend
+COPY --from=frontend-build /app/frontend/dist ./frontend/dist
+
+# Expose port for Hugging Face
+EXPOSE 7860
+
+# Start server
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]
+```
+
+### 3. Créer docker-compose.yml (pour test local)
+
+```yaml
+version: '3.8'
+
+services:
+  backend:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - ./backend:/app/backend
+      - ./frontend/dist:/app/frontend/dist
+    environment:
+      - PYTHONUNBUFFERED=1
+```
+
+### 4. Créer README.md pour Hugging Face
+
+```yaml
+---
+title: Cluedo Custom
+emoji: 🔍
+colorFrom: red
+colorTo: purple
+sdk: docker
+pinned: false
+app_port: 7860
+---
+
+# 🔍 Cluedo Custom
+
+Créez votre propre jeu de Cluedo avec des suspects, armes et lieux personnalisés !
+
+## 🎮 Comment jouer
+
+1. **Créer une partie** : Choisissez un thème (Manoir classique, Bureau, Château)
+2. **Partager le code** : Envoyez le code à 4 caractères à vos amis
+3. **Jouer** : Lancez les dés, déplacez-vous, faites des suggestions !
+
+## 🛠️ Développement local
+
+\`\`\`bash
+# Build et lancer avec Docker
+docker-compose up --build
+
+# Ou séparément :
+# Backend
+cd backend && pip install -r requirements.txt && uvicorn main:app --port 8000
+
+# Frontend
+cd frontend && npm install && npm run dev
+\`\`\`
+```
+
+### 5. Commandes pour tester
+
+```bash
+# 1. Installer frontend
+cd frontend
+npm install
+
+# 2. Builder frontend
+npm run build
+
+# 3. Tester backend seul (sert le frontend builded)
+cd ../backend
+pip install -r requirements.txt
+uvicorn main:app --port 7860
+
+# Ouvrir http://localhost:7860
+
+# 4. Build Docker
+cd ..
+docker build -t cluedo-custom .
+docker run -p 7860:7860 cluedo-custom
+
+# 5. Deploy sur Hugging Face
+# - Créer un nouveau Space (SDK: Docker)
+# - Push le code
+# - Hugging Face va build automatiquement
+```
+
+## 🎨 Templates de composants React simplifiés
+
+Les composants doivent être **ultra-simples** :
+
+### Home.jsx (minimal)
+- Titre "Cluedo Custom"
+- Input "Votre nom"
+- Bouton "Créer une partie"
+- Lien "Rejoindre une partie existante"
+
+### Game.jsx (minimal)
+- Section "Plateau" : Liste des pièces avec icônes joueurs
+- Section "Mes cartes" : Liste simple
+- Section "Actions" :
+  - Si mon tour : Bouton "Lancer dés" OU "Passer"
+  - Si déplacé : Selects (suspect/arme/pièce) + "Suggérer" / "Accuser"
+- Section "Historique" : 5 dernières actions
+
+## ⚡ Quick Start (après avoir créé les composants)
+
+```bash
+# Terminal 1 - Backend
+cd backend
+pip install -r requirements.txt
+uvicorn main:app --reload --port 8000
+
+# Terminal 2 - Frontend (dev mode)
+cd frontend
+npm install
+npm run dev
+# Ouvre http://localhost:3000
+
+# Pour production (single server)
+cd frontend
+npm run build
+cd ../backend
+uvicorn main:app --port 7860
+# Ouvre http://localhost:7860
+```
+
+## 🐳 Déployer sur Hugging Face
+
+1. Créer un Space : https://huggingface.co/new-space
+2. Choisir SDK: **Docker**
+3. Cloner le repo du Space
+4. Copier tous les fichiers dedans
+5. Ajouter `README.md` avec le header YAML
+6. Push:
+```bash
+git add .
+git commit -m "Initial commit"
+git push
+```
+
+7. Attendre le build (~5-10 min)
+8. Votre jeu est en ligne ! 🎉
+
+---
+
+**Note** : Les composants React sont volontairement simplifiés pour aller vite. Tu pourras les améliorer après le déploiement.

backend/config.py

@@ -0,0 +1,37 @@
+"""
+Configuration module for Cluedo Custom application.
+Loads environment variables and provides application settings.
+"""
+
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+class Settings:
+    """Application settings loaded from environment variables."""
+
+    # Application settings
+    APP_NAME: str = os.getenv("APP_NAME", "Cluedo Custom")
+    MAX_PLAYERS: int = int(os.getenv("MAX_PLAYERS", "8"))
+
+    # AI settings
+    USE_OPENAI: bool = os.getenv("USE_OPENAI", "false").lower() == "true"
+    OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
+
+    # Game settings
+    MIN_PLAYERS: int = 3
+    MIN_ROOMS: int = 6
+    MAX_ROOMS: int = 12
+
+    # Server settings
+    HOST: str = "0.0.0.0"
+    PORT: int = 7860
+
+    # Game data file
+    GAMES_FILE: str = "games.json"
+
+
+settings = Settings()

backend/defaults.py

@@ -0,0 +1,101 @@
+"""
+Default game presets for quick setup
+"""
+
+DEFAULT_THEMES = {
+    "classic": {
+        "name": "Meurtre au Manoir",
+        "tone": "🎬 Thriller",
+        "rooms": [
+            "Cuisine",
+            "Salon",
+            "Bureau",
+            "Chambre",
+            "Garage",
+            "Jardin"
+        ],
+        "weapons": [
+            "Poignard",
+            "Revolver",
+            "Corde",
+            "Chandelier",
+            "Clé anglaise",
+            "Poison"
+        ],
+        "suspects": [
+            "Mme Leblanc",
+            "Col. Moutarde",
+            "Mlle Rose",
+            "Prof. Violet",
+            "Mme Pervenche",
+            "M. Olive"
+        ]
+    },
+    "office": {
+        "name": "Meurtre au Bureau",
+        "tone": "😂 Parodique",
+        "rooms": [
+            "Open Space",
+            "Salle de réunion",
+            "Cafétéria",
+            "Bureau CEO",
+            "Toilettes",
+            "Parking"
+        ],
+        "weapons": [
+            "Clé USB",
+            "Agrafeuse",
+            "Câble HDMI",
+            "Capsule de café",
+            "Souris d'ordinateur",
+            "Plante verte"
+        ],
+        "suspects": [
+            "Claire",
+            "Pierre",
+            "Daniel",
+            "Marie",
+            "Thomas",
+            "Sophie"
+        ]
+    },
+    "fantasy": {
+        "name": "Meurtre au Château",
+        "tone": "🧙‍♂️ Fantastique",
+        "rooms": [
+            "Grande Salle",
+            "Tour des Mages",
+            "Donjon",
+            "Bibliothèque",
+            "Armurerie",
+            "Crypte"
+        ],
+        "weapons": [
+            "Épée enchantée",
+            "Potion empoisonnée",
+            "Grimoire maudit",
+            "Dague runique",
+            "Bâton magique",
+            "Amulette sombre"
+        ],
+        "suspects": [
+            "Merlin le Sage",
+            "Dame Morgane",
+            "Chevalier Lancelot",
+            "Elfe Aranelle",
+            "Nain Thorin",
+            "Sorcière Malva"
+        ]
+    }
+}
+
+# Default theme to use
+DEFAULT_THEME = "classic"
+
+def get_default_game_config(theme: str = DEFAULT_THEME):
+    """Get default game configuration"""
+    if theme not in DEFAULT_THEMES:
+        theme = DEFAULT_THEME
+
+    config = DEFAULT_THEMES[theme].copy()
+    return config

backend/game_engine.py

@@ -0,0 +1,294 @@
+"""
+Game engine for Cluedo Custom.
+Handles game logic, card distribution, turn management, and game rules.
+"""
+
+import random
+from typing import List, Optional, Tuple
+from models import Game, Card, CardType, Solution, GameStatus, Player
+from datetime import datetime
+
+
+# Default character names (fallback if no custom suspects provided)
+DEFAULT_CHARACTERS = [
+    "Miss Scarlett",
+    "Colonel Mustard",
+    "Mrs. White",
+    "Reverend Green",
+    "Mrs. Peacock",
+    "Professor Plum"
+]
+
+# Default weapon names (fallback if no custom weapons provided)
+DEFAULT_WEAPONS = [
+    "Candlestick",
+    "Knife",
+    "Lead Pipe",
+    "Revolver",
+    "Rope",
+    "Wrench"
+]
+
+
+class GameEngine:
+    """Core game logic engine for Cluedo Custom."""
+
+    @staticmethod
+    def initialize_game(game: Game) -> Game:
+        """
+        Initialize a game with cards and solution.
+        Distributes cards among players after setting aside the solution.
+        """
+        # Use custom suspects or defaults
+        suspects = game.custom_suspects if game.custom_suspects else DEFAULT_CHARACTERS
+        weapons = game.custom_weapons if game.custom_weapons else DEFAULT_WEAPONS
+
+        # Create character cards
+        game.characters = [
+            Card(name=name, card_type=CardType.CHARACTER)
+            for name in suspects
+        ]
+
+        # Create weapon cards
+        game.weapons = [
+            Card(name=name, card_type=CardType.WEAPON)
+            for name in weapons
+        ]
+
+        # Create room cards
+        game.room_cards = [
+            Card(name=room, card_type=CardType.ROOM)
+            for room in game.rooms
+        ]
+
+        # Select solution (one of each type)
+        solution_character = random.choice(game.characters)
+        solution_weapon = random.choice(game.weapons)
+        solution_room = random.choice(game.room_cards)
+
+        game.solution = Solution(
+            character=solution_character,
+            weapon=solution_weapon,
+            room=solution_room
+        )
+
+        # Remaining cards to distribute
+        remaining_cards = []
+        remaining_cards.extend([c for c in game.characters if c.name != solution_character.name])
+        remaining_cards.extend([w for w in game.weapons if w.name != solution_weapon.name])
+        remaining_cards.extend([r for r in game.room_cards if r.name != solution_room.name])
+
+        # Shuffle and distribute
+        random.shuffle(remaining_cards)
+        GameEngine._distribute_cards(game, remaining_cards)
+
+        # Set game status to in progress
+        game.status = GameStatus.IN_PROGRESS
+        game.current_player_index = 0
+
+        return game
+
+    @staticmethod
+    def _distribute_cards(game: Game, cards: List[Card]):
+        """
+        Distribute cards evenly among all players.
+        """
+        num_players = len(game.players)
+        if num_players == 0:
+            return
+
+        for i, card in enumerate(cards):
+            player_index = i % num_players
+            game.players[player_index].cards.append(card)
+
+    @staticmethod
+    def check_suggestion(
+        game: Game,
+        player_id: str,
+        character: str,
+        weapon: str,
+        room: str
+    ) -> Tuple[bool, Optional[str], Optional[Card]]:
+        """
+        Process a player's suggestion.
+        Returns (can_disprove, disprover_name, card_shown).
+
+        Starting with the next player clockwise, check if anyone can disprove
+        the suggestion by showing one matching card.
+        """
+        player_index = next(
+            (i for i, p in enumerate(game.players) if p.id == player_id),
+            None
+        )
+        if player_index is None:
+            return False, None, None
+
+        num_players = len(game.players)
+
+        # Check other players clockwise
+        for offset in range(1, num_players):
+            check_index = (player_index + offset) % num_players
+            checker = game.players[check_index]
+
+            # Find matching cards
+            matching_cards = [
+                card for card in checker.cards
+                if card.name in [character, weapon, room]
+            ]
+
+            if matching_cards:
+                # Show one random matching card
+                card_to_show = random.choice(matching_cards)
+                return True, checker.name, card_to_show
+
+        # No one can disprove
+        return False, None, None
+
+    @staticmethod
+    def check_accusation(
+        game: Game,
+        character: str,
+        weapon: str,
+        room: str
+    ) -> bool:
+        """
+        Check if an accusation is correct.
+        Returns True if the accusation matches the solution.
+        """
+        if not game.solution:
+            return False
+
+        return (
+            game.solution.character.name == character and
+            game.solution.weapon.name == weapon and
+            game.solution.room.name == room
+        )
+
+    @staticmethod
+    def process_accusation(
+        game: Game,
+        player_id: str,
+        character: str,
+        weapon: str,
+        room: str
+    ) -> Tuple[bool, str]:
+        """
+        Process a player's accusation.
+        Returns (is_correct, message).
+
+        If correct, player wins.
+        If incorrect, player is eliminated from the game.
+        """
+        player = next((p for p in game.players if p.id == player_id), None)
+        if not player:
+            return False, "Player not found"
+
+        is_correct = GameEngine.check_accusation(game, character, weapon, room)
+
+        if is_correct:
+            game.winner = player.name
+            game.status = GameStatus.FINISHED
+            return True, f"{player.name} wins! The accusation was correct."
+        else:
+            # Eliminate player
+            player.is_active = False
+
+            # Check if only one or no players remain active
+            active_players = [p for p in game.players if p.is_active]
+            if len(active_players) <= 1:
+                game.status = GameStatus.FINISHED
+                if active_players:
+                    game.winner = active_players[0].name
+                    return False, f"{player.name}'s accusation was wrong. {game.winner} wins by elimination!"
+                else:
+                    return False, "All players eliminated. Game over!"
+
+            return False, f"{player.name}'s accusation was wrong and is eliminated from the game."
+
+    @staticmethod
+    def add_turn_record(
+        game: Game,
+        player_id: str,
+        action: str,
+        details: Optional[str] = None,
+        ai_comment: Optional[str] = None
+    ):
+        """Add a turn record to the game history."""
+        from models import Turn
+
+        player = next((p for p in game.players if p.id == player_id), None)
+        if not player:
+            return
+
+        turn = Turn(
+            player_id=player_id,
+            player_name=player.name,
+            action=action,
+            details=details,
+            ai_comment=ai_comment,
+            timestamp=datetime.now().isoformat()
+        )
+        game.turns.append(turn)
+
+    @staticmethod
+    def get_player_card_names(player: Player) -> List[str]:
+        """Get list of card names for a player."""
+        return [card.name for card in player.cards]
+
+    @staticmethod
+    def can_player_act(game: Game, player_id: str) -> bool:
+        """Check if it's the player's turn and they can act."""
+        current_player = game.get_current_player()
+        if not current_player:
+            return False
+
+        return (
+            current_player.id == player_id and
+            current_player.is_active and
+            game.status == GameStatus.IN_PROGRESS
+        )
+
+    @staticmethod
+    def roll_dice() -> int:
+        """Roll two dice and return the sum (2-12)."""
+        return random.randint(1, 6) + random.randint(1, 6)
+
+    @staticmethod
+    def move_player(game: Game, player_id: str, dice_roll: int) -> Tuple[bool, str, int]:
+        """
+        Move a player on the board based on dice roll.
+        Returns (success, message, new_room_index).
+        """
+        player = next((p for p in game.players if p.id == player_id), None)
+        if not player:
+            return False, "Joueur introuvable", -1
+
+        num_rooms = len(game.rooms)
+        if num_rooms == 0:
+            return False, "Pas de pièces disponibles", -1
+
+        # Calculate new position (circular movement)
+        new_room_index = (player.current_room_index + dice_roll) % num_rooms
+        old_room = game.rooms[player.current_room_index]
+        new_room = game.rooms[new_room_index]
+
+        player.current_room_index = new_room_index
+
+        message = f"🎲 Dés: {dice_roll} | {old_room} → {new_room}"
+        return True, message, new_room_index
+
+    @staticmethod
+    def can_make_suggestion(game: Game, player_id: str, room: str) -> Tuple[bool, str]:
+        """
+        Check if a player can make a suggestion.
+        Players can only suggest in the room they're currently in.
+        """
+        player = next((p for p in game.players if p.id == player_id), None)
+        if not player:
+            return False, "Joueur introuvable"
+
+        current_room = game.rooms[player.current_room_index]
+        if current_room != room:
+            return False, f"Tu dois être dans {room} pour faire cette suggestion ! Tu es actuellement dans {current_room}."
+
+        return True, ""

backend/game_manager.py

@@ -0,0 +1,151 @@
+"""
+Game manager for handling multiple concurrent games.
+Provides in-memory storage and game lifecycle management.
+"""
+
+import json
+import os
+from typing import Dict, Optional, List
+from models import Game, Player, CreateGameRequest, GameStatus
+from game_engine import GameEngine
+from config import settings
+
+
+class GameManager:
+    """Manages multiple game instances in memory."""
+
+    def __init__(self):
+        self.games: Dict[str, Game] = {}
+        self.load_games()
+
+    def create_game(self, request: CreateGameRequest) -> Game:
+        """
+        Create a new game instance.
+        """
+        game_id = Game.generate_game_id()
+
+        # Ensure unique game ID
+        while game_id in self.games:
+            game_id = Game.generate_game_id()
+
+        game = Game(
+            game_id=game_id,
+            name=request.game_name,
+            narrative_tone=request.narrative_tone,
+            custom_prompt=request.custom_prompt,
+            rooms=request.rooms,
+            custom_weapons=request.custom_weapons,
+            custom_suspects=request.custom_suspects,
+            use_ai=request.use_ai,
+            max_players=settings.MAX_PLAYERS
+        )
+
+        self.games[game_id] = game
+        self.save_games()
+
+        return game
+
+    def get_game(self, game_id: str) -> Optional[Game]:
+        """Retrieve a game by ID."""
+        return self.games.get(game_id)
+
+    def join_game(self, game_id: str, player_name: str) -> Optional[Player]:
+        """
+        Add a player to an existing game.
+        Returns the player if successful, None otherwise.
+        """
+        game = self.get_game(game_id)
+
+        if not game:
+            return None
+
+        if game.status != GameStatus.WAITING:
+            return None  # Can't join a game in progress
+
+        if game.is_full():
+            return None  # Game is full
+
+        player = game.add_player(player_name)
+        self.save_games()
+
+        return player
+
+    def start_game(self, game_id: str) -> bool:
+        """
+        Start a game (initialize cards and solution).
+        Returns True if successful.
+        """
+        game = self.get_game(game_id)
+
+        if not game:
+            return False
+
+        if game.status != GameStatus.WAITING:
+            return False  # Game already started
+
+        if len(game.players) < settings.MIN_PLAYERS:
+            return False  # Not enough players
+
+        # Initialize the game
+        GameEngine.initialize_game(game)
+        self.save_games()
+
+        return True
+
+    def list_active_games(self) -> List[Dict]:
+        """
+        List all active games (waiting or in progress).
+        Returns simplified game info for listing.
+        """
+        active_games = []
+
+        for game in self.games.values():
+            if game.status in [GameStatus.WAITING, GameStatus.IN_PROGRESS]:
+                active_games.append({
+                    "game_id": game.game_id,
+                    "name": game.name,
+                    "status": game.status,
+                    "players": len(game.players),
+                    "max_players": game.max_players,
+                })
+
+        return active_games
+
+    def delete_game(self, game_id: str) -> bool:
+        """Delete a game from memory."""
+        if game_id in self.games:
+            del self.games[game_id]
+            self.save_games()
+            return True
+        return False
+
+    def save_games(self):
+        """Persist games to JSON file."""
+        try:
+            games_data = {
+                game_id: game.model_dump()
+                for game_id, game in self.games.items()
+            }
+
+            with open(settings.GAMES_FILE, 'w') as f:
+                json.dump(games_data, f, indent=2)
+        except Exception as e:
+            print(f"Error saving games: {e}")
+
+    def load_games(self):
+        """Load games from JSON file if it exists."""
+        if not os.path.exists(settings.GAMES_FILE):
+            return
+
+        try:
+            with open(settings.GAMES_FILE, 'r') as f:
+                games_data = json.load(f)
+
+            for game_id, game_dict in games_data.items():
+                self.games[game_id] = Game(**game_dict)
+        except Exception as e:
+            print(f"Error loading games: {e}")
+
+
+# Global game manager instance
+game_manager = GameManager()

backend/main.py

@@ -0,0 +1,363 @@
+"""
+FastAPI backend for Cluedo Custom
+Serves both API and React frontend
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import Optional, List
+import os
+
+from models import CreateGameRequest, GameStatus
+from game_manager import game_manager
+from game_engine import GameEngine
+from defaults import get_default_game_config, DEFAULT_THEMES
+
+app = FastAPI(title="Cluedo Custom API")
+
+# CORS for development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ==================== API ROUTES ====================
+
+@app.get("/api/health")
+async def health():
+    return {"status": "ok", "message": "Cluedo Custom API is running"}
+
+
+@app.get("/api/themes")
+async def get_themes():
+    """Get available game themes"""
+    return {"themes": DEFAULT_THEMES}
+
+
+class QuickCreateRequest(BaseModel):
+    theme: str = "classic"
+    player_name: str
+
+
+@app.post("/api/games/quick-create")
+async def quick_create_game(req: QuickCreateRequest):
+    """Create a game quickly with default theme"""
+    try:
+        config = get_default_game_config(req.theme)
+
+        game_req = CreateGameRequest(
+            game_name=config["name"],
+            narrative_tone=config["tone"],
+            custom_prompt=None,
+            rooms=config["rooms"],
+            custom_weapons=config["weapons"],
+            custom_suspects=config["suspects"],
+            use_ai=False
+        )
+
+        game = game_manager.create_game(game_req)
+
+        # Auto-join creator as first player
+        player = game_manager.join_game(game.game_id, req.player_name)
+
+        return {
+            "game_id": game.game_id,
+            "player_id": player.id if player else None,
+            "game_name": game.name,
+            "theme": req.theme
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+class JoinRequest(BaseModel):
+    game_id: str
+    player_name: str
+
+
+@app.post("/api/games/join")
+async def join_game(req: JoinRequest):
+    """Join an existing game"""
+    game = game_manager.get_game(req.game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if game.status != GameStatus.WAITING:
+        raise HTTPException(status_code=400, detail="Game already started")
+
+    if game.is_full():
+        raise HTTPException(status_code=400, detail="Game is full")
+
+    player = game_manager.join_game(req.game_id.upper(), req.player_name)
+
+    if not player:
+        raise HTTPException(status_code=400, detail="Could not join game")
+
+    return {
+        "game_id": game.game_id,
+        "player_id": player.id,
+        "player_name": player.name
+    }
+
+
+@app.post("/api/games/{game_id}/start")
+async def start_game(game_id: str):
+    """Start a game"""
+    success = game_manager.start_game(game_id.upper())
+
+    if not success:
+        raise HTTPException(status_code=400, detail="Cannot start game (need min 3 players)")
+
+    game = game_manager.get_game(game_id.upper())
+    return {
+        "status": "started",
+        "first_player": game.get_current_player().name if game else None
+    }
+
+
+@app.get("/api/games/{game_id}/state/{player_id}")
+async def get_game_state(game_id: str, player_id: str):
+    """Get game state for a specific player"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    player = next((p for p in game.players if p.id == player_id), None)
+
+    if not player:
+        raise HTTPException(status_code=404, detail="Player not found")
+
+    current_player = game.get_current_player()
+
+    # Build player-specific view
+    return {
+        "game_id": game.game_id,
+        "game_name": game.name,
+        "status": game.status.value,
+        "scenario": game.scenario,
+        "rooms": game.rooms,
+        "suspects": [c.name for c in game.characters],
+        "weapons": [w.name for w in game.weapons],
+        "my_cards": [{"name": c.name, "type": c.card_type.value} for c in player.cards],
+        "my_position": player.current_room_index,
+        "current_room": game.rooms[player.current_room_index] if game.rooms else None,
+        "players": [
+            {
+                "name": p.name,
+                "is_active": p.is_active,
+                "position": p.current_room_index,
+                "room": game.rooms[p.current_room_index] if game.rooms else None,
+                "is_me": p.id == player_id
+            }
+            for p in game.players
+        ],
+        "current_turn": {
+            "player_name": current_player.name if current_player else None,
+            "is_my_turn": current_player.id == player_id if current_player else False
+        },
+        "recent_actions": [
+            {
+                "player": t.player_name,
+                "action": t.action,
+                "details": t.details,
+                "ai_comment": t.ai_comment
+            }
+            for t in game.turns[-5:]
+        ],
+        "winner": game.winner
+    }
+
+
+class DiceRollRequest(BaseModel):
+    player_id: str
+
+
+@app.post("/api/games/{game_id}/roll")
+async def roll_dice(game_id: str, req: DiceRollRequest):
+    """Roll dice and move player"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Roll dice
+    dice = GameEngine.roll_dice()
+
+    # Move player
+    success, msg, new_pos = GameEngine.move_player(game, req.player_id, dice)
+
+    if not success:
+        raise HTTPException(status_code=400, detail=msg)
+
+    # Record turn
+    GameEngine.add_turn_record(game, req.player_id, "move", msg)
+    game_manager.save_games()
+
+    return {
+        "dice_value": dice,
+        "new_position": new_pos,
+        "new_room": game.rooms[new_pos],
+        "message": msg
+    }
+
+
+class SuggestionRequest(BaseModel):
+    player_id: str
+    suspect: str
+    weapon: str
+    room: str
+
+
+@app.post("/api/games/{game_id}/suggest")
+async def make_suggestion(game_id: str, req: SuggestionRequest):
+    """Make a suggestion"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Check if player is in the room
+    can_suggest, error = GameEngine.can_make_suggestion(game, req.player_id, req.room)
+    if not can_suggest:
+        raise HTTPException(status_code=400, detail=error)
+
+    # Process suggestion
+    can_disprove, disprover, card = GameEngine.check_suggestion(
+        game, req.player_id, req.suspect, req.weapon, req.room
+    )
+
+    result = {
+        "suggestion": f"{req.suspect} + {req.weapon} + {req.room}",
+        "was_disproven": can_disprove,
+        "disprover": disprover if can_disprove else None,
+        "card_shown": card.name if card else None
+    }
+
+    # Record turn
+    GameEngine.add_turn_record(
+        game,
+        req.player_id,
+        "suggest",
+        result["suggestion"]
+    )
+
+    game.next_turn()
+    game_manager.save_games()
+
+    return result
+
+
+class AccusationRequest(BaseModel):
+    player_id: str
+    suspect: str
+    weapon: str
+    room: str
+
+
+@app.post("/api/games/{game_id}/accuse")
+async def make_accusation(game_id: str, req: AccusationRequest):
+    """Make an accusation"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Process accusation
+    is_correct, message = GameEngine.process_accusation(
+        game, req.player_id, req.suspect, req.weapon, req.room
+    )
+
+    # Record turn
+    GameEngine.add_turn_record(
+        game,
+        req.player_id,
+        "accuse",
+        f"{req.suspect} + {req.weapon} + {req.room}"
+    )
+
+    if not is_correct and game.status == GameStatus.IN_PROGRESS:
+        game.next_turn()
+
+    game_manager.save_games()
+
+    return {
+        "is_correct": is_correct,
+        "message": message,
+        "winner": game.winner
+    }
+
+
+class PassRequest(BaseModel):
+    player_id: str
+
+
+@app.post("/api/games/{game_id}/pass")
+async def pass_turn(game_id: str, req: PassRequest):
+    """Pass the turn"""
+    game = game_manager.get_game(game_id.upper())
+
+    if not game:
+        raise HTTPException(status_code=404, detail="Game not found")
+
+    if not GameEngine.can_player_act(game, req.player_id):
+        raise HTTPException(status_code=400, detail="Not your turn")
+
+    # Record turn
+    GameEngine.add_turn_record(game, req.player_id, "pass", "Passed turn")
+
+    game.next_turn()
+    game_manager.save_games()
+
+    next_player = game.get_current_player()
+
+    return {
+        "message": "Turn passed",
+        "next_player": next_player.name if next_player else None
+    }
+
+
+# ==================== SERVE REACT APP ====================
+
+# Check if frontend build exists
+frontend_path = os.path.join(os.path.dirname(__file__), "..", "frontend", "dist")
+
+if os.path.exists(frontend_path):
+    # Serve static files
+    app.mount("/assets", StaticFiles(directory=os.path.join(frontend_path, "assets")), name="assets")
+
+    @app.get("/{full_path:path}")
+    async def serve_react(full_path: str):
+        """Serve React app for all non-API routes"""
+        if full_path.startswith("api/"):
+            raise HTTPException(status_code=404, detail="API route not found")
+
+        index_file = os.path.join(frontend_path, "index.html")
+        if os.path.exists(index_file):
+            return FileResponse(index_file)
+        else:
+            raise HTTPException(status_code=404, detail="Frontend not built")
+else:
+    @app.get("/")
+    async def root():
+        return {
+            "message": "Cluedo Custom API",
+            "docs": "/docs",
+            "frontend": "Not built yet. Run: cd frontend && npm run build"
+        }

backend/models.py

@@ -0,0 +1,182 @@
+"""
+Data models for Cluedo Custom game.
+Defines the structure of players, cards, and game state.
+"""
+
+from typing import List, Optional, Dict
+from pydantic import BaseModel, Field
+from enum import Enum
+import random
+import string
+
+
+class NarrativeTone(str, Enum):
+    """Narrative tone options for the game."""
+    SERIOUS = "🕵️ Sérieuse"
+    PARODY = "😂 Parodique"
+    FANTASY = "🧙‍♂️ Fantastique"
+    THRILLER = "🎬 Thriller"
+    HORROR = "👻 Horreur"
+
+
+class CardType(str, Enum):
+    """Types of cards in the game."""
+    CHARACTER = "character"
+    WEAPON = "weapon"
+    ROOM = "room"
+
+
+class Card(BaseModel):
+    """Represents a single card in the game."""
+    name: str
+    card_type: CardType
+
+
+class Player(BaseModel):
+    """Represents a player in the game."""
+    id: str
+    name: str
+    cards: List[Card] = Field(default_factory=list)
+    is_active: bool = True
+    current_room_index: int = 0  # Position on the board
+
+
+class GameStatus(str, Enum):
+    """Status of a game."""
+    WAITING = "waiting"  # Waiting for players to join
+    IN_PROGRESS = "in_progress"  # Game is running
+    FINISHED = "finished"  # Game has ended
+
+
+class Turn(BaseModel):
+    """Represents a turn action in the game."""
+    player_id: str
+    player_name: str
+    action: str  # "move", "suggest", "accuse", "pass"
+    details: Optional[str] = None
+    ai_comment: Optional[str] = None  # Desland's sarcastic comment
+    timestamp: str
+
+
+class Solution(BaseModel):
+    """The secret solution to the mystery."""
+    character: Card
+    weapon: Card
+    room: Card
+
+
+class InvestigationNote(BaseModel):
+    """Player's notes on the investigation."""
+    player_id: str
+    element_name: str  # Name of suspect/weapon/room
+    element_type: str  # "suspect", "weapon", "room"
+    status: str  # "unknown", "eliminated", "maybe"
+
+
+class Game(BaseModel):
+    """Represents a complete game instance."""
+    game_id: str
+    name: str
+    status: GameStatus = GameStatus.WAITING
+
+    # Theme and narrative
+    narrative_tone: str = NarrativeTone.SERIOUS.value
+    custom_prompt: Optional[str] = None
+
+    # Game elements (customizable)
+    rooms: List[str]
+    custom_weapons: List[str] = Field(default_factory=list)
+    custom_suspects: List[str] = Field(default_factory=list)
+
+    use_ai: bool = False
+
+    # Players
+    players: List[Player] = Field(default_factory=list)
+    max_players: int = 8
+    current_player_index: int = 0
+
+    # Cards
+    characters: List[Card] = Field(default_factory=list)
+    weapons: List[Card] = Field(default_factory=list)
+    room_cards: List[Card] = Field(default_factory=list)
+
+    # Solution
+    solution: Optional[Solution] = None
+
+    # Game state
+    turns: List[Turn] = Field(default_factory=list)
+    winner: Optional[str] = None
+
+    # Investigation notes (for UI)
+    investigation_notes: List[InvestigationNote] = Field(default_factory=list)
+
+    # AI-generated content
+    scenario: Optional[str] = None
+
+    @staticmethod
+    def generate_game_id() -> str:
+        """Generate a unique 4-character game ID (like AB7F)."""
+        chars = string.ascii_uppercase + string.digits
+        return ''.join(random.choices(chars, k=4))
+
+    def add_player(self, player_name: str) -> Player:
+        """Add a new player to the game."""
+        player_id = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8))
+        # All players start in the first room
+        player = Player(id=player_id, name=player_name, current_room_index=0)
+        self.players.append(player)
+        return player
+
+    def get_current_player(self) -> Optional[Player]:
+        """Get the player whose turn it is."""
+        if not self.players:
+            return None
+        return self.players[self.current_player_index]
+
+    def next_turn(self):
+        """Move to the next active player's turn."""
+        if not self.players:
+            return
+
+        # Skip eliminated players
+        attempts = 0
+        while attempts < len(self.players):
+            self.current_player_index = (self.current_player_index + 1) % len(self.players)
+            if self.players[self.current_player_index].is_active:
+                break
+            attempts += 1
+
+    def is_full(self) -> bool:
+        """Check if the game has reached maximum players."""
+        return len(self.players) >= self.max_players
+
+
+class CreateGameRequest(BaseModel):
+    """Request to create a new game."""
+    game_name: str
+    narrative_tone: str = NarrativeTone.SERIOUS.value
+    custom_prompt: Optional[str] = None
+    rooms: List[str]
+    custom_weapons: List[str]
+    custom_suspects: List[str]
+    use_ai: bool = False
+
+
+class JoinGameRequest(BaseModel):
+    """Request to join an existing game."""
+    game_id: str
+    player_name: str
+
+
+class GameAction(BaseModel):
+    """Request to perform a game action."""
+    game_id: str
+    player_id: str
+    action_type: str  # "move", "suggest", "accuse", "pass"
+    # For movement
+    dice_roll: Optional[int] = None
+    target_room_index: Optional[int] = None
+    # For suggestions/accusations
+    character: Optional[str] = None
+    weapon: Optional[str] = None
+    room: Optional[str] = None

backend/requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+pydantic==2.5.0
+python-multipart==0.0.6

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="fr">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>🔍 Cluedo Custom</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "cluedo-custom-frontend",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.20.0",
+    "axios": "^1.6.2"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.43",
+    "@types/react-dom": "^18.2.17",
+    "@vitejs/plugin-react": "^4.2.1",
+    "autoprefixer": "^10.4.16",
+    "postcss": "^8.4.32",
+    "tailwindcss": "^3.3.6",
+    "vite": "^5.0.8"
+  }
+}

frontend/postcss.config.js

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

frontend/src/api.js

@@ -0,0 +1,57 @@
+import axios from 'axios';
+
+const API_BASE = import.meta.env.VITE_API_URL || '/api';
+
+const api = axios.create({
+  baseURL: API_BASE,
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+export const gameAPI = {
+  // Get available themes
+  getThemes: () => api.get('/themes'),
+
+  // Quick create with defaults
+  quickCreate: (theme, playerName) =>
+    api.post('/games/quick-create', { theme, player_name: playerName }),
+
+  // Join existing game
+  join: (gameId, playerName) =>
+    api.post('/games/join', { game_id: gameId, player_name: playerName }),
+
+  // Start game
+  start: (gameId) => api.post(`/games/${gameId}/start`),
+
+  // Get game state
+  getState: (gameId, playerId) => api.get(`/games/${gameId}/state/${playerId}`),
+
+  // Roll dice
+  rollDice: (gameId, playerId) =>
+    api.post(`/games/${gameId}/roll`, { player_id: playerId }),
+
+  // Make suggestion
+  suggest: (gameId, playerId, suspect, weapon, room) =>
+    api.post(`/games/${gameId}/suggest`, {
+      player_id: playerId,
+      suspect,
+      weapon,
+      room,
+    }),
+
+  // Make accusation
+  accuse: (gameId, playerId, suspect, weapon, room) =>
+    api.post(`/games/${gameId}/accuse`, {
+      player_id: playerId,
+      suspect,
+      weapon,
+      room,
+    }),
+
+  // Pass turn
+  pass: (gameId, playerId) =>
+    api.post(`/games/${gameId}/pass`, { player_id: playerId }),
+};
+
+export default api;

frontend/src/index.css

@@ -0,0 +1,17 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  @apply bg-dark-950 text-gray-100;
+}
+
+#root {
+  min-height: 100vh;
+}

frontend/tailwind.config.js

@@ -0,0 +1,39 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        primary: {
+          50: '#fef2f2',
+          100: '#fee2e2',
+          200: '#fecaca',
+          300: '#fca5a5',
+          400: '#f87171',
+          500: '#ef4444',
+          600: '#dc2626',
+          700: '#b91c1c',
+          800: '#991b1b',
+          900: '#7f1d1d',
+        },
+        dark: {
+          50: '#f8fafc',
+          100: '#f1f5f9',
+          200: '#e2e8f0',
+          300: '#cbd5e1',
+          400: '#94a3b8',
+          500: '#64748b',
+          600: '#475569',
+          700: '#334155',
+          800: '#1e293b',
+          900: '#0f172a',
+          950: '#020617',
+        },
+      },
+    },
+  },
+  plugins: [],
+}

frontend/vite.config.js

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    port: 3000,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8000',
+        changeOrigin: true,
+      },
+    },
+  },
+})