Update semantic_database.py

semantic_database.py

@@ -15,9 +15,9 @@ logger = logging.getLogger(__name__)
 class SemanticDatabase:
     """
     💾 SISTEMA DE BASE DE DATOS SEMÁNTICA — ¡AHORA EN USO ACTIVO!
-    
+
     Gestiona:
-    - Cache de prompts de alta calidad (¡priorizados por el agente!)
+    - Caché de prompts de alta calidad (¡priorizados por el agente!)
     - Memoria episódica de sesiones
     - Estadísticas del sistema
     - Optimización y limpieza automática
@@ -35,7 +35,7 @@ class SemanticDatabase:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
                 
-                # Tabla de cache de prompts — ¡AHORA USADA ACTIVAMENTE!
+                # Tabla de caché de prompts — ¡AHORA USADA ACTIVAMENTE!
                 cursor.execute("""
                     CREATE TABLE IF NOT EXISTS prompt_cache (
                         prompt_hash TEXT PRIMARY KEY,
@@ -109,7 +109,7 @@ class SemanticDatabase:
     
     def store_cache_result(self, original_prompt: str, enhanced_prompt: str, 
                           category: str, similarity_score: float, source_field: str) -> bool:
-        """💾 Almacena resultado en cache — ¡USADO POR EL AGENTE!"""
+        """💾 Almacena resultado en caché — ¡USADO POR EL AGENTE!"""
         try:
             prompt_hash = self._get_prompt_hash(original_prompt)
             
@@ -149,11 +149,11 @@ class SemanticDatabase:
                     return True
                     
         except Exception as e:
-            logger.error(f"❌ Error almacenando en cache: {e}")
+            logger.error(f"❌ Error almacenando en caché: {e}")
             return False
     
     def get_cached_result(self, prompt: str) -> Optional[Dict]:
-        """🔍 Busca resultado en cache"""
+        """🔍 Busca resultado en caché"""
         try:
             prompt_hash = self._get_prompt_hash(prompt)
             
@@ -204,7 +204,7 @@ class SemanticDatabase:
                     return None
                     
         except Exception as e:
-            logger.error(f"❌ Error buscando en cache: {e}")
+            logger.error(f"❌ Error buscando en caché: {e}")
             return None
 
     def get_top_cached_prompts(self, prompt: str, category: str, top_k: int = 5) -> List[Dict]:
@@ -365,15 +365,177 @@ class SemanticDatabase:
                     
                     stats = {}
                     
-                    # Estadísticas de cache
+                    # Estadísticas de caché
                     cursor.execute("SELECT COUNT(*), AVG(hit_count), AVG(similarity_score) FROM prompt_cache")
                     cache_stats = cursor.fetchone()
-                    stats['cache'] = {
-                        'total_entries': cache_stats[0] or 0,
-                        'avg_hit_count': round(cache_stats[1] or 0, 2),
-                        'avg_similarity': round(cache_stats[2] or 0, 3)
+                    stats['caché'] = {
+                        'total_entradas': cache_stats[0] or 0,
+                        'promedio_usos': round(cache_stats[1] or 0, 2),
+                        'promedio_similitud': round(cache_stats[2] or 0, 3)
                     }
                     
                     # Estadísticas de memoria episódica
                     cursor.execute("""
-                        SELECT COUNT(*), COUNT(DISTINCT session_id), 
+                        SELECT COUNT(*), COUNT(DISTINCT session_id), 
+                               AVG(similarity_score), AVG(processing_time),
+                               SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*)
+                        FROM episodic_memory
+                    """)
+                    memory_stats = cursor.fetchone()
+                    stats['episódica'] = {
+                        'búsquedas_totales': memory_stats[0] or 0,
+                        'sesiones_únicas': memory_stats[1] or 0,
+                        'promedio_similitud': round(memory_stats[2] or 0, 3),
+                        'tiempo_promedio': round(memory_stats[3] or 0, 2),
+                        'tasa_éxito': round(memory_stats[4] or 0, 1)
+                    }
+                    
+                    # Estadísticas de últimos 7 días
+                    cursor.execute("""
+                        SELECT SUM(total_searches), SUM(cache_hits), AVG(avg_processing_time)
+                        FROM daily_stats 
+                        WHERE date >= date('now', '-7 days')
+                    """)
+                    weekly_stats = cursor.fetchone()
+                    stats['semanal'] = {
+                        'búsquedas_totales': weekly_stats[0] or 0,
+                        'aciertos_caché': weekly_stats[1] or 0,
+                        'tiempo_promedio': round(weekly_stats[2] or 0, 2)
+                    }
+                    
+                    # Información de la base de datos
+                    cursor.execute("SELECT COUNT(*) FROM sqlite_master WHERE type='table'")
+                    table_count = cursor.fetchone()[0]
+                    
+                    stats['base_de_datos'] = {
+                        'tablas': table_count,
+                        'tamaño_mb': self._get_db_size_mb(),
+                        'última_limpieza': self._get_config_value('last_cleanup'),
+                        'versión': '2.0'
+                    }
+                    
+                    return stats
+                    
+        except Exception as e:
+            logger.error(f"❌ Error obteniendo estadísticas: {e}")
+            return {}
+    
+    def cleanup_cache(self, max_age_days: int = 30, max_entries: int = 1000) -> Tuple[int, int]:
+        """🧹 Limpieza de caché antiguo"""
+        try:
+            with self.lock:
+                with sqlite3.connect(self.db_path) as conn:
+                    cursor = conn.cursor()
+                    
+                    # Eliminar entradas muy antiguas
+                    cutoff_date = (datetime.now() - timedelta(days=max_age_days)).isoformat()
+                    cursor.execute(
+                        "DELETE FROM prompt_cache WHERE last_accessed < ?",
+                        (cutoff_date,)
+                    )
+                    old_deleted = cursor.rowcount
+                    
+                    # Eliminar entradas menos usadas si hay demasiadas
+                    cursor.execute("SELECT COUNT(*) FROM prompt_cache")
+                    total_count = cursor.fetchone()[0]
+                    
+                    excess_deleted = 0
+                    if total_count > max_entries:
+                        excess_count = total_count - max_entries
+                        cursor.execute("""
+                            DELETE FROM prompt_cache 
+                            WHERE prompt_hash IN (
+                                SELECT prompt_hash FROM prompt_cache 
+                                ORDER BY hit_count ASC, last_accessed ASC 
+                                LIMIT ?
+                            )
+                        """, (excess_count,))
+                        excess_deleted = cursor.rowcount
+                    
+                    # Limpiar memoria episódica antigua (más de 90 días)
+                    old_memory_cutoff = (datetime.now() - timedelta(days=90)).isoformat()
+                    cursor.execute(
+                        "DELETE FROM episodic_memory WHERE timestamp < ?",
+                        (old_memory_cutoff,)
+                    )
+                    
+                    # Actualizar configuración
+                    self._set_config_value('last_cleanup', datetime.now().isoformat())
+                    
+                    conn.commit()
+                    
+                    total_deleted = old_deleted + excess_deleted
+                    logger.info(f"🧹 Limpieza completada: {total_deleted} entradas eliminadas")
+                    
+                    return old_deleted, excess_deleted
+                    
+        except Exception as e:
+            logger.error(f"❌ Error en limpieza: {e}")
+            return 0, 0
+    
+    def optimize_databases(self) -> bool:
+        """⚡ Optimiza la base de datos"""
+        try:
+            with self.lock:
+                with sqlite3.connect(self.db_path) as conn:
+                    cursor = conn.cursor()
+                    
+                    cursor.execute("VACUUM")
+                    cursor.execute("ANALYZE")
+                    
+                    conn.commit()
+                    
+                    logger.info("⚡ Base de datos optimizada")
+                    return True
+                    
+        except Exception as e:
+            logger.error(f"❌ Error optimizando base de datos: {e}")
+            return False
+    
+    def _get_db_size_mb(self) -> float:
+        """📏 Obtiene tamaño de la base de datos en MB"""
+        try:
+            import os
+            size_bytes = os.path.getsize(self.db_path)
+            return round(size_bytes / (1024 * 1024), 2)
+        except:
+            return 0.0
+    
+    def _get_config_value(self, key: str) -> Optional[str]:
+        """⚙️ Obtiene valor de configuración"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT value FROM system_config WHERE key = ?", (key,))
+                result = cursor.fetchone()
+                return result[0] if result else None
+        except:
+            return None
+    
+    def _set_config_value(self, key: str, value: str) -> bool:
+        """⚙️ Establece valor de configuración"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                    INSERT OR REPLACE INTO system_config (key, value) 
+                    VALUES (?, ?)
+                """, (key, value))
+                conn.commit()
+                return True
+        except:
+            return False
+    
+    def get_cache_size(self) -> int:
+        """📊 Obtiene número de entradas en caché"""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT COUNT(*) FROM prompt_cache")
+                return cursor.fetchone()[0]
+        except:
+            return 0
+    
+    def close(self):
+        """🔒 Cierra conexiones (cleanup)"""
+        logger.info("📊 Base de datos cerrada correctamente")