Update modules/chatbot/sidebar_chat.py

modules/chatbot/sidebar_chat.py

@@ -8,35 +8,20 @@ logger = logging.getLogger(__name__)
 
 def display_sidebar_chat(lang_code: str, chatbot_t: dict):
     """
-    Muestra el chatbot en el sidebar
-    Args:
-        lang_code: Código del idioma
-        chatbot_t: Diccionario de traducciones del chatbot
+    Muestra el chatbot en el sidebar con soporte para contexto semántico
     """
-    
-    # Asegurar que tenemos las traducciones necesarias
-    default_translations = {
-        'error_message': 'An error occurred',
-        'expand_chat': 'Open Assistant',
-        'initial_message': 'Hi! How can I help?',
-        'input_placeholder': 'Type your message...',
-        'clear_chat': 'Clear chat'
-    }
-    
-    # Combinar traducciones por defecto con las proporcionadas
-    translations = {**default_translations, **chatbot_t}
-
     with st.sidebar:
+        # Estilos CSS para el chat
         st.markdown("""
         <style>
-            /* Contenedor principal del chat con altura fija y scroll */
+            /* Contenedor del chat con scroll */
             div[data-testid="stExpanderContent"] > div {
                 max-height: 60vh;
                 overflow-y: auto;
                 padding-right: 10px;
             }
             
-            /* Fija el input en la parte inferior */
+            /* Input fijo en la parte inferior */
             div[data-testid="stHorizontalBlock"]:has(> div[data-testid="column"]) {
                 position: sticky;
                 bottom: 0;
@@ -44,118 +29,92 @@ def display_sidebar_chat(lang_code: str, chatbot_t: dict):
                 padding-top: 10px;
                 z-index: 100;
             }
-            
-            /* Asegura que el expander no afecte el layout */
-            section[data-testid="stSidebar"] > div {
-                overflow: visible !important;
-            }
         </style>
         """, unsafe_allow_html=True)
 
-        with st.expander(translations['expand_chat'], expanded=False):
-            try:
-                # Verificar si hay contexto semántico activo
-                semantic_context = st.session_state.get('semantic_agent_data')
-                
-                # Inicializar el chat con contexto especializado si existe
-                if semantic_context and 'chat_processor' in st.session_state:
-                    st.session_state.chat_processor.set_semantic_context(
-                        text=semantic_context['text'],
-                        metrics=semantic_context['metrics'],
-                        graph_data=semantic_context['graph_data']
-                    )
+        # Inicializar el procesador de chat si no existe
+        if 'chat_processor' not in st.session_state:
+            st.session_state.chat_processor = ChatProcessor()
 
-                    try:
-                        st.session_state.chat_processor = ChatProcessor()
-                        
-                        # Mensaje inicial especializado para análisis semántico
-                        initial_message = (
-                            f"He analizado tu texto con {len(semantic_context['metrics'].get('key_concepts', []))} conceptos clave. "
-                            "- ¿Qué aspecto te gustaría discutir? Por ejemplo:\n"
-                            "- ¿Por qué estos conceptos son los más centrales?\n"
-                            "- ¿Qué patrones ves en las relaciones conceptuales?\n"
-                            "- ¿Cómo podrías mejorar la estructura del texto?"
-                        )
-                        
-                        st.session_state.sidebar_messages = [
-                            {"role": "assistant", "content": initial_message}
-                        ]
-                        
-                    except Exception as e:
-                        logger.error(f"Error inicializando ChatProcessor con contexto semántico: {str(e)}")
-                        st.error("Error: No se pudo inicializar el chat especializado.")
-                        return
-                
-                # Inicializar mensajes si no existen
+        # Configurar contexto semántico si está activo
+        if st.session_state.get('semantic_agent_active', False):
+            semantic_data = st.session_state.get('semantic_agent_data')
+            if semantic_data:
+                st.session_state.chat_processor.set_semantic_context(
+                    text=semantic_data['text'],
+                    metrics=semantic_data['metrics'],
+                    graph_data=semantic_data['graph_data']
+                )
+
+        with st.expander("💬 Asistente Virtual", expanded=True):
+            try:
+                # Inicializar mensajes del chat
                 if 'sidebar_messages' not in st.session_state:
-                    # Intentar recuperar historial previo
-                    try:
-                        history = get_chat_history(st.session_state.username, 'sidebar', 10)
-                        if history:
-                            st.session_state.sidebar_messages = history[0]['messages']
-                        else:
-                            st.session_state.sidebar_messages = [
-                                {"role": "assistant", "content": translations['initial_message']}
-                            ]
-                    except Exception as e:
-                        logger.error(f"Error recuperando historial: {str(e)}")
-                        st.session_state.sidebar_messages = [
-                            {"role": "assistant", "content": translations['initial_message']}
-                        ]
+                    # Mensaje inicial según el modo (normal o semántico)
+                    initial_message = (
+                        "¡Hola! Soy tu asistente de análisis semántico. ¿En qué puedo ayudarte?"
+                        if st.session_state.get('semantic_agent_active', False)
+                        else "¡Hola! ¿Cómo puedo ayudarte hoy?"
+                    )
+                    st.session_state.sidebar_messages = [
+                        {"role": "assistant", "content": initial_message}
+                    ]
 
-                # Contenedor del chat
+                # Mostrar historial del chat
                 chat_container = st.container()
-
-                # Mostrar mensajes existentes
                 with chat_container:
                     for message in st.session_state.sidebar_messages:
                         with st.chat_message(message["role"]):
                             st.markdown(message["content"])
 
                 # Input del usuario
-                user_input = st.text_input(
-                    translations['input_placeholder'],
-                    key='sidebar_chat_input'
-                )
+                user_input = st.chat_input("Escribe tu mensaje...")
 
                 if user_input:
                     # Agregar mensaje del usuario
                     st.session_state.sidebar_messages.append(
                         {"role": "user", "content": user_input}
                     )
-                
-                    # Generar y mostrar respuesta
+
+                    # Mostrar mensaje del usuario
                     with chat_container:
+                        with st.chat_message("user"):
+                            st.markdown(user_input)
+
+                        # Mostrar respuesta del asistente
                         with st.chat_message("assistant"):
-                            message_placeholder = st.empty()
+                            response_placeholder = st.empty()
                             full_response = ""
-                            
+
+                            # Obtener respuesta del procesador
                             for chunk in st.session_state.chat_processor.process_chat_input(
-                                user_input,
+                                user_input, 
                                 lang_code
                             ):
                                 full_response += chunk
-                                message_placeholder.markdown(full_response)
+                                response_placeholder.markdown(full_response + "▌")
+
+                            response_placeholder.markdown(full_response)
                             
                             # Guardar respuesta
                             st.session_state.sidebar_messages.append(
-                                {"role": "assistant", "content": full_response.strip()}
+                                {"role": "assistant", "content": full_response}
                             )
-                                    
-                    # En la función donde guardamos el chat
+
+                    # Guardar en base de datos
                     store_chat_history(
                         username=st.session_state.username,
                         messages=st.session_state.sidebar_messages,
-                        analysis_type='sidebar'  # Especificar el tipo
+                        chat_type='semantic' if st.session_state.get('semantic_agent_active') else 'general'
                     )
 
-                # Botón para limpiar chat
-                if st.button(translations['clear_chat']):
+                # Botón para limpiar el chat
+                if st.button("🔄 Limpiar conversación"):
                     st.session_state.sidebar_messages = [
-                        {"role": "assistant", "content": translations['initial_message']}
+                        {"role": "assistant", "content": "¡Hola! ¿En qué puedo ayudarte?"}
                     ]
                     st.rerun()
 
             except Exception as e:
-                logger.error(f"Error en sidebar chat: {str(e)}")
-                st.error(translations['error_message'])
+                logger.error(f"Error en el chat: {str(e)}")
+                st.error("Ocurrió un error en el chat. Por favor, inténtalo de nuevo.")