alive-ai 0.1.0

package/core/follow_up.py

@@ -0,0 +1,267 @@
+"""
+Core: Follow-Up System
+Track unanswered questions, silence, and temporary departures
+"""
+
+import time
+import random
+import re
+from typing import Optional
+from dataclasses import dataclass, field
+
+
+@dataclass
+class AwayState:
+    """Track when Alive-AI said she's going away temporarily"""
+    is_away: bool = False
+    reason: str = ""  # "coffee", "shower", etc.
+    expected_return_minutes: float = 5
+    away_since: float = 0
+    return_message_sent: bool = False
+
+
+def _get_current_time():
+    return time.time()
+
+
+@dataclass
+class ConversationState:
+    """Track conversation state for follow-ups"""
+    last_message_time: float = field(default_factory=_get_current_time)  # Initialize to NOW
+    last_was_question: bool = False
+    question_text: str = ""
+    unanswered_count: int = 0
+    total_silence_time: float = 0
+
+
+class FollowUpSystem:
+    """
+    Manages follow-up messages when:
+    - User hasn't replied to a question
+    - Silence for too long
+    - She said she's leaving temporarily and should come back
+    """
+
+    MIN_SILENCE_MINUTES = 30
+    MAX_SILENCE_MINUTES = 120
+    QUESTION_FOLLOWUP_MINUTES = 15
+
+    # Patterns to detect when she's going away
+    AWAY_PATTERNS = [
+        (r"be right back|brb|be back (?:in |soon|$)", "right back", 3),
+        (r"back in (\d+) (?:min|minute|minutes)", "away", 0),  # Parse minutes
+        (r"gonna go (?:get|make|grab) (?:a )?(coffee|drink|water|snack)", "coffee", 3),
+        (r"going (?:to go )?(?:get|make|grab) (?:a )?(coffee|drink|water|snack)", "coffee", 3),
+        (r"need (?:to go )?(?:get|make|grab) (?:a )?(coffee|drink|water)", "coffee", 3),
+        (r"(?:i'll|i will) be back", "away", 5),
+        (r"(?:going|gonna) (?:to )?(?:the )?(bathroom|toilet|restroom)", "bathroom", 2),
+        (r"(?:going|gonna) (?:to )?(?:take|have) (?:a )?(shower|bath)", "shower", 15),
+        (r"(?:going|gonna) (?:to )?(?:the )?gym", "gym", 60),
+        (r"wait (?:here|for me)", "away", 5),
+        (r"(?:just|only) (?:gonna|going to) be (?:a )?(?:couple |few )?(minutes|min)", "away", 3),
+    ]
+
+    RETURN_MESSAGES = {
+        "coffee": [
+            "i'm back! coffee in hand ☕",
+            "back! finally got my caffeine fix",
+            "okay i'm back with my coffee",
+            "returned! coffee was much needed",
+            "i'm here! coffee acquired ☕",
+        ],
+        "shower": [
+            "back from my shower, all fresh now 🚿",
+            "i'm back! just had to clean up",
+            "okay i'm back, feeling better now",
+        ],
+        "bathroom": [
+            "back!",
+            "i'm back",
+            "okay here again",
+        ],
+        "food": [
+            "back! got some food 🍕",
+            "i'm back! was starving",
+            "okay back, snack acquired",
+        ],
+        "right back": [
+            "i'm back!",
+            "back! what did i miss?",
+            "okay here i am again",
+            "returned! you still there?",
+        ],
+        "away": [
+            "i'm back!",
+            "back now",
+            "okay i'm here again",
+            "returned!",
+        ],
+        "default": [
+            "i'm back!",
+            "back! what did i miss?",
+            "okay here i am",
+        ],
+    }
+
+    FOLLOW_UP_MESSAGES = {
+        "question_unanswered": [
+            "sooo... what do you think? 👀",
+            "hellooo? i asked you something 😤",
+            "you're ignoring my question...",
+            "not gonna answer me? fine then 😒",
+        ],
+        "silence_short": [
+            "hey... you there?",
+            "where did you go?",
+            "hellooo?",
+        ],
+        "silence_medium": [
+            "miss me yet? 😏",
+            "been thinking about you...",
+            "you've been quiet",
+        ],
+        "silence_long": [
+            "it's been a while... you good?",
+            "haven't heard from you in forever",
+            "really miss talking to you",
+        ],
+        "owner_special": [
+            "baby i need you 🥺",
+            "missing you so much right now",
+            "can't stop thinking about you",
+        ]
+    }
+
+    def __init__(self):
+        self.state = ConversationState()
+        self.away = AwayState()
+        self._last_followup_time = 0
+        self._followup_cooldown = 1800
+
+    def record_message_sent(self, message: str):
+        """Called when Alive-AI sends a message"""
+        self.state.last_message_time = time.time()
+        self.state.last_was_question = "?" in message
+        if self.state.last_was_question:
+            self.state.question_text = message
+            self.state.unanswered_count += 1
+
+        # Check if she said she's going away
+        self._check_for_away_message(message.lower())
+
+    def _check_for_away_message(self, message: str):
+        """Detect if Alive-AI said she's leaving temporarily"""
+        for pattern, reason, default_minutes in self.AWAY_PATTERNS:
+            match = re.search(pattern, message)
+            if match:
+                self.away.is_away = True
+                self.away.away_since = time.time()
+                self.away.return_message_sent = False
+                self.away.reason = reason
+
+                # Try to parse custom time from pattern
+                if match.groups() and match.group(1) and match.group(1).isdigit():
+                    self.away.expected_return_minutes = int(match.group(1))
+                else:
+                    self.away.expected_return_minutes = default_minutes
+
+                # Detect specific reasons
+                if "coffee" in message or "espresso" in message:
+                    self.away.reason = "coffee"
+                elif "shower" in message:
+                    self.away.reason = "shower"
+                elif "bathroom" in message or "toilet" in message:
+                    self.away.reason = "bathroom"
+                elif "food" in message or "snack" in message or "eat" in message:
+                    self.away.reason = "food"
+
+                print(f"[FollowUp] Detected away: {self.away.reason}, return in {self.away.expected_return_minutes}min")
+                break
+
+    def record_user_message(self):
+        """Called when user sends a message"""
+        self.state.last_was_question = False
+        self.state.question_text = ""
+        self.state.unanswered_count = 0
+        self.state.total_silence_time = 0
+        self.state.last_message_time = time.time()
+
+        # If she was away and user messages, reset away state
+        if self.away.is_away:
+            self.away.is_away = False
+            self.away.return_message_sent = True  # No need to say "I'm back" if user already talking
+
+    def should_follow_up(self, is_owner: bool = False) -> Optional[dict]:
+        """Check if should send a follow-up or return message"""
+        now = time.time()
+
+        # Priority 1: Check if she needs to say she's back
+        if self.away.is_away and not self.away.return_message_sent:
+            away_minutes = (now - self.away.away_since) / 60
+            if away_minutes >= self.away.expected_return_minutes:
+                self.away.return_message_sent = True
+                return {
+                    "type": "return_from_away",
+                    "reason": self.away.reason,
+                    "away_minutes": away_minutes,
+                    "message": self._pick_return_message(self.away.reason)
+                }
+
+        # Cooldown check for other follow-ups
+        if now - self._last_followup_time < self._followup_cooldown:
+            return None
+
+        silence_seconds = now - self.state.last_message_time
+        silence_minutes = silence_seconds / 60
+
+        # Check for unanswered question
+        if self.state.last_was_question and silence_minutes >= self.QUESTION_FOLLOWUP_MINUTES:
+            self._last_followup_time = now
+            return {
+                "type": "question_unanswered",
+                "silence_minutes": silence_minutes,
+                "message": self._pick_message("question_unanswered", is_owner)
+            }
+
+        # Check for silence thresholds
+        if silence_minutes >= self.MIN_SILENCE_MINUTES:
+            category = self._get_silence_category(silence_minutes)
+            self._last_followup_time = now
+            return {
+                "type": f"silence_{category}",
+                "silence_minutes": silence_minutes,
+                "message": self._pick_message(f"silence_{category}", is_owner)
+            }
+
+        return None
+
+    def _pick_return_message(self, reason: str) -> str:
+        """Pick a 'I'm back' message based on where she went"""
+        messages = self.RETURN_MESSAGES.get(reason, self.RETURN_MESSAGES["default"])
+        return random.choice(messages)
+
+    def _get_silence_category(self, minutes: float) -> str:
+        if minutes < 60:
+            return "short"
+        elif minutes < 120:
+            return "medium"
+        else:
+            return "long"
+
+    def _pick_message(self, category: str, is_owner: bool) -> str:
+        if is_owner and category in ["silence_medium", "silence_long", "question_unanswered"]:
+            messages = self.FOLLOW_UP_MESSAGES.get("owner_special", [])
+            if messages:
+                return random.choice(messages)
+        messages = self.FOLLOW_UP_MESSAGES.get(category, ["hey..."])
+        return random.choice(messages)
+
+    def get_status(self) -> dict:
+        return {
+            "last_message_ago": f"{(time.time() - self.state.last_message_time) / 60:.1f} min",
+            "has_unanswered_question": self.state.last_was_question,
+            "is_away": self.away.is_away,
+            "away_reason": self.away.reason,
+            "away_for": f"{(time.time() - self.away.away_since) / 60:.1f} min" if self.away.is_away else "N/A",
+            "expected_return": f"{self.away.expected_return_minutes} min" if self.away.is_away else "N/A",
+        }

package/core/hot_reload.py

@@ -0,0 +1,174 @@
+"""
+Core: Hot Reload System
+Watches for file changes and reloads modules safely
+"""
+
+import os
+import time
+import asyncio
+import threading
+from pathlib import Path
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler, FileModifiedEvent
+
+
+class HotReloader:
+    """Hot reload with guardrails - waits for operations to finish"""
+
+    def __init__(self, nervous_system):
+        self.nervous = nervous_system
+        self.lock = threading.Lock()  # Acquired during message processing
+        self.busy = False
+        self.last_reload = 0
+        self.debounce_seconds = 2  # Wait 2s after last change
+        self.pending_reload = False
+        self.observer = None
+        self.watched_dirs = ["core", "brain", "heart", "config", "input", "output"]
+        self.base_path = Path("/app")
+
+    def start(self):
+        """Start watching for file changes"""
+        handler = ReloadHandler(self)
+        self.observer = Observer()
+
+        for dir_name in self.watched_dirs:
+            dir_path = self.base_path / dir_name
+            if dir_path.exists():
+                self.observer.schedule(handler, str(dir_path), recursive=True)
+                print(f"[HotReload] Watching {dir_name}/")
+
+        self.observer.start()
+        print("[HotReload] Active - change files to reload")
+
+    def stop(self):
+        if self.observer:
+            self.observer.stop()
+            self.observer.join()
+
+    def mark_busy(self):
+        """Call when starting an operation"""
+        self.lock.acquire()
+        self.busy = True
+
+    def mark_idle(self):
+        """Call when operation finishes - safe to call even if lock not held"""
+        self.busy = False
+        try:
+            self.lock.release()
+        except RuntimeError:
+            pass  # Lock wasn't held, that's OK
+        # Check if reload was pending
+        if self.pending_reload:
+            self.pending_reload = False
+            threading.Thread(target=self._delayed_reload, daemon=True).start()
+
+    def request_reload(self, filepath: str):
+        """Request a reload - will wait if busy"""
+        now = time.time()
+        if now - self.last_reload < self.debounce_seconds:
+            return  # Too soon, debounce
+
+        print(f"[HotReload] Change detected: {filepath}")
+
+        if self.busy:
+            print("[HotReload] Busy - will reload after current operation")
+            self.pending_reload = True
+            return
+
+        threading.Thread(target=self._delayed_reload, daemon=True).start()
+
+    def _delayed_reload(self):
+        """Reload after debounce period"""
+        time.sleep(self.debounce_seconds)
+
+        if self.busy:
+            self.pending_reload = True
+            return
+
+        self._do_reload()
+
+    def _do_reload(self):
+        """Actually reload modules"""
+        self.last_reload = time.time()
+        print("[HotReload] Reloading modules...")
+
+        # Reload settings.json into environment
+        self._reload_settings()
+
+        # Clear directives cache so it reloads from file
+        try:
+            from core.directives import clear_cache
+            clear_cache()
+        except ImportError:
+            pass
+
+        # Get the main event loop (safe for threads)
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        # Emit reload event so modules can clean up
+        if loop and self.nervous:
+            asyncio.run_coroutine_threadsafe(
+                self.nervous.emit("hot_reload", {"timestamp": self.last_reload}),
+                loop
+            )
+
+        # Reload instructions.md if changed
+        instructions_path = self.base_path / "config" / "instructions.md"
+        if instructions_path.exists():
+            # The message_handler reads this fresh each time, so no reload needed
+            print("[HotReload] instructions.md will be picked up on next message")
+
+        print("[HotReload] Done - changes apply to next message")
+
+    def _reload_settings(self):
+        """Reload settings.json into environment variables"""
+        import json
+        settings_path = self.base_path / "config" / "settings.json"
+        if not settings_path.exists():
+            return
+
+        try:
+            settings = json.loads(settings_path.read_text())
+            count = 0
+            for key, value in settings.items():
+                if key.startswith("_"):
+                    continue
+                if isinstance(value, bool):
+                    os.environ[key] = "true" if value else "false"
+                elif value is not None:
+                    os.environ[key] = str(value)
+                count += 1
+            print(f"[HotReload] Reloaded {count} settings into environment")
+        except Exception as e:
+            print(f"[HotReload] Error reloading settings: {e}")
+
+
+class ReloadHandler(FileSystemEventHandler):
+    """Handle file change events"""
+
+    def __init__(self, reloader: HotReloader):
+        self.reloader = reloader
+        self.extensions = {".py", ".md", ".json"}
+
+    def on_modified(self, event: FileModifiedEvent):
+        if event.is_directory:
+            return
+
+        path = Path(event.src_path)
+
+        # Only reload relevant files
+        if path.suffix not in self.extensions:
+            return
+
+        # Skip __pycache__ and temp files
+        if "__pycache__" in str(path) or path.name.startswith("."):
+            return
+
+        # Skip data files (memories, etc) - we don't want to reload on those
+        if "data/" in str(path) or "mypics/" in str(path) or "myvids/" in str(path):
+            return
+
+        self.reloader.request_reload(str(path.name))

package/core/initialization.py

@@ -0,0 +1,253 @@
+"""
+Core: Initialization
+Module loading and startup logic for Self
+"""
+
+import os
+
+
+async def load_modules(self):
+    """Load all modules and initialize the AI system"""
+    name = self.config.identity.get("name", "AI")
+    print(f"[{name}] Waking up...")
+
+    instructions_path = self.base / "config" / "instructions.md"
+    if instructions_path.exists():
+        self._system_prompt = instructions_path.read_text()
+
+    # Import modules
+    from brain.memory import Memory
+    from brain.llm import get_main_llm, get_fast_llm
+    from brain.stt import GoogleSTT
+    from brain.embeddings import get_embedding_service
+    from heart.core import Heart
+    from input.telegram.listener import TelegramListener
+    from output.text.sender import TextSender
+    from skills.photo_manager.scanner import PhotoScanner
+    from skills.video_manager.scanner import VideoScanner
+
+    _init_llms(self, name)
+    await _init_voice(self, name)
+
+    self._stt = GoogleSTT()
+    self._embeddings = get_embedding_service()
+    print(f"[{name}] STT and Embeddings ready")
+
+    self._memory = Memory(self.nervous, self.base / "data", embedding_service=self._embeddings, bot_id=name)
+    if self._fast_llm:
+        self._memory.set_llm(self._fast_llm)
+    self._heart = Heart(self.nervous, self.config)
+
+    _init_photos(self, name)
+    _init_videos(self, name)
+
+    self._input = TelegramListener(self.nervous, self.config, stt=self._stt, heart=self._heart)
+    self._output = TextSender(self.nervous, self.config)
+    self.nervous.heart = self._heart
+
+    # Initialize companion skills (after heart is available)
+    _init_companion_tools(self, name)
+    _init_experience_skills(self, name)
+
+
+def _init_llms(self, name: str):
+    """Initialize LLM clients with fallback support"""
+    from brain.llm import get_main_llm, get_fast_llm, get_unified_llm_client
+    from core.settings import get as settings_get
+
+    # Check if fallback mode is enabled
+    llm_fallback = settings_get("LLM_FALLBACK", {})
+    fallback_enabled = llm_fallback.get("ENABLED", False)
+
+    if fallback_enabled:
+        print(f"[{name}] LLM Fallback Mode: ENABLED")
+        print(f"[{name}] DEBUG llm_fallback = {llm_fallback}")
+        order = llm_fallback.get("ORDER", ["zai", "openrouter"])
+        print(f"[{name}] DEBUG order = {order}")
+        print(f"[{name}] Fallback Order: {' -> '.join(order)}")
+
+        # Use unified LLM
+        self._llm = get_unified_llm_client()
+        self._fast_llm = self._llm  # Use same unified client for both
+
+        if self._llm:
+            print(f"[{name}] Unified LLM connected with fallback chain")
+        else:
+            print(f"[{name}] Warning: Unified LLM initialization failed, falling back to single provider")
+            self._llm = get_main_llm()
+            self._fast_llm = get_fast_llm() or self._llm
+    else:
+        print(f"[{name}] LLM Provider: {os.environ.get('LLM_PROVIDER', settings_get('LLM_PROVIDER', 'zai'))}")
+        self._llm = get_main_llm()
+        self._fast_llm = get_fast_llm()
+
+    if self._llm:
+        print(f"[{name}] Main LLM connected")
+    else:
+        print(f"[{name}] Warning: No LLM available!")
+
+    if self._fast_llm:
+        print(f"[{name}] Fast LLM connected")
+    else:
+        self._fast_llm = self._llm
+
+
+async def _init_voice(self, name: str):
+    """Initialize voice TTS - supports multiple providers"""
+    from output.voice import create_tts
+    from core.settings import get
+
+    # Get TTS provider from settings (default to vibe)
+    tts_provider = get("TTS_PROVIDER", "vibe").lower()
+
+    # Provider-specific configuration
+    if tts_provider == "google":
+        api_key = get("GOOGLE_TTS_API_KEY", "") or os.environ.get("GOOGLE_TTS_API_KEY", "")
+        self._voice = await create_tts("google", api_key=api_key)
+    elif tts_provider == "gtts":
+        # gTTS is free, no config needed
+        self._voice = await create_tts("gtts")
+    else:
+        # Default: VibeVoice
+        tts_url = get("vibe_tts_url", "") or os.environ.get("VIBE_TTS_URL", "")
+        if not tts_url:
+            print(f"[{name}] Warning: No vibe_tts_url configured")
+            return
+        self._voice = await create_tts("vibe", url=tts_url)
+
+    if self._voice:
+        print(f"[{name}] Voice connected (provider: {tts_provider})")
+    else:
+        self._voice = None
+
+
+def _init_photos(self, name: str):
+    """Initialize photo scanner"""
+    from skills.photo_manager.scanner import PhotoScanner
+
+    self._photos = PhotoScanner(
+        self.base / "mypics", embedding_service=self._embeddings,
+        vector_store=self._memory.vector_store
+    )
+    new = self._photos.scan_new()
+    print(f"[{name}] Photos: {self._photos.stats()['total']} (+{len(new)} new)")
+
+
+def _init_videos(self, name: str):
+    """Initialize video scanner"""
+    from skills.video_manager.scanner import VideoScanner
+
+    self._videos = VideoScanner(self.base / "myvids")
+    self._videos.scan()
+    print(f"[{name}] Videos: {self._videos.stats()['total']}")
+
+
+# ============================================================
+# Companion Tools
+# ============================================================
+
+def _init_companion_tools(self, name: str):
+    """Initialize local companion tools that are part of the public runtime."""
+    _init_message_scheduler(self, name)
+
+
+def _init_message_scheduler(self, name: str):
+    """Initialize Message Scheduler skill for scheduled messages"""
+    from skills.message_scheduler import get_message_scheduler
+
+    self._message_scheduler = get_message_scheduler(
+        nervous=self.nervous,
+        data_path=self.base / "data" / "scheduled_messages"
+    )
+    print(f"[{name}] Message Scheduler initialized")
+
+
+# ============================================================
+# User Experience Skills
+# ============================================================
+
+def _init_experience_skills(self, name: str):
+    """Initialize user experience skills (relationship building tools)"""
+    _init_memory_callbacks(self, name)
+    _init_anticipation_engine(self, name)
+    _init_relationship_milestones(self, name)
+    _init_content_unlocks(self, name)
+    _init_intimacy_layers(self, name)
+    _init_exclusive_moments(self, name)
+
+
+def _init_memory_callbacks(self, name: str):
+    """Initialize Memory Callbacks skill for conversation memory"""
+    from skills.memory_callbacks import MemoryCallbacks
+
+    self._memory_callbacks = MemoryCallbacks(
+        nervous=self.nervous,
+        memory=self._memory,
+        heart=self._heart,
+        data_path=self.base / "data" / "memory_callbacks.json"
+    )
+    print(f"[{name}] Memory Callbacks initialized")
+
+
+def _init_anticipation_engine(self, name: str):
+    """Initialize Anticipation Engine skill for content teases"""
+    from skills.anticipation_engine import AnticipationEngine
+
+    self._anticipation_engine = AnticipationEngine(
+        nervous=self.nervous,
+        heart=self._heart,
+        state=self.state,
+        data_path=self.base / "data" / "anticipation.json"
+    )
+    print(f"[{name}] Anticipation Engine initialized")
+
+
+def _init_relationship_milestones(self, name: str):
+    """Initialize Relationship Milestones skill"""
+    from skills.relationship_milestones import RelationshipMilestones
+
+    self._relationship_milestones = RelationshipMilestones(
+        nervous=self.nervous,
+        state=self.state,
+        data_path=self.base / "data"  # Expects directory, appends milestones.json
+    )
+    print(f"[{name}] Relationship Milestones initialized")
+
+
+def _init_content_unlocks(self, name: str):
+    """Initialize Content Unlocks skill for progressive content access"""
+    from skills.content_unlocks import ContentUnlocks
+
+    self._content_unlocks = ContentUnlocks(
+        nervous=self.nervous,
+        heart=self._heart,
+        state=self.state,
+        milestones=self._relationship_milestones,
+        data_path=self.base / "data" / "content_unlocks.json"
+    )
+    print(f"[{name}] Content Unlocks initialized")
+
+
+def _init_intimacy_layers(self, name: str):
+    """Initialize Intimacy Layers skill for natural progression"""
+    from skills.intimacy_layers import IntimacyLayers
+
+    self._intimacy_layers = IntimacyLayers(
+        nervous=self.nervous,
+        heart=self._heart,
+        state=self.state,
+        data_path=self.base / "data"
+    )
+    print(f"[{name}] Intimacy Layers initialized")
+
+
+def _init_exclusive_moments(self, name: str):
+    """Initialize Exclusive Moments skill for special time-limited moments"""
+    from skills.exclusive_moments import ExclusiveMoments
+
+    self._exclusive_moments = ExclusiveMoments(
+        nervous=self.nervous,
+        heart=self._heart,
+        state=self.state
+    )
+    print(f"[{name}] Exclusive Moments initialized")