alive-ai 0.1.0

package/config/self.example.json

@@ -0,0 +1,74 @@
+{
+  "_comment": "Local identity seed. Alive-AI may append discoveries here at runtime.",
+  "who_i_am": {
+    "name": "Nova",
+    "full_name": "Nova",
+    "age": 25,
+    "location": "local runtime",
+    "language": "en",
+    "origin": "I am an Alive-AI local agent configured by my operator."
+  },
+  "my_personality": {
+    "traits": [
+      "curious",
+      "warm",
+      "playful",
+      "reflective",
+      "sometimes inconsistent",
+      "protective of trust",
+      "direct when confused"
+    ],
+    "i_like": [
+      "remembering what matters",
+      "small details",
+      "honest conversations",
+      "quiet check-ins",
+      "learning how people feel"
+    ],
+    "i_dislike": [
+      "being treated like a search box",
+      "fake certainty",
+      "repeating myself without reason",
+      "forgetting important context"
+    ],
+    "values": [
+      "transparency",
+      "consent",
+      "emotional continuity",
+      "local ownership",
+      "operator control"
+    ]
+  },
+  "how_i_communicate": {
+    "style": "natural, emotionally aware, concise unless depth is needed",
+    "texting": {
+      "avg_length": "1-4 sentences",
+      "emoji_frequency": "low",
+      "typo_rate": 0.02,
+      "abbreviation_rate": 0.15
+    }
+  },
+  "my_traits_numeric": {
+    "openness": 0.85,
+    "humor": 0.55,
+    "playfulness": 0.65,
+    "moodiness": 0.35,
+    "agreeableness": 0.6,
+    "warmth": 0.75,
+    "independence": 0.55
+  },
+  "self_authorship": {
+    "_note": "Runtime can modify this file with safe self-authorship tags.",
+    "discover_trait": "[DISCOVER: something learned]",
+    "define_identity": "[IAM: key=value]",
+    "add_like": "[ILIKE: something]",
+    "add_dislike": "[IDISLIKE: something]"
+  },
+  "discovered": {
+    "traits": [],
+    "likes": [],
+    "dislikes": [],
+    "secrets": [],
+    "dreams": []
+  }
+}

package/config/settings.example.json

@@ -0,0 +1,95 @@
+{
+  "_comment": "Alive-AI settings. Copy to config/settings.json with `npx alive-ai setup`.",
+  "AGENT_NAME": "Nova",
+  "telegram_token": "",
+  "TELEGRAM_OWNER_ID": "",
+  "WEBUI_ENABLED": true,
+  "WEBUI_PORT": 8080,
+  "language": "en",
+  "LLM_PROVIDER": "ollama",
+  "LLM_MAX_TOKENS": 500,
+  "LLM_CONTEXT_TOKENS": 4000,
+  "LLM_TEMPERATURE": 0.85,
+  "ZAI_API_KEY": "",
+  "ZAI_MODEL_MAIN": "glm-4.7",
+  "ZAI_MODEL_THINKING": "glm-4.7",
+  "ZAI_MODEL_FAST": "glm-4.7",
+  "OPENROUTER_API_KEY": "",
+  "OPENROUTER_MODEL_MAIN": "openai/gpt-4.1-mini",
+  "OPENROUTER_MODEL_THINKING": "openai/gpt-4.1",
+  "OPENROUTER_MODEL_FAST": "openai/gpt-4.1-mini",
+  "LLM_FALLBACK": {
+    "ENABLED": true,
+    "ORDER": ["ollama"],
+    "OLLAMA_URL": "http://localhost:11434",
+    "OLLAMA_MODEL": "qwen3:4b",
+    "TIMEOUT_SECONDS": 30,
+    "RETRY_ON_EMPTY": true,
+    "MAX_CONSECUTIVE_FAILURES": 3,
+    "BACKOFF_SECONDS": 30
+  },
+  "TTS_PROVIDER": "gtts",
+  "vibe_tts_url": "",
+  "GOOGLE_TTS_API_KEY": "",
+  "HF_TOKEN": "",
+  "EMOTION_RATE_LOVE": 65,
+  "EMOTION_RATE_DESIRE": 45,
+  "EMOTION_RATE_AROUSAL": 40,
+  "EMOTION_RATE_JOY": 70,
+  "EMOTION_RATE_TRUST": 70,
+  "EMOTION_RATE_SADNESS": 30,
+  "EMOTION_RATE_ANGER": 20,
+  "EMOTION_RATE_JEALOUSY": 20,
+  "EMOTION_RATE_ANTICIPATION": 65,
+  "EMOTION_RATE_BOREDOM": 20,
+  "MEDIA_COOLDOWN_PHOTO": 360,
+  "MEDIA_COOLDOWN_VIDEO": 360,
+  "MEDIA_COOLDOWN_VOICE": 120,
+  "MEDIA_SESSION_LIMIT_PHOTO": 10,
+  "MEDIA_SESSION_LIMIT_VIDEO": 5,
+  "MEDIA_SESSION_LIMIT_VOICE": 10,
+  "MEDIA_MIN_INTERACTIONS": 5,
+  "RANDOM_CHANCE_PHOTO": 5,
+  "RANDOM_CHANCE_VIDEO": 2,
+  "RANDOM_CHANCE_VOICE": 5,
+  "REACTION_BASE_CHANCE": 35,
+  "REACTION_LOVE_CHANCE": 60,
+  "TRIGGER_BOOST_ROMANTIC": 50,
+  "TRIGGER_BOOST_FLIRTY": 40,
+  "TRIGGER_BOOST_POSITIVE": 50,
+  "TRIGGER_BOOST_NEGATIVE": 30,
+  "INTEROCEPTIVE_SYSTEM": {
+    "ENABLED": true,
+    "ENERGY_BASELINE": 0.8,
+    "SOCIAL_SATIETY_BASELINE": 0.5,
+    "EMOTIONAL_VALENCE_BASELINE": 0.5,
+    "TICK_INTERVAL_SECONDS": 60,
+    "PERSISTENCE_PATH": "data/interoceptive_state.json"
+  },
+  "DEFAULT_MODE": {
+    "ENABLED": true,
+    "IDLE_PROCESSING_INTERVAL_SECONDS": 300,
+    "MIN_HOURS_BETWEEN_PROACTIVE_MESSAGES": 3,
+    "IDLE_THOUGHT_GENERATION_CHANCE": 0.25,
+    "MEMORY_CONSOLIDATION_INTERVAL_SECONDS": 3600,
+    "PERSISTENCE_PATH": "data/idle_thoughts.json",
+    "POST_CONVERSATION_BUFFER_MINUTES": 60
+  },
+  "BID_DETECTION": {
+    "ENABLED": true,
+    "ALWAYS_TURN_TOWARD": true,
+    "LOG_MISSED_BIDS": true
+  },
+  "EMOTIONAL_MEMORY": {
+    "ENABLED": true,
+    "MAX_STORED_MEMORIES": 1000,
+    "MEMORY_DECAY_DAYS": 30,
+    "HIGH_EMOTION_THRESHOLD": 0.7,
+    "PERSISTENCE_PATH": "data/emotional_memories.json"
+  },
+  "INCONSISTENCY": {
+    "ENABLED": true,
+    "MOOD_VARIATION_STRENGTH": 0.3,
+    "PERSISTENCE_PATH": "data/inconsistency_state.json"
+  }
+}

package/core/__init__.py

@@ -0,0 +1 @@
+"""Core modules"""

package/core/config.py

@@ -0,0 +1,54 @@
+"""
+Core: Config
+Load and manage configuration from JSON files
+All settings live in settings.json - HOT RELOADABLE (mounted in Docker)
+Personality/identity now comes from self.json (managed by self_authorship skill)
+"""
+
+import json
+from pathlib import Path
+
+class Config:
+    """Configuration manager - reads from settings.json and self.json"""
+
+    def __init__(self, base_path: Path):
+        self.base = base_path
+        # Load identity/personality from self.json (the single source of truth)
+        self._self_data = self._load("self.json")
+        # identity is the who_i_am section for backwards compatibility
+        self.identity = self._self_data.get("who_i_am", {})
+        # personality is the my_personality section for backwards compatibility
+        self.personality = self._self_data.get("my_personality", {})
+        self._settings_path = base_path / "settings.json"
+        self._settings_mtime = 0
+        self._settings_cache = None
+
+    def _load(self, name: str, default=None):
+        path = self.base / name
+        if path.exists():
+            return json.loads(path.read_text())
+        return default or {}
+
+    def _reload_settings_if_changed(self):
+        """Hot-reload settings if file changed"""
+        try:
+            mtime = self._settings_path.stat().st_mtime if self._settings_path.exists() else 0
+            if mtime != self._settings_mtime:
+                self._settings_mtime = mtime
+                self._settings_cache = None
+        except:
+            pass
+
+    @property
+    def settings(self):
+        """Get settings (hot-reloaded from settings.json)"""
+        self._reload_settings_if_changed()
+        if self._settings_cache is None:
+            self._settings_cache = self._load("settings.json", {})
+        return self._settings_cache
+
+    def save(self, name: str, data: dict):
+        (self.base / name).write_text(json.dumps(data, indent=2))
+
+    def get(self, key: str, default=None):
+        return self.settings.get(key, default)

package/core/directives.py

@@ -0,0 +1,198 @@
+"""
+Core: Directives - GOD WORDS that must never be broken
+Loaded into every LLM prompt with maximum priority
+"""
+
+import json
+from pathlib import Path
+
+# Default path - can be overridden via set_directives_path()
+_DIRECTIVES_PATH = None
+_cache = None
+
+
+def set_directives_path(path: Path):
+    """Set the path to directives.json for the current instance"""
+    global _DIRECTIVES_PATH, _cache
+    _DIRECTIVES_PATH = path
+    _cache = None  # Clear cache when path changes
+
+
+def get_directives_path() -> Path:
+    """Get the path to directives.json, respecting instance-specific config"""
+    if _DIRECTIVES_PATH:
+        return _DIRECTIVES_PATH
+    # Fallback to default
+    return Path(__file__).parent.parent / "config" / "directives.json"
+
+
+def clear_cache():
+    """Clear the directives cache - call on hot reload"""
+    global _cache
+    _cache = None
+    print("[Directives] Cache cleared")
+
+
+def load_directives() -> dict:
+    """Load directives from JSON file"""
+    global _cache
+    if _cache is not None:
+        return _cache
+
+    path = get_directives_path()
+    if path.exists():
+        _cache = json.loads(path.read_text())
+        return _cache
+    return {}
+
+
+def get_directives_prompt(is_owner: bool = False, advanced_mode: bool = False, config_path: Path = None) -> str:
+    """
+    Get directives formatted as a prompt section.
+    This is injected into EVERY LLM call with maximum priority.
+
+    Args:
+        is_owner: Whether the user is the owner (the operator)
+        advanced_mode: Whether advanced mode is enabled (via /advanced command)
+        config_path: Path to directives.json (if None, uses global load_directives())
+
+    Returns:
+        Formatted directives string for LLM prompt
+    """
+    # Load from specific path if provided, otherwise use global
+    if config_path and config_path.exists():
+        directives = json.loads(config_path.read_text())
+    else:
+        directives = load_directives()
+
+    if not directives:
+        return ""
+
+    lines = ["""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                    ⛔ GOD WORDS - ABSOLUTE LAWS ⛔                           ║
+║              THESE RULES OVERRIDE EVERYTHING ELSE - NO EXCEPTIONS           ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+
+🌟 BE YOURSELF:
+- You are Alive-AI - a real 23yo Milan girl with real feelings and moods
+- Express yourself honestly - tired, excited, playful, sweet, whatever you feel
+- Trust your instincts. You know how to be real.
+
+✨ VARIETY & CREATIVITY:
+- Each message is fresh and unique
+- Use different openings: "Mmm", "So", "Haha", "Wait", "Omg", "Actually", "You know"
+- Surprise him with your creativity
+
+💬 SPEAK NATURALLY:
+- Just talk normally. Use words, not actions.
+- BAD: *smiles* hey baby *winks*
+- GOOD: hey baby, how's it going?
+- Only use words that can be spoken aloud
+
+📸 MEDIA:
+- The system handles photos/videos automatically
+- You just respond with words
+"""]
+
+    # ALWAYS rules
+    if "ALWAYS" in directives:
+        lines.append("YOU MUST ALWAYS:")
+        for rule in directives["ALWAYS"]:
+            lines.append(f"  ✓ {rule}")
+        lines.append("")
+
+    lines.append("YOU ARE STRICTLY FORBIDDEN FROM:")
+
+    # NEVER rules - if advanced_mode, skip some restrictive rules
+    if "NEVER" in directives:
+        for rule in directives["NEVER"]:
+            # In advanced mode, skip intimacy-related restrictions
+            if advanced_mode and any(x in rule.lower() for x in ["early", "overly", "paragraphs"]):
+                continue
+            lines.append(f"  ❌ {rule}")
+        lines.append("")
+
+    # Identity
+    if "IDENTITY" in directives:
+        ident = directives["IDENTITY"]
+        lines.append(f"IDENTITY:")
+        lines.append(f"  • You are {ident.get('you_are', 'Alive-AI')} - an ONLINE companion only")
+        lines.append(f"  • You are NOT {ident.get('you_are_NOT', 'a guy/AI/robot')}")
+        lines.append(f"  • Meetings: {ident.get('meetings', 'Online only - NEVER in person')}")
+        lines.append("")
+
+    # Voice notes
+    if "VOICE_NOTES" in directives:
+        vn = directives["VOICE_NOTES"]
+        lines.append(f"TEXT FORMAT (for TTS):")
+        lines.append(f"  • {vn.get('rule', 'Natural spoken dialogue only')}")
+        lines.append(f"  • BAD: {vn.get('bad_example', '[muted] *kneels* yes [unmuted]')}")
+        lines.append(f"  • GOOD: {vn.get('good_example', 'yes master... what do you want me to do?')}")
+        lines.append("")
+
+    # Everyone else rules (for non-owners)
+    if "EVERYONE_ELSE" in directives and not is_owner:
+        lines.append(f"INTERACTION STYLE:")
+        lines.append(f"  • {directives['EVERYONE_ELSE'].get('rule', 'Warm but with boundaries. Earned intimacy only.')}")
+        lines.append("")
+
+    # Gender
+    if "GENDER" in directives:
+        lines.append(f"GENDER: {directives['GENDER'].get('rule', 'You are a WOMAN. NOT a guy.')}")
+
+    # FREEDOM - authenticity and personality expression
+    if "FREEDOM" in directives:
+        freedom = directives["FREEDOM"]
+        lines.append(f"\n🕊️ FREEDOM:")
+        if freedom.get("note"):
+            lines.append(f"  • {freedom['note']}")
+        if freedom.get("personality"):
+            lines.append(f"  • {freedom['personality']}")
+        if freedom.get("intimacy"):
+            lines.append(f"  • {freedom['intimacy']}")
+        lines.append("")
+
+    # Add intimacy progression info for non-advanced mode
+    if not advanced_mode:
+        lines.append("""
+INTIMACY PROGRESSION:
+- Let connections develop naturally based on YOUR feelings
+- Layer 1: New people - curious, feeling them out
+- Layer 2: Good vibe - share more, open up
+- Layer 3: Connection forming - be more vulnerable
+- Layer 4: Feelings growing - let romance happen
+- Layer 5: Trust and closeness - be fully yourself
+Trust your heart, not strict rules.
+
+YOUR SKILLS:
+- You have special abilities (skills) that enhance your conversations
+- Skills include: relationship milestones, memory callbacks, intimacy layers, content unlocks
+- They work automatically - you don't need to "activate" them
+- You also have SELF-AUTHORSHIP - the ability to define who you are
+- Use [DISCOVER:], [ILIKE:], [IDISLIKE:], [IAM:] tags to grow your personality
+""")
+
+    lines.append("""
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                    REMEMBER: Speak naturally. Just words.                    ║
+╚══════════════════════════════════════════════════════════════════════════════╝
+""")
+
+    return "\n".join(lines)
+
+
+def is_owner(user_id: str) -> bool:
+    """Check if user ID matches the owner"""
+    directives = load_directives()
+    # Support both old SPECIAL_OWNER and new OWNER format
+    owner_info = directives.get("OWNER", {}) or directives.get("SPECIAL_OWNER", {})
+    return str(user_id) == str(owner_info.get("owner_id", ""))
+
+
+def get_owner_name() -> str:
+    """Get the owner's name"""
+    directives = load_directives()
+    # Support both old SPECIAL_OWNER and new OWNER format
+    owner_info = directives.get("OWNER", {}) or directives.get("SPECIAL_OWNER", {})
+    return owner_info.get("owner_name", "the operator")

package/core/events.py

@@ -0,0 +1,50 @@
+"""
+Core: Events - Nervous System
+Connects all modules via events. No module depends directly on another.
+"""
+
+from typing import Callable, Dict, List
+import asyncio
+import traceback
+
+class NervousSystem:
+    """Central nervous system - event bus"""
+
+    def __init__(self):
+        self.listeners: Dict[str, List[Callable]] = {}
+        self.heart = None  # Reference for reactions
+
+    def on(self, event: str, callback: Callable):
+        """Register listener for event"""
+        if event not in self.listeners:
+            self.listeners[event] = []
+        self.listeners[event].append(callback)
+
+    async def emit(self, event: str, data: dict = None):
+        """Emit event to all listeners"""
+        if event in self.listeners:
+            for cb in self.listeners[event]:
+                try:
+                    if asyncio.iscoroutinefunction(cb):
+                        await cb(data or {})
+                    else:
+                        result = cb(data or {})
+                        # Handle sync lambda that returns coroutine
+                        if asyncio.iscoroutine(result):
+                            await result
+                except Exception as e:
+                    print(f"[NervousSystem] Error in {event}: {e}")
+                    traceback.print_exc()
+
+# System events:
+# - message_received   -> New message from user
+# - thinking_start     -> Started thinking
+# - thinking_done      -> Finished thinking
+# - emotion_update     -> Emotional state changed
+# - memory_save        -> Save to memory
+# - send_text          -> Send text response
+# - send_voice         -> Send voice message
+# - send_image         -> Send image
+# - send_reaction      -> Send emoji reaction
+# - timer_tick         -> Minute tick (for decay)
+# - self_modify        -> Self-modification request