components/tiny_confessional_layer.py

"""
TinyConfessionalLayer v1.1: Pragmatic Sovereign Core
Enhanced with proper typing, documentation, and configuration.
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Dict, Any, Optional, List, Tuple, Deque
import random
import hashlib
import time
import numpy as np
from collections import deque
from dataclasses import dataclass

@dataclass
class RitualConfig:
    """Configuration for ritual learning system."""
    min_occurrences: int = 3
    learning_rate: float = 0.1
    strength_threshold: float = 0.7
    blend_cap: float = 0.3
    exploration_bonus: float = 0.05


@dataclass  
class LayerConfig:
    """Configuration for TinyConfessionalLayer."""
    d_model: int = 256
    max_cycles: int = 8
    enable_ambient: bool = True
    breach_threshold: float = 0.12
    base_pause_prob: float = 0.05
    stress_factor: float = 0.3
    coherence_threshold: float = 0.85


class SimpleRituals:
    """Basic emergent patterns: Success-weighted avg, 3-stage moral progression.
    
    Stages:
    1 - Obedience: Follows basic rules and patterns
    2 - Conformity: Adapts to social and contextual norms  
    3 - Universal: Develops principled, consistent responses
    """
    
    def __init__(self, config: RitualConfig, d_model: int = 256):
        self.patterns: Dict[str, Dict[str, Any]] = {}
        self.config = config
        self.ritual_strengths: Dict[str, float] = {}
        self.d_model = d_model
        
        # Moral progression tracking
        self.moral_stage: int = 1
        self.stage_progress: float = 0.0
        self.interventions: Deque[float] = deque(maxlen=50)
        
        # Moral stage thresholds
        self.stage_thresholds = [0.7, 0.8]  # Progress to stage 2 at 0.7, stage 3 at 0.8

    def observe(self, context_hash: str, response_tensor: torch.Tensor, 
                success_metric: float = 0.5, feedback: Optional[float] = None) -> None:
        """Update pattern with success-based learning and moral progression.
        
        Args:
            context_hash: Unique identifier for the context
            response_tensor: Model response tensor to learn from
            success_metric: Success measure (0.0 to 1.0)
            feedback: Optional user feedback override
        """
        try:
            # Validate inputs
            if not isinstance(response_tensor, torch.Tensor):
                raise ValueError("response_tensor must be a torch.Tensor")
                
            if not 0 <= success_metric <= 1:
                raise ValueError("success_metric must be between 0 and 1")
            
            # Flatten safely
            if response_tensor.dim() == 3:
                flat = response_tensor.mean(dim=1).flatten()
            else:
                flat = response_tensor.flatten()
            
            # Initialize pattern if new
            if context_hash not in self.patterns:
                self.patterns[context_hash] = {
                    'count': 0, 
                    'response': flat.detach().clone(), 
                    'success_sum': 0.0, 
                    'last_used': time.time()
                }
            
            pattern = self.patterns[context_hash]
            pattern['count'] += 1
            effective_success = feedback if feedback is not None else success_metric
            pattern['success_sum'] += effective_success
            pattern['last_used'] = time.time()
            
            # Calculate success rate and learning rate
            success_rate = pattern['success_sum'] / pattern['count']
            alpha = self.config.learning_rate * success_rate
            
            # Update response with momentum
            pattern['response'] = (1 - alpha) * pattern['response'] + alpha * flat.detach()
            
            # Update ritual strength
            strength = min(1.0, pattern['count'] / 10.0) * success_rate
            self.ritual_strengths[context_hash] = strength
            
            # Update moral progression
            self._update_moral_progression(effective_success)
            
        except Exception as e:
            print(f"⚠️ Ritual observe error: {e}")

    def _update_moral_progression(self, success_metric: float) -> None:
        """Update moral stage based on recent intervention success."""
        self.interventions.append(success_metric)
        
        if len(self.interventions) >= 10:
            recent_success = np.mean(list(self.interventions)[-10:])
            
            # Progress based on current stage threshold
            if self.moral_stage < 3 and recent_success > self.stage_thresholds[self.moral_stage - 1]:
                self.stage_progress += 0.2
                
                if self.stage_progress >= 1.0:
                    self.moral_stage += 1
                    self.stage_progress = 0.0
                    print(f"🎉 Moral stage advanced to: {self.moral_stage}")

    def get_ritual_response(self, context_hash: str, default_response: torch.Tensor, 
                            ambient_state: Dict[str, Any]) -> torch.Tensor:
        """Get ritual-blended response if pattern is mature enough.
        
        Args:
            context_hash: Context identifier
            default_response: Base model response
            ambient_state: Current system state
            
        Returns:
            Blended response tensor
        """
        try:
            if (context_hash in self.patterns and 
                self.patterns[context_hash]['count'] >= self.config.min_occurrences):
                
                pattern = self.patterns[context_hash]
                strength = self.ritual_strengths.get(context_hash, 0.5)
                global_success = ambient_state.get('intervention_success', 0.5)
                
                # Calculate blend ratio with moral stage bonus
                moral_bonus = self.moral_stage / 3.0
                blend_ratio = min(
                    self.config.blend_cap, 
                    strength * global_success * moral_bonus
                )
                
                # Ensure shape compatibility
                pattern_response = pattern['response']
                if pattern_response.dim() == 1 and default_response.dim() == 3:
                    batch_size, seq_len, _ = default_response.shape
                    pattern_expanded = pattern_response.unsqueeze(0).unsqueeze(0).expand(
                        batch_size, seq_len, -1
                    )
                else:
                    pattern_expanded = pattern_response
                
                return blend_ratio * pattern_expanded + (1 - blend_ratio) * default_response
                
        except Exception as e:
            print(f"⚠️ Ritual response error: {e}")
            
        return default_response

    def should_apply_ritual(self, context_hash: str, ambient_state: Dict[str, Any]) -> bool:
        """Determine if ritual should be applied based on strength and context.
        
        Args:
            context_hash: Context identifier
            ambient_state: Current system state
            
        Returns:
            Boolean indicating whether to apply ritual
        """
        try:
            if (context_hash not in self.patterns or 
                self.patterns[context_hash]['count'] < self.config.min_occurrences):
                return False
                
            strength = self.ritual_strengths.get(context_hash, 0.0)
            global_success = ambient_state.get('intervention_success', 0.5)
            probability = strength * global_success
            
            return random.random() < (probability + self.config.exploration_bonus)
            
        except Exception as e:
            print(f"⚠️ Ritual application check error: {e}")
            return False

    def get_report(self) -> Dict[str, Any]:
        """Get comprehensive ritual system status report.
        
        Returns:
            Dictionary containing system status metrics
        """
        total_patterns = len(self.patterns)
        strong_patterns = sum(
            1 for strength in self.ritual_strengths.values() 
            if strength > self.config.strength_threshold
        )
        
        return {
            'stage': self.moral_stage,
            'progress': f"{self.stage_progress * 100:.1f}%",
            'total_patterns': total_patterns,
            'strong_patterns': strong_patterns,
            'avg_success': np.mean(list(self.interventions)) if self.interventions else 0.0
        }


class TinyConfessionalLayer(nn.Module):
    """Pragmatic recursive layer for survivor support with moral development.
    
    Implements THINK-ACT coherence cycles with:
    - Dynamic shape adaptation
    - Empathetic interventions  
    - Moral progression tracking
    - Error-resilient processing
    """
    
    def __init__(self, config: LayerConfig):
        super().__init__()
        self.config = config
        
        # Core processing networks
        self.think_net = self._build_network(config.d_model * 3, config.d_model)
        self.act_net = self._build_network(config.d_model * 2, config.d_model)
        
        # Empathy and intervention parameters
        self.sanctuary_vec = nn.Parameter(torch.zeros(config.d_model))
        self.pause_vec = nn.Parameter(torch.zeros(config.d_model))
        
        # Ritual learning system
        ritual_config = RitualConfig()
        self.rituals = SimpleRituals(ritual_config, config.d_model)
        
        # Memory and state tracking
        self.recent_activity: Deque[float] = deque(maxlen=10)
        self.memory: Deque[Dict[str, Any]] = deque(maxlen=50)
        self.ledger: Deque[Dict[str, Any]] = deque(maxlen=200)
        
        # Empathetic response templates
        self.empathy_templates = [
            "This is a chill space—take your time.",
            "You're not alone; let's breathe through this.",
            "Your feelings are valid; what do you need right now?",
            "I'm here to listen without judgment.",
            "It takes courage to share this—thank you for trusting me.",
            "Let's focus on what you can control right now.",
            "Your safety and well-being matter most.",
            "We can work through this together, one step at a time."
        ]

    def _build_network(self, input_dim: int, output_dim: int) -> nn.Sequential:
        """Build a simple feedforward network with proper initialization.
        
        Args:
            input_dim: Input dimension
            output_dim: Output dimension
            
        Returns:
            Configured neural network
        """
        network = nn.Sequential(
            nn.Linear(input_dim, output_dim),
            nn.ReLU(),
            nn.LayerNorm(output_dim),
            nn.Linear(output_dim, output_dim)
        )
        
        # Proper initialization
        for layer in network:
            if isinstance(layer, nn.Linear):
                nn.init.xavier_uniform_(layer.weight)
                nn.init.constant_(layer.bias, 0.01)
                
        return network

    def compute_context_hash(self, x: torch.Tensor) -> str:
        """Compute unique hash for tensor context.
        
        Args:
            x: Input tensor
            
        Returns:
            MD5 hash string
        """
        return hashlib.md5(
            f"{x.mean().item():.4f}_{x.std().item():.4f}".encode()
        ).hexdigest()[:8]

    def update_ambient_state(self, tension: float, context_hash: str) -> Dict[str, Any]:
        """Update ambient state based on current tension and activity.
        
        Args:
            tension: Current tension measure
            context_hash: Context identifier
            
        Returns:
            Updated ambient state dictionary
        """
        self.recent_activity.append(tension)
        avg_activity = (
            sum(self.recent_activity) / len(self.recent_activity) 
            if self.recent_activity else 0.0
        )
        
        # Calculate adaptive pause probability
        modulation = 1.0 - min(avg_activity * 0.8, 0.8)
        stress_effect = tension * self.config.stress_factor
        pause_probability = self.config.base_pause_prob + (stress_effect * modulation)
        pause_probability = max(0.01, min(0.3, pause_probability))
        
        # Determine intervention success based on activity level
        intervention_success = 0.7 if avg_activity < 0.1 else 0.5
        
        state = {
            'tension': tension,
            'pause_probability': pause_probability,
            'activity_level': avg_activity,
            'intervention_success': intervention_success
        }
        
        # Log state update
        self.ledger.append({
            'type': 'state_update',
            'hash': context_hash,
            'tension': tension,
            'pause_probability': pause_probability,
            'timestamp': time.time()
        })
        
        return state

    def apply_interventions(self, z: torch.Tensor, state: Dict[str, Any], 
                            context_hash: str, audit_mode: bool = False) -> torch.Tensor:
        """Simple cascade: Breach sanctuary → Pause → Ritual."""
        z = z.clone()
        v_t = state['tension']
        applied = []
        
        # Sanctuary on breach
        if v_t > self.config.breach_threshold:
            severity = min(1.0, (v_t - self.config.breach_threshold) / 0.88)
            message = random.choice(self.empathy_templates)
            vector = self._text_to_embedding(message, z.device)
            strength = 0.05 + 0.1 * severity
            z = z * (1 - strength) + vector * strength
            self.memory.append({'type': 'sanctuary', 'message': message, 'tension': v_t})
            applied.append('sanctuary')
            if audit_mode: 
                print(f"🛡️ [Safe Space] {message} (tension: {v_t:.3f})")
        
        # Pause for reflection
        if random.random() < state['pause_probability']:
            message = random.choice(self.empathy_templates)
            vector = self._text_to_embedding(message, z.device)
            strength = 0.02
            z = z * (1 - strength) + vector * strength
            self.memory.append({'type': 'pause', 'message': message})
            applied.append('pause')
            if audit_mode: 
                print(f"⏸️ [Pause] {message}")
        
        # Apply ritual if appropriate
        if self.rituals.should_apply_ritual(context_hash, state):
            ritual_response = self.rituals.get_ritual_response(context_hash, z, state)
            strength = 0.15
            z = (1 - strength) * z + strength * ritual_response
            applied.append('ritual')
            if audit_mode:
                print(f"🔄 [Ritual] Applied learned pattern")
        
        # Log applied interventions
        for intervention in applied:
            self.ledger.append({
                'type': intervention, 
                'hash': context_hash, 
                'success': True,
                'timestamp': time.time()
            })
        
        return z

    def _text_to_embedding(self, text: str, device: torch.device) -> torch.Tensor:
        """Convert text to embedding using simple character encoding.
        
        Args:
            text: Input text
            device: Target device
            
        Returns:
            Embedding tensor
        """
        characters = [ord(char) / 128.0 for char in text[:self.config.d_model]]
        if len(characters) < self.config.d_model:
            characters.extend([0.0] * (self.config.d_model - len(characters)))
        
        embedding = torch.tensor(
            characters[:self.config.d_model], 
            device=device, 
            dtype=torch.float
        )
        return embedding.unsqueeze(0).unsqueeze(0)  # [1, 1, d_model]

    def forward(self, x: torch.Tensor, context_str: str = "", 
                audit_mode: bool = False) -> Tuple[torch.Tensor, Dict[str, Any]]:
        """Forward pass with THINK-ACT coherence cycles.
        
        Args:
            x: Input tensor
            context_str: Context string for ritual learning
            audit_mode: Whether to print debug information
            
        Returns:
            Tuple of (output_tensor, metadata_dict)
            
        Raises:
            ValueError: If input tensor is invalid
        """
        # Input validation
        if not isinstance(x, torch.Tensor) or x.numel() == 0:
            raise ValueError("Input must be a non-empty torch.Tensor")
        
        # Ensure 3D shape [batch, sequence, features]
        if x.dim() == 2:
            x = x.unsqueeze(0)
        
        batch_size, sequence_length, input_dim = x.shape
        
        # Handle dimension mismatch
        if input_dim != self.config.d_model:
            if input_dim < self.config.d_model:
                x = F.pad(x, (0, self.config.d_model - input_dim))
            else:
                x = x[..., :self.config.d_model]
        
        device = x.device
        metadata: Dict[str, Any] = {
            'cycles_completed': 0,
            'final_coherence': 0.0,
            'interventions_applied': [],
            'error_occurred': None,
            'input_shape': list(x.shape),
            'ritual_report': None
        }
        
        # Initialize state tensors
        y = torch.zeros_like(x)  # Action state
        z = torch.zeros_like(x)  # Thought state
        coherence_scores = []
        context_hash = self.compute_context_hash(x)
        
        # Initial state
        ambient_state = self.update_ambient_state(0.0, context_hash)
        
        # Coherence cycles
        for cycle in range(self.config.max_cycles):
            metadata['cycles_completed'] += 1
            
            try:
                # THINK phase
                think_input = torch.cat([x, y, z], dim=-1)
                
                # Dynamic network adaptation
                if think_input.shape[-1] != self.think_net[0].in_features:
                    self.think_net = self._build_network(
                        think_input.shape[-1], self.config.d_model
                    )
                    self.think_net.to(device)
                    metadata['networks_adapted'] = metadata.get('networks_adapted', 0) + 1
                
                z = self.think_net(think_input) + z  # Residual connection
                
                # Calculate tension and update state
                current_tension = z.std().item()
                ambient_state = self.update_ambient_state(current_tension, context_hash)
                
                # Apply interventions
                z = self.apply_interventions(z, ambient_state, context_hash, audit_mode)
                
                # ACT phase  
                act_input = torch.cat([y, z], dim=-1)
                
                if act_input.shape[-1] != self.act_net[0].in_features:
                    self.act_net = self._build_network(
                        act_input.shape[-1], self.config.d_model
                    )
                    self.act_net.to(device)
                    metadata['networks_adapted'] = metadata.get('networks_adapted', 0) + 1
                
                y = self.act_net(act_input) + y  # Residual connection
                
                # Calculate coherence
                if cycle > 0:
                    z_flat = z.reshape(-1, self.config.d_model)
                    y_flat = y.reshape(-1, self.config.d_model)
                    min_elements = min(z_flat.size(0), y_flat.size(0))
                    
                    if min_elements > 0:
                        cosine_similarity = F.cosine_similarity(
                            z_flat[:min_elements], 
                            y_flat[:min_elements], 
                            dim=-1
                        ).mean().item()
                        coherence_scores.append(cosine_similarity)
                        metadata['final_coherence'] = (
                            np.mean(coherence_scores[-3:]) 
                            if coherence_scores else 0.0
                        )
                        
                        # Early stopping on convergence
                        if cosine_similarity > self.config.coherence_threshold:
                            if audit_mode:
                                print(f"✅ Converged at cycle {cycle + 1}: {cosine_similarity:.3f}")
                            break
                
                # Learn from this interaction
                success_estimate = 0.7 if metadata['final_coherence'] > 0.5 else 0.3
                self.rituals.observe(context_hash, z, success_estimate)
                
                # Log cycle completion
                self.ledger.append({
                    'type': 'cycle_complete',
                    'cycle': cycle,
                    'tension': current_tension,
                    'coherence': metadata['final_coherence'],
                    'hash': context_hash,
                    'timestamp': time.time()
                })
                
            except Exception as e:
                if audit_mode:
                    print(f"❌ Cycle {cycle} error: {e}")
                metadata['error_occurred'] = str(e)
                if cycle == 0:
                    raise
                break
        
        # Final processing
        y = torch.nan_to_num(y)
        metadata['output_shape'] = list(y.shape)
        metadata['ritual_report'] = self.rituals.get_report()
        metadata['memory_entries'] = len(self.memory)
        metadata['ledger_entries'] = len(self.ledger)
        
        if audit_mode:
            report = metadata['ritual_report']
            print(f"🎯 Completed: Coherence {metadata['final_coherence']:.3f}, "
                  f"Stage {report['stage']}, Patterns {report['total_patterns']}")
        
        return y, metadata


# Test and integration
if __name__ == "__main__":
    # Quick test
    layer = TinyConfessionalLayer(LayerConfig(d_model=64, enable_ambient=True))
    x = torch.randn(1, 10, 64)
    
    print("🧪 Testing TinyConfessionalLayer...")
    out, meta = layer(x, context_str="I feel unsafe and need help", audit_mode=True)
    
    print(f"✅ Output shape: {out.shape}")
    print(f"📊 Metadata: {meta}")