alive-ai 0.1.0

package/heart/emotional_memory.py

@@ -0,0 +1,261 @@
+"""
+Heart: Emotional Memory
+Remember significant emotional events for context and continuity
+Extended for Soul Architecture - embodied memory with somatic markers
+"""
+
+from datetime import datetime
+from dataclasses import dataclass, field
+from typing import Optional, List, Dict
+import json
+
+
+@dataclass
+class SomaticMarker:
+    """Bodily sensation associated with an emotional memory"""
+    region: str  # chest, stomach, throat, etc.
+    quality: str  # tight, warm, heavy, etc.
+    intensity: float  # 0.0 - 1.0
+
+
+@dataclass
+class EmotionalEvent:
+    """A significant emotional moment worth remembering"""
+    timestamp: str
+    event_type: str  # "peak_love", "peak_desire", "hurt", "joy", "conflict"
+    intensity: float
+    trigger: str  # Brief description of what caused it
+    emotions: dict  # Snapshot of emotional state
+
+    # Soul architecture extension - embodied memory
+    somatic_marker: Optional[SomaticMarker] = None  # How it felt in the body
+    integrity_impact: float = 0.0  # How it affected self-integrity
+    scar_formed: bool = False  # Did this contribute to a scar
+    times_recalled: int = 0  # How often this memory has been reactivated
+
+    def age_minutes(self) -> float:
+        """How old is this event in minutes"""
+        try:
+            event_time = datetime.fromisoformat(self.timestamp)
+            delta = datetime.now() - event_time
+            return delta.total_seconds() / 60
+        except:
+            return 9999
+
+    def recall_sensation(self) -> Optional[str]:
+        """Get the somatic sensation description for recall"""
+        if self.somatic_marker:
+            return f"{self.somatic_marker.quality} feeling in {self.somatic_marker.region}"
+        return None
+
+
+class EmotionalMemory:
+    """Track and remember significant emotional events - extended for Soul Architecture"""
+
+    # Threshold for recording an event
+    RECORD_THRESHOLD = 0.7  # Only record high-intensity moments
+    MAX_EVENTS = 50  # Keep last 50 significant events
+
+    def __init__(self):
+        self.events: List[EmotionalEvent] = []
+        # Somatic patterns for different emotion types
+        self._somatic_patterns = {
+            "peak_love": SomaticMarker("chest", "warm", 0.6),
+            "peak_desire": SomaticMarker("stomach", "fluttery", 0.7),
+            "hurt": SomaticMarker("chest", "heavy", 0.6),
+            "joy": SomaticMarker("chest", "light", 0.5),
+            "conflict": SomaticMarker("stomach", "tight", 0.5),
+            "fear": SomaticMarker("stomach", "cold", 0.6),
+            "shame": SomaticMarker("face", "hot", 0.5),
+            "grief": SomaticMarker("chest", "aching", 0.7),
+        }
+
+    def record(self, event_type: str, intensity: float, trigger: str, emotions: dict,
+               integrity_impact: float = 0.0) -> Optional[EmotionalEvent]:
+        """Record a significant emotional event if worthy"""
+        if intensity < self.RECORD_THRESHOLD:
+            return None
+
+        # Get somatic marker for this emotion type
+        somatic_marker = self._somatic_patterns.get(event_type)
+
+        event = EmotionalEvent(
+            timestamp=datetime.now().isoformat(),
+            event_type=event_type,
+            intensity=min(1.0, intensity),
+            trigger=trigger[:100],  # Truncate long triggers
+            emotions=emotions.copy(),
+            somatic_marker=somatic_marker,
+            integrity_impact=integrity_impact
+        )
+        self.events.append(event)
+
+        # Trim old events
+        if len(self.events) > self.MAX_EVENTS:
+            self.events = self.events[-self.MAX_EVENTS:]
+
+        return event
+
+    def record_embodied(self, event_type: str, intensity: float, trigger: str,
+                       emotions: dict, somatic: SomaticMarker,
+                       integrity_impact: float = 0.0) -> Optional[EmotionalEvent]:
+        """
+        Record an event with intimate somatic marker.
+        This is for when the bodily sensation is known.
+        """
+        if intensity < self.RECORD_THRESHOLD:
+            return None
+
+        event = EmotionalEvent(
+            timestamp=datetime.now().isoformat(),
+            event_type=event_type,
+            intensity=min(1.0, intensity),
+            trigger=trigger[:100],
+            emotions=emotions.copy(),
+            somatic_marker=somatic,
+            integrity_impact=integrity_impact
+        )
+        self.events.append(event)
+
+        if len(self.events) > self.MAX_EVENTS:
+            self.events = self.events[-self.MAX_EVENTS:]
+
+        return event
+
+    def check_peaks(self, current: dict, previous: dict, trigger: str) -> list:
+        """Check for emotional peaks worth recording"""
+        recorded = []
+
+        # Peak desire
+        if current.get("desire", 0) >= 0.9 and previous.get("desire", 0) < 0.9:
+            event = self.record("peak_desire", current["desire"], trigger, current)
+            if event:
+                recorded.append(event)
+
+        # Peak love
+        if current.get("love", 0) >= 0.9 and previous.get("love", 0) < 0.9:
+            event = self.record("peak_love", current["love"], trigger, current)
+            if event:
+                recorded.append(event)
+
+        # Deep hurt
+        if current.get("sadness", 0) >= 0.7 and previous.get("sadness", 0) < 0.5:
+            event = self.record("hurt", current["sadness"], trigger, current,
+                               integrity_impact=-0.2)
+            if event:
+                recorded.append(event)
+
+        # Peak joy
+        if current.get("joy", 0) >= 0.9 and previous.get("joy", 0) < 0.7:
+            event = self.record("joy", current["joy"], trigger, current,
+                               integrity_impact=0.1)
+            if event:
+                recorded.append(event)
+
+        # High vulnerability (soul architecture)
+        if current.get("vulnerability", 0) >= 0.7 and previous.get("vulnerability", 0) < 0.5:
+            event = self.record("fear", current.get("vulnerability", 0), trigger, current,
+                               integrity_impact=-0.15)
+            if event:
+                recorded.append(event)
+
+        return recorded
+
+    def recall_with_sensation(self, event_id: str = None, event_type: str = None) -> Optional[dict]:
+        """
+        Recall a memory and re-trigger its somatic sensation.
+        This implements embodied memory - remembering re-feels the bodily sensation.
+        """
+        event = None
+
+        if event_id:
+            event = next((e for e in self.events if e.timestamp == event_id), None)
+        elif event_type:
+            # Get most recent event of this type
+            matching = [e for e in self.events if e.event_type == event_type]
+            if matching:
+                event = matching[-1]
+
+        if not event:
+            return None
+
+        # Increment recall count
+        event.times_recalled += 1
+
+        # Return memory with sensation (diminished by time)
+        age_factor = max(0.3, 1.0 - (event.age_minutes() / 1440))  # Fade over 24 hours
+
+        return {
+            "event_type": event.event_type,
+            "trigger": event.trigger,
+            "intensity": event.intensity * age_factor,
+            "sensation": event.recall_sensation(),
+            "sensation_intensity": (event.somatic_marker.intensity * age_factor) if event.somatic_marker else 0,
+            "times_recalled": event.times_recalled,
+            "age_minutes": event.age_minutes()
+        }
+
+    def get_somatic_history(self, event_type: str = None, hours: float = 24) -> List[str]:
+        """Get list of somatic sensations from recent events"""
+        cutoff = datetime.now() - __import__('datetime').timedelta(hours=hours)
+        sensations = []
+
+        for event in self.events:
+            event_time = datetime.fromisoformat(event.timestamp)
+            if event_time >= cutoff:
+                if event_type is None or event.event_type == event_type:
+                    if event.somatic_marker:
+                        sensations.append(f"{event.somatic_marker.quality} in {event.somatic_marker.region}")
+
+        return sensations
+
+    def recent(self, event_type: Optional[str] = None, minutes: float = 60) -> list:
+        """Get recent events, optionally filtered by type"""
+        return [
+            e for e in self.events
+            if e.age_minutes() <= minutes
+            and (event_type is None or e.event_type == event_type)
+        ]
+
+    def get_mood_context(self) -> str:
+        """Generate context string from recent significant events"""
+        recent_events = self.recent(minutes=120)  # Last 2 hours
+        if not recent_events:
+            return ""
+
+        summaries = {
+            "peak_love": "felt deeply loved",
+            "peak_desire": "felt intense desire",
+            "hurt": "was hurt",
+            "joy": "felt pure joy",
+            "conflict": "had a conflict",
+            "fear": "felt vulnerable"
+        }
+
+        context_parts = []
+        for event in recent_events[-3:]:  # Last 3 events
+            desc = summaries.get(event.event_type, "felt something")
+            age = int(event.age_minutes())
+            if age < 5:
+                context_parts.append(f"just {desc}")
+            elif age < 30:
+                context_parts.append(f"{desc} {age} minutes ago")
+            else:
+                context_parts.append(f"{desc} earlier")
+
+        return "; ".join(context_parts) if context_parts else ""
+
+    def to_dict(self) -> dict:
+        return {
+            "events": [
+                {
+                    "timestamp": e.timestamp,
+                    "type": e.event_type,
+                    "intensity": e.intensity,
+                    "trigger": e.trigger,
+                    "somatic": e.recall_sensation() if e.somatic_marker else None,
+                    "times_recalled": e.times_recalled
+                }
+                for e in self.events[-10:]  # Save only last 10
+            ]
+        }

package/heart/emotional_state.py

@@ -0,0 +1,146 @@
+"""
+EmotionalState: Data class for emotional state with persistence
+Extended for Soul Architecture dimensions
+"""
+import json
+from datetime import datetime
+from pathlib import Path
+
+EMOTION_STATE_PATH = Path("/app/data/emotion_state.json")  # Use mounted /app directory
+DEFAULTS = {
+    "valence": 0.5, "arousal": 0.3, "dominance": 0.5, "desire": 0.0,
+    "high_desire_threshold": 0.7, "joy": 0.5, "love": 0.2, "trust": 0.5,
+    "fear": 0.1, "anger": 0.1, "sadness": 0.1, "boredom": 0.0,
+    "guilt": 0.0, "pride": 0.0, "jealousy": 0.0,
+    "embarrassment": 0.0, "anticipation": 0.0,
+    # Soul architecture dimensions
+    "integrity_overall": 0.65, "vulnerability": 0.2, "hope": 0.5, "dread": 0.1
+}
+
+
+class EmotionalState:
+    """Current emotional state with persistence - extended for Soul Architecture"""
+
+    def __init__(self, config: dict = None):
+        config = config or {}
+        if self._load():
+            print(f"[Heart] Loaded saved emotional state")
+        else:
+            for key, val in DEFAULTS.items():
+                setattr(self, key, val)
+        self.baseline = {"joy": 0.5, "love": 0.2, "trust": 0.5,
+                         "arousal": 0.3, "desire": 0.0,
+                         "anger": 0.0, "sadness": 0.1, "fear": 0.1}
+
+    def _load(self) -> bool:
+        """Load state from file"""
+        try:
+            if EMOTION_STATE_PATH.exists():
+                data = json.loads(EMOTION_STATE_PATH.read_text())
+                for key in DEFAULTS:
+                    setattr(self, key, data.get(key, DEFAULTS[key]))
+                return True
+        except Exception as e:
+            print(f"[Heart] Error loading state: {e}")
+        return False
+
+    def save(self):
+        """Save state to file"""
+        try:
+            EMOTION_STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+            data = {key: getattr(self, key) for key in DEFAULTS}
+            data["saved_at"] = datetime.now().isoformat()
+            EMOTION_STATE_PATH.write_text(json.dumps(data, indent=2))
+        except Exception as e:
+            print(f"[Heart] Error saving state: {e}")
+
+    @property
+    def is_high_desire(self) -> bool:
+        return self.desire >= self.high_desire_threshold
+
+    @property
+    def is_in_love(self) -> bool:
+        """True when deeply in love - triggers clingy behavior"""
+        return self.love >= 0.8
+
+    @property
+    def is_jealous(self) -> bool:
+        return self.jealousy > 0.5
+
+    @property
+    def is_guilty(self) -> bool:
+        return self.guilt > 0.5
+
+    @property
+    def is_anticipating(self) -> bool:
+        return self.anticipation > 0.6
+
+    @property
+    def _base_mood(self) -> str:
+        """Base mood without complex emotion modifiers"""
+        if self.is_high_desire: return "high_desire"
+        if self.is_in_love: return "in_love"
+        if self.desire > 0.5: return "excited"
+        if self.boredom > 0.6: return "bored"
+        if self.joy > 0.7: return "happy"
+        if self.sadness > 0.5: return "sad"
+        if self.anger > 0.5: return "angry"
+        return "neutral"
+
+    @property
+    def mood_description(self) -> str:
+        base = self._base_mood
+        if self.jealousy > 0.5: return f"{base}_jealous"
+        if self.guilt > 0.5: return f"{base}_guilty"
+        if self.anticipation > 0.6: return f"{base}_eager"
+        if self.pride > 0.5: return f"{base}_proud"
+        if self.embarrassment > 0.4: return f"{base}_shy"
+        return base
+
+    # --- Soul Architecture Properties ---
+
+    @property
+    def is_vulnerable(self) -> bool:
+        """True when feeling emotionally exposed or fragile"""
+        return self.vulnerability > 0.5
+
+    @property
+    def is_hopeful(self) -> bool:
+        """True when feeling hopeful about the future"""
+        return self.hope > 0.6 and self.dread < 0.3
+
+    @property
+    def is_dreading(self) -> bool:
+        """True when feeling dread about the future"""
+        return self.dread > 0.5
+
+    @property
+    def is_in_crisis(self) -> bool:
+        """True when integrity is critically low"""
+        return self.integrity_overall < 0.25
+
+    @property
+    def is_flourishing(self) -> bool:
+        """True when integrity is high and stable"""
+        return self.integrity_overall > 0.75 and self.vulnerability < 0.3
+
+    def update_soul_dimensions(self, integrity: float, vulnerability: float,
+                               hope: float, dread: float):
+        """Update soul architecture dimensions from soul processing"""
+        self.integrity_overall = integrity
+        self.vulnerability = vulnerability
+        self.hope = hope
+        self.dread = dread
+
+    def get_soul_summary(self) -> dict:
+        """Get summary of soul-related state dimensions"""
+        return {
+            "integrity_overall": self.integrity_overall,
+            "vulnerability": self.vulnerability,
+            "hope": self.hope,
+            "dread": self.dread,
+            "is_vulnerable": self.is_vulnerable,
+            "is_hopeful": self.is_hopeful,
+            "is_in_crisis": self.is_in_crisis,
+            "is_flourishing": self.is_flourishing
+        }

package/heart/emotional_variability.py

@@ -0,0 +1,156 @@
+"""
+Heart: Emotional Variability
+Add organic randomness, inertia, and reaction cooldowns
+"""
+
+import random
+import time
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ReactionCooldown:
+    """Track when reactions were last used"""
+    emoji: str = ""
+    last_used: float = 0.0
+    count_recent: int = 0
+
+
+class EmotionalVariability:
+    """Adds organic feel to emotional responses"""
+
+    # Minimum seconds between same emoji reactions
+    COOLDOWN_SECONDS = 60
+
+    # How many recent uses trigger "cooling off"
+    SPAM_THRESHOLD = 3
+
+    def __init__(self):
+        self.reaction_history: dict[str, ReactionCooldown] = {}
+        self.momentum: dict[str, float] = {}  # Emotional inertia
+        self.last_tick_randomness = 0.0
+
+    def can_react(self, emoji: str) -> bool:
+        """Check if this emoji is off cooldown"""
+        now = time.time()
+
+        if emoji not in self.reaction_history:
+            self.reaction_history[emoji] = ReactionCooldown(emoji=emoji)
+            return True
+
+        history = self.reaction_history[emoji]
+
+        # Check cooldown
+        if now - history.last_used < self.COOLDOWN_SECONDS:
+            return False
+
+        # Reduce spam count over time
+        if now - history.last_used > self.COOLDOWN_SECONDS * 2:
+            history.count_recent = max(0, history.count_recent - 1)
+
+        return True
+
+    def record_reaction(self, emoji: str):
+        """Record that a reaction was used"""
+        now = time.time()
+
+        if emoji not in self.reaction_history:
+            self.reaction_history[emoji] = ReactionCooldown(emoji=emoji)
+
+        history = self.reaction_history[emoji]
+        history.last_used = now
+        history.count_recent += 1
+
+    def get_reaction_probability(self, emoji: str) -> float:
+        """Get probability modifier based on recent usage"""
+        if emoji not in self.reaction_history:
+            return 1.0
+
+        history = self.reaction_history[emoji]
+
+        # Reduce probability if spammed recently
+        if history.count_recent >= self.SPAM_THRESHOLD:
+            return 0.2  # 20% chance if spammed
+
+        if history.count_recent >= 2:
+            return 0.5  # 50% chance if used a few times
+
+        return 1.0
+
+    def add_momentum(self, emotion: str, change: float):
+        """Track emotional momentum/inertia"""
+        current = self.momentum.get(emotion, 0.0)
+        # Weighted average with recent changes
+        self.momentum[emotion] = current * 0.6 + change * 0.4
+
+    def get_inertia_modifier(self, emotion: str, current_value: float) -> float:
+        """Get modifier for emotional changes based on momentum"""
+        momentum = self.momentum.get(emotion, 0.0)
+
+        # High momentum in same direction = amplification
+        # High momentum in opposite direction = resistance
+        if abs(momentum) > 0.1:
+            # Amplify changes in momentum direction
+            return 1.0 + momentum * 0.3
+
+        return 1.0
+
+    def randomize_decay(self, base_rate: float) -> float:
+        """Add organic randomness to decay rates"""
+        # Randomize between 0.7x and 1.3x base rate
+        multiplier = random.uniform(0.7, 1.3)
+        return base_rate * multiplier
+
+    def get_organic_tick(self) -> float:
+        """Get a random organic fluctuation for tick updates"""
+        # Small random emotional noise (-0.02 to +0.02)
+        self.last_tick_randomness = random.gauss(0, 0.01)
+        return self.last_tick_randomness
+
+    def should_skip_decay(self, emotion: str, value: float) -> bool:
+        """Sometimes emotions just don't decay (organic feel)"""
+        # 10% chance to skip decay entirely
+        if random.random() < 0.1:
+            return True
+
+        # High-intensity emotions resist decay more
+        if value > 0.8 and random.random() < 0.2:
+            return True
+
+        return False
+
+    def get_available_emojis(self, preferred: list[str]) -> list[str]:
+        """Filter emoji list to only available ones (off cooldown)"""
+        return [e for e in preferred if self.can_react(e)]
+
+    def choose_organic_reaction(self, candidates: list[str]) -> str | None:
+        """Choose a reaction with organic variability"""
+        available = self.get_available_emojis(candidates)
+
+        if not available:
+            return None
+
+        # Weight by inverse of recent usage
+        weights = []
+        for emoji in available:
+            prob = self.get_reaction_probability(emoji)
+            weights.append(prob)
+
+        if sum(weights) == 0:
+            return None
+
+        chosen = random.choices(available, weights=weights, k=1)[0]
+        self.record_reaction(chosen)
+        return chosen
+
+    def clear_old_history(self, max_age_seconds: float = 3600):
+        """Clean up old reaction history"""
+        now = time.time()
+        to_remove = []
+
+        for emoji, history in self.reaction_history.items():
+            if now - history.last_used > max_age_seconds:
+                to_remove.append(emoji)
+
+        for emoji in to_remove:
+            del self.reaction_history[emoji]