Update src/brain_agent.py

src/brain_agent.py

@@ -2,6 +2,7 @@
 🧠 Agent 2 (Interpretation) - Gemini 2.0 EDITION
 -------------------------------------------------
 This version of the AgentBrain is specifically designed to work with Google's Gemini 2.0.
+
 """
 
 import os
@@ -13,64 +14,29 @@ import concurrent.futures
 from rapidfuzz import process, fuzz
 
 class AgentInterpretation:
-    def __init__(self, config, gemini_manager_instance=None, hf_manager_instance=None):
+    def __init__(self, config, gemini_manager_instance=None):
         self.config = config
         self.df = pd.DataFrame()
         self.lookup_list = []
         self.gemini_manager = gemini_manager_instance
-        self.hf_manager = hf_manager_instance
         self.active_profiles_list = []
-        
-        # 🟢 FIX: Initialize with a safe default so it ALWAYS exists
-        self.lab_profile = {"lab_name": "Default Profile", "jargon": {}}
-        
-        # Persistence for last used profile
-        self.last_profile_path = os.path.join(self.config.PROFILES_DIR, "last_used_profile.txt")
 
-        # Load initial profile
-        last_used = self._get_last_used_profile_name()
-        print(f"🧠 Loading initial profile: {last_used}")
-        self.load_profile_by_name(last_used)
+        # Load default
+        self.load_profile_by_name("NSL Lab Trainer.json")
 
         self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
         print("🧠 Agent 2 (Interpretation) Online: Persistent Pool Ready.")
         self.refresh_knowledge_base()
 
-    def _get_last_used_profile_name(self):
-        try:
-            if os.path.exists(self.last_profile_path):
-                with open(self.last_profile_path, 'r', encoding='utf-8') as f:
-                    name = f.read().strip()
-                    if os.path.exists(os.path.join(self.config.PROFILES_DIR, name)):
-                        return name
-        except: pass
-        return "Korean English.json"
-
-    # 🟢 NEW: Manual Sync Method
-    def sync_from_huggingface(self):
-        if self.hf_manager:
-            print("🔄 Triggering Manual Cloud Sync...")
-            self.hf_manager.pull_datasets()
-            self.refresh_knowledge_base() # Reload CSVs
-            return "✅ Cloud Sync Complete. Lists refreshed."
-        return "⚠️ HF Manager not connected."
-
     def get_available_profiles(self):
         files = glob.glob(os.path.join(self.config.PROFILES_DIR, "*.json"))
-        return sorted([os.path.basename(f) for f in files])
+        return [os.path.basename(f) for f in files]
 
     def load_profile_by_name(self, filename):
         path = os.path.join(self.config.PROFILES_DIR, filename)
         try:
             with open(path, 'r', encoding='utf-8') as f:
                 self.lab_profile = json.load(f)
-                
-                # Save persistence
-                try:
-                    with open(self.last_profile_path, 'w', encoding='utf-8') as f_last:
-                        f_last.write(filename)
-                except: pass
-
                 return self.lab_profile
         except: return {}
 
@@ -78,14 +44,10 @@ class AgentInterpretation:
         if not filename.endswith(".json"): filename += ".json"
         path = os.path.join(self.config.PROFILES_DIR, filename)
         try:
-            with open(path, "w", encoding="utf-8") as f: 
-                json.dump(json.loads(json_str), f, indent=2)
-            
-            if self.hf_manager:
-                self.hf_manager.push_update(path, commit_msg=f"Update Profile: {filename}")
-                return "✅ Saved locally & Pushing to HF..." 
-            else:
-                return "⚠️ Saved locally only (HF Manager missing)"
+            with open(path, "w", encoding="utf-8") as f: json.dump(json.loads(json_str), f, indent=2)
+            # Note: We can't easily push to HF here without circular dependency or passing HF manager.
+            # Ideally, the Brain agent shouldn't manage HF syncing, but for now we return success.
+            return "✅ Saved locally (HF Sync pending)" 
         except Exception as e: return f"❌ Error: {e}"
 
     def get_current_profile_text(self):
@@ -96,6 +58,7 @@ class AgentInterpretation:
         loaded_count = 0
         names = []
         self.active_profiles_list = []
+
         for f_path in files:
             try:
                 with open(f_path, 'r', encoding='utf-8') as f:
@@ -136,20 +99,32 @@ class AgentInterpretation:
         return cleaned_list
 
     def generate_mission(self, context="General"):
+        """
+        Generates a random, realistic scenario based on the context.
+        """
         prompt = f"""
         Generate a short, realistic roleplay scenario for a user to speak a dialect phrase.
+        
         Constraints:
         1. Context: {context}
-        2. Target Audience: Speakers of non-standard English dialects.
+        2. Target Audience: Speakers of non-standard English dialects (e.g., Nigerian, Indian).
         3. Length: 1 sentence.
-        4. Goal: Provoke a natural reaction.
+        4. Goal: Provoke a natural reaction (complaint, greeting, warning, negotiation).
         5. Output Format: JSON with keys 'text' and 'emoji'.
+        
+        Examples:
+        - Context: Traffic -> {{"text": "A bus driver cut you off. Yell at him.", "emoji": "🚌"}}
+        - Context: Market -> {{"text": "The fish is too expensive. Ask for a discount.", "emoji": "🐟"}}
         """
+        
         try:
+            # Call Gemini (assuming self.gemini_manager is set up)
             response = self.gemini_manager.generate_content(prompt)
+            # Clean up JSON (sometimes AI adds ```json ... ```)
             clean_json = response.text.replace("```json", "").replace("```", "").strip()
             return json.loads(clean_json)
         except:
+            # Fallback if AI fails
             return {"text": "Describe your morning routine.", "emoji": "☀️"}
             
     def generate_unknown_analysis(self, text):
@@ -161,8 +136,8 @@ class AgentInterpretation:
         prompt = f"""
         Analyze utterance: "{text}"
         Context/Jargon Keys: {list(set(all_jargon_keys))[:50]}
-        Task: Provide 1 distinct interpretation (Casual, Formal, or Cultural).
-        CRITICAL INSTRUCTION: Treat the input as valid, meaningful Dialectal English.
+        Task: Provide 3 distinct interpretations (Casual, Formal, or Cultural).
+        CRITICAL INSTRUCTION: Treat the input as valid, meaningful Dialectal English. Do NOT label it as "incorrect".
         Output Strictly JSON: [ {{ "Dialect": "General", "Clarification": "...", "Tone": "...", "Context": "...", "Pragmatics": "..." }} ]
         """
         try:
@@ -174,7 +149,7 @@ class AgentInterpretation:
             return [{"Dialect": "Unknown", "Clarification": "Analysis Failed", "Tone": "---", "Context": "---", "Pragmatic Analysis": "Error"}]
 
     def adapt_with_ai(self, full_text, db_row):
-        if not self.gemini_manager: return db_row["Clarification"], db_row.get("Pragmatic_Analysis", "---")
+        if not self.gemini_manager: return db_row["Clarification"], db_row["Pragmatic_Analysis"]
         prompt = f"""
         Ref Term: "{db_row['Utterance']}" = "{db_row['Clarification']}"
         User said: "{full_text}"
@@ -188,7 +163,7 @@ class AgentInterpretation:
                 data = json.loads(clean_json.group(0))
                 return data.get("clarification", db_row["Clarification"]), data.get("pragmatics", "AI Adapted Analysis")
         except: pass
-        return db_row["Clarification"], db_row.get("Pragmatic_Analysis", "---")
+        return db_row["Clarification"], db_row["Pragmatic_Analysis"]
 
     def detect_and_analyze(self, text, threshold=60):
         clean_text = text.lower().strip()
@@ -287,70 +262,4 @@ class AgentInterpretation:
             pat = self.gemini_manager.generate_fast(f"Regex for: '{utterance}'. Return ONLY regex string.").text.strip().replace("`", "")
             re.compile(pat)
             return pat
-        except: return safe
-
-    # ==========================================
-    #      PhD-GRADE SOCIOLINGUISTIC ANALYSIS
-    # ==========================================
-    def analyze_dialect_multi(self, text, language_code="en"):
-        """
-        PhD-Grade Sociolinguistic Analysis for PureConvo Project.
-        Extracts Intent, Register, and Cultural Nuance using structured JSON.
-        """
-        # Define the research-grade prompt
-        research_prompt = f"""
-        Act as an expert Sociolinguist for the PureConvo research project.
-        Analyze the following utterance within the context of Intra-English Dialect Interpretation.
-
-        Utterance: "{text}"
-        Primary Language Context: {language_code}
-
-        Provide a multi-dialectal analysis in a JSON LIST format. For each likely dialect, include:
-        1. "dialect": The specific name (e.g., 'Nigerian English', 'AAVE').
-        2. "clarification": A 'General English' translation that preserves original intent.
-        3. "tone": Categorize as: 'Neutral / Conversational', 'Casual / Slang', 'Formal / Professional', or 'Proverb / Idiom'.
-        4. "context": The situational environment where this is most likely spoken.
-        5. "pragmatics": A structured string containing:
-           - [Force]: (e.g., Phatic, Directive, Expressive)
-           - [Deixis]: Implied social hierarchy/distance.
-           - [Register]: Numeric scale 1-5.
-           - [Nuance]: Specific cultural/linguistic markers.
-
-        JSON format ONLY. No conversational filler.
-        """
-
-        try:
-            # 🟢 FIX: Using self.gemini_manager instead of self.model
-            response = self.gemini_manager.generate_content(research_prompt)
-            
-            # Clean response text (remove markdown blocks if present)
-            raw_json = response.text.replace("```json", "").replace("```", "").strip()
-            analysis_list = json.loads(raw_json)
-            
-            # 🟢 VALIDATION: Ensure the data matches your UI columns perfectly
-            validated_results = []
-            for item in analysis_list:
-                validated_results.append({
-                    "Clarification_Source": "✨ PhD-AI (CA-IEDI)", # Added for UI consistency
-                    "Speaker": "Speaker 1",         # Added for UI consistency
-                    "dialect": item.get("dialect", "Unknown"),
-                    "clarification": item.get("clarification", "N/A"),
-                    "tone": item.get("tone", "Neutral / Conversational"),
-                    "context": item.get("context", "General"),
-                    "pragmatics": item.get("pragmatics", "No analysis provided.")
-                })
-            
-            return validated_results
-
-        except Exception as e:
-            print(f"❌ [BRAIN] Analysis Pipeline Crash: {e}")
-            # Return a safe fallback list to prevent UI "Format Errors"
-            return [{
-                "Clarification_Source": "⚠️ Error",
-                "Speaker": "---",
-                "dialect": "Detection Failed",
-                "clarification": "Error processing analysis",
-                "tone": "Neutral",
-                "context": "N/A",
-                "pragmatics": str(e)
-            }]        
+        except: return safe