File size: 19,167 Bytes
51b711f
 
 
bd0fafb
51b711f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
bd0fafb
51b711f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
bd0fafb
 
 
 
51b711f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
bd0fafb
 
 
51b711f
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
# type: ignore
"""
================================================================================
KIAMI V21 ULTIMATE - CONTEXT ISOLATION MODULE
================================================================================
Sistema de isolamento de contexto entre conversas (PV e Grupos).
Garante que contexto de um grupo não vaze para outro ou para PVs.

Features:
- Context ID único por combinação (usuário + tipo + grupo)
- Salt criptográfico para prevenir guessing
- CRUD completo para contextos isolados
- Integração com Database para persistência
- Suporte a migração de dados existentes
================================================================================
"""

import os
import sys
import hashlib
import time
import json
import logging
from pathlib import Path
from typing import Optional, Dict, Any, List, Tuple
from dataclasses import dataclass, field, asdict
from datetime import datetime

# Imports robustos com fallback
try:
    from . import config
    from .database import Database
    CONTEXT_ISOLATION_AVAILABLE = True
except ImportError:
    try:
        import modules.config as config
        from modules.database import Database
        CONTEXT_ISOLATION_AVAILABLE = True
    except ImportError:
        CONTEXT_ISOLATION_AVAILABLE = False
        config = None
        Database = None

logger = logging.getLogger(__name__)

# ============================================================
# CONFIGURAÇÃO DE ISOLAMENTO
# ============================================================

# Salt para geração de context_id (muda a cada deployment)
CONTEXT_SALT: str = os.getenv("CONTEXT_SALT", "KIAMI_V21_CONTEXT_ISOLATION_v1")

# Versão do esquema de isolamento (para migrações)
SCHEMA_VERSION: int = 1


@dataclass
class ConversationContext:
    """
    Contexto isolado para uma conversa específica (PV ou Grupo).
    
    Attributes:
        context_id: Identificador único (hash de tipo + numero + grupo)
        numero_usuario: Número do usuário
        grupo_id: ID do grupo (None para PV)
        tipo_conversa: "pv" ou "grupo"
        short_memory: Lista de mensagens de curto prazo (max 100)
        estado_emocional: Estado emocional atual
        nivel_intimidade: Nível de intimidade (1-3)
        created_at: Timestamp de criação
        last_interaction: Timestamp da última interação
        metadata: Metadados adicionais
    """
    context_id: str
    numero_usuario: str
    grupo_id: Optional[str] = None
    tipo_conversa: str = "pv"
    short_memory: List[Dict[str, Any]] = field(default_factory=list)
    estado_emocional: str = "neutral"
    nivel_intimidade: int = 1
    created_at: float = field(default_factory=time.time)
    last_interaction: float = field(default_factory=time.time)
    metadata: Dict[str, Any] = field(default_factory=dict)
    
    def to_dict(self) -> Dict[str, Any]:
        """Converte para dicionário serializável."""
        return asdict(self)
    
    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> 'ConversationContext':
        """Cria instância a partir de dicionário."""
        return cls(**data)
    
    @property
    def is_grupo(self) -> bool:
        """Retorna True se for conversa em grupo."""
        return self.tipo_conversa == "grupo"
    
    @property
    def display_name(self) -> str:
        """Nome de exibição do contexto."""
        if self.is_grupo:
            return f"Grupo {self.grupo_id or 'desconhecido'}"
        return f"PV {self.numero_usuario}"


# ============================================================
# FUNÇÕES DE GERAÇÃO DE CONTEXT ID
# ============================================================

def generate_context_id(
    numero_usuario: str,
    tipo_conversa: str,
    grupo_id: Optional[str] = None
) -> str:
    """
    Gera ID único e criptográfico para uma conversa.
    
    Args:
        numero_usuario: Número de telefone do usuário
        tipo_conversa: "pv" ou "grupo"
        grupo_id: ID do grupo (opcional)
        
    Returns:
        String de 64 caracteres (SHA256 hash)
    """
    # Limpa inputs (preserva caracteres alfanuméricos para suportar LIDs e Identidades Únicas)
    numero_clean = "".join(c for c in str(numero_usuario) if c.isalnum()) or "unknown"
    tipo_clean = str(tipo_conversa).lower().strip()
    # Para grupos, mantemos apenas caracteres alfanuméricos
    grupo_clean = "".join(c for c in str(grupo_id) if c.isalnum()) if grupo_id else "pv"

    # 🔒 ISOLAMENTO CRÍTICO: CADA usuário tem seu próprio contexto mesmo em grupos
    # NÃO compartilhar contexts entre usuários - causa vazamento de memória e mistura de conversas
    # Antes: if tipo_clean == "grupo" -> raw = f"...shared:{grupo_clean}" (BUG - vazamento)
    # Agora: sempre incluir numero_usuario na chave para isolamento total
    raw = f"{CONTEXT_SALT}:{tipo_clean}:{numero_clean}:{grupo_clean}"

    # Gera hash
    hash_obj = hashlib.sha256(raw.encode('utf-8'))
    return hash_obj.hexdigest()


def validate_context_id(context_id: str) -> bool:
    """
    Valida formato de context_id.
    
    Args:
        context_id: ID a ser validado
        
    Returns:
        True se formato válido
    """
    if not context_id or not isinstance(context_id, str):
        return False
    
    # SHA256 hex = 64 caracteres
    return len(context_id) == 64 and all(c in '0123456789abcdef' for c in context_id)


# ============================================================
# CLASSE PRINCIPAL DE ISOLAMENTO
# ============================================================

class ContextIsolationManager:
    """
    Gerenciador de isolamento de contexto.
    
    Provides:
    - Criação e gestão de contextos isolados
    - Persistência em banco de dados
    - Migração de dados legados
    - Estatísticas e debugging
    """
    
    _instance = None
    _lock = None
    
    def __new__(cls):
        if cls._instance is None:
            # Import threading here to avoid top-level overhead if not used
            import threading
            cls._lock = threading.Lock()
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance
    
    def __init__(self):
        if self._initialized:
            return
        
        self._db: Optional[Database] = None
        self._contexts_cache: Dict[str, ConversationContext] = {}
        self._initialized = True
        
        # Logger
        if CONTEXT_ISOLATION_AVAILABLE and config:
            logger.info("✅ ContextIsolationManager inicializado")
        else:
            print("[WARN] ContextIsolationManager: config/database não disponíveis")
    
    def _get_db(self) -> Database:
        """Obtém instância do banco de dados usando DB_PATH do config (com fallback seguro)."""
        if self._db is None:
            if Database:
                try:
                    db_path = getattr(config, 'DB_PATH', None) or "data/akira.db"
                    self._db = Database(str(db_path))
                except Exception:
                    self._db = Database()
            else:
                raise RuntimeError("Database não disponível")
        return self._db
    
    # ============================================================
    # CRIAÇÃO E GESTÃO DE CONTEXTOS
    # ============================================================
    
    def get_or_create_context(
        self,
        numero_usuario: str,
        tipo_conversa: str,
        grupo_id: Optional[str] = None,
        metadata: Optional[Dict[str, Any]] = None
    ) -> ConversationContext:
        """
        Obtém contexto existente ou cria novo.
        
        Args:
            numero_usuario: Número do usuário
            tipo_conversa: "pv" ou "grupo"
            grupo_id: ID do grupo (None para PV)
            metadata: Metadados opcionais para novo contexto
            
        Returns:
            ConversationContext instance
        """
        context_id = generate_context_id(numero_usuario, tipo_conversa, grupo_id)
        
        # Verifica cache
        if context_id in self._contexts_cache:
            ctx = self._contexts_cache[context_id]
            ctx.last_interaction = time.time()
            return ctx
        
        # Tenta carregar do banco
        db = self._get_db()
        ctx_data = db.recuperar_contexto_isolado(context_id)
        
        if ctx_data:
            ctx = ConversationContext.from_dict(ctx_data)
        else:
            # Cria novo contexto
            ctx = ConversationContext(
                context_id=context_id,
                numero_usuario=numero_usuario,
                grupo_id=grupo_id,
                tipo_conversa=tipo_conversa,
                metadata=metadata or {}
            )
            # Salva no banco
            self._save_context(ctx)
        
        # Atualiza cache
        ctx.last_interaction = time.time()
        self._contexts_cache[context_id] = ctx
        
        return ctx
    
    def get_conversation_id(
        self,
        usuario: str = "",
        conversation_type: str = "pv",
        group_id: Optional[str] = None,
        numero: Optional[str] = None
    ) -> str:
        """
        Gera e retorna o conversation_id da conversa.
        Compatível com chamadas de api.py.
        """
        nr = numero or usuario or "anonimo"
        return generate_context_id(nr, conversation_type, group_id)

    def get_context(
        self,
        numero_usuario: str,
        tipo_conversa: str,
        grupo_id: Optional[str] = None
    ) -> Optional[ConversationContext]:
        """
        Obtém contexto existente (não cria novo).
        
        Args:
            numero_usuario: Número do usuário
            tipo_conversa: "pv" ou "grupo"
            grupo_id: ID do grupo
            
        Returns:
            ConversationContext ou None se não existir
        """
        context_id = generate_context_id(numero_usuario, tipo_conversa, grupo_id)
        
        # Verifica cache
        if context_id in self._contexts_cache:
            return self._contexts_cache[context_id]
        
        # Busca no banco
        db = self._get_db()
        ctx_data = db.recuperar_contexto_isolado(context_id)
        
        if ctx_data:
            ctx = ConversationContext.from_dict(ctx_data)
            self._contexts_cache[context_id] = ctx
            return ctx
        
        return None
    
    def _save_context(self, context: ConversationContext) -> bool:
        """Salva contexto no banco de dados."""
        try:
            db = self._get_db()
            return db.salvar_contexto_isolado(context.to_dict())
        except Exception as e:
            logger.warning(f"Falha ao salvar contexto: {e}")
            return False
    
    def save_context(self, context: ConversationContext) -> bool:
        """Salva contexto e atualiza cache."""
        context.last_interaction = time.time()
        self._contexts_cache[context.context_id] = context
        return self._save_context(context)
    
    def delete_context(self, context_id: str) -> bool:
        """
        Remove contexto isolado.
        
        Args:
            context_id: ID do contexto a remover
            
        Returns:
            True se removido com sucesso
        """
        if not validate_context_id(context_id):
            logger.warning(f"Context ID inválido: {context_id}")
            return False
        
        # Remove do cache
        if context_id in self._contexts_cache:
            del self._contexts_cache[context_id]
        
        # Remove do banco
        try:
            db = self._get_db()
            return db.deletar_contexto_isolado(context_id)
        except Exception as e:
            logger.warning(f"Falha ao deletar contexto: {e}")
            return False
    
    # ============================================================
    # GESTÃO DE MEMÓRIA DE CURTO PRAZO
    # ============================================================
    
    def add_message_to_context(
        self,
        context: ConversationContext,
        role: str,
        content: str,
        importancia: float = 1.0,
        emocao: str = "neutral",
        reply_info: Optional[Dict[str, Any]] = None
    ) -> None:
        """
        Adiciona mensagem à memória de curto prazo do contexto.
        
        Args:
            context: ConversationContext
            role: "user" ou "assistant"
            content: Texto da mensagem
            importancia: Peso da mensagem (1.0 = normal, >1.0 = reply)
            emocao: Emoção detectada
            reply_info: Info adicional se for reply
        """
        MAX_MESSAGES = 100  # Configurado pelo usuário
        
        message_entry = {
            "role": role,
            "content": content,
            "timestamp": time.time(),
            "importancia": importancia,
            "emocao": emocao,
            "reply_info": reply_info or {}
        }
        
        # Adiciona à lista
        context.short_memory.append(message_entry)
        
        # Sliding window - remove mensagens antigas
        if len(context.short_memory) > MAX_MESSAGES:
            context.short_memory = context.short_memory[-MAX_MESSAGES:]
        
        # Atualiza timestamp
        context.last_interaction = time.time()
        
        # Salva no banco
        self.save_context(context)
    
    def get_context_window(
        self,
        context: ConversationContext,
        include_replies: bool = True,
        prioritize_replies: bool = True,
        max_messages: int = 100
    ) -> List[Dict[str, Any]]:
        """
        Obtém janela de contexto com prioridade para replies.
        
        Args:
            context: ConversationContext
            include_replies: Se deve incluir mensagens de reply
            prioritize_replies: Se deve dar prioridade a replies
            max_messages: Máximo de mensagens a retornar
            
        Returns:
            Lista de mensagens ordenadas por importância
        """
        messages = context.short_memory.copy()
        
        if not messages:
            return []
        
        # Filtra replies se necessário
        if not include_replies:
            messages = [m for m in messages if not m.get('reply_info', {})]
        
        # Ordena por importância (replies primeiro)
        if prioritize_replies:
            messages.sort(key=lambda x: x.get('importancia', 1.0), reverse=True)
        
        # Limita quantidade
        return messages[:max_messages]
    
    def clear_context_memory(self, context: ConversationContext) -> bool:
        """
        Limpa memória de curto prazo do contexto.
        
        Args:
            context: ConversationContext
            
        Returns:
            True se limpo com sucesso
        """
        context.short_memory = []
        context.last_interaction = time.time()
        return self.save_context(context)
    
    # ============================================================
    # LISTAGEM E ESTATÍSTICAS
    # ============================================================
    
    def list_user_contexts(self, numero_usuario: str) -> List[ConversationContext]:
        """
        Lista todos os contextos de um usuário.
        
        Args:
            numero_usuario: Número do usuário
            
        Returns:
            Lista de ConversationContext
        """
        try:
            db = self._get_db()
            contexts_data = db.listar_contextos_usuario(numero_usuario)
            
            contexts = []
            for data in contexts_data:
                ctx = ConversationContext.from_dict(data)
                # Atualiza cache
                self._contexts_cache[ctx.context_id] = ctx
                contexts.append(ctx)
            
            return contexts
        except Exception as e:
            logger.warning(f"Erro ao listar contextos: {e}")
            return []
    
    def get_stats(self) -> Dict[str, Any]:
        """
        Retorna estatísticas do sistema de isolamento.
        
        Returns:
            Dicionário com estatísticas
        """
        return {
            "cached_contexts": len(self._contexts_cache),
            "schema_version": SCHEMA_VERSION,
            "context_salt_set": bool(os.getenv("CONTEXT_SALT")),
            "max_messages_per_context": 100
        }
    
    # ============================================================
    # MIGRAÇÃO DE DADOS LEGADOS
    # ============================================================
    
    def migrate_legacy_context(
        self,
        numero_usuario: str,
        grupo_id: Optional[str] = None,
        tipo_conversa: str = "pv"
    ) -> Optional[ConversationContext]:
        """
        Migra contexto legado para novo sistema isolado.
        """
        existing = self.get_context(numero_usuario, tipo_conversa, grupo_id)
        if existing:
            return existing
        context = self.get_or_create_context(numero_usuario, tipo_conversa, grupo_id)
        logger.info(f"📦 Contexto migrado: {context.display_name}")
        return context

# ============================================================
# FUNÇÕES DE COMPATIBILIDADE
# ============================================================

def get_isolation_manager() -> ContextIsolationManager:
    """Obtém instância singleton do gerenciador."""
    return ContextIsolationManager()


def criar_contexto_isolado(
    numero_usuario: str,
    tipo_conversa: str,
    grupo_id: Optional[str] = None
) -> ConversationContext:
    """
    Factory function para criar contexto isolado.
    
    Args:
        numero_usuario: Número do usuário
        tipo_conversa: "pv" ou "grupo"
        grupo_id: ID do grupo (None para PV)
        
    Returns:
        ConversationContext instance
    """
    manager = get_isolation_manager()
    return manager.get_or_create_context(numero_usuario, tipo_conversa, grupo_id)


# ============================================================
# HELPER PARA API
# ============================================================

def extrair_conversation_id_do_request(data: Dict[str, Any]) -> Tuple[str, str, Optional[str]]:
    """
    Extrai parâmetros para conversation_id de um request da API.
    
    Args:
        data: Payload do request (dict)
        
    Returns:
        Tupla (numero_usuario, tipo_conversa, grupo_id)
    """
    numero_usuario = data.get('numero', 'anonimo') or 'anonimo'
    tipo_conversa = data.get('tipo_conversa', 'pv')
    
    # Para mensagens de grupo, grupo_id vem em campos diferentes
    grupo_id = data.get('grupo_id') or data.get('contexto_grupo')
    
    return numero_usuario, tipo_conversa, grupo_id


# ============================================================
# COMPATIBILIDADE — aliases para imports legados
# ============================================================

# Injeção dinâmica removida - método agora está na classe


# type: ignore