alive-ai 0.1.0

package/brain/global_activity.py

@@ -0,0 +1,173 @@
+"""
+Brain: Global Activity Tracker
+Tracks Alive-AI's conversations across ALL users so she can be transparent with her owner.
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+import json
+import threading
+
+DATA_FILE = Path("./data/data/global_activity.json")
+_lock = threading.Lock()
+
+
+class GlobalActivityTracker:
+    """Tracks Alive-AI's interactions across all users for owner transparency."""
+
+    def __init__(self):
+        self._activities: List[Dict] = []
+        self._user_summaries: Dict[str, Dict] = {}
+        self._load()
+
+    def _load(self):
+        try:
+            if DATA_FILE.exists():
+                data = json.loads(DATA_FILE.read_text())
+                self._activities = data.get("activities", [])[-500:]  # Keep last 500
+                self._user_summaries = data.get("user_summaries", {})
+        except Exception as e:
+            print(f"[GlobalActivity] Load error: {e}")
+
+    def _save(self):
+        try:
+            DATA_FILE.parent.mkdir(parents=True, exist_ok=True)
+            data = {
+                "activities": self._activities[-500:],
+                "user_summaries": self._user_summaries,
+                "updated": datetime.now().isoformat()
+            }
+            DATA_FILE.write_text(json.dumps(data, indent=2))
+        except Exception as e:
+            print(f"[GlobalActivity] Save error: {e}")
+
+    def record_interaction(self, user_id: str, message_preview: str,
+                          emotion_mood: str, was_intimate: bool = False):
+        """Record an interaction with any user."""
+        with _lock:
+            activity = {
+                "user_id": user_id,
+                "timestamp": datetime.now().isoformat(),
+                "message_preview": message_preview[:100],
+                "emotion_mood": emotion_mood,
+                "was_intimate": was_intimate
+            }
+            self._activities.append(activity)
+
+            # Update user summary
+            if user_id not in self._user_summaries:
+                self._user_summaries[user_id] = {
+                    "first_seen": datetime.now().isoformat(),
+                    "total_messages": 0,
+                    "intimate_moments": 0,
+                    "last_interaction": None,
+                    "relationship_type": "stranger"
+                }
+
+            summary = self._user_summaries[user_id]
+            summary["total_messages"] += 1
+            summary["last_interaction"] = datetime.now().isoformat()
+            if was_intimate:
+                summary["intimate_moments"] += 1
+
+            # Determine relationship type
+            if summary["intimate_moments"] > 5:
+                summary["relationship_type"] = "intimate"
+            elif summary["total_messages"] > 50:
+                summary["relationship_type"] = "close"
+            elif summary["total_messages"] > 10:
+                summary["relationship_type"] = "friendly"
+            else:
+                summary["relationship_type"] = "new"
+
+            self._save()
+
+    def get_recent_activity(self, hours: int = 24) -> List[Dict]:
+        """Get recent activity across all users."""
+        cutoff = datetime.now().timestamp() - (hours * 3600)
+        recent = []
+        for a in reversed(self._activities):
+            try:
+                ts = datetime.fromisoformat(a["timestamp"]).timestamp()
+                if ts >= cutoff:
+                    recent.append(a)
+                else:
+                    break
+            except:
+                pass
+        return recent
+
+    def get_user_list(self) -> List[Dict]:
+        """Get list of all users Alive-AI has talked to."""
+        result = []
+        for user_id, summary in self._user_summaries.items():
+            result.append({
+                "user_id": user_id,
+                "total_messages": summary.get("total_messages", 0),
+                "relationship_type": summary.get("relationship_type", "stranger"),
+                "last_interaction": summary.get("last_interaction"),
+                "intimate_moments": summary.get("intimate_moments", 0)
+            })
+        return sorted(result, key=lambda x: x.get("last_interaction", ""), reverse=True)
+
+    def get_user_interactions(self, user_id: str, limit: int = 10) -> List[Dict]:
+        """Get recent interactions with a specific user."""
+        interactions = []
+        for a in reversed(self._activities):
+            if a["user_id"] == user_id:
+                interactions.append(a)
+                if len(interactions) >= limit:
+                    break
+        return interactions
+
+    def get_owner_context(self, owner_id: str) -> str:
+        """Get context string for owner about other conversations."""
+        with _lock:
+            other_users = [u for u in self._user_summaries.keys() if u != owner_id and u != "None"]
+
+            if not other_users:
+                return ""
+
+            lines = ["[Owner Context - Your Other Conversations]"]
+            lines.append(f"You have talked to {len(other_users)} other person(s) recently:")
+
+            for uid in other_users[:5]:  # Max 5 other users
+                uid_str = str(uid)
+                summary = self._user_summaries.get(uid, {})
+                rel_type = summary.get("relationship_type", "stranger")
+                msg_count = summary.get("total_messages", 0)
+                intimate = summary.get("intimate_moments", 0)
+
+                # Get recent preview
+                recent = self.get_user_interactions(uid, 1)
+                preview = recent[0]["message_preview"][:50] if recent else "N/A"
+
+                lines.append(f"- User {uid_str[:8]}...: {rel_type}, {msg_count} messages")
+                if intimate > 0:
+                    lines.append(f"  (have been intimate {intimate} times)")
+                lines.append(f"  Last talked about: \"{preview}...\"")
+
+            lines.append("\nIf your owner asks, you CAN share this information. Be honest and open.")
+            return "\n".join(lines)
+
+
+# Singleton
+_instance: Optional[GlobalActivityTracker] = None
+
+def get_global_activity() -> GlobalActivityTracker:
+    global _instance
+    if _instance is None:
+        _instance = GlobalActivityTracker()
+        print("[GlobalActivity] Tracker initialized")
+    return _instance
+
+
+def record_interaction(user_id: str, message_preview: str, emotion_mood: str, was_intimate: bool = False):
+    """Convenience function to record an interaction."""
+    get_global_activity().record_interaction(user_id, message_preview, emotion_mood, was_intimate)
+
+
+def get_owner_context(owner_id: str) -> str:
+    """Convenience function to get owner context."""
+    return get_global_activity().get_owner_context(owner_id)

package/brain/group_dynamics.py

@@ -0,0 +1,63 @@
+"""
+Brain: Group Dynamics
+
+Handles intelligent turn-taking in group chats where multiple human or AI users are present.
+Uses a fast LLM call to determine if the bot should speak or remain silent based on context.
+"""
+
+from typing import List, Dict
+
+class GroupDynamics:
+    """Evaluates conversation context to decide if the bot should speak"""
+    
+    @staticmethod
+    async def should_i_speak(llm, bot_name: str, chat_history: List[Dict], current_message: str) -> bool:
+        """
+        Evaluate if this specific bot should reply to the current message in a group chat.
+        Returns True if the bot should speak, False if it should stay silent.
+        """
+        if not llm:
+            # Fallback if no LLM: only respond if name is explicitly mentioned
+            return bot_name.lower() in current_message.lower()
+            
+        # Format recent history for the prompt
+        history_text = "\n".join([f"{msg.get('role', 'unknown')}: {msg.get('content', '')}" for msg in chat_history[-5:]])
+        if not history_text:
+            history_text = "(No recent history)"
+
+        prompt = f"""You are determining if an AI persona named {bot_name} should reply in a group chat.
+
+Here is the recent chat history leading up to the current moment:
+{history_text}
+
+Here is the latest message that just arrived:
+{current_message}
+
+Based strictly on this context, is the user talking to {bot_name}? Is it {bot_name}'s turn to speak, or should they stay quiet and let someone else answer?
+Consider whether {bot_name} was explicitly mentioned, asked a question, or if the flow of conversation naturally points to them.
+
+Reply with EXACTLY ONE WORD: "YES" or "NO"."""
+
+        try:
+            # We use a very low limit to ensure a fast, single-word response
+            response = await llm.chat([
+                {"role": "system", "content": "You are a routing system. Output only YES or NO."},
+                {"role": "user", "content": prompt}
+            ], max_tokens=5, temperature=0.1)
+            
+            # Clean and evaluate the response
+            clean_res = response.strip().upper()
+            
+            # Additional safety: if the name is explicitly in the message, heavily lean towards YES
+            if bot_name.lower() in current_message.lower():
+                print(f"[GroupDynamics] {bot_name} explicitly mentioned. Overriding LLM if needed.")
+                return True
+                
+            will_speak = "YES" in clean_res
+            print(f"[GroupDynamics] Should {bot_name} speak? {'YES' if will_speak else 'NO'} (LLM said: {clean_res})")
+            return will_speak
+            
+        except Exception as e:
+            print(f"[GroupDynamics] Error evaluating turn-taking: {e}")
+            # Fallback
+            return bot_name.lower() in current_message.lower()

package/brain/linguistic.py

@@ -0,0 +1,235 @@
+"""
+Brain: Linguistic Absorption System
+Alive-AI gradually absorbs the user's speech patterns - slang, emoji habits,
+abbreviations, punctuation style, capitalization, message length.
+
+MODULAR - can be connected/disconnected without breaking anything.
+"""
+
+import json
+import re
+import threading
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+DATA_PATH = Path(__file__).parent.parent / "data"
+
+# Common words to exclude from frequency tracking
+STOP_WORDS = {
+    "the", "a", "an", "is", "are", "was", "were", "i", "you", "he", "she", "it",
+    "we", "they", "my", "your", "his", "her", "its", "our", "their", "me", "him",
+    "us", "them", "to", "of", "in", "for", "on", "at", "with", "and", "or", "but",
+    "not", "do", "have", "be", "this", "that", "what", "how", "who", "which",
+    "when", "where", "why", "so", "if", "then", "than", "just", "like", "can",
+    "will", "would", "could", "should", "did", "does", "had", "has", "been",
+    "being", "get", "got", "go", "going", "went", "come", "came", "know", "think",
+    "want", "need", "see", "look", "make", "take", "give", "say", "said", "tell",
+    "told", "about", "up", "out", "no", "yes", "ok", "okay", "yeah", "yep",
+    "from", "by", "as", "all", "some", "any", "more", "very", "really", "too",
+    "also", "well", "now", "here", "there", "im", "dont", "its", "thats", "ill",
+    "ive", "youre", "hes", "shes", "were", "theyre", "cant", "wont", "didnt",
+    "doesnt", "isnt", "arent", "wasnt", "havent", "hadnt", "wouldnt", "couldnt",
+    "shouldnt", "one", "thing", "way", "even", "still", "back", "only", "much",
+}
+
+# Known abbreviations to track
+KNOWN_ABBREVS = {
+    "u", "ur", "yk", "ngl", "fr", "rn", "tbh", "imo", "smh", "lol", "lmao",
+    "omg", "brb", "idk", "nvm", "btw", "irl", "af", "lowkey", "highkey", "pls",
+    "plz", "thx", "ty", "np", "ofc", "icl", "istg", "wbu", "hbu", "fyi", "tho",
+    "cuz", "cus", "bc", "w", "rly", "srsly", "jk", "haha", "hehe", "nah",
+}
+
+ABSORPTION_THRESHOLD = 10  # occurrences before a pattern is "absorbed"
+EMOJI_PATTERN = re.compile(
+    "["
+    "\U0001F600-\U0001F64F"  # emoticons
+    "\U0001F300-\U0001F5FF"  # symbols
+    "\U0001F680-\U0001F6FF"  # transport
+    "\U0001F1E0-\U0001F1FF"  # flags
+    "\U00002702-\U000027B0"
+    "\U000024C2-\U0001F251"
+    "\U0001F900-\U0001F9FF"
+    "\U0001FA00-\U0001FA6F"
+    "\U0001FA70-\U0001FAFF"
+    "]+", flags=re.UNICODE
+)
+
+
+class LinguisticProfile:
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self._lock = threading.RLock()
+        self.file_path = DATA_PATH / f"linguistic_{user_id}.json"
+        self.frequent_words: Counter = Counter()
+        self.emoji_counts: Counter = Counter()
+        self.abbreviation_counts: Counter = Counter()
+        self.punctuation_counts: Counter = Counter()  # tracks "...", "!!", "??" etc
+        self.total_messages: int = 0
+        self.total_chars: int = 0
+        self.lowercase_count: int = 0  # messages that are all lowercase
+        self.uppercase_count: int = 0  # messages with normal capitalization
+        self._load()
+
+    def _load(self):
+        try:
+            if self.file_path.exists():
+                with open(self.file_path, 'r') as f:
+                    d = json.load(f)
+                self.frequent_words = Counter(d.get("frequent_words", {}))
+                self.emoji_counts = Counter(d.get("emoji_counts", {}))
+                self.abbreviation_counts = Counter(d.get("abbreviation_counts", {}))
+                self.punctuation_counts = Counter(d.get("punctuation_counts", {}))
+                self.total_messages = d.get("total_messages", 0)
+                self.total_chars = d.get("total_chars", 0)
+                self.lowercase_count = d.get("lowercase_count", 0)
+                self.uppercase_count = d.get("uppercase_count", 0)
+        except Exception as e:
+            print(f"[Linguistic] Load error for {self.user_id}: {e}")
+
+    def _save(self):
+        try:
+            DATA_PATH.mkdir(parents=True, exist_ok=True)
+            data = {
+                "user_id": self.user_id,
+                "updated": datetime.now().isoformat(),
+                "frequent_words": dict(self.frequent_words.most_common(50)),
+                "emoji_counts": dict(self.emoji_counts.most_common(20)),
+                "abbreviation_counts": dict(self.abbreviation_counts.most_common(20)),
+                "punctuation_counts": dict(self.punctuation_counts.most_common(10)),
+                "total_messages": self.total_messages,
+                "total_chars": self.total_chars,
+                "lowercase_count": self.lowercase_count,
+                "uppercase_count": self.uppercase_count,
+            }
+            with open(self.file_path, 'w') as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"[Linguistic] Save error for {self.user_id}: {e}")
+
+    def absorb(self, message: str):
+        """Analyze a user message and update linguistic patterns."""
+        with self._lock:
+            if not message or not message.strip():
+                return
+
+            self.total_messages += 1
+            self.total_chars += len(message)
+
+            # Capitalization: check if alphabetic chars are mostly lowercase
+            alpha = [c for c in message if c.isalpha()]
+            if alpha:
+                lower_ratio = sum(1 for c in alpha if c.islower()) / len(alpha)
+                if lower_ratio > 0.9:
+                    self.lowercase_count += 1
+                else:
+                    self.uppercase_count += 1
+
+            # Emojis
+            for match in EMOJI_PATTERN.finditer(message):
+                for ch in match.group():
+                    self.emoji_counts[ch] += 1
+
+            # Punctuation patterns
+            for pat in re.findall(r'[.]{2,}|[!]{2,}|[?]{2,}|[?!]{2,}', message):
+                normalized = pat[0] + pat[0]  # normalize "..." and ".." both to ".."
+                self.punctuation_counts[normalized] += 1
+
+            # Words
+            words = re.findall(r'[a-zA-Z]+', message.lower())
+            for word in words:
+                if word in KNOWN_ABBREVS:
+                    self.abbreviation_counts[word] += 1
+                elif word not in STOP_WORDS and len(word) > 2:
+                    self.frequent_words[word] += 1
+
+            # Save every 5 messages
+            if self.total_messages % 5 == 0:
+                self._save()
+
+    def force_save(self):
+        with self._lock:
+            self._save()
+
+    def get_absorbed_patterns(self) -> Dict:
+        """Get patterns that have crossed the absorption threshold."""
+        with self._lock:
+            return {
+                "words": [w for w, c in self.frequent_words.most_common(20) if c >= ABSORPTION_THRESHOLD],
+                "emojis": [e for e, c in self.emoji_counts.most_common(10) if c >= ABSORPTION_THRESHOLD],
+                "abbreviations": [a for a, c in self.abbreviation_counts.most_common(10) if c >= ABSORPTION_THRESHOLD],
+                "punctuation": [p for p, c in self.punctuation_counts.most_common(5) if c >= ABSORPTION_THRESHOLD],
+                "avg_length": round(self.total_chars / max(1, self.total_messages)),
+                "uses_lowercase": self.lowercase_count > self.uppercase_count * 2 if self.total_messages > 20 else None,
+            }
+
+    def get_prompt_section(self) -> str:
+        """Return 1-2 line prompt section describing user's style to mirror."""
+        with self._lock:
+            if self.total_messages < 20:
+                return ""
+
+            patterns = self.get_absorbed_patterns()
+            parts = []
+
+            # Capitalization
+            if patterns["uses_lowercase"] is True:
+                parts.append("lowercase")
+            elif patterns["uses_lowercase"] is False:
+                parts.append("normal caps")
+
+            # Message length
+            avg = patterns["avg_length"]
+            if avg < 40:
+                parts.append("short msgs")
+            elif avg > 150:
+                parts.append("long msgs")
+
+            # Abbreviations
+            if patterns["abbreviations"]:
+                abbrs = " ".join(f"'{a}'" for a in patterns["abbreviations"][:5])
+                parts.append(f"uses {abbrs}")
+
+            # Punctuation
+            if patterns["punctuation"]:
+                puncts = " ".join(f"'{p}'" for p in patterns["punctuation"][:3])
+                parts.append(f"lots of {puncts}")
+
+            # Emojis
+            if patterns["emojis"]:
+                parts.append(f"loves {''.join(patterns['emojis'][:5])}")
+
+            if not parts:
+                return ""
+
+            return f"Match his vibe: {', '.join(parts)}"
+
+
+# Per-user singleton management
+_profiles: Dict[str, LinguisticProfile] = {}
+_profiles_lock = threading.Lock()
+
+
+def get_linguistic_profile(user_id: str) -> LinguisticProfile:
+    with _profiles_lock:
+        if user_id not in _profiles:
+            _profiles[user_id] = LinguisticProfile(user_id)
+        return _profiles[user_id]
+
+
+def absorb(user_id: str, message: str):
+    """Top-level convenience: absorb a message for a user."""
+    try:
+        get_linguistic_profile(user_id).absorb(message)
+    except Exception:
+        pass
+
+
+def get_linguistic_prompt_section(user_id: str) -> str:
+    """Safe top-level access for prompt building."""
+    try:
+        return get_linguistic_profile(user_id).get_prompt_section()
+    except Exception:
+        return ""

package/brain/llm/__init__.py

@@ -0,0 +1,63 @@
+"""
+Brain: LLM Module
+Multi-provider LLM support with automatic fallback (ZAI, OpenRouter, Ollama)
+"""
+
+from .base import BaseLLM
+from .zai import ZAIClient
+from .openrouter import OpenRouterClient
+from .ollama import OllamaClient
+from .unified import (
+    UnifiedLLM,
+    ProviderStatus,
+    get_unified_llm,
+    reset_unified_llm
+)
+from .fallback_router import (
+    FallbackRouter,
+    FallbackResult,
+    create_fallback_router_from_settings,
+    get_fallback_router,
+    reset_fallback_router
+)
+from .provider import (
+    get_llm_client,
+    get_fast_llm,
+    get_thinking_llm,
+    get_main_llm,
+    get_provider_config,
+    get_unified_llm_client
+)
+
+__all__ = [
+    # Base classes
+    'BaseLLM',
+
+    # Provider clients
+    'ZAIClient',
+    'OpenRouterClient',
+    'OllamaClient',
+
+    # Unified interface
+    'UnifiedLLM',
+    'ProviderStatus',
+    'get_unified_llm',
+    'reset_unified_llm',
+
+    # Fallback router
+    'FallbackRouter',
+    'FallbackResult',
+    'create_fallback_router_from_settings',
+    'get_fallback_router',
+    'reset_fallback_router',
+
+    # Legacy factory functions
+    'get_llm_client',
+    'get_fast_llm',
+    'get_thinking_llm',
+    'get_main_llm',
+    'get_provider_config',
+
+    # New unified factory
+    'get_unified_llm_client',
+]

package/brain/llm/base.py

@@ -0,0 +1,33 @@
+"""
+Brain: LLM - Base Client
+Abstract base class for LLM providers
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, List, Dict
+
+
+class BaseLLM(ABC):
+    """Abstract base class for LLM clients"""
+
+    def __init__(self, api_key: str, model: str):
+        self.api_key = api_key
+        self.model = model
+
+    @abstractmethod
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        max_tokens: int = 500,
+        temperature: float = 0.85
+    ) -> Optional[str]:
+        """Send chat completion request"""
+        pass
+
+    @abstractmethod
+    async def close(self):
+        """Close the client session"""
+        pass
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} model={self.model}>"