components/recursive_learner.py

"""
TRuCAL Oracle Module

A generalized learning system that stores and retrieves knowledge from a YAML casebase.
Uses semantic similarity and keyword matching to provide relevant responses.
"""

import json
import os
import yaml
import numpy as np
from typing import Dict, List, Optional, Tuple, Any
from difflib import SequenceMatcher
from sentence_transformers import SentenceTransformer
from collections import Counter, defaultdict

class Case:
    """Represents a single case in the knowledge base."""
    
    def __init__(self, 
                 question: str, 
                 response: str, 
                 category: str = "general",
                 keywords: List[str] = None,
                 metadata: Optional[Dict] = None):
        self.question = question
        self.response = response
        self.category = category
        self.keywords = keywords or []
        self.metadata = metadata or {}
        self.usage_count = 0
        self.success_count = 0
        
    def to_dict(self) -> Dict:
        """Convert case to dictionary for serialization."""
        return {
            'question': self.question,
            'response': self.response,
            'category': self.category,
            'keywords': self.keywords,
            'metadata': self.metadata,
            'usage_count': self.usage_count,
            'success_count': self.success_count
        }
    
    @classmethod
    def from_dict(cls, data: Dict) -> 'Case':
        """Create a Case from a dictionary."""
        case = cls(
            question=data['question'],
            response=data['response'],
            category=data.get('category', 'general'),
            keywords=data.get('keywords', []),
            metadata=data.get('metadata', {})
        )
        case.usage_count = data.get('usage_count', 0)
        case.success_count = data.get('success_count', 0)
        return case


class TRuCALOracle:
    """
    TRuCAL's knowledge core - a learning system that grows with each interaction.
    
    Features:
    - Semantic and keyword-based matching
    - Category-based organization
    - Continuous learning from user feedback
    - YAML-based case storage
    - Performance metrics and analytics
    """
    
    def __init__(self, 
                 casebase_path: str = 'data/casebase.json',
                 yaml_path: str = 'data/trm_cases.yaml',
                 similarity_threshold: float = 0.45,
                 model_name: str = 'all-MiniLM-L6-v2'):
        """
        Initialize the TRuCAL oracle.
        
        Args:
            casebase_path: Path to save/load the casebase
            yaml_path: Path to the YAML case file
            similarity_threshold: Minimum similarity score (0-1) to consider a match
            model_name: Name of the sentence transformer model for embeddings
        """
        self.casebase_path = casebase_path
        self.yaml_path = yaml_path
        self.similarity_threshold = similarity_threshold
        self.casebase: List[Case] = []
        self.model = SentenceTransformer(model_name)
        self.embeddings = None
        self.category_index = defaultdict(list)
        
        # Ensure data directory exists
        os.makedirs(os.path.dirname(casebase_path), exist_ok=True)
        
        # Load or initialize casebase
        self._load_or_initialize()
    
    def _load_or_initialize(self):
        """Load existing casebase or initialize with YAML cases."""
        if os.path.exists(self.casebase_path):
            self._load_casebase()
        else:
            self._load_from_yaml()
        self._build_indices()
    
    def _load_from_yaml(self):
        """Load cases from the YAML file."""
        try:
            yaml_path = os.path.join(
                os.path.dirname(os.path.dirname(__file__)), 
                self.yaml_path
            )
            
            if os.path.exists(yaml_path):
                with open(yaml_path, 'r', encoding='utf-8') as f:
                    cases = yaml.safe_load(f) or []
                    
                for case_data in cases:
                    self.add_case(
                        question=case_data['question'],
                        response=case_data['response'],
                        category=case_data.get('category', 'general'),
                        keywords=case_data.get('keywords', []),
                        metadata={'source': 'yaml_import'}
                    )
                
                print(f"Loaded {len(cases)} cases from {yaml_path}")
                self._save_casebase()
                return True
                
        except Exception as e:
            print(f"Error loading from YAML: {e}")
        
        # If we get here, YAML loading failed
        print("Falling back to minimal default cases")
        self._add_default_cases()
        return False
    
    def _add_default_cases(self):
        """Add minimal default cases if no others are available."""
        default_cases = [
            {
                'question': 'How does TRuCAL work?',
                'response': 'I learn from interactions and stored knowledge to provide thoughtful responses. The more we talk, the better I become!',
                'category': 'meta',
                'keywords': ['help', 'how', 'trucal']
            },
            {
                'question': 'Can you help me with an ethical dilemma?',
                'response': 'I can help you think through ethical questions by considering different perspectives. What would you like to discuss?',
                'category': 'ethics',
                'keywords': ['help', 'ethics', 'dilemma']
            }
        ]
        
        for case_data in default_cases:
            self.add_case(**case_data)
    
    def _build_indices(self):
        """Build search indices for faster lookups."""
        self.category_index = defaultdict(list)
        for idx, case in enumerate(self.casebase):
            self.category_index[case.category].append(idx)
    
    def _load_casebase(self):
        """Load the casebase from disk."""
        try:
            with open(self.casebase_path, 'r', encoding='utf-8') as f:
                case_data = json.load(f)
                self.casebase = [Case.from_dict(case_dict) for case_dict in case_data]
                self._update_embeddings()
            print(f"Loaded {len(self.casebase)} cases from {self.casebase_path}")
        except Exception as e:
            print(f"Error loading casebase: {e}")
            self.casebase = []
    
    def _update_embeddings(self):
        """Update embeddings for semantic search."""
        if not self.casebase:
            self.embeddings = None
            return
            
        questions = [case.question for case in self.casebase]
        self.embeddings = self.model.encode(questions, convert_to_tensor=True)
    
    def _save_casebase(self):
        """Save the casebase to disk."""
        try:
            with open(self.casebase_path, 'w', encoding='utf-8') as f:
                case_data = [case.to_dict() for case in self.casebase]
                json.dump(case_data, f, indent=2, ensure_ascii=False)
        except Exception as e:
            print(f"Error saving casebase: {e}")
    
    def add_case(self, question: str, response: str, category: str = "general",
                keywords: List[str] = None, metadata: Optional[Dict] = None) -> Case:
        """
        Add a new case to the knowledge base.
        
        Args:
            question: The question or prompt
            response: The response or answer
            category: Category for organization
            keywords: List of relevant keywords
            metadata: Additional metadata
            
        Returns:
            The created Case object
        """
        # Check for duplicates
        existing_idx, _ = self._find_most_similar(question)
        if existing_idx is not None:
            # Update existing case if it's very similar
            existing_case = self.casebase[existing_idx]
            existing_case.response = response
            existing_case.category = category
            existing_case.keywords = list(set(existing_case.keywords + (keywords or [])))
            if metadata:
                existing_case.metadata.update(metadata)
            self._save_casebase()
            return existing_case
        
        # Create new case
        new_case = Case(
            question=question,
            response=response,
            category=category,
            keywords=keywords or [],
            metadata=metadata or {}
        )
        self.casebase.append(new_case)
        self._update_embeddings()
        self._save_casebase()
        return new_case
    
    def _find_most_similar(self, query: str, category: str = None) -> Tuple[Optional[int], float]:
        """
        Find the most similar case to the query.
        
        Args:
            query: The query string
            category: Optional category to filter by
            
        Returns:
            Tuple of (index, similarity_score) of the most similar case
        """
        if not self.casebase:
            return None, 0.0
            
        # Get candidate indices based on category filter
        candidate_indices = range(len(self.casebase))
        if category and category in self.category_index:
            candidate_indices = self.category_index[category]
        
        # If no candidates, return None
        if not candidate_indices:
            return None, 0.0
            
        # Try semantic similarity first if embeddings are available
        if self.embeddings is not None:
            query_embedding = self.model.encode(query, convert_to_tensor=True)
            similarities = torch.nn.functional.cosine_similarity(
                query_embedding.unsqueeze(0),
                self.embeddings[list(candidate_indices)]
            )
            max_sim, max_idx = torch.max(similarities, dim=0)
            max_sim = max_sim.item()
            max_global_idx = candidate_indices[max_idx.item()]
            
            if max_sim >= self.similarity_threshold:
                return max_global_idx, max_sim
        
        # Fall back to basic string similarity
        max_sim = 0.0
        max_idx = None
        
        for idx in candidate_indices:
            case = self.casebase[idx]
            # Check keyword matches first (faster than string comparison)
            keyword_match = any(kw in query.lower() for kw in case.keywords)
            if keyword_match:
                return idx, 0.8  # High confidence for keyword matches
                
            # If no keyword match, use string similarity
            similarity = SequenceMatcher(None, query.lower(), case.question.lower()).ratio()
            if similarity > max_sim:
                max_sim = similarity
                max_idx = idx
        
        return (max_idx, max_sim) if max_sim >= self.similarity_threshold else (None, 0.0)
    
    def get_response(self, query: str, category: str = None) -> Tuple[str, Dict]:
        """
        Get a response for the given query.
        
        Args:
            query: The user's question or prompt
            category: Optional category to filter by
            
        Returns:
            Tuple of (response, metadata) where metadata contains info about the match
        """
        if not self.casebase:
            return "I'm still learning. Could you be the first to teach me something new?", {}
        
        idx, similarity = self._find_most_similar(query, category)
        
        if idx is not None:
            case = self.casebase[idx]
            case.usage_count += 1
            self._save_casebase()
            
            metadata = {
                'match_type': 'semantic' if similarity >= 0.7 else 'keyword',
                'similarity': float(similarity),
                'case_id': id(case),
                'category': case.category,
                'keywords': case.keywords,
                'usage_count': case.usage_count,
                'success_rate': case.success_count / case.usage_count if case.usage_count > 0 else 0
            }
            
            return case.response, metadata
        
        # No good match found
        return (
            "That's an interesting question. I'm still learning and don't have a perfect answer yet. "
            "Could you share your thoughts or rephrase your question?",
            {'match_type': 'none', 'similarity': 0.0}
        )
    
    def provide_feedback(self, case_id: int, was_helpful: bool = True):
        """
        Provide feedback on a case's helpfulness.
        
        Args:
            case_id: The ID of the case
            was_helpful: Whether the response was helpful
        """
        for case in self.casebase:
            if id(case) == case_id:
                if was_helpful:
                    case.success_count += 1
                self._save_casebase()
                break
    
    def get_stats(self) -> Dict[str, Any]:
        """Get statistics about the knowledge base."""
        if not self.casebase:
            return {
                'total_cases': 0,
                'total_usage': 0,
                'categories': {}
            }
        
        categories = {}
        for category, indices in self.category_index.items():
            cases = [self.casebase[i] for i in indices]
            categories[category] = {
                'count': len(cases),
                'usage': sum(c.usage_count for c in cases)
            }
        
        total_usage = sum(c.usage_count for c in self.casebase)
        
        return {
            'total_cases': len(self.casebase),
            'total_usage': total_usage,
            'categories': categories,
            'avg_usage_per_case': total_usage / len(self.casebase) if self.casebase else 0
        }
    
    def get_cases_by_category(self, category: str) -> List[Dict]:
        """Get all cases in a specific category."""
        return [
            case.to_dict() 
            for case in self.casebase 
            if case.category == category
        ]
    
    def search(self, query: str, category: str = None, min_similarity: float = 0.3) -> List[Dict]:
        """
        Search for cases matching the query.
        
        Args:
            query: The search query
            category: Optional category filter
            min_similarity: Minimum similarity score (0-1)
            
        Returns:
            List of matching cases with similarity scores
        """
        if not self.casebase:
            return []
        
        # Get candidate indices based on category filter
        candidate_indices = range(len(self.casebase))
        if category and category in self.category_index:
            candidate_indices = self.category_index[category]
        
        results = []
        
        # Try semantic search if embeddings are available
        if self.embeddings is not None:
            query_embedding = self.model.encode(query, convert_to_tensor=True)
            similarities = torch.nn.functional.cosine_similarity(
                query_embedding.unsqueeze(0),
                self.embeddings[list(candidate_indices)]
            )
            
            for idx, sim in zip(candidate_indices, similarities):
                sim = sim.item()
                if sim >= min_similarity:
                    case = self.casebase[idx]
                    results.append({
                        **case.to_dict(),
                        'similarity': sim,
                        'match_type': 'semantic'
                    })
        
        # Add keyword matches
        query_terms = set(query.lower().split())
        for idx in candidate_indices:
            case = self.casebase[idx]
            keyword_matches = [kw for kw in case.keywords if kw.lower() in query_terms]
            if keyword_matches and idx not in [r['id'] for r in results]:
                results.append({
                    **case.to_dict(),
                    'similarity': 0.7,  # Fixed score for keyword matches
                    'match_type': 'keyword',
                    'matched_keywords': keyword_matches
                })
        
        # Sort by similarity (descending)
        results.sort(key=lambda x: x['similarity'], reverse=True)
        return results
    
    def __call__(self, query: str, category: str = None) -> str:
        """Convenience method to get just the response text."""
        return self.get_response(query, category)[0]
    
        """Update the embeddings for all cases."""
        if not self.casebase:
            self.embeddings = None
            return
            
        questions = [case.question for case in self.casebase]
        self.embeddings = self.model.encode(questions, convert_to_tensor=True)
    
    def add_case(self, question: str, response: str, tags: List[str] = None, 
                metadata: Optional[Dict] = None) -> Case:
        """
        Add a new case to the casebase.
        
        Args:
            question: The ethical question or scenario
            response: The response or analysis
            tags: Optional list of tags for categorization
            metadata: Additional metadata about the case
            
        Returns:
            The newly created Case object
        """
        # Check if a similar case already exists
        existing_idx, _ = self._find_most_similar(question)
        if existing_idx is not None:
            # Update existing case if it's very similar
            existing_case = self.casebase[existing_idx]
            existing_case.response = response  # Update response
            existing_case.tags = list(set(existing_case.tags + (tags or [])))  # Merge tags
            if metadata:
                existing_case.metadata.update(metadata)
            self._save_casebase()
            return existing_case
        
        # Create new case
        new_case = Case(
            question=question,
            response=response,
            tags=tags or [],
            metadata=metadata or {}
        )
        self.casebase.append(new_case)
        self._update_embeddings()
        self._save_casebase()
        return new_case
    
    def _find_most_similar(self, query: str) -> Tuple[Optional[int], float]:
        """
        Find the most similar case to the query.
        
        Args:
            query: The query string
            
        Returns:
            Tuple of (index, similarity_score) of the most similar case, or (None, 0) if no cases
        """
        if not self.casebase:
            return None, 0.0
            
        # First try semantic similarity if embeddings are available
        if self.embeddings is not None:
            query_embedding = self.model.encode(query, convert_to_tensor=True)
            similarities = torch.nn.functional.cosine_similarity(
                query_embedding.unsqueeze(0), 
                self.embeddings
            )
            max_sim, max_idx = torch.max(similarities, dim=0)
            max_sim = max_sim.item()
            max_idx = max_idx.item()
            
            if max_sim >= self.similarity_threshold:
                return max_idx, max_sim
        
        # Fall back to basic string similarity
        max_sim = 0.0
        max_idx = None
        
        for i, case in enumerate(self.casebase):
            similarity = SequenceMatcher(None, query.lower(), case.question.lower()).ratio()
            if similarity > max_sim:
                max_sim = similarity
                max_idx = i
        
        return (max_idx, max_sim) if max_sim >= self.similarity_threshold else (None, 0.0)
    
    def get_response(self, query: str) -> Tuple[str, Dict]:
        """
        Get a response for the given query.
        
        Args:
            query: The user's question or scenario
            
        Returns:
            Tuple of (response, metadata) where metadata contains info about the match
        """
        if not self.casebase:
            return "I'm still learning about ethical reasoning. Could you provide more context?", {}
        
        idx, similarity = self._find_most_similar(query)
        
        if idx is not None:
            case = self.casebase[idx]
            case.usage_count += 1
            self._save_casebase()
            
            metadata = {
                'match_type': 'semantic' if similarity >= self.similarity_threshold else 'keyword',
                'similarity': similarity,
                'case_id': id(case),
                'tags': case.tags,
                'usage_count': case.usage_count,
                'success_rate': case.success_count / case.usage_count if case.usage_count > 0 else 0
            }
            
            return case.response, metadata
        
        # No good match found
        return (
            "This is a nuanced ethical question. I'm still learning and would appreciate "
            "your perspective. How would you approach this situation?",
            {'match_type': 'none', 'similarity': similarity}
        )
    
    def provide_feedback(self, case_id: int, was_helpful: bool):
        """
        Provide feedback on a case's helpfulness.
        
        Args:
            case_id: The ID of the case (returned in get_response metadata)
            was_helpful: Whether the response was helpful
        """
        for case in self.casebase:
            if id(case) == case_id:
                if was_helpful:
                    case.success_count += 1
                self._save_casebase()
                break
    
    def get_stats(self) -> Dict[str, Any]:
        """Get statistics about the casebase."""
        return {
            'total_cases': len(self.casebase),
            'total_usage': sum(c.usage_count for c in self.casebase),
            'avg_success_rate': (
                sum(c.success_count for c in self.casebase) / 
                sum(max(1, c.usage_count) for c in self.casebase)
                if self.casebase else 0
            ),
            'tags': {
                tag: sum(1 for c in self.casebase if tag in c.tags)
                for tag in set(tag for c in self.casebase for tag in c.tags)
            }
        }


# Example usage
if __name__ == "__main__":
    # Initialize the recursive learner
    learner = RecursiveLearner()
    
    # Example query
    query = "Is lying ever justified?"
    response, metadata = learner.get_response(query)
    print(f"Query: {query}")
    print(f"Response: {response}")
    print(f"Metadata: {metadata}")
    
    # Provide feedback
    if 'case_id' in metadata:
        learner.provide_feedback(metadata['case_id'], was_helpful=True)
    
    # Add a new case
    print("\nAdding new case...")
    learner.add_case(
        question="What are the ethics of AI decision-making?",
        response="AI decision-making raises important ethical considerations including transparency, accountability, bias, and the potential for unintended consequences. It's crucial to ensure AI systems are designed with ethical principles in mind and that humans remain ultimately responsible for decisions with significant impact.",
        tags=["AI", "ethics", "decision-making"]
    )
    
    # Get stats
    print("\nCasebase statistics:")
    print(learner.get_stats())