Selaa lähdekoodia

New ux and scraping

augustin.podvin 8 kuukautta sitten
vanhempi
commit
f8a880eed6

+ 3 - 0
.env.example

@@ -1,6 +1,9 @@
 # Copier ce fichier en .env et remplir les valeurs
 # cp .env.example .env
 
+# DEBUG=1 : mode debug (Flask debug, scraping limité à 15 URLs) | DEBUG=0 : production (pas de limite URLs)
+# DEBUG=0
+
 SECRET_KEY=votre-secret-key-changez-en-production
 # PostgreSQL: postgresql://postgres:postgres@localhost:5432/agent
 # SQLite (plus simple): sqlite:///agent.db

+ 4 - 0
README.md

@@ -61,6 +61,10 @@ full_update_pipeline()
 "
 ```
 
+## Méthode BMAD (contexte IA)
+
+Le projet intègre une adoption légère de la [méthode BMAD](https://docs.bmad-method.org/) pour guider les agents IA. Le fichier `_bmad-output/project-context.md` contient le contexte technique (stack, règles, architecture). Pour les nouvelles fonctionnalités, voir `_bmad-output/BMAD_GUIDE.md`.
+
 ## Tests
 
 Les dépendances (dont pytest) sont installées dans l'image Docker. Pour lancer les tests :

+ 1 - 0
Untitled

@@ -0,0 +1 @@
+processing

+ 52 - 0
_bmad-output/BMAD_GUIDE.md

@@ -0,0 +1,52 @@
+# Guide BMAD — Agent Docker
+
+Ce projet adopte une **version légère** de la [méthode BMAD](https://docs.bmad-method.org/) (Build More Architect Dreams) pour structurer le développement avec des agents IA (Cursor, Claude, etc.).
+
+## Ce qui a été mis en place
+
+### 1. `project-context.md`
+
+Fichier de référence pour les agents IA : stack technique, règles d’implémentation, résumé d’architecture. **À inclure dans le contexte** lorsque vous travaillez sur le projet avec un assistant IA.
+
+### 2. Structure des dossiers
+
+```
+_bmad-output/
+├── project-context.md      # Contexte pour les agents
+├── guidelines.md            # UX, UI et bonnes pratiques
+├── backlog.md               # Liste des fonctionnalités à faire
+├── planning-artifacts/      # Architecture, PRD (voir Documents/)
+├── implementation-artifacts/  # Sprint, stories (à venir)
+└── BMAD_GUIDE.md           # Ce fichier
+```
+
+### 3. Documents existants
+
+- `Documents/Architecture.md` — Architecture et flux
+- `Documents/Choix_techniques.md` — Limites et paramètres
+
+## Utilisation avec Cursor
+
+1. **Référencer le contexte** : mentionnez `@_bmad-output/project-context.md` dans vos prompts pour que l’agent respecte les conventions du projet.
+
+2. **Backlog** : maintenez la liste des fonctionnalités dans `backlog.md` (statut, priorité, notes).
+
+3. **Nouvelles fonctionnalités** : avant de coder, créez une story dans `implementation-artifacts/` (format : objectif, critères d’acceptation, contraintes techniques).
+
+4. **Changements d’architecture** : mettez à jour `Documents/Architecture.md` et `project-context.md`.
+
+## Installation BMAD complète (optionnel)
+
+Pour utiliser les workflows BMAD complets (PRD, epics, sprint-planning, etc.) :
+
+```bash
+npx bmad-method install
+```
+
+Cela crée `_bmad/` (agents, workflows) et complète `_bmad-output/`. **Nécessite Node.js.**
+
+## Ressources
+
+- [Documentation BMAD](https://docs.bmad-method.org/)
+- [Workflow Map](https://docs.bmad-method.org/reference/workflow-map/)
+- [Project Context](https://docs.bmad-method.org/how-to/project-context/)

+ 149 - 0
_bmad-output/DEVuserfeature/CHOIX.md

@@ -0,0 +1,149 @@
+# Choix — Gestion des utilisateurs (chat privé)
+
+**Date** : 2025-03-03  
+**Contexte** : Chatbot RAG documentaire sur le wiki Intersel
+
+---
+
+## 1. Accès au chat : **Privé**
+
+Le chat n’est accessible qu’aux utilisateurs **authentifiés**.
+
+---
+
+## 2. Authentification : **Comptes wiki**
+
+Seuls les utilisateurs ayant un compte sur le **wiki Intersel** (Dokuwiki) peuvent accéder au chatbot.
+
+- **Source de vérité** : le wiki (https://wiki.intersel.fr)
+- **Identifiant utilisateur** : le `username` du wiki (ex. `augustin_podvin`)
+
+**Justification** : le RAG indexe le wiki ; les utilisateurs autorisés sont ceux qui ont déjà accès au wiki.
+
+---
+
+### 2.1 Option privilégiée : **Cookie ou jeton du wiki**
+
+Objectif : éviter de redemander login/mot de passe. Si l’utilisateur est déjà connecté au wiki, il accède au chatbot sans ressaisir ses identifiants.
+
+| Scénario | Domaine wiki | Domaine chatbot | Faisabilité |
+|----------|--------------|-----------------|-------------|
+| **A. Même domaine** | wiki.intersel.fr | wiki.intersel.fr/chat | ✅ Le cookie Dokuwiki est envoyé au chatbot. On peut vérifier la session. |
+| **B. Sous-domaines** | wiki.intersel.fr | chat.intersel.fr | ⚠️ Cookie non partagé par défaut. Nécessite config cookie sur `.intersel.fr` (plugin ou config Dokuwiki). |
+| **C. Domaines différents** | wiki.intersel.fr | localhost ou autre | ❌ Cookie non partagé. Il faut un **jeton** passé par URL. |
+
+**Mécanismes possibles :**
+
+1. **Cookie du wiki (scénario A ou B)**  
+   - Le chatbot reçoit le cookie de session Dokuwiki.  
+   - On appelle une page protégée du wiki (ex. `/doku.php`) avec ce cookie pour vérifier l’identité et récupérer le `username`.  
+   - Si OK → on crée une session Flask côté chatbot.
+
+2. **Jeton passé par URL (scénario C ou lien depuis le wiki)**  
+   - Sur le wiki : lien « Accéder au chatbot » qui redirige vers `https://chatbot.../login?token=xxx`.  
+   - Le token est généré par un script/plugin sur le wiki (secret partagé, usage unique, courte durée).  
+   - Le chatbot valide le token et crée sa session.
+
+3. **Fallback : formulaire login**  
+   - Si pas de cookie/ token valide : formulaire classique username + password, validation via `login_to_wiki()`.
+
+---
+
+### 2.2 Cookie PHP du wiki — fonctionnement détaillé
+
+Dokuwiki utilise des cookies PHP pour la session (observés sur wiki.intersel.fr) :
+
+| Cookie | Rôle | Attributs |
+|--------|------|------------|
+| **DW<hash>** (ex. `DW68700bfd16c2027d...`) | Authentification : contient username + mot de passe chiffrés (Blowfish). Expire en 1 an ou à la fermeture du navigateur. | HttpOnly, Secure, SameSite=Lax |
+| **DokuWiki** | Identifiant de session PHP (données temporaires, protection CSRF). Valeur ex. `ak9rpcmh4nt0mksfv5nj2u3l4e`. | HttpOnly, Secure, Session |
+| **FCK_NmSp_acl** | ACL / permissions (même valeur que DokuWiki ou lié). Optionnel pour l’auth. | HttpOnly, Secure |
+
+**Condition** : le chatbot doit être sur le **même domaine** que le wiki (ex. `wiki.intersel.fr/chat`) pour que le navigateur envoie ces cookies au serveur du chatbot. Les cookies HttpOnly ne sont pas lisibles en JavaScript ; le backend Flask les reçoit automatiquement dans le header `Cookie` des requêtes.
+
+**Flux de validation :**
+
+1. L’utilisateur ouvre `wiki.intersel.fr/chat` (chatbot servi via reverse proxy sur le même domaine).
+2. Le navigateur envoie les cookies `DW*` et `DokuWiki` avec la requête.
+3. Le chatbot (Flask) reçoit la requête avec le header `Cookie`.
+4. Pour valider : le chatbot fait une requête HTTP vers le wiki en **transmettant ce cookie**.
+5. Le wiki vérifie le cookie et renvoie la page (ou une API).
+6. Si la réponse indique « utilisateur connecté » → on extrait le `username` et on crée une session Flask.
+
+**Mise en œuvre côté wiki** (au choix) :
+
+- **Option simple** : requête GET vers `wiki.intersel.fr/doku.php` avec le cookie, puis parsing du HTML pour détecter le username (présence de « logout », lien profil, etc.).
+- **Option propre** : ajouter un script PHP sur le wiki (ex. `lib/exe/checkauth.php`) qui lit la session Dokuwiki et renvoie du JSON : `{"user": "augustin_podvin"}` ou `401` si non connecté.
+
+**Résumé** : oui, on peut s’appuyer sur le cookie PHP du wiki, à condition que le chatbot soit servi sur le même domaine (reverse proxy sur `wiki.intersel.fr/chat`).
+
+---
+
+## 3. Mémoire : **Par utilisateur**
+
+Chaque utilisateur a sa **propre mémoire** (Q/R persistées pour le RAG).
+
+- **Actuel** : mémoire globale partagée (`memory_chunks.json`, `faiss_memory_index.index`)
+- **Cible** : mémoire isolée par utilisateur
+
+**Options techniques** :
+- **A** : Fichiers séparés par user → `memory_chunks_{username}.json` + `faiss_memory_{username}.index`
+- **B** : Fichier unique avec champ `user_id` / `username` et filtrage à la lecture
+
+---
+
+## 4. Chats sauvegardés
+
+Les conversations sont **liées à l’utilisateur** et stockées en base (modèle `Chat` avec `user_id`).
+
+- **Identifiant** : `username` wiki (ou `user_id` si on garde une table `User` synchronisée)
+- **Routes** : `/api/save_chat`, `/api/user_chats` déjà présentes, à brancher sur l’auth wiki
+
+---
+
+## 5. Modèle utilisateur
+
+**Option A — Sans table User**  
+- Auth = validation wiki uniquement  
+- Identifiant = `username` wiki  
+- Chats et mémoire indexés par `username`
+
+**Option B — Table User synchronisée**  
+- À la 1ère connexion wiki réussie : création/mise à jour d’un `User` (email optionnel si le wiki l’expose)  
+- `user_id` = clé pour chats et mémoire  
+- Permet d’enrichir le profil plus tard (nom, email, etc.)
+
+---
+
+## 6. Sessions
+
+- **Flask sessions** (cookies sécurisés) ou **JWT**
+- Stockage côté client : cookie httpOnly (sessions) ou token (JWT)
+- Durée de session à définir (ex. 24 h, 7 jours)
+
+---
+
+## 7. Récapitulatif des impacts
+
+| Composant | Modification |
+|-----------|--------------|
+| `src/agent_ai/auth.py` | Réutiliser `login_to_wiki` pour l’auth utilisateur |
+| `src/api/routes.py` | Remplacer signup/signin par auth wiki ; sécuriser save_chat, user_chats |
+| `src/service/memory_service.py` | Mémoire par user (fichiers ou champ user) |
+| `src/service/qa_service.py` | Passer `user_id`/`username` pour la mémoire |
+| `src/api/qa_routes.py` | Exiger une session/token valide |
+| `src/templates/index.html` | Rediriger vers login si non connecté ; charger chats via API |
+| `src/templates/login.html` | Formulaire username + password wiki (pas email) |
+| `src/templates/register.html` | Supprimer ou remplacer par « Créer un compte sur le wiki » |
+
+---
+
+## 8. Points à trancher
+
+- [ ] **Déploiement** : chatbot sur même domaine que le wiki (A), sous-domaine (B) ou domaine différent (C) ?
+- [ ] **Auth wiki** : cookie (A/B) ou jeton URL (C) en priorité ?
+- [ ] Option A ou B pour le modèle utilisateur (sans/avec table User)
+- [ ] Option A ou B pour la mémoire (fichiers séparés vs fichier unique)
+- [ ] Sessions Flask vs JWT
+- [ ] Durée de session
+- [ ] Gestion du logout (invalidation session / token)

+ 11 - 0
_bmad-output/DEVuserfeature/README.md

@@ -0,0 +1,11 @@
+# DEVuserfeature — Gestion des utilisateurs
+
+Dossier de conception pour la fonctionnalité **chat privé** avec authentification wiki et mémoire par utilisateur.
+
+## Contenu
+
+- **CHOIX.md** — Décisions prises et options à trancher
+
+## Contexte
+
+Le chatbot RAG indexe le wiki Intersel. L’accès au chat est réservé aux utilisateurs connectés au wiki, avec une mémoire et des conversations propres à chaque utilisateur.

+ 29 - 0
_bmad-output/backlog.md

@@ -0,0 +1,29 @@
+# Backlog — Fonctionnalités à faire
+
+Liste des fonctionnalités prévues pour le projet Agent Docker (chatbot RAG).
+
+**Légende :** `[ ]` À faire | `[~]` En cours | `[x]` Fait | Priorité : P1 (haute) / P2 (moyenne) / P3 (basse)
+
+---
+
+## Fonctionnalités
+
+| Statut | Priorité | Fonctionnalité | Notes |
+|--------|----------|----------------|-------|
+| [ ] | P1 | *À compléter* | |
+| [ ] | P2 | *À compléter* | |
+| [ ] | P3 | *À compléter* | |
+| [ ] | P2 | **7) Bibliothèque de prompts et templates internes** | UX propre (pas un dossier Notion). Galerie de "cartes" par métier : Support, Sales, RH, Ops, Finance, IT. Chaque carte : champs à remplir (variables), exemple de résultat, docs recommandés associés. Favoris + "utilisés récemment". Effet : standardisation et montée en qualité. |
+| [ ] | P2 | **8) Mémoire et "profil utilisateur" contrôlés** | Personnalisation visible et maîtrisable. "Ce que je sais sur vous" (panneau) : rôle, équipe, produits, clients suivis. Bouton "Ne plus utiliser" / "Oublier". Indication claire quand la réponse utilise votre historique. Effet : confiance + conformité. |
+
+---
+
+## Idées / À prioriser
+
+- 
+- 
+- 
+
+---
+
+*Dernière mise à jour : 2025-03-03*

+ 138 - 0
_bmad-output/guidelines.md

@@ -0,0 +1,138 @@
+# Guidelines — UX, UI et bonnes pratiques
+
+Synthèse des règles de conception et d'expérience utilisateur pour le projet Agent Docker (chatbot RAG Intersel).
+
+---
+
+## 1. Design system
+
+### Palette (CSS custom properties) — Indigo chaleureux
+
+```css
+--primary:          #4f46e5   /* indigo 600 — boutons, liens, focus */
+--primary-hover:    #4338ca   /* indigo 700 — hover */
+--primary-light:    #eef2ff   /* indigo 50  — arrière-plan item actif */
+--header-bg:        #0f172a   /* slate 900 — header sombre */
+--bg:               #f8fafc   /* slate 50  — fond général */
+--sidebar-bg:       #f1f5f9   /* slate 100 — sidebar */
+--surface:          #ffffff   /* blanc — zones élevées (input, cards) */
+--border:           #e2e8f0   /* slate 200 — séparateurs */
+--text:             #1e293b   /* slate 800 — texte principal */
+--text-muted:       #64748b   /* slate 500 — texte secondaire */
+--bubble-user-bg:   #e0e7ff   /* indigo 100 — bulle utilisateur */
+--bubble-user-text: #3730a3   /* indigo 800 */
+--bubble-bot-bg:    #ffffff   /* blanc — bulle bot */
+--bubble-bot-text:  #334155   /* slate 700 */
+```
+
+Focus ring : `box-shadow: 0 0 0 3px rgba(79, 70, 229, 0.15);`
+
+### Dark mode (classe `body.dark`)
+
+```css
+--header-bg:        #020617   /* slate 950 */
+--bg:               #0f172a   /* slate 900 */
+--sidebar-bg:       #1e293b   /* slate 800 */
+--surface:          #1e293b
+--border:           #334155   /* slate 700 */
+--text:             #f1f5f9   /* slate 100 */
+--bubble-user-bg:   #3730a3   /* indigo 800 */
+--bubble-bot-bg:    #334155   /* slate 700 */
+```
+
+### Typographie
+
+- **Police principale** : Inter (Google Fonts), poids 400, 500, 600
+- **Taille de base** : 0.9375rem (~15px) pour les messages, 0.875rem pour les labels
+- **Line-height** : 1.5 à 1.6 pour la lisibilité
+
+### Composants réutilisables
+
+- **Boutons** : `border-radius: 9px` (forms) / `12px` (chat), padding 0.65rem 1rem
+- **Inputs** : `border-radius: 9px`, focus `box-shadow: 0 0 0 3px rgba(79,70,229,0.15)`
+- **Cards** : `border-radius: 12px`, `border: 1px solid #e2e8f0`, `box-shadow: 0 1px 4px rgba(0,0,0,0.05)`
+- **Badges** : `badge-ok` (vert f0fdf4/166534), `badge-warn` (jaune fefce8/854d0e), `badge-error` (rouge fef2f2/b91c1c)
+
+---
+
+## 2. UX — Expérience utilisateur
+
+### Chat
+
+- **Message max** : 2000 caractères (`CHAT_MAX_CHARS`) — afficher un compteur si pertinent
+- **Messages** : bulles alignées à droite (user) / gauche (bot), max-width 72%
+- **Avatars** : icônes FA (`fa-user` / `fa-robot`) dans un cercle coloré, 30×30px
+- **Typing indicator** : animation de 3 points pendant la génération de la réponse
+- **Message de bienvenue** : icône centrée, titre et description, ton professionnel
+- **Sources** : afficher les URLs/chunk_id des sources utilisées pour la réponse
+
+### Formulaires (login / register)
+
+- **Présentation** : card centrée, max-width 400–440px, `border-radius: 16px`
+- **Logo** : carré indigo 44×44px (`#4f46e5`) avec icône FA, en haut de la card
+- **Labels** : toujours associés aux champs, taille 0.8rem, couleur `#475569`
+- **Validation** : messages d'erreur/succès stylés (fond coloré + bordure), pas d'`alert()`
+- **Feedback** : désactiver les boutons pendant les requêtes
+- **Redirection post-login/register** : délai ~1.5-2s pour laisser lire le message
+
+### Accessibilité
+
+- `lang="fr"` sur `<html>`
+- `viewport` pour le responsive
+- États `:focus` visibles sur tous les éléments interactifs
+- Contraste suffisant sur tous les textes
+
+---
+
+## 3. UI — Interface
+
+### Cohérence entre les pages
+
+- Utiliser **Inter** et la palette ci-dessus partout
+- Icônes : **Font Awesome 6.5** (`fas fa-*`)
+- Header sombre (`#0f172a`) cohérent sur toutes les pages
+- Éviter les couleurs Bootstrap par défaut (`#007bff`) au profit de `--primary`
+
+### Responsive
+
+- Layout flex/column adapté mobile
+- `overflow-y: auto` sur la zone de messages
+- Cards formulaire en largeur maximale avec `max-width`
+
+### Dark mode (chat uniquement)
+
+- Classe `body.dark` gérée par JS + `localStorage`
+- Bouton toggle dans le header (icône lune/soleil)
+
+---
+
+## 4. Contraintes techniques (UX)
+
+| Limite | Valeur | Impact UX |
+|--------|--------|-----------|
+| Message chat max | 2000 caractères | Afficher limite ou compteur |
+| Taille payload | 16 Mo | Limite uploads fichiers |
+| URLs max (scraping) | 100 | Contexte limité pour les réponses |
+| Anti-spam | Message vide, répétition ≥50 car., URLs ≥5 | Messages d'erreur explicites |
+
+---
+
+## 5. Ton et contenu
+
+- **Langue** : français
+- **Ton** : professionnel, utile, factuel
+- **Erreurs** : messages clairs et actionnables (ex. « Message trop long. Max 2000 caractères. »)
+- **Réponses** : le bot doit citer les sources quand possible
+- **Pas d'`alert()`** : utiliser des blocs feedback stylés
+
+---
+
+## 6. Bonnes pratiques développement
+
+- **Templates** : Jinja2, structure cohérente (head, body, scripts)
+- **Styles** : CSS variables en `:root`, inline `<style>` dans les templates
+- **JS** : feedback immédiat (loading, erreur), désactivation du bouton pendant requête
+
+---
+
+*Dernière mise à jour : 2025-03-03*

+ 0 - 0
_bmad-output/implementation-artifacts/.gitkeep


+ 20 - 0
_bmad-output/planning-artifacts/README.md

@@ -0,0 +1,20 @@
+# Planning Artifacts (BMAD)
+
+Ce dossier contient les artefacts de planification du projet, alignés avec la méthode BMAD.
+
+## Documents existants
+
+| Document | Emplacement | Description |
+|----------|-------------|-------------|
+| **Architecture** | `../Documents/Architecture.md` | Flux de données, composants, démarrage |
+| **Choix techniques** | `../Documents/Choix_techniques.md` | Limites, constantes, paramètres |
+
+## Structure BMAD
+
+- **Phase 2 (Planning)** : PRD non formalisé — le projet est déjà en production
+- **Phase 3 (Solutioning)** : Architecture documentée dans `Documents/`
+- **Phase 4 (Implementation)** : `implementation-artifacts/` pour sprint-status, stories
+
+## Epics et Stories
+
+Pour les nouvelles fonctionnalités, créer des fichiers `epics/epic-XXX.md` et `story-YYY.md` selon le format BMAD.

+ 61 - 0
_bmad-output/project-context.md

@@ -0,0 +1,61 @@
+---
+project_name: 'Agent Docker - Chatbot RAG Intersel'
+user_name: 'Équipe Intersel'
+date: '2025-03-03'
+sections_completed: ['technology_stack', 'critical_rules', 'architecture_summary']
+---
+
+# Project Context for AI Agents
+
+Contexte technique pour les agents IA travaillant sur le projet Agent Docker (chatbot RAG documentaire).
+
+## Technology Stack & Versions
+
+- **Backend** : Python 3.x, Flask 3.1, Gunicorn 23
+- **Base de données** : PostgreSQL (SQLAlchemy 2.0, psycopg2)
+- **RAG / ML** : sentence-transformers (all-mpnet-base-v2), FAISS, LangChain, rank-bm25
+- **LLM** : API Scaleway (Mistral), modèle par défaut mistral-small-3.2-24b-instruct-2506
+- **Scraping** : requests, BeautifulSoup, authentification session (Dokuwiki)
+- **Tests** : pytest
+- **Conteneurisation** : Docker, Docker Compose
+
+## Critical Implementation Rules
+
+**Python / Flask :**
+- Structure : `src/` pour le code (app, api, service, agent_ai, utils, models)
+- Config via `config.py` et variables d'environnement (`.env`)
+- Routes API sous `src/api/` (qa_routes, file_routes, admin_routes, routes)
+- Services métier dans `src/service/` (state, qa_service, embedding_service, memory_service)
+
+**Données et indexation :**
+- Fichiers de données dans `data/` (racine) et `src/data/` (uploads, etc.)
+- Pipeline : scraping → raw_pages.json → chunking → All_chunks.json → FAISS index
+- Ne jamais hardcoder les chemins : utiliser `os.path.join(base_dir, 'data', ...)`
+
+**RAG / Recherche :**
+- Recherche hybride : FAISS (top 200) + BM25 + MMR (lambda 0.7) + cross-encoder (rerank)
+- Top final : 20 chunks envoyés au LLM
+- Modèle embedding : all-mpnet-base-v2 (cohérence requise partout)
+
+**Sécurité :**
+- Chaque question utilisateur passe par `_is_safe_query()` (LLM) avant traitement
+- Pas de données sensibles dans les logs ou réponses
+
+**Tests :**
+- Tests dans `tests/` (test_chunking, test_scraping, test_security, test_auth)
+- Lancer : `pytest tests/ -v`
+
+## Architecture Summary
+
+- **Scraping** : `src/agent_ai/scraping.py`, `auth.py` — crawl wiki Intersel, hash pour détection changements
+- **Chunking** : `src/agent_ai/chunking.py` — découpage sémantique par phrases avec overlap
+- **Pipeline** : `src/utils/processing.py` — orchestration scrape → chunks → embeddings → FAISS
+- **State** : `src/service/state.py` — chunks, index FAISS, modèle embedding, mémoire
+- **QA** : `src/service/qa_service.py` — hybrid_search, prompt, appel LLM Scaleway
+- **Mémoire** : `src/service/memory_service.py` — Q/R persistées dans index FAISS dédié
+
+## Documents de référence
+
+- `Documents/Architecture.md` — flux de données, composants
+- `Documents/Choix_techniques.md` — limites, constantes, paramètres (MAX_URLS_TO_SCRAPE=100, etc.)
+- `_bmad-output/guidelines.md` — UX, UI, design system, ton et contenu

+ 5 - 1
config.py

@@ -2,13 +2,17 @@ import os
 from dotenv import load_dotenv
 load_dotenv()
 
+# Variable globale DEBUG : 1 = mode debug (Flask debug, scraping limité à 15 URLs), 0 = production (pas de limite URLs)
+DEBUG = int(os.environ.get('DEBUG', '0')) == 1
+
+
 class Config:
     """Configuration de base pour l'application"""
     
     # Configuration Flask
     SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key-change-in-production'
     FLASK_ENV = os.environ.get('FLASK_ENV', 'production')
-    FLASK_DEBUG = os.environ.get('FLASK_DEBUG', 'false').lower() == 'true'
+    FLASK_DEBUG = os.environ.get('FLASK_DEBUG', 'false').lower() == 'true' or DEBUG
     FLASK_HOST = os.environ.get('FLASK_HOST', '0.0.0.0')
     FLASK_PORT = int(os.environ.get('FLASK_PORT', 5000))
     

+ 0 - 0
processing.py → old/processing.py


+ 424 - 142
src/agent_ai/scraping.py

@@ -1,197 +1,479 @@
-from bs4 import BeautifulSoup
-from src.agent_ai.auth import session
-from urllib.parse import urljoin, urlparse
-import time
-import hashlib
+"""
+Scraping du wiki Intersel via l'API JSON-RPC officielle DokuWiki.
+
+Utilise core.listPages (toutes les pages) et core.getPage (contenu wikitext).
+Authentification : core.login (WIKI_USERNAME, WIKI_PASSWORD).
+
+Prérequis DokuWiki : l'option "remote" doit être activée dans la configuration.
+Voir https://www.dokuwiki.org/config:remote
+
+Fallback : si l'API n'est pas disponible, utilise le scraping HTML classique.
+"""
+
+import os
 import json
+import hashlib
+import time
 import random
 from concurrent.futures import ThreadPoolExecutor, as_completed
-import os
+from urllib.parse import urljoin
+
+import requests
 
-base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))  
-data_dir = os.path.join(base_dir, 'data')
+from config import DEBUG
+
+base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+data_dir = os.path.join(base_dir, "data")
 
 BASE_URL = "https://wiki.intersel.fr/"
-VISITED = set()
+JSONRPC_URL = "https://wiki.intersel.fr/lib/exe/jsonrpc.php"
 
-# Nombre maximum d'URLs à scraper (crawl + fetch). Voir Documents/Choix_techniques.md.
-MAX_URLS_TO_SCRAPE = 15
+# Max URLs : env MAX_URLS (ex: 500), ou 15 si DEBUG, sinon pas de limite
+_max = os.getenv("MAX_URLS")
+MAX_URLS = int(_max) if _max and str(_max).isdigit() else (15 if DEBUG else None)
 
 USER_AGENTS = [
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
 ]
 
-def random_headers():
-    return {
-        "User-Agent": random.choice(USER_AGENTS)
-    }
-
-def hash_text(text):
-    return hashlib.md5(text.encode("utf-8")).hexdigest()
 
-def fetch_single_page(url, old_hashes):
+def _jsonrpc_call(method: str, params: dict | None = None, session: requests.Session | None = None) -> dict:
+    """
+    Appel JSON-RPC DokuWiki (format simplifié : POST /method avec params en body).
+    Retourne {"result": ...} ou {"error": {"code": ..., "message": ...}}.
+    """
+    sess = session or requests.Session()
+    url = f"{JSONRPC_URL}/{method}"
+    headers = {
+        "Content-Type": "application/json",
+        "User-Agent": random.choice(USER_AGENTS),
+    }
+    body = params if params is not None else {}
+    try:
+        resp = sess.post(url, json=body, headers=headers, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        return data
+    except Exception as e:
+        return {"error": {"code": -1, "message": str(e)}}
+
+
+def _page_id_to_url(page_id: str) -> str:
+    """Convertit un page_id DokuWiki en URL complète."""
+    if not page_id or page_id == "start":
+        return BASE_URL.rstrip("/")
+    return f"{BASE_URL}doku.php?id={page_id}"
+
+
+def _login_jsonrpc(session: requests.Session) -> bool:
+    """Authentification via core.login (déconseillé mais simple). Utilise les cookies pour les appels suivants."""
+    user = os.getenv("WIKI_USERNAME")
+    password = os.getenv("WIKI_PASSWORD")
+    if not user or not password:
+        return False
+    r = _jsonrpc_call("core.login", {"user": user, "pass": password}, session)
+    if "error" in r:
+        error_code = r["error"].get("code", -1)
+        if error_code != 0:  # 0 = succès, autre = erreur
+            print(f"❌ JSON-RPC login failed: {r['error'].get('message', r)}")
+            return False
+    if r.get("result"):
+        print("✅ JSON-RPC login OK")
+        return True
+    return False
+
+
+def _list_all_pages_via_api(session: requests.Session) -> list[dict]:
+    """
+    core.listPages avec namespace="" et depth=0 = toutes les pages du wiki.
+    Retourne une liste de {"id", "revision", "size", "title", "hash", ...}.
+    """
+    r = _jsonrpc_call("core.listPages", {"namespace": "", "depth": 0, "hash": True}, session)
+    if "error" in r:
+        error_code = r["error"].get("code", -1)
+        if error_code != 0:  # 0 = succès
+            print(f"⚠️ core.listPages failed: {r['error'].get('message', r)}")
+            return []
+    pages = r.get("result") or []
+    return pages
+
+
+def _get_page_content_via_api(page_id: str, session: requests.Session) -> str | None:
+    """core.getPage : retourne le wikitext de la page."""
+    r = _jsonrpc_call("core.getPage", {"page": page_id}, session)
+    if "error" in r:
+        error_code = r["error"].get("code", -1)
+        if error_code != 0:  # 0 = succès
+            return None
+    return r.get("result") or ""
+
+
+def _fetch_page(page_id: str, old_hashes: dict, cookies: dict) -> tuple[str, str | None, str | None]:
+    """Récupère une page via l'API avec session thread-safe. Retourne (page_id, text, hash)."""
+    # Créer une nouvelle session pour chaque thread (thread-safe)
+    session = requests.Session()
+    session.cookies.update(cookies)
+    session.headers.update({"User-Agent": random.choice(USER_AGENTS)})
+    
+    text = _get_page_content_via_api(page_id, session)
+    if text is None:
+        return page_id, None, None
+    
+    current_hash = hashlib.md5(text.encode("utf-8")).hexdigest()
+    url = _page_id_to_url(page_id)
+    
+    if old_hashes.get(url) != current_hash:
+        print(f"🆕 Modifiée : {page_id}")
+        return page_id, text, current_hash  # Retourner le texte seulement si modifié
+    else:
+        print(f"✅ Inchangée : {page_id}")
+        return page_id, None, current_hash  # Pas de texte si inchangée
+
+
+def _scrape_via_jsonrpc(session: requests.Session | None = None) -> tuple[list[dict], dict]:
+    """
+    Scraping complet via API JSON-RPC.
+    Si session fournie (avec cookies du login web), on l'utilise sans core.login.
+    """
+    sess = session or requests.Session()
+    sess.headers.setdefault("User-Agent", random.choice(USER_AGENTS))
+
+    if session is None:
+        if not _login_jsonrpc(sess):
+            return [], {"total_urls": 0, "pages_with_content": 0, "failed_urls": [], "mode": "jsonrpc", "error": "Login failed"}
+    else:
+        print("✅ Utilisation des cookies du login web pour l'API")
+
+    page_infos = _list_all_pages_via_api(sess)
+    if not page_infos:
+        return [], {"total_urls": 0, "pages_with_content": 0, "failed_urls": [], "mode": "jsonrpc", "error": "No pages from API"}
+
+    # Limiter si DEBUG
+    if MAX_URLS:
+        page_infos = page_infos[:MAX_URLS]
+        print(f"📋 Limite à {MAX_URLS} URLs")
+    print(f"📋 API : {len(page_infos)} pages à récupérer")
+
+    # Charger anciens hashes
+    hashes_path = os.path.join(data_dir, "page_hashes.json")
     try:
-        headers = random_headers()
-        edit_url = url + "&do=edit" if "?" in url else url + "?do=edit"
-        response = session.get(edit_url, headers=headers, timeout=10)
+        with open(hashes_path, "r", encoding="utf-8") as f:
+            old_hashes = json.load(f)
+    except FileNotFoundError:
+        old_hashes = {}
 
-        if response.status_code != 200:
-            return url, None, None
+    # Récupérer le contenu de chaque page (parallèle)
+    all_page_ids = [p["id"] for p in page_infos]
+    url_to_text = {}
+    new_hashes = {}
 
-        # Forcer l'encodage UTF-8 pour éviter les caractères bizarres
-        response.encoding = 'utf-8'
+    # Extraire les cookies de la session pour les passer aux threads
+    session_cookies = dict(sess.cookies)
 
-        if "text/html" not in response.headers.get("Content-Type", ""):
-            return url, None, None
+    with ThreadPoolExecutor(max_workers=3) as executor:
+        futures = {
+            executor.submit(_fetch_page, pid, old_hashes, session_cookies): pid
+            for pid in all_page_ids
+        }
+        for future in as_completed(futures):
+            page_id, text, h = future.result()
+            url = _page_id_to_url(page_id)
+            if text is not None:
+                url_to_text[url] = text
+            if h is not None:
+                new_hashes[url] = h
+
+    # Fusionner avec ancien contenu (pages inchangées)
+    raw_pages_path = os.path.join(data_dir, "raw_pages.json")
+    try:
+        with open(raw_pages_path, "r", encoding="utf-8") as f:
+            old_raw = {p["url"]: p["text"] for p in json.load(f)}
+    except FileNotFoundError:
+        old_raw = {}
+    for u, t in url_to_text.items():
+        old_raw[u] = t
+    all_urls = sorted(set(_page_id_to_url(pid) for pid in all_page_ids))
+    cleaned = {u: old_raw[u] for u in all_urls if u in old_raw}
 
-        soup = BeautifulSoup(response.text, "html.parser")
-        textarea = soup.find("textarea", {"name": "wikitext"})
+    failed = [u for u in all_urls if u not in cleaned]
 
-        if textarea:
-            raw_text = textarea.get_text(separator="\n").strip()
-            current_hash = hash_text(raw_text)
+    urls_path = os.path.join(data_dir, "urls.json")
+    with open(urls_path, "w", encoding="utf-8") as f:
+        json.dump(all_urls, f, ensure_ascii=False, indent=2)
+    with open(raw_pages_path, "w", encoding="utf-8") as f:
+        json.dump([{"url": u, "text": t} for u, t in cleaned.items()], f, ensure_ascii=False, indent=2)
+    with open(hashes_path, "w", encoding="utf-8") as f:
+        json.dump(new_hashes, f, ensure_ascii=False, indent=2)
 
-            if old_hashes.get(url) != current_hash:
-                print(f"🆕 Modifiée : {url}")
-                return url, raw_text, current_hash
-            else:
-                print(f"✅ Inchangée : {url}")
-        else:
-            print(f"⚠️ Pas de <textarea> pour {url}")
-    except Exception as e:
-        print(f"❌ Erreur pour {url}: {e}")
+    print(f"📄 {len(cleaned)} pages récupérées via JSON-RPC")
+    print(f"🔗 URLs enregistrées dans '{urls_path}'")
 
-    # 💡 Petite pause aléatoire
-    time.sleep(random.uniform(0.5, 2))
-    return url, None, None
+    pages_list = [{"url": u, "text": t} for u, t in cleaned.items()]
+    stats = {
+        "total_urls": len(all_page_ids),
+        "pages_with_content": len(cleaned),
+        "failed_urls": failed,
+        "mode": "jsonrpc",
+    }
+    return pages_list, stats
 
 
-def fetch_all_pages_content(urls, old_hashes):
-    url_texts = {}
-    new_hashes = {}
+# --- Fallback : scraping HTML (si API désactivée) ---
 
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        futures = [executor.submit(fetch_single_page, url, old_hashes) for url in urls]
+def _scrape_via_html() -> tuple[list[dict], dict]:
+    """Fallback : scraping HTML classique (do=edit, textarea)."""
+    from src.agent_ai.auth import session
+    from bs4 import BeautifulSoup
+    from urllib.parse import urljoin, urlparse
 
-        for future in as_completed(futures):
-            url, text, current_hash = future.result()
-            if text:
-                url_texts[url] = text
-                new_hashes[url] = current_hash
-            elif current_hash:
-                new_hashes[url] = current_hash
-
-    return url_texts, new_hashes
-
-def is_valid_wiki_url(url):
-    parsed = urlparse(url)
-    return (
-        parsed.netloc == "wiki.intersel.fr"
-        and "do=" not in parsed.query
-        and not url.endswith((".jpg", ".png", ".pdf", ".docx", ".xlsx"))
-        and "#" not in url
-    )
-
-def crawl_wiki(start_url, existing_urls):
-    visited = set(existing_urls)
-    to_visit = [start_url]
-
-    while to_visit and len(visited) < MAX_URLS_TO_SCRAPE:
-        current_url = to_visit.pop(0)
-        if current_url in visited:
-            continue
-
-        print(f"🔎 Visiting: {current_url}")
-        visited.add(current_url)
+    def is_valid_wiki_url(url):
+        parsed = urlparse(url)
+        return (
+            parsed.netloc == "wiki.intersel.fr"
+            and "do=" not in parsed.query
+            and "idx=" not in parsed.query
+            and not url.endswith((".jpg", ".png", ".pdf", ".docx", ".xlsx"))
+            and "#" not in url
+        )
 
+    def _fetch_index_page_links(index_url):
+        """Récupère les liens d'une page index : pages (id=) et sous-index (do=index&idx=)."""
+        content_urls, sub_index_urls = set(), set()
         try:
-            headers = random_headers()
-            response = session.get(current_url, headers=headers, timeout=10)
-            if response.status_code != 200:
-                continue
-
-            soup = BeautifulSoup(response.text, "html.parser")
-
+            resp = session.get(index_url, headers={"User-Agent": random.choice(USER_AGENTS)}, timeout=15)
+            if resp.status_code != 200:
+                return content_urls, sub_index_urls
+            soup = BeautifulSoup(resp.text, "html.parser")
             for link in soup.find_all("a", href=True):
-                absolute_url = urljoin(current_url, link["href"])
-                if is_valid_wiki_url(absolute_url) and absolute_url not in visited and absolute_url not in to_visit:
-                    to_visit.append(absolute_url)
-
-            time.sleep(random.uniform(1, 2))
+                abs_url = urljoin(index_url, link["href"])
+                if "wiki.intersel.fr" not in abs_url or "#" in abs_url:
+                    continue
+                parsed = urlparse(abs_url)
+                if "do=index" in parsed.query:
+                    sub_index_urls.add(abs_url)
+                elif "do=" not in parsed.query and "idx=" not in parsed.query and "id=" in parsed.query:
+                    content_urls.add(abs_url)
         except Exception as e:
-            print(f"❌ Error with {current_url}: {e}")
-
-    return list(visited)
-
+            print(f"⚠️ Index {index_url}: {e}")
+        return content_urls, sub_index_urls
+
+    def fetch_crawl_bfs_urls(max_pages=200):
+        """Crawl BFS depuis la homepage : suit tous les liens internes. Meilleure source (1239+ URLs)."""
+        base = BASE_URL.rstrip("/")
+        to_visit = [base, f"{base}/doku.php?id=start"]
+        visited = set()
+        content_urls = set()
+
+        while to_visit and len(visited) < max_pages:
+            url = to_visit.pop(0)
+            if url in visited:
+                continue
+            visited.add(url)
+            try:
+                r = session.get(url, headers={"User-Agent": random.choice(USER_AGENTS)}, timeout=10)
+                if r.status_code != 200:
+                    continue
+                soup = BeautifulSoup(r.text, "html.parser")
+                for link in soup.find_all("a", href=True):
+                    abs_url = urljoin(url, link["href"])
+                    if "wiki.intersel.fr" not in abs_url or "#" in abs_url:
+                        continue
+                    parsed = urlparse(abs_url)
+                    if "do=" in parsed.query or "idx=" in parsed.query:
+                        continue
+                    if "id=" in parsed.query or abs_url.rstrip("/") == base:
+                        clean = abs_url.split("&")[0].split("#")[0]
+                        if clean not in visited and clean not in to_visit:
+                            to_visit.append(clean)
+                        content_urls.add(clean)
+                content_urls.add(url.split("&")[0].split("#")[0])
+                time.sleep(random.uniform(0.15, 0.35))
+            except Exception as e:
+                pass
+
+        content_urls.add(base)
+
+        def norm(u):
+            u = u.split("#")[0].split("&")[0].rstrip("/")
+            if u.endswith("/doku.php") or u == base + "/":
+                return base
+            return u
+
+        urls = [norm(u) for u in content_urls if "wiki.intersel.fr" in u and "do=" not in u and "idx=" not in u]
+        # Filtrer et dédupliquer
+        urls = sorted(set(u for u in urls if is_valid_wiki_url(u)))
+        if urls:
+            print(f"📋 Crawl BFS : {len(urls)} URLs")
+        return urls
+
+    def fetch_sitemap_urls():
+        """Tente de récupérer les URLs depuis le sitemap (si activé)."""
+        import re
+        for sitemap_url in [
+            "https://wiki.intersel.fr/doku.php?sitemap=xml",
+            "https://wiki.intersel.fr/doku.php?do=sitemap",
+        ]:
+            try:
+                r = session.get(sitemap_url, headers={"User-Agent": random.choice(USER_AGENTS)}, timeout=10)
+                if r.status_code != 200:
+                    continue
+                text = r.text or ""
+                urls = []
+                if "<loc>" in text:
+                    found = re.findall(r"<loc>([^<]+)</loc>", text)
+                    urls = [u.strip() for u in found if "wiki.intersel.fr" in u and "do=" not in u and "idx=" not in u]
+                elif "doku.php?id=" in text:
+                    found = re.findall(r'https://wiki\.intersel\.fr/doku\.php\?id=[^"\'<>\s&]+', text)
+                    urls = [u.split("&")[0].rstrip(".,;:)") for u in found]
+                urls = list(dict.fromkeys(urls))
+                if urls:
+                    urls.insert(0, BASE_URL.rstrip("/"))
+                    urls = list(dict.fromkeys(urls))
+                    print(f"📋 Sitemap : {len(urls)} URLs")
+                    return urls
+            except Exception:
+                pass
+        return []
+
+    def fetch_index_urls():
+        """Parcourt l'index et les sous-index pour collecter toutes les URLs."""
+        base_index = "https://wiki.intersel.fr/doku.php?do=index"
+        all_content = set()
+        to_visit, visited = [base_index], set()
+        while to_visit:
+            url = to_visit.pop(0)
+            if url in visited:
+                continue
+            visited.add(url)
+            content, sub = _fetch_index_page_links(url)
+            all_content |= content
+            for s in sub:
+                if s not in visited and s not in to_visit:
+                    to_visit.append(s)
+            time.sleep(random.uniform(0.3, 0.6))
+        all_content.add(BASE_URL.rstrip("/"))
+        return list(all_content)
+
+    def _to_edit_url(url):
+        base = BASE_URL.rstrip("/")
+        if url == base or url == base + "/":
+            return f"{base}/doku.php?id=start&do=edit"
+        return url + ("&do=edit" if "?" in url else "?do=edit")
+
+    def fetch_page(url, old_hashes):
+        try:
+            edit_url = _to_edit_url(url)
+            r = session.get(edit_url, timeout=15)
+            if r.status_code != 200:
+                return url, None, None
+            soup = BeautifulSoup(r.text, "html.parser")
+            ta = soup.find("textarea", {"name": "wikitext"})
+            if ta:
+                text = ta.get_text(separator="\n").strip()
+                h = hashlib.md5(text.encode("utf-8")).hexdigest()
+                return url, text if old_hashes.get(url) != h else None, h
+        except Exception as e:
+            print(f"❌ {url}: {e}")
+        return url, None, None
 
-def scrape_pages():
-    start_url = "https://wiki.intersel.fr/"
     urls_path = os.path.join(data_dir, "urls.json")
     raw_pages_path = os.path.join(data_dir, "raw_pages.json")
     hashes_path = os.path.join(data_dir, "page_hashes.json")
 
-    # Charger anciens hashs
     try:
         with open(hashes_path, "r", encoding="utf-8") as f:
             old_hashes = json.load(f)
     except FileNotFoundError:
         old_hashes = {}
 
-    # Charger anciennes URLs
     try:
         with open(urls_path, "r", encoding="utf-8") as f:
-            urls = json.load(f)
-        print("✅ URLs chargées depuis urls.json")
+            existing = set(json.load(f))
     except FileNotFoundError:
-        print("🚀 Crawling initial du wiki")
-        urls = []
-
-    # Nouveau crawl (limité à MAX_URLS_TO_SCRAPE)
-    crawled_urls = crawl_wiki(start_url, urls)
-    all_urls = sorted(set(urls + crawled_urls))[:MAX_URLS_TO_SCRAPE]
-
-    print(f"🌐 Total URLs à vérifier (max {MAX_URLS_TO_SCRAPE}) : {len(all_urls)}")
-
-    # Scraping des pages
-    pages, new_hashes = fetch_all_pages_content(all_urls, old_hashes)
+        existing = set()
+
+    crawl_urls = fetch_crawl_bfs_urls(max_pages=200)
+    sitemap_urls = fetch_sitemap_urls() if not crawl_urls else []
+    index_urls = fetch_index_urls() if not (crawl_urls or sitemap_urls) else []
+    all_urls = sorted(existing | set(crawl_urls or sitemap_urls or index_urls) | {BASE_URL.rstrip("/")})
+    all_urls = [u for u in all_urls if is_valid_wiki_url(u)]
+    if MAX_URLS:
+        all_urls = all_urls[:MAX_URLS]
+    src = "crawl BFS" if crawl_urls else ("sitemap" if sitemap_urls else "index")
+    print(f"🌐 HTML fallback : {len(all_urls)} URLs ({src})")
+
+    url_to_text = {}
+    new_hashes = {}
+    for url in all_urls:
+        _, text, h = fetch_page(url, old_hashes)
+        if text:
+            url_to_text[url] = text
+        if h:
+            new_hashes[url] = h
+        time.sleep(random.uniform(0.3, 0.8))
 
-    # Charger anciens raw_pages
     try:
         with open(raw_pages_path, "r", encoding="utf-8") as f:
-            old_raw_pages = {p["url"]: p["text"] for p in json.load(f)}
+            old_raw = {p["url"]: p["text"] for p in json.load(f)}
     except FileNotFoundError:
-        old_raw_pages = {}
+        old_raw = {}
+    for u, t in url_to_text.items():
+        old_raw[u] = t
+    cleaned = {u: t for u, t in old_raw.items() if u in all_urls}
 
-    # Mettre à jour uniquement les pages modifiées
-    for url, text in pages.items():
-        old_raw_pages[url] = text
-
-    # Enlever les URLs qui n’existent plus (optionnel)
-    cleaned_raw_pages = {url: text for url, text in old_raw_pages.items() if url in all_urls}
-
-    # Sauvegarder le nouveau contenu
     with open(raw_pages_path, "w", encoding="utf-8") as f:
-        json.dump(
-            [{"url": url, "text": text} for url, text in cleaned_raw_pages.items()],
-            f, ensure_ascii=False, indent=2
-        )
-
+        json.dump([{"url": u, "text": t} for u, t in cleaned.items()], f, ensure_ascii=False, indent=2)
     with open(hashes_path, "w", encoding="utf-8") as f:
         json.dump(new_hashes, f, ensure_ascii=False, indent=2)
-
     with open(urls_path, "w", encoding="utf-8") as f:
         json.dump(all_urls, f, ensure_ascii=False, indent=2)
 
-    print("📄 Pages modifiées sauvegardées")
-    print(f"📄 Contenu brut mis à jour enregistré dans '{raw_pages_path}'")
-    print(f"🔗 URLs enregistrées dans '{urls_path}'")
-    print(f"🔐 Hashes des pages enregistrés dans '{hashes_path}'")
+    failed = [u for u in all_urls if u not in cleaned]
+    pages_list = [{"url": u, "text": t} for u, t in cleaned.items()]
+    stats = {"total_urls": len(all_urls), "pages_with_content": len(cleaned), "failed_urls": failed, "mode": "html"}
+    return pages_list, stats
 
-    pages_list = [{"url": url, "text": text} for url, text in cleaned_raw_pages.items()]
-    failed_urls = [u for u in all_urls if u not in cleaned_raw_pages]
-    stats = {
-        "total_urls": len(all_urls),
-        "pages_with_content": len(cleaned_raw_pages),
-        "failed_urls": failed_urls,
-    }
-    return pages_list, stats
+
+def _is_api_available(session: requests.Session | None = None) -> bool:
+    """Test disponibilité de l'API JSON-RPC. Option: session avec cookies (après login web)."""
+    sess = session or requests.Session()
+    url = f"{JSONRPC_URL}/core.getAPIVersion"
+    try:
+        r = sess.post(
+            url,
+            json={},
+            headers={"Content-Type": "application/json", "User-Agent": random.choice(USER_AGENTS)},
+            timeout=5,
+        )
+        data = r.json() if r.text else {}
+        ok = r.status_code == 200 and "result" in data
+        if not ok:
+            print(f"   → API: status={r.status_code}, response={str(data)[:80]}...")
+        return ok
+    except Exception as e:
+        print(f"   → API indisponible: {e}")
+        return False
+
+
+def scrape_pages() -> tuple[list[dict], dict]:
+    """
+    Point d'entrée principal. Essaie d'abord l'API JSON-RPC, puis fallback HTML.
+    Stratégie : login web d'abord, puis test API avec les cookies (fonctionne même si remote
+    exige une session valide). Sinon fallback HTML avec parcours des sous-index.
+    """
+    from src.agent_ai.auth import session as auth_session
+    from src.service.auth_service import auto_login
+
+    auto_login()  # Toujours login web (pour fallback ou pour cookies API)
+
+    # 1. Tester l'API avec la session authentifiée (cookies du login web)
+    if _is_api_available(auth_session):
+        pages_list, stats = _scrape_via_jsonrpc(session=auth_session)
+        if not stats.get("error"):
+            return pages_list, stats
+        print(f"⚠️ API error, fallback HTML: {stats.get('error')}")
+    else:
+        print("⚠️ API non disponible, fallback HTML")
+
+    # 2. Fallback : scraping HTML avec parcours des sous-index
+    return _scrape_via_html()

+ 253 - 0
src/agent_ai/scraping_OLD.py

@@ -0,0 +1,253 @@
+from bs4 import BeautifulSoup
+from src.agent_ai.auth import session
+from urllib.parse import urljoin, urlparse
+import time
+import hashlib
+import json
+import random
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import os
+
+from config import DEBUG
+
+base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))  
+data_dir = os.path.join(base_dir, 'data')
+
+BASE_URL = "https://wiki.intersel.fr/"
+VISITED = set()
+
+# DEBUG=1 : max 15 URLs. DEBUG=0 : pas de limite.
+MAX_URLS_TO_SCRAPE = 15 if DEBUG else None
+
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
+]
+
+def random_headers():
+    return {
+        "User-Agent": random.choice(USER_AGENTS)
+    }
+
+def hash_text(text):
+    return hashlib.md5(text.encode("utf-8")).hexdigest()
+
+def _to_edit_url(url: str) -> str:
+    """Construit l'URL d'édition DokuWiki (?do=edit)."""
+    base = BASE_URL.rstrip("/")
+    if url == base or url == base + "/":
+        return f"{base}/doku.php?id=start&do=edit"  # Page d'accueil
+    return url + ("&do=edit" if "?" in url else "?do=edit")
+
+
+def fetch_single_page(url, old_hashes):
+    try:
+        headers = random_headers()
+        edit_url = _to_edit_url(url)
+        response = session.get(edit_url, headers=headers, timeout=15)
+
+        if response.status_code != 200:
+            return url, None, None
+
+        # Forcer l'encodage UTF-8 pour éviter les caractères bizarres
+        response.encoding = 'utf-8'
+
+        if "text/html" not in response.headers.get("Content-Type", ""):
+            return url, None, None
+
+        soup = BeautifulSoup(response.text, "html.parser")
+        textarea = soup.find("textarea", {"name": "wikitext"})
+
+        if textarea:
+            raw_text = textarea.get_text(separator="\n").strip()
+            current_hash = hash_text(raw_text)
+
+            if old_hashes.get(url) != current_hash:
+                print(f"🆕 Modifiée : {url}")
+                return url, raw_text, current_hash
+            else:
+                print(f"✅ Inchangée : {url}")
+        else:
+            print(f"⚠️ Pas de <textarea> pour {url}")
+    except Exception as e:
+        print(f"❌ Erreur pour {url}: {e}")
+
+    # 💡 Petite pause aléatoire
+    time.sleep(random.uniform(0.5, 2))
+    return url, None, None
+
+
+def fetch_all_pages_content(urls, old_hashes):
+    url_texts = {}
+    new_hashes = {}
+
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        futures = [executor.submit(fetch_single_page, url, old_hashes) for url in urls]
+
+        for i, future in enumerate(as_completed(futures), 1):
+            url, text, current_hash = future.result()
+            if text:
+                url_texts[url] = text
+            if current_hash:
+                new_hashes[url] = current_hash
+            if i % 5 == 0 or i == len(urls):
+                print(f"   Progression: {i}/{len(urls)} pages traitées")
+
+    return url_texts, new_hashes
+
+def is_valid_wiki_url(url):
+    """Exclut les URLs d'index (idx=), login (do=), et fichiers binaires."""
+    parsed = urlparse(url)
+    return (
+        parsed.netloc == "wiki.intersel.fr"
+        and "do=" not in parsed.query
+        and "idx=" not in parsed.query  # vues index/sitemap, pas des pages éditables
+        and not url.endswith((".jpg", ".png", ".pdf", ".docx", ".xlsx"))
+        and "#" not in url
+    )
+
+
+def fetch_index_urls():
+    """
+    Récupère les URLs depuis la page index/sitemap de DokuWiki (do=index).
+    Permet d'obtenir bien plus que les 15 URLs du crawl BFS depuis la homepage.
+    """
+    index_url = "https://wiki.intersel.fr/doku.php?do=index"
+    urls = set()
+    try:
+        print("📋 Récupération de l'index DokuWiki (sitemap)...")
+        response = session.get(index_url, headers=random_headers(), timeout=15)
+        if response.status_code != 200:
+            print(f"⚠️ Index non accessible (status {response.status_code})")
+            return []
+        response.encoding = "utf-8"
+        soup = BeautifulSoup(response.text, "html.parser")
+        for link in soup.find_all("a", href=True):
+            absolute_url = urljoin(index_url, link["href"])
+            if is_valid_wiki_url(absolute_url):
+                urls.add(absolute_url)
+        print(f"📋 Index : {len(urls)} URLs trouvées")
+        time.sleep(random.uniform(1, 2))
+    except Exception as e:
+        print(f"⚠️ Erreur récupération index : {e}")
+    return list(urls)
+
+
+def crawl_wiki(start_url, existing_urls):
+    visited = set(existing_urls)
+    to_visit = [start_url]
+    max_pages = MAX_URLS_TO_SCRAPE if MAX_URLS_TO_SCRAPE else 10**6  # pas de limite en prod
+
+    while to_visit and len(visited) < max_pages:
+        current_url = to_visit.pop(0)
+        if current_url in visited:
+            continue
+
+        print(f"🔎 Visiting: {current_url}")
+        visited.add(current_url)
+
+        try:
+            headers = random_headers()
+            response = session.get(current_url, headers=headers, timeout=10)
+            if response.status_code != 200:
+                continue
+
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            for link in soup.find_all("a", href=True):
+                absolute_url = urljoin(current_url, link["href"])
+                if is_valid_wiki_url(absolute_url) and absolute_url not in visited and absolute_url not in to_visit:
+                    to_visit.append(absolute_url)
+
+            time.sleep(random.uniform(1, 2))
+        except Exception as e:
+            print(f"❌ Error with {current_url}: {e}")
+
+    return list(visited)
+
+
+def scrape_pages():
+    start_url = "https://wiki.intersel.fr/"
+    urls_path = os.path.join(data_dir, "urls.json")
+    raw_pages_path = os.path.join(data_dir, "raw_pages.json")
+    hashes_path = os.path.join(data_dir, "page_hashes.json")
+
+    # Charger anciens hashs
+    try:
+        with open(hashes_path, "r", encoding="utf-8") as f:
+            old_hashes = json.load(f)
+    except FileNotFoundError:
+        old_hashes = {}
+
+    # Charger anciennes URLs
+    try:
+        with open(urls_path, "r", encoding="utf-8") as f:
+            urls = json.load(f)
+        print("✅ URLs chargées depuis urls.json")
+    except FileNotFoundError:
+        print("🚀 Crawling initial du wiki")
+        urls = []
+
+    # 1. Récupérer les URLs depuis l'index DokuWiki (sitemap) pour avoir bien plus que 15
+    index_urls = fetch_index_urls()
+    if index_urls:
+        combined = set(urls) | set(index_urls) | {start_url}
+        all_urls = sorted(combined)[:MAX_URLS_TO_SCRAPE] if MAX_URLS_TO_SCRAPE else sorted(combined)
+        print(f"📋 Utilisation de l'index : {len(all_urls)} URLs au total")
+    else:
+        # 2. Fallback : crawl BFS classique si l'index est vide ou inaccessible
+        crawled_urls = crawl_wiki(start_url, urls)
+        all_urls = sorted(set(urls + crawled_urls))[:MAX_URLS_TO_SCRAPE] if MAX_URLS_TO_SCRAPE else sorted(set(urls + crawled_urls))
+
+    # Exclure les URLs idx= / do= (vues index, non éditables) même si déjà dans urls.json
+    before = len(all_urls)
+    all_urls = [u for u in all_urls if is_valid_wiki_url(u)]
+    if MAX_URLS_TO_SCRAPE:
+        all_urls = all_urls[:MAX_URLS_TO_SCRAPE]
+    if before > len(all_urls):
+        print(f"🔧 {before - len(all_urls)} URLs idx= exclues (vues index non éditables)")
+    limit_msg = f"max {MAX_URLS_TO_SCRAPE}" if MAX_URLS_TO_SCRAPE else "pas de limite"
+    print(f"🌐 Total URLs à vérifier ({limit_msg}) : {len(all_urls)}")
+
+    # Scraping des pages
+    pages, new_hashes = fetch_all_pages_content(all_urls, old_hashes)
+
+    # Charger anciens raw_pages
+    try:
+        with open(raw_pages_path, "r", encoding="utf-8") as f:
+            old_raw_pages = {p["url"]: p["text"] for p in json.load(f)}
+    except FileNotFoundError:
+        old_raw_pages = {}
+
+    # Mettre à jour uniquement les pages modifiées
+    for url, text in pages.items():
+        old_raw_pages[url] = text
+
+    # Enlever les URLs qui n’existent plus (optionnel)
+    cleaned_raw_pages = {url: text for url, text in old_raw_pages.items() if url in all_urls}
+
+    # Sauvegarder le nouveau contenu
+    with open(raw_pages_path, "w", encoding="utf-8") as f:
+        json.dump(
+            [{"url": url, "text": text} for url, text in cleaned_raw_pages.items()],
+            f, ensure_ascii=False, indent=2
+        )
+
+    with open(hashes_path, "w", encoding="utf-8") as f:
+        json.dump(new_hashes, f, ensure_ascii=False, indent=2)
+
+    with open(urls_path, "w", encoding="utf-8") as f:
+        json.dump(all_urls, f, ensure_ascii=False, indent=2)
+
+    print("📄 Pages modifiées sauvegardées")
+    print(f"📄 Contenu brut mis à jour enregistré dans '{raw_pages_path}'")
+    print(f"🔗 URLs enregistrées dans '{urls_path}'")
+    print(f"🔐 Hashes des pages enregistrés dans '{hashes_path}'")
+
+    pages_list = [{"url": url, "text": text} for url, text in cleaned_raw_pages.items()]
+    failed_urls = [u for u in all_urls if u not in cleaned_raw_pages]
+    stats = {
+        "total_urls": len(all_urls),
+        "pages_with_content": len(cleaned_raw_pages),
+        "failed_urls": failed_urls,
+    }
+    return pages_list, stats

+ 7 - 0
src/api/admin_routes.py

@@ -14,19 +14,25 @@ def trigger_indexation():
     Déclenche manuellement le pipeline d'indexation.
     Recharge le state après exécution.
     """
+    logger.info("📥 Requête POST /api/trigger-indexation reçue")
+    print("📥 Indexation demandée – démarrage du pipeline…", flush=True)
+
     if update_lock.locked():
+        print("⚠️ Indexation déjà en cours – requête ignorée", flush=True)
         return jsonify({
             "error": "Une indexation est déjà en cours.",
             "status": "running",
         }), 409
 
     try:
+        print("🔄 Scraping du wiki + chunking + embeddings en cours… (peut prendre plusieurs minutes)", flush=True)
         result = full_update_pipeline()
 
         # Recharger le state dans l'app
         from src.service.state import state, load_chunks_and_index
         state["all_chunks"], state["index"] = load_chunks_and_index()
 
+        print(f"✅ Indexation terminée en {result.get('duration_seconds', 0):.1f}s – {result.get('chunk_count', 0)} chunks", flush=True)
         return jsonify({
             "status": "success",
             "mode": result.get("mode"),
@@ -37,6 +43,7 @@ def trigger_indexation():
         }), 200
     except Exception as e:
         logger.exception("Erreur lors du trigger indexation: %s", e)
+        print(f"❌ Erreur indexation: {e}", flush=True)
         return jsonify({
             "status": "error",
             "error": str(e),

+ 48 - 5
src/api/qa_routes.py

@@ -1,11 +1,9 @@
 # qa_routes.py
-from flask import Blueprint, request, jsonify, current_app
-from src.service.qa_service import process_question
-import time
-import hashlib
+import json
+from flask import Blueprint, request, jsonify, current_app, Response, stream_with_context
+from src.service.qa_service import process_question, process_question_stream
 import re
 import logging
-import json
 import os
 
 logger = logging.getLogger(__name__)
@@ -71,3 +69,48 @@ def qa_chain():
         logger.exception("Erreur lors du traitement de /qa_chain")
         return jsonify({"error": "Erreur interne serveur"}), 500
 
+
+def _stream_events(question):
+    """Générateur SSE : envoie des lignes data: {...} pour le stream de la réponse IA."""
+    try:
+        for event in process_question_stream(question):
+            payload = json.dumps(event, ensure_ascii=False)
+            yield f"data: {payload}\n\n"
+    except Exception as e:
+        logger.exception("Erreur dans le stream QA")
+        yield f"data: {json.dumps({'type': 'error', 'message': str(e)}, ensure_ascii=False)}\n\n"
+
+
+@qa_blueprint.route('/qa_chain/stream', methods=['POST'])
+def qa_chain_stream():
+    """Route streaming : retourne la réponse de l'IA en Server-Sent Events (SSE)."""
+    if not request.is_json:
+        return jsonify({"error": "Payload JSON requis."}), 400
+
+    data = request.get_json(silent=True)
+    if data is None:
+        return jsonify({"error": "JSON invalide."}), 400
+
+    question = data.get("query", "").strip()
+    if not isinstance(question, str):
+        return jsonify({"error": "Le champ 'query' doit être une chaîne."}), 400
+
+    max_chars = current_app.config.get("CHAT_MAX_CHARS", 1000)
+    if len(question) > max_chars:
+        return jsonify({"error": f"Message trop long. Max {max_chars} caractères."}), 400
+
+    if _is_spammy(question):
+        client_ip = request.headers.get("X-Forwarded-For", request.remote_addr)
+        logger.warning("Spam détecté depuis %s : %s", client_ip, question[:200])
+        return jsonify({"error": "Message suspect rejeté."}), 400
+
+    return Response(
+        stream_with_context(_stream_events(question)),
+        mimetype="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+            "Connection": "keep-alive",
+        },
+    )
+

+ 73 - 29
src/app.py

@@ -15,6 +15,7 @@ from src.api.admin_routes import admin_blueprint
 from src.service.auth_service import auto_login
 from src.api.routes import main
 from src.models import db
+from config import DEBUG
 
 load_dotenv(override=True)
 
@@ -35,6 +36,11 @@ def create_app():
     app.config["CHAT_MAX_CHARS"] = 2000
     app.config.from_object('config.Config')
 
+    # En mode debug (DEBUG=1) : recharger les templates à chaque requête (F5 suffit, pas besoin de relancer l'app)
+    if DEBUG:
+        app.config["DEBUG"] = True
+        app.config["TEMPLATES_AUTO_RELOAD"] = True
+
 
     
 
@@ -74,33 +80,41 @@ def create_app():
     @app.route("/api/dashboard", methods=["GET"])
     def dashboard():
         """Données agrégées pour la page Développeur (monitoring)."""
-        pipeline = get_pipeline_status()
-        return jsonify({
-            "health": {
-                "ready": pipeline.get("ready", False),
-                "chunk_count": pipeline.get("chunk_count", 0),
-                "message": "Application prête" if pipeline.get("ready") else "Indexation requise",
-            },
-            "pipeline": {
-                "last_run": pipeline.get("last_run"),
-                "duration_seconds": pipeline.get("duration_seconds"),
-                "mode": pipeline.get("mode"),
-                "error": pipeline.get("error"),
-                "scraping_stats": pipeline.get("scraping_stats"),
-            },
-            "memory": {
-                "entries_count": len(state.get("memory_chunks", [])),
-            },
-            "chat": {
-                "history_count": len(state.get("chat_history", [])),
-            },
-            "config": {
-                "scw_api_set": bool(os.getenv("SCW_API_KEY")),
-                "wiki_username_set": bool(os.getenv("WIKI_USERNAME")),
-                "wiki_password_set": bool(os.getenv("WIKI_PASSWORD")),
-            },
-            "scaleway_billing": get_scaleway_consumption() or {},
-        }), 200
+        logger.info("GET /api/dashboard demandé")
+        try:
+            pipeline = get_pipeline_status()
+            # Timeout court pour le dashboard pour ne pas bloquer l'affichage
+            billing = get_scaleway_consumption(timeout=3) or {}
+            return jsonify({
+                "health": {
+                    "ready": pipeline.get("ready", False),
+                    "chunk_count": pipeline.get("chunk_count", 0),
+                    "message": "Application prête" if pipeline.get("ready") else "Indexation requise",
+                },
+                "pipeline": {
+                    "last_run": pipeline.get("last_run"),
+                    "duration_seconds": pipeline.get("duration_seconds"),
+                    "mode": pipeline.get("mode"),
+                    "error": pipeline.get("error"),
+                    "scraping_stats": pipeline.get("scraping_stats"),
+                },
+                "memory": {
+                    "entries_count": len(state.get("memory_chunks", [])),
+                },
+                "chat": {
+                    "history_count": len(state.get("chat_history", [])),
+                },
+                "config": {
+                    "debug": DEBUG,
+                    "scw_api_set": bool(os.getenv("SCW_API_KEY")),
+                    "wiki_username_set": bool(os.getenv("WIKI_USERNAME")),
+                    "wiki_password_set": bool(os.getenv("WIKI_PASSWORD")),
+                },
+                "scaleway_billing": billing,
+            }), 200
+        except Exception as e:
+            logger.exception("Erreur dans /api/dashboard: %s", e)
+            return jsonify({"error": str(e)}), 500
 
     # Routes
     @app.route("/")
@@ -109,7 +123,37 @@ def create_app():
 
     @app.route("/developpeur")
     def developpeur():
-        return render_template("developpeur.html")
+        """Page monitoring : données rendues côté serveur pour affichage immédiat (sans fetch)."""
+        try:
+            pipeline = get_pipeline_status()
+            billing = get_scaleway_consumption(timeout=3) or {}
+            dashboard = {
+                "health": {
+                    "ready": pipeline.get("ready", False),
+                    "chunk_count": pipeline.get("chunk_count", 0),
+                    "message": "Application prête" if pipeline.get("ready") else "Indexation requise",
+                },
+                "pipeline": {
+                    "last_run": pipeline.get("last_run"),
+                    "duration_seconds": pipeline.get("duration_seconds"),
+                    "mode": pipeline.get("mode"),
+                    "error": pipeline.get("error"),
+                    "scraping_stats": pipeline.get("scraping_stats"),
+                },
+                "memory": {"entries_count": len(state.get("memory_chunks", []))},
+                "chat": {"history_count": len(state.get("chat_history", []))},
+                "config": {
+                    "debug": DEBUG,
+                    "scw_api_set": bool(os.getenv("SCW_API_KEY")),
+                    "wiki_username_set": bool(os.getenv("WIKI_USERNAME")),
+                    "wiki_password_set": bool(os.getenv("WIKI_PASSWORD")),
+                },
+                "scaleway_billing": billing,
+            }
+        except Exception as e:
+            logger.exception("Erreur préparation dashboard pour /developpeur: %s", e)
+            dashboard = None
+        return render_template("developpeur.html", dashboard=dashboard)
 
     @app.route("/register")
     def register():
@@ -151,4 +195,4 @@ if __name__ == "__main__":
     logger.info("Scheduler started (runs every 24h)")
     logger.info("Application started")
 
-    app.run(host="0.0.0.0", port=5000, debug=True)
+    app.run(host="0.0.0.0", port=5000, debug=DEBUG)

+ 201 - 1
src/service/qa_service.py

@@ -17,7 +17,7 @@ from sklearn.metrics.pairwise import cosine_similarity
 
 from src.service.embedding_service import hybrid_search
 from src.service.memory_service import retrieve_relevant_memory, save_memory_entry
-from .state import state
+from .state import state, save_chat_history_to_file
 
 
 # Configure logging
@@ -150,6 +150,47 @@ def call_scaleway_llama3(
     return "Erreur inconnue lors de l'appel au modèle."
 
 
+def call_scaleway_llama3_stream(
+    prompt: str,
+    model: Optional[str] = None,
+    temperature: float = 0.15,
+    top_p: float = 1.0,
+    max_tokens: int = 512,
+    presence_penalty: float = 0.0,
+):
+    """
+    Appelle le LLM Scaleway en mode stream ; génère les fragments de texte au fur et à mesure.
+    Yields: str (fragments de contenu)
+    """
+    if not scw_client:
+        logger.error("SCW_API_KEY is not set; cannot call Scaleway API.")
+        yield "Erreur : clé API Scaleway manquante."
+        return
+
+    model = model or SCW_MODEL
+    try:
+        stream = scw_client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "Tu es un assistant documentaire. Réponds de manière factuelle en français."},
+                {"role": "user", "content": prompt},
+            ],
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            presence_penalty=presence_penalty,
+            stream=True,
+        )
+        for chunk in stream:
+            if chunk.choices and len(chunk.choices) > 0:
+                delta = chunk.choices[0].delta
+                if delta and getattr(delta, "content", None):
+                    yield delta.content
+    except Exception as e:
+        logger.exception("Exception during Scaleway API stream call")
+        yield f"\n\nErreur : Impossible d'obtenir une réponse du modèle ({str(e)[:100]})."
+
+
 # --- Security check using LLM ---
 def _is_safe_query(query: str) -> bool:
     """
@@ -335,6 +376,7 @@ def process_question(question: str) -> Tuple[Dict[str, Any], int]:
         # --- Save to chat history and memory ---
         chat_entry = {"query": corrected_question, "answer": answer, "topic": topic}
         state.setdefault("chat_history", []).append(chat_entry)
+        save_chat_history_to_file()
 
         try:
             save_memory_entry(question, answer, topic=topic)
@@ -378,6 +420,7 @@ def process_question(question: str) -> Tuple[Dict[str, Any], int]:
             fallback_answer = call_scaleway_llama3(fallback_prompt).strip()
             fallback_entry = {"query": question, "answer": fallback_answer, "sources": ["Google Search"]}
             state.setdefault("chat_history", []).append(fallback_entry)
+            save_chat_history_to_file()
 
             interaction["answer"] = fallback_answer
             interaction["sources"] = ["Google Search"]
@@ -387,3 +430,160 @@ def process_question(question: str) -> Tuple[Dict[str, Any], int]:
         except Exception as fallback_error:
             logger.error(f"Fallback SerpAPI error: {fallback_error}")
             return {"error": f"Erreur SerpAPI : {str(fallback_error)}"}, 500
+
+
+# --- Streaming QA pipeline (génère des événements pour SSE) ---
+def process_question_stream(question: str):
+    """
+    Même logique que process_question mais stream la réponse du LLM.
+    Yields: dict avec "type" ("start" | "chunk" | "done" | "error") et champs associés.
+    """
+    if not question.strip():
+        yield {"type": "error", "message": "Question vide."}
+        return
+
+    corrected_question = quote_keywords(question)
+    start_time = time.time()
+    interaction = {
+        "question": question,
+        "corrected_question": corrected_question,
+        "timestamp": datetime.now().isoformat(),
+        "steps": [{"step": "init", "details": "Initial interaction setup"}],
+        "latency": None,
+        "tokens_usage": {"input": 0, "output": 0},
+        "answer": "",
+        "sources": [],
+        "no_answer_reason": None,
+    }
+
+    topic = detect_topic_smart(corrected_question)
+    state["current_topic"] = topic
+    interaction["steps"].append({"step": "topic_detection", "details": f"Topic detected: {topic}"})
+
+    memory_contexts = []
+    all_memory = retrieve_relevant_memory(corrected_question, top_k=20)
+    for m in all_memory:
+        if isinstance(m, dict):
+            mem_text = m.get("text", "")
+            mem_topic = m.get("topic", "general")
+        else:
+            mem_text = str(m)
+            mem_topic = "general"
+        if mem_topic == topic:
+            memory_contexts.append(mem_text)
+
+    if not _is_safe_query(question):
+        logger.warning(f"⚠️ Unsafe or sensitive question blocked: {question}")
+        interaction["no_answer_reason"] = "Contenu sensible ou dangereux détecté."
+        yield {"type": "done", "error": "Contenu sensible ou dangereux détecté.", "interaction": interaction}
+        return
+
+    try:
+        all_chunks = state.get("all_chunks", [])
+        if not all_chunks:
+            interaction["latency"] = round(time.time() - start_time, 4)
+            msg = (
+                "Aucune base documentaire chargée. Lancez l'indexation du wiki pour pouvoir poser des questions."
+            )
+            yield {"type": "done", "answer": msg, "interaction": interaction, "sources": []}
+            return
+
+        state["chunk_urls"] = [
+            chunk.get("url", "URL inconnue") if isinstance(chunk, dict) else "URL inconnue"
+            for chunk in all_chunks
+        ]
+
+        reranked_chunks = hybrid_search(
+            corrected_question,
+            bm25_weight=0.4,
+            top_k_candidates=200,
+            top_k_final=20,
+        )
+
+        table = []
+        top_chunks = []
+        chunk_citations = []
+        tokenizer = AutoTokenizer.from_pretrained("gpt2")
+
+        for rank, (chunk, idx, score) in enumerate(reranked_chunks):
+            chunk_dict = all_chunks[idx] if idx < len(all_chunks) else {}
+            chunk_text = chunk_dict.get("text", str(chunk))
+            chunk_url = chunk_dict.get("url", "URL inconnue")
+            id_chunk = chunk_dict.get("chunk_id", f"unk_{rank}")
+            chunk_with_citation = f"[{id_chunk}] {chunk_text.strip()}"
+            top_chunks.append(chunk_with_citation)
+            chunk_citations.append(
+                f"[{id_chunk}]{chunk_url}" if chunk_url != "URL inconnue" else f"[{id_chunk}] URL inconnue"
+            )
+            encoded_tokens = tokenizer.encode(chunk_text)
+            interaction["tokens_usage"]["input"] += len(encoded_tokens)
+            wrapped_chunk = "\n".join(textwrap.wrap(chunk_text.strip(), width=80))[:500] + "..."
+            wrapped_url = "\n".join(textwrap.wrap(chunk_url, width=80))
+            table.append([id_chunk, round(score, 4), len(encoded_tokens), wrapped_chunk, wrapped_url])
+
+        interaction["steps"].append({"step": "retrieved_chunks", "details": "Chunks retrieved and ranked"})
+
+        memory_section = (
+            "Mémoire longue durée pertinente (questions/réponses passées) :\n"
+            + "\n\n".join(memory_contexts)
+            + "\n\n"
+            if memory_contexts
+            else ""
+        )
+        top_context = "\n\n".join(top_chunks)
+        recent_context = (
+            "\n\n".join(
+                [
+                    f"Q: {e['query']}\nA: {e['answer']}"
+                    for e in state.get("chat_history", [])
+                    if detect_topic_smart(e["query"]) == topic
+                ]
+            )
+            + "\n\n"
+        )
+        prompt = (
+            "Réponds en français, de manière factuelle, structurée et précise, "
+            "en te basant uniquement sur le contexte fourni (extraits du wiki Intersel). "
+            "Indique l'identifiant exact du chunk utilisé entre crochets quand tu t'appuies sur un passage.\n\n"
+            "Règles importantes :\n"
+            "- Si le contexte ne contient aucune information pertinente pour répondre à la question, "
+            "réponds uniquement : « D'après le contexte fourni (wiki Intersel), il n'y a pas d'information "
+            "permettant de répondre à cette question. » Puis liste éventuellement les thèmes ou types de documents "
+            "qui manqueraient (ex. : documentation sur les CMS, les technologies utilisées, etc.).\n"
+            "- Ne mentionne jamais de clé API, d'erreur technique, de modèle ou de problème d'accès comme « données manquantes ».\n"
+            "- Ne fais aucune supposition non justifiée.\n\n"
+            f"{memory_section}{recent_context}{top_context}\n\nQuestion : {corrected_question}"
+        )
+        interaction["steps"].append({"step": "prompt_creation", "details": "Prompt generated for Llama3"})
+
+        yield {"type": "start"}
+
+        full_answer = []
+        for content in call_scaleway_llama3_stream(prompt):
+            full_answer.append(content)
+            yield {"type": "chunk", "content": content}
+
+        answer = "".join(full_answer)
+        interaction["steps"].append({"step": "answer_generation", "details": "Answer generated"})
+        chat_entry = {"query": corrected_question, "answer": answer, "topic": topic}
+        state.setdefault("chat_history", []).append(chat_entry)
+        try:
+            save_memory_entry(question, answer, topic=topic)
+        except Exception:
+            logger.exception("Failed to save memory entry.")
+
+        answer_with_sources = f"{answer.strip()}\n\nSources:\n" + "\n".join(chunk_citations)
+        interaction["latency"] = round(time.time() - start_time, 4)
+        interaction["answer"] = answer
+
+        yield {
+            "type": "done",
+            "answer": answer_with_sources,
+            "sources": chunk_citations,
+            "interaction": interaction,
+        }
+
+    except Exception as e:
+        logger.error(f"Error in process_question_stream: {e}")
+        traceback.print_exc()
+        yield {"type": "error", "message": str(e)}

+ 2 - 1
src/service/scaleway_billing_service.py

@@ -24,6 +24,7 @@ def _money_to_euro(amount: dict) -> float:
 
 def get_scaleway_consumption(
     billing_period: Optional[str] = None,
+    timeout: int = 10,
 ) -> Optional[dict]:
     """
     Appelle l'API Billing Scaleway pour le mois courant (ou billing_period YYYY-MM).
@@ -60,7 +61,7 @@ def get_scaleway_consumption(
                 "Content-Type": "application/json",
             },
             params=params,
-            timeout=10,
+            timeout=timeout,
         )
         r.raise_for_status()
         data = r.json()

+ 33 - 1
src/service/state.py

@@ -32,13 +32,45 @@ def get_embedding_function():
     return HuggingFaceEmbeddings(model_name="all-mpnet-base-v2")
 
 
+def _get_chat_history_path():
+    base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+    data_dir = os.path.join(base_dir, 'data')
+    os.makedirs(data_dir, exist_ok=True)
+    return os.path.join(data_dir, "chat_history.json")
+
+
+def load_chat_history_from_file():
+    """Charge l'historique du chat depuis le fichier JSON (persiste après redémarrage)."""
+    path = _get_chat_history_path()
+    if not os.path.exists(path):
+        return []
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, list) else []
+    except Exception as e:
+        print(f"⚠️ Erreur chargement chat_history: {e}")
+        return []
+
+
+def save_chat_history_to_file():
+    """Sauvegarde l'historique du chat dans un fichier JSON."""
+    path = _get_chat_history_path()
+    try:
+        history = state.get("chat_history", [])
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(history, f, ensure_ascii=False, indent=2)
+    except Exception as e:
+        print(f"⚠️ Erreur sauvegarde chat_history: {e}")
+
+
 chunks, index = load_chunks_and_index()
 
 state = {
     "embedding_model": get_embedding_function(),
     "memory_index": None,
     "memory_chunks": [],
-    "chat_history": [],
+    "chat_history": load_chat_history_from_file(),
     "all_chunks": chunks, 
     "chunk_urls": [],
     "llm": None,

+ 306 - 136
src/templates/developpeur.html

@@ -3,89 +3,118 @@
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}" type="image/x-icon" />
   <title>Développeur – Monitoring</title>
-  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&display=swap" />
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" />
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" />
   <style>
-    * { box-sizing: border-box; }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
     body {
-      margin: 0;
       font-family: 'Inter', sans-serif;
-      background: #f4f6f8;
-      color: #333;
+      background: #f8fafc;
+      color: #1e293b;
       min-height: 100vh;
     }
     .header {
-      background: #07468f;
-      color: white;
-      padding: 1rem 1.5rem;
+      background: #0f172a;
+      color: #f1f5f9;
+      padding: 0.875rem 1.5rem;
       display: flex;
       justify-content: space-between;
       align-items: center;
     }
-    .header h1 { margin: 0; font-size: 1.35rem; }
+    .header h1 {
+      margin: 0;
+      font-size: 1rem;
+      font-weight: 600;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+    .header h1 i { color: #60a5fa; }
     .header a {
-      color: rgba(255,255,255,0.9);
+      display: flex;
+      align-items: center;
+      gap: 0.4rem;
+      color: #94a3b8;
       text-decoration: none;
-      font-size: 0.95rem;
+      font-size: 0.85rem;
+      transition: color 0.15s;
     }
-    .header a:hover { text-decoration: underline; }
+    .header a:hover { color: #f1f5f9; }
     .main {
-      max-width: 900px;
+      max-width: 860px;
       margin: 0 auto;
       padding: 1.5rem;
     }
     .toolbar {
       display: flex;
-      gap: 0.75rem;
+      gap: 0.6rem;
       margin-bottom: 1.5rem;
     }
     .btn {
-      padding: 0.5rem 1rem;
+      padding: 0.45rem 1rem;
       border: none;
       border-radius: 8px;
       cursor: pointer;
-      font-weight: 600;
-      font-size: 0.9rem;
+      font-family: 'Inter', sans-serif;
+      font-weight: 500;
+      font-size: 0.85rem;
+      display: flex;
+      align-items: center;
+      gap: 0.4rem;
+      transition: background 0.15s;
     }
-    .btn-primary { background: #07468f; color: white; }
-    .btn-primary:hover { background: #053a75; }
-    .btn-secondary { background: #e0e0e0; color: #333; }
-    .btn-secondary:hover { background: #d0d0d0; }
-    .btn:disabled { opacity: 0.6; cursor: not-allowed; }
+    .btn-primary { background: #4f46e5; color: white; }
+    .btn-primary:hover { background: #4338ca; }
+    .btn-secondary { background: #e2e8f0; color: #475569; }
+    .btn-secondary:hover { background: #cbd5e1; }
+    .btn:disabled { opacity: 0.5; cursor: not-allowed; }
     .card {
       background: white;
-      border-radius: 10px;
-      box-shadow: 0 1px 4px rgba(0,0,0,0.08);
+      border: 1px solid #e2e8f0;
+      border-radius: 12px;
+      box-shadow: 0 1px 4px rgba(0,0,0,0.05);
       padding: 1.25rem;
-      margin-bottom: 1rem;
+      margin-bottom: 0.875rem;
     }
     .card h2 {
-      margin: 0 0 0.75rem 0;
-      font-size: 1.1rem;
-      color: #07468f;
+      margin: 0 0 0.875rem 0;
+      font-size: 0.9rem;
+      font-weight: 600;
+      color: #1e293b;
       display: flex;
       align-items: center;
       gap: 0.5rem;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
     }
-    .status-row { display: flex; align-items: center; gap: 0.5rem; margin: 0.35rem 0; }
+    .card h2 i { color: #4f46e5; }
+    .status-row { display: flex; align-items: center; gap: 0.5rem; margin: 0.35rem 0; font-size: 0.9rem; color: #475569; }
+    .status-row strong { color: #1e293b; }
     .badge {
-      display: inline-block;
-      padding: 0.2rem 0.5rem;
+      display: inline-flex;
+      align-items: center;
+      padding: 0.2rem 0.6rem;
       border-radius: 6px;
-      font-size: 0.8rem;
+      font-size: 0.75rem;
       font-weight: 600;
     }
-    .badge-ok { background: #d4edda; color: #155724; }
-    .badge-warn { background: #fff3cd; color: #856404; }
-    .badge-error { background: #f8d7da; color: #721c24; }
-    .mono { font-family: ui-monospace, monospace; font-size: 0.9rem; }
-    .message { margin-top: 0.75rem; padding: 0.75rem; background: #f8f9fa; border-radius: 6px; font-size: 0.9rem; }
-    #loading { text-align: center; padding: 2rem; color: #666; }
-    #error { color: #c00; margin-bottom: 1rem; }
-    .scraping-table { width: 100%; border-collapse: collapse; font-size: 0.9rem; }
+    .badge-ok { background: #f0fdf4; color: #166534; border: 1px solid #bbf7d0; }
+    .badge-warn { background: #fefce8; color: #854d0e; border: 1px solid #fde68a; }
+    .badge-error { background: #fef2f2; color: #b91c1c; border: 1px solid #fecaca; }
+    .mono { font-family: ui-monospace, 'Cascadia Code', monospace; font-size: 0.85rem; color: #64748b; }
+    .message { margin-top: 0.75rem; padding: 0.6rem 0.875rem; background: #f8fafc; border: 1px solid #e2e8f0; border-radius: 8px; font-size: 0.875rem; color: #475569; }
+    #loading { text-align: center; padding: 2rem; color: #64748b; }
+    #error { background: #fef2f2; border: 1px solid #fecaca; color: #b91c1c; padding: 0.65rem 0.875rem; border-radius: 8px; font-size: 0.875rem; margin-bottom: 1rem; }
+    .confirm-overlay { position: fixed; inset: 0; background: rgba(0,0,0,0.4); display: flex; align-items: center; justify-content: center; z-index: 9999; }
+    .confirm-box { background: white; padding: 1.5rem; border-radius: 12px; max-width: 400px; box-shadow: 0 4px 20px rgba(0,0,0,0.15); }
+    .confirm-box p { margin: 0 0 1rem 0; color: #1e293b; }
+    .confirm-box .btn { margin-right: 0.5rem; }
+    .scraping-table { width: 100%; border-collapse: collapse; font-size: 0.875rem; }
     .scraping-table th, .scraping-table td { padding: 0.4rem 0.5rem; text-align: left; }
-    .scraping-table th { color: #555; }
+    .scraping-table th { color: #64748b; font-weight: 500; font-size: 0.8rem; text-transform: uppercase; letter-spacing: 0.04em; }
+    .scraping-table td { color: #1e293b; }
   </style>
 </head>
 <body>
@@ -95,140 +124,281 @@
   </div>
   <div class="main">
     <div class="toolbar">
-      <button class="btn btn-secondary" id="btnRefresh" title="Rafraîchir"><i class="fas fa-sync-alt"></i> Rafraîchir</button>
-      <button class="btn btn-primary" id="btnIndexation" title="Lancer l'indexation"><i class="fas fa-database"></i> Lancer l'indexation</button>
+      <button type="button" class="btn btn-secondary" id="btnRefresh" title="Rafraîchir"><i class="fas fa-sync-alt"></i> Rafraîchir</button>
+      <button type="button" class="btn btn-primary" id="btnIndexation" title="Lancer l'indexation"><i class="fas fa-database"></i> Lancer l'indexation</button>
     </div>
+    <div id="indexationStatus" class="message" style="display:none; margin-bottom:1rem;"></div>
     <div id="error"></div>
     <div id="content">
-      <div id="loading">Chargement du statut…</div>
+      {% if dashboard %}
+      <div class="card">
+        <h2><i class="fas fa-heartbeat"></i> Santé (healthcheck)</h2>
+        <div class="status-row">
+          <span class="badge {{ 'badge-ok' if dashboard.health.ready else 'badge-error' }}">{{ 'Prêt' if dashboard.health.ready else 'Non prêt' }}</span>
+          <span>Chunks indexés : <strong>{{ dashboard.health.chunk_count or 0 }}</strong></span>
+          <span class="mono" style="font-size:0.8rem; color:#666;">(index FAISS)</span>
+        </div>
+        <div class="message">{{ dashboard.health.message or '-' }}</div>
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-cogs"></i> Pipeline – Métadonnées</h2>
+        <div class="status-row">Dernière exécution : <span class="mono">{{ dashboard.pipeline.last_run or 'Jamais' }}</span></div>
+        <div class="status-row">Durée totale : <span>{% if dashboard.pipeline.duration_seconds is not none %}{{ dashboard.pipeline.duration_seconds }} s{% else %}-{% endif %}</span></div>
+        <div class="status-row">Mode : <span class="mono">{{ dashboard.pipeline.mode or '-' }}</span></div>
+        {% if dashboard.pipeline.error %}<div class="status-row"><span class="badge badge-error">Erreur</span> <span>{{ dashboard.pipeline.error }}</span></div>{% endif %}
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-spider"></i> Étape 1 – Scraping (crawl)</h2>
+        {% if dashboard.pipeline.scraping_stats and dashboard.pipeline.scraping_stats.total_urls is not none %}
+        <table class="scraping-table">
+          <tr><th>total_urls</th><td>{{ dashboard.pipeline.scraping_stats.total_urls }}</td></tr>
+          <tr><th>pages_with_content</th><td>{{ dashboard.pipeline.scraping_stats.pages_with_content or '-' }}</td></tr>
+          <tr><th>failed_urls</th><td>{{ (dashboard.pipeline.scraping_stats.failed_urls|length) if dashboard.pipeline.scraping_stats.failed_urls else 0 }}</td></tr>
+        </table>
+        {% else %}<div class="message">Aucune donnée (indexation non exécutée)</div>{% endif %}
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-puzzle-piece"></i> Étape 2 – Chunking (sémantique)</h2>
+        <div class="status-row">Chunks produits : <strong>{{ dashboard.health.chunk_count or 0 }}</strong></div>
+        <div class="message" style="font-size:0.85rem;">Découpage par similarité sémantique (NLTK + SentenceTransformer)</div>
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-vector-square"></i> Étape 3 – Embeddings & index FAISS</h2>
+        <div class="status-row">Vecteurs (embeddings) : <strong>{{ dashboard.health.chunk_count or 0 }}</strong></div>
+        <div class="message" style="font-size:0.85rem;">all-mpnet-base-v2 → IndexFlatIP (cosine similarity)</div>
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-memory"></i> Mémoire & Chat</h2>
+        <div class="status-row">Mémoire longue durée : <strong>{{ dashboard.memory.entries_count or 0 }}</strong> entrées</div>
+        <div class="status-row">Historique chat (session) : <strong>{{ dashboard.chat.history_count or 0 }}</strong> échanges</div>
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-euro-sign"></i> Dépenses API Scaleway</h2>
+        {% if dashboard.scaleway_billing and dashboard.scaleway_billing|length %}
+        <div class="status-row">Période : <strong>{{ dashboard.scaleway_billing.period or 'Mois courant' }}</strong></div>
+        {% if dashboard.scaleway_billing.error %}<div class="status-row"><span class="badge badge-warn">Erreur API</span> <span>{{ dashboard.scaleway_billing.error }}</span></div>{% endif %}
+        {% if dashboard.scaleway_billing.total_eur is not none and not dashboard.scaleway_billing.error %}
+        <div class="status-row">Total mois : <strong>{{ "%.2f"|format(dashboard.scaleway_billing.total_eur) }} {{ dashboard.scaleway_billing.currency or 'EUR' }}</strong></div>
+        {% if dashboard.scaleway_billing.consumptions %}
+        <table class="scraping-table" style="margin-top:0.5rem;">
+          <tr><th>Catégorie</th><th>Montant</th></tr>
+          {% for c in dashboard.scaleway_billing.consumptions %}<tr><td>{{ c.category }}</td><td>{{ "%.2f"|format(c.amount_eur) if c.amount_eur is not none else '-' }} €</td></tr>{% endfor %}
+        </table>
+        {% endif %}{% endif %}
+        {% else %}<div class="message">Définir <span class="mono">SCW_ORGANIZATION_ID</span> (ou <span class="mono">SCW_ENDPOINT</span>) et une clé API avec droit <strong>BillingReadOnly</strong> pour afficher les dépenses.</div>{% endif %}
+      </div>
+      <div class="card">
+        <h2><i class="fas fa-key"></i> Configuration (.env)</h2>
+        <div class="status-row"><span class="badge {{ 'badge-warn' if dashboard.config.debug else 'badge-ok' }}">DEBUG</span> {{ 'Activé (1)' if dashboard.config.debug else 'Désactivé (0)' }} — {{ 'Flask debug ON, scraping max 15 URLs' if dashboard.config.debug else 'Flask debug OFF, scraping sans limite' }}</div>
+        <div class="status-row"><span class="badge {{ 'badge-ok' if dashboard.config.scw_api_set else 'badge-warn' }}">SCW_API_KEY</span> {{ 'Défini' if dashboard.config.scw_api_set else 'Non défini' }}</div>
+        <div class="status-row"><span class="badge {{ 'badge-ok' if dashboard.config.wiki_username_set else 'badge-warn' }}">WIKI_USERNAME</span> {{ 'Défini' if dashboard.config.wiki_username_set else 'Non défini' }}</div>
+        <div class="status-row"><span class="badge {{ 'badge-ok' if dashboard.config.wiki_password_set else 'badge-warn' }}">WIKI_PASSWORD</span> {{ 'Défini' if dashboard.config.wiki_password_set else 'Non défini' }}</div>
+      </div>
+      {% else %}
+      <div id="loading">Erreur lors du chargement. Utilisez <strong>Rafraîchir</strong>.</div>
+      {% endif %}
     </div>
   </div>
   <script>
-    const content = document.getElementById('content');
-    const errEl = document.getElementById('error');
-    const btnRefresh = document.getElementById('btnRefresh');
-    const btnIndexation = document.getElementById('btnIndexation');
+    console.log('[DEV] Script charge OK');
+    var content = document.getElementById('content');
+    var errEl = document.getElementById('error');
+    var statusEl = document.getElementById('indexationStatus');
+    var btnRefresh = document.getElementById('btnRefresh');
+    var btnIndexation = document.getElementById('btnIndexation');
+    console.log('[DEV] btnIndexation:', btnIndexation);
 
     function showError(msg) {
       errEl.textContent = msg;
       errEl.style.display = msg ? 'block' : 'none';
     }
 
+    function showStatus(msg, visible) {
+      if (statusEl) {
+        statusEl.textContent = msg;
+        statusEl.style.display = visible ? 'block' : 'none';
+        statusEl.style.background = visible ? '#eff6ff' : '';
+        statusEl.style.borderColor = '#93c5fd';
+      }
+    }
+
+    function renderBilling(billing) {
+      if (!billing || !Object.keys(billing).length) {
+        return '<div class="message">Definir SCW_ORGANIZATION_ID et une cle API avec droit BillingReadOnly pour afficher les depenses.</div>';
+      }
+      var html = '';
+      html += '<div class="status-row">Periode : <strong>' + (billing.period || 'Mois courant') + '</strong></div>';
+      if (billing.error) {
+        html += '<div class="status-row"><span class="badge badge-warn">Erreur API</span> <span>' + billing.error + '</span></div>';
+      } else if (billing.total_eur != null) {
+        html += '<div class="status-row">Total mois : <strong>' + billing.total_eur.toFixed(2) + ' ' + (billing.currency || 'EUR') + '</strong></div>';
+        if (billing.consumptions && billing.consumptions.length) {
+          html += '<table class="scraping-table" style="margin-top:0.5rem;"><tr><th>Categorie</th><th>Montant</th></tr>';
+          billing.consumptions.forEach(function(c) {
+            html += '<tr><td>' + c.category + '</td><td>' + (c.amount_eur != null ? c.amount_eur.toFixed(2) + ' EUR' : '-') + '</td></tr>';
+          });
+          html += '</table>';
+        }
+      }
+      return html;
+    }
+
     function render(d) {
-      const health = d.health || {};
-      const pipeline = d.pipeline || {};
-      const memory = d.memory || {};
-      const chat = d.chat || {};
-      const config = d.config || {};
-      const scraping = pipeline.scraping_stats || {};
-      const billing = d.scaleway_billing || {};
-
-      const ready = health.ready;
-      content.innerHTML = `
-        <div class="card">
-          <h2><i class="fas fa-heartbeat"></i> Santé (healthcheck)</h2>
-          <div class="status-row">
-            <span class="badge ${ready ? 'badge-ok' : 'badge-error'}">${ready ? 'Prêt' : 'Non prêt'}</span>
-            <span>Chunks indexés : <strong>${health.chunk_count ?? 0}</strong></span>
-            <span class="mono" style="font-size:0.8rem; color:#666;">(index FAISS)</span>
-          </div>
-          <div class="message">${health.message || '-'}</div>
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-cogs"></i> Pipeline – Métadonnées</h2>
-          <div class="status-row">Dernière exécution : <span class="mono">${pipeline.last_run || 'Jamais'}</span></div>
-          <div class="status-row">Durée totale : <span>${pipeline.duration_seconds != null ? pipeline.duration_seconds + ' s' : '-'}</span></div>
-          <div class="status-row">Mode : <span class="mono">${pipeline.mode || '-'}</span></div>
-          ${pipeline.error ? `<div class="status-row"><span class="badge badge-error">Erreur</span> <span>${pipeline.error}</span></div>` : ''}
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-spider"></i> Étape 1 – Scraping (crawl)</h2>
-          ${scraping.total_urls != null ? `
-          <table class="scraping-table">
-            <tr><th>total_urls</th><td>${scraping.total_urls}</td></tr>
-            <tr><th>pages_with_content</th><td>${scraping.pages_with_content ?? '-'}</td></tr>
-            <tr><th>failed_urls</th><td>${(scraping.failed_urls && scraping.failed_urls.length) || 0}</td></tr>
-          </table>
-          ` : '<div class="message">Aucune donnée (indexation non exécutée)</div>'}
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-puzzle-piece"></i> Étape 2 – Chunking (sémantique)</h2>
-          <div class="status-row">Chunks produits : <strong>${health.chunk_count ?? 0}</strong></div>
-          <div class="message" style="font-size:0.85rem;">Découpage par similarité sémantique (NLTK + SentenceTransformer)</div>
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-vector-square"></i> Étape 3 – Embeddings & index FAISS</h2>
-          <div class="status-row">Vecteurs (embeddings) : <strong>${health.chunk_count ?? 0}</strong></div>
-          <div class="message" style="font-size:0.85rem;">all-mpnet-base-v2 → IndexFlatIP (cosine similarity)</div>
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-memory"></i> Mémoire & Chat</h2>
-          <div class="status-row">Mémoire longue durée : <strong>${memory.entries_count ?? 0}</strong> entrées</div>
-          <div class="status-row">Historique chat (session) : <strong>${chat.history_count ?? 0}</strong> échanges</div>
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-euro-sign"></i> Dépenses API Scaleway</h2>
-          ${Object.keys(billing).length ? `
-          <div class="status-row">Période : <strong>${billing.period || 'Mois courant'}</strong></div>
-          ${billing.error ? `<div class="status-row"><span class="badge badge-warn">Erreur API</span> <span>${billing.error}</span></div>` : ''}
-          ${billing.total_eur != null && !billing.error ? `
-          <div class="status-row">Total mois : <strong>${billing.total_eur.toFixed(2)} ${billing.currency || 'EUR'}</strong></div>
-          ${(billing.consumptions && billing.consumptions.length) ? `
-          <table class="scraping-table" style="margin-top:0.5rem;">
-            <tr><th>Catégorie</th><th>Montant</th></tr>
-            ${billing.consumptions.map(c => `<tr><td>${c.category}</td><td>${c.amount_eur != null ? c.amount_eur.toFixed(2) + ' €' : '-'}</td></tr>`).join('')}
-          </table>
-          ` : ''}
-          ` : `
-          <div class="message">Définir <span class="mono">SCW_ORGANIZATION_ID</span> (ou utiliser <span class="mono">SCW_ENDPOINT</span> comme project_id) et une clé API avec droit <strong>BillingReadOnly</strong> pour afficher les dépenses.</div>
-          `}
-        </div>
-        <div class="card">
-          <h2><i class="fas fa-key"></i> Configuration (.env)</h2>
-          <div class="status-row"><span class="badge ${config.scw_api_set ? 'badge-ok' : 'badge-warn'}">SCW_API_KEY</span> ${config.scw_api_set ? 'Défini' : 'Non défini'}</div>
-          <div class="status-row"><span class="badge ${config.wiki_username_set ? 'badge-ok' : 'badge-warn'}">WIKI_USERNAME</span> ${config.wiki_username_set ? 'Défini' : 'Non défini'}</div>
-          <div class="status-row"><span class="badge ${config.wiki_password_set ? 'badge-ok' : 'badge-warn'}">WIKI_PASSWORD</span> ${config.wiki_password_set ? 'Défini' : 'Non défini'}</div>
-        </div>
-      `;
+      var health = d.health || {};
+      var pipeline = d.pipeline || {};
+      var memory = d.memory || {};
+      var chat = d.chat || {};
+      var config = d.config || {};
+      var scraping = pipeline.scraping_stats || {};
+      var billing = d.scaleway_billing || {};
+      var ready = health.ready;
+
+      var scrapingHtml = scraping.total_urls != null
+        ? '<table class="scraping-table">'
+          + '<tr><th>total_urls</th><td>' + scraping.total_urls + '</td></tr>'
+          + '<tr><th>pages_with_content</th><td>' + (scraping.pages_with_content || '-') + '</td></tr>'
+          + '<tr><th>failed_urls</th><td>' + ((scraping.failed_urls && scraping.failed_urls.length) || 0) + '</td></tr>'
+          + '</table>'
+        : '<div class="message">Aucune donnee (indexation non executee)</div>';
+
+      var html = '';
+      html += '<div class="card">';
+      html += '<h2><i class="fas fa-heartbeat"></i> Sante (healthcheck)</h2>';
+      html += '<div class="status-row">';
+      html += '<span class="badge ' + (ready ? 'badge-ok' : 'badge-error') + '">' + (ready ? 'Pret' : 'Non pret') + '</span>';
+      html += '<span>Chunks indexes : <strong>' + (health.chunk_count || 0) + '</strong></span>';
+      html += '<span class="mono" style="font-size:0.8rem; color:#666;">(index FAISS)</span>';
+      html += '</div>';
+      html += '<div class="message">' + (health.message || '-') + '</div>';
+      html += '</div>';
+
+      html += '<div class="card">';
+      html += '<h2><i class="fas fa-cogs"></i> Pipeline - Metadonnees</h2>';
+      html += '<div class="status-row">Derniere execution : <span class="mono">' + (pipeline.last_run || 'Jamais') + '</span></div>';
+      html += '<div class="status-row">Duree totale : <span>' + (pipeline.duration_seconds != null ? pipeline.duration_seconds + ' s' : '-') + '</span></div>';
+      html += '<div class="status-row">Mode : <span class="mono">' + (pipeline.mode || '-') + '</span></div>';
+      if (pipeline.error) { html += '<div class="status-row"><span class="badge badge-error">Erreur</span> <span>' + pipeline.error + '</span></div>'; }
+      html += '</div>';
+
+      html += '<div class="card"><h2><i class="fas fa-spider"></i> Etape 1 - Scraping (crawl)</h2>' + scrapingHtml + '</div>';
+
+      html += '<div class="card">';
+      html += '<h2><i class="fas fa-puzzle-piece"></i> Etape 2 - Chunking</h2>';
+      html += '<div class="status-row">Chunks produits : <strong>' + (health.chunk_count || 0) + '</strong></div>';
+      html += '</div>';
+
+      html += '<div class="card">';
+      html += '<h2><i class="fas fa-vector-square"></i> Etape 3 - Embeddings FAISS</h2>';
+      html += '<div class="status-row">Vecteurs : <strong>' + (health.chunk_count || 0) + '</strong></div>';
+      html += '</div>';
+
+      html += '<div class="card">';
+      html += '<h2><i class="fas fa-memory"></i> Memoire et Chat</h2>';
+      html += '<div class="status-row">Memoire longue duree : <strong>' + (memory.entries_count || 0) + '</strong> entrees</div>';
+      html += '<div class="status-row">Historique chat : <strong>' + (chat.history_count || 0) + '</strong> echanges</div>';
+      html += '</div>';
+
+      html += '<div class="card"><h2><i class="fas fa-euro-sign"></i> Depenses API Scaleway</h2>' + renderBilling(billing) + '</div>';
+
+      html += '<div class="card">';
+      html += '<h2><i class="fas fa-key"></i> Configuration (.env)</h2>';
+      html += '<div class="status-row"><span class="badge ' + (config.debug ? 'badge-warn' : 'badge-ok') + '">DEBUG</span> ' + (config.debug ? 'Active (1)' : 'Desactive (0)') + ' — ' + (config.debug ? 'Flask debug ON, scraping max 15 URLs' : 'Flask debug OFF, scraping sans limite') + '</div>';
+      html += '<div class="status-row"><span class="badge ' + (config.scw_api_set ? 'badge-ok' : 'badge-warn') + '">SCW_API_KEY</span> ' + (config.scw_api_set ? 'Defini' : 'Non defini') + '</div>';
+      html += '<div class="status-row"><span class="badge ' + (config.wiki_username_set ? 'badge-ok' : 'badge-warn') + '">WIKI_USERNAME</span> ' + (config.wiki_username_set ? 'Defini' : 'Non defini') + '</div>';
+      html += '<div class="status-row"><span class="badge ' + (config.wiki_password_set ? 'badge-ok' : 'badge-warn') + '">WIKI_PASSWORD</span> ' + (config.wiki_password_set ? 'Defini' : 'Non defini') + '</div>';
+      html += '</div>';
+
+      content.innerHTML = html;
+    }
+
+    function baseUrl() {
+      return (typeof window !== 'undefined' && window.location && window.location.origin) ? window.location.origin : '';
     }
 
     async function load() {
       showError('');
       content.innerHTML = '<div id="loading">Chargement du statut…</div>';
+      const url = baseUrl() + '/api/dashboard';
       try {
-        const r = await fetch('/api/dashboard');
-        if (!r.ok) throw new Error('Erreur ' + r.status);
-        const data = await r.json();
-        render(data);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 12000);
+        const r = await fetch(url, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (r.ok) {
+          const data = await r.json();
+          render(data);
+          return;
+        }
+        const errBody = await r.json().catch(() => ({}));
+        if (r.status === 500 && (errBody.error || '').length) {
+          showError('Erreur serveur : ' + errBody.error);
+        } else {
+          showError('Erreur ' + r.status + (r.status === 500 ? ' — voir les logs du terminal serveur' : ''));
+        }
+        content.innerHTML = '<p class="message">Réessayez avec <strong>Rafraîchir</strong> ou consultez la console (F12).</p>';
       } catch (e) {
-        showError('Impossible de charger le dashboard : ' + e.message);
-        content.innerHTML = '';
+        const msg = e.name === 'AbortError'
+          ? 'Délai dépassé (12 s). Le serveur est peut-être occupé. Réessayez ou regardez les logs.'
+          : 'Impossible de charger le dashboard : ' + e.message;
+        showError(msg);
+        content.innerHTML = '<p class="message">Vérifiez que vous êtes bien sur <strong>' + (baseUrl() || 'http://127.0.0.1:5000') + '</strong> et la console (F12).</p>';
       }
     }
 
     btnRefresh.addEventListener('click', load);
 
-    btnIndexation.addEventListener('click', async () => {
+    const runIndexation = async () => {
+      const originalHtml = btnIndexation.innerHTML;
+      btnIndexation.innerHTML = '<i class="fas fa-spinner fa-spin"></i> En cours...';
       btnIndexation.disabled = true;
       showError('');
+      showStatus('Indexation en cours... Cela peut prendre plusieurs minutes.', true);
+      let success = false;
       try {
         const r = await fetch('/api/trigger-indexation', { method: 'POST' });
-        const data = await r.json().catch(() => ({}));
+        const data = await r.json().catch(function() { return {}; });
         if (r.status === 409) {
-          showError('Une indexation est déjà en cours.');
+          showError('Une indexation est deja en cours.');
+          showStatus('', false);
         } else if (!r.ok) {
           showError(data.error || 'Erreur ' + r.status);
+          showStatus('', false);
         } else {
+          showStatus('Indexation terminee : ' + (data.chunk_count || 0) + ' chunks indexes.', true);
           showError('');
+          success = true;
           await load();
         }
-      } catch (e) {
-        showError('Erreur : ' + e.message);
+      } catch (err) {
+        showError('Erreur reseau : ' + err.message);
+        showStatus('', false);
       }
+      btnIndexation.innerHTML = originalHtml;
       btnIndexation.disabled = false;
-    });
+      if (success) { setTimeout(function() { showStatus('', false); }, 5000); }
+    };
 
-    load();
+    btnIndexation.addEventListener('click', function() {
+      var overlay = document.createElement('div');
+      overlay.className = 'confirm-overlay';
+      var box = document.createElement('div');
+      box.className = 'confirm-box';
+      box.innerHTML = '<p><strong>Lancer l\'indexation ?</strong></p><p>Scraping du wiki + reconstruction de l\'index. Peut prendre plusieurs minutes.</p>';
+      var btnOui = document.createElement('button');
+      btnOui.type = 'button';
+      btnOui.className = 'btn btn-primary';
+      btnOui.textContent = 'Oui, lancer';
+      var btnNon = document.createElement('button');
+      btnNon.type = 'button';
+      btnNon.className = 'btn btn-secondary';
+      btnNon.textContent = 'Annuler';
+      box.appendChild(btnOui);
+      box.appendChild(btnNon);
+      overlay.appendChild(box);
+      document.body.appendChild(overlay);
+      btnNon.addEventListener('click', function() { overlay.remove(); });
+      btnOui.addEventListener('click', function() { overlay.remove(); runIndexation(); });
+    });
   </script>
 </body>
 </html>

Tiedoston diff-näkymää rajattu, sillä se on liian suuri
+ 603 - 351
src/templates/index.html


+ 220 - 30
src/templates/login.html

@@ -1,30 +1,220 @@
-<!-- login.html -->
-<form onsubmit="login(event)">
-  <input type="email" id="email" required />
-  <input type="password" id="password" required />
-  <button type="submit">Connexion</button>
-</form>
-
-<script>
-async function login(event) {
-  event.preventDefault();
-  const res = await fetch('/signin', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      email: document.getElementById('email').value,
-      password: document.getElementById('password').value
-    })
-  });
-
-  const data = await res.json();
-  if (res.ok) {
-    localStorage.setItem('userId', data.user_id);
-    setTimeout(() => {
-        window.location.href = '/';
-                    }, 2000);
-  } else {
-    alert(data.message);
-  }
-}
-</script>
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}" type="image/x-icon" />
+  <title>Connexion — Intersel</title>
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" />
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" />
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      font-family: 'Inter', sans-serif;
+      background: #f8fafc;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 1.5rem;
+      color: #1e293b;
+    }
+
+    .card {
+      background: #ffffff;
+      border: 1px solid #e2e8f0;
+      border-radius: 16px;
+      box-shadow: 0 4px 24px rgba(0,0,0,0.06);
+      padding: 2.5rem 2rem;
+      width: 100%;
+      max-width: 400px;
+    }
+
+    .card-header {
+      text-align: center;
+      margin-bottom: 2rem;
+    }
+
+    .card-header .logo {
+      width: 44px;
+      height: 44px;
+      background: #4f46e5;
+      border-radius: 12px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 1rem;
+      color: white;
+      font-size: 1.2rem;
+    }
+
+    .card-header h1 {
+      font-size: 1.35rem;
+      font-weight: 600;
+      color: #0f172a;
+      margin-bottom: 0.25rem;
+    }
+
+    .card-header p {
+      font-size: 0.875rem;
+      color: #64748b;
+    }
+
+    .form-group {
+      display: flex;
+      flex-direction: column;
+      gap: 0.35rem;
+      margin-bottom: 1rem;
+    }
+
+    label {
+      font-size: 0.8rem;
+      font-weight: 500;
+      color: #475569;
+    }
+
+    input[type="email"],
+    input[type="password"] {
+      width: 100%;
+      padding: 0.6rem 0.875rem;
+      border: 1px solid #e2e8f0;
+      border-radius: 9px;
+      font-size: 0.9rem;
+      font-family: 'Inter', sans-serif;
+      color: #1e293b;
+      background: #f8fafc;
+      transition: border-color 0.15s, box-shadow 0.15s;
+    }
+
+    input:focus {
+      outline: none;
+      border-color: #4f46e5;
+      background: #ffffff;
+      box-shadow: 0 0 0 3px rgba(79, 70, 229, 0.15);
+    }
+
+    input::placeholder { color: #94a3b8; }
+
+    button[type="submit"] {
+      width: 100%;
+      padding: 0.7rem;
+      background: #4f46e5;
+      color: white;
+      border: none;
+      border-radius: 9px;
+      font-size: 0.9rem;
+      font-family: 'Inter', sans-serif;
+      font-weight: 500;
+      cursor: pointer;
+      margin-top: 0.5rem;
+      transition: background 0.15s, transform 0.1s;
+    }
+
+    button[type="submit"]:hover { background: #4338ca; }
+    button[type="submit"]:active { transform: scale(0.99); }
+
+    .feedback {
+      margin-top: 1rem;
+      padding: 0.65rem 0.875rem;
+      border-radius: 8px;
+      font-size: 0.85rem;
+      display: none;
+    }
+
+    .feedback.error {
+      background: #fef2f2;
+      color: #b91c1c;
+      border: 1px solid #fecaca;
+      display: block;
+    }
+
+    .feedback.success {
+      background: #f0fdf4;
+      color: #166534;
+      border: 1px solid #bbf7d0;
+      display: block;
+    }
+
+    .card-footer {
+      text-align: center;
+      margin-top: 1.5rem;
+      font-size: 0.85rem;
+      color: #64748b;
+    }
+
+    .card-footer a {
+      color: #4f46e5;
+      text-decoration: none;
+      font-weight: 500;
+    }
+
+    .card-footer a:hover { text-decoration: underline; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="card-header">
+      <div class="logo"><i class="fas fa-robot"></i></div>
+      <h1>Connexion</h1>
+      <p>Accédez au chatbot documentaire Intersel</p>
+    </div>
+
+    <form id="loginForm" onsubmit="login(event)">
+      <div class="form-group">
+        <label for="email">Adresse email</label>
+        <input type="email" id="email" placeholder="jean.dupont@intersel.fr" required />
+      </div>
+
+      <div class="form-group">
+        <label for="password">Mot de passe</label>
+        <input type="password" id="password" placeholder="Votre mot de passe" required />
+      </div>
+
+      <button type="submit">Se connecter</button>
+    </form>
+
+    <div class="feedback" id="feedback"></div>
+
+    <div class="card-footer">
+      Pas encore de compte ? <a href="/register">S'inscrire</a>
+    </div>
+  </div>
+
+  <script>
+    function showFeedback(message, type) {
+      const feedback = document.getElementById('feedback');
+      feedback.textContent = message;
+      feedback.className = `feedback ${type}`;
+    }
+
+    async function login(event) {
+      event.preventDefault();
+      document.getElementById('feedback').className = 'feedback';
+
+      try {
+        const res = await fetch('/signin', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            email: document.getElementById('email').value,
+            password: document.getElementById('password').value
+          })
+        });
+
+        const data = await res.json();
+
+        if (res.ok) {
+          localStorage.setItem('userId', data.user_id);
+          showFeedback("Connexion réussie, redirection…", "success");
+          setTimeout(() => { window.location.href = '/'; }, 1500);
+        } else {
+          showFeedback(data.message || "Identifiants incorrects.", "error");
+        }
+      } catch (err) {
+        showFeedback("Erreur réseau ou serveur.", "error");
+      }
+    }
+  </script>
+</body>
+</html>

+ 247 - 134
src/templates/register.html

@@ -1,155 +1,268 @@
 <!DOCTYPE html>
 <html lang="fr">
 <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>Inscription</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 400px;
-            margin: 50px auto;
-            padding: 20px;
-            border: 1px solid #ddd;
-            border-radius: 5px;
-        }
-        input[type="text"],
-        input[type="email"],
-        input[type="password"],
-        select {
-            width: 100%;
-            padding: 10px;
-            margin: 8px 0 15px 0;
-            border: 1px solid #ccc;
-            border-radius: 3px;
-            box-sizing: border-box;
-        }
-        button {
-            padding: 10px;
-            width: 100%;
-            background-color: #007bff;
-            color: white;
-            border: none;
-            border-radius: 3px;
-            cursor: pointer;
-            font-size: 16px;
-        }
-        button:hover {
-            background-color: #0056b3;
-        }
-        .message {
-            margin-top: 15px;
-            font-weight: bold;
-        }
-        .error {
-            color: red;
-        }
-        .success {
-            color: green;
-        }
-        label {
-            font-weight: bold;
-        }
-    </style>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <link rel="icon" href="{{ url_for('static', filename='favicon.ico') }}" type="image/x-icon" />
+  <title>Inscription — Intersel</title>
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" />
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" />
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      font-family: 'Inter', sans-serif;
+      background: #f8fafc;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 1.5rem;
+      color: #1e293b;
+    }
+
+    .card {
+      background: #ffffff;
+      border: 1px solid #e2e8f0;
+      border-radius: 16px;
+      box-shadow: 0 4px 24px rgba(0,0,0,0.06);
+      padding: 2.5rem 2rem;
+      width: 100%;
+      max-width: 440px;
+    }
+
+    .card-header {
+      text-align: center;
+      margin-bottom: 2rem;
+    }
+
+    .card-header .logo {
+      width: 44px;
+      height: 44px;
+      background: #4f46e5;
+      border-radius: 12px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin: 0 auto 1rem;
+      color: white;
+      font-size: 1.2rem;
+    }
+
+    .card-header h1 {
+      font-size: 1.35rem;
+      font-weight: 600;
+      color: #0f172a;
+      margin-bottom: 0.25rem;
+    }
+
+    .card-header p {
+      font-size: 0.875rem;
+      color: #64748b;
+    }
+
+    .form-row {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 0.75rem;
+    }
+
+    .form-group {
+      display: flex;
+      flex-direction: column;
+      gap: 0.35rem;
+      margin-bottom: 1rem;
+    }
+
+    label {
+      font-size: 0.8rem;
+      font-weight: 500;
+      color: #475569;
+    }
+
+    input[type="text"],
+    input[type="email"],
+    input[type="password"],
+    select {
+      width: 100%;
+      padding: 0.6rem 0.875rem;
+      border: 1px solid #e2e8f0;
+      border-radius: 9px;
+      font-size: 0.9rem;
+      font-family: 'Inter', sans-serif;
+      color: #1e293b;
+      background: #f8fafc;
+      transition: border-color 0.15s, box-shadow 0.15s;
+    }
+
+    input:focus, select:focus {
+      outline: none;
+      border-color: #4f46e5;
+      background: #ffffff;
+      box-shadow: 0 0 0 3px rgba(79, 70, 229, 0.15);
+    }
+
+    select { cursor: pointer; }
+
+    input::placeholder { color: #94a3b8; }
+
+    button[type="submit"] {
+      width: 100%;
+      padding: 0.7rem;
+      background: #4f46e5;
+      color: white;
+      border: none;
+      border-radius: 9px;
+      font-size: 0.9rem;
+      font-family: 'Inter', sans-serif;
+      font-weight: 500;
+      cursor: pointer;
+      margin-top: 0.5rem;
+      transition: background 0.15s, transform 0.1s;
+    }
+
+    button[type="submit"]:hover { background: #4338ca; }
+    button[type="submit"]:active { transform: scale(0.99); }
+
+    .feedback {
+      margin-top: 1rem;
+      padding: 0.65rem 0.875rem;
+      border-radius: 8px;
+      font-size: 0.85rem;
+      display: none;
+    }
+
+    .feedback.error {
+      background: #fef2f2;
+      color: #b91c1c;
+      border: 1px solid #fecaca;
+      display: block;
+    }
+
+    .feedback.success {
+      background: #f0fdf4;
+      color: #166534;
+      border: 1px solid #bbf7d0;
+      display: block;
+    }
+
+    .card-footer {
+      text-align: center;
+      margin-top: 1.5rem;
+      font-size: 0.85rem;
+      color: #64748b;
+    }
+
+    .card-footer a {
+      color: #4f46e5;
+      text-decoration: none;
+      font-weight: 500;
+    }
+
+    .card-footer a:hover { text-decoration: underline; }
+  </style>
 </head>
 <body>
-
-    <h2>Créer un compte</h2>
+  <div class="card">
+    <div class="card-header">
+      <div class="logo"><i class="fas fa-user-plus"></i></div>
+      <h1>Créer un compte</h1>
+      <p>Rejoignez le chatbot documentaire Intersel</p>
+    </div>
 
     <form id="registerForm">
-        <label for="name">Prénom :</label><br />
-        <input type="text" id="name" name="name" required /><br />
-
-        <label for="surname">Nom :</label><br />
-        <input type="text" id="surname" name="surname" required /><br />
+      <div class="form-row">
+        <div class="form-group">
+          <label for="name">Prénom</label>
+          <input type="text" id="name" name="name" placeholder="Jean" required />
+        </div>
+        <div class="form-group">
+          <label for="surname">Nom</label>
+          <input type="text" id="surname" name="surname" placeholder="Dupont" required />
+        </div>
+      </div>
 
-        
-        <label for="userType">Type d'utilisateur :</label><br />
+      <div class="form-group">
+        <label for="userType">Rôle</label>
         <select id="userType" name="userType" required>
-            <option value="" disabled selected>Choisir un type</option>
-            <option value="Admin">Admin</option>
-            <option value="Stagiaire">Stagiaire</option>
-        </select><br />
+          <option value="" disabled selected>Choisir un rôle</option>
+          <option value="Admin">Administrateur</option>
+          <option value="Stagiaire">Stagiaire</option>
+        </select>
+      </div>
 
-        <label for="email">Email :</label><br />
-        <input type="email" id="email" name="email" required /><br />
+      <div class="form-group">
+        <label for="email">Adresse email</label>
+        <input type="email" id="email" name="email" placeholder="jean.dupont@intersel.fr" required />
+      </div>
 
-        <label for="password">Mot de passe :</label><br />
-        <input type="password" id="password" name="password" required minlength="6" /><br />
+      <div class="form-group">
+        <label for="password">Mot de passe</label>
+        <input type="password" id="password" name="password" placeholder="Min. 6 caractères" required minlength="6" />
+      </div>
 
-        <button type="submit">S'inscrire</button>
+      <button type="submit">Créer mon compte</button>
     </form>
 
-    <div class="message" id="message"></div>
+    <div class="feedback" id="feedback"></div>
 
-    <script>
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[a-zA-Z]{2,}$/;
-        const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{6,}$/;
+    <div class="card-footer">
+      Déjà inscrit ? <a href="/login">Se connecter</a>
+    </div>
+  </div>
 
-        function validateEmail(email) {
-            return emailRegex.test(email);
-        }
+  <script>
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[a-zA-Z]{2,}$/;
+    const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{6,}$/;
 
-        function validatePassword(password) {
-            return passwordRegex.test(password);
-        }
-        const form = document.getElementById('registerForm');
-        const messageDiv = document.getElementById('message');
-
-        form.addEventListener('submit', async (e) => {
-            e.preventDefault();
-
-            const name = form.name.value.trim();
-            const surname = form.surname.value.trim();
-            const userType = form.userType.value;
-            const email = form.email.value.trim();
-            const password = form.password.value.trim();
-
-            messageDiv.textContent = "";
-            messageDiv.className = "message";
-
-            if (!validateEmail(email)) {
-                messageDiv.textContent = "Email invalide. Veuillez entrer un email valide.";
-                messageDiv.classList.add('error');
-                return;
-            }
-
-            if (!validatePassword(password)) {
-                messageDiv.textContent = "Le mot de passe doit contenir au moins 6 caractères, avec une majuscule, une minuscule, un chiffre et un caractère spécial.";
-                messageDiv.classList.add('error');
-                return;
-            }
-
-            try {
-                const response = await fetch('/signup', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, surname, userType, email, password })
-                });
-
-                const data = await response.json();
-
-                if (response.ok) {
-                    messageDiv.textContent = data.message;
-                    messageDiv.classList.add('success');
-                    form.reset();
-
-                    // Redirection vers login.html après 2 secondes (pour laisser voir le message)
-                   setTimeout(() => {
-                        window.location.href = '/login';
-                    }, 2000);
-
-                } else {
-                    messageDiv.textContent = data.message || 'Erreur lors de l\'inscription';
-                    messageDiv.classList.add('error');
-                }
-
-            } catch (err) {
-                messageDiv.textContent = 'Erreur réseau ou serveur';
-                messageDiv.classList.add('error');
-            }
+    const form = document.getElementById('registerForm');
+    const feedback = document.getElementById('feedback');
+
+    function showFeedback(message, type) {
+      feedback.textContent = message;
+      feedback.className = `feedback ${type}`;
+    }
+
+    form.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      feedback.className = 'feedback';
+
+      const name = form.name.value.trim();
+      const surname = form.surname.value.trim();
+      const userType = form.userType.value;
+      const email = form.email.value.trim();
+      const password = form.password.value.trim();
+
+      if (!emailRegex.test(email)) {
+        showFeedback("Email invalide. Veuillez entrer un email valide.", "error");
+        return;
+      }
+
+      if (!passwordRegex.test(password)) {
+        showFeedback("Le mot de passe doit contenir au moins 6 caractères, avec majuscule, minuscule, chiffre et caractère spécial.", "error");
+        return;
+      }
+
+      try {
+        const response = await fetch('/signup', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ name, surname, userType, email, password })
         });
-    </script>
 
+        const data = await response.json();
+
+        if (response.ok) {
+          showFeedback(data.message || "Compte créé avec succès !", "success");
+          form.reset();
+          setTimeout(() => { window.location.href = '/login'; }, 2000);
+        } else {
+          showFeedback(data.message || "Erreur lors de l'inscription.", "error");
+        }
+      } catch (err) {
+        showFeedback("Erreur réseau ou serveur.", "error");
+      }
+    });
+  </script>
 </body>
 </html>

BIN
static/favicon.ico


+ 46 - 0
test-to-delete/run_scraping.py

@@ -0,0 +1,46 @@
+"""Lance le scraping du wiki à la main. Depuis agent_docker : py .\test-to-delete\run_scraping.py"""
+import sys
+import os
+import traceback
+
+# Pour que "src" soit trouvé même quand le script est dans test-to-delete/
+agent_docker_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if agent_docker_root not in sys.path:
+    sys.path.insert(0, agent_docker_root)
+
+os.chdir(agent_docker_root)  # .env et src/data sont ici
+
+from dotenv import load_dotenv
+load_dotenv()
+
+if __name__ == "__main__":
+    print("🚀 Démarrage du test de scraping...")
+    print(f"   CWD: {os.getcwd()}")
+    print(f"   DEBUG: {os.getenv('DEBUG', '0')}")
+    print(f"   WIKI_USERNAME défini: {'oui' if os.getenv('WIKI_USERNAME') else 'NON'}")
+    
+    try:
+        from src.service.auth_service import auto_login
+        from src.agent_ai.scraping import scrape_pages
+        
+        auto_login()  # Obligatoire : le scraping utilise la session authentifiée
+        pages, stats = scrape_pages()
+        
+        print(f"\n✅ Résultat: {len(pages)} pages récupérées")
+        print(f"📊 Stats: {stats}")
+        
+        if pages:
+            print(f"📄 Première page: {pages[0]['url'][:60]}...")
+            txt = pages[0].get('text', '')
+            print(f"📝 Contenu ({len(txt)} chars): {txt[:80]}...")
+        else:
+            print("⚠️ Aucune page récupérée !")
+            if stats.get("failed_urls"):
+                print(f"   URLs en échec: {len(stats['failed_urls'])}")
+        
+        print(f"\n📁 Fichiers: src/data/urls.json, raw_pages.json, page_hashes.json")
+        
+    except Exception as e:
+        print(f"\n❌ ERREUR: {e}")
+        traceback.print_exc()
+        sys.exit(1)

+ 270 - 0
test-to-delete/test_fetch_urls.py

@@ -0,0 +1,270 @@
+"""
+Test de récupération d'URLs du wiki par différentes méthodes.
+Depuis agent_docker : py .\test-to-delete\test_fetch_urls.py
+"""
+import sys
+import os
+
+agent_docker_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if agent_docker_root not in sys.path:
+    sys.path.insert(0, agent_docker_root)
+os.chdir(agent_docker_root)
+
+from dotenv import load_dotenv
+load_dotenv()
+
+import time
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin, urlparse
+
+BASE_URL = "https://wiki.intersel.fr/"
+JSONRPC_URL = "https://wiki.intersel.fr/lib/exe/jsonrpc.php"
+XMLRPC_URL = "https://wiki.intersel.fr/lib/exe/xmlrpc.php"
+INDEX_URL = "https://wiki.intersel.fr/doku.php?do=index"
+
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/115.0.0"
+
+
+def is_valid_page_url(url):
+    """URL de page de contenu (id=, pas do=, pas idx=)."""
+    parsed = urlparse(url)
+    return (
+        "wiki.intersel.fr" in url
+        and "do=" not in parsed.query
+        and "idx=" not in parsed.query
+        and "id=" in parsed.query
+        and "#" not in url
+    )
+
+
+def test_jsonrpc(session):
+    """Test JSON-RPC core.getAPIVersion."""
+    print("\n--- 1. JSON-RPC ---")
+    try:
+        r = session.post(
+            f"{JSONRPC_URL}/core.getAPIVersion",
+            json={},
+            headers={"Content-Type": "application/json", "User-Agent": USER_AGENT},
+            timeout=5,
+        )
+        data = r.json() if r.text else {}
+        print(f"   Status: {r.status_code}")
+        print(f"   Response: {data}")
+        if r.status_code == 200 and "result" in data:
+            print("   ✅ JSON-RPC OK")
+            return True
+        print("   ❌ JSON-RPC non disponible")
+        return False
+    except Exception as e:
+        print(f"   ❌ Erreur: {e}")
+        return False
+
+
+def test_xmlrpc(session):
+    """Test XML-RPC (alternative à JSON-RPC)."""
+    print("\n--- 2. XML-RPC ---")
+    try:
+        xml_body = """<?xml version="1.0"?>
+<methodCall>
+  <methodName>wiki.getVersion</methodName>
+  <params></params>
+</methodCall>"""
+        r = session.post(
+            XMLRPC_URL,
+            data=xml_body,
+            headers={"Content-Type": "text/xml", "User-Agent": USER_AGENT},
+            timeout=5,
+        )
+        print(f"   Status: {r.status_code}")
+        print(f"   Response (100 chars): {r.text[:100] if r.text else 'vide'}...")
+        if r.status_code == 200 and "methodResponse" in (r.text or ""):
+            print("   ✅ XML-RPC répond")
+            return True
+        print("   ❌ XML-RPC non disponible")
+        return False
+    except Exception as e:
+        print(f"   ❌ Erreur: {e}")
+        return False
+
+
+def test_index_page(session):
+    """Récupère les URLs depuis la page index (sans sous-index)."""
+    print("\n--- 3. Index HTML (do=index) ---")
+    urls = set()
+    try:
+        r = session.get(INDEX_URL, headers={"User-Agent": USER_AGENT}, timeout=10)
+        print(f"   Status: {r.status_code}")
+        if r.status_code != 200:
+            return []
+        soup = BeautifulSoup(r.text, "html.parser")
+        for link in soup.find_all("a", href=True):
+            abs_url = urljoin(INDEX_URL, link["href"])
+            if is_valid_page_url(abs_url):
+                urls.add(abs_url)
+        urls.add(BASE_URL.rstrip("/"))
+        print(f"   ✅ {len(urls)} URLs (pages id= + homepage)")
+        return sorted(urls)
+    except Exception as e:
+        print(f"   ❌ Erreur: {e}")
+        return []
+
+
+def test_crawl_bfs(session, max_pages=100):
+    """Crawl BFS depuis la homepage : suit tous les liens internes du wiki."""
+    print("\n--- 4. Crawl BFS (depuis homepage) ---")
+    base = BASE_URL.rstrip("/")
+    to_visit = [base, f"{base}/doku.php?id=start"]
+    visited = set()
+    content_urls = set()
+
+    while to_visit and len(visited) < max_pages:
+        url = to_visit.pop(0)
+        if url in visited:
+            continue
+        visited.add(url)
+        try:
+            r = session.get(url, headers={"User-Agent": USER_AGENT}, timeout=10)
+            if r.status_code != 200:
+                continue
+            soup = BeautifulSoup(r.text, "html.parser")
+            for link in soup.find_all("a", href=True):
+                abs_url = urljoin(url, link["href"])
+                if "wiki.intersel.fr" not in abs_url or "#" in abs_url:
+                    continue
+                parsed = urlparse(abs_url)
+                if "do=" in parsed.query or "idx=" in parsed.query:
+                    continue
+                if "id=" in parsed.query or abs_url.rstrip("/") == base:
+                    clean = abs_url.split("&")[0].split("#")[0]
+                    if clean not in visited and clean not in to_visit:
+                        to_visit.append(clean)
+                    content_urls.add(clean)
+            content_urls.add(url.split("&")[0].split("#")[0])
+            time.sleep(0.2)
+        except Exception as e:
+            print(f"   ⚠️ {url[:50]}: {e}")
+
+    content_urls.add(base)
+    def norm(u):
+        u = u.split("#")[0].split("&")[0].rstrip("/")
+        if u.endswith("/doku.php") or u == base + "/":
+            return base
+        return u
+    urls = sorted(set(norm(u) for u in content_urls if "wiki.intersel.fr" in u and "do=" not in u and "idx=" not in u))
+    print(f"   ✅ {len(urls)} URLs (après {len(visited)} pages visitées)")
+    return urls
+
+
+def test_index_with_subindex(session):
+    """Parcourt index + sous-index (do=index&idx=...)."""
+    print("\n--- 5. Index + sous-index (parcours récursif) ---")
+    content_urls = set()
+    sub_indexes = set()
+    to_visit = [INDEX_URL]
+    visited = set()
+
+    while to_visit:
+        url = to_visit.pop(0)
+        if url in visited:
+            continue
+        visited.add(url)
+        try:
+            r = session.get(url, headers={"User-Agent": USER_AGENT}, timeout=10)
+            if r.status_code != 200:
+                continue
+            soup = BeautifulSoup(r.text, "html.parser")
+            for link in soup.find_all("a", href=True):
+                abs_url = urljoin(url, link["href"])
+                if "wiki.intersel.fr" not in abs_url or "#" in abs_url:
+                    continue
+                parsed = urlparse(abs_url)
+                if "do=index" in parsed.query:
+                    sub_indexes.add(abs_url)
+                    if abs_url not in visited and abs_url not in to_visit:
+                        to_visit.append(abs_url)
+                elif is_valid_page_url(abs_url):
+                    content_urls.add(abs_url)
+        except Exception as e:
+            print(f"   ⚠️ {url}: {e}")
+
+    content_urls.add(BASE_URL.rstrip("/"))
+    print(f"   ✅ {len(content_urls)} URLs (après {len(visited)} pages d'index)")
+    return sorted(content_urls)
+
+
+def test_sitemap(session):
+    """Test et parse le sitemap (plusieurs URLs possibles)."""
+    print("\n--- 6. Sitemap ---")
+    sitemap_urls = [
+        "https://wiki.intersel.fr/doku.php?sitemap=xml",
+        "https://wiki.intersel.fr/doku.php?do=sitemap",
+    ]
+    urls = []
+    for sitemap_url in sitemap_urls:
+        try:
+            r = session.get(sitemap_url, headers={"User-Agent": USER_AGENT}, timeout=10)
+            print(f"   {sitemap_url}: status={r.status_code}")
+            text = r.text or ""
+            # Debug : afficher le début pour comprendre le format
+            if not urls and text:
+                print(f"   [DEBUG] Aperçu (300 chars): {repr(text[:300])}")
+            import re
+            # Format XML sitemap : <loc>https://...</loc>
+            if "<loc>" in text:
+                found = re.findall(r"<loc>([^<]+)</loc>", text)
+                urls = [u.strip() for u in found if "wiki.intersel.fr" in u and "do=" not in u and "idx=" not in u]
+            # Format HTML : extraire les liens doku.php?id=
+            elif "doku.php" in text or "id=" in text:
+                found = re.findall(r'https://wiki\.intersel\.fr/doku\.php\?id=[^"\'<>\s&]+', text)
+                urls = [u.split("&")[0].rstrip(".,;:)") for u in found]
+            urls = list(dict.fromkeys(urls))
+            if urls:
+                urls.insert(0, BASE_URL.rstrip("/"))
+                urls = list(dict.fromkeys(urls))
+                print(f"   ✅ {len(urls)} URLs extraites")
+                return urls
+        except Exception as e:
+            print(f"   Erreur: {e}")
+    print("   ⚠️ 0 URLs extraites")
+    return urls
+
+
+def main():
+    print("=" * 50)
+    print("Test récupération URLs wiki Intersel")
+    print("=" * 50)
+
+    from src.service.auth_service import auto_login
+    from src.agent_ai.auth import session
+
+    auto_login()
+
+    # Tests
+    test_jsonrpc(session)
+    test_xmlrpc(session)
+    urls_index = test_index_page(session)
+    urls_crawl = test_crawl_bfs(session, max_pages=150)
+    urls_subindex = test_index_with_subindex(session)
+    urls_sitemap = test_sitemap(session)
+
+    # Résumé
+    print("\n" + "=" * 50)
+    print("RÉSUMÉ")
+    print("=" * 50)
+    print(f"Index simple      : {len(urls_index)} URLs")
+    print(f"Crawl BFS         : {len(urls_crawl)} URLs")
+    print(f"Index + sous-index: {len(urls_subindex)} URLs")
+    print(f"Sitemap           : {len(urls_sitemap)} URLs")
+
+    best = max([urls_crawl, urls_subindex, urls_sitemap], key=len)
+    if best:
+        print(f"\n>>> Meilleure source: {len(best)} URLs")
+        for u in best[:8]:
+            print(f"  - {u[:75]}...")
+        if len(best) > 8:
+            print(f"  ... et {len(best) - 8} autres")
+
+
+if __name__ == "__main__":
+    main()

+ 34 - 0
test-to-delete/test_scaleway.py

@@ -0,0 +1,34 @@
+from openai import OpenAI
+
+SCW_API_KEY = "ad99d6a9-b71e-457d-855a-4d4b5f9abdda"
+SCW_MODEL   = "mistral-small-3.2-24b-instruct-2506"
+BASE_URL    = "https://api.scaleway.ai/d7d5949a-c2bb-484a-b973-e05a83510efd/v1"
+
+client = OpenAI(
+    base_url=BASE_URL,
+    api_key=SCW_API_KEY
+)
+
+print(f"Appel vers : {BASE_URL}")
+print(f"Modèle     : {SCW_MODEL}\n")
+print("Réponse du modèle : ", end="", flush=True)
+
+response = client.chat.completions.create(
+    model=SCW_MODEL,
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant"},
+        {"role": "user",   "content": "Dis bonjour en une phrase."}
+    ],
+    max_tokens=512,
+    temperature=0.15,
+    top_p=1,
+    presence_penalty=0,
+    stream=True,
+    response_format={"type": "text"}
+)
+
+for chunk in response:
+    if chunk.choices and chunk.choices[0].delta.content:
+        print(chunk.choices[0].delta.content, end="", flush=True)
+
+print()

+ 46 - 0
test-to-delete/test_scaleway_consumption.py

@@ -0,0 +1,46 @@
+"""
+Test de l'API consumption Scaleway (Billing).
+À supprimer : script de test manuel pour vérifier l'appel à l'API Billing.
+"""
+import os
+import sys
+
+# Ajouter le chemin agent_docker pour importer le service
+agent_docker = os.path.join(os.path.dirname(__file__), "..", "agent_docker")
+sys.path.insert(0, agent_docker)
+
+# Charger le .env de agent_docker
+from dotenv import load_dotenv
+load_dotenv(os.path.join(agent_docker, ".env"))
+
+from src.service.scaleway_billing_service import get_scaleway_consumption
+
+if __name__ == "__main__":
+    # Vérifier que les variables d'environnement sont définies
+    if not os.getenv("SCW_API_KEY") and not os.getenv("SCW_SECRET_KEY"):
+        print("Erreur : définir SCW_API_KEY ou SCW_SECRET_KEY dans .env")
+        sys.exit(1)
+    if not os.getenv("SCW_ORGANIZATION_ID") and not os.getenv("SCW_ENDPOINT"):
+        print("Erreur : définir SCW_ORGANIZATION_ID ou SCW_ENDPOINT (project_id) dans .env")
+        sys.exit(1)
+
+    print("Appel API Billing Scaleway (mois courant)...")
+    result = get_scaleway_consumption(timeout=10)
+
+    if result is None:
+        print("Aucun résultat (config manquante)")
+        sys.exit(1)
+
+    if result.get("error"):
+        print(f"Erreur : {result['error']}")
+        sys.exit(1)
+
+    print(f"Période : {result.get('period', 'N/A')}")
+    print(f"Total : {result.get('total_eur', 0):.2f} {result.get('currency', 'EUR')}")
+    if result.get("consumptions"):
+        print("Détail par catégorie :")
+        for c in result["consumptions"]:
+            print(f"  - {c['category']}: {c['amount_eur']:.2f} €")
+    else:
+        print("Aucune consommation détaillée.")
+    print("OK")

Kaikkia tiedostoja ei voida näyttää, sillä liian monta tiedostoa muuttui tässä diffissä