alive-ai 0.1.0

package/core/user_manager.py

@@ -0,0 +1,306 @@
+"""
+Core: User Manager
+Manages per-user memory instances and settings.
+Each user gets their own memory, intimacy state, and content unlocks.
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, Optional, Any
+from datetime import datetime
+
+
+class UserManager:
+    """
+    Manages per-user state and memory paths.
+    Provides user isolation for memory, intimacy layers, and content unlocks.
+    """
+
+    def __init__(self, base_path: Path = None):
+        """
+        Initialize the User Manager.
+
+        Args:
+            base_path: Base path for data storage (defaults to /app/data or local data/)
+        """
+        if base_path:
+            self.base_path = base_path
+        else:
+            # Try Docker path first, then local development path
+            docker_path = Path("/app/data")
+            local_path = Path(__file__).parent.parent / "data"
+            self.base_path = docker_path if docker_path.exists() else local_path
+
+        self.users_path = self.base_path / "users"
+        self.users_path.mkdir(parents=True, exist_ok=True)
+
+        # Cache for user data paths
+        self._user_paths: Dict[str, Dict[str, Path]] = {}
+
+        # Owner settings cache
+        self._owner_settings: Optional[dict] = None
+
+    def get_user_path(self, user_id: str) -> Path:
+        """
+        Get the base path for a user's data.
+
+        Args:
+            user_id: The user's Telegram ID
+
+        Returns:
+            Path to the user's data directory
+        """
+        user_path = self.users_path / str(user_id)
+        user_path.mkdir(parents=True, exist_ok=True)
+        return user_path
+
+    def get_user_paths(self, user_id: str) -> Dict[str, Path]:
+        """
+        Get all paths for a user's data files.
+
+        Args:
+            user_id: The user's Telegram ID
+
+        Returns:
+            Dictionary with paths for all user data files
+        """
+        if user_id in self._user_paths:
+            return self._user_paths[user_id]
+
+        base = self.get_user_path(user_id)
+        paths = {
+            "base": base,
+            "conversations": base / "conversations",
+            "facts": base / "facts.json",
+            "intimacy_layers": base / "intimacy_layers.json",
+            "content_unlocks": base / "content_unlocks.json",
+            "summaries": base / "summaries",
+        }
+
+        # Ensure directories exist
+        paths["conversations"].mkdir(parents=True, exist_ok=True)
+        paths["summaries"].mkdir(parents=True, exist_ok=True)
+
+        self._user_paths[user_id] = paths
+        return paths
+
+    # -------------------------------------------------------------------------
+    # Owner Settings
+    # -------------------------------------------------------------------------
+
+    def _load_owner_settings(self) -> dict:
+        """Load owner settings from file"""
+        if self._owner_settings is not None:
+            return self._owner_settings
+
+        settings_path = self.base_path / "owner_settings.json"
+        if settings_path.exists():
+            try:
+                self._owner_settings = json.loads(settings_path.read_text())
+            except (json.JSONDecodeError, Exception):
+                self._owner_settings = {}
+        else:
+            self._owner_settings = {}
+
+        return self._owner_settings
+
+    def _save_owner_settings(self, settings: dict):
+        """Save owner settings to file"""
+        settings_path = self.base_path / "owner_settings.json"
+        settings["updated_at"] = datetime.now().isoformat()
+        settings_path.write_text(json.dumps(settings, indent=2))
+        self._owner_settings = settings
+
+    def is_advanced_enabled(self) -> bool:
+        """
+        Check if owner has /advanced mode enabled (advanced access).
+
+        Returns:
+            True if advanced mode is enabled
+        """
+        settings = self._load_owner_settings()
+        return settings.get("advanced_enabled", False)
+
+    def set_advanced_enabled(self, enabled: bool) -> bool:
+        """
+        Set the advanced mode status.
+
+        Args:
+            enabled: Whether to enable or disable advanced mode
+
+        Returns:
+            The new enabled state
+        """
+        settings = self._load_owner_settings()
+        settings["advanced_enabled"] = enabled
+        self._save_owner_settings(settings)
+        return enabled
+
+    def toggle_advanced(self) -> bool:
+        """
+        Toggle the advanced mode status.
+
+        Returns:
+            The new enabled state
+        """
+        current = self.is_advanced_enabled()
+        return self.set_advanced_enabled(not current)
+
+    def get_owner_settings(self) -> dict:
+        """
+        Get all owner settings.
+
+        Returns:
+            Dictionary with all owner settings
+        """
+        return self._load_owner_settings().copy()
+
+    # -------------------------------------------------------------------------
+    # User Existence & Migration
+    # -------------------------------------------------------------------------
+
+    def user_exists(self, user_id: str) -> bool:
+        """
+        Check if a user has existing data.
+
+        Args:
+            user_id: The user's Telegram ID
+
+        Returns:
+            True if user has any data
+        """
+        user_path = self.get_user_path(user_id)
+        facts_path = user_path / "facts.json"
+        conv_path = user_path / "conversations"
+
+        return facts_path.exists() or (conv_path.exists() and any(conv_path.glob("*.jsonl")))
+
+    def get_all_users(self) -> list:
+        """
+        Get list of all user IDs that have data.
+
+        Returns:
+            List of user ID strings
+        """
+        users = []
+        if self.users_path.exists():
+            for user_dir in self.users_path.iterdir():
+                if user_dir.is_dir() and user_dir.name.isdigit():
+                    users.append(user_dir.name)
+        return users
+
+    def migrate_legacy_data(self, owner_id: str):
+        """
+        Migrate legacy data from the old flat structure to per-user structure.
+
+        Args:
+            owner_id: The owner's Telegram ID to migrate data to
+        """
+        import shutil
+
+        legacy_paths = {
+            "conversations": self.base_path / "conversations",
+            "facts": self.base_path / "facts.json",
+            "intimacy_layers": self.base_path / "intimacy_layers.json",
+            "content_unlocks": self.base_path / "content_unlocks.json",
+            "summaries": self.base_path / "summaries",
+        }
+
+        user_paths = self.get_user_paths(owner_id)
+
+        # Migrate conversations
+        if legacy_paths["conversations"].exists():
+            for conv_file in legacy_paths["conversations"].glob("*.jsonl"):
+                dest = user_paths["conversations"] / conv_file.name
+                if not dest.exists():
+                    shutil.copy2(conv_file, dest)
+                    print(f"[UserManager] Migrated conversation: {conv_file.name}")
+
+        # Migrate facts.json
+        if legacy_paths["facts"].exists() and not user_paths["facts"].exists():
+            shutil.copy2(legacy_paths["facts"], user_paths["facts"])
+            print(f"[UserManager] Migrated facts.json")
+
+        # Migrate intimacy_layers.json
+        if legacy_paths["intimacy_layers"].exists() and not user_paths["intimacy_layers"].exists():
+            shutil.copy2(legacy_paths["intimacy_layers"], user_paths["intimacy_layers"])
+            print(f"[UserManager] Migrated intimacy_layers.json")
+
+        # Migrate content_unlocks.json
+        if legacy_paths["content_unlocks"].exists() and not user_paths["content_unlocks"].exists():
+            shutil.copy2(legacy_paths["content_unlocks"], user_paths["content_unlocks"])
+            print(f"[UserManager] Migrated content_unlocks.json")
+
+        # Migrate summaries
+        if legacy_paths["summaries"].exists():
+            for summary_file in legacy_paths["summaries"].glob("*.json"):
+                dest = user_paths["summaries"] / summary_file.name
+                if not dest.exists():
+                    shutil.copy2(summary_file, dest)
+                    print(f"[UserManager] Migrated summary: {summary_file.name}")
+
+        print(f"[UserManager] Migration complete for user {owner_id}")
+
+    # -------------------------------------------------------------------------
+    # User Stats
+    # -------------------------------------------------------------------------
+
+    def get_user_stats(self, user_id: str) -> Dict[str, Any]:
+        """
+        Get statistics for a user.
+
+        Args:
+            user_id: The user's Telegram ID
+
+        Returns:
+            Dictionary with user statistics
+        """
+        paths = self.get_user_paths(user_id)
+
+        stats = {
+            "user_id": user_id,
+            "exists": self.user_exists(user_id),
+            "has_facts": paths["facts"].exists(),
+            "has_intimacy": paths["intimacy_layers"].exists(),
+            "has_unlocks": paths["content_unlocks"].exists(),
+            "conversation_files": 0,
+            "summary_files": 0,
+        }
+
+        if paths["conversations"].exists():
+            stats["conversation_files"] = len(list(paths["conversations"].glob("*.jsonl")))
+
+        if paths["summaries"].exists():
+            stats["summary_files"] = len(list(paths["summaries"].glob("*.json")))
+
+        return stats
+
+
+# Global singleton instance
+_user_manager: Optional[UserManager] = None
+
+
+def get_user_manager(base_path: Path = None) -> UserManager:
+    """
+    Get the global UserManager instance.
+
+    Args:
+        base_path: Base path for data storage (only used on first call)
+
+    Returns:
+        The UserManager singleton
+    """
+    global _user_manager
+    if _user_manager is None:
+        _user_manager = UserManager(base_path)
+    return _user_manager
+
+
+def is_advanced_enabled() -> bool:
+    """
+    Convenience function to check if advanced mode is enabled.
+
+    Returns:
+        True if advanced mode is enabled
+    """
+    return get_user_manager().is_advanced_enabled()

package/core/user_tracker.py

@@ -0,0 +1,144 @@
+"""
+Core: User Tracker
+Track active users for proactive messaging and multi-user support
+"""
+
+import time
+from typing import Dict, Optional, List
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ActiveUser:
+    """Represents an active user conversation"""
+    user_id: str
+    chat_id: int
+    last_interaction: float = field(default_factory=time.time)
+    message_count: int = 0
+    pet_name: str = "babe"
+
+    def touch(self):
+        """Update last interaction time"""
+        self.last_interaction = time.time()
+        self.message_count += 1
+
+    @property
+    def silence_minutes(self) -> float:
+        """How long since last interaction"""
+        return (time.time() - self.last_interaction) / 60
+
+
+class UserTracker:
+    """
+    Tracks active users for proactive messaging.
+    Stores user_id, chat_id, and conversation metadata.
+    """
+
+    # Users inactive for this long are considered "gone"
+    INACTIVE_AFTER_MINUTES = 120
+
+    # Users inactive for this long are removed from tracking
+    FORGET_AFTER_HOURS = 48
+
+    def __init__(self):
+        self._users: Dict[str, ActiveUser] = {}
+        self._chat_to_user: Dict[int, str] = {}  # chat_id -> user_id mapping
+
+    def register_message(self, user_id: str, chat_id: int, pet_name: str = "babe"):
+        """Register that a message was received from this user"""
+        if not user_id:
+            return
+
+        user_id = str(user_id)
+
+        if user_id in self._users:
+            self._users[user_id].touch()
+            self._users[user_id].chat_id = chat_id
+            self._users[user_id].pet_name = pet_name
+        else:
+            self._users[user_id] = ActiveUser(
+                user_id=user_id,
+                chat_id=chat_id,
+                pet_name=pet_name
+            )
+            print(f"[UserTracker] New user registered: {user_id}")
+
+        # Update chat_id mapping
+        self._chat_to_user[chat_id] = user_id
+
+    def get_user(self, user_id: str) -> Optional[ActiveUser]:
+        """Get user by user_id"""
+        return self._users.get(str(user_id))
+
+    def get_user_by_chat(self, chat_id: int) -> Optional[ActiveUser]:
+        """Get user by chat_id"""
+        user_id = self._chat_to_user.get(chat_id)
+        if user_id:
+            return self._users.get(user_id)
+        return None
+
+    def get_active_users(self, within_minutes: float = None) -> List[ActiveUser]:
+        """
+        Get list of users who are still considered active.
+        within_minutes: only users who messaged within this time (default: INACTIVE_AFTER_MINUTES)
+        """
+        threshold = (within_minutes or self.INACTIVE_AFTER_MINUTES) * 60
+        now = time.time()
+        return [u for u in self._users.values() if (now - u.last_interaction) < threshold]
+
+    def get_users_for_follow_up(self, min_silence_minutes: float = 30, max_silence_minutes: float = 180) -> List[ActiveUser]:
+        """
+        Get users who might need a follow-up message.
+        - Have been silent for at least min_silence_minutes
+        - Haven't been silent for more than max_silence_minutes (they're probably gone)
+        """
+        result = []
+        for user in self._users.values():
+            silence = user.silence_minutes
+            if min_silence_minutes <= silence <= max_silence_minutes:
+                result.append(user)
+        return result
+
+    def cleanup_stale(self):
+        """Remove users who have been inactive too long"""
+        threshold = self.FORGET_AFTER_HOURS * 3600
+        now = time.time()
+        stale = [uid for uid, u in self._users.items() if (now - u.last_interaction) > threshold]
+        for uid in stale:
+            chat_id = self._users[uid].chat_id
+            del self._users[uid]
+            if chat_id in self._chat_to_user:
+                del self._chat_to_user[chat_id]
+            print(f"[UserTracker] Removed stale user: {uid}")
+
+    @property
+    def total_users(self) -> int:
+        return len(self._users)
+
+    def get_status(self) -> dict:
+        """Get status summary for debugging"""
+        return {
+            "total_users": self.total_users,
+            "active_users": len(self.get_active_users()),
+            "users_needing_follow_up": len(self.get_users_for_follow_up()),
+            "users": [
+                {
+                    "user_id": u.user_id,
+                    "silence_minutes": round(u.silence_minutes, 1),
+                    "message_count": u.message_count
+                }
+                for u in self._users.values()
+            ]
+        }
+
+
+# Global instance
+_tracker: Optional[UserTracker] = None
+
+
+def get_user_tracker() -> UserTracker:
+    """Get the global user tracker instance"""
+    global _tracker
+    if _tracker is None:
+        _tracker = UserTracker()
+    return _tracker

package/demo/index.html

@@ -0,0 +1,144 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Alive-AI Demo Dashboard</title>
+  <style>
+    :root {
+      color-scheme: dark;
+      --bg: #080b0f;
+      --panel: #111821;
+      --line: #263445;
+      --text: #f5f7fb;
+      --muted: #9aa8b7;
+      --green: #41f0a1;
+      --pink: #ff5c8a;
+      --yellow: #ffcf5a;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      background: var(--bg);
+      color: var(--text);
+      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      letter-spacing: 0;
+    }
+    .app {
+      width: min(980px, calc(100vw - 32px));
+      margin: 0 auto;
+      padding: 28px 0;
+    }
+    header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      margin-bottom: 18px;
+    }
+    .brand { display: flex; align-items: center; gap: 12px; }
+    .brand img { width: 42px; height: 42px; border-radius: 8px; }
+    h1 { margin: 0; font-size: 22px; }
+    .status {
+      border: 1px solid rgba(65,240,161,0.3);
+      color: var(--green);
+      padding: 8px 10px;
+      border-radius: 999px;
+      font-size: 13px;
+      font-weight: 750;
+    }
+    .grid {
+      display: grid;
+      grid-template-columns: 1.1fr 0.9fr;
+      gap: 16px;
+    }
+    .panel {
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 16px;
+    }
+    .panel h2 {
+      margin: 0 0 14px;
+      font-size: 15px;
+      color: var(--muted);
+      text-transform: uppercase;
+    }
+    .metric { margin-bottom: 14px; }
+    .metric label { display: flex; justify-content: space-between; color: var(--muted); font-size: 13px; margin-bottom: 8px; }
+    .bar { height: 11px; border-radius: 999px; overflow: hidden; background: #25313d; }
+    .fill { height: 100%; width: 50%; border-radius: inherit; background: var(--green); transition: width 500ms ease; }
+    .fill.pink { background: var(--pink); }
+    .fill.yellow { background: var(--yellow); }
+    .thought {
+      min-height: 132px;
+      display: flex;
+      align-items: center;
+      font-size: 22px;
+      line-height: 1.35;
+    }
+    .counters { display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px; }
+    .counter { border: 1px solid var(--line); border-radius: 8px; padding: 14px; background: #0c131a; }
+    .counter strong { display: block; font-size: 28px; color: var(--green); }
+    .counter span { color: var(--muted); font-size: 13px; }
+    @media (max-width: 720px) {
+      .grid { grid-template-columns: 1fr; }
+      .counters { grid-template-columns: 1fr; }
+      header { align-items: flex-start; gap: 12px; flex-direction: column; }
+    }
+  </style>
+</head>
+<body>
+  <main class="app">
+    <header>
+      <div class="brand"><img src="/assets/logo.svg" alt=""><div><h1>Alive-AI Demo</h1><div id="mood">curious</div></div></div>
+      <div class="status">local dashboard preview</div>
+    </header>
+    <section class="grid">
+      <div class="panel">
+        <h2>Emotional State</h2>
+        <div class="metric"><label>Joy <span id="joyVal">64%</span></label><div class="bar"><div class="fill" id="joy"></div></div></div>
+        <div class="metric"><label>Trust <span id="trustVal">58%</span></label><div class="bar"><div class="fill pink" id="trust"></div></div></div>
+        <div class="metric"><label>Anticipation <span id="anticipationVal">72%</span></label><div class="bar"><div class="fill yellow" id="anticipation"></div></div></div>
+        <div class="metric"><label>Vulnerability <span id="vulnerabilityVal">34%</span></label><div class="bar"><div class="fill" id="vulnerability"></div></div></div>
+      </div>
+      <div class="panel">
+        <h2>Current Thought</h2>
+        <div class="thought" id="thought">I keep a little emotional residue from every interaction.</div>
+      </div>
+      <div class="panel">
+        <h2>Runtime Counters</h2>
+        <div class="counters">
+          <div class="counter"><strong id="memories">128</strong><span>memories</span></div>
+          <div class="counter"><strong id="impulses">42</strong><span>impulses</span></div>
+          <div class="counter"><strong>SSE</strong><span>live state</span></div>
+        </div>
+      </div>
+      <div class="panel">
+        <h2>Install</h2>
+        <pre><code>npx . setup
+npx . start</code></pre>
+      </div>
+    </section>
+  </main>
+  <script>
+    async function tick() {
+      const res = await fetch("/state");
+      const data = await res.json();
+      document.getElementById("mood").textContent = data.mood;
+      document.getElementById("thought").textContent = data.thought;
+      for (const key of Object.keys(data.emotions)) {
+        const value = data.emotions[key];
+        const bar = document.getElementById(key);
+        const label = document.getElementById(key + "Val");
+        if (bar) bar.style.width = value + "%";
+        if (label) label.textContent = value + "%";
+      }
+      document.getElementById("memories").textContent = data.counters.memories;
+      document.getElementById("impulses").textContent = data.counters.impulses;
+    }
+    tick();
+    setInterval(tick, 1000);
+  </script>
+</body>
+</html>

package/docker-compose.yml

@@ -0,0 +1,28 @@
+services:
+  alive-ai:
+    build: .
+    container_name: alive-ai
+    command: python main.py
+    env_file:
+      - .env
+    volumes:
+      - .:/app
+      - alive_ai_cache:/app/.cache
+    ports:
+      - "8080:8080"
+    depends_on:
+      - redis
+    restart: unless-stopped
+
+  redis:
+    image: redis/redis-stack-server:latest
+    container_name: alive-ai-redis
+    ports:
+      - "6379:6379"
+    volumes:
+      - alive_ai_redis:/data
+    restart: unless-stopped
+
+volumes:
+  alive_ai_cache:
+  alive_ai_redis:

package/docs/assets/logo.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" role="img" aria-labelledby="title desc">
+  <title id="title">Alive-AI logo</title>
+  <desc id="desc">A neural core wrapped by a heartbeat pulse.</desc>
+  <rect width="512" height="512" rx="112" fill="#080b0f"/>
+  <circle cx="256" cy="256" r="154" fill="none" stroke="#f5f7fb" stroke-width="12" opacity="0.18"/>
+  <path d="M86 274h72l30-70 47 148 50-201 40 123h101" fill="none" stroke="#41f0a1" stroke-width="18" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M151 335c35 48 91 77 153 69 83-11 145-84 138-168-7-91-89-160-180-150-51 6-96 36-121 80" fill="none" stroke="#ff5c8a" stroke-width="14" stroke-linecap="round"/>
+  <circle cx="256" cy="256" r="57" fill="#101820" stroke="#f5f7fb" stroke-width="10"/>
+  <circle cx="256" cy="256" r="15" fill="#41f0a1"/>
+  <circle cx="216" cy="224" r="10" fill="#ffcf5a"/>
+  <circle cx="301" cy="223" r="10" fill="#ff5c8a"/>
+  <circle cx="221" cy="295" r="10" fill="#f5f7fb"/>
+  <circle cx="300" cy="294" r="10" fill="#41f0a1"/>
+  <path d="M226 229l30 27 45-31M256 256l-35 39M256 256l44 38" fill="none" stroke="#f5f7fb" stroke-width="7" stroke-linecap="round"/>
+</svg>