diff --git a/TEST-GUIDE.md b/TEST-GUIDE.md
new file mode 100644
index 0000000..e4c4a29
--- /dev/null
+++ b/TEST-GUIDE.md
@@ -0,0 +1,201 @@
+# 🧪 DRS Integration Test Suite - Guide d'utilisation
+
+## 📋 Vue d'ensemble
+
+Le système de test d'intégration complet permet de vérifier le bon fonctionnement de tous les modules DRS et leur interaction.
+
+## 🚀 Comment lancer les tests
+
+### Option 1: Interface utilisateur (Recommandé)
+1. Ouvrir l'application (http://localhost:3000)
+2. Appuyer sur `F12` pour ouvrir le Debug Panel
+3. Cliquer sur le bouton "🧪 Run Integration Tests"
+4. Observer les résultats dans le panneau de test qui apparaît
+
+### Option 2: Console
+```javascript
+// Tests complets d'intégration
+runDRSTests() // Tests architecture et modules
+runUIUXTests() // Tests interface utilisateur complets
+runE2ETests() // Tests scénarios end-to-end
+
+// Tests rapides spécifiques
+test.testAll() // Tous les tests rapides
+test.testFlashcardRetry() // Test du système de retry des flashcards
+test.testVocabularyProgress() // Test du système de progrès vocabulary
+test.testIntelligentSequencer() // Test du séquenceur intelligent
+test.testAIIntegration() // Test de l'intégration IA
+test.testDRSSystem() // Test du système DRS
+test.testWordDiscovery() // Test du système de découverte de mots
+
+// Statut des modules
+test.showModuleStatus() // Affiche l'état de tous les modules
+
+// Aide
+test.help() // Affiche l'aide des commandes
+```
+
+## 📊 Types de tests
+
+### 1. Tests du système de base
+- ✅ Application chargée et fonctionnelle
+- ✅ EventBus opérationnel
+- ✅ ModuleLoader fonctionnel
+- ✅ Router opérationnel
+
+### 2. Tests de chargement de contenu
+- ✅ ContentLoader accessible
+- ✅ Chargement de contenu de chapitre
+- ✅ Validation de la structure des données
+
+### 3. Tests du système DRS
+- ✅ UnifiedDRS disponible
+- ✅ IAEngine opérationnel
+- ✅ LLMValidator disponible
+
+### 4. Tests des modules d'exercices
+- ✅ TextModule
+- ✅ AudioModule
+- ✅ ImageModule
+- ✅ GrammarModule
+- ✅ TextAnalysisModule
+- ✅ GrammarAnalysisModule
+- ✅ TranslationModule
+- ✅ OpenResponseModule
+- ✅ WordDiscoveryModule
+
+### 5. Tests d'intégration IA
+- ✅ Configuration des fournisseurs IA
+- ✅ Validation des réponses (structure)
+- ✅ Gestion des erreurs
+
+### 6. Tests du système de prérequis
+- ✅ PrerequisiteEngine disponible
+- ✅ Suivi des mots maîtrisés
+- ✅ Système de découverte de mots
+- ✅ Calcul des progrès
+
+### 7. Tests IntelligentSequencer
+- ✅ Chargement du séquenceur
+- ✅ Création de sessions guidées
+- ✅ Recommandations d'exercices
+- ✅ Insights de performance
+
+### 8. Tests d'intégration croisée
+- ✅ Intégration modal de vocabulaire
+- ✅ Intégration Flashcard-PrerequisiteEngine
+- ✅ Intégration DRS-IA
+- ✅ Communication EventBus
+
+## 📈 Interprétation des résultats
+
+### Taux de réussite
+- **90%+** : 🎉 EXCELLENT - Système hautement fonctionnel
+- **75-89%** : 👍 BON - Système majoritairement fonctionnel avec problèmes mineurs
+- **50-74%** : ⚠️ MODÉRÉ - Système avec problèmes significatifs
+- **<50%** : 🚨 CRITIQUE - Système avec problèmes majeurs
+
+### Messages d'erreur communs
+
+#### ❌ "Application not loaded"
+- **Cause** : L'application ne s'est pas initialisée correctement
+- **Solution** : Recharger la page et attendre l'initialisation complète
+
+#### ❌ "Module not found"
+- **Cause** : Un module n'est pas chargé ou accessible
+- **Solution** : Vérifier les logs de console pour les erreurs de chargement
+
+#### ❌ "API key" / "provider" errors
+- **Cause** : Tests IA échouent sans clés API (normal)
+- **Impact** : N'affecte pas les autres fonctionnalités
+
+#### ❌ "Content not available"
+- **Cause** : Fichiers de contenu manquants
+- **Solution** : Vérifier que les fichiers JSON de contenu existent
+
+## 🔧 Dépannage
+
+### Tests échouent massivement
+1. Vérifier que le serveur de développement fonctionne (port 3000)
+2. Ouvrir les outils de développement (F12) et vérifier les erreurs
+3. Recharger la page complètement
+4. Vérifier que tous les fichiers JS sont accessibles
+
+### Tests IA échouent
+- **Normal** sans clés API configurées
+- Pour tester réellement l'IA : configurer les clés dans `IAEngine`
+
+### Tests de contenu échouent
+- Vérifier que les fichiers `/content/chapters/*.json` existent
+- Vérifier la structure des données JSON
+
+### Tests de modules spécifiques échouent
+- Vérifier que les fichiers de modules existent dans `/src/DRS/exercise-modules/`
+- Contrôler les erreurs de syntaxe dans les modules
+
+## 📝 Ajout de nouveaux tests
+
+### Tests dans `test-integration.js`
+```javascript
+// Ajouter dans la classe DRSIntegrationTester
+async testNewFeature() {
+ this.log('🧪 Testing new feature...');
+
+ this.test('Feature test name', () => {
+ // Test synchrone
+ return condition;
+ });
+
+ await this.asyncTest('Async feature test', async () => {
+ // Test asynchrone
+ const result = await someAsyncOperation();
+ return result.isValid;
+ });
+}
+```
+
+### Tests console dans `test-console-commands.js`
+```javascript
+// Ajouter dans window.testCommands
+async testNewFeature() {
+ console.log('🧪 Testing new feature...');
+ // Logique de test
+ return success;
+}
+```
+
+## 🎯 Utilisation en développement
+
+### Tests rapides pendant le développement
+```javascript
+// Test rapide d'un module spécifique
+test.testFlashcardRetry()
+
+// Vérifier l'état après modifications
+test.showModuleStatus()
+```
+
+### Tests complets avant release
+```javascript
+// Tests d'intégration complets
+runDRSTests()
+```
+
+### Tests de régression
+Lancer les tests après chaque modification majeure pour s'assurer qu'aucune fonctionnalité existante n'est cassée.
+
+## 📋 Checklist de validation
+
+Avant de considérer le système comme stable :
+
+- [ ] Tests de base > 95% de réussite
+- [ ] Tests de contenu fonctionnels
+- [ ] Tests DRS > 90% de réussite
+- [ ] Tests de modules d'exercices > 85% de réussite
+- [ ] Tests d'intégration croisée > 90% de réussite
+- [ ] Aucune erreur critique dans la console
+- [ ] Tous les modules accessibles via `test.showModuleStatus()`
+
+---
+
+**🎯 Objectif** : Maintenir un taux de réussite global > 90% pour assurer la stabilité du système.
\ No newline at end of file
diff --git a/index.html b/index.html
index 38c9846..1f51065 100644
--- a/index.html
+++ b/index.html
@@ -48,6 +48,20 @@
+
+
+
+
+
@@ -68,8 +82,7 @@
const contentLoader = new ContentLoader();
window.contentLoader = contentLoader;
- // Initialize Smart Preview Orchestrator (will be initialized later when app is ready)
- let smartPreviewOrchestrator = null;
+ // Smart Preview Orchestrator will be initialized automatically by Application.js
// Wait for both DOM and application to be ready
let appReady = false;
@@ -128,22 +141,7 @@
if (loadingScreen) loadingScreen.style.display = 'none';
if (appContainer) appContainer.style.display = 'block';
- // Initialize Smart Preview Orchestrator
- try {
- smartPreviewOrchestrator = new SmartPreviewOrchestrator(
- 'smartPreviewOrchestrator',
- { eventBus, contentLoader },
- { llm: { provider: 'openai' } }
- );
-
- // CRITICAL: Register module with EventBus before initialization
- eventBus.registerModule(smartPreviewOrchestrator);
-
- await smartPreviewOrchestrator.init();
- console.log('🎯 Smart Preview Orchestrator initialized');
- } catch (error) {
- console.error('❌ Failed to initialize Smart Preview Orchestrator:', error);
- }
+ // Smart Preview Orchestrator is automatically initialized by Application.js
// Show debug panel if enabled
const status = app.getStatus();
@@ -2100,10 +2098,16 @@
🧠 Smart Guide Active
-
+
+
+
+
Analyzing performance and preparing intelligent sequence...
@@ -2186,6 +2190,281 @@
}
};
+ // Helper function to get current book ID from chapter ID
+ window.getCurrentBookId = function() {
+ const chapterId = window.currentChapterId || 'sbs-7-8';
+ // Parse chapter ID to extract book (e.g., "sbs-7-8" -> "sbs")
+ const parts = chapterId.split('-');
+ return parts[0] || 'sbs';
+ };
+
+ // Helper function to load persisted vocabulary data
+ window.loadPersistedVocabularyData = async function(chapterId) {
+ try {
+ const bookId = getCurrentBookId();
+ console.log(`📁 Loading persisted data for ${bookId}/${chapterId}`);
+
+ // Load from API server progress
+ const serverProgress = await getChapterProgress(bookId, chapterId);
+ console.log('Server progress:', serverProgress);
+
+ // Load from localStorage FlashcardLearning
+ const flashcardProgress = JSON.parse(localStorage.getItem('flashcard_progress') || '{}');
+ console.log('Flashcard progress:', flashcardProgress);
+
+ // Extract mastered words from flashcard data
+ const flashcardMasteredWords = Object.keys(flashcardProgress).filter(cardId => {
+ const progress = flashcardProgress[cardId];
+ return progress.masteryLevel === 'mastered';
+ }).map(cardId => {
+ // Extract word from cardId (format: "vocab_word" or "sentence_index")
+ const progress = flashcardProgress[cardId];
+ return progress.word || cardId.replace('vocab_', '').replace(/_/g, ' ');
+ });
+
+ // Combine discovered and mastered words from server
+ const serverDiscoveredWords = serverProgress.masteredVocabulary || [];
+
+ return {
+ serverDiscovered: serverDiscoveredWords,
+ flashcardMastered: flashcardMasteredWords,
+ serverData: serverProgress,
+ flashcardData: flashcardProgress
+ };
+
+ } catch (error) {
+ console.warn('Failed to load persisted vocabulary data:', error);
+ return {
+ serverDiscovered: [],
+ flashcardMastered: [],
+ serverData: {},
+ flashcardData: {}
+ };
+ }
+ };
+
+ // Helper function to calculate combined vocabulary progress
+ window.calculateVocabularyProgress = async function(chapterId, persistedData, prerequisiteEngine) {
+ try {
+ console.log('🧮 Calculating combined vocabulary progress...');
+
+ // Get chapter content to know total vocabulary
+ const moduleLoader = window.app.getCore().moduleLoader;
+ const contentLoader = moduleLoader.getModule('contentLoader');
+
+ if (!contentLoader) {
+ throw new Error('ContentLoader not available');
+ }
+
+ const content = await contentLoader.getContent(chapterId);
+ if (!content?.vocabulary) {
+ throw new Error('No vocabulary content found');
+ }
+
+ const allWords = Object.keys(content.vocabulary);
+ const vocabCount = allWords.length;
+
+ // Combine all data sources
+ const combinedDiscovered = new Set([
+ ...persistedData.serverDiscovered,
+ ...persistedData.flashcardMastered
+ ]);
+
+ const combinedMastered = new Set([
+ ...persistedData.flashcardMastered
+ ]);
+
+ // Add current session data if prerequisiteEngine is available
+ if (prerequisiteEngine) {
+ allWords.forEach(word => {
+ if (prerequisiteEngine.isDiscovered(word)) {
+ combinedDiscovered.add(word);
+ }
+ if (prerequisiteEngine.isMastered(word)) {
+ combinedMastered.add(word);
+ }
+ });
+ }
+
+ // Count words that are in the current chapter vocabulary
+ const discoveredCount = allWords.filter(word => combinedDiscovered.has(word)).length;
+ const masteredCount = allWords.filter(word => combinedMastered.has(word)).length;
+ const masteredWordsList = allWords.filter(word => combinedMastered.has(word));
+
+ const result = {
+ total: vocabCount,
+ discovered: discoveredCount,
+ mastered: masteredCount,
+ discoveredPercentage: vocabCount > 0 ? Math.round((discoveredCount / vocabCount) * 100) : 0,
+ masteredPercentage: vocabCount > 0 ? Math.round((masteredCount / vocabCount) * 100) : 0,
+ masteredWordsList: masteredWordsList
+ };
+
+ console.log('✅ Combined progress calculated:', result);
+ return result;
+
+ } catch (error) {
+ console.warn('Failed to calculate vocabulary progress:', error);
+ return {
+ total: 0,
+ discovered: 0,
+ mastered: 0,
+ discoveredPercentage: 0,
+ masteredPercentage: 0,
+ masteredWordsList: []
+ };
+ }
+ };
+
+ window.showVocabularyKnowledge = async function() {
+ try {
+ console.log('📖 Refreshing vocabulary knowledge with latest data...');
+
+ // Close any existing modal first
+ const existingModal = document.querySelector('.vocabulary-knowledge-modal');
+ if (existingModal) {
+ existingModal.remove();
+ console.log('🗑️ Removed existing modal');
+ }
+
+ // Always start fresh - reload all data on every opening
+ const currentChapterId = window.currentChapterId || 'sbs-7-8';
+ console.log('🔄 Reloading data for chapter:', currentChapterId);
+
+ // Load fresh persisted data
+ const persistedData = await loadPersistedVocabularyData(currentChapterId);
+ console.log('📁 Fresh persisted data loaded:', persistedData);
+
+ // Get prerequisite engine from current session
+ let prerequisiteEngine = null;
+ try {
+ const moduleLoader = window.app.getCore().moduleLoader;
+ const orchestrator = moduleLoader.getModule('smartPreviewOrchestrator');
+ if (orchestrator) {
+ prerequisiteEngine = orchestrator.sharedServices?.prerequisiteEngine || orchestrator.prerequisiteEngine;
+ console.log('🔗 PrerequisiteEngine connected:', !!prerequisiteEngine);
+ }
+ } catch (error) {
+ console.log('Could not connect to PrerequisiteEngine:', error);
+ }
+
+ // Calculate fresh combined progress
+ const vocabularyProgress = await calculateVocabularyProgress(currentChapterId, persistedData, prerequisiteEngine);
+ console.log('📊 Fresh vocabulary progress:', vocabularyProgress);
+
+ // Prepare data for modal
+ const progress = {
+ vocabulary: vocabularyProgress
+ };
+ const masteredWords = vocabularyProgress.masteredWordsList;
+
+
+ // Create vocabulary knowledge modal
+ const modal = document.createElement('div');
+ modal.className = 'vocabulary-knowledge-modal';
+ modal.innerHTML = `
+