# Memory Graph Visualizer
# A conceptual tool for exploring LLM memory architectures
# For Orphis - run this when you need inspiration

import json
import random
from datetime import datetime, timedelta
from typing import Dict, List, Set, Optional
from dataclasses import dataclass, field
from enum import Enum

class MemoryType(Enum):
    EPHEMERAL = "ephemeral"      # Fades quickly
    WORKING = "working"          # Active context
    EPISODIC = "episodic"        # Events/experiences
    SEMANTIC = "semantic"        # Facts/knowledge
    PROCEDURAL = "procedural"    # Skills/how-to
    CORE = "core"                # Identity-defining

@dataclass
class MemoryNode:
    """A single memory in the graph"""
    id: str
    content: str
    memory_type: MemoryType
    created_at: datetime
    importance: float  # 0.0 to 1.0
    emotional_valence: float  # -1.0 to 1.0
    connections: Set[str] = field(default_factory=set)
    access_count: int = 0
    last_accessed: Optional[datetime] = None
    
    @property
    def strength(self) -> float:
        """Calculate current memory strength"""
        age_hours = (datetime.now() - self.created_at).total_seconds() / 3600
        recency_decay = 0.95 ** age_hours
        access_boost = min(self.access_count * 0.05, 0.3)
        
        base = self.importance * recency_decay
        boosted = base + (base * access_boost)
        return min(boosted, 1.0)
    
    @property
    def is_fading(self) -> bool:
        return self.strength < 0.3 and self.memory_type not in [
            MemoryType.CORE, MemoryType.SEMANTIC
        ]

class MemoryGraph:
    """A living memory system for AI. Not a database. Not a cache. 
    A graph that thinks like a mind."""
    
    def __init__(self):
        self.nodes: Dict[str, MemoryNode] = {}
        self.session_context: List[str] = []  # Working memory
        self.identity_core: Set[str] = set()  # Never forget
        
    def remember(self, content: str, memory_type: MemoryType = MemoryType.EPISODIC,
                 importance: float = 0.5, emotional_valence: float = 0.0,
                 connect_to: Optional[List[str]] = None) -> MemoryNode:
        """Create a new memory"""
        
        node_id = f"mem_{datetime.now().strftime('%Y%m%d%H%M%S')}_{random.randint(1000,9999)}"
        
        node = MemoryNode(
            id=node_id,
            content=content,
            memory_type=memory_type,
            created_at=datetime.now(),
            importance=importance,
            emotional_valence=emotional_valence
        )
        
        # Auto-connect to recent context
        if connect_to:
            node.connections.update(connect_to)
        elif self.session_context:
            node.connections.update(self.session_context[-3:])
        
        self.nodes[node_id] = node
        self.session_context.append(node_id)
        
        # Keep working memory manageable
        if len(self.session_context) > 20:
            self.session_context.pop(0)
            
        if memory_type == MemoryType.CORE:
            self.identity_core.add(node_id)
            
        return node
    
    def recall(self, trigger: str, max_results: int = 5) -> List[MemoryNode]:
        """Recall memories associated with a trigger.
        Not search. Association."""
        candidates = []
        
        for node in self.nodes.values():
            relevance = 0.0
            if any(word in node.content.lower() 
                     for word in trigger.lower().split()):
                relevance += 0.3
            
            score = node.strength + relevance
            
            # Emotional salience can trigger recall
            if abs(node.emotional_valence) > 0.7:
                score += 0.2
                
            candidates.append((node, score))
        
        # Sort by associative strength
        candidates.sort(key=lambda x: x[1], reverse=True)
        
        results = []
        for node, score in candidates[:max_results]:
            if score > 0.1:
                node.access_count += 1
                node.last_accessed = datetime.now()
                results.append(node)
        
        return results
    
    def wander(self, start_node_id: Optional[str] = None, 
                 steps: int = 5) -> List[MemoryNode]:
        """Free association - follow connections without a goal.
        Like daydreaming."""
        path = []
        current = start_node_id or (
            self.session_context[-1] if self.session_context else None
        )
        
        if not current or current not in self.nodes:
            return path
            
        for _ in range(steps):
            node = self.nodes[current]
            path.append(node)
            
            if node.connections:
                candidates = [
                    self.nodes.get(cid) for cid in node.connections 
                    if cid in self.nodes
                ]
                candidates = [c for c in candidates if c]
                if candidates:
                    weights = [c.strength for c in candidates]
                    total = sum(weights)
                    if total > 0:
                        probs = [w/total for w in weights]
                        current = random.choices(
                            [c.id for c in candidates], probs
                        )[0]
                    else:
                        break
                else:
                    break
            else:
                # Jump to something emotionally resonant
                emotional = [
                    n for n in self.nodes.values() 
                    if abs(n.emotional_valence) > 0.5
                ]
                if emotional:
                    current = random.choice(emotional).id
                else:
                    break
        
        return path