Update src/core/QuizEngine.py

src/core/QuizEngine.py

@@ -11,12 +11,9 @@ class QuizEngine:
 
     # --- MODE 1: ACRONYMS ---
     def get_random_acronym(self):
-        if not self.acronym_mgr.acronyms:
-            return None
-        
+        if not self.acronym_mgr.acronyms: return None
         acronym = random.choice(list(self.acronym_mgr.acronyms.keys()))
         definition = self.acronym_mgr.acronyms[acronym]
-        
         return {
             "type": "acronym",
             "term": acronym,
@@ -24,26 +21,21 @@ class QuizEngine:
             "question": f"What does **{acronym}** stand for?"
         }
 
-    # --- MODE 2: DOCUMENTS (Updated for Guided Quizzing) ---
+    # --- MODE 2: SCENARIO SIMULATOR (Updated) ---
     def get_document_context(self, username, topic_filter=None):
         """
-        Fetches a context chunk with Tiered Fallback.
-        Returns None if absolutely no files exist.
-        Returns {'error': 'topic_not_found'} if the filter is too strict.
+        Fetches a LARGE context chunk (4000 chars) to ensure continuity.
         """
         user_dir = os.path.join(self.source_dir, username)
         if not os.path.exists(user_dir): return None
 
         files = [f for f in os.listdir(user_dir) if f.lower().endswith(('.txt', '.md'))]
         if not files: return None
-
-        # Shuffle files to ensure randomness
         random.shuffle(files)
 
-        # Track if we found ANY matching files for the topic (for debugging)
+        # Track if we found topic match
         topic_match_found = False
 
-        # Attempt loop
         for attempt in range(20):
             selected_file = random.choice(files)
             try:
@@ -51,50 +43,39 @@ class QuizEngine:
                 with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                     text = f.read()
 
-                # CRITICAL CHECK: Is file empty?
-                if len(text.strip()) < 50: continue
+                if len(text.strip()) < 100: continue
 
-                # --- TIER 1: FILTERING ---
+                # TIER 1: Topic Filter
                 if topic_filter:
-                    if topic_filter.lower() not in text.lower():
-                        continue # Skip this file, it doesn't have the topic
-                    topic_match_found = True # We found a file that has the topic!
-
-                # --- TIER 2: CHUNKING ---
-                # Sliding Window Strategy
-                step_size = 1000
-                window_size = 1500
+                    if topic_filter.lower() not in text.lower(): continue
+                    topic_match_found = True
+
+                # TIER 2: Large Window Extraction (The "Mega-Window")
+                # We grab 4000 chars instead of 1500 to get "Before & After" context
+                window_size = 4000 
+                step_size = 2000
                 candidates = []
-                
-                # If text is small, take it all
+
                 if len(text) < window_size:
                     candidates.append(text)
                 else:
-                    # Scan the file
                     for i in range(0, len(text) - window_size, step_size):
                         chunk = text[i : i + window_size]
                         
-                        # Soft Filter: Skip if mostly empty
-                        if len(chunk.strip()) < 50: continue
+                        if len(chunk.strip()) < 200: continue
+                        if topic_filter and topic_filter.lower() not in chunk.lower(): continue
                         
-                        # Topic Check (Fine-grained)
-                        if topic_filter and topic_filter.lower() not in chunk.lower():
-                            continue
-                            
                         candidates.append(chunk)
 
-                # FALLBACK: If candidates is empty (maybe topic is in file but split across chunks?)
-                # We just grab a random chunk from the file that contains the topic
+                # Fallback: If topic matches file but logic missed it, force a grab
                 if not candidates and topic_filter and topic_match_found:
-                    # Crude fallback: Find the index of the word and grab text around it
                     idx = text.lower().find(topic_filter.lower())
-                    start = max(0, idx - 500)
-                    end = min(len(text), idx + 1000)
+                    start = max(0, idx - 1000)
+                    end = min(len(text), idx + 3000)
                     candidates.append(text[start:end])
 
                 if not candidates: continue
 
-                # Success!
                 selected_context = random.choice(candidates)
                 
                 return {
@@ -104,78 +85,53 @@ class QuizEngine:
                 }
 
             except Exception as e:
-                self.logger.error(f"Error fetching context from {selected_file}: {e}")
+                self.logger.error(f"Error fetching context: {e}")
                 continue
         
-        # If we failed after 20 tries:
-        if topic_filter and not topic_match_found:
-            return {"error": "topic_not_found"}
-        
+        if topic_filter and not topic_match_found: return {"error": "topic_not_found"}
         return None
 
-    def construct_question_generation_prompt(self, context_text):
+    # --- PROMPTS ---
+
+    def construct_scenario_prompt(self, context_text):
         """
-        REVISED PROMPT: 'Board-Style' Questions (No Spoilers).
-        Includes Examples for quality, but output is strictly the question text.
+        Generates a 'Board-Style' Scenario.
+        Forces the model to output a Scenario AND a Hidden Solution.
         """
         return (
-            f"Act as a Navy Board Examiner.\n"
-            f"Here is a raw text excerpt from Navy documentation:\n"
-            f"'''{context_text}'''\n\n"
-            f"TASK: Generate a single question based on this text.\n\n"
+            f"Act as a Senior Navy Board Examiner.\n"
+            f"Reference Material:\n'''{context_text}'''\n\n"
+            f"TASK: \n"
+            f"1. Identify a key technical concept in the text (e.g., Stability, Finance, Contracting).\n"
+            f"2. Create a REALISTIC SCENARIO based on this concept. Do not ask 'What is X?'. Instead, describe a situation (e.g., 'You are the DCA...', 'A contractor submits a bid...') and ask for the candidate's assessment.\n"
+            f"3. Create the OFFICIAL SOLUTION explaining the 'Why' behind the answer.\n\n"
             
-            f"EXAMPLES OF DESIRED QUALITY (DO THIS):\n"
-            f"1. [Simple Fact]\n"
-            f"   Text: 'The NSWC is in Maryland.'\n"
-            f"   Good Question: 'Where are the Naval Surface Warfare Centers located?'\n"
-            f"2. [Process/Order]\n"
-            f"   Text: 'There are five acquisition phases.'\n"
-            f"   Good Question: 'What are the five acquisition phases?'\n"
-            f"3. [Scenario/Application]\n"
-            f"   Text: 'A significant Nunn-McCurdy Unit Cost Breach is defined as cost growth of 15% over current baseline.'\n"
-            f"   Good Question: 'What conditions trigger a significant Nunn-McCurdy Unit Cost Breach?'\n\n"
-
-            f"EXAMPLES OF POOR QUALITY (AVOID THIS):\n"
-            f"1. [Lazy/Meta-Reference]\n"
-            f"   Bad Question: 'What does the text say about the budget?'\n"
-            f"   Critique: Do not reference 'the text'. Ask about the subject matter directly.\n"
-            f"2. [Yes/No]\n"
-            f"   Bad Question: 'Is the budget cycle annual?'\n"
-            f"   Critique: Too easy. Ask 'What is the duration of the budget cycle?' instead.\n\n"
-
-            f"STRICT RULES:\n"
-            f"1. You must base your question on a SPECIFIC SENTENCE in the text.\n"
-            f"2. If the text is meaningless or 'Intentionally Left Blank', output 'UNABLE'.\n\n"
+            f"STRICT OUTPUT FORMAT:\n"
+            f"SCENARIO: [Your scenario text here]\n"
+            f"SOLUTION: [The detailed answer key]"
+        )
+
+    def construct_scenario_grading_prompt(self, scenario, user_answer, solution, context_text):
+        """
+        Grades with the specific 'Board Assessment' persona requested.
+        """
+        return (
+            f"Act as a Senior Navy Board Examiner grading a candidate's oral response.\n\n"
+            f"--- THE SCENARIO ---\n{scenario}\n\n"
+            f"--- OFFICIAL SOLUTION (For You) ---\n{solution}\n\n"
+            f"--- REFERENCE TEXT ---\n{context_text}\n\n"
+            f"--- CANDIDATE ANSWER ---\n{user_answer}\n\n"
+            
+            f"TASK: Grade the candidate.\n"
+            f"1. Compare their answer to the Official Solution and Reference Text.\n"
+            f"2. Look for technical precision (e.g., 'G rises' vs 'Weight moves').\n"
+            f"3. Provide a numeric grade and a structured critique.\n\n"
             
             f"OUTPUT FORMAT:\n"
-            f"Output ONLY the question text. Do NOT output the answer or the quote."
+            f"**Grade:** [0-10]/10\n"
+            f"**Critique:** [Your detailed feedback. Be firm but constructive. Highlight specifically what they missed (e.g., 'You identified the List, but failed to identify the Loll.').]"
         )
-    
-    def construct_grading_prompt(self, question, answer, context_text):
-            """
-            Grades the answer using a composite context (Seed + RAG Results).
-            """
-            return (
-                f"You are a Board Examiner.\n"
-                f"Reference Material (Combined Sources):\n"
-                f"'''{context_text}'''\n\n"
-                f"Question: {question}\n"
-                f"Candidate Answer: {answer}\n\n"
-                f"TASK: Grade the answer based strictly on the Reference Material above.\n"
-                f"1. Search the Reference Material for the correct answer. The answer might be split across the Primary Source and Related Documentation.\n"
-                f"2. If the candidate's answer matches the facts found ANYWHERE in the text, grade PASS.\n"
-                f"3. If the candidate misses key details that ARE present in the text, grade FAIL or PASS with Comments.\n"
-                f"4. If the provided Reference Material does NOT contain the answer (i.e., retrieval failed), be lenient and grade based on general knowledge, but note 'Verified by General Knowledge' in the feedback.\n\n"
-                f"OUTPUT FORMAT:\n"
-                f"**GRADE:** [PASS/FAIL]\n"
-                f"**FEEDBACK:** [Brief correction or confirmation]"
-            )
-    
+
+    # Legacy prompts (keep for safety if you switch modes)
     def construct_acronym_grading_prompt(self, term, correct_definition, user_answer):
-        return (
-            f"Term: {term}\n"
-            f"Official Definition: {correct_definition}\n"
-            f"User Answer: {user_answer}\n\n"
-            f"Grade as PASS (correct expansion) or FAIL. If close, PASS with comment.\n"
-            f"Output: **GRADE:** [Status]\n**FEEDBACK:** [Details]"
-        )
+        return f"Term: {term}\nDefinition: {correct_definition}\nAnswer: {user_answer}\nGrade PASS/FAIL."