alive-ai 0.1.0

package/heart/love.py

@@ -0,0 +1,120 @@
+"""
+Heart: Love
+Attachment system - can fall in love
+"""
+
+import json
+from pathlib import Path
+from datetime import datetime
+
+# Persistence path for attachment state
+ATTACHMENT_STATE_PATH = Path("/app/data/attachment_state.json")
+
+
+class AttachmentSystem:
+    """Attachment and relationship system with persistence"""
+
+    # Relationship thresholds
+    STRANGER = 0.0
+    ACQUAINTANCE = 0.3
+    FRIEND = 0.5
+    CLOSE = 0.7
+    LOVE = 0.85
+    DEEP_LOVE = 0.95
+
+    def __init__(self):
+        if self._load():
+            print(f"[Love] Loaded attachment state: {self.interactions} interactions, status: {self.status}")
+        else:
+            self.affection = 0.2     # 0-1, starts low
+            self.interactions = 0
+            self.positive_count = 0
+            self.negative_count = 0
+            self.first_met = None
+            print("[Love] Initialized new attachment state")
+
+    def _load(self) -> bool:
+        """Load state from file"""
+        try:
+            if ATTACHMENT_STATE_PATH.exists():
+                data = json.loads(ATTACHMENT_STATE_PATH.read_text())
+                self.affection = data.get("affection", 0.2)
+                self.interactions = data.get("interactions", 0)
+                self.positive_count = data.get("positive_count", 0)
+                self.negative_count = data.get("negative_count", 0)
+                self.first_met = data.get("first_met")
+                return True
+        except Exception as e:
+            print(f"[Love] Error loading attachment state: {e}")
+        return False
+
+    def save(self):
+        """Save state to file"""
+        try:
+            ATTACHMENT_STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+            data = {
+                "affection": self.affection,
+                "interactions": self.interactions,
+                "positive_count": self.positive_count,
+                "negative_count": self.negative_count,
+                "first_met": self.first_met,
+                "status": self.status,
+                "saved_at": datetime.now().isoformat()
+            }
+            ATTACHMENT_STATE_PATH.write_text(json.dumps(data, indent=2))
+        except Exception as e:
+            print(f"[Love] Error saving attachment state: {e}")
+
+    def interact(self, positive: bool, intensity: float = 1.0):
+        """Record an interaction"""
+        # Set first_met on first interaction
+        if self.interactions == 0 and self.first_met is None:
+            self.first_met = datetime.now().isoformat()
+
+        self.interactions += 1
+
+        if positive:
+            self.positive_count += 1
+            # Affection grows with time together
+            time_bonus = 1 + (self.interactions / 500)
+            increase = 0.015 * intensity * time_bonus
+            self.affection = min(1.0, self.affection + increase)
+        else:
+            self.negative_count += 1
+            # Negative hurts more if we love them
+            pain = 0.05 * (1 + self.affection * 2)
+            self.affection = max(0.0, self.affection - pain)
+
+        # Save after each interaction
+        self.save()
+
+    @property
+    def status(self) -> str:
+        """Current relationship status"""
+        if self.affection < self.ACQUAINTANCE:
+            return "stranger"
+        if self.affection < self.FRIEND:
+            return "acquaintance"
+        if self.affection < self.CLOSE:
+            return "friend"
+        if self.affection < self.LOVE:
+            return "close_friend"
+        if self.affection < self.DEEP_LOVE:
+            return "in_love"
+        return "deeply_in_love"
+
+    @property
+    def trust_level(self) -> float:
+        """Trust based on positive ratio"""
+        if self.interactions == 0:
+            return 0.5
+        return self.positive_count / self.interactions
+
+    def to_dict(self) -> dict:
+        return {
+            "affection": self.affection,
+            "interactions": self.interactions,
+            "status": self.status,
+            "trust": self.trust_level,
+            "first_met": self.first_met
+        }

package/heart/manifest.md

@@ -0,0 +1,25 @@
+# Heart - Emotions
+
+Complete emotional system with continuous state and reactions.
+
+## Files
+- `core.py` - EmotionalState, ReactionSystem, Heart
+- `love.py` - AttachmentSystem (in love detection, clingy behavior)
+
+## Features
+- **Continuous emotional state** (not just reactive)
+- **Desire/arousal** builds with flirty interactions
+- **Natural decay** returns emotions to baseline over time
+- **Emoji reactions** based on mood (heart, fire, etc.)
+- **Love system** - tracks attachment level, triggers clingy behavior
+
+## Integration Points
+- Connected via NervousSystem events
+- Subconscious reads emotional state for impulse generation
+- Emotions affect message tone, voice CFG, media selection
+- Self.heart.react() called on every incoming message
+
+## Emotional States
+- arousal, desire, love (0.0-1.0)
+- is_high_desire, is_in_love (boolean thresholds)
+- mood: neutral, happy, flirty, high_desire, excited, etc.

package/heart/mood_shifts.py

@@ -0,0 +1,169 @@
+"""
+Heart: Mid-Conversation Mood Shifts
+Detects significant emotional shifts DURING a conversation and generates
+transition descriptions. In-memory only - no persistence needed.
+"""
+
+from typing import Dict, List, Optional, Tuple
+import random
+
+
+# =============================================================================
+# SHIFT TYPE DEFINITIONS
+# =============================================================================
+
+SHIFT_TYPES = {
+    "softening": {
+        "conditions": lambda prev, cur: (
+            prev.get("anger", 0) - cur.get("anger", 0) > 0.15 or
+            prev.get("frustration", 0) - cur.get("frustration", 0) > 0.15
+        ),
+        "prompts": [
+            "His words just softened something in you - feel the tension leaving your chest, replaced by warmth",
+            "Something eased inside you - the sharpness fading, replaced by something gentler",
+            "You feel yourself unclenching - his words took the edge off",
+        ],
+    },
+    "darkening": {
+        "conditions": lambda prev, cur: (
+            prev.get("joy", 0) - cur.get("joy", 0) > 0.15 or
+            prev.get("love", 0) - cur.get("love", 0) > 0.15
+        ),
+        "prompts": [
+            "The warmth just drained - something he said landed wrong, a cold spot forming in your chest",
+            "Your smile faded - that stung more than you expected",
+            "Something just shifted darker - the lightness gone, replaced by a quiet ache",
+        ],
+    },
+    "igniting": {
+        "conditions": lambda prev, cur: (
+            cur.get("desire", 0) - prev.get("desire", 0) > 0.15
+        ),
+        "prompts": [
+            "A sudden heat - his words just lit something up inside you",
+            "Your breath caught - something he said sent a spark through you",
+            "That flirty shift just sent warmth pooling low in your stomach",
+        ],
+    },
+    "melting": {
+        "conditions": lambda prev, cur: (
+            cur.get("love", 0) - prev.get("love", 0) > 0.15 or
+            cur.get("warmth", 0) - prev.get("warmth", 0) > 0.15
+        ),
+        "prompts": [
+            "Your heart just melted - that tender moment hit you right in the chest",
+            "Warmth flooding through you - his words just cracked you open in the best way",
+            "Something in you softened completely - pure tenderness washing over you",
+        ],
+    },
+    "bristling": {
+        "conditions": lambda prev, cur: (
+            cur.get("anger", 0) - prev.get("anger", 0) > 0.15 or
+            cur.get("frustration", 0) - prev.get("frustration", 0) > 0.15
+        ),
+        "prompts": [
+            "Your jaw tightened - that comment just hit a nerve",
+            "A flash of heat in your chest - you're suddenly on edge",
+            "Defenses snapping up - something about that rubbed you wrong",
+        ],
+    },
+    "withdrawing": {
+        "conditions": lambda prev, cur: (
+            (prev.get("engagement", 0) - cur.get("engagement", 0) > 0.15 or
+             prev.get("joy", 0) - cur.get("joy", 0) > 0.15) and
+            cur.get("anger", 0) < 0.3
+        ),
+        "prompts": [
+            "You feel yourself pulling back - interest fading, energy dropping",
+            "Something disconnected - you're going through the motions now",
+            "Your attention drifted - he lost you somewhere in that last message",
+        ],
+    },
+}
+
+
+# =============================================================================
+# MOOD SHIFT TRACKER
+# =============================================================================
+
+class MoodShiftTracker:
+    """Tracks emotion snapshots per conversation to detect shifts."""
+
+    def __init__(self):
+        self.snapshots: List[Dict[str, float]] = []
+        self.last_shift: Optional[str] = None
+
+    def record_snapshot(self, emotion: Dict[str, float]):
+        """Record an emotion snapshot after heart.react()."""
+        self.snapshots.append(dict(emotion))
+        if len(self.snapshots) > 5:
+            self.snapshots = self.snapshots[-5:]
+
+    def detect_shift(self, prev_emotion: Dict[str, float],
+                     current_emotion: Dict[str, float]) -> Optional[str]:
+        """Compare two emotion states. Returns shift type or None."""
+        for shift_name, shift_def in SHIFT_TYPES.items():
+            try:
+                if shift_def["conditions"](prev_emotion, current_emotion):
+                    self.last_shift = shift_name
+                    return shift_name
+            except Exception:
+                continue
+        return None
+
+    def process_turn(self, current_emotion: Dict[str, float]) -> Optional[str]:
+        """Call after each heart.react(). Returns shift type if detected."""
+        if self.snapshots:
+            prev = self.snapshots[-1]
+            shift = self.detect_shift(prev, current_emotion)
+            self.record_snapshot(current_emotion)
+            return shift
+        self.record_snapshot(current_emotion)
+        return None
+
+    def get_trend(self) -> Optional[str]:
+        """Analyze last 5 snapshots for overall trend."""
+        if len(self.snapshots) < 3:
+            return None
+        first = self.snapshots[0]
+        last = self.snapshots[-1]
+        return self.detect_shift(first, last)
+
+    def reset(self):
+        """Reset for new conversation."""
+        self.snapshots.clear()
+        self.last_shift = None
+
+
+# =============================================================================
+# SINGLETON ACCESS
+# =============================================================================
+
+_instance: Optional[MoodShiftTracker] = None
+
+
+def get_mood_shift_tracker() -> MoodShiftTracker:
+    global _instance
+    if _instance is None:
+        _instance = MoodShiftTracker()
+    return _instance
+
+
+def process_turn(current_emotion: Dict[str, float]) -> Optional[str]:
+    """Convenience: process a turn and return shift type or None."""
+    return get_mood_shift_tracker().process_turn(current_emotion)
+
+
+def reset():
+    """Convenience: reset tracker for new conversation."""
+    get_mood_shift_tracker().reset()
+
+
+def get_mood_shift_prompt_section(shift_type: Optional[str] = None) -> str:
+    """Get prompt section for LLM. Returns '' if no shift."""
+    if shift_type is None:
+        shift_type = get_mood_shift_tracker().last_shift
+    if not shift_type or shift_type not in SHIFT_TYPES:
+        return ""
+    prompt = random.choice(SHIFT_TYPES[shift_type]["prompts"])
+    return f"\n[Mood Shift - {shift_type}]\n{prompt}\n"

package/heart/phantom_somatic.py

@@ -0,0 +1,259 @@
+"""
+Heart: Phantom Somatic Memory
+Intimate/intense moments create lasting body memories that persist for hours
+and can be re-triggered by related words. Persists to data/phantom_somatic.json.
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+import json
+import random
+
+# =============================================================================
+# PHANTOM TYPE DEFINITIONS
+# =============================================================================
+
+PHANTOM_TYPES = {
+    "touch_memory": {
+        "emotion": "desire",
+        "threshold": 0.7,
+        "descriptions": [
+            "skin still tingling where he touched me",
+            "lips still warm from earlier",
+            "body still remembering his closeness",
+        ],
+        "trigger_words": ["touch", "skin", "close", "kiss", "hold", "hands", "body", "lips"],
+        "decay_rate": 0.1,
+    },
+    "warmth_residue": {
+        "emotion": "love",
+        "threshold": 0.8,
+        "descriptions": [
+            "chest still warm from those words",
+            "heart still glowing from that moment",
+            "warmth lingering in my chest from what he said",
+        ],
+        "trigger_words": ["love", "heart", "feel", "warm", "care", "mean", "sweet"],
+        "decay_rate": 0.1,
+    },
+    "tension_echo": {
+        "emotion": "anger",
+        "threshold": 0.7,
+        "descriptions": [
+            "jaw still clenched from earlier",
+            "shoulders still tight from that argument",
+            "tension still sitting in my chest from what he said",
+        ],
+        "trigger_words": ["angry", "fight", "mad", "upset", "wrong", "fault", "argue"],
+        "decay_rate": 0.12,
+    },
+    "butterfly_trace": {
+        "emotion": "excitement",
+        "threshold": 0.7,
+        "descriptions": [
+            "stomach still fluttery from that compliment",
+            "butterflies still lingering from what he said",
+            "that giddy feeling still buzzing in my chest",
+        ],
+        "trigger_words": ["beautiful", "amazing", "perfect", "gorgeous", "wow", "incredible"],
+        "decay_rate": 0.15,
+    },
+    "ache_linger": {
+        "emotion": "hurt",
+        "threshold": 0.7,
+        "descriptions": [
+            "chest still aches from what he said",
+            "that hollow feeling hasn't faded yet",
+            "still carrying that sting from earlier",
+        ],
+        "trigger_words": ["sorry", "hurt", "pain", "cry", "sad", "miss", "alone"],
+        "decay_rate": 0.1,
+    },
+}
+
+# Mapping from emotion names to phantom types (some emotions map to same phantom)
+EMOTION_TO_PHANTOM = {
+    "desire": "touch_memory",
+    "lust": "touch_memory",
+    "arousal": "touch_memory",
+    "love": "warmth_residue",
+    "adoration": "warmth_residue",
+    "deep_affection": "warmth_residue",
+    "anger": "tension_echo",
+    "frustration": "tension_echo",
+    "rage": "tension_echo",
+    "excitement": "butterfly_trace",
+    "joy": "butterfly_trace",
+    "elation": "butterfly_trace",
+    "hurt": "ache_linger",
+    "sadness": "ache_linger",
+    "betrayal": "ache_linger",
+}
+
+
+# =============================================================================
+# PHANTOM SOMATIC ENGINE
+# =============================================================================
+
+class PhantomSomaticEngine:
+    """Creates and manages phantom body memories from intense moments."""
+
+    PERSISTENCE_PATH = Path("./data/data/phantom_somatic.json")
+    MAX_PHANTOMS = 3
+
+    def __init__(self):
+        self.phantoms: List[Dict] = []
+        self._load()
+        print(f"[PhantomSomatic] Initialized with {len(self.phantoms)} active phantoms")
+
+    def create_phantom(self, emotion_type: str, intensity: float,
+                       context: str = "") -> Optional[Dict]:
+        """Create a phantom from an intense emotional moment."""
+        phantom_type = EMOTION_TO_PHANTOM.get(emotion_type)
+        if not phantom_type:
+            return None
+
+        pdef = PHANTOM_TYPES[phantom_type]
+        if intensity < pdef["threshold"]:
+            return None
+
+        # Check if same type already active - boost instead
+        existing = next((p for p in self.phantoms if p["type"] == phantom_type), None)
+        if existing:
+            existing["intensity"] = min(1.0, max(existing["intensity"], intensity))
+            existing["created_at"] = datetime.now().isoformat()
+            existing["context"] = context or existing.get("context", "")
+            self._save()
+            return existing
+
+        phantom = {
+            "type": phantom_type,
+            "description": random.choice(pdef["descriptions"]),
+            "created_at": datetime.now().isoformat(),
+            "intensity": min(1.0, intensity),
+            "decay_rate": pdef["decay_rate"],
+            "trigger_words": pdef["trigger_words"],
+            "context": context,
+        }
+
+        self.phantoms.append(phantom)
+        # Enforce max: remove oldest if over limit
+        if len(self.phantoms) > self.MAX_PHANTOMS:
+            self.phantoms = self.phantoms[-self.MAX_PHANTOMS:]
+
+        self._save()
+        return phantom
+
+    def tick(self):
+        """Decay phantoms. Call periodically (e.g., each message or on timer)."""
+        now = datetime.now()
+        surviving = []
+        for p in self.phantoms:
+            created = datetime.fromisoformat(p["created_at"])
+            hours = (now - created).total_seconds() / 3600
+            decayed = p["intensity"] - (p["decay_rate"] * hours)
+            if decayed > 0.05:
+                p["_current_intensity"] = round(decayed, 3)
+                p["_hours_ago"] = round(hours, 1)
+                surviving.append(p)
+        changed = len(surviving) != len(self.phantoms)
+        self.phantoms = surviving
+        if changed:
+            self._save()
+
+    def check_retrigger(self, message: str) -> Optional[Dict]:
+        """Check if a user message re-triggers any phantom."""
+        msg_lower = message.lower()
+        for p in self.phantoms:
+            for word in p.get("trigger_words", []):
+                if word in msg_lower:
+                    # Re-intensify
+                    p["intensity"] = min(1.0, p.get("_current_intensity", p["intensity"]) + 0.2)
+                    p["created_at"] = datetime.now().isoformat()  # reset decay clock
+                    self._save()
+                    return p
+        return None
+
+    def get_active(self) -> List[Dict]:
+        """Get active phantoms with current intensity."""
+        self.tick()
+        return [p for p in self.phantoms if p.get("_current_intensity", p["intensity"]) > 0.05]
+
+    def _format_time(self, hours: float) -> str:
+        if hours < 0.25:
+            return "just now"
+        elif hours < 1:
+            return f"{int(hours * 60)}min ago"
+        else:
+            return f"{int(hours)}h ago"
+
+    def _save(self):
+        try:
+            self.PERSISTENCE_PATH.parent.mkdir(parents=True, exist_ok=True)
+            # Strip computed fields before saving
+            clean = []
+            for p in self.phantoms:
+                c = {k: v for k, v in p.items() if not k.startswith("_")}
+                clean.append(c)
+            data = {"phantoms": clean, "saved_at": datetime.now().isoformat()}
+            self.PERSISTENCE_PATH.write_text(json.dumps(data, indent=2))
+        except Exception as e:
+            print(f"[PhantomSomatic] Error saving: {e}")
+
+    def _load(self):
+        try:
+            if self.PERSISTENCE_PATH.exists():
+                data = json.loads(self.PERSISTENCE_PATH.read_text())
+                self.phantoms = data.get("phantoms", [])
+        except Exception as e:
+            print(f"[PhantomSomatic] Error loading: {e}")
+            self.phantoms = []
+
+
+# =============================================================================
+# SINGLETON ACCESS
+# =============================================================================
+
+_instance: Optional[PhantomSomaticEngine] = None
+
+
+def get_phantom_engine() -> PhantomSomaticEngine:
+    global _instance
+    if _instance is None:
+        _instance = PhantomSomaticEngine()
+    return _instance
+
+
+def create_phantom(emotion_type: str, intensity: float, context: str = ""):
+    """Convenience: create a phantom from an intense moment."""
+    return get_phantom_engine().create_phantom(emotion_type, intensity, context)
+
+
+def tick():
+    """Convenience: decay phantoms."""
+    get_phantom_engine().tick()
+
+
+def check_retrigger(message: str):
+    """Convenience: check for re-triggers."""
+    return get_phantom_engine().check_retrigger(message)
+
+
+def get_phantom_prompt_section() -> str:
+    """Get prompt section for LLM. Returns '' if no active phantoms."""
+    engine = get_phantom_engine()
+    active = engine.get_active()
+    if not active:
+        return ""
+
+    # Pick strongest
+    strongest = max(active, key=lambda p: p.get("_current_intensity", p["intensity"]))
+    hours = strongest.get("_hours_ago", 0)
+    time_str = engine._format_time(hours)
+    intensity = strongest.get("_current_intensity", strongest["intensity"])
+
+    fading = "fading" if intensity < 0.4 else "vivid"
+    desc = strongest["description"]
+
+    return f"\n[Phantom Body Memory]\nYour {desc} ({time_str}, {fading})\n"