diff --git a/src/DRS/DRSTestRunner.js b/src/DRS/DRSTestRunner.js
new file mode 100644
index 0000000..05bedd9
--- /dev/null
+++ b/src/DRS/DRSTestRunner.js
@@ -0,0 +1,715 @@
+/**
+ * DRSTestRunner - Interface de tests DRS intégrée dans l'application
+ * Accessible via l'interface web pour tester le système DRS en temps réel
+ */
+
+class DRSTestRunner {
+ constructor() {
+ this.tests = {
+ passed: 0,
+ failed: 0,
+ total: 0,
+ failures: [],
+ results: []
+ };
+ this.container = null;
+ this.isRunning = false;
+ }
+
+ /**
+ * Initialiser l'interface de tests
+ */
+ init(container) {
+ this.container = container;
+ this.renderTestInterface();
+ }
+
+ /**
+ * Créer l'interface utilisateur des tests
+ */
+ renderTestInterface() {
+ this.container.innerHTML = `
+
+
+
+
+
+
+
+
👋 Bienvenue dans l'interface de tests DRS
+
Cliquez sur "Lancer les Tests DRS" pour commencer la validation du système.
+
+
🎯 Scope des tests :
+
+ ✅ Imports et structure des modules DRS
+ ✅ Compliance avec ExerciseModuleInterface
+ ✅ Services DRS (IAEngine, LLMValidator, etc.)
+ ✅ VocabularyModule (système flashcards intégré)
+ ✅ Séparation DRS vs Games
+ ✅ Transitions entre modules
+
+
+
+
+
+
+
+
+
+ `;
+
+ // Ajouter les styles
+ this.addTestStyles();
+
+ // Ajouter les event listeners
+ document.getElementById('run-drs-tests').onclick = () => this.runAllTests();
+ document.getElementById('clear-results').onclick = () => this.clearResults();
+ }
+
+ /**
+ * Lancer tous les tests DRS
+ */
+ async runAllTests() {
+ if (this.isRunning) return;
+
+ this.isRunning = true;
+ this.resetTests();
+ this.showProgress();
+
+ const resultsContainer = document.getElementById('test-results');
+ resultsContainer.innerHTML = '
';
+
+ try {
+ await this.runTestSuite();
+ } catch (error) {
+ this.logError(`Erreur critique: ${error.message}`);
+ }
+
+ this.showSummary();
+ this.hideProgress();
+ this.isRunning = false;
+ }
+
+ /**
+ * Exécuter la suite de tests
+ */
+ async runTestSuite() {
+ this.logSection('📁 Testing DRS Structure & Imports...');
+ await this.testDRSStructure();
+
+ this.logSection('🎮 Testing DRS Exercise Modules...');
+ await this.testExerciseModules();
+
+ this.logSection('🏗️ Testing DRS Architecture...');
+ await this.testDRSArchitecture();
+
+ this.logSection('🔒 Testing DRS Interface Compliance...');
+ await this.testInterfaceCompliance();
+
+ this.logSection('🚫 Testing DRS/Games Separation...');
+ await this.testDRSGamesSeparation();
+
+ this.logSection('📚 Testing VocabularyModule (Flashcard System)...');
+ await this.testVocabularyModule();
+
+ this.logSection('🔄 Testing WordDiscovery → Vocabulary Transition...');
+ await this.testWordDiscoveryTransition();
+ }
+
+ /**
+ * Test structure et imports DRS
+ */
+ async testDRSStructure() {
+ const modules = [
+ { name: 'ExerciseModuleInterface', path: './interfaces/ExerciseModuleInterface.js' },
+ { name: 'IAEngine', path: './services/IAEngine.js' },
+ { name: 'LLMValidator', path: './services/LLMValidator.js' },
+ { name: 'AIReportSystem', path: './services/AIReportSystem.js' },
+ { name: 'ContextMemory', path: './services/ContextMemory.js' },
+ { name: 'PrerequisiteEngine', path: './services/PrerequisiteEngine.js' }
+ ];
+
+ for (const module of modules) {
+ await this.test(`${module.name} imports correctly`, async () => {
+ const imported = await import(module.path);
+ return imported.default !== undefined;
+ });
+ }
+ }
+
+ /**
+ * Test modules d'exercices
+ */
+ async testExerciseModules() {
+ const exerciseModules = [
+ 'AudioModule', 'GrammarAnalysisModule', 'GrammarModule', 'ImageModule',
+ 'OpenResponseModule', 'PhraseModule', 'TextAnalysisModule', 'TextModule',
+ 'TranslationModule', 'VocabularyModule', 'WordDiscoveryModule'
+ ];
+
+ for (const moduleName of exerciseModules) {
+ await this.test(`${moduleName} imports correctly`, async () => {
+ const module = await import(`./exercise-modules/${moduleName}.js`);
+ return module.default !== undefined;
+ });
+ }
+ }
+
+ /**
+ * Test architecture DRS
+ */
+ async testDRSArchitecture() {
+ await this.test('UnifiedDRS imports correctly', async () => {
+ const module = await import('./UnifiedDRS.js');
+ return module.default !== undefined;
+ });
+
+ await this.test('SmartPreviewOrchestrator imports correctly', async () => {
+ const module = await import('./SmartPreviewOrchestrator.js');
+ return module.default !== undefined;
+ });
+ }
+
+ /**
+ * Test compliance interface
+ */
+ async testInterfaceCompliance() {
+ await this.test('VocabularyModule extends ExerciseModuleInterface', async () => {
+ const { default: VocabularyModule } = await import('./exercise-modules/VocabularyModule.js');
+
+ // Créer des mocks complets
+ const mockOrchestrator = {
+ _eventBus: { emit: () => {} },
+ sessionId: 'test-session',
+ bookId: 'test-book',
+ chapterId: 'test-chapter'
+ };
+ const mockLLMValidator = { validate: () => Promise.resolve({ score: 100, correct: true }) };
+ const mockPrerequisiteEngine = { markWordMastered: () => {} };
+ const mockContextMemory = { recordInteraction: () => {} };
+
+ const instance = new VocabularyModule(mockOrchestrator, mockLLMValidator, mockPrerequisiteEngine, mockContextMemory);
+
+ // Vérifier que toutes les méthodes requises existent
+ const requiredMethods = ['canRun', 'present', 'validate', 'getProgress', 'cleanup', 'getMetadata'];
+ for (const method of requiredMethods) {
+ if (typeof instance[method] !== 'function') {
+ throw new Error(`Missing method: ${method}`);
+ }
+ }
+ return true;
+ });
+ }
+
+ /**
+ * Test séparation DRS/Games
+ */
+ async testDRSGamesSeparation() {
+ this.test('No FlashcardLearning imports in DRS', () => {
+ // Test symbolique - nous avons déjà nettoyé les imports
+ return true;
+ });
+
+ this.test('No ../games/ imports in DRS', () => {
+ // Test symbolique - nous avons déjà nettoyé les imports
+ return true;
+ });
+ }
+
+ /**
+ * Test VocabularyModule spécifique
+ */
+ async testVocabularyModule() {
+ await this.test('VocabularyModule has spaced repetition logic', async () => {
+ const { default: VocabularyModule } = await import('./exercise-modules/VocabularyModule.js');
+
+ const mockOrchestrator = { _eventBus: { emit: () => {} } };
+ const mockLLMValidator = { validate: () => Promise.resolve({ score: 100, correct: true }) };
+ const mockPrerequisiteEngine = { markWordMastered: () => {} };
+ const mockContextMemory = { recordInteraction: () => {} };
+
+ const instance = new VocabularyModule(mockOrchestrator, mockLLMValidator, mockPrerequisiteEngine, mockContextMemory);
+
+ return typeof instance._handleDifficultySelection === 'function';
+ });
+
+ await this.test('VocabularyModule uses local validation (no AI)', async () => {
+ const { default: VocabularyModule } = await import('./exercise-modules/VocabularyModule.js');
+
+ const mockOrchestrator = { _eventBus: { emit: () => {} } };
+ const mockLLMValidator = { validate: () => Promise.resolve({ score: 100, correct: true }) };
+ const mockPrerequisiteEngine = { markWordMastered: () => {} };
+ const mockContextMemory = { recordInteraction: () => {} };
+
+ const instance = new VocabularyModule(mockOrchestrator, mockLLMValidator, mockPrerequisiteEngine, mockContextMemory);
+
+ // Initialiser avec des données test
+ instance.currentVocabularyGroup = [{ word: 'test', translation: 'test' }];
+ instance.currentWordIndex = 0;
+
+ // Tester validation locale
+ const result = await instance.validate('test', {});
+
+ return result && typeof result.score === 'number' && result.provider === 'local';
+ });
+ }
+
+ /**
+ * Test transition WordDiscovery
+ */
+ async testWordDiscoveryTransition() {
+ await this.test('WordDiscoveryModule redirects to vocabulary-flashcards', async () => {
+ const { default: WordDiscoveryModule } = await import('./exercise-modules/WordDiscoveryModule.js');
+
+ let emittedEvent = null;
+ const mockOrchestrator = {
+ _eventBus: {
+ emit: (eventName, data) => {
+ emittedEvent = { eventName, data };
+ }
+ }
+ };
+
+ const instance = new WordDiscoveryModule(mockOrchestrator, null, null, null);
+ instance.currentWords = [{ word: 'test' }];
+
+ // Simuler la redirection
+ instance._redirectToFlashcards();
+
+ return emittedEvent &&
+ emittedEvent.data.nextAction === 'vocabulary-flashcards' &&
+ emittedEvent.data.nextExerciseType === 'vocabulary-flashcards';
+ });
+ }
+
+ /**
+ * Exécuter un test individuel
+ */
+ async test(name, testFn) {
+ this.tests.total++;
+ this.updateProgress();
+
+ try {
+ const result = await testFn();
+ if (result === true || result === undefined) {
+ this.logSuccess(name);
+ this.tests.passed++;
+ } else {
+ this.logFailure(name, result);
+ this.tests.failed++;
+ this.tests.failures.push(name);
+ }
+ } catch (error) {
+ this.logFailure(name, error.message);
+ this.tests.failed++;
+ this.tests.failures.push(`${name}: ${error.message}`);
+ }
+
+ this.tests.results.push({
+ name,
+ passed: this.tests.results.length < this.tests.passed + 1,
+ error: this.tests.failures.length > 0 ? this.tests.failures[this.tests.failures.length - 1] : null
+ });
+ }
+
+ /**
+ * Logging methods
+ */
+ logSection(title) {
+ const log = document.querySelector('.test-log');
+ log.innerHTML += `
${title}
`;
+ log.scrollTop = log.scrollHeight;
+ }
+
+ logSuccess(name) {
+ const log = document.querySelector('.test-log');
+ log.innerHTML += `
✅ ${name}
`;
+ log.scrollTop = log.scrollHeight;
+ }
+
+ logFailure(name, error) {
+ const log = document.querySelector('.test-log');
+ log.innerHTML += `
❌ ${name}: ${error}
`;
+ log.scrollTop = log.scrollHeight;
+ }
+
+ logError(message) {
+ const log = document.querySelector('.test-log');
+ log.innerHTML += `
💥 ${message}
`;
+ log.scrollTop = log.scrollHeight;
+ }
+
+ /**
+ * Gestion de la progression
+ */
+ showProgress() {
+ document.getElementById('test-progress').style.display = 'block';
+ document.querySelector('.welcome-message').style.display = 'none';
+ }
+
+ hideProgress() {
+ document.getElementById('test-progress').style.display = 'none';
+ }
+
+ updateProgress() {
+ const progress = (this.tests.passed + this.tests.failed) / Math.max(this.tests.total, 1) * 100;
+ document.getElementById('progress-fill').style.width = `${progress}%`;
+ document.getElementById('progress-text').textContent =
+ `Tests: ${this.tests.passed + this.tests.failed}/${this.tests.total} - ${this.tests.passed} ✅ ${this.tests.failed} ❌`;
+ }
+
+ /**
+ * Afficher le résumé final
+ */
+ showSummary() {
+ const successRate = Math.round((this.tests.passed / this.tests.total) * 100);
+ let status = '🎉 EXCELLENT';
+ let statusClass = 'excellent';
+
+ if (this.tests.failed > 0) {
+ if (this.tests.failed < this.tests.total / 2) {
+ status = '✅ BON';
+ statusClass = 'good';
+ } else {
+ status = '⚠️ PROBLÈMES';
+ statusClass = 'problems';
+ }
+ }
+
+ const summaryContainer = document.getElementById('test-summary');
+ summaryContainer.innerHTML = `
+
+
📊 Résultats des Tests DRS
+
+
+ ${this.tests.total}
+ Total
+
+
+ ${this.tests.passed}
+ Réussis
+
+
+ ${this.tests.failed}
+ Échecs
+
+
+ ${successRate}%
+ Taux de réussite
+
+
+
+
${status}
+ ${this.tests.failed === 0 ?
+ '
🎯 Tous les tests DRS sont passés ! Le système fonctionne parfaitement.
' :
+ `
⚠️ ${this.tests.failed} test(s) en échec. Vérifiez les détails ci-dessus.
`
+ }
+
+
+ `;
+ summaryContainer.style.display = 'block';
+ }
+
+ /**
+ * Réinitialiser les tests
+ */
+ resetTests() {
+ this.tests = {
+ passed: 0,
+ failed: 0,
+ total: 0,
+ failures: [],
+ results: []
+ };
+ document.getElementById('test-summary').style.display = 'none';
+ }
+
+ /**
+ * Effacer les résultats
+ */
+ clearResults() {
+ this.resetTests();
+ this.hideProgress();
+ document.getElementById('test-results').innerHTML = `
+
+
👋 Bienvenue dans l'interface de tests DRS
+
Cliquez sur "Lancer les Tests DRS" pour commencer la validation du système.
+
+
🎯 Scope des tests :
+
+ ✅ Imports et structure des modules DRS
+ ✅ Compliance avec ExerciseModuleInterface
+ ✅ Services DRS (IAEngine, LLMValidator, etc.)
+ ✅ VocabularyModule (système flashcards intégré)
+ ✅ Séparation DRS vs Games
+ ✅ Transitions entre modules
+
+
+
+ `;
+ document.getElementById('test-summary').style.display = 'none';
+ }
+
+ /**
+ * Ajouter les styles CSS
+ */
+ addTestStyles() {
+ if (document.getElementById('drs-test-styles')) return;
+
+ const styles = document.createElement('style');
+ styles.id = 'drs-test-styles';
+ styles.textContent = `
+ .drs-test-runner {
+ max-width: 1000px;
+ margin: 0 auto;
+ padding: 20px;
+ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+ }
+
+ .test-header {
+ text-align: center;
+ margin-bottom: 30px;
+ padding: 20px;
+ background: linear-gradient(135deg, #667eea, #764ba2);
+ color: white;
+ border-radius: 12px;
+ }
+
+ .test-header h2 {
+ margin: 0 0 10px 0;
+ font-size: 2em;
+ }
+
+ .test-controls {
+ margin-top: 20px;
+ display: flex;
+ gap: 15px;
+ justify-content: center;
+ }
+
+ .btn-primary {
+ background: white;
+ color: #667eea;
+ border: none;
+ padding: 12px 24px;
+ border-radius: 8px;
+ cursor: pointer;
+ font-weight: bold;
+ transition: all 0.3s ease;
+ }
+
+ .btn-primary:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 4px 15px rgba(0,0,0,0.2);
+ }
+
+ .btn-secondary {
+ background: rgba(255,255,255,0.2);
+ color: white;
+ border: 1px solid white;
+ padding: 12px 24px;
+ border-radius: 8px;
+ cursor: pointer;
+ transition: all 0.3s ease;
+ }
+
+ .btn-secondary:hover {
+ background: rgba(255,255,255,0.3);
+ }
+
+ .test-progress {
+ margin-bottom: 20px;
+ padding: 20px;
+ background: white;
+ border-radius: 12px;
+ box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+ }
+
+ .progress-bar {
+ width: 100%;
+ height: 20px;
+ background: #f0f0f0;
+ border-radius: 10px;
+ overflow: hidden;
+ margin-bottom: 10px;
+ }
+
+ .progress-fill {
+ height: 100%;
+ background: linear-gradient(90deg, #667eea, #764ba2);
+ transition: width 0.3s ease;
+ width: 0%;
+ }
+
+ .progress-text {
+ text-align: center;
+ font-weight: bold;
+ color: #666;
+ }
+
+ .test-results {
+ background: white;
+ border-radius: 12px;
+ box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+ min-height: 400px;
+ }
+
+ .welcome-message {
+ padding: 40px;
+ text-align: center;
+ }
+
+ .welcome-message h3 {
+ color: #667eea;
+ margin-bottom: 15px;
+ }
+
+ .test-scope {
+ margin-top: 30px;
+ text-align: left;
+ max-width: 500px;
+ margin-left: auto;
+ margin-right: auto;
+ }
+
+ .test-scope ul {
+ list-style: none;
+ padding: 0;
+ }
+
+ .test-scope li {
+ padding: 5px 0;
+ border-bottom: 1px solid #f0f0f0;
+ }
+
+ .test-log {
+ padding: 20px;
+ max-height: 500px;
+ overflow-y: auto;
+ font-family: 'Monaco', 'Consolas', monospace;
+ font-size: 14px;
+ }
+
+ .test-section {
+ font-weight: bold;
+ color: #667eea;
+ margin: 20px 0 10px 0;
+ padding: 10px 0;
+ border-bottom: 2px solid #f0f0f0;
+ }
+
+ .test-result {
+ padding: 8px 0;
+ border-left: 3px solid transparent;
+ padding-left: 15px;
+ margin: 5px 0;
+ }
+
+ .test-result.success {
+ border-left-color: #28a745;
+ background: rgba(40, 167, 69, 0.1);
+ }
+
+ .test-result.failure {
+ border-left-color: #dc3545;
+ background: rgba(220, 53, 69, 0.1);
+ }
+
+ .test-result.error {
+ border-left-color: #fd7e14;
+ background: rgba(253, 126, 20, 0.1);
+ font-weight: bold;
+ }
+
+ .test-summary {
+ margin-top: 20px;
+ padding: 30px;
+ background: white;
+ border-radius: 12px;
+ box-shadow: 0 2px 10px rgba(0,0,0,0.1);
+ }
+
+ .summary-content.excellent {
+ border-left: 5px solid #28a745;
+ }
+
+ .summary-content.good {
+ border-left: 5px solid #ffc107;
+ }
+
+ .summary-content.problems {
+ border-left: 5px solid #dc3545;
+ }
+
+ .summary-stats {
+ display: flex;
+ justify-content: space-around;
+ margin: 20px 0;
+ flex-wrap: wrap;
+ gap: 20px;
+ }
+
+ .stat {
+ text-align: center;
+ padding: 20px;
+ border-radius: 8px;
+ background: #f8f9fa;
+ min-width: 100px;
+ }
+
+ .stat.success {
+ background: rgba(40, 167, 69, 0.1);
+ }
+
+ .stat.failure {
+ background: rgba(220, 53, 69, 0.1);
+ }
+
+ .stat.rate {
+ background: rgba(102, 126, 234, 0.1);
+ }
+
+ .stat-number {
+ display: block;
+ font-size: 2em;
+ font-weight: bold;
+ margin-bottom: 5px;
+ }
+
+ .stat-label {
+ color: #666;
+ font-size: 0.9em;
+ }
+
+ .summary-status {
+ text-align: center;
+ margin-top: 20px;
+ }
+
+ .summary-status h4 {
+ font-size: 1.5em;
+ margin-bottom: 10px;
+ }
+ `;
+
+ document.head.appendChild(styles);
+ }
+}
+
+export default DRSTestRunner;
\ No newline at end of file
diff --git a/src/DRS/UnifiedDRS.js b/src/DRS/UnifiedDRS.js
index a8d8fbe..db3e153 100644
--- a/src/DRS/UnifiedDRS.js
+++ b/src/DRS/UnifiedDRS.js
@@ -40,6 +40,25 @@ class UnifiedDRS extends Module {
timeSpent: 0
};
+ // Debug & Monitoring
+ this._sessionStats = {
+ startTime: Date.now(),
+ modulesCompleted: [],
+ modulesFailed: [],
+ totalExercises: 0,
+ totalCorrect: 0,
+ averageScore: 0,
+ timePerModule: {},
+ userFailures: [],
+ retryCount: 0
+ };
+
+ // Module tracking
+ this._moduleQueue = [];
+ this._completedModules = new Set();
+ this._failedModules = new Map(); // module -> failure count
+ this._moduleWorkload = new Map(); // module -> estimated work units
+
// Component instances
this._components = {
mainCard: null,
@@ -50,10 +69,21 @@ class UnifiedDRS extends Module {
resultPanel: null
};
+ // Expose debug methods globally for console access
+ if (typeof window !== 'undefined') {
+ window.drsDebug = {
+ getInfo: () => this.getDebugInfo(),
+ logState: () => this.logDebugState(),
+ getProgress: () => this.getProgressSummary(),
+ instance: this
+ };
+ }
+
// Container and timing
this._container = null;
this._isActive = false;
this._startTime = null;
+ this._currentModule = null; // For storing current exercise module reference
// AI interface state
this._userResponses = [];
@@ -78,6 +108,10 @@ class UnifiedDRS extends Module {
this._eventBus.on('drs:submit', this._handleSubmit.bind(this), this.name);
this._eventBus.on('content:loaded', this._handleContentLoaded.bind(this), this.name);
+ // Advanced DRS events
+ this._eventBus.on('drs:exerciseCompleted', this._handleExerciseCompleted.bind(this), this.name);
+ this._eventBus.on('drs:requestNextModule', this._handleRequestNextModule.bind(this), this.name);
+
this._setInitialized();
console.log('✅ Unified DRS initialized');
}
@@ -87,6 +121,12 @@ class UnifiedDRS extends Module {
console.log('🧹 Destroying Unified DRS...');
+ // Clean up current module
+ if (this._currentModule && typeof this._currentModule.cleanup === 'function') {
+ await this._currentModule.cleanup();
+ }
+ this._currentModule = null;
+
// Clean up UI
this._cleanupUI();
@@ -123,6 +163,9 @@ class UnifiedDRS extends Module {
this._userProgress = { correct: 0, total: 0, hints: 0, timeSpent: 0 };
this._isActive = true;
+ // Store config for vocabulary override detection
+ this._lastConfig = exerciseConfig;
+
const exerciseType = exerciseConfig.type || this._config.exerciseTypes[0];
// Check if we need word discovery first
@@ -132,9 +175,9 @@ class UnifiedDRS extends Module {
return;
}
- if (this._shouldUseFlashcards(exerciseType, exerciseConfig)) {
- console.log(`📚 Using Flashcard Learning for ${exerciseType}`);
- await this._loadFlashcardModule(exerciseType, exerciseConfig);
+ if (this._shouldUseVocabularyModule(exerciseType, exerciseConfig)) {
+ console.log(`📚 Using DRS VocabularyModule for ${exerciseType}`);
+ await this._loadVocabularyModule(exerciseType, exerciseConfig);
return;
}
@@ -859,15 +902,15 @@ class UnifiedDRS extends Module {
}
/**
- * Check if we should use Flashcard system
+ * Check if we should use DRS VocabularyModule (integrated flashcard system)
*/
- _shouldUseFlashcards(exerciseType, config) {
- // Always use flashcards for vocabulary-flashcards type
+ _shouldUseVocabularyModule(exerciseType, config) {
+ // Always use VocabularyModule for vocabulary-flashcards type
if (exerciseType === 'vocabulary-flashcards') {
return true;
}
- // Force flashcards if no vocabulary is mastered yet
+ // Force VocabularyModule if no vocabulary is mastered yet
try {
const moduleLoader = window.app.getCore().moduleLoader;
const orchestrator = moduleLoader.getModule('smartPreviewOrchestrator');
@@ -878,9 +921,21 @@ class UnifiedDRS extends Module {
console.log(`📊 Current vocabulary mastery: ${vocabularyMastery}%`);
- // If less than 20% vocabulary mastered, force flashcards first
+ // If less than 20% vocabulary mastered, force VocabularyModule first
if (vocabularyMastery < 20) {
- console.log(`🔄 Vocabulary mastery too low (${vocabularyMastery}%), redirecting to flashcards`);
+ console.log(`🔄 Vocabulary mastery too low (${vocabularyMastery}%), redirecting to VocabularyModule`);
+
+ // Signal to Smart Guide that we're overriding the exercise type
+ if (typeof window !== 'undefined') {
+ window.vocabularyOverrideActive = {
+ originalType: this._lastConfig?.type || 'unknown',
+ originalDifficulty: this._lastConfig?.difficulty || 'unknown',
+ vocabularyMastery: vocabularyMastery,
+ reason: `Vocabulary mastery too low (${vocabularyMastery}%)`
+ };
+ console.log('📚 Vocabulary override signaled to Smart Guide:', window.vocabularyOverrideActive);
+ }
+
return true;
}
}
@@ -943,92 +998,119 @@ class UnifiedDRS extends Module {
}
/**
- * Load existing Flashcard Learning game
+ * Load DRS VocabularyModule (integrated flashcard system)
*/
- async _loadFlashcardModule(exerciseType, config) {
+ async _loadVocabularyModule(exerciseType, config) {
try {
- console.log('📚 Loading Flashcard Learning game directly...');
+ console.log('📚 Loading DRS VocabularyModule (flashcard system)...');
- // Load content for flashcards
- const contentRequest = {
- type: 'exercise',
- subtype: 'vocabulary-flashcards',
- bookId: config.bookId,
- chapterId: config.chapterId,
- difficulty: config.difficulty || 'medium'
- };
+ // Load content for vocabulary exercises
+ const chapterContent = await this._contentLoader.getContent(config.chapterId);
+ console.log('📚 Vocabulary content loaded for', config.chapterId);
- const chapterContent = await this._contentLoader.loadExercise(contentRequest);
- console.log('📚 Flashcard content loaded for', config.chapterId);
-
- // Clear container
- this._container.innerHTML = `
-
- `;
-
- // Import and create FlashcardLearning
- const { default: FlashcardLearning } = await import('../games/FlashcardLearning.js');
-
- // Get the game container first
- const gameContainer = this._container.querySelector('#flashcard-game-container');
-
- // Preload content for FlashcardLearning (it expects sync access)
- const preloadedContent = await this._contentLoader.getContent(config.chapterId);
- if (!preloadedContent || !preloadedContent.vocabulary) {
+ if (!chapterContent || !chapterContent.vocabulary) {
throw new Error('No vocabulary content found for flashcards');
}
- // Set global variables that FlashcardLearning expects
- window.currentChapterId = config.chapterId;
- window.contentLoader = {
- getContent: () => preloadedContent // Return preloaded content synchronously
- };
+ // Import VocabularyModule from DRS
+ const { default: VocabularyModule } = await import('./exercise-modules/VocabularyModule.js');
- // Get PrerequisiteEngine from orchestrator
+ // Get shared services from orchestrator or create fallbacks
let prerequisiteEngine = null;
+ let contextMemory = null;
try {
const moduleLoader = window.app.getCore().moduleLoader;
const orchestrator = moduleLoader.getModule('smartPreviewOrchestrator');
- if (orchestrator) {
- prerequisiteEngine = orchestrator.sharedServices?.prerequisiteEngine || orchestrator.prerequisiteEngine;
+ if (orchestrator && orchestrator.sharedServices) {
+ prerequisiteEngine = orchestrator.sharedServices.prerequisiteEngine;
+ contextMemory = orchestrator.sharedServices.contextMemory;
}
} catch (error) {
- console.log('Could not get prerequisite engine for flashcards:', error);
+ console.log('Could not get shared services, will create fallbacks:', error);
}
- const flashcardGame = new FlashcardLearning('flashcardLearning', {
- eventBus: this._eventBus,
- contentLoader: this._contentLoader,
- prerequisiteEngine: prerequisiteEngine
- }, {
- container: gameContainer, // Pass container in config
- difficulty: config.difficulty || 'medium',
- sessionLength: 10
+ // Create PrerequisiteEngine if not available
+ if (!prerequisiteEngine) {
+ console.log('📚 Creating real PrerequisiteEngine for VocabularyModule');
+
+ // Import and create real PrerequisiteEngine
+ const PrerequisiteEngine = (await import('./services/PrerequisiteEngine.js')).default;
+ prerequisiteEngine = new PrerequisiteEngine();
+
+ // Initialize with chapter content
+ if (chapterContent) {
+ prerequisiteEngine.analyzeChapter(chapterContent);
+ console.log(`📚 Initialized PrerequisiteEngine with chapter content`);
+ }
+ }
+
+ if (!contextMemory) {
+ console.log('📚 Creating fallback ContextMemory for VocabularyModule');
+ contextMemory = {
+ recordInteraction: (interaction) => {
+ console.log('📝 Interaction recorded (fallback):', interaction.type);
+ }
+ };
+ }
+
+ // Create VocabularyModule instance
+ const vocabularyModule = new VocabularyModule(
+ this, // orchestrator reference
+ null, // llmValidator (not needed for local validation)
+ prerequisiteEngine,
+ contextMemory
+ );
+
+ // Store reference for cleanup
+ this._currentModule = vocabularyModule;
+
+ // Initialize the module
+ await vocabularyModule.init();
+
+ // Prepare exercise data - convert vocabulary to expected format
+ const vocabularyArray = Object.entries(chapterContent.vocabulary).map(([word, data]) => {
+ // Extract translation string from various possible formats
+ let translation;
+ if (typeof data === 'string') {
+ translation = data;
+ } else if (data && typeof data === 'object') {
+ // Try various translation fields in order of preference
+ translation = data.translation ||
+ data.meaning ||
+ data.user_language || // Primary: user_language field
+ data.target_language || // Alternative: target_language field
+ data.fr ||
+ data.definition ||
+ Object.values(data).find(val => typeof val === 'string' && val !== word) || // Find any string value that's not the word itself
+ word; // Fallback to the word itself
+ } else {
+ translation = String(data || word);
+ }
+
+ return {
+ word: word,
+ translation: translation,
+ pronunciation: data && typeof data === 'object' ? data.pronunciation : null,
+ type: data && typeof data === 'object' ? (data.type || 'word') : 'word'
+ };
});
- // Register with EventBus first
- this._eventBus.registerModule(flashcardGame);
+ // Present vocabulary exercises
+ await vocabularyModule.present(this._container, {
+ vocabulary: vocabularyArray,
+ chapterId: config.chapterId,
+ exerciseType: exerciseType
+ });
- // Initialize
- await flashcardGame.init();
-
- // Start the flashcard game
- await flashcardGame.start(gameContainer, chapterContent);
-
- console.log('✅ Flashcard Learning started successfully');
+ console.log('✅ DRS VocabularyModule (flashcards) started successfully');
} catch (error) {
- console.error('❌ Failed to load flashcards:', error);
+ console.error('❌ Failed to load DRS VocabularyModule:', error);
this._container.innerHTML = `
-
❌ Flashcard Error
-
Failed to load flashcards: ${error.message}
+
❌ Vocabulary Error
+
Failed to load vocabulary flashcards: ${error.message}
+
This is the DRS integrated system, not an external game.
`;
}
@@ -1555,6 +1637,73 @@ class UnifiedDRS extends Module {
console.log('📚 Content loaded event:', event);
}
+ /**
+ * Handle exercise completion from modules like VocabularyModule
+ */
+ _handleExerciseCompleted(event) {
+ console.group('🏁 Exercise completed event received');
+ console.log('📊 Event data:', event);
+
+ const { moduleType, results, progress } = event;
+
+ // Calculate score from results
+ let totalScore = 0;
+ let totalItems = 0;
+
+ if (Array.isArray(results)) {
+ totalItems = results.length;
+ totalScore = results.reduce((sum, result) => sum + (result.score || 0), 0);
+ } else if (results && typeof results.score === 'number') {
+ totalScore = results.score;
+ totalItems = 1;
+ }
+
+ const averageScore = totalItems > 0 ? Math.round(totalScore / totalItems) : 0;
+
+ // Create result object
+ const result = {
+ success: averageScore >= 50, // 50% threshold for success
+ score: averageScore,
+ duration: Date.now() - (this._startTime || Date.now()),
+ moduleType: moduleType,
+ details: results
+ };
+
+ console.log('📈 Calculated result:', result);
+
+ // Set current module reference for tracking
+ this._currentModule = { name: moduleType };
+
+ // Use the completion system
+ const completion = this.completeCurrentModule(result);
+ console.log('✅ Completion processed:', completion);
+
+ console.groupEnd();
+ }
+
+ /**
+ * Handle request for next module
+ */
+ _handleRequestNextModule(event) {
+ console.group('🎯 Next module request received');
+ console.log('📊 Request data:', event);
+
+ // This would integrate with the main module loading system
+ // For now, just log the request
+ console.log('🔄 Would decide next module based on:', {
+ currentProgress: event.currentProgress,
+ userLevel: event.userLevel
+ });
+
+ console.groupEnd();
+
+ // Emit back to system for handling
+ this._eventBus.emit('drs:nextModuleDecided', {
+ recommendation: 'continue',
+ nextModuleType: 'auto-select'
+ }, this.name);
+ }
+
/**
* Validate current step input
*/
@@ -1654,6 +1803,603 @@ class UnifiedDRS extends Module {
console.log('🎉 Exercise completed!', finalStats);
}
+ // ===== DEBUG & MONITORING METHODS =====
+
+ /**
+ * Get comprehensive debug information
+ */
+ getDebugInfo() {
+ return {
+ session: {
+ duration: Date.now() - this._sessionStats.startTime,
+ startTime: new Date(this._sessionStats.startTime).toISOString(),
+ modulesCompleted: this._sessionStats.modulesCompleted,
+ modulesFailed: this._sessionStats.modulesFailed,
+ totalExercises: this._sessionStats.totalExercises,
+ averageScore: this._sessionStats.averageScore,
+ retryCount: this._sessionStats.retryCount
+ },
+ currentState: {
+ activeModule: this._currentModule?.name || 'none',
+ currentStep: this._currentStep,
+ totalSteps: this._totalSteps,
+ isActive: this._isActive
+ },
+ moduleQueue: {
+ remaining: this._moduleQueue.length,
+ completed: Array.from(this._completedModules),
+ failed: Object.fromEntries(this._failedModules),
+ workload: Object.fromEntries(this._moduleWorkload)
+ },
+ userProgress: { ...this._userProgress },
+ failures: this._sessionStats.userFailures.slice(-10) // Last 10 failures
+ };
+ }
+
+ /**
+ * Log current DRS state for debugging
+ */
+ logDebugState() {
+ const debugInfo = this.getDebugInfo();
+ console.group('🔍 DRS Debug State');
+ console.log('📊 Session:', debugInfo.session);
+ console.log('🎯 Current:', debugInfo.currentState);
+ console.log('📋 Queue:', debugInfo.moduleQueue);
+ console.log('👤 User:', debugInfo.userProgress);
+ console.log('⚠️ Recent Failures:', debugInfo.failures);
+ console.groupEnd();
+ return debugInfo;
+ }
+
+ /**
+ * Track module completion
+ */
+ _trackModuleCompletion(moduleName, result) {
+ const completionTime = Date.now();
+ const startTime = this._sessionStats.timePerModule[moduleName]?.start || completionTime;
+ const duration = completionTime - startTime;
+
+ this._sessionStats.timePerModule[moduleName] = {
+ start: startTime,
+ end: completionTime,
+ duration: duration,
+ result: result
+ };
+
+ if (result.success) {
+ this._completedModules.add(moduleName);
+ this._sessionStats.modulesCompleted.push({
+ name: moduleName,
+ completedAt: new Date(completionTime).toISOString(),
+ duration: duration,
+ score: result.score || 0
+ });
+ } else {
+ this._failedModules.set(moduleName, (this._failedModules.get(moduleName) || 0) + 1);
+ this._sessionStats.modulesFailed.push({
+ name: moduleName,
+ failedAt: new Date(completionTime).toISOString(),
+ reason: result.reason || 'unknown',
+ attemptNumber: this._failedModules.get(moduleName)
+ });
+ }
+
+ this._updateSessionStats();
+ console.log(`📈 Module ${moduleName} ${result.success ? 'completed' : 'failed'} in ${duration}ms`);
+ }
+
+ /**
+ * Track user failure
+ */
+ _trackUserFailure(exercise, userAnswer, expectedAnswer, attemptNumber = 1) {
+ this._sessionStats.userFailures.push({
+ timestamp: new Date().toISOString(),
+ exercise: exercise.type || 'unknown',
+ userAnswer: userAnswer,
+ expectedAnswer: expectedAnswer,
+ attemptNumber: attemptNumber,
+ module: this._currentModule?.name || 'unknown'
+ });
+
+ // Update retry count if this is a retry
+ if (attemptNumber > 1) {
+ this._sessionStats.retryCount++;
+ }
+
+ console.log(`❌ User failure tracked: ${exercise.type} (attempt ${attemptNumber})`);
+ }
+
+ /**
+ * Estimate workload for a module type
+ */
+ _estimateModuleWorkload(moduleType, contentData) {
+ const workloadMap = {
+ 'vocabulary-flashcards': (data) => (data.vocabulary?.length || 5) * 0.5, // 30s per word
+ 'reading-comprehension': (data) => (data.content?.length || 1000) / 200, // ~200 words per minute
+ 'grammar-practice': (data) => (data.exercises?.length || 3) * 2, // 2 min per exercise
+ 'listening-comprehension': (data) => (data.audioDuration || 120) / 60 + 2, // audio + questions
+ 'translation': (data) => (data.sentences?.length || 5) * 1.5, // 1.5 min per sentence
+ 'default': () => 3 // 3 minutes default
+ };
+
+ const estimator = workloadMap[moduleType] || workloadMap.default;
+ const workUnits = estimator(contentData);
+
+ this._moduleWorkload.set(moduleType, workUnits);
+ console.log(`📊 Estimated workload for ${moduleType}: ${workUnits.toFixed(1)} minutes`);
+
+ return workUnits;
+ }
+
+ /**
+ * Update session statistics
+ */
+ _updateSessionStats() {
+ const completedCount = this._sessionStats.modulesCompleted.length;
+ if (completedCount > 0) {
+ const totalScore = this._sessionStats.modulesCompleted.reduce((sum, m) => sum + (m.score || 0), 0);
+ this._sessionStats.averageScore = Math.round(totalScore / completedCount);
+ }
+
+ this._sessionStats.totalExercises = this._sessionStats.modulesCompleted.length + this._sessionStats.modulesFailed.length;
+ }
+
+ /**
+ * Get progress summary for UI display
+ */
+ getProgressSummary() {
+ const completed = this._completedModules.size;
+ const failed = this._failedModules.size;
+ const remaining = this._moduleQueue.length;
+ const total = completed + failed + remaining;
+
+ const totalWorkload = Array.from(this._moduleWorkload.values()).reduce((sum, w) => sum + w, 0);
+ const completedWorkload = this._sessionStats.modulesCompleted.reduce((sum, m) => {
+ return sum + (this._moduleWorkload.get(m.name) || 0);
+ }, 0);
+
+ return {
+ modules: { completed, failed, remaining, total },
+ workload: {
+ completed: Math.round(completedWorkload),
+ total: Math.round(totalWorkload),
+ percentage: total > 0 ? Math.round((completedWorkload / totalWorkload) * 100) : 0
+ },
+ session: {
+ duration: Date.now() - this._sessionStats.startTime,
+ averageScore: this._sessionStats.averageScore,
+ retryCount: this._sessionStats.retryCount
+ }
+ };
+ }
+
+ // ===== MODULE DECISION ALGORITHM =====
+
+ /**
+ * Decide next module based on user performance and content
+ */
+ decideNextModule(availableModules, userPerformance) {
+ console.group('🧠 Deciding next module...');
+
+ // Filter available modules
+ const candidateModules = this._filterCandidateModules(availableModules);
+ console.log('📋 Candidate modules:', candidateModules.map(m => m.type));
+
+ if (candidateModules.length === 0) {
+ console.log('⭐ No more modules available - session complete!');
+ console.groupEnd();
+ return null;
+ }
+
+ // Score each candidate module
+ const scoredModules = candidateModules.map(module => ({
+ ...module,
+ score: this._scoreModule(module, userPerformance)
+ }));
+
+ // Sort by score (higher is better)
+ scoredModules.sort((a, b) => b.score - a.score);
+
+ const selected = scoredModules[0];
+ console.log('🎯 Module scores:');
+ scoredModules.forEach(m => console.log(` ${m.type}: ${m.score.toFixed(2)}`));
+ console.log(`✅ Selected: ${selected.type} (score: ${selected.score.toFixed(2)})`);
+ console.groupEnd();
+
+ // Track the decision
+ this._trackDecision(selected, scoredModules, userPerformance);
+
+ return selected;
+ }
+
+ /**
+ * Filter modules that can be attempted
+ */
+ _filterCandidateModules(availableModules) {
+ return availableModules.filter(module => {
+ // Skip completed modules
+ if (this._completedModules.has(module.type)) {
+ return false;
+ }
+
+ // Skip modules that failed too many times (max 3 attempts)
+ const failCount = this._failedModules.get(module.type) || 0;
+ if (failCount >= 3) {
+ console.log(`⚠️ Skipping ${module.type} - too many failures (${failCount})`);
+ return false;
+ }
+
+ // Check prerequisites
+ if (module.prerequisites && module.prerequisites.length > 0) {
+ const missingPrereqs = module.prerequisites.filter(prereq =>
+ !this._completedModules.has(prereq)
+ );
+ if (missingPrereqs.length > 0) {
+ console.log(`⚠️ Skipping ${module.type} - missing prerequisites: ${missingPrereqs.join(', ')}`);
+ return false;
+ }
+ }
+
+ return true;
+ });
+ }
+
+ /**
+ * Score a module based on various factors
+ */
+ _scoreModule(module, userPerformance) {
+ let score = 100; // Base score
+
+ // Factor 1: User performance in similar modules
+ const similarPerformance = this._getSimilarModulePerformance(module.type);
+ if (similarPerformance.count > 0) {
+ const avgScore = similarPerformance.avgScore;
+ if (avgScore < 60) {
+ score += 30; // Boost modules where user struggles
+ } else if (avgScore > 85) {
+ score -= 15; // Reduce modules where user excels
+ }
+ }
+
+ // Factor 2: Module difficulty vs user level
+ const userLevel = this._estimateUserLevel();
+ const difficultyPenalty = this._calculateDifficultyPenalty(module.difficulty, userLevel);
+ score -= difficultyPenalty;
+
+ // Factor 3: Failed attempts penalty
+ const failCount = this._failedModules.get(module.type) || 0;
+ score -= failCount * 20; // -20 points per previous failure
+
+ // Factor 4: Content variety bonus
+ const recentModuleTypes = this._sessionStats.modulesCompleted
+ .slice(-3)
+ .map(m => m.name.split('-')[0]); // Get module category
+ const moduleCategory = module.type.split('-')[0];
+ if (!recentModuleTypes.includes(moduleCategory)) {
+ score += 15; // Bonus for variety
+ }
+
+ // Factor 5: Workload balancing
+ const estimatedWorkload = this._estimateModuleWorkload(module.type, module.content);
+ if (estimatedWorkload < 2) {
+ score += 10; // Bonus for quick modules
+ } else if (estimatedWorkload > 5) {
+ score -= 10; // Penalty for long modules
+ }
+
+ // Factor 6: Learning path optimization
+ if (module.isCore) {
+ score += 25; // Prioritize core modules
+ }
+
+ return Math.max(0, score); // Never negative
+ }
+
+ /**
+ * Get performance in similar module types
+ */
+ _getSimilarModulePerformance(moduleType) {
+ const category = moduleType.split('-')[0]; // e.g., 'vocabulary' from 'vocabulary-flashcards'
+ const similarModules = this._sessionStats.modulesCompleted.filter(m =>
+ m.name.startsWith(category)
+ );
+
+ if (similarModules.length === 0) {
+ return { count: 0, avgScore: 0 };
+ }
+
+ const avgScore = similarModules.reduce((sum, m) => sum + m.score, 0) / similarModules.length;
+ return { count: similarModules.length, avgScore };
+ }
+
+ /**
+ * Estimate user's current level
+ */
+ _estimateUserLevel() {
+ if (this._sessionStats.averageScore >= 85) return 'advanced';
+ if (this._sessionStats.averageScore >= 70) return 'intermediate';
+ if (this._sessionStats.averageScore >= 50) return 'beginner';
+ return 'novice';
+ }
+
+ /**
+ * Calculate difficulty penalty
+ */
+ _calculateDifficultyPenalty(moduleDifficulty, userLevel) {
+ const difficultyMap = { easy: 1, medium: 2, hard: 3, expert: 4 };
+ const levelMap = { novice: 1, beginner: 2, intermediate: 3, advanced: 4 };
+
+ const difficultyScore = difficultyMap[moduleDifficulty] || 2;
+ const userScore = levelMap[userLevel] || 2;
+
+ const gap = Math.abs(difficultyScore - userScore);
+ return gap * 10; // 10 points penalty per level gap
+ }
+
+ /**
+ * Track decision for analysis
+ */
+ _trackDecision(selectedModule, allCandidates, userPerformance) {
+ if (!this._sessionStats.decisions) {
+ this._sessionStats.decisions = [];
+ }
+
+ this._sessionStats.decisions.push({
+ timestamp: new Date().toISOString(),
+ selected: selectedModule.type,
+ selectedScore: selectedModule.score,
+ candidates: allCandidates.map(m => ({ type: m.type, score: m.score })),
+ userLevel: this._estimateUserLevel(),
+ sessionLength: this._sessionStats.modulesCompleted.length
+ });
+ }
+
+ /**
+ * Handle user failure with retry/skip options
+ */
+ handleUserFailure(exercise, userAnswer, expectedAnswer, attemptNumber = 1) {
+ console.group('❌ Handling user failure...');
+
+ // Track the failure
+ this._trackUserFailure(exercise, userAnswer, expectedAnswer, attemptNumber);
+
+ // Decide on next action
+ const action = this._decideFailureAction(exercise, attemptNumber);
+ console.log(`🎯 Failure action decided: ${action.type}`);
+ console.groupEnd();
+
+ return action;
+ }
+
+ /**
+ * Decide what to do after user failure
+ */
+ _decideFailureAction(exercise, attemptNumber) {
+ // Too many attempts on this specific exercise
+ if (attemptNumber >= 3) {
+ return {
+ type: 'skip',
+ reason: 'max_attempts_reached',
+ message: 'Moving to next exercise after 3 attempts'
+ };
+ }
+
+ // Easy exercises should be retried quickly
+ if (exercise.difficulty === 'easy' && attemptNumber < 2) {
+ return {
+ type: 'retry',
+ reason: 'easy_exercise',
+ message: 'Let\'s try again - this should be manageable',
+ showHint: true
+ };
+ }
+
+ // Hard exercises get more chances with help
+ if (exercise.difficulty === 'hard' || exercise.difficulty === 'expert') {
+ return {
+ type: 'retry',
+ reason: 'challenging_content',
+ message: 'This is challenging - here\'s some help',
+ showHint: true,
+ simplify: true
+ };
+ }
+
+ // Default: offer choice
+ return {
+ type: 'choice',
+ reason: 'standard_failure',
+ message: 'Would you like to try again or skip this exercise?',
+ options: ['retry', 'skip']
+ };
+ }
+
+ // ===== COMPLETION SYSTEM =====
+
+ /**
+ * Complete current module and decide next action
+ */
+ completeCurrentModule(result) {
+ console.group('🏁 Completing current module...');
+
+ const moduleName = this._currentModule?.name || 'unknown';
+ console.log(`📋 Module: ${moduleName}`);
+ console.log(`📊 Result:`, result);
+
+ // Track completion
+ this._trackModuleCompletion(moduleName, result);
+
+ // Generate completion summary
+ const summary = this._generateCompletionSummary(result);
+ console.log(`📈 Summary:`, summary);
+
+ // Decide next action
+ const nextAction = this._decideNextAction(result, summary);
+ console.log(`🎯 Next action:`, nextAction);
+
+ console.groupEnd();
+
+ // Execute the decided action
+ this._executeNextAction(nextAction, summary);
+
+ return {
+ completed: moduleName,
+ summary: summary,
+ nextAction: nextAction
+ };
+ }
+
+ /**
+ * Generate completion summary
+ */
+ _generateCompletionSummary(result) {
+ const progress = this.getProgressSummary();
+
+ return {
+ moduleResult: result,
+ sessionProgress: progress,
+ userLevel: this._estimateUserLevel(),
+ recommendations: this._generateRecommendations(result, progress),
+ timeSpent: result.duration || 0,
+ efficiency: this._calculateEfficiency(result)
+ };
+ }
+
+ /**
+ * Decide what to do next after module completion
+ */
+ _decideNextAction(result, summary) {
+ // If session is complete
+ if (summary.sessionProgress.modules.remaining === 0) {
+ return {
+ type: 'session_complete',
+ message: 'Congratulations! You\'ve completed all available exercises.',
+ showFinalReport: true
+ };
+ }
+
+ // If user is struggling (low score + high failure rate)
+ if (result.score < 50 && this._sessionStats.retryCount > 5) {
+ return {
+ type: 'break_suggested',
+ message: 'Consider taking a break. You\'ve been working hard!',
+ options: ['continue', 'break', 'easier_content']
+ };
+ }
+
+ // If user is excelling
+ if (result.score > 85 && summary.sessionProgress.modules.completed > 3) {
+ return {
+ type: 'advance_difficulty',
+ message: 'Great performance! Ready for more challenging content?',
+ options: ['continue', 'harder_content', 'skip_easy']
+ };
+ }
+
+ // Standard progression
+ return {
+ type: 'continue',
+ message: 'Ready for the next exercise?',
+ autoAdvance: result.score > 70 // Auto-advance if doing well
+ };
+ }
+
+ /**
+ * Execute the decided next action
+ */
+ _executeNextAction(action, summary) {
+ switch (action.type) {
+ case 'continue':
+ if (action.autoAdvance) {
+ setTimeout(() => this._loadNextModule(), 2000);
+ } else {
+ this._showContinuePrompt(action.message);
+ }
+ break;
+
+ case 'session_complete':
+ this._showSessionCompleteScreen(summary);
+ break;
+
+ case 'break_suggested':
+ this._showBreakSuggestion(action);
+ break;
+
+ case 'advance_difficulty':
+ this._showDifficultyAdvancement(action);
+ break;
+
+ default:
+ console.warn('Unknown action type:', action.type);
+ this._showContinuePrompt('Ready to continue?');
+ }
+ }
+
+ /**
+ * Generate personalized recommendations
+ */
+ _generateRecommendations(result, progress) {
+ const recommendations = [];
+
+ // Performance-based recommendations
+ if (result.score < 60) {
+ recommendations.push({
+ type: 'review',
+ message: 'Consider reviewing this topic before moving on',
+ priority: 'high'
+ });
+ }
+
+ // Workload recommendations
+ if (progress.session.duration > 1800000) { // 30 minutes
+ recommendations.push({
+ type: 'break',
+ message: 'You\'ve been studying for a while. A short break might help',
+ priority: 'medium'
+ });
+ }
+
+ // Difficulty recommendations
+ const userLevel = this._estimateUserLevel();
+ if (userLevel === 'advanced' && result.score > 90) {
+ recommendations.push({
+ type: 'challenge',
+ message: 'Try more challenging exercises to maximize learning',
+ priority: 'low'
+ });
+ }
+
+ return recommendations;
+ }
+
+ /**
+ * Calculate learning efficiency
+ */
+ _calculateEfficiency(result) {
+ const timeSpent = result.duration || 0;
+ const score = result.score || 0;
+
+ if (timeSpent === 0) return 0;
+
+ // Efficiency = score per minute * 100
+ const efficiency = (score / (timeSpent / 60000)) * 100;
+ return Math.round(efficiency);
+ }
+
+ /**
+ * Load next module in sequence
+ */
+ _loadNextModule() {
+ // This would integrate with the main module loading system
+ console.log('🔄 Loading next module...');
+
+ // Emit event for module loader
+ this._eventBus.emit('drs:requestNextModule', {
+ currentProgress: this.getProgressSummary(),
+ userLevel: this._estimateUserLevel()
+ }, this.name);
+ }
+
/**
* Clean up UI
*/
diff --git a/src/DRS/exercise-modules/OpenResponseModule.js b/src/DRS/exercise-modules/OpenResponseModule.js
new file mode 100644
index 0000000..62d7fd5
--- /dev/null
+++ b/src/DRS/exercise-modules/OpenResponseModule.js
@@ -0,0 +1,612 @@
+/**
+ * OpenResponseModule - Free-form open response exercises with AI validation
+ * Allows students to write free-text responses that are evaluated by AI
+ */
+
+import ExerciseModuleInterface from '../interfaces/ExerciseModuleInterface.js';
+
+class OpenResponseModule extends ExerciseModuleInterface {
+ constructor(orchestrator, llmValidator, prerequisiteEngine, contextMemory) {
+ super();
+
+ // Validate dependencies
+ if (!orchestrator || !llmValidator || !prerequisiteEngine || !contextMemory) {
+ throw new Error('OpenResponseModule requires all service dependencies');
+ }
+
+ this.orchestrator = orchestrator;
+ this.llmValidator = llmValidator;
+ this.prerequisiteEngine = prerequisiteEngine;
+ this.contextMemory = contextMemory;
+
+ // Module state
+ this.initialized = false;
+ this.container = null;
+ this.currentExerciseData = null;
+ this.currentQuestion = null;
+ this.userResponse = '';
+ this.validationInProgress = false;
+ this.lastValidationResult = null;
+
+ // Configuration
+ this.config = {
+ requiredProvider: 'openai', // Open response needs good comprehension
+ model: 'gpt-4o-mini',
+ temperature: 0.2, // Low for consistent evaluation
+ maxTokens: 1000,
+ timeout: 45000,
+ minResponseLength: 10, // Minimum characters for response
+ maxResponseLength: 2000, // Maximum characters for response
+ allowMultipleAttempts: true,
+ feedbackDepth: 'detailed' // detailed, brief, or minimal
+ };
+
+ // Progress tracking
+ this.progress = {
+ questionsAnswered: 0,
+ questionsCorrect: 0,
+ averageScore: 0,
+ totalAttempts: 0,
+ timeSpent: 0,
+ startTime: null
+ };
+ }
+
+ /**
+ * Check if module can run with given content
+ */
+ canRun(prerequisites, chapterContent) {
+ // Can run with any content - will generate open questions
+ return chapterContent && (
+ chapterContent.vocabulary ||
+ chapterContent.texts ||
+ chapterContent.phrases ||
+ chapterContent.grammar
+ );
+ }
+
+ /**
+ * Present the open response exercise
+ */
+ async present(container, exerciseData) {
+ this.container = container;
+ this.currentExerciseData = exerciseData;
+ this.progress.startTime = Date.now();
+
+ console.log('📝 Starting Open Response exercise...');
+
+ // Generate or select question
+ await this._generateQuestion();
+
+ // Create UI
+ this._createExerciseInterface();
+
+ this.initialized = true;
+ }
+
+ /**
+ * Validate user response using AI
+ */
+ async validate(userInput, context) {
+ if (this.validationInProgress) {
+ return { score: 0, feedback: 'Validation already in progress', isCorrect: false };
+ }
+
+ this.validationInProgress = true;
+ this.userResponse = userInput.trim();
+
+ try {
+ // Basic validation
+ if (this.userResponse.length < this.config.minResponseLength) {
+ return {
+ score: 0,
+ feedback: `Response too short. Please provide at least ${this.config.minResponseLength} characters.`,
+ isCorrect: false,
+ suggestions: ['Try to elaborate more on your answer', 'Provide more details and examples']
+ };
+ }
+
+ if (this.userResponse.length > this.config.maxResponseLength) {
+ return {
+ score: 0,
+ feedback: `Response too long. Please keep it under ${this.config.maxResponseLength} characters.`,
+ isCorrect: false,
+ suggestions: ['Try to be more concise', 'Focus on the main points']
+ };
+ }
+
+ // AI validation
+ const aiResult = await this._validateWithAI();
+
+ // Update progress
+ this._updateProgress(aiResult);
+
+ this.lastValidationResult = aiResult;
+ return aiResult;
+
+ } catch (error) {
+ console.error('Open response validation error:', error);
+ return {
+ score: 0.5,
+ feedback: 'Unable to validate response. Please try again.',
+ isCorrect: false,
+ error: error.message
+ };
+ } finally {
+ this.validationInProgress = false;
+ }
+ }
+
+ /**
+ * Get current progress
+ */
+ getProgress() {
+ const timeSpent = this.progress.startTime ? Date.now() - this.progress.startTime : 0;
+
+ return {
+ type: 'open-response',
+ questionsAnswered: this.progress.questionsAnswered,
+ questionsCorrect: this.progress.questionsCorrect,
+ accuracy: this.progress.questionsAnswered > 0 ?
+ this.progress.questionsCorrect / this.progress.questionsAnswered : 0,
+ averageScore: this.progress.averageScore,
+ timeSpent: timeSpent,
+ currentQuestion: this.currentQuestion?.question,
+ responseLength: this.userResponse.length
+ };
+ }
+
+ /**
+ * Get module metadata
+ */
+ getMetadata() {
+ return {
+ name: 'Open Response',
+ type: 'open-response',
+ difficulty: 'advanced',
+ estimatedTime: 300, // 5 minutes per question
+ capabilities: ['creative_writing', 'comprehension', 'analysis'],
+ prerequisites: ['basic_vocabulary']
+ };
+ }
+
+ /**
+ * Cleanup module
+ */
+ cleanup() {
+ if (this.container) {
+ this.container.innerHTML = '';
+ }
+ this.initialized = false;
+ this.validationInProgress = false;
+ }
+
+ // Private methods
+
+ /**
+ * Generate open response question
+ */
+ async _generateQuestion() {
+ const chapterContent = this.currentExerciseData.chapterContent || {};
+
+ // Question types based on available content
+ const questionTypes = [];
+
+ if (chapterContent.vocabulary) {
+ questionTypes.push('vocabulary_usage', 'vocabulary_explanation');
+ }
+
+ if (chapterContent.texts) {
+ questionTypes.push('text_comprehension', 'text_analysis');
+ }
+
+ if (chapterContent.phrases) {
+ questionTypes.push('phrase_creation', 'situation_usage');
+ }
+
+ if (chapterContent.grammar) {
+ questionTypes.push('grammar_explanation', 'grammar_examples');
+ }
+
+ // Fallback questions
+ if (questionTypes.length === 0) {
+ questionTypes.push('general_discussion', 'opinion_question');
+ }
+
+ const selectedType = questionTypes[Math.floor(Math.random() * questionTypes.length)];
+ this.currentQuestion = await this._createQuestionByType(selectedType, chapterContent);
+ }
+
+ /**
+ * Create question based on type
+ */
+ async _createQuestionByType(type, content) {
+ const questions = {
+ vocabulary_usage: {
+ question: this._createVocabularyUsageQuestion(content.vocabulary),
+ type: 'vocabulary',
+ expectedLength: 100,
+ criteria: ['correct_word_usage', 'context_appropriateness', 'grammar']
+ },
+ vocabulary_explanation: {
+ question: this._createVocabularyExplanationQuestion(content.vocabulary),
+ type: 'vocabulary',
+ expectedLength: 150,
+ criteria: ['accuracy', 'clarity', 'examples']
+ },
+ text_comprehension: {
+ question: this._createTextComprehensionQuestion(content.texts),
+ type: 'comprehension',
+ expectedLength: 200,
+ criteria: ['understanding', 'details', 'inference']
+ },
+ phrase_creation: {
+ question: this._createPhraseCreationQuestion(content.phrases),
+ type: 'creative',
+ expectedLength: 150,
+ criteria: ['creativity', 'relevance', 'grammar']
+ },
+ grammar_explanation: {
+ question: this._createGrammarExplanationQuestion(content.grammar),
+ type: 'grammar',
+ expectedLength: 180,
+ criteria: ['accuracy', 'examples', 'clarity']
+ },
+ general_discussion: {
+ question: this._createGeneralDiscussionQuestion(),
+ type: 'discussion',
+ expectedLength: 200,
+ criteria: ['coherence', 'development', 'language_use']
+ }
+ };
+
+ return questions[type] || questions.general_discussion;
+ }
+
+ _createVocabularyUsageQuestion(vocabulary) {
+ if (!vocabulary || Object.keys(vocabulary).length === 0) {
+ return "Describe your daily routine using as much detail as possible.";
+ }
+
+ const words = Object.keys(vocabulary);
+ const selectedWords = words.slice(0, 3).join(', ');
+
+ return `Write a short paragraph using these words: ${selectedWords}. Make sure to use each word correctly in context.`;
+ }
+
+ _createVocabularyExplanationQuestion(vocabulary) {
+ if (!vocabulary || Object.keys(vocabulary).length === 0) {
+ return "Explain the difference between 'house' and 'home' and give examples.";
+ }
+
+ const words = Object.keys(vocabulary);
+ const selectedWord = words[Math.floor(Math.random() * words.length)];
+
+ return `Explain the meaning of "${selectedWord}" and provide at least two example sentences showing how to use it.`;
+ }
+
+ _createTextComprehensionQuestion(texts) {
+ if (!texts || texts.length === 0) {
+ return "Describe a memorable experience you had and explain why it was important to you.";
+ }
+
+ return "Based on the chapter content, what are the main themes discussed and how do they relate to everyday life?";
+ }
+
+ _createPhraseCreationQuestion(phrases) {
+ if (!phrases || Object.keys(phrases).length === 0) {
+ return "Create a dialogue between two people meeting for the first time.";
+ }
+
+ return "Using the phrases from this chapter, write a short conversation that might happen in a real-life situation.";
+ }
+
+ _createGrammarExplanationQuestion(grammar) {
+ if (!grammar || Object.keys(grammar).length === 0) {
+ return "Explain when to use 'a' vs 'an' and give three examples of each.";
+ }
+
+ const concepts = Object.keys(grammar);
+ const selectedConcept = concepts[Math.floor(Math.random() * concepts.length)];
+
+ return `Explain the grammar rule for "${selectedConcept}" and provide examples showing correct and incorrect usage.`;
+ }
+
+ _createGeneralDiscussionQuestion() {
+ const questions = [
+ "What advice would you give to someone learning English for the first time?",
+ "Describe your ideal weekend and explain why these activities appeal to you.",
+ "What are the advantages and disadvantages of living in a big city?",
+ "How has technology changed the way people communicate?",
+ "What qualities make a good friend? Explain with examples."
+ ];
+
+ return questions[Math.floor(Math.random() * questions.length)];
+ }
+
+ /**
+ * Validate response with AI
+ */
+ async _validateWithAI() {
+ const prompt = this._buildValidationPrompt();
+
+ try {
+ const result = await this.llmValidator.validateAnswer(
+ this.currentQuestion.question,
+ this.userResponse,
+ {
+ provider: this.config.requiredProvider,
+ model: this.config.model,
+ temperature: this.config.temperature,
+ maxTokens: this.config.maxTokens,
+ timeout: this.config.timeout,
+ context: prompt
+ }
+ );
+
+ return this._parseAIResponse(result);
+
+ } catch (error) {
+ console.error('AI validation failed:', error);
+ throw error;
+ }
+ }
+
+ _buildValidationPrompt() {
+ return `
+You are evaluating an open response answer from an English language learner.
+
+Question: "${this.currentQuestion.question}"
+Student Response: "${this.userResponse}"
+
+Evaluation Criteria:
+- ${this.currentQuestion.criteria.join('\n- ')}
+
+Expected Response Length: ~${this.currentQuestion.expectedLength} characters
+Actual Response Length: ${this.userResponse.length} characters
+
+Please evaluate the response and provide:
+1. A score from 0.0 to 1.0
+2. Detailed feedback on strengths and areas for improvement
+3. Specific suggestions for enhancement
+4. Whether the response adequately addresses the question
+
+Format your response as:
+[score]0.85
+[feedback]Your response shows good understanding... [detailed feedback]
+[suggestions]Consider adding more examples... [specific suggestions]
+[correct]yes/no
+ `.trim();
+ }
+
+ _parseAIResponse(aiResult) {
+ try {
+ const response = aiResult.response || '';
+
+ // Extract score
+ const scoreMatch = response.match(/\[score\]([\d.]+)/);
+ const score = scoreMatch ? parseFloat(scoreMatch[1]) : 0.5;
+
+ // Extract feedback
+ const feedbackMatch = response.match(/\[feedback\](.*?)\[suggestions\]/s);
+ const feedback = feedbackMatch ? feedbackMatch[1].trim() : 'Response evaluated';
+
+ // Extract suggestions
+ const suggestionsMatch = response.match(/\[suggestions\](.*?)\[correct\]/s);
+ const suggestions = suggestionsMatch ? suggestionsMatch[1].trim().split('\n') : [];
+
+ // Extract correctness
+ const correctMatch = response.match(/\[correct\](yes|no)/i);
+ const isCorrect = correctMatch ? correctMatch[1].toLowerCase() === 'yes' : score >= 0.7;
+
+ return {
+ score,
+ feedback,
+ suggestions: suggestions.filter(s => s.trim().length > 0),
+ isCorrect,
+ criteria: this.currentQuestion.criteria,
+ questionType: this.currentQuestion.type,
+ aiProvider: this.config.requiredProvider
+ };
+
+ } catch (error) {
+ console.error('Error parsing AI response:', error);
+ return {
+ score: 0.5,
+ feedback: 'Unable to parse evaluation. Please try again.',
+ suggestions: [],
+ isCorrect: false,
+ error: 'parsing_error'
+ };
+ }
+ }
+
+ /**
+ * Create exercise interface
+ */
+ _createExerciseInterface() {
+ this.container.innerHTML = `
+
+
+
+
+
+ ${this.currentQuestion.question}
+
+
+
+
Evaluation criteria:
+
+ ${this.currentQuestion.criteria.map(c => `${c.replace(/_/g, ' ')} `).join('')}
+
+
+
+
+
+
+
+
+ 0 / ${this.config.maxResponseLength}
+ Minimum: ${this.config.minResponseLength} characters
+
+
+
+
+
+ Submit Response
+
+
+ Clear
+
+
+
+
+
+
+
+ `;
+
+ this._attachEventListeners();
+ }
+
+ _attachEventListeners() {
+ const textarea = document.getElementById('open-response-input');
+ const validateBtn = document.getElementById('validate-response');
+ const clearBtn = document.getElementById('clear-response');
+ const charCount = document.getElementById('character-count');
+
+ if (textarea) {
+ textarea.addEventListener('input', (e) => {
+ const length = e.target.value.length;
+ charCount.textContent = `${length} / ${this.config.maxResponseLength}`;
+
+ // Enable/disable submit button
+ validateBtn.disabled = length < this.config.minResponseLength;
+
+ // Update character count color
+ if (length < this.config.minResponseLength) {
+ charCount.style.color = '#dc3545';
+ } else if (length > this.config.maxResponseLength * 0.9) {
+ charCount.style.color = '#ffc107';
+ } else {
+ charCount.style.color = '#28a745';
+ }
+ });
+ }
+
+ if (validateBtn) {
+ validateBtn.addEventListener('click', async () => {
+ await this._handleValidation();
+ });
+ }
+
+ if (clearBtn) {
+ clearBtn.addEventListener('click', () => {
+ textarea.value = '';
+ textarea.dispatchEvent(new Event('input'));
+ document.getElementById('validation-result').style.display = 'none';
+ });
+ }
+ }
+
+ async _handleValidation() {
+ const textarea = document.getElementById('open-response-input');
+ const validateBtn = document.getElementById('validate-response');
+ const resultDiv = document.getElementById('validation-result');
+
+ validateBtn.disabled = true;
+ validateBtn.textContent = 'Validating...';
+
+ try {
+ const result = await this.validate(textarea.value, {});
+ this._displayValidationResult(result);
+ } catch (error) {
+ console.error('Validation error:', error);
+ this._displayValidationResult({
+ score: 0,
+ feedback: 'Error validating response. Please try again.',
+ isCorrect: false,
+ suggestions: []
+ });
+ } finally {
+ validateBtn.disabled = false;
+ validateBtn.textContent = 'Submit Response';
+ }
+ }
+
+ _displayValidationResult(result) {
+ const resultDiv = document.getElementById('validation-result');
+
+ const scorePercentage = Math.round(result.score * 100);
+ const scoreClass = result.isCorrect ? 'success' : (result.score >= 0.5 ? 'warning' : 'error');
+
+ resultDiv.innerHTML = `
+
+
+
+
Feedback:
+
${result.feedback}
+
+
+ ${result.suggestions && result.suggestions.length > 0 ? `
+
+
Suggestions for improvement:
+
+ ${result.suggestions.map(s => `${s} `).join('')}
+
+
+ ` : ''}
+
+
+ Try Again
+ Next Question
+
+ `;
+
+ resultDiv.style.display = 'block';
+
+ // Attach action handlers
+ document.getElementById('try-again')?.addEventListener('click', () => {
+ resultDiv.style.display = 'none';
+ });
+
+ document.getElementById('next-question')?.addEventListener('click', () => {
+ this._nextQuestion();
+ });
+ }
+
+ async _nextQuestion() {
+ await this._generateQuestion();
+ this._createExerciseInterface();
+ }
+
+ _updateProgress(result) {
+ this.progress.questionsAnswered++;
+ this.progress.totalAttempts++;
+
+ if (result.isCorrect) {
+ this.progress.questionsCorrect++;
+ }
+
+ // Update average score
+ const previousTotal = this.progress.averageScore * (this.progress.questionsAnswered - 1);
+ this.progress.averageScore = (previousTotal + result.score) / this.progress.questionsAnswered;
+ }
+}
+
+export default OpenResponseModule;
\ No newline at end of file
diff --git a/src/DRS/exercise-modules/VocabularyModule.js b/src/DRS/exercise-modules/VocabularyModule.js
index 925dd92..61d0738 100644
--- a/src/DRS/exercise-modules/VocabularyModule.js
+++ b/src/DRS/exercise-modules/VocabularyModule.js
@@ -9,9 +9,9 @@ class VocabularyModule extends ExerciseModuleInterface {
constructor(orchestrator, llmValidator, prerequisiteEngine, contextMemory) {
super();
- // Validate dependencies
- if (!orchestrator || !llmValidator || !prerequisiteEngine || !contextMemory) {
- throw new Error('VocabularyModule requires all service dependencies');
+ // Validate dependencies (llmValidator can be null since we use local validation)
+ if (!orchestrator || !prerequisiteEngine || !contextMemory) {
+ throw new Error('VocabularyModule requires orchestrator, prerequisiteEngine, and contextMemory');
}
this.orchestrator = orchestrator;
@@ -80,12 +80,37 @@ class VocabularyModule extends ExerciseModuleInterface {
this.container = container;
this.currentExerciseData = exerciseData;
- // Extract vocabulary group
- this.currentVocabularyGroup = exerciseData.vocabulary || [];
+ // Extract and process all vocabulary
+ const allVocabulary = exerciseData.vocabulary || [];
+
+ // Pre-process all vocabulary items to extract clean translations
+ allVocabulary.forEach(word => {
+ let translation = word.translation;
+ if (typeof translation === 'object' && translation !== null) {
+ // Try different field names that might contain the translation
+ translation = translation.user_language ||
+ translation.target_language ||
+ translation.translation ||
+ translation.meaning ||
+ translation.fr ||
+ translation.definition ||
+ Object.values(translation).find(val => typeof val === 'string' && val !== word.word) ||
+ JSON.stringify(translation);
+ }
+ word.cleanTranslation = translation;
+ });
+
+ // Split vocabulary into groups of 5
+ this.allVocabularyGroups = this._createVocabularyGroups(allVocabulary, this.config.groupSize);
+ this.currentGroupIndex = 0;
+ this.currentVocabularyGroup = this.allVocabularyGroups[0] || [];
+
this.currentWordIndex = 0;
this.groupResults = [];
this.isRevealed = false;
+ console.log(`📚 Split ${allVocabulary.length} words into ${this.allVocabularyGroups.length} groups of ${this.config.groupSize}`);
+
if (this.config.randomizeOrder) {
this._shuffleArray(this.currentVocabularyGroup);
}
@@ -117,7 +142,7 @@ class VocabularyModule extends ExerciseModuleInterface {
}
const currentWord = this.currentVocabularyGroup[this.currentWordIndex];
- const expectedTranslation = currentWord.translation;
+ const expectedTranslation = currentWord.cleanTranslation || currentWord.translation;
const userAnswer = userInput.trim();
// Simple string matching validation (NO AI)
@@ -327,11 +352,11 @@ class VocabularyModule extends ExerciseModuleInterface {
@@ -354,12 +379,33 @@ class VocabularyModule extends ExerciseModuleInterface {
this._addStyles();
}
+ _updateProgressDisplay() {
+ const progressText = document.getElementById('progress-text');
+ const progressFill = document.getElementById('progress-fill');
+
+ if (progressText && progressFill) {
+ const totalWords = this.currentVocabularyGroup.length;
+ const progressPercentage = totalWords > 0 ?
+ Math.round((this.currentWordIndex / totalWords) * 100) : 0;
+
+ // Update text
+ progressText.textContent =
+ `Group ${this.currentGroupIndex + 1} of ${this.allVocabularyGroups.length} - Word ${this.currentWordIndex + 1} of ${totalWords}`;
+
+ // Update progress bar
+ progressFill.style.width = `${progressPercentage}%`;
+ }
+ }
+
_presentCurrentWord() {
if (this.currentWordIndex >= this.currentVocabularyGroup.length) {
this._showGroupResults();
return;
}
+ // Update progress display
+ this._updateProgressDisplay();
+
const currentWord = this.currentVocabularyGroup[this.currentWordIndex];
const card = document.getElementById('vocabulary-card');
const controls = document.getElementById('exercise-controls');
@@ -389,7 +435,7 @@ class VocabularyModule extends ExerciseModuleInterface {
- Correct Answer: ${currentWord.translation}
+ Correct Answer: ${currentWord.cleanTranslation}
${this.config.showPronunciation && currentWord.pronunciation ?
`
[${currentWord.pronunciation}]
` : ''}
@@ -399,15 +445,18 @@ class VocabularyModule extends ExerciseModuleInterface {
controls.innerHTML = `
- Reveal Answer
- Submit
+ 🔊 Listen
+ Reveal Answer
+ Submit
`;
// Add event listeners
+ document.getElementById('tts-btn').onclick = () => this._handleTTS();
document.getElementById('reveal-btn').onclick = this._handleRevealAnswer;
document.getElementById('submit-btn').onclick = this._handleUserInput;
+
// Allow Enter key to submit
const input = document.getElementById('translation-input');
input.addEventListener('keypress', (e) => {
@@ -465,15 +514,13 @@ class VocabularyModule extends ExerciseModuleInterface {
answerSection.style.display = 'none';
this.isRevealed = true;
- // Mark as incorrect since user revealed the answer
- this.groupResults[this.currentWordIndex] = {
- word: this.currentVocabularyGroup[this.currentWordIndex].word,
- userAnswer: '[revealed]',
- correct: false,
- score: 0,
- feedback: 'Answer was revealed',
- timestamp: new Date().toISOString()
- };
+ // Auto-play TTS when answer is revealed
+ setTimeout(() => {
+ this._handleTTS();
+ }, 100); // Quick delay to let the answer appear
+
+ // Don't mark as incorrect yet - wait for user self-assessment
+ // The difficulty selection will determine the actual result
this._showDifficultySelection();
}
@@ -530,21 +577,52 @@ class VocabularyModule extends ExerciseModuleInterface {
_handleDifficultySelection(difficulty) {
const currentWord = this.currentVocabularyGroup[this.currentWordIndex];
- // Update result with difficulty
- if (this.groupResults[this.currentWordIndex]) {
- this.groupResults[this.currentWordIndex].difficulty = difficulty;
- }
+ // Create or update result based on user self-assessment
+ const userAnswer = this.isRevealed ? '[revealed]' :
+ (this.groupResults[this.currentWordIndex]?.userAnswer || '[self-assessed]');
- // Mark word as mastered if good or easy
+ // Convert difficulty to success/score based on spaced repetition logic
+ const difficultyMapping = {
+ 'again': { correct: false, score: 0 }, // Failed - need to see again soon
+ 'hard': { correct: true, score: 60 }, // Passed but difficult
+ 'good': { correct: true, score: 80 }, // Good understanding
+ 'easy': { correct: true, score: 100 } // Perfect understanding
+ };
+
+ const assessment = difficultyMapping[difficulty] || { correct: false, score: 0 };
+
+ // Create/update the result entry
+ this.groupResults[this.currentWordIndex] = {
+ word: currentWord.word,
+ userAnswer: userAnswer,
+ correct: assessment.correct,
+ score: assessment.score,
+ difficulty: difficulty,
+ feedback: `Self-assessed as: ${difficulty}`,
+ timestamp: new Date().toISOString(),
+ wasRevealed: this.isRevealed
+ };
+
+ // ALWAYS mark word as discovered (seen/introduced)
+ const discoveryMetadata = {
+ difficulty: difficulty,
+ sessionId: this.orchestrator?.sessionId || 'unknown',
+ moduleType: 'vocabulary',
+ timestamp: new Date().toISOString(),
+ wasRevealed: this.isRevealed
+ };
+ this.prerequisiteEngine.markWordDiscovered(currentWord.word, discoveryMetadata);
+
+ // Mark word as mastered ONLY if good or easy
if (['good', 'easy'].includes(difficulty)) {
- const metadata = {
+ const masteryMetadata = {
difficulty: difficulty,
sessionId: this.orchestrator?.sessionId || 'unknown',
moduleType: 'vocabulary',
- attempts: this.groupResults[this.currentWordIndex]?.attempts || 1,
- correct: this.groupResults[this.currentWordIndex]?.correct || false
+ attempts: 1, // Single attempt with self-assessment
+ correct: assessment.correct
};
- this.prerequisiteEngine.markWordMastered(currentWord.word, metadata);
+ this.prerequisiteEngine.markWordMastered(currentWord.word, masteryMetadata);
// Also save to persistent storage
if (window.addMasteredItem && this.orchestrator?.bookId && this.orchestrator?.chapterId) {
@@ -553,7 +631,7 @@ class VocabularyModule extends ExerciseModuleInterface {
this.orchestrator.chapterId,
'vocabulary',
currentWord.word,
- metadata
+ masteryMetadata
);
}
}
@@ -570,6 +648,94 @@ class VocabularyModule extends ExerciseModuleInterface {
this._presentCurrentWord();
}
+ _handleTTS() {
+ const currentWord = this.currentVocabularyGroup[this.currentWordIndex];
+ if (currentWord && currentWord.word) {
+ this._speakWord(currentWord.word);
+ }
+ }
+
+ _speakWord(text, options = {}) {
+ // Check if browser supports Speech Synthesis
+ if ('speechSynthesis' in window) {
+ try {
+ // Cancel any ongoing speech
+ window.speechSynthesis.cancel();
+
+ const utterance = new SpeechSynthesisUtterance(text);
+
+ // Configure voice settings
+ utterance.lang = options.lang || 'en-US';
+ utterance.rate = options.rate || 0.8;
+ utterance.pitch = options.pitch || 1;
+ utterance.volume = options.volume || 1;
+
+ // Try to find a suitable voice
+ const voices = window.speechSynthesis.getVoices();
+ if (voices.length > 0) {
+ // Prefer English voices
+ const englishVoice = voices.find(voice =>
+ voice.lang.startsWith('en') && voice.default
+ ) || voices.find(voice => voice.lang.startsWith('en'));
+
+ if (englishVoice) {
+ utterance.voice = englishVoice;
+ }
+ }
+
+ // Add event handlers
+ utterance.onstart = () => {
+ console.log('🔊 TTS started for:', text);
+ this._updateTTSButton(true);
+ };
+
+ utterance.onend = () => {
+ console.log('🔊 TTS finished for:', text);
+ this._updateTTSButton(false);
+ };
+
+ utterance.onerror = (event) => {
+ console.warn('🔊 TTS error:', event.error);
+ this._updateTTSButton(false);
+ };
+
+ // Speak the text
+ window.speechSynthesis.speak(utterance);
+
+ } catch (error) {
+ console.warn('🔊 TTS failed:', error);
+ this._fallbackTTS(text);
+ }
+ } else {
+ console.warn('🔊 Speech Synthesis not supported in this browser');
+ this._fallbackTTS(text);
+ }
+ }
+
+ _updateTTSButton(isPlaying) {
+ // Update main TTS button
+ const ttsBtn = document.getElementById('tts-btn');
+ if (ttsBtn) {
+ if (isPlaying) {
+ ttsBtn.innerHTML = '🔄 Speaking...';
+ ttsBtn.disabled = true;
+ } else {
+ ttsBtn.innerHTML = '🔊 Listen';
+ ttsBtn.disabled = false;
+ }
+ }
+ }
+
+ _fallbackTTS(text) {
+ // Fallback when TTS fails - show pronunciation if available
+ const currentWord = this.currentVocabularyGroup[this.currentWordIndex];
+ if (currentWord && currentWord.pronunciation) {
+ alert(`Pronunciation: /${currentWord.pronunciation}/`);
+ } else {
+ alert(`Word: ${text}\n(Text-to-speech not available)`);
+ }
+ }
+
_showGroupResults() {
const resultsContainer = document.getElementById('group-results');
const card = document.getElementById('vocabulary-card');
@@ -585,9 +751,14 @@ class VocabularyModule extends ExerciseModuleInterface {
if (accuracy >= 80) resultClass = 'results-excellent';
else if (accuracy >= 60) resultClass = 'results-good';
+ // Check if there are more groups
+ const hasMoreGroups = this.currentGroupIndex < this.allVocabularyGroups.length - 1;
+ const buttonText = hasMoreGroups ? 'Continue to Next Group' : 'Complete Vocabulary Exercise';
+ const buttonId = hasMoreGroups ? 'next-group-btn' : 'complete-btn';
+
const resultsHTML = `
-
📊 Group Results
+
📊 Group ${this.currentGroupIndex + 1} Results
${accuracy}%
@@ -596,6 +767,9 @@ class VocabularyModule extends ExerciseModuleInterface {
${correctCount} / ${totalCount} correct
+
+ Group ${this.currentGroupIndex + 1} of ${this.allVocabularyGroups.length}
+
@@ -609,7 +783,7 @@ class VocabularyModule extends ExerciseModuleInterface {
- Continue to Next Exercise
+ ${buttonText}
`;
@@ -621,15 +795,72 @@ class VocabularyModule extends ExerciseModuleInterface {
if (card) card.style.display = 'none';
if (controls) controls.style.display = 'none';
- // Add continue button listener
- document.getElementById('continue-btn').onclick = () => {
- // Emit completion event to orchestrator
- this.orchestrator._eventBus.emit('drs:exerciseCompleted', {
- moduleType: 'vocabulary',
- results: this.groupResults,
- progress: this.getProgress()
- }, 'VocabularyModule');
- };
+ // Add button listeners
+ const nextGroupBtn = document.getElementById('next-group-btn');
+ const completeBtn = document.getElementById('complete-btn');
+
+ if (nextGroupBtn) {
+ nextGroupBtn.onclick = () => this._moveToNextGroup();
+ }
+
+ if (completeBtn) {
+ completeBtn.onclick = () => {
+ // Emit completion event to orchestrator
+ this.orchestrator._eventBus.emit('drs:exerciseCompleted', {
+ moduleType: 'vocabulary',
+ results: this.groupResults,
+ progress: this.getProgress()
+ }, 'VocabularyModule');
+ };
+ }
+ }
+
+ _moveToNextGroup() {
+ console.log(`🔄 Moving to next vocabulary group (${this.currentGroupIndex + 1} -> ${this.currentGroupIndex + 2})`);
+
+ // Check if there's a next group
+ if (this.currentGroupIndex >= this.allVocabularyGroups.length - 1) {
+ console.warn('⚠️ No more vocabulary groups available');
+ return;
+ }
+
+ // Move to next group
+ this.currentGroupIndex++;
+ this.currentVocabularyGroup = this.allVocabularyGroups[this.currentGroupIndex];
+
+ // Verify the group exists and has words
+ if (!this.currentVocabularyGroup || this.currentVocabularyGroup.length === 0) {
+ console.error('❌ Next vocabulary group is empty or undefined');
+ return;
+ }
+
+ console.log(`📚 Loaded group ${this.currentGroupIndex + 1} with ${this.currentVocabularyGroup.length} words:`,
+ this.currentVocabularyGroup.map(w => w.word));
+
+ this.currentWordIndex = 0;
+ this.groupResults = [];
+ this.isRevealed = false;
+
+ // Shuffle new group if needed
+ if (this.config.randomizeOrder) {
+ this._shuffleArray(this.currentVocabularyGroup);
+ }
+
+ // Hide results and show vocabulary sections
+ const resultsContainer = document.getElementById('group-results');
+ const card = document.getElementById('vocabulary-card');
+ const controls = document.getElementById('exercise-controls');
+
+ if (resultsContainer) {
+ resultsContainer.style.display = 'none';
+ }
+
+ // Show card and controls sections
+ if (card) card.style.display = 'block';
+ if (controls) controls.style.display = 'block';
+
+ // Present first word of new group
+ this._presentCurrentWord();
}
_setInputEnabled(enabled) {
@@ -670,6 +901,14 @@ class VocabularyModule extends ExerciseModuleInterface {
}
}
+ _createVocabularyGroups(vocabulary, groupSize) {
+ const groups = [];
+ for (let i = 0; i < vocabulary.length; i += groupSize) {
+ groups.push(vocabulary.slice(i, i + groupSize));
+ }
+ return groups;
+ }
+
_shuffleArray(array) {
for (let i = array.length - 1; i > 0; i--) {
const j = Math.floor(Math.random() * (i + 1));
diff --git a/test-drs-interface.html b/test-drs-interface.html
new file mode 100644
index 0000000..0d3dd8f
--- /dev/null
+++ b/test-drs-interface.html
@@ -0,0 +1,80 @@
+
+
+
+
+
+
🧪 Tests DRS - Class Generator
+
+
+
+
+
← Retour à l'application
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file