Update modules/contexto.py

modules/contexto.py

@@ -1,722 +1,454 @@
-# modules/database.py — AKIRA V21 FINAL CORRIGIDO (Dezembro 2025)
+# modules/contexto.py — AKIRA V21 FINAL CORRIGIDO (Dezembro 2025)
 """
-✅ TOTALMENTE ADAPTADO ao index.js atualizado
-✅ CORREÇÃO: Métodos corretos para api.py, contexto.py, treinamento.py
-✅ Estrutura completa com reply_metadata
-✅ Todos os métodos necessários implementados
+✅ TOTALMENTE ADAPTADO ao database.py correto
+✅ Usa métodos corretos do database
+✅ Processa reply_metadata do index.js
+✅ Sistema emocional DistilBERT
 """
 
-import sqlite3
+import logging
+import re
+import random
 import time
-import os
 import json
-import hashlib
-from datetime import datetime
-from typing import Optional, List, Dict, Any, Tuple
-from loguru import logger
+from typing import Optional, List, Dict, Tuple, Any
+from collections import deque
 
-class Database:
-    def __init__(self, db_path: str = "akira.db"):
-        self.db_path = db_path
-        self.max_retries = 5
-        self.retry_delay = 0.1
-        
-        db_dir = os.path.dirname(self.db_path)
-        if db_dir:
-            os.makedirs(db_dir, exist_ok=True)
-        
-        self._init_db()
-        self._ensure_columns()
-        logger.info(f"✅ Database inicializado: {self.db_path}")
+logger = logging.getLogger(__name__)
 
-    def _get_connection(self) -> sqlite3.Connection:
-        conn = sqlite3.connect(self.db_path, timeout=30.0, check_same_thread=False)
-        conn.execute('PRAGMA journal_mode=WAL')
-        conn.execute('PRAGMA synchronous=NORMAL')
-        conn.execute('PRAGMA cache_size=2000')
-        return conn
+# Modelo de emoções
+try:
+    from transformers import pipeline
+    EMOTION_CLASSIFIER = pipeline(
+        "text-classification",
+        model="j-hartmann/emotion-english-distilroberta-base",
+        top_k=3,
+        device=-1,
+        truncation=True
+    )
+    logger.info("✅ Modelo DistilBERT carregado")
+    EMOTION_CACHE = {}
+except Exception as e:
+    logger.warning(f"⚠️ DistilBERT não disponível: {e}")
+    EMOTION_CLASSIFIER = None
+    EMOTION_CACHE = {}
 
-    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:
-                with self._get_connection() as conn:
-                    c = conn.cursor()
-                    if params:
-                        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:
-                        return c.fetchall() if c.description else []
-                    else:
-                        return c.lastrowid
-            except sqlite3.OperationalError as e:
-                if "database is locked" in str(e) and attempt < self.max_retries - 1:
-                    time.sleep(self.retry_delay * (2 ** attempt))
-                    continue
-                logger.error(f"Erro SQL: {e}")
-                raise
-            except Exception as e:
-                logger.error(f"Erro na query: {e}")
-                raise
+# Mapeamento emoção → humor
+EMOTION_TO_HUMOR = {
+    "joy": "feliz_ironica",
+    "sadness": "triste_ironica",
+    "anger": "irritada_ironica",
+    "fear": "preocupada_ironica",
+    "surprise": "curiosa_ironica",
+    "disgust": "irritada_ironica",
+    "neutral": "normal_ironico",
+    "love": "romantico_carinhoso"
+}
 
-    def _init_db(self):
-        """Cria todas as tabelas necessárias"""
-        try:
-            with self._get_connection() as conn:
-                c = conn.cursor()
-                
-                # Tabela principal de mensagens
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS mensagens (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        usuario TEXT NOT NULL,
-                        usuario_nome TEXT DEFAULT '',
-                        numero TEXT NOT NULL,
-                        mensagem TEXT NOT NULL,
-                        resposta TEXT NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        tipo_contexto TEXT DEFAULT 'pv',
-                        tipo_conversa TEXT DEFAULT 'pv',
-                        tipo_mensagem TEXT DEFAULT 'texto',
-                        
-                        -- Reply info
-                        is_reply BOOLEAN DEFAULT 0,
-                        mensagem_original TEXT,
-                        mensagem_citada_limpa TEXT,
-                        reply_to_bot BOOLEAN DEFAULT 0,
-                        reply_info_json TEXT,
-                        
-                        -- Estado
-                        humor TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        emocao_detectada TEXT,
-                        confianca_emocao REAL DEFAULT 0.5,
-                        
-                        -- Grupo
-                        grupo_id TEXT DEFAULT '',
-                        grupo_nome TEXT DEFAULT '',
-                        
-                        -- Audio
-                        audio_transcricao TEXT,
-                        fonte_stt TEXT DEFAULT 'deepgram',
-                        confianca_stt REAL DEFAULT 0.0,
-                        
-                        -- Meta
-                        comando_executado TEXT,
-                        has_media BOOLEAN DEFAULT 0,
-                        media_type TEXT DEFAULT '',
-                        message_id TEXT UNIQUE,
-                        bot_response_time_ms INTEGER DEFAULT 0,
-                        is_mention BOOLEAN DEFAULT 0,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        deletado BOOLEAN DEFAULT 0
-                    )
-                ''')
-                
-                # Usuários privilegiados
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS usuarios_privilegiados (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT UNIQUE NOT NULL,
-                        nome TEXT NOT NULL,
-                        nome_curto TEXT,
-                        tom_inicial TEXT DEFAULT 'formal',
-                        pode_dar_ordens BOOLEAN DEFAULT 0,
-                        pode_usar_reset BOOLEAN DEFAULT 0,
-                        pode_forcar_modo BOOLEAN DEFAULT 0,
-                        pode_apagar_mensagens BOOLEAN DEFAULT 0,
-                        pode_moderar_grupos BOOLEAN DEFAULT 0,
-                        nivel_acesso TEXT DEFAULT 'vip',
-                        ultimo_comando TEXT,
-                        timestamp_comando DATETIME,
-                        comandos_executados INTEGER DEFAULT 0,
-                        comandos_falhos INTEGER DEFAULT 0,
-                        config_personalizada TEXT DEFAULT '{}',
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Contexto
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS contexto (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT UNIQUE NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        tipo_contexto TEXT DEFAULT 'pv',
-                        historico TEXT,
-                        humor_atual TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        nivel_transicao INTEGER DEFAULT 0,
-                        humor_alvo TEXT DEFAULT 'normal_ironico',
-                        termos TEXT,
-                        girias TEXT,
-                        tom TEXT DEFAULT 'normal',
-                        emocao_tendencia TEXT DEFAULT 'neutral',
-                        volatilidade REAL DEFAULT 0.5,
-                        nome_usuario TEXT DEFAULT '',
-                        ultima_mensagem_audio BOOLEAN DEFAULT 0,
-                        frequencia_audio INTEGER DEFAULT 0,
-                        prefere_audio BOOLEAN DEFAULT 0,
-                        nivel_confianca_stt REAL DEFAULT 0.0,
-                        configuracao_reply TEXT DEFAULT '{}',
-                        estatisticas_interacao TEXT DEFAULT '{}',
-                        ultimo_contato DATETIME,
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        data_atualizacao DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Training examples
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS training_examples (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        input_text TEXT NOT NULL,
-                        output_text TEXT NOT NULL,
-                        humor TEXT DEFAULT 'normal_ironico',
-                        modo_resposta TEXT DEFAULT 'normal_ironico',
-                        emocao_contexto TEXT,
-                        contexto_super_claro TEXT,
-                        tipo_interacao TEXT DEFAULT 'normal',
-                        score_relevancia REAL DEFAULT 1.0,
-                        tags TEXT DEFAULT '',
-                        qualidade_score REAL DEFAULT 1.0,
-                        usado BOOLEAN DEFAULT 0,
-                        usado_para_finetuning BOOLEAN DEFAULT 0,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Transições de humor
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS transicoes_humor (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        humor_anterior TEXT NOT NULL,
-                        humor_novo TEXT NOT NULL,
-                        emocao_trigger TEXT,
-                        confianca_emocao REAL,
-                        nivel_transicao INTEGER,
-                        razao TEXT,
-                        intensidade REAL DEFAULT 0.5,
-                        contexto_mensagem TEXT,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Gírias
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS girias_aprendidas (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        contexto_id TEXT NOT NULL,
-                        giria TEXT NOT NULL,
-                        significado TEXT NOT NULL,
-                        contexto TEXT,
-                        frequencia INTEGER DEFAULT 1,
-                        ultimo_uso DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        data_criacao DATETIME DEFAULT CURRENT_TIMESTAMP,
-                        UNIQUE(numero, giria)
-                    )
-                ''')
-                
-                # Comandos executados
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS comandos_executados (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        comando TEXT NOT NULL,
-                        parametros TEXT,
-                        sucesso BOOLEAN DEFAULT 1,
-                        resposta TEXT,
-                        tipo_conversa TEXT DEFAULT 'pv',
-                        grupo_id TEXT DEFAULT '',
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                # Reset log
-                c.execute('''
-                    CREATE TABLE IF NOT EXISTS reset_log (
-                        id INTEGER PRIMARY KEY AUTOINCREMENT,
-                        numero TEXT NOT NULL,
-                        tipo_reset TEXT NOT NULL,
-                        itens_apagados INTEGER DEFAULT 0,
-                        motivo TEXT,
-                        sucesso BOOLEAN DEFAULT 1,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
-                ''')
-                
-                conn.commit()
-                logger.info("✅ Tabelas criadas/verificadas")
-                
-        except Exception as e:
-            logger.error(f"❌ Erro ao criar tabelas: {e}")
-            raise
-
-    def _ensure_columns(self):
-        """Garante que todas as colunas existam"""
-        try:
-            with self._get_connection() as conn:
-                c = conn.cursor()
-                
-                # Colunas para mensagens
-                novas_colunas = [
-                    ("tipo_mensagem", "TEXT DEFAULT 'texto'"),
-                    ("reply_info_json", "TEXT"),
-                    ("usuario_nome", "TEXT DEFAULT ''"),
-                    ("grupo_id", "TEXT DEFAULT ''"),
-                    ("grupo_nome", "TEXT DEFAULT ''"),
-                    ("audio_transcricao", "TEXT"),
-                    ("fonte_stt", "TEXT DEFAULT 'deepgram'"),
-                    ("confianca_stt", "REAL DEFAULT 0.0"),
-                    ("comando_executado", "TEXT"),
-                    ("tipo_conversa", "TEXT DEFAULT 'pv'"),
-                    ("is_mention", "BOOLEAN DEFAULT 0"),
-                    ("has_media", "BOOLEAN DEFAULT 0"),
-                    ("media_type", "TEXT DEFAULT ''"),
-                    ("message_id", "TEXT UNIQUE"),
-                    ("bot_response_time_ms", "INTEGER DEFAULT 0")
-                ]
-                
-                for col_name, col_def in novas_colunas:
-                    try:
-                        c.execute(f"ALTER TABLE mensagens ADD COLUMN {col_name} {col_def}")
-                    except sqlite3.OperationalError:
-                        pass
-                
-                conn.commit()
-                
-        except Exception as e:
-            logger.warning(f"Erro ao verificar colunas: {e}")
+class MemoriaEmocional:
+    def __init__(self, max_size=50):
+        self.historico = deque(maxlen=max_size)
+        self.tendencia_emocional = "neutral"
+        self.volatilidade = 0.5
+        
+    def adicionar_interacao(self, mensagem: str, emocao: str, confianca: float):
+        self.historico.append({
+            "mensagem": mensagem[:100],
+            "emocao": emocao,
+            "confianca": confianca,
+            "timestamp": time.time()
+        })
+        self._atualizar_tendencia()
+        
+    def _atualizar_tendencia(self):
+        if not self.historico:
+            return
+        recentes = list(self.historico)[-10:]
+        contagem = {}
+        for entry in recentes:
+            emocao = entry["emocao"]
+            contagem[emocao] = contagem.get(emocao, 0) + entry["confianca"]
+        if contagem:
+            self.tendencia_emocional = max(contagem, key=contagem.get)
 
-    # ========================================================================
-    # MÉTODOS DE SALVAMENTO (ADAPTADOS AO INDEX.JS)
-    # ========================================================================
+class Contexto:
+    def __init__(self, db: Any, usuario: str = "anonimo"):
+        self.db = db
+        self.usuario = usuario
+        
+        # Estado
+        self.humor_atual = "normal_ironico"
+        self.modo_resposta_atual = "normal_ironico"
+        self.memoria_emocional = MemoriaEmocional(max_size=50)
+        
+        # Transição
+        self.nivel_transicao = 0
+        self.humor_alvo = "normal_ironico"
+        self.ultima_transicao = time.time()
+        
+        # Conversa
+        self.ultima_mensagem_akira = None
+        self.tipo_conversa = "pv"
+        self.is_grupo = False
+        
+        # Usuário
+        self.numero_usuario = ""
+        self.nome_usuario = "Anônimo"
+        self.grupo_id = ""
+        self.grupo_nome = ""
+        
+        # Histórico
+        self.historico_mensagens = []
+        
+        self._carregar_estado_inicial()
+        logger.info(f"✅ Contexto inicializado: {self.usuario}")
     
-    def salvar_mensagem(self, usuario: str, mensagem: str, resposta: str,
-                       numero: str = '', is_reply: bool = False,
-                       mensagem_original: str = None,
-                       mensagem_citada_limpa: str = None,
-                       reply_to_bot: bool = False,
-                       humor: str = 'normal_ironico',
-                       modo_resposta: str = 'normal_ironico',
-                       emocao_detectada: str = None,
-                       confianca_emocao: float = 0.5,
-                       tipo_mensagem: str = 'texto',
-                       reply_info_json: str = None,
-                       usuario_nome: str = '',
-                       grupo_id: str = '',
-                       grupo_nome: str = '',
-                       tipo_conversa: str = 'pv',
-                       audio_transcricao: str = None,
-                       fonte_stt: str = 'deepgram',
-                       confianca_stt: float = 0.0,
-                       comando_executado: str = None,
-                       has_media: bool = False,
-                       media_type: str = '',
-                       message_id: str = None,
-                       bot_response_time_ms: int = 0,
-                       is_mention: bool = False) -> bool:
-        """Salva mensagem no banco - COMPATÍVEL COM INDEX.JS"""
+    def _carregar_estado_inicial(self):
+        """Carrega estado do banco"""
         try:
-            numero_final = str(numero or usuario).strip()
-            contexto_id = self._gerar_contexto_id(numero_final, tipo_conversa)
-            
-            # Converte reply_info para JSON se for dict
-            if isinstance(reply_info_json, dict):
-                reply_info_json = json.dumps(reply_info_json, ensure_ascii=False)
+            if hasattr(self.db, 'recuperar_humor_atual'):
+                self.humor_atual = self.db.recuperar_humor_atual(self.usuario)
             
-            # Gera message_id se não fornecido
-            if not message_id:
-                message_id = f"{numero_final}_{int(time.time() * 1000)}"
+            if hasattr(self.db, 'recuperar_modo_resposta'):
+                self.modo_resposta_atual = self.db.recuperar_modo_resposta(self.usuario)
             
-            self._execute_with_retry(
-                """
-                INSERT INTO mensagens
-                (usuario, usuario_nome, mensagem, resposta, numero, contexto_id, tipo_contexto,
-                 tipo_conversa, tipo_mensagem, is_reply, mensagem_original, mensagem_citada_limpa,
-                 reply_to_bot, reply_info_json, humor, modo_resposta, emocao_detectada, 
-                 confianca_emocao, grupo_id, grupo_nome, audio_transcricao, fonte_stt, 
-                 confianca_stt, comando_executado, has_media, media_type, message_id,
-                 bot_response_time_ms, is_mention)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    usuario[:50], usuario_nome[:100] or usuario[:100], 
-                    mensagem[:4000], resposta[:4000], numero_final,
-                    contexto_id, tipo_conversa, tipo_conversa, tipo_mensagem,
-                    int(is_reply), mensagem_original, mensagem_citada_limpa,
-                    int(reply_to_bot), reply_info_json, humor, modo_resposta,
-                    emocao_detectada, confianca_emocao, grupo_id[:50], grupo_nome[:100],
-                    audio_transcricao[:2000] if audio_transcricao else None,
-                    fonte_stt[:50], confianca_stt, comando_executado[:100] if comando_executado else None,
-                    int(has_media), media_type[:50], message_id[:100],
-                    bot_response_time_ms, int(is_mention)
-                ),
-                commit=True,
-                fetch=False
-            )
+            if hasattr(self.db, 'recuperar_mensagens'):
+                try:
+                    mensagens_db = self.db.recuperar_mensagens(self.usuario, limite=10)
+                    for msg in mensagens_db:
+                        if isinstance(msg, tuple) and len(msg) >= 2:
+                            if msg[0]:  # mensagem
+                                self.historico_mensagens.append({
+                                    "role": "user",
+                                    "content": msg[0],
+                                    "timestamp": msg[7] if len(msg) > 7 else time.time()
+                                })
+                            if len(msg) > 1 and msg[1]:  # resposta
+                                self.historico_mensagens.append({
+                                    "role": "assistant",
+                                    "content": msg[1],
+                                    "timestamp": msg[7] if len(msg) > 7 else time.time()
+                                })
+                except Exception as e:
+                    logger.warning(f"Falha ao carregar histórico: {e}")
             
-            logger.debug(f"✅ Mensagem salva: {numero_final} | {tipo_mensagem}")
-            return True
+            self.historico_mensagens.sort(key=lambda x: x.get('timestamp', 0))
             
         except Exception as e:
-            logger.error(f"❌ Erro ao salvar mensagem: {e}")
-            return False
-
-    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,
-                               contexto_super_claro: Dict = None,
-                               tipo_interacao: str = "normal",
-                               score_relevancia: float = 1.0,
-                               tags: List[str] = None) -> bool:
-        """Salva exemplo de treinamento"""
+            logger.warning(f"Erro ao carregar estado: {e}")
+    
+    def detectar_emocao_avancada(self, mensagem: str) -> Tuple[str, float, Dict]:
+        """Detecta emoção usando DistilBERT"""
+        mensagem_limpa = mensagem.strip()
+        cache_key = mensagem_limpa[:100].lower()
+        
+        if cache_key in EMOTION_CACHE:
+            return EMOTION_CACHE[cache_key]
+        
+        if not EMOTION_CLASSIFIER:
+            return self._detectar_emocao_fallback(mensagem_limpa)
+        
         try:
-            contexto_json = json.dumps(contexto_super_claro, ensure_ascii=False) if contexto_super_claro else None
-            tags_str = ",".join(tags) if tags else ""
+            resultados = EMOTION_CLASSIFIER(mensagem_limpa[:256], truncation=True)
             
-            self._execute_with_retry(
-                """
-                INSERT INTO training_examples
-                (input_text, output_text, humor, modo_resposta, emocao_contexto,
-                 qualidade_score, contexto_super_claro, tipo_interacao, score_relevancia, tags)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    input_text[:2000], output_text[:2000], humor, modo_resposta,
-                    emocao_contexto, qualidade_score, contexto_json,
-                    tipo_interacao, score_relevancia, tags_str[:200]
-                ),
-                commit=True,
-                fetch=False
-            )
-            logger.debug(f"✅ Training example salvo | Score: {qualidade_score:.2f}")
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar training: {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,
-                              contexto_mensagem: str = None):
-        """Salva transição de humor"""
-        try:
-            contexto_id = self._gerar_contexto_id(numero, 'auto')
+            emocao_primaria = resultados[0][0]['label']
+            confianca_primaria = resultados[0][0]['score']
             
-            self._execute_with_retry(
-                """
-                INSERT INTO transicoes_humor
-                (numero, contexto_id, humor_anterior, humor_novo, emocao_trigger,
-                 confianca_emocao, nivel_transicao, razao, intensidade, contexto_mensagem)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                """,
-                (
-                    str(numero).strip(), contexto_id, humor_anterior, humor_novo,
-                    emocao_trigger, confianca_emocao, nivel_transicao,
-                    razao[:200], intensidade, contexto_mensagem[:500] if contexto_mensagem else None
-                ),
-                commit=True,
-                fetch=False
-            )
-            logger.debug(f"🎭 Transição salva: {humor_anterior} → {humor_novo}")
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar transição: {e}")
-
-    def salvar_giria(self, numero: str, giria: str, significado: str, contexto: str = ""):
-        """Salva gíria aprendida"""
-        try:
-            numero_final = str(numero).strip()
-            contexto_id = self._gerar_contexto_id(numero_final, 'auto')
+            detalhes = {
+                "primaria": {"emocao": emocao_primaria, "confianca": confianca_primaria},
+                "polaridade": "positiva" if emocao_primaria in ["joy", "love"] else "negativa" if emocao_primaria in ["anger", "sadness"] else "neutra"
+            }
             
-            result = self._execute_with_retry(
-                "SELECT id, frequencia FROM girias_aprendidas WHERE numero = ? AND giria = ?",
-                (numero_final, giria),
-                fetch=True
-            )
+            self.memoria_emocional.adicionar_interacao(mensagem_limpa, emocao_primaria, confianca_primaria)
             
-            if result:
-                self._execute_with_retry(
-                    """
-                    UPDATE girias_aprendidas
-                    SET frequencia = frequencia + 1,
-                        ultimo_uso = CURRENT_TIMESTAMP
-                    WHERE numero = ? AND giria = ?
-                    """,
-                    (numero_final, giria),
-                    commit=True,
-                    fetch=False
-                )
-            else:
-                self._execute_with_retry(
-                    """
-                    INSERT INTO girias_aprendidas
-                    (numero, contexto_id, giria, significado, contexto)
-                    VALUES (?, ?, ?, ?, ?)
-                    """,
-                    (numero_final, contexto_id, giria, significado, contexto[:100]),
-                    commit=True,
-                    fetch=False
-                )
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar gíria: {e}")
-            return False
-
-    # ========================================================================
-    # MÉTODOS DE RECUPERAÇÃO
-    # ========================================================================
-    
-    def recuperar_mensagens(self, numero: str, limite: int = 10) -> List[Tuple]:
-        """Recupera mensagens do usuário"""
-        try:
-            results = self._execute_with_retry(
-                """
-                SELECT mensagem, resposta, is_reply, mensagem_original, 
-                       reply_to_bot, humor, modo_resposta, timestamp
-                FROM mensagens
-                WHERE numero = ? AND deletado = 0
-                ORDER BY timestamp DESC
-                LIMIT ?
-                """,
-                (str(numero).strip(), limite),
-                fetch=True
-            )
+            resultado = (emocao_primaria, confianca_primaria, detalhes)
+            EMOTION_CACHE[cache_key] = resultado
             
-            if results:
-                return results[::-1]  # Reverter para ordem cronológica
-            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 = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            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"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT modo_resposta FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return result[0][0] if result else "normal_ironico"
-        except Exception:
-            return "normal_ironico"
-
-    def recuperar_training_examples(self, limite: int = 100, usado: bool = False) -> List[Dict]:
-        """Recupera exemplos de treinamento"""
-        try:
-            where_clause = "WHERE usado = 0" if not usado else ""
-            results = self._execute_with_retry(
-                f"""
-                SELECT input_text, output_text, humor, modo_resposta,
-                       qualidade_score, tipo_interacao
-                FROM training_examples
-                {where_clause}
-                ORDER BY qualidade_score DESC
-                LIMIT ?
-                """,
-                (limite,),
-                fetch=True
-            )
+            return resultado
             
-            return [
-                {
-                    "input": r[0],
-                    "output": r[1],
-                    "humor": r[2],
-                    "modo": r[3],
-                    "score": r[4],
-                    "tipo": r[5]
-                }
-                for r in results
-            ]
         except Exception as e:
-            logger.error(f"❌ Erro ao recuperar exemplos: {e}")
-            return []
-
-    def marcar_examples_como_usados(self, ids: List[int] = None):
-        """Marca exemplos como usados"""
-        try:
-            if ids:
-                placeholders = ','.join(['?'] * len(ids))
-                query = f"UPDATE training_examples SET usado = 1 WHERE id IN ({placeholders})"
-                self._execute_with_retry(query, tuple(ids), commit=True, fetch=False)
-            else:
-                self._execute_with_retry(
-                    "UPDATE training_examples SET usado = 1 WHERE usado = 0",
-                    commit=True,
-                    fetch=False
+            logger.warning(f"Erro no DistilBERT: {e}")
+            return self._detectar_emocao_fallback(mensagem_limpa)
+    
+    def _detectar_emocao_fallback(self, mensagem: str) -> Tuple[str, float, Dict]:
+        """Fallback para detecção de emoção"""
+        mensagem_lower = mensagem.lower()
+        positivas = ['bom', 'ótimo', 'feliz', 'adorei']
+        negativas = ['ruim', 'péssimo', 'triste', 'raiva']
+        
+        pos = sum(1 for p in positivas if p in mensagem_lower)
+        neg = sum(1 for n in negativas if n in mensagem_lower)
+        
+        if pos > neg and pos >= 2:
+            return ("joy", 0.7, {"primaria": {"emocao": "joy", "confianca": 0.7}})
+        elif neg > pos and neg >= 2:
+            return ("anger", 0.7, {"primaria": {"emocao": "anger", "confianca": 0.7}})
+        else:
+            return ("neutral", 0.5, {"primaria": {"emocao": "neutral", "confianca": 0.5}})
+    
+    def atualizar_humor_gradual(self, emocao: str, confianca: float, tom_usuario: str,
+                                usuario_privilegiado: bool = False) -> str:
+        """Atualiza humor gradualmente"""
+        humor_anterior = self.humor_atual
+        
+        # Sugere humor
+        humor_sugerido = EMOTION_TO_HUMOR.get(emocao, "normal_ironico")
+        
+        if usuario_privilegiado and tom_usuario == "formal":
+            humor_sugerido = "tecnico_formal"
+        
+        # Inicia transição
+        if self.humor_alvo != humor_sugerido:
+            self.humor_alvo = humor_sugerido
+            self.nivel_transicao = 0
+        
+        # Transição
+        taxa = 0.5
+        if confianca > 0.8:
+            taxa += 0.3
+        if tom_usuario == "rude":
+            taxa += 0.4
+        
+        self.nivel_transicao = min(3, self.nivel_transicao + taxa)
+        
+        # Novo humor
+        if self.nivel_transicao >= 3:
+            novo_humor = self.humor_alvo
+        else:
+            novo_humor = self.humor_atual
+        
+        # Salva transição se mudou
+        if novo_humor != humor_anterior and hasattr(self.db, 'salvar_transicao_humor'):
+            try:
+                self.db.salvar_transicao_humor(
+                    self.usuario,
+                    humor_anterior,
+                    novo_humor,
+                    emocao,
+                    confianca,
+                    self.nivel_transicao,
+                    f"Emoção: {emocao} ({confianca:.2f})"
                 )
-        except Exception as e:
-            logger.error(f"❌ Erro ao marcar exemplos: {e}")
-
-    # ========================================================================
-    # PRIVILÉGIOS
-    # ========================================================================
+            except Exception as e:
+                logger.warning(f"Erro ao salvar transição: {e}")
+        
+        self.humor_atual = novo_humor
+        return novo_humor
     
-    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 = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return bool(result)
-        except Exception:
-            return False
-
-    def pode_usar_reset(self, numero: str) -> bool:
-        """Verifica se pode usar reset"""
-        try:
-            result = self._execute_with_retry(
-                "SELECT pode_usar_reset FROM usuarios_privilegiados WHERE numero = ?",
-                (str(numero).strip(),),
-                fetch=True
-            )
-            return bool(result and result[0][0])
-        except Exception:
-            return False
-
-    def registrar_comando(self, numero: str, comando: str, parametros: str = None,
-                         sucesso: bool = True, resposta: str = None,
-                         tipo_conversa: str = 'pv', grupo_id: str = ''):
-        """Registra comando executado"""
-        try:
-            self._execute_with_retry(
-                """
-                INSERT INTO comandos_executados
-                (numero, comando, parametros, sucesso, resposta, tipo_conversa, grupo_id)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                """,
-                (str(numero).strip(), comando, parametros, int(sucesso), resposta, tipo_conversa, grupo_id),
-                commit=True,
-                fetch=False
-            )
-        except Exception as e:
-            logger.error(f"❌ Erro ao registrar comando: {e}")
-
-    def resetar_contexto_usuario(self, numero: str, tipo: str = "completo") -> Dict:
-        """Reseta contexto do usuário"""
+    def detectar_tom_usuario(self, mensagem: str) -> Tuple[str, float]:
+        """Detecta tom do usuário"""
+        mensagem_lower = mensagem.lower()
+        
+        # Formal
+        if any(x in mensagem_lower for x in ["senhor", "doutor", "por favor"]):
+            return ("formal", 0.8)
+        
+        # Rude
+        rudes = ['burro', 'idiota', 'merda', 'caralho']
+        if any(x in mensagem_lower for x in rudes):
+            return ("rude", 0.9)
+        
+        # Informal
+        if any(x in mensagem_lower for x in ['puto', 'mano', 'fixe']):
+            return ("informal", 0.7)
+        
+        return ("neutro", 0.5)
+    
+    def detectar_modo_resposta(self, mensagem: str, tom_usuario: str,
+                              usuario_privilegiado: bool = False) -> str:
+        """Detecta modo de resposta"""
+        mensagem_lower = mensagem.lower()
+        
+        if usuario_privilegiado and tom_usuario == "formal":
+            return "tecnico_formal"
+        
+        if tom_usuario == "rude":
+            return "agressivo_direto"
+        
+        if '?' in mensagem and len(mensagem) > 100:
+            return "filosofico_ironico"
+        
+        palavras_romanticas = ['amor', 'paixão', 'gosto de ti']
+        if any(p in mensagem_lower for p in palavras_romanticas):
+            return "romantico_carinhoso"
+        
+        return "normal_ironico"
+    
+    def analisar_intencao_e_normalizar(self, mensagem: str, historico: List[Dict] = None,
+                                      mensagem_citada: str = None,
+                                      reply_metadata: Dict = None) -> Dict[str, Any]:
+        """Análise principal - COMPATÍVEL COM INDEX.JS"""
+        if not isinstance(mensagem, str):
+            mensagem = str(mensagem)
+        
+        if historico is None:
+            historico = self.obter_historico_para_llm()
+        
+        # Verifica privilégio
+        usuario_privilegiado = False
+        if self.numero_usuario and hasattr(self.db, 'is_usuario_privilegiado'):
+            try:
+                usuario_privilegiado = self.db.is_usuario_privilegiado(self.numero_usuario)
+            except:
+                pass
+        
+        # Detecta emoção
+        emocao, confianca, detalhes_emocao = self.detectar_emocao_avancada(mensagem)
+        
+        # Detecta tom
+        tom_usuario, intensidade_tom = self.detectar_tom_usuario(mensagem)
+        
+        # Atualiza humor
+        humor_atualizado = self.atualizar_humor_gradual(
+            emocao, confianca, tom_usuario, usuario_privilegiado
+        )
+        
+        # Detecta modo
+        modo_resposta = self.detectar_modo_resposta(mensagem, tom_usuario, usuario_privilegiado)
+        self.modo_resposta_atual = modo_resposta
+        
+        # Analisa reply
+        reply_analysis = self._analisar_reply_context(mensagem_citada, reply_metadata)
+        
+        # Resultado
+        resultado = {
+            "tom_usuario": tom_usuario,
+            "tom_intensidade": intensidade_tom,
+            "emocao_primaria": emocao,
+            "confianca_emocao": confianca,
+            "detalhes_emocao": detalhes_emocao,
+            "modo_resposta": modo_resposta,
+            "humor_atualizado": humor_atualizado,
+            "nivel_transicao": self.nivel_transicao,
+            "humor_alvo": self.humor_alvo,
+            "usuario_privilegiado": usuario_privilegiado,
+            "nome_usuario": self.nome_usuario,
+            "numero_usuario": self.numero_usuario,
+            "eh_resposta": reply_analysis.get("is_reply", False),
+            "eh_resposta_ao_bot": reply_analysis.get("reply_to_bot", False),
+            "mensagem_citada_limpa": mensagem_citada or "",
+            "reply_analysis": reply_analysis,
+            "reply_metadata": reply_metadata,
+            "tipo_conversa": self.tipo_conversa,
+            "is_grupo": self.is_grupo,
+            "tendencia_emocional": self.memoria_emocional.tendencia_emocional,
+            "volatilidade_usuario": self.memoria_emocional.volatilidade
+        }
+        
+        return resultado
+    
+    def _analisar_reply_context(self, mensagem_citada: str, reply_metadata: Dict) -> Dict[str, Any]:
+        """Analisa contexto de reply"""
+        if reply_metadata:
+            return {
+                "is_reply": reply_metadata.get('is_reply', False),
+                "reply_to_bot": reply_metadata.get('reply_to_bot', False),
+                "quoted_author_name": reply_metadata.get('quoted_author_name', ''),
+                "texto_citado_completo": reply_metadata.get('texto_mensagem_citada', ''),
+                "context_hint": reply_metadata.get('context_hint', ''),
+                "source": "reply_metadata"
+            }
+        
+        if mensagem_citada:
+            reply_to_bot = "AKIRA" in mensagem_citada.upper()
+            return {
+                "is_reply": True,
+                "reply_to_bot": reply_to_bot,
+                "quoted_author_name": "Akira" if reply_to_bot else "desconhecido",
+                "texto_citado_completo": mensagem_citada,
+                "context_hint": f"Citando {'Akira' if reply_to_bot else 'outra pessoa'}",
+                "source": "mensagem_citada"
+            }
+        
+        return {
+            "is_reply": False,
+            "reply_to_bot": False,
+            "quoted_author_name": "",
+            "texto_citado_completo": "",
+            "context_hint": "",
+            "source": "nenhum"
+        }
+    
+    def obter_historico_para_llm(self) -> List[Dict]:
+        """Retorna histórico formatado"""
+        return [
+            {"role": msg["role"], "content": msg["content"][:500]}
+            for msg in self.historico_mensagens[-10:]
+        ]
+    
+    def atualizar_contexto(self, mensagem: str, resposta: str, numero: str,
+                          is_reply: bool = False, mensagem_original: str = None,
+                          reply_to_bot: bool = False):
+        """Atualiza contexto após interação"""
         try:
-            if not self.pode_usar_reset(numero):
-                return {"sucesso": False, "erro": "Sem permissão", "itens_apagados": 0}
+            timestamp = time.time()
             
-            itens = 0
+            # Adiciona ao histórico
+            self.historico_mensagens.append({
+                "role": "user",
+                "content": mensagem,
+                "timestamp": timestamp,
+                "is_reply": is_reply,
+                "reply_to_bot": reply_to_bot
+            })
+            self.historico_mensagens.append({
+                "role": "assistant",
+                "content": resposta,
+                "timestamp": timestamp
+            })
             
-            # Remove mensagens
-            self._execute_with_retry(
-                "DELETE FROM mensagens WHERE numero = ?",
-                (str(numero).strip(),),
-                commit=True,
-                fetch=False
-            )
-            itens += 1
+            # Limita
+            if len(self.historico_mensagens) > 20:
+                self.historico_mensagens = self.historico_mensagens[-20:]
             
-            # Remove contexto
-            self._execute_with_retry(
-                "DELETE FROM contexto WHERE numero = ?",
-                (str(numero).strip(),),
-                commit=True,
-                fetch=False
-            )
-            itens += 1
+            self.ultima_mensagem_akira = resposta
             
-            logger.info(f"✅ Reset completo para {numero}: {itens} itens")
-            return {"sucesso": True, "itens_apagados": itens}
+            # Salva no banco
+            if hasattr(self.db, 'salvar_mensagem'):
+                try:
+                    self.db.salvar_mensagem(
+                        usuario=self.nome_usuario,
+                        mensagem=mensagem,
+                        resposta=resposta,
+                        numero=numero,
+                        is_reply=is_reply,
+                        mensagem_original=mensagem_original or '',
+                        reply_to_bot=reply_to_bot,
+                        humor=self.humor_atual,
+                        modo_resposta=self.modo_resposta_atual,
+                        usuario_nome=self.nome_usuario,
+                        tipo_conversa=self.tipo_conversa
+                    )
+                except Exception as e:
+                    logger.warning(f"Erro ao salvar mensagem: {e}")
             
         except Exception as e:
-            logger.error(f"❌ Erro ao resetar: {e}")
-            return {"sucesso": False, "erro": str(e), "itens_apagados": 0}
-
-    # ========================================================================
-    # AUXILIARES
-    # ========================================================================
+            logger.error(f"Erro ao atualizar contexto: {e}")
     
-    def _gerar_contexto_id(self, numero: str, tipo: str = 'auto') -> str:
-        """Gera ID único para contexto"""
-        if tipo == 'auto':
-            num_str = str(numero).lower()
-            if "@g.us" in num_str or "grupo_" in num_str or "120363" in num_str:
-                tipo = "grupo"
-            else:
-                tipo = "pv"
-        
-        data_semana = datetime.now().strftime("%Y-%W")
-        salt = f"AKIRA_V21_{data_semana}_ISOLATION"
-        raw = f"{str(numero).strip()}|{tipo}|{salt}"
-        return hashlib.sha256(raw.encode()).hexdigest()[:32]
-
-    def registrar_tom_usuario(self, numero: str, tom: str, confianca: float = 0.6,
-                             mensagem_contexto: str = None) -> bool:
-        """Registra tom detectado"""
-        try:
-            logger.info(f"✅ Tom registrado: {tom} ({confianca:.2f}) para {numero}")
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro ao registrar tom: {e}")
-            return False
-
-    def salvar_aprendizado_detalhado(self, input_text: str, output_text: str,
-                                    contexto: Dict, qualidade_score: float = 1.0,
-                                    tipo_aprendizado: str = "reply_padrao",
-                                    metadata: Dict = None) -> bool:
-        """Salva aprendizado detalhado"""
-        try:
-            contexto_super_claro = {
-                'tipo_aprendizado': tipo_aprendizado,
-                'metadata': metadata or {},
-                'timestamp': time.time()
-            }
-            
-            return self.salvar_training_example(
-                input_text=input_text,
-                output_text=output_text,
-                humor=contexto.get("humor_atualizado", "normal_ironico"),
-                qualidade_score=qualidade_score,
-                contexto_super_claro=contexto_super_claro,
-                tipo_interacao=tipo_aprendizado
-            )
-        except Exception as e:
-            logger.error(f"❌ Erro ao salvar aprendizado: {e}")
-            return False
-
-    def close(self):
-        """Fecha conexão"""
-        logger.info("✅ Database fechado")
+    def atualizar_informacoes_usuario(self, nome: str, numero: str,
+                                     grupo_id: str = "", grupo_nome: str = "",
+                                     tipo_conversa: str = "pv"):
+        """Atualiza informações do usuário"""
+        self.nome_usuario = nome or self.nome_usuario
+        self.numero_usuario = numero or self.numero_usuario
+        self.grupo_id = grupo_id or self.grupo_id
+        self.grupo_nome = grupo_nome or self.grupo_nome
+        self.tipo_conversa = tipo_conversa
+        self.is_grupo = tipo_conversa == "grupo"
 
-# Singleton
-_db_instance = None
-
-def get_database(db_path: str = "akira.db") -> Database:
-    global _db_instance
-    if _db_instance is None:
-        _db_instance = Database(db_path)
-    return _db_instance
+def criar_contexto(db: Any, identificador: str, tipo: str = "pv") -> Contexto:
+    """Cria contexto isolado"""
+    try:
+        if tipo == "grupo":
+            usuario_id = f"grupo_{identificador}"
+        else:
+            usuario_id = f"pv_{identificador}"
+        
+        contexto = Contexto(db, usuario_id)
+        contexto.tipo_conversa = tipo
+        contexto.is_grupo = (tipo == "grupo")
+        
+        return contexto
+    except Exception as e:
+        logger.error(f"Erro ao criar contexto: {e}")
+        return Contexto(db, "fallback")