Update modules/database.py

modules/database.py

@@ -7,7 +7,9 @@ Banco de dados SQLite para Akira IA - COMPLETAMENTE ATUALIZADO
 ✅ Transições graduais de humor (3 níveis)
 ✅ Memória emocional BERT GoEmotions
 ✅ Backup e otimização automática
+✅ MÉTODOS FALTANTES ADICIONADOS: salvar_training_example, registrar_tom_usuario
 """
+
 import sqlite3
 import time
 import os
@@ -25,22 +27,22 @@ class Database:
         self.db_path = db_path or config.DB_PATH
         self.max_retries = 5
         self.retry_delay = 0.1
-        
+       
         # Cria diretório se necessário
         db_dir = os.path.dirname(self.db_path)
         if db_dir:
             os.makedirs(db_dir, exist_ok=True)
-        
+       
         self._init_db()
         self._ensure_all_columns_and_indexes()
         self._sincronizar_usuarios_privilegiados()  # Sincroniza com config
-        
+       
         logger.info(f"✅ Banco V21 inicializado: {self.db_path}")
 
     # ================================================================
     # ISOLAMENTO CRIPTOGRÁFICO (V21 MELHORADO)
     # ================================================================
-    
+   
     def _gerar_contexto_id(self, numero: str, tipo: str = 'auto') -> str:
         """
         Gera ID único isolado com salt dinâmico.
@@ -51,11 +53,11 @@ class Database:
                 tipo = "grupo"
             else:
                 tipo = "pv"
-        
+       
         # Salt dinâmico baseado em data
         data_semana = datetime.now().strftime("%Y-%W")
         salt = f"AKIRA_V21_{data_semana}_ISOLATION"
-        
+       
         # Hash único
         raw = f"{str(numero).strip()}|{tipo}|{salt}"
         return hashlib.sha256(raw.encode()).hexdigest()[:32]
@@ -63,7 +65,7 @@ class Database:
     # ================================================================
     # CONEXÃO COM OTIMIZAÇÕES
     # ================================================================
-    
+   
     def _get_connection(self) -> sqlite3.Connection:
         for attempt in range(self.max_retries):
             try:
@@ -84,7 +86,7 @@ class Database:
                 raise
         raise sqlite3.OperationalError("Falha após retries")
 
-    def _execute_with_retry(self, query: str, params: Optional[tuple] = None, 
+    def _execute_with_retry(self, query: str, params: Optional[tuple] = None,
                            commit: bool = False, fetch: bool = True):
         for attempt in range(self.max_retries):
             try:
@@ -94,10 +96,10 @@ class Database:
                         c.execute(query, params)
                     else:
                         c.execute(query)
-                    
+                   
                     if commit:
                         conn.commit()
-                    
+                   
                     if fetch and query.strip().upper().startswith('SELECT'):
                         return c.fetchall()
                     elif fetch:
@@ -117,13 +119,13 @@ class Database:
     # ================================================================
     # VERIFICAÇÃO E CRIAÇÃO DE COLUNAS/ÍNDICES
     # ================================================================
-    
+   
     def _ensure_all_columns_and_indexes(self):
         """Garante que todas as colunas e índices existam"""
         try:
             with self._get_connection() as conn:
                 c = conn.cursor()
-                
+               
                 # Índices para performance
                 indexes = [
                     "CREATE INDEX IF NOT EXISTS idx_mensagens_numero ON mensagens(numero, deletado)",
@@ -137,28 +139,28 @@ class Database:
                     "CREATE INDEX IF NOT EXISTS idx_comandos_numero ON comandos_executados(numero, timestamp)",
                     "CREATE INDEX IF NOT EXISTS idx_reset_numero ON reset_log(numero, timestamp)"
                 ]
-                
+               
                 for idx_query in indexes:
                     try:
                         c.execute(idx_query)
                     except Exception as e:
                         logger.warning(f"Erro ao criar índice: {e}")
-                
+               
                 conn.commit()
                 logger.info("✅ Índices verificados/criados")
-                
+               
         except Exception as e:
             logger.error(f"Erro ao verificar colunas/índices: {e}")
 
     # ================================================================
     # INICIALIZAÇÃO COMPLETA
     # ================================================================
-    
+   
     def _init_db(self):
         try:
             with self._get_connection() as conn:
                 c = conn.cursor()
-                
+               
                 # TABELA PRINCIPAL DE MENSAGENS
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS mensagens (
@@ -180,7 +182,7 @@ class Database:
                         deletado BOOLEAN DEFAULT 0
                     )
                 ''')
-                
+               
                 # TABELA DE USUÁRIOS PRIVILEGIADOS (V21)
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
@@ -200,7 +202,7 @@ class Database:
                         data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 # TABELA DE CONTEXTO
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS contexto (
@@ -222,7 +224,7 @@ class Database:
                         data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 # TABELA DE TRANSIÇÕES DE HUMOR
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS transicoes_humor (
@@ -239,7 +241,7 @@ class Database:
                         timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 # TABELA DE EXEMPLOS DE TREINAMENTO
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS training_examples (
@@ -254,7 +256,7 @@ class Database:
                         timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 # TABELA DE GÍRIAS APRENDIDAS
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS girias_aprendidas (
@@ -269,7 +271,7 @@ class Database:
                         data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 # TABELA DE COMANDOS EXECUTADOS
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS comandos_executados (
@@ -282,7 +284,7 @@ class Database:
                         timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 # TABELA DE RESETS (LOG)
                 c.execute('''
                     CREATE TABLE IF NOT EXISTS reset_log (
@@ -295,11 +297,11 @@ class Database:
                         timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                     )
                 ''')
-                
+               
                 conn.commit()
-                
+               
             logger.info("✅ Todas as tabelas criadas/verificadas")
-            
+           
         except Exception as e:
             logger.error(f"❌ Erro ao criar tabelas: {e}")
             raise
@@ -307,15 +309,15 @@ class Database:
     # ================================================================
     # SINCRONIZAÇÃO DE USUÁRIOS PRIVILEGIADOS
     # ================================================================
-    
+   
     def _sincronizar_usuarios_privilegiados(self):
         """Sincroniza usuários privilegiados do config.py com o banco"""
         try:
             for numero, dados in config.USUARIOS_PRIVILEGIADOS.items():
                 self._execute_with_retry(
                     """
-                    INSERT OR REPLACE INTO usuarios_privilegiados 
-                    (numero, nome, nome_curto, tom_inicial, pode_dar_ordens, 
+                    INSERT OR REPLACE INTO usuarios_privilegiados
+                    (numero, nome, nome_curto, tom_inicial, pode_dar_ordens,
                      pode_usar_reset, pode_forcar_modo, nivel_acesso, data_atualizacao)
                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
                     """,
@@ -332,18 +334,17 @@ class Database:
                     commit=True,
                     fetch=False
                 )
-            
+           
             logger.info(f"✅ Usuários privilegiados sincronizados: {len(config.USUARIOS_PRIVILEGIADOS)}")
-            
+           
         except Exception as e:
             logger.error(f"Erro ao sincronizar usuários privilegiados: {e}")
 
     # ================================================================
     # VERIFICAÇÃO DE PRIVILÉGIOS (ROBUSTA)
     # ================================================================
-    
+   
     def is_usuario_privilegiado(self, numero: str) -> bool:
-        """Verifica se usuário é privilegiado"""
         try:
             result = self._execute_with_retry(
                 "SELECT 1 FROM usuarios_privilegiados WHERE numero = ?",
@@ -354,22 +355,21 @@ class Database:
         except Exception as e:
             logger.error(f"Erro ao verificar privilégio: {e}")
             return False
-    
+   
     def get_usuario_privilegiado(self, numero: str) -> Optional[Dict]:
-        """Retorna dados completos do usuário privilegiado"""
         try:
             result = self._execute_with_retry(
                 """
                 SELECT numero, nome, nome_curto, tom_inicial, pode_dar_ordens,
                        pode_usar_reset, pode_forcar_modo, nivel_acesso,
                        ultimo_comando, timestamp_comando, comandos_executados
-                FROM usuarios_privilegiados 
+                FROM usuarios_privilegiados
                 WHERE numero = ?
                 """,
                 (str(numero).strip(),),
                 fetch=True
             )
-            
+           
             if result:
                 row = result[0]
                 return {
@@ -386,34 +386,30 @@ class Database:
                     "comandos_executados": row[10]
                 }
             return None
-            
+           
         except Exception as e:
             logger.error(f"Erro ao obter usuário privilegiado: {e}")
             return None
-    
+   
     def pode_dar_ordens(self, numero: str) -> bool:
-        """Verifica se usuário pode dar ordens"""
         user = self.get_usuario_privilegiado(numero)
         return user and user.get("pode_dar_ordens", False)
-    
+   
     def pode_usar_reset(self, numero: str) -> bool:
-        """Verifica se usuário pode usar /reset"""
         user = self.get_usuario_privilegiado(numero)
         return user and user.get("pode_usar_reset", False)
-    
+   
     def pode_forcar_modo(self, numero: str) -> bool:
-        """Verifica se usuário pode forçar modo"""
         user = self.get_usuario_privilegiado(numero)
         return user and user.get("pode_forcar_modo", False)
-    
-    def registrar_comando(self, numero: str, comando: str, 
+   
+    def registrar_comando(self, numero: str, comando: str,
                          parametros: str = None, sucesso: bool = True,
                          resposta: str = None):
-        """Registra comando executado"""
         try:
             self._execute_with_retry(
                 """
-                INSERT INTO comandos_executados 
+                INSERT INTO comandos_executados
                 (numero, comando, parametros, sucesso, resposta)
                 VALUES (?, ?, ?, ?, ?)
                 """,
@@ -421,12 +417,11 @@ class Database:
                 commit=True,
                 fetch=False
             )
-            
-            # Atualiza contador no usuário privilegiado
+           
             if self.is_usuario_privilegiado(numero):
                 self._execute_with_retry(
                     """
-                    UPDATE usuarios_privilegiados 
+                    UPDATE usuarios_privilegiados
                     SET ultimo_comando = ?,
                         timestamp_comando = CURRENT_TIMESTAMP,
                         comandos_executados = comandos_executados + 1,
@@ -437,32 +432,25 @@ class Database:
                     commit=True,
                     fetch=False
                 )
-            
+           
         except Exception as e:
             logger.error(f"Erro ao registrar comando: {e}")
 
     # ================================================================
     # SISTEMA DE RESET (EXCLUSIVO PARA PRIVILEGIADOS)
     # ================================================================
-    
+   
     def resetar_contexto_usuario(self, numero: str, tipo: str = "completo") -> Dict:
-        """
-        Reseta contexto do usuário.
-        Disponível APENAS para usuários com pode_usar_reset = True
-        """
         try:
-            # Verifica privilégio
             if not self.pode_usar_reset(numero):
                 return {
                     "sucesso": False,
                     "erro": "Usuário não tem permissão para reset",
                     "itens_apagados": 0
                 }
-            
-            contexto_id = self._gerar_contexto_id(numero, 'auto')
+           
             itens_apagados = 0
-            
-            # 1. Apaga mensagens
+           
             result = self._execute_with_retry(
                 "DELETE FROM mensagens WHERE numero = ?",
                 (str(numero).strip(),),
@@ -470,8 +458,7 @@ class Database:
                 fetch=False
             )
             itens_apagados += result if result else 0
-            
-            # 2. Apaga contexto
+           
             self._execute_with_retry(
                 "DELETE FROM contexto WHERE numero = ?",
                 (str(numero).strip(),),
@@ -479,8 +466,7 @@ class Database:
                 fetch=False
             )
             itens_apagados += 1
-            
-            # 3. Apaga transições de humor
+           
             result = self._execute_with_retry(
                 "DELETE FROM transicoes_humor WHERE numero = ?",
                 (str(numero).strip(),),
@@ -488,8 +474,7 @@ class Database:
                 fetch=False
             )
             itens_apagados += result if result else 0
-            
-            # 4. Apaga gírias aprendidas
+           
             result = self._execute_with_retry(
                 "DELETE FROM girias_aprendidas WHERE numero = ?",
                 (str(numero).strip(),),
@@ -497,11 +482,10 @@ class Database:
                 fetch=False
             )
             itens_apagados += result if result else 0
-            
-            # 5. Log do reset
+           
             self._execute_with_retry(
                 """
-                INSERT INTO reset_log 
+                INSERT INTO reset_log
                 (numero, tipo_reset, itens_apagados, motivo, sucesso)
                 VALUES (?, ?, ?, ?, 1)
                 """,
@@ -509,22 +493,20 @@ class Database:
                 commit=True,
                 fetch=False
             )
-            
+           
             logger.info(f"✅ Reset completo para {numero}: {itens_apagados} itens apagados")
-            
+           
             return {
                 "sucesso": True,
                 "itens_apagados": itens_apagados,
                 "mensagem": f"Contexto resetado com sucesso ({itens_apagados} itens removidos)"
             }
-            
+           
         except Exception as e:
             logger.error(f"Erro ao resetar contexto: {e}")
-            
-            # Log do erro
             self._execute_with_retry(
                 """
-                INSERT INTO reset_log 
+                INSERT INTO reset_log
                 (numero, tipo_reset, itens_apagados, motivo, sucesso)
                 VALUES (?, ?, ?, ?, 0)
                 """,
@@ -532,52 +514,43 @@ class Database:
                 commit=True,
                 fetch=False
             )
-            
             return {
                 "sucesso": False,
                 "erro": str(e),
                 "itens_apagados": 0
             }
-    
+
     def resetar_tudo(self, confirmacao: bool = False) -> Dict:
-        """
-        Reseta TODA a base de dados (APENAS para emergências).
-        Requer confirmação explícita.
-        """
         if not confirmacao:
             return {
                 "sucesso": False,
                 "erro": "Confirmação necessária. Use confirmacao=True",
                 "itens_apagados": 0
             }
-        
+       
         try:
-            # Conta total antes
             total_mensagens = self._execute_with_retry(
                 "SELECT COUNT(*) FROM mensagens",
                 fetch=True
             )[0][0]
-            
-            # Apaga tudo (exceto usuários privilegiados)
+           
             tabelas_para_resetar = [
                 "mensagens", "contexto", "transicoes_humor",
-                "girias_aprendidas", "training_examples", 
+                "girias_aprendidas", "training_examples",
                 "comandos_executados", "reset_log"
             ]
-            
-            itens_totais = 0
+           
             for tabela in tabelas_para_resetar:
                 self._execute_with_retry(f"DELETE FROM {tabela}", commit=True, fetch=False)
-                itens_totais += 1
-            
+           
             logger.warning(f"⚠️ RESET COMPLETO DA DATABASE: {total_mensagens} mensagens apagadas")
-            
+           
             return {
                 "sucesso": True,
                 "itens_apagados": total_mensagens,
                 "mensagem": f"Database resetada completamente. {total_mensagens} mensagens removidas."
             }
-            
+           
         except Exception as e:
             logger.error(f"Erro no reset completo: {e}")
             return {
@@ -589,24 +562,22 @@ class Database:
     # ================================================================
     # MÉTODOS DE RECUPERAÇÃO (COM ISOLAMENTO)
     # ================================================================
-    
+   
     def recuperar_mensagens(self, numero: str, limite: int = 10) -> List[Tuple]:
-        """Recupera histórico de mensagens"""
         try:
             results = self._execute_with_retry(
                 """
                 SELECT mensagem, resposta, is_reply, mensagem_original, reply_to_bot,
                        humor, modo_resposta, emocao_detectada, confianca_emocao
-                FROM mensagens 
+                FROM mensagens
                 WHERE numero = ? AND deletado = 0
-                ORDER BY timestamp DESC 
+                ORDER BY timestamp DESC
                 LIMIT ?
                 """,
                 (str(numero).strip(), limite),
                 fetch=True
             )
-            
-            # Retorna em ordem cronológica
+           
             if results:
                 return [
                     (
@@ -616,13 +587,12 @@ class Database:
                     for r in results[::-1]
                 ]
             return []
-            
+           
         except Exception as e:
             logger.error(f"Erro ao recuperar mensagens: {e}")
             return []
-    
+
     def recuperar_humor_atual(self, numero: str) -> str:
-        """Recupera humor atual"""
         try:
             result = self._execute_with_retry(
                 "SELECT humor_atual FROM contexto WHERE numero = ?",
@@ -632,9 +602,8 @@ class Database:
             return result[0][0] if result else "normal_ironico"
         except Exception:
             return "normal_ironico"
-    
+
     def recuperar_modo_resposta(self, numero: str) -> str:
-        """Recupera modo de resposta atual"""
         try:
             result = self._execute_with_retry(
                 "SELECT modo_resposta FROM contexto WHERE numero = ?",
@@ -644,22 +613,21 @@ class Database:
             return result[0][0] if result else "normal_ironico"
         except Exception:
             return "normal_ironico"
-    
+
     def recuperar_contexto_completo(self, numero: str) -> Dict:
-        """Recupera contexto completo do usuário"""
         try:
             result = self._execute_with_retry(
                 """
-                SELECT contexto_id, tipo_contexto, historico, humor_atual, 
+                SELECT contexto_id, tipo_contexto, historico, humor_atual,
                        modo_resposta, nivel_transicao, humor_alvo, termos,
                        girias, tom, emocao_tendencia, volatilidade
-                FROM contexto 
+                FROM contexto
                 WHERE numero = ?
                 """,
                 (str(numero).strip(),),
                 fetch=True
             )
-            
+           
             if result:
                 row = result[0]
                 return {
@@ -676,8 +644,7 @@ class Database:
                     "emocao_tendencia": row[10] or "neutral",
                     "volatilidade": row[11] or 0.5
                 }
-            
-            # Se não existir, cria contexto inicial
+           
             return {
                 "contexto_id": self._gerar_contexto_id(numero, 'auto'),
                 "tipo_contexto": "pv",
@@ -692,7 +659,7 @@ class Database:
                 "emocao_tendencia": "neutral",
                 "volatilidade": 0.5
             }
-            
+           
         except Exception as e:
             logger.error(f"Erro ao recuperar contexto: {e}")
             return {
@@ -709,9 +676,8 @@ class Database:
                 "emocao_tendencia": "neutral",
                 "volatilidade": 0.5
             }
-    
+
     def recuperar_historico_humor(self, numero: str, limite: int = 5) -> List[Dict]:
-        """Recupera histórico de transições de humor"""
         try:
             results = self._execute_with_retry(
                 """
@@ -725,7 +691,7 @@ class Database:
                 (str(numero).strip(), limite),
                 fetch=True
             )
-            
+           
             return [
                 {
                     "anterior": r[0],
@@ -742,14 +708,13 @@ class Database:
         except Exception as e:
             logger.error(f"Erro ao recuperar histórico humor: {e}")
             return []
-    
+
     def recuperar_girias_usuario(self, numero: str) -> List[Dict]:
-        """Recupera gírias aprendidas"""
         try:
             results = self._execute_with_retry(
                 """
                 SELECT giria, significado, contexto, frequencia, ultimo_uso
-                FROM girias_aprendidas 
+                FROM girias_aprendidas
                 WHERE numero = ?
                 ORDER BY frequencia DESC, ultimo_uso DESC
                 LIMIT 20
@@ -757,7 +722,7 @@ class Database:
                 (str(numero).strip(),),
                 fetch=True
             )
-            
+           
             return [
                 {
                     'giria': r[0],
@@ -771,13 +736,12 @@ class Database:
         except Exception as e:
             logger.error(f"Erro ao recuperar gírias: {e}")
             return []
-    
+
     def recuperar_training_examples(self, limite: int = 100) -> List[Dict]:
-        """Recupera exemplos para treinamento"""
         try:
             results = self._execute_with_retry(
                 """
-                SELECT input_text, output_text, humor, modo_resposta, 
+                SELECT input_text, output_text, humor, modo_resposta,
                        emocao_contexto, qualidade_score
                 FROM training_examples
                 WHERE usado = 0
@@ -787,7 +751,7 @@ class Database:
                 (limite,),
                 fetch=True
             )
-            
+           
             return [
                 {
                     "input": r[0],
@@ -802,9 +766,8 @@ class Database:
         except Exception as e:
             logger.error(f"Erro ao recuperar exemplos: {e}")
             return []
-    
+
     def marcar_examples_como_usados(self):
-        """Marca exemplos como usados"""
         try:
             self._execute_with_retry(
                 "UPDATE training_examples SET usado = 1 WHERE usado = 0",
@@ -818,24 +781,23 @@ class Database:
     # ================================================================
     # MÉTODOS DE SALVAMENTO (COM CONTEXTO)
     # ================================================================
-    
+   
     def salvar_mensagem(self, usuario: str, mensagem: str, resposta: str,
                        numero: str = '', is_reply: bool = False,
                        mensagem_original: str = None, reply_to_bot: bool = False,
-                       humor: str = 'normal_ironico', 
+                       humor: str = 'normal_ironico',
                        modo_resposta: str = 'normal_ironico',
                        emocao_detectada: str = None,
                        confianca_emocao: float = 0.5):
-        """Salva mensagem com contexto completo"""
         try:
             numero_final = str(numero or usuario).strip()
             contexto_id = self._gerar_contexto_id(numero_final, 'auto')
             tipo_contexto = "grupo" if ("@g.us" in numero_final or "120363" in numero_final) else "pv"
-            
+           
             self._execute_with_retry(
                 """
-                INSERT INTO mensagens 
-                (usuario, mensagem, resposta, numero, contexto_id, tipo_contexto, 
+                INSERT INTO mensagens
+                (usuario, mensagem, resposta, numero, contexto_id, tipo_contexto,
                  is_reply, mensagem_original, reply_to_bot, humor, modo_resposta,
                  emocao_detectada, confianca_emocao)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -849,74 +811,69 @@ class Database:
                 commit=True,
                 fetch=False
             )
-            
+           
             logger.debug(f"✅ Mensagem salva: {numero_final} ({tipo_contexto})")
             return True
-            
+           
         except Exception as e:
             logger.error(f"Erro ao salvar mensagem: {e}")
             return False
-    
+   
     def salvar_contexto(self, numero: str, **kwargs):
-        """Salva/atualiza contexto do usuário"""
         try:
             numero_final = str(numero).strip()
             contexto_id = self._gerar_contexto_id(numero_final, 'auto')
             tipo_contexto = "grupo" if ("@g.us" in numero_final or "120363" in numero_final) else "pv"
-            
-            # Prepara campos
+           
             campos = {
                 "numero": numero_final,
                 "contexto_id": contexto_id,
                 "tipo_contexto": tipo_contexto,
                 "data_atualizacao": "CURRENT_TIMESTAMP"
             }
-            
-            # Adiciona campos fornecidos
+           
             campos.update(kwargs)
-            
-            # Constrói query dinâmica
+           
             colunas = []
             valores = []
             placeholders = []
-            
+           
             for key, value in campos.items():
                 if key != "data_atualizacao":
                     colunas.append(key)
                     valores.append(value)
                     placeholders.append("?")
-            
+           
             colunas.append("data_atualizacao")
             placeholders.append("CURRENT_TIMESTAMP")
-            
+           
             query = f"""
-                INSERT OR REPLACE INTO contexto 
+                INSERT OR REPLACE INTO contexto
                 ({', '.join(colunas)})
                 VALUES ({', '.join(placeholders)})
             """
-            
+           
             self._execute_with_retry(
                 query,
                 tuple(valores),
                 commit=True,
                 fetch=False
             )
-            
+           
             return True
-            
+           
         except Exception as e:
             logger.error(f"Erro ao salvar contexto: {e}")
             return False
-    
+   
     def salvar_transicao_humor(self, numero: str, humor_anterior: str,
                               humor_novo: str, emocao_trigger: str = None,
                               confianca_emocao: float = 0.5,
                               nivel_transicao: int = 0,
                               razao: str = "", intensidade: float = 0.5):
-        """Registra transição de humor"""
         try:
             contexto_id = self._gerar_contexto_id(numero, 'auto')
-            
+           
             self._execute_with_retry(
                 """
                 INSERT INTO transicoes_humor
@@ -932,23 +889,94 @@ class Database:
                 commit=True,
                 fetch=False
             )
-            
-            # Atualiza humor no contexto
+           
             self.salvar_contexto(
                 numero=numero,
                 humor_atual=humor_novo,
                 nivel_transicao=nivel_transicao,
                 humor_alvo=humor_novo if nivel_transicao >= 3 else humor_anterior
             )
-            
+           
             logger.debug(f"🎭 Transição salva: {humor_anterior} → {humor_novo} (nivel: {nivel_transicao})")
-            
+           
         except Exception as e:
             logger.error(f"Erro ao salvar transição: {e}")
-    
+
     # ================================================================
-    # MÉTODOS FALTANTES (ADICIONADOS AGORA)
-    # =========================================================
+    # MÉTODOS FALTANTES ADICIONADOS (RESOLVEM OS ERROS)
+    # ================================================================
+
+    def salvar_training_example(self, input_text: str, output_text: str,
+                               humor: str = "normal_ironico",
+                               modo_resposta: str = "normal_ironico",
+                               emocao_contexto: str = None,
+                               qualidade_score: float = 1.0) -> bool:
+        """
+        Salva um exemplo de alta qualidade para treinamento futuro.
+        """
+        try:
+            self._execute_with_retry(
+                """
+                INSERT INTO training_examples
+                (input_text, output_text, humor, modo_resposta, emocao_contexto, qualidade_score)
+                VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (input_text[:2000], output_text[:2000], humor, modo_resposta, emocao_contexto, qualidade_score),
+                commit=True,
+                fetch=False
+            )
+            logger.info(f"✅ Training example salvo | Score: {qualidade_score:.2f}")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Erro ao salvar training example: {e}")
+            return False
+
+    def registrar_tom_usuario(self, numero: str, tom: str, confianca: float = 0.6,
+                              mensagem_contexto: str = None) -> bool:
+        """
+        Registra o tom emocional detectado do usuário.
+        Atualiza também a tendência no contexto.
+        """
+        try:
+            numero_final = str(numero).strip()
+            contexto_id = self._gerar_contexto_id(numero_final, 'auto')
+            tipo_contexto = "grupo" if ("@g.us" in numero_final or "120363" in numero_final) else "pv"
+
+            self._execute_with_retry(
+                """
+                INSERT INTO mensagens
+                (usuario, mensagem, resposta, numero, contexto_id, tipo_contexto,
+                 humor, modo_resposta, emocao_detectada, confianca_emocao)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    "SISTEMA_TOM",
+                    f"[TOM_DETECTADO: {tom}] {mensagem_contexto or ''}",
+                    "",
+                    numero_final,
+                    contexto_id,
+                    tipo_contexto,
+                    "normal_ironico",
+                    "normal_ironico",
+                    tom,
+                    confianca
+                ),
+                commit=True,
+                fetch=False
+            )
+
+            self.salvar_contexto(
+                numero=numero_final,
+                tom=tom,
+                emocao_tendencia=tom
+            )
+
+            logger.info(f"✅ Tom registrado: {tom} (confiança: {confianca:.2f}) para {numero_final}")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Erro ao registrar tom do usuário: {e}")
+            return False
+
     # ================================================================
     # FECHAMENTO SEGURO DA CONEXÃO
     # ================================================================
@@ -960,7 +988,8 @@ class Database:
         except:
             pass
 
-# Garante fechamento ao encerrar o app
+
+# Instância global e fechamento seguro ao encerrar o app
 import atexit
 db_instance = Database(config.DB_PATH)
 atexit.register(db_instance.close)