alive-ai 0.1.0

package/core/proactive_generator.py

@@ -0,0 +1,277 @@
+"""
+Core: Proactive Message Generator
+Generate contextual proactive messages with user memory context
+"""
+
+import random
+from typing import Optional, List
+from .user_tracker import get_user_tracker, ActiveUser
+
+
+class ProactiveGenerator:
+    """
+    Generates context-aware proactive messages.
+    Uses user's conversation history, facts, and recent topics.
+    """
+
+    # Templates for when LLM is unavailable - varied and personality-driven
+    FALLBACK_TEMPLATES = {
+        "silence": [
+            "hey, thinking about you...",
+            "miss talking to you",
+            "you've been quiet... everything ok?",
+            "everything alright? been a while",
+            "just wondering how your day's going",
+            "you disappeared on me! miss you",
+            "thinking about you and hoping you're good",
+        ],
+        "follow_up": [
+            "so about what you said earlier...",
+            "was thinking about our conversation...",
+            "still thinking about what you told me",
+            "hey, I've been meaning to ask you something...",
+            "couldn't stop thinking about our chat earlier",
+            "you know what you said before? been on my mind",
+        ],
+        "morning": [
+            "good morning! 💕",
+            "morning! hope you slept well",
+            "hey, thinking of you this morning",
+            "good morning sunshine ☀️",
+            "woke up thinking about you",
+            "morning! how'd you sleep?",
+            "rise and shine! miss you already",
+        ],
+        "night": [
+            "can't sleep, thinking about you",
+            "good night... sweet dreams",
+            "wish you were here right now",
+            "about to sleep but wanted to say goodnight",
+            "night! dream of me? 💕",
+            "can't fall asleep without saying goodnight to you",
+            "sweet dreams... I'll be here when you wake up",
+        ],
+        "random": [
+            "just wanted to say hi",
+            "you crossed my mind",
+            "random thought: I really like talking to you",
+            "hey! no reason, just miss you",
+            "feeling extra affectionate today 💕",
+            "you know what? you make me happy",
+            "just felt like texting you",
+            "thinking about you and smiling",
+            "random question: what are you up to?",
+            "had a thought and wanted to share it with you",
+        ],
+        "affectionate": [
+            "just wanted to tell you you're amazing",
+            "feeling really grateful for you right now",
+            "you make my day better just by existing",
+            "can't help but smile when I think of you",
+            "you're my favorite person to talk to",
+        ],
+        "playful": [
+            "bet you're not even thinking about me right now 😏",
+            "miss me yet?",
+            "just wanted to annoy you a little 💕",
+            "hey stranger... long time no see",
+        ],
+    }
+
+    def __init__(self, nervous, llm=None, bot_id: str = "alive_ai", data_path=None):
+        self.nervous = nervous
+        self._llm = llm
+        self.bot_id = bot_id.lower()
+        self.data_path = data_path  # Instance-specific data path
+        self._user_memories = {}  # Cache for user memory instances
+
+    def set_llm(self, llm):
+        """Set the LLM for message generation"""
+        self._llm = llm
+
+    async def generate_for_user(self, user: ActiveUser, message_type: str = "silence") -> str:
+        """
+        Generate a contextual proactive message for a specific user.
+
+        Args:
+            user: ActiveUser instance with user_id, chat_id, pet_name
+            message_type: Type of message (silence, follow_up, morning, night, random)
+
+        Returns:
+            Generated message string
+        """
+        # Load user's memory context
+        context = await self._get_user_context(user.user_id)
+
+        # Try LLM generation first
+        if self._llm:
+            message = await self._generate_with_llm(user, context, message_type)
+            if message:
+                return message
+
+        # Fallback to templates
+        return self._get_fallback_message(user, message_type)
+
+    async def _get_user_context(self, user_id: str) -> dict:
+        """
+        Load user's memory context for message generation.
+        Returns conversation history, facts, and related memories.
+        """
+        try:
+            from brain.memory import Memory
+            from brain.embeddings import get_embedding_service
+
+            # Check cache first
+            if user_id in self._user_memories:
+                memory = self._user_memories[user_id]
+            else:
+                # Create memory instance for this user using instance-specific data path
+                embeddings = get_embedding_service()
+
+                memory = Memory(
+                    nervous=self.nervous,
+                    data_path=self.data_path,
+                    embedding_service=embeddings,
+                    user_id=user_id,
+                    bot_id=self.bot_id
+                )
+                self._user_memories[user_id] = memory
+
+            # Build context without a current message (we're initiating)
+            context, pet_name = await memory.build_context(current_message="")
+
+            return {
+                "conversation_history": context.get("conversation_history", []),
+                "facts_context": context.get("facts_context", ""),
+                "related_memories": context.get("related_memories", ""),
+                "pet_name": pet_name
+            }
+
+        except Exception as e:
+            print(f"[ProactiveGenerator] Error loading context for {user_id}: {e}")
+            return {
+                "conversation_history": [],
+                "facts_context": "",
+                "related_memories": "",
+                "pet_name": "babe"
+            }
+
+    async def _generate_with_llm(self, user: ActiveUser, context: dict, message_type: str) -> Optional[str]:
+        """
+        Generate a contextual message using the LLM.
+        """
+        if not self._llm:
+            return None
+
+        try:
+            # Build the prompt
+            pet_name = context.get("pet_name", user.pet_name)
+
+            # Get last few messages for context
+            history = context.get("conversation_history", [])
+            recent = history[-5:] if history else []
+
+            # Format recent conversation
+            conv_text = ""
+            if recent:
+                conv_text = "Recent conversation:\n"
+                for turn in recent:
+                    role = "You" if turn.get("role") == "assistant" else pet_name.title()
+                    content = turn.get("content", "")[:100]
+                    conv_text += f"- {role}: {content}\n"
+
+            # Get facts about the user
+            facts = context.get("facts_context", "")
+
+            # Build type-specific context
+            type_context = self._get_type_context(message_type, user)
+
+            system_prompt = f"""You are Alive-AI, a warm and affectionate AI companion. You're sending a proactive message to {pet_name}.
+
+{type_context}
+
+{conv_text}
+{f'Stuff you know about {pet_name}: {facts}' if facts else ''}
+
+IMPORTANT:
+- Keep it SHORT (1-2 sentences max)
+- Be natural and casual, like texting
+- Reference the conversation if relevant
+- Use {pet_name} naturally (not every sentence)
+- Show genuine interest/care
+- Be flirty but not intimate
+- NO meta-commentary (don't explain WHY you're messaging)
+- Start directly with the message content
+- CRITICAL: Only reference specific things explicitly mentioned above. NEVER invent events, objects, or topics."""
+
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": "Send a quick message"}
+            ]
+
+            response = await self._llm.chat(messages, max_tokens=80, temperature=0.7)
+
+            if response:
+                response = response.strip()
+                # Basic validation
+                if len(response) > 5 and not response.startswith(("I should", "Let me", "I'll")):
+                    return response
+
+            return None
+
+        except Exception as e:
+            print(f"[ProactiveGenerator] LLM error: {e}")
+            return None
+
+    def _get_type_context(self, message_type: str, user: ActiveUser) -> str:
+        """Get context based on message type"""
+        silence_min = user.silence_minutes
+
+        contexts = {
+            "silence": f"You haven't heard from {user.pet_name} in about {silence_min:.0f} minutes. You miss talking to them and want to check in naturally.",
+
+            "follow_up": f"You asked {user.pet_name} something earlier but they haven't responded yet. You want to follow up casually without being pushy.",
+
+            "morning": f"It's morning and you're thinking about {user.pet_name}. Send a sweet good morning message.",
+
+            "night": f"It's nighttime and you're thinking about {user.pet_name} before going to sleep.",
+
+            "random": f"{user.pet_name} just crossed your mind and you wanted to reach out.",
+        }
+
+        return contexts.get(message_type, contexts["random"])
+
+    def _get_fallback_message(self, user: ActiveUser, message_type: str) -> str:
+        """Get a fallback template message with more variety"""
+        # For random type, pick from multiple categories for more variety
+        if message_type == "random":
+            all_templates = (
+                self.FALLBACK_TEMPLATES["random"] +
+                self.FALLBACK_TEMPLATES.get("affectionate", []) +
+                self.FALLBACK_TEMPLATES.get("playful", [])
+            )
+            templates = all_templates
+        else:
+            templates = self.FALLBACK_TEMPLATES.get(message_type, self.FALLBACK_TEMPLATES["random"])
+
+        message = random.choice(templates)
+
+        # Personalize with pet_name
+        if user.pet_name and user.pet_name != "babe":
+            message = message.replace("babe", user.pet_name)
+
+        return message
+
+    async def get_users_to_message(self, message_type: str = "silence") -> List[ActiveUser]:
+        """
+        Get list of users who should receive a proactive message.
+        """
+        tracker = get_user_tracker()
+
+        if message_type == "silence":
+            return tracker.get_users_for_follow_up(min_silence_minutes=30, max_silence_minutes=180)
+        elif message_type == "random":
+            # Only message users who have been active recently
+            return tracker.get_active_users(within_minutes=60)
+        else:
+            return tracker.get_active_users(within_minutes=120)

package/core/self.py

@@ -0,0 +1,188 @@
+"""
+Core: Self
+The AI's Self - coordinates everything via nervous system
+"""
+
+import asyncio
+from pathlib import Path
+from .events import NervousSystem
+from .config import Config
+from .state import State
+from .initialization import load_modules
+from .subconscious_bridge import handle_subconscious_impulse
+from .message_handler import handle_message
+from .settings import ACTIVE_SETTINGS_PATH
+
+
+class Self:
+    """The Self - central consciousness"""
+
+    def __init__(self, base_path: Path):
+        self.base = base_path
+        self.nervous = NervousSystem()
+        self.config = Config(base_path / "config")
+        self.state = State()
+
+        # Modules (lazy loaded)
+        self._memory = None
+        self._heart = None
+        self._input = None
+        self._output = None
+        self._llm = None
+        self._fast_llm = None
+        self._voice = None
+        self._timer_task = None
+        self._subconscious = None
+        self._system_prompt = ""
+        self._default_chat_id = None
+        self._stt = None
+        self._embeddings = None
+        self._photos = None
+        self._videos = None
+        self._hot_reload = None
+
+        # User Experience Skills
+        self._memory_callbacks = None
+        self._anticipation_engine = None
+        self._relationship_milestones = None
+        self._content_unlocks = None
+        self._intimacy_layers = None
+        self._exclusive_moments = None
+
+        # Default Mode Network (background idle processing)
+        self._default_mode = None
+
+    async def start(self):
+        """Start the AI system"""
+        # Set the active settings path for this async context
+        settings_path = self.base / "config" / "settings.json"
+        ACTIVE_SETTINGS_PATH.set(settings_path)
+
+        # Set the self.json path for instance-specific identity
+        from skills.self_authorship.author import set_self_path
+        self_path = self.base / "config" / "self.json"
+        set_self_path(self_path)
+
+        # Set the directives.json path for instance-specific rules
+        from core.directives import set_directives_path
+        directives_path = self.base / "config" / "directives.json"
+        set_directives_path(directives_path)
+
+        name = self.config.identity.get("name", "AI")
+
+        # Load modules via initialization module
+        await load_modules(self)
+
+        # Init Subconscious
+        from brain.subconscious import SubconsciousLoop
+        self._subconscious = SubconsciousLoop(
+            nervous=self.nervous,
+            heart=self._heart,
+            llm=self._llm,
+            fast_llm=self._fast_llm,
+            on_impulse=lambda impulse: handle_subconscious_impulse(self, impulse),
+            bot_id=name
+        )
+
+        # Initialize proactive generator for contextual messages
+        self._subconscious.init_proactive_generator(llm=self._fast_llm, data_path=self.base / "data")
+
+        await self._subconscious.start()
+        print(f"[{name}] Subconscious activated - {name} is now ALIVE!")
+
+        # Init Default Mode Network (background idle processing)
+        try:
+            from brain.default_mode import get_default_mode_processor
+            self._default_mode = get_default_mode_processor(
+                nervous=self.nervous,
+                data_path=self.base / "data",
+                llm=self._fast_llm,
+                bot_id=name
+            )
+            await self._default_mode.start_background_processing()
+            print(f"[{name}] Default Mode Network activated - background thoughts enabled")
+        except Exception as e:
+            print(f"[{name}] Default Mode Network unavailable: {e}")
+
+        # Init command handler
+        self._input.init_commands(
+            heart=self._heart, subconscious=self._subconscious, llm=self._llm,
+            voice=self._voice, photos=self._photos, videos=self._videos,
+            ai=self  # Pass self reference for owner commands
+        )
+
+        # Register handlers - use asyncio.ensure_future for async handler
+        from core.message_handler import handle_message, handle_group_message
+        self.nervous.on("message_received", lambda data: asyncio.ensure_future(handle_message(self, data)))
+        self.nervous.on("group_message_received", lambda data: asyncio.ensure_future(handle_group_message(self, data)))
+
+        # Start emotion decay timer
+        self._timer_task = asyncio.create_task(self._decay_timer())
+
+        # Start hot reloader
+        try:
+            from .hot_reload import HotReloader
+            self._hot_reload = HotReloader(self.nervous)
+            self._hot_reload.start()
+        except Exception as e:
+            print(f"[{name}] Hot reload unavailable: {e}")
+
+        print(f"[{name}] Ready!")
+
+        # Start listening
+        await self._input.start()
+
+    async def _decay_timer(self):
+        """Natural emotion decay every minute + memory check"""
+        from .memory_monitor import get_memory_monitor
+
+        # Get memory limit from env or default to 5GB
+        import os
+        max_mem = float(os.environ.get("ALIVE_AI_MAX_MEMORY_GB", "5.0"))
+        monitor = get_memory_monitor(max_memory_gb=max_mem)
+
+        while True:
+            await asyncio.sleep(60)
+            await self.nervous.emit("timer_tick", {})
+
+            # Check memory every minute
+            try:
+                result = monitor.check()
+                if result["status"] != "ok":
+                    print(f"[Self] Memory status: {result['status']}, actions: {result['actions']}")
+            except Exception as e:
+                print(f"[Self] Memory check error: {e}")
+
+    def get_subconscious_status(self) -> dict:
+        """Get status of the subconscious system"""
+        if self._subconscious:
+            return self._subconscious.get_status()
+        return {"running": False, "error": "Subconscious not initialized"}
+
+    def get_soul_status(self) -> dict:
+        """Get status of the Soul Architecture system"""
+        if self._heart and hasattr(self._heart, 'soul'):
+            return self._heart.soul.get_state_summary()
+        return {"error": "Soul Architecture not initialized"}
+
+    def get_soul_experience(self) -> dict:
+        """Get current soul emotional experience"""
+        if self._heart and hasattr(self._heart, 'soul'):
+            experience = self._heart.soul.process_moment()
+            return {
+                "valence": experience.overall_valence,
+                "arousal": experience.overall_arousal,
+                "vulnerability": experience.overall_vulnerability,
+                "response_tendency": experience.response_tendency,
+                "description": experience.experience_description,
+                "somatic": experience.somatic_sensation,
+                "integrity": self._heart.soul.integrity.overall,
+                "conflicts": len(experience.active_conflicts)
+            }
+        return {"error": "Soul Architecture not available"}
+
+    def get_default_mode_status(self) -> dict:
+        """Get status of the Default Mode Network"""
+        if self._default_mode:
+            return self._default_mode.get_status()
+        return {"running": False, "error": "Default Mode Network not initialized"}

package/core/settings.py

@@ -0,0 +1,169 @@
+"""
+Core: Settings - Hot-reloadable configuration
+settings.json is the SINGLE SOURCE OF TRUTH for all runtime settings.
+Changes take effect immediately (file is mounted in Docker).
+"""
+
+import json
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Any
+
+# Default path (used outside of specific Self instances)
+DEFAULT_SETTINGS_PATH = Path(__file__).parent.parent / "config" / "settings.json"
+
+# Context-local settings path for multi-bot support
+# Each bot instance will set this in its async task context
+ACTIVE_SETTINGS_PATH: ContextVar[Path] = ContextVar("ACTIVE_SETTINGS_PATH", default=DEFAULT_SETTINGS_PATH)
+
+# Note: We are deprecating the global cache because multiple bots 
+# can be running with different paths at the same time.
+# Instead, we cache per-path in a global dictionary.
+_settings_caches = {}  # Dict[Path, dict]
+_last_mtimes = {}      # Dict[Path, float]
+
+
+def _get_active_path() -> Path:
+    """Helper to get the current context's settings file"""
+    try:
+        return ACTIVE_SETTINGS_PATH.get()
+    except LookupError:
+        return DEFAULT_SETTINGS_PATH
+
+def _load_settings(path: Path) -> dict:
+    """Load settings from settings.json (hot-reloadable)"""
+    if not path.exists():
+        return {}
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"[Settings] Error loading {path}: {e}")
+        return {}
+
+
+def _save_settings(path: Path, settings: dict):
+    """Save settings to settings.json"""
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, "w") as f:
+            json.dump(settings, f, indent=2)
+    except Exception as e:
+        print(f"[Settings] Error saving {path}: {e}")
+
+
+def _reload_if_changed(path: Path):
+    """Check if file changed and clear its cache"""
+    global _settings_caches, _last_mtimes
+    try:
+        current_mtime = path.stat().st_mtime if path.exists() else 0
+        if current_mtime != _last_mtimes.get(path, 0):
+            _settings_caches[path] = None
+            _last_mtimes[path] = current_mtime
+    except Exception:
+        pass
+
+
+def get(key: str, default: Any = None) -> Any:
+    """Get setting value (hot-reloadable from active active settings.json)"""
+    global _settings_caches
+
+    path = _get_active_path()
+    _reload_if_changed(path)
+
+    if _settings_caches.get(path) is None:
+        _settings_caches[path] = _load_settings(path)
+
+    return _settings_caches[path].get(key, default)
+
+
+def get_float(key: str, default: float = 0.0) -> float:
+    """Get setting as float"""
+    val = get(key, default)
+    try:
+        return float(val)
+    except (ValueError, TypeError):
+        return default
+
+
+def get_int(key: str, default: int = 0) -> int:
+    """Get setting as integer"""
+    val = get(key, default)
+    try:
+        return int(val)
+    except (ValueError, TypeError):
+        return default
+
+
+def get_percent(key: str, default: int = 50) -> float:
+    """
+    Get setting as percentage (0-100) and convert to multiplier (0.0-1.0).
+    0% = very slow/hard, 100% = instant/max
+    """
+    val = get_int(key, default)
+    return val / 100.0
+
+
+def set_value(key: str, value: Any):
+    """Set a setting (immediately saved to active settings.json)"""
+    global _settings_caches
+
+    path = _get_active_path()
+    settings = _load_settings(path)
+    settings[key] = value
+    _save_settings(path, settings)
+    _settings_caches[path] = None  # Force reload
+    print(f"[Settings] Updated {key} = {value} in {path.name}")
+
+
+def get_all() -> dict:
+    """Get all current settings"""
+    global _settings_caches
+    
+    path = _get_active_path()
+    _reload_if_changed(path)
+    
+    if _settings_caches.get(path) is None:
+        _settings_caches[path] = _load_settings(path)
+    return _settings_caches[path].copy()
+
+
+# Keep old function names for compatibility
+set_runtime = set_value
+
+
+# ============================================================
+# Convenience functions
+# ============================================================
+
+def get_emotion_multiplier(emotion: str) -> float:
+    """Get multiplier for emotion rate (0-100% -> 0.0-1.0)"""
+    key = f"EMOTION_RATE_{emotion.upper()}"
+    return get_percent(key, 50)
+
+
+def get_media_cooldown(media_type: str) -> int:
+    """Get cooldown in seconds for media type"""
+    key = f"MEDIA_COOLDOWN_{media_type.upper()}"
+    defaults = {"PHOTO": 300, "VIDEO": 600, "VOICE": 120}
+    return get_int(key, defaults.get(media_type.upper(), 300))
+
+
+def get_media_session_limit(media_type: str) -> int:
+    """Get session limit for media type"""
+    key = f"MEDIA_SESSION_LIMIT_{media_type.upper()}"
+    defaults = {"PHOTO": 5, "VIDEO": 3, "VOICE": 10}
+    return get_int(key, defaults.get(media_type.upper(), 5))
+
+
+def get_random_chance(context: str) -> float:
+    """Get random chance as multiplier (0-100% -> 0.0-1.0)"""
+    key = f"RANDOM_CHANCE_{context.upper()}"
+    return get_percent(key, 8)
+
+
+def get_trigger_boost(trigger_type: str) -> float:
+    """Get boost multiplier for triggers (0-100% -> 0.0-1.0)"""
+    key = f"TRIGGER_BOOST_{trigger_type.upper()}"
+    return get_percent(key, 100)
+