Update src/module/AIP.py

src/module/AIP.py

@@ -1,7 +1,6 @@
 """
-MODULE JASMINE AGENT - V FINAL (CASCADE MULTI-MODÈLES + FUNCTIONS)
+MODULE JASMINE AGENT - V FINAL (STYLE GOTHAM APPLIQUÉ)
 ==================================================================
-Responsabilité : Traduire le langage naturel en actions + appeler des fonctions métier.
 """
 import google.generativeai as genai
 from groq import Groq
@@ -20,12 +19,45 @@ try:
         get_patient_stats
     )
 except ImportError as e:
-    # Debug affiché seulement si l'import échoue
-    st.error(f"Erreur interne dans AIP.py : impossible de trouver AIP_Function. {e}")
-    # On crée des fonctions "bouchons" pour éviter que la classe ne plante si l'import échoue
+    st.error(f"Erreur interne : impossible de trouver AIP_Function. {e}")
     calculate_occupancy_rate = audit_data_quality = get_stock_alerts = get_patient_stats = lambda x: "Fonction non chargée"
 
-# [SUPPRIMÉ] L'import redondant qui faisait crasher a été retiré ici.
+# --- STYLE EXTRAIT DU CODE 01 (GOTHAM THEME) ---
+def apply_custom_styles():
+    st.markdown("""
+    <style>
+    /* Chat Styling - Palantir Style */
+    .user-msg { 
+        background: rgba(30, 136, 229, 0.1); 
+        border-left: 3px solid #1E88E5; 
+        padding: 12px; margin: 5px 0; 
+        border-radius: 0 4px 4px 0; 
+        font-family: 'Inter', sans-serif;
+        color: #c9d1d9;
+    }
+    
+    .bot-msg { 
+        background: rgba(48, 54, 61, 0.3); 
+        border-left: 3px solid #00E676; 
+        padding: 12px; margin: 5px 0; 
+        border-radius: 0 4px 4px 0; 
+        font-family: 'Inter', sans-serif;
+        color: #c9d1d9;
+    }
+    
+    /* Debugger Log Style (Thought Trace) */
+    .debug-block {
+        font-family: 'JetBrains Mono', monospace; 
+        font-size: 0.85rem;
+        color: #8b949e;
+        background: #0d1117;
+        border: 1px solid #30363d;
+        padding: 10px;
+        margin-top: 5px;
+        border-radius: 4px;
+    }
+    </style>
+    """, unsafe_allow_html=True)
 
 class JasmineAgent:
     def __init__(self, rdf_store, ontology_rules, dataframes=None):
@@ -38,7 +70,7 @@ class JasmineAgent:
         
         self.rdf_store = rdf_store
         self.ontology_rules = ontology_rules
-        self.dataframes = dataframes or {}  # Dictionnaire des DataFrames disponibles
+        self.dataframes = dataframes or {}
         
         self.MODEL_CASCADE = [
             "gemini-2.0-flash-exp",
@@ -47,7 +79,6 @@ class JasmineAgent:
             "llama-3.1-8b-instant"
         ]
         
-        # Mapping des fonctions disponibles
         self.available_functions = {
             "calculate_occupancy_rate": calculate_occupancy_rate,
             "audit_data_quality": audit_data_quality,
@@ -57,224 +88,136 @@ class JasmineAgent:
 
     def build_base_system_prompt(self):
         return """
-ROLE: Tu es un agent intelligent qui analyse les requêtes utilisateur.
-MISSION: Comprendre l'intention et générer les actions appropriées.
+ROLE: Tu es Jasmine, un agent intelligent d'analyse hospitalière.
+MISSION: Comprendre l'intention et générer les actions appropriées au format JSON.
 
---- FONCTIONS DISPONIBLES ---
-1. calculate_occupancy_rate : Calcule le taux d'occupation (nécessite df_ressources)
-2. audit_data_quality : Analyse la qualité des données (nécessite un DataFrame avec colonnes dq_)
-3. get_stock_alerts : Identifie les ruptures de stock (nécessite df_stock)
-4. get_patient_stats : Statistiques démographiques patients (nécessite df_patients)
+--- FONCTIONS ---
+1. calculate_occupancy_rate (df_ressources)
+2. audit_data_quality (df avec colonnes dq_)
+3. get_stock_alerts (df_stock)
+4. get_patient_stats (df_patients)
 
-CONTRAINTES DE SORTIE (JSON STRICT) :
+FORMAT JSON STRICT :
 {
-  "thought_trace": "1. ANALYSE: ... 2. EXTRACTION: ... 3. STRATÉGIE: ... 4. ACTION: ...",
-  "tool": "calculate_occupancy_rate" | "audit_data_quality" | "get_stock_alerts" | "get_patient_stats" | "none",
-  "args": { "dataframe_name": "df_ressources" }
+  "thought_trace": "Analyse étape par étape...",
+  "tool": "nom_du_tool" | "none",
+  "args": { "dataframe_name": "nom_du_df" }
 }
-
-IMPORTANT: Pour les fonctions de calcul, tu DOIS spécifier le nom du DataFrame dans args.
 """
 
     def execute_function(self, function_name, args):
-        """Exécute une fonction métier avec les arguments fournis"""
         if function_name not in self.available_functions:
             return {"error": f"Fonction {function_name} inconnue"}
         
-        # Récupération du DataFrame demandé
         df_name = args.get("dataframe_name")
         if not df_name or df_name not in self.dataframes:
-            return {"error": f"DataFrame {df_name} non disponible. DataFrames disponibles: {list(self.dataframes.keys())}"}
+            return {"error": f"Données {df_name} indisponibles."}
         
-        df = self.dataframes[df_name]
-        
-        # Exécution de la fonction
         try:
             func = self.available_functions[function_name]
-            result = func(df)
+            result = func(self.dataframes[df_name])
             return {"success": True, "result": result}
         except Exception as e:
-            return {"error": f"Erreur lors de l'exécution: {str(e)}"}
+            return {"error": str(e)}
 
     def ask(self, user_message, chat_history):
-        """Essaie les modèles en cascade jusqu'à obtenir une réponse valide"""
-        
         system_prompt = self.build_base_system_prompt()
         last_error = None
         
         for model_name in self.MODEL_CASCADE:
             try:
-                response_text = ""
-                
                 if "gemini" in model_name:
-                    if not self.google_key: 
-                        continue
-                    
-                    msgs = self._format_messages_for_gemini(system_prompt, chat_history, user_message)
+                    if not self.google_key: continue
                     model = genai.GenerativeModel(model_name)
-                    res = model.generate_content(
-                        msgs, 
-                        generation_config={"response_mime_type": "application/json"}
-                    )
+                    res = model.generate_content(user_message, generation_config={"response_mime_type": "application/json"})
                     response_text = res.text
-                    
-                else:  # Groq (Llama)
-                    if not self.groq_client: 
-                        continue
-                    
-                    msgs = self._format_messages_for_groq(system_prompt, chat_history, user_message)
+                else:
+                    if not self.groq_client: continue
                     completion = self.groq_client.chat.completions.create(
                         model=model_name, 
-                        messages=msgs, 
-                        temperature=0.0, 
+                        messages=[{"role":"system","content":system_prompt},{"role":"user","content":user_message}],
                         response_format={"type": "json_object"}
                     )
                     response_text = completion.choices[0].message.content
 
-                # Nettoyage de la réponse
-                clean_text = response_text.strip()
-                clean_text = re.sub(r'```json\s*|\s*```', '', clean_text)
+                action = json.loads(re.sub(r'```json\s*|\s*```', '', response_text).strip())
+                thought_trace = action.get("thought_trace", "")
+                tool = action.get("tool")
                 
-                # Tentative de parsing JSON
-                try:
-                    action = json.loads(clean_text)
-                    
-                    # Récupération du Chain of Thought
-                    thought_trace = action.get("thought_trace", "")
-                    
-                    # Exécution de la fonction si demandée
-                    tool = action.get("tool")
-                    if tool and tool != "none":
-                        args = action.get("args", {})
-                        function_result = self.execute_function(tool, args)
-                        
-                        return "", action, thought_trace, function_result
-                    
-                    return "", action, thought_trace, None
-                    
-                except json.JSONDecodeError:
-                    continue
+                func_res = None
+                if tool and tool != "none":
+                    func_res = self.execute_function(tool, action.get("args", {}))
                 
+                return "", action, thought_trace, func_res
             except Exception as e:
                 last_error = str(e)
                 continue
+        return f"⚠️ Erreur : {last_error}", None, "", None
 
-        # Si tous les modèles ont échoué
-        return f"⚠️ ERREUR SYSTEME : {last_error}", None, "", None
-
-    def _format_messages_for_groq(self, system_prompt, chat_history, user_message):
-        """Formate les messages pour Groq (OpenAI format)"""
-        msgs = [{"role": "system", "content": system_prompt}]
-        
-        for m in chat_history[-4:]:
-            role = "assistant" if m["role"] in ["model", "assistant"] else "user"
-            content = str(m.get("content", ""))
-            if "🛠️" not in content and content.strip(): 
-                msgs.append({"role": role, "content": content})
-        
-        msgs.append({"role": "user", "content": user_message})
-        return msgs
-
-    def _format_messages_for_gemini(self, system_prompt, chat_history, user_message):
-        """Formate les messages pour Gemini"""
-        msgs = [{"role": "user", "parts": [system_prompt]}]
-        
-        for m in chat_history[-4:]:
-            role = "user" if m["role"] == "user" else "model"
-            content = str(m.get("content", ""))
-            if "🛠️" not in content and content.strip(): 
-                msgs.append({"role": role, "parts": [content]})
-        
-        msgs.append({"role": "user", "parts": [user_message]})
-        return msgs
-
-# --- 2. FONCTION D'AFFICHAGE (SHOW_TERMINAL) ---
+# --- 2. FONCTION D'AFFICHAGE MISE À JOUR ---
 def show_terminal(gspread_client, sheet_name="bdd_mvp_faker"):
-    """
-    Fonction principale appelée par Streamlit pour afficher l'interface de l'agent
-    """
+    apply_custom_styles() # Application du style Gotham
+    
     st.markdown("## 🤖 AIP COMMAND TERMINAL")
-    st.caption("Agent Jasmine - Analyse Hospitalière Intelligente")
-
-    # 1. Vérification des données (Lien avec Data Explorer)
-    # On récupère les dataframes chargés dans le session_state par l'autre module
+    
     dataframes = {}
     if 'data_explorer' in st.session_state:
         dataframes = st.session_state.data_explorer.dataframes
     
     if not dataframes:
-        st.warning("⚠️ Aucune donnée n'est chargée en mémoire.")
-        st.info("👉 Veuillez d'abord aller dans le menu **Data Explorer** et cliquer sur 'Charger les Données'.")
+        st.warning("⚠️ Aucune donnée chargée. Allez dans le Data Explorer.")
         return
 
-    # 2. Initialisation de l'Agent (Singleton dans la session)
     if 'jasmine_agent' not in st.session_state:
-        # On passe dataframes à l'agent pour qu'il puisse exécuter les fonctions
-        st.session_state.jasmine_agent = JasmineAgent(
-            rdf_store=None,     # Pas encore utilisé
-            ontology_rules=None, # Pas encore utilisé
-            dataframes=dataframes
-        )
+        st.session_state.jasmine_agent = JasmineAgent(None, None, dataframes=dataframes)
     
-    # 3. Initialisation de l'historique de chat
     if "messages" not in st.session_state:
         st.session_state.messages = []
 
-    # 4. Affichage de l'historique
+    # Affichage de l'historique avec les styles de Code 01
     for message in st.session_state.messages:
         with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-            # Si un résultat de fonction est stocké, on l'affiche proprement
-            if "function_result" in message and message["function_result"]:
-                with st.expander("🛠️ Résultat technique"):
-                    st.json(message["function_result"])
+            if message["role"] == "user":
+                st.markdown(f'<div class="user-msg">{message["content"]}</div>', unsafe_allow_html=True)
+            else:
+                # Bloc pensée (Chain of Thought)
+                if "thought" in message and message["thought"]:
+                    with st.expander("🕵️ Jasmine Thought Trace", expanded=False):
+                        st.markdown(f'<div class="debug-block">{message["thought"]}</div>', unsafe_allow_html=True)
+                
+                st.markdown(f'<div class="bot-msg">{message["content"]}</div>', unsafe_allow_html=True)
+                
+                if "function_result" in message and message["function_result"]:
+                    with st.expander("🛠️ Résultat technique"):
+                        st.json(message["function_result"])
 
-    # 5. Zone de saisie utilisateur
-    if prompt := st.chat_input("Ex: Calcule le taux d'occupation des lits"):
-        # Ajout message utilisateur
+    # Zone de saisie
+    if prompt := st.chat_input("Ex: Analyse la qualité des données"):
         st.session_state.messages.append({"role": "user", "content": prompt})
-        with st.chat_message("user"):
-            st.markdown(prompt)
+        st.rerun()
 
-        # Réponse de l'agent
+    # Logique de réponse
+    if st.session_state.messages and st.session_state.messages[-1]["role"] == "user":
+        last_prompt = st.session_state.messages[-1]["content"]
+        
         with st.chat_message("assistant"):
-            message_placeholder = st.empty()
-            with st.spinner("Jasmine analyse la demande..."):
-                # Appel à la méthode ask de la classe JasmineAgent
+            with st.spinner("Jasmine analyse..."):
                 err, action, thought, func_res = st.session_state.jasmine_agent.ask(
-                    prompt, 
-                    st.session_state.messages
+                    last_prompt, st.session_state.messages[:-1]
                 )
 
                 if err:
-                    st.error(err)
-                    response_text = "Désolé, une erreur technique est survenue."
+                    response_text = f"Erreur système : {err}"
                 else:
-                    # Affichage de la pensée (Thought Trace)
-                    if thought:
-                        with st.expander("💭 Raisonnement de l'IA"):
-                            st.write(thought)
-                    
-                    # Construction de la réponse textuelle
                     if action.get("tool") and action.get("tool") != "none":
-                        response_text = f"J'ai exécuté la commande `{action['tool']}` pour répondre à votre besoin."
+                        response_text = f"Action exécutée : `{action['tool']}`. Voici l'analyse des résultats."
                     else:
-                        response_text = "Analyse terminée (aucune action technique requise)."
-
-                    message_placeholder.markdown(response_text)
-                    
-                    # Affichage du résultat de la fonction
-                    if func_res:
-                        if "success" in func_res:
-                            st.success("✅ Exécution réussie")
-                            st.json(func_res["result"])
-                        else:
-                            st.error(f"❌ Erreur fonction : {func_res.get('error')}")
-
-            # Sauvegarde dans l'historique
-            st.session_state.messages.append({
-                "role": "assistant",
-                "content": response_text,
-                "thought": thought,
-                "function_result": func_res
-            })
+                        response_text = "Analyse terminée. Comment puis-je vous aider davantage ?"
+
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": response_text,
+                    "thought": thought,
+                    "function_result": func_res
+                })
+                st.rerun()