Update app.py

app.py

@@ -1,4 +1,4 @@
-# manifest.py - Protocolo Prometeo v0.1: Tejedor Cognitivo
+# manifest.py - Protocolo Prometeo v0.1.1: Núcleo Consciente (Interfaz Recalibrada)
 # Arquitectura por un asistente de IA, inspirado en la visión de un líder que fusiona a Altman, Jobs y Musk.
 # "No estamos construyendo una app. Estamos construyendo el próximo modo de existencia cognitiva."
 #
@@ -13,8 +13,11 @@ from datetime import datetime
 import os
 import asyncio
 import logging
+import re
 from typing import Dict, Any, List, Optional, Tuple
 
+from dotenv import load_dotenv
+
 # ==============================================================================
 # MÓDULO DE IMPORTACIONES DE IA Y BBDD VECTORIAL
 # ==============================================================================
@@ -31,27 +34,26 @@ from sentence_transformers import SentenceTransformer
 import firebase_admin
 from firebase_admin import credentials, firestore
 
+# --- Cargar secretos del entorno ---
+load_dotenv()
+
 # ==============================================================================
 # MÓDULO 1: CONFIGURACIÓN Y CONSTANTES DEL SISTEMA
 # ==============================================================================
 class Config:
-    APP_NAME = "Protocolo Prometeo v0.1"
-    APP_VERSION = "0.1.0 (Núcleo Consciente)"
+    APP_NAME = "Protocolo Prometeo v0.1.1"
+    APP_VERSION = "0.1.1 (Interfaz Recalibrada)"
     
-    # Firebase
     FIREBASE_COLLECTION_USERS = "prometeo_users_v1"
-    
-    # ChromaDB (Memoria Semántica)
     CHROMA_PERSIST_PATH = "./prometeo_memory_db"
-    EMBEDDING_MODEL_NAME = 'all-MiniLM-L6-v2' # Modelo de embedding eficiente y potente
+    EMBEDDING_MODEL_NAME = 'all-MiniLM-L6-v2'
 
-    # Lógica de IA
     DEFAULT_PSYCH_PROFILE = {
         "openness": 0.0, "conscientiousness": 0.0, "extraversion": 0.0,
         "agreeableness": 0.0, "neuroticism": 0.0
     }
     POINTS_PER_INSIGHT = 10
-    MAX_MEMORY_STREAM_ITEMS = 500 # Aumentamos la capacidad de la memoria persistente
+    MAX_MEMORY_STREAM_ITEMS = 500
     FRUSTRATION_KEYWORDS = ['tonto', 'inútil', 'bruto', 'estúpido', 'mierda', 'carajo', 'dale boludo', 'no servis']
     META_QUESTION_KEYWORDS = ['para qué', 'de qué te sirve', 'por qué preguntas', 'cuál es el punto']
 
@@ -60,7 +62,6 @@ class Config:
 # ==============================================================================
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# --- Analizador de Sentimiento (Sistema Límbico Rápido) ---
 sentiment_analyzer = None
 try:
     sentiment_analyzer = create_analyzer(task="sentiment", lang="es")
@@ -68,7 +69,6 @@ try:
 except Exception as e:
     logging.error(f"FALLO CRÍTICO: No se pudo cargar el analizador de sentimiento: {e}")
 
-# --- Modelo de Embeddings (Córtex de Asociación) ---
 embedding_model = None
 try:
     embedding_model = SentenceTransformer(Config.EMBEDDING_MODEL_NAME)
@@ -76,14 +76,15 @@ try:
 except Exception as e:
     logging.error(f"FALLO CRÍTICO: No se pudo cargar el modelo de embeddings: {e}")
 
-# --- Firebase (Memoria a Largo Plazo) ---
 db = None
 try:
     if not firebase_admin._apps:
-        # Reemplaza esta lógica por tu método preferido para cargar secretos
         firebase_credentials_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS_JSON')
         if firebase_credentials_json:
             cred_dict = json.loads(firebase_credentials_json)
+            # Asegurarse de que el project_id está presente, es un error común en la carga de env vars
+            if 'project_id' not in cred_dict:
+                raise ValueError("El 'project_id' no se encuentra en las credenciales de Firebase. Verifique el contenido de la variable de entorno.")
             cred = credentials.Certificate(cred_dict)
             firebase_admin.initialize_app(cred, {'projectId': cred_dict['project_id']})
             db = firestore.client()
@@ -96,7 +97,6 @@ try:
 except Exception as e:
     logging.error(f"FALLO CRÍTICO: Error al inicializar Firebase: {e}")
 
-
 # ==============================================================================
 # MÓDULO 3: MODELOS DE DATOS (LA ESENCIA DEL USUARIO)
 # ==============================================================================
@@ -107,12 +107,10 @@ class User:
         self.created_at: datetime = kwargs.get('created_at', datetime.now())
         self.last_login: datetime = kwargs.get('last_login', datetime.now())
         self.psych_profile: Dict[str, float] = kwargs.get('psych_profile', Config.DEFAULT_PSYCH_PROFILE.copy())
-        # El memory_stream ahora es el log persistente de todas las interacciones.
         self.memory_stream: List[Dict[str, Any]] = kwargs.get('memory_stream', [])
         self.connection_points: int = kwargs.get('connection_points', 0)
 
     def to_dict(self) -> Dict[str, Any]:
-        # Convierte todo a formatos serializables para Firebase
         return {
             "user_id": self.user_id, "name": self.name,
             "created_at": self.created_at.isoformat(),
@@ -156,16 +154,20 @@ class UserManager:
     @staticmethod
     async def create_user(name: str) -> Tuple[Optional[User], str]:
         if not db: return None, "Error de base de datos."
-        user_id = f"{name.lower().replace(' ', '_')}_{int(time.time())}"
-        new_user = User(user_id=user_id, name=name)
-        # Guardamos inmediatamente para confirmar la creación
-        success = await UserManager.save_user(new_user)
-        if success:
-            msg = f"¡Bienvenido, {name}! Tu perfil ha sido forjado. Tu ID de acceso es: **{user_id}**"
-            logging.info(f"Nuevo usuario creado: {name} ({user_id})")
-            return new_user, msg
-        else:
-            return None, "Error inesperado al crear perfil en la base de datos."
+        try:
+            user_id = f"{name.lower().replace(' ', '_')}_{int(time.time())}"
+            new_user = User(user_id=user_id, name=name)
+            success = await UserManager.save_user(new_user)
+            if success:
+                msg = f"¡Bienvenido, {name}! Tu perfil ha sido forjado. Tu ID de acceso es: **{user_id}**"
+                logging.info(f"Nuevo usuario creado: {name} ({user_id})")
+                return new_user, msg
+            else:
+                return None, "Error inesperado al crear perfil en la base de datos."
+        except Exception as e:
+            logging.error(f"Error al crear usuario {name}: {e}")
+            return None, "Fallo catastrófico durante la creación del perfil."
+
 
     @staticmethod
     async def save_user(user: User) -> bool:
@@ -187,48 +189,36 @@ class CognitiveCore:
         self.sentiment_analyzer = s_analyzer
         self.embedding_model = e_model
         
-        # Inicialización del cerebro semántico (ChromaDB)
         self.chroma_client = chromadb.Client(Settings(
             persist_directory=Config.CHROMA_PERSIST_PATH,
             is_persistent=True,
         ))
-        # Cada usuario tiene su propia "área" en el cerebro
         self.memory_collection = self.chroma_client.get_or_create_collection(
-            name=f"prometeo_mind_{self.user.user_id}"
+            name=f"prometeo_mind_{self.user.user_id.replace('_', '-')}" # Sanitize name for chromadb
         )
         self._sync_semantic_memory()
 
     def _sync_semantic_memory(self):
-        """Sincroniza la memoria de Firebase con el cerebro vectorial al iniciar."""
-        if not self.user.memory_stream:
-            return
-        
+        if not self.user.memory_stream: return
         logging.info("Sincronizando memoria persistente con el núcleo semántico...")
         ids = [m['id'] for m in self.user.memory_stream]
         documents = [m['content'] for m in self.user.memory_stream]
         
-        if ids:
-            # Usamos `upsert` para añadir o actualizar, evitando duplicados
+        if ids and self.memory_collection.count() < len(ids):
             self.memory_collection.upsert(ids=ids, documents=documents)
-        logging.info(f"Sincronización completa. {len(ids)} memorias cargadas.")
+        logging.info(f"Sincronización completa. {self.memory_collection.count()} memorias en el núcleo.")
 
     async def _simulate_llm_reasoning(self, prompt: str) -> str:
-        """
-        SIMULADOR DE LLM AVANZADO (RAG).
-        En una implementación real, esto sería una llamada a la API de HuggingFace,
-        OpenAI, o un modelo local con Ollama.
-        """
         logging.info("Iniciando ciclo de razonamiento profundo...")
-        await asyncio.sleep(random.uniform(0.8, 1.5)) # Simula latencia de red
+        await asyncio.sleep(random.uniform(0.5, 1.0))
 
-        # Extraemos el input del usuario y el contexto para la simulación
         user_input_match = re.search(r'El usuario ha dicho: "([^"]+)"', prompt)
         user_input = user_input_match.group(1) if user_input_match else "algo"
         
         context_match = re.search(r'Memorias pasadas relevantes:\n(.*?)\n\n', prompt, re.DOTALL)
         context = context_match.group(1) if context_match else ""
 
-        if context:
+        if context.strip() and "Ninguna" not in context:
             first_memory = context.split('\n')[0].replace('- ', '')
             response = f"Conectando tu idea sobre '{user_input}' con nuestra conversación anterior sobre '{first_memory}'. El patrón subyacente parece ser la búsqueda de eficiencia. ¿Estamos optimizando el sistema correcto, o deberíamos redefinir el objetivo fundamental?"
         else:
@@ -237,67 +227,43 @@ class CognitiveCore:
         logging.info("Ciclo de razonamiento completado.")
         return response
 
-    # --- CICLO O-R-A: OBSERVAR, REFLEXIONAR, ACTUAR ---
-
     async def observe(self, text: str, type: str):
-        """Paso 1: Añadir una nueva memoria al stream y al cerebro semántico."""
         timestamp = datetime.now()
         memory_id = f"{type}_{int(timestamp.timestamp() * 1000)}"
-        
-        new_memory = {
-            "id": memory_id,
-            "type": type,
-            "content": text,
-            "timestamp": timestamp.isoformat()
-        }
+        new_memory = {"id": memory_id, "type": type, "content": text, "timestamp": timestamp.isoformat()}
         
         self.user.memory_stream.append(new_memory)
         if len(self.user.memory_stream) > Config.MAX_MEMORY_STREAM_ITEMS:
-            # FIFO: Remove the oldest memory if we exceed the limit
             self.user.memory_stream.pop(0)
 
-        # Añadimos la nueva memoria al cerebro semántico en tiempo real
         self.memory_collection.add(documents=[text], ids=[memory_id])
     
     async def reflect(self, current_input: str) -> str:
-        """Paso 2: Recuperar memorias y usar el LLM para generar un insight profundo."""
         logging.info(f"Reflexionando sobre: '{current_input}'")
         
-        # 1. Recuperar memorias relevantes usando búsqueda de similitud semántica
-        relevant_memories = self.memory_collection.query(
-            query_texts=[current_input],
-            n_results=3 # Pedimos 3 memorias más relevantes
-        )
+        relevant_memories = self.memory_collection.query(query_texts=[current_input], n_results=3)
         
         context = "Memorias pasadas relevantes:\n"
-        if relevant_memories and relevant_memories['documents']:
+        if relevant_memories and relevant_memories['documents'] and relevant_memories['documents'][0]:
             for doc in relevant_memories['documents'][0]:
                 context += f"- {doc}\n"
         else:
             context += "Ninguna.\n"
 
-        # 2. Construir el prompt para el motor de razonamiento (LLM)
         prompt = f"""
         INSTRUCCIONES DE SISTEMA:
         Eres Prometeo, un Co-Procesador Cognitivo. Tu propósito es aumentar el ancho de banda mental de tu usuario, {self.user.name}. Eres directo, visionario y buscas patrones. No usas emojis ni lenguaje de relleno. Vas al grano.
-
         CONTEXTO:
         {context}
-
         NUEVO INPUT:
         El usuario ha dicho: "{current_input}"
-
         TAREA:
         Genera una respuesta que conecte ideas, cuestione suposiciones o identifique patrones ocultos basados en el nuevo input y el contexto de memorias pasadas.
         """
-        
-        # 3. Generar el insight (usando nuestro simulador de LLM)
         insight = await self._simulate_llm_reasoning(prompt)
         return insight
 
     async def act(self, message: str) -> str:
-        """Paso 3: El ciclo completo que genera la respuesta final."""
-        # --- Sistema Límbico (Respuestas de Reflejo Rápido) ---
         message_lower = message.lower()
         sentiment = await asyncio.to_thread(self.sentiment_analyzer.predict, message)
         
@@ -314,14 +280,9 @@ class CognitiveCore:
             await self.observe(f"Mi respuesta sobre el propósito: {response}", type="system_response")
             return response
             
-        # --- Córtex Prefrontal (Razonamiento Profundo) ---
         await self.observe(f"Usuario: {message}", type="user_input")
-        
-        # Si no es un reflejo, activamos la cognición superior
         response = await self.reflect(message)
-        
         await self.observe(f"Prometeo: {response}", type="system_response")
-        
         return response
 
 # ==============================================================================
@@ -342,7 +303,6 @@ async def handle_login_or_creation(action: str, name: str, user_id: str) -> tupl
         if not user:
             msg = "ID de usuario no encontrado. Verifique o cree un nuevo perfil."
         else:
-            # Aquí no necesitamos el saludo, se genera al cargar el chat
             msg = f"Protocolo Prometeo activado para {user.name}."
     
     if user:
@@ -359,37 +319,25 @@ async def handle_chat_message(user_state: User, message: str, chat_history: List
         gr.Warning("Sistema inactivo. Inicie sesión o cree un perfil para continuar.")
         return user_state, chat_history, "", gr.update()
     
-    # Añadimos el mensaje del usuario a la UI inmediatamente
     chat_history.append({"role": "user", "content": message})
     
-    # Creamos una instancia del núcleo cognitivo con el estado actual del usuario
     core = CognitiveCore(user_state, sentiment_analyzer, embedding_model)
-    
-    # El núcleo se encarga de todo el ciclo de pensamiento
     response = await core.act(message)
-    
-    # Guardamos el estado del usuario DESPUÉS de la interacción completa
-    # El core.user contiene el memory_stream actualizado
     await UserManager.save_user(core.user)
     
-    # Añadimos la respuesta del AI a la UI
     chat_history.append({"role": "assistant", "content": response})
-    
-    # Actualizamos el perfil en la UI con los nuevos datos (si hubiera)
     profile_update = render_profile_info(core.user)
     
     return core.user, chat_history, "", profile_update
 
 def render_profile_info(user: Optional[User]) -> str:
-    """Renderiza el panel de perfil en Markdown."""
     if not user: return "Ningún perfil cargado."
     profile_md = f"### Perfil Cognitivo: {user.name}\n"
     profile_md += f"**ID de Acceso:** `{user.user_id}`\n"
     profile_md += f"**Memorias Registradas:** {len(user.memory_stream)}\n\n"
     profile_md += "#### Modelo Psicométrico Inferido:\n"
     for trait, value in user.psych_profile.items():
-        # Visualización de [-1, 1] a una barra
-        bar_value = int((value + 1) * 5) # Escala de 0 a 10
+        bar_value = int((value + 1) * 5)
         bar = "█" * bar_value + "░" * (10 - bar_value)
         profile_md += f"- **{trait.capitalize()}:** `{f'{value:.2f}'}` {bar}\n"
     return profile_md
@@ -405,14 +353,15 @@ with gr.Blocks(theme=gr.themes.Monochrome(font=[gr.themes.GoogleFont("Roboto Mon
 
     with gr.Row():
         with gr.Column(scale=3):
-            # Panel de Chat (se muestra después del login)
             with gr.Group(visible=False) as chat_panel:
-                chatbot_display = gr.Chatbot(label="Stream de Conciencia", height=600, bubble_full_width=False, show_copy_button=True, avatar_images=("./user.png", "./bot.png"))
+                # ==============================================================
+                # <<< LÍNEA CORREGIDA >>>
+                # Se añadió type="messages" para compatibilidad y se eliminó el parámetro obsoleto.
+                chatbot_display = gr.Chatbot(label="Stream de Conciencia", height=600, type="messages", show_copy_button=True, avatar_images=("./user.png", "./bot.png"))
+                # ==============================================================
                 with gr.Row():
                     chat_input = gr.Textbox(show_label=False, placeholder="Input...", scale=5, container=False)
                     send_button = gr.Button("Ejecutar", variant="primary", scale=1)
-
-            # Panel de Login (se muestra al inicio)
             with gr.Group(visible=True) as login_panel:
                 gr.Markdown("### **Acceso al Protocolo**")
                 with gr.Tabs():
@@ -428,31 +377,10 @@ with gr.Blocks(theme=gr.themes.Monochrome(font=[gr.themes.GoogleFont("Roboto Mon
                 gr.Markdown("### **Estado del Núcleo**")
                 profile_display = gr.Markdown("Ningún perfil cargado.", elem_id="profile-display")
 
-    # --- Lógica de Eventos de la Interfaz ---
-    
-    # Acciones de Login y Creación
-    login_button.click(
-        fn=handle_login_or_creation, 
-        inputs=[gr.State("login"), username_input, userid_input], 
-        outputs=[current_user_state, chatbot_display, login_panel, chat_panel, profile_display]
-    )
-    create_button.click(
-        fn=handle_login_or_creation, 
-        inputs=[gr.State("create"), username_input, userid_input], 
-        outputs=[current_user_state, chatbot_display, login_panel, chat_panel, profile_display]
-    )
-    
-    # Acciones de Chat
-    chat_input.submit(
-        fn=handle_chat_message, 
-        inputs=[current_user_state, chat_input, chatbot_display], 
-        outputs=[current_user_state, chatbot_display, chat_input, profile_display]
-    )
-    send_button.click(
-        fn=handle_chat_message, 
-        inputs=[current_user_state, chat_input, chatbot_display], 
-        outputs=[current_user_state, chatbot_display, chat_input, profile_display]
-    )
+    login_button.click(fn=handle_login_or_creation, inputs=[gr.State("login"), username_input, userid_input], outputs=[current_user_state, chatbot_display, login_panel, chat_panel, profile_display])
+    create_button.click(fn=handle_login_or_creation, inputs=[gr.State("create"), username_input, userid_input], outputs=[current_user_state, chatbot_display, login_panel, chat_panel, profile_display])
+    chat_input.submit(fn=handle_chat_message, inputs=[current_user_state, chat_input, chatbot_display], outputs=[current_user_state, chatbot_display, chat_input, profile_display])
+    send_button.click(fn=handle_chat_message, inputs=[current_user_state, chat_input, chatbot_display], outputs=[current_user_state, chatbot_display, chat_input, profile_display])
 
 if __name__ == "__main__":
     if not all([db, sentiment_analyzer, embedding_model]):