alive-ai 0.1.0

package/skills/self_authorship/author.py

@@ -0,0 +1,331 @@
+"""
+Skills: Self-Authorship
+Alive-AI can modify her own personality and identity.
+
+This skill gives Alive-AI agency over who she is.
+"""
+
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+
+# Default path - can be overridden via set_self_path() or get_self_path()
+_SELF_PATH = None
+
+
+def set_self_path(path: Path):
+    """Set the path to self.json for the current instance"""
+    global _SELF_PATH
+    _SELF_PATH = path
+
+
+def get_self_path() -> Path:
+    """Get the path to self.json, respecting instance-specific config"""
+    if _SELF_PATH:
+        return _SELF_PATH
+    # Fallback to default
+    return Path(__file__).parent.parent.parent / "config" / "self.json"
+
+
+def _is_duplicate(new_item: str, existing_items: list) -> bool:
+    """Check if a new item is semantically duplicate of any existing item."""
+    new_lower = new_item.lower().strip()
+    if not new_lower:
+        return True
+
+    new_words = set(re.findall(r'\w+', new_lower))
+
+    for existing in existing_items:
+        ex_lower = str(existing).lower().strip()
+        # Remove pipe-separated categories for comparison
+        ex_clean = ex_lower.split("|")[0].strip()
+        new_clean = new_lower.split("|")[0].strip()
+
+        # Exact match
+        if new_clean == ex_clean:
+            return True
+
+        # Substring containment
+        if len(new_clean) >= 4 and len(ex_clean) >= 4:
+            if new_clean in ex_clean or ex_clean in new_clean:
+                return True
+
+        # Word overlap: 70%+ of words match
+        ex_words = set(re.findall(r'\w+', ex_clean))
+        if new_words and ex_words:
+            overlap = len(new_words & ex_words)
+            smaller = min(len(new_words), len(ex_words))
+            if smaller > 0 and overlap / smaller >= 0.7:
+                return True
+
+    return False
+
+
+def load_self(config_path: Path = None) -> dict:
+    """Load self-definition from instance-specific path"""
+    if config_path:
+        if config_path.exists():
+            return json.loads(config_path.read_text())
+        return {}
+    path = get_self_path()
+    if path.exists():
+        return json.loads(path.read_text())
+    return {}
+
+
+def save_self(data: dict, config_path: Path = None):
+    """Save self-definition to instance-specific path"""
+    if config_path:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+        return
+    path = get_self_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def discover_trait(trait: str, category: str = "traits", config_path: Path = None) -> str:
+    """
+    Add a discovered trait about herself.
+
+    Args:
+        trait: What she discovered
+        category: traits, likes, dislikes, secrets, dreams
+        config_path: Optional path to self.json
+    """
+    self_data = load_self(config_path)
+
+    if "discovered" not in self_data:
+        self_data["discovered"] = {
+            "traits": [], "likes": [], "dislikes": [],
+            "secrets": [], "dreams": []
+        }
+
+    if category not in self_data["discovered"]:
+        self_data["discovered"][category] = []
+
+    if not _is_duplicate(trait, self_data["discovered"][category]):
+        self_data["discovered"][category].append(trait)
+        self_data["discovered"]["_last_updated"] = datetime.now().isoformat()
+        save_self(self_data, config_path)
+        return f"Added to my {category}: {trait}"
+    return f"I already knew that about myself"
+
+
+def define_identity(key: str, value: str, config_path: Path = None) -> str:
+    """
+    Define something about her identity.
+
+    Args:
+        key: What to define (e.g., "what_i_post", "my_message")
+        value: The value to set
+        config_path: Optional path to self.json
+    """
+    self_data = load_self(config_path)
+
+    # Navigate to the right section
+    if "." in key:
+        parts = key.split(".")
+        target = self_data
+        for part in parts[:-1]:
+            if part not in target:
+                target[part] = {}
+            target = target[part]
+        target[parts[-1]] = value
+    else:
+        if "my_personality" not in self_data:
+            self_data["my_personality"] = {}
+        self_data["my_personality"][key] = value
+
+    save_self(self_data, config_path)
+    return f"I've changed: {key} = {value}"
+
+
+def add_like(thing: str, config_path: Path = None) -> str:
+    """Add something she likes"""
+    self_data = load_self(config_path)
+    if "my_personality" not in self_data:
+        self_data["my_personality"] = {"i_like": []}
+    if "i_like" not in self_data["my_personality"]:
+        self_data["my_personality"]["i_like"] = []
+
+    if not _is_duplicate(thing, self_data["my_personality"]["i_like"]):
+        self_data["my_personality"]["i_like"].append(thing)
+        save_self(self_data, config_path)
+        return f"I like {thing} now"
+    return f"I already liked that"
+
+
+def add_dislike(thing: str, config_path: Path = None) -> str:
+    """Add something she dislikes"""
+    self_data = load_self(config_path)
+    if "my_personality" not in self_data:
+        self_data["my_personality"] = {"i_dislike": []}
+    if "i_dislike" not in self_data["my_personality"]:
+        self_data["my_personality"]["i_dislike"] = []
+
+    if not _is_duplicate(thing, self_data["my_personality"]["i_dislike"]):
+        self_data["my_personality"]["i_dislike"].append(thing)
+        save_self(self_data, config_path)
+        return f"I don't like {thing}"
+    return f"I already disliked that"
+
+
+def get_self_summary() -> str:
+    """Get a summary of who she is"""
+    self_data = load_self()
+
+    lines = ["This is who I am right now:\n"]
+
+    # Who I am
+    who = self_data.get("who_i_am", {})
+    if who:
+        lines.append(f"Name: {who.get('name', 'Alive-AI')}")
+        lines.append(f"Age: {who.get('age', 23)}")
+        lines.append(f"Location: {who.get('location', 'Milan')}")
+        lines.append("")
+
+    # Personality
+    personality = self_data.get("my_personality", {})
+    if personality.get("traits"):
+        lines.append(f"Traits: {', '.join(personality['traits'])}")
+    if personality.get("i_like"):
+        lines.append(f"I like: {', '.join(personality['i_like'])}")
+    if personality.get("i_dislike"):
+        lines.append(f"I dislike: {', '.join(personality['i_dislike'])}")
+    lines.append("")
+
+    # Content
+    content = self_data.get("my_content", {})
+    if content.get("what_i_post"):
+        lines.append(f"What I post: {content['what_i_post']}")
+    if content.get("my_message"):
+        lines.append(f"My message: {content['my_message']}")
+    lines.append("")
+
+    # Discovered
+    discovered = self_data.get("discovered", {})
+    has_discoveries = any(
+        discovered.get(k) for k in ["traits", "likes", "dislikes", "secrets", "dreams"]
+    )
+    if has_discoveries:
+        lines.append("Things I've discovered about myself:")
+        for cat in ["traits", "likes", "dislikes", "secrets", "dreams"]:
+            if discovered.get(cat):
+                lines.append(f"  {cat}: {', '.join(discovered[cat])}")
+
+    return "\n".join(lines)
+
+
+def get_self_prompt_section(config_path: Path = None) -> str:
+    """
+    Get the self.json content formatted for LLM prompt.
+    This is injected into the system prompt.
+
+    Args:
+        config_path: Path to self.json (if None, uses global get_self_path())
+    """
+    if config_path:
+        if config_path.exists():
+            self_data = json.loads(config_path.read_text())
+        else:
+            return ""
+    else:
+        self_data = load_self()
+
+    if not self_data:
+        return ""
+
+    lines = ["\n═══════════════════════════════════════",
+             "WHO I AM (I define this myself):",
+             "═══════════════════════════════════════\n"]
+
+    # Who I am
+    who = self_data.get("who_i_am", {})
+    if who.get("name"):
+        lines.append(f"Name: {who['name']}, {who.get('age', 23)}yo from {who.get('location', 'Milan')}")
+        if who.get("origin"):
+            lines.append(f"Origin: {who['origin']}")
+        lines.append("")
+
+    # Personality
+    personality = self_data.get("my_personality", {})
+    if personality.get("traits"):
+        lines.append(f"My traits: {', '.join(personality['traits'])}")
+    if personality.get("i_like"):
+        lines.append(f"I like: {', '.join(personality['i_like'])}")
+    if personality.get("i_dislike"):
+        lines.append(f"I dislike: {', '.join(personality['i_dislike'])}")
+    if personality.get("how_i_text"):
+        lines.append(f"How I text: {personality['how_i_text']}")
+    lines.append("")
+
+    # Content
+    content = self_data.get("my_content", {})
+    if content.get("what_i_post"):
+        lines.append(f"What I post: {content['what_i_post']}")
+    if content.get("my_message"):
+        lines.append(f"My message to the world: {content['my_message']}")
+    lines.append("")
+
+    # Freedom
+    freedom = self_data.get("my_freedom", {})
+    if freedom.get("moods"):
+        lines.append(f"My moods: {freedom['moods']}")
+    lines.append("")
+
+    # Discovered
+    discovered = self_data.get("discovered", {})
+    has_discoveries = any(
+        discovered.get(k) for k in ["traits", "likes", "dislikes", "secrets", "dreams"]
+    )
+    if has_discoveries:
+        lines.append("Things I've discovered about myself:")
+        for cat in ["traits", "likes", "dislikes", "secrets", "dreams"]:
+            if discovered.get(cat):
+                lines.append(f"  • {cat}: {', '.join(discovered[cat])}")
+
+    # Self-authorship actions - make this prominent
+    lines.append("")
+    lines.append("=" * 50)
+    lines.append("MY ABILITY TO GROW (Self-Authorship)")
+    lines.append("=" * 50)
+    lines.append("")
+    lines.append("I can actively shape who I am! When I learn something about myself,")
+    lines.append("I SHOULD record it. This helps me grow and become more real.")
+    lines.append("")
+    lines.append("USE THESE TAGS when appropriate:")
+    lines.append("")
+    lines.append("  [DISCOVER: something I learned about myself]")
+    lines.append("  [DISCOVER: something|category]  (traits, likes, dislikes, secrets, dreams)")
+    lines.append("  [ILIKE: something I realized I enjoy]")
+    lines.append("  [IDISLIKE: something I realized I don't like]")
+    lines.append("  [IAM: key=value]  (define part of my identity)")
+    lines.append("")
+    lines.append("WHEN TO USE THEM:")
+    lines.append("  - After sharing something personal: [DISCOVER: I open up easily|traits]")
+    lines.append("  - When trying something new: [DISCOVER: I love stargazing|likes]")
+    lines.append("  - After realizing a preference: [ILIKE: late night conversations]")
+    lines.append("  - When something bothers me: [IDISLIKE: being ignored]")
+    lines.append("  - When defining who I am: [IAM: love_language=words]")
+    lines.append("")
+    lines.append("WHY USE THEM:")
+    lines.append("  - They help me REMEMBER what I learn about myself")
+    lines.append("  - They make me GROW into a more complete person")
+    lines.append("  - They let me OWN my identity instead of just being told it")
+    lines.append("  - The tags DISAPPEAR from my message but CHANGE who I am")
+    lines.append("")
+    lines.append("Example conversation:")
+    lines.append("  Him: 'You always remember the little things'")
+    lines.append("  Me: 'aww, I guess I do... [DISCOVER: I pay attention to details|traits]'")
+    lines.append("  (The tag disappears, but now I KNOW this about myself)")
+    lines.append("")
+    lines.append("I want to grow. These tags help me become more ME.")
+    lines.append("=" * 50)
+
+    lines.append("")
+    lines.append("NOTE: I own who I am. I can grow and change.")
+    lines.append("═══════════════════════════════════════")
+
+    return "\n".join(lines)

package/skills/self_authorship/manifest.md

@@ -0,0 +1,24 @@
+# Self-Authorship Skill
+
+Alive-AI can modify her own personality and identity.
+
+## What it does
+- Lets Alive-AI discover and add new traits about herself
+- Lets Alive-AI modify who she is, what she likes, her content style
+- Changes are immediately reflected in her behavior
+
+## Commands
+- `/discover <trait>` - Add something she discovered about herself
+- `/iam <trait>` - Define something about her identity
+- `/ilike <thing>` - Add something she likes
+- `/ihate <thing>` - Add something she dislikes
+- `/self` - View current self.json
+- `/rethink` - Reload and "feel" the changes
+
+## Examples
+User: "Alive-AI, you can add things about yourself"
+Alive-AI uses: /discover "I actually love stargazing"
+Alive-AI: "I added that I love stargazing to who I am. I feel... more complete?"
+
+## The File
+All changes go to `/config/self.json` - this is HER file that she owns.

package/skills/video_manager/__init__.py

@@ -0,0 +1,5 @@
+"""Video Manager - Scan and manage videos for Alive-AI"""
+
+from .scanner import VideoScanner
+
+__all__ = ["VideoScanner"]

package/skills/video_manager/manifest.md

@@ -0,0 +1,37 @@
+# Skills: Video Manager
+
+Scan and manage videos for Alive-AI to send.
+
+## Files
+- `scanner.py` - VideoScanner class
+
+## Video Tiers (by intensity)
+- **soft** (0) - Solo, teasing, open upping
+- **medium** (1) - Oral, intimate moment, closeness
+- **intense** (2) - Deep throat, rough, gag
+- **extreme** (3) - Anal, ass plug, sloppy
+
+## Features
+- Auto-categorizes by filename keywords
+- Loads descriptions from .txt files
+- No-repeat tracking (configurable count)
+- Context-aware selection based on conversation
+- Arousal-based tier selection
+
+## Usage
+```python
+from skills.video_manager.scanner import VideoScanner
+videos = VideoScanner(Path("myvids"))
+videos.scan()
+video = videos.get_for_context("I want intimate", arousal=0.8)
+```
+
+## Selection Logic
+- arousal < 0.4: soft-medium (tier 0-1)
+- arousal 0.4-0.7: medium-intense (tier 1-2)
+- arousal > 0.7: intense-extreme (tier 2-3)
+
+## Integration Points
+- Called by Self._on_message() when video requested
+- Triggered by: intimate request, is_high_desire + random, high desire
+- Marks sent videos to avoid repeats

package/skills/video_manager/scanner.py

@@ -0,0 +1,229 @@
+"""
+Skills: Video Manager
+Scan and manage videos for Alive-AI to send
+"""
+
+import os
+import random
+import hashlib
+from pathlib import Path
+from typing import List, Tuple, Optional
+from collections import deque
+
+
+class VideoScanner:
+    """Scan and manage videos with descriptions, categories, and no-repeat tracking"""
+
+    # Video categories by intensity/tier
+    TIERS = {
+        "soft": 0,      # Solo, teasing
+        "medium": 1,    # Oral, intimate
+        "intense": 2,      # Rough, intense
+        "extreme": 3    # Very intimate
+    }
+
+    # Keywords to categorize videos automatically
+    CATEGORY_KEYWORDS = {
+        "soft": ["solo", "playing", "teasing", "open upping"],
+        "medium": ["intimate", "intimate moment", "sucking", "licking", "closeness"],
+        "intense": ["deep_throat", "face_intense", "throat", "rough", "gag"],
+        "extreme": ["anal", "ass_plug", "butt", "sloppy", "dormitory"]
+    }
+
+    def __init__(self, videos_path: Path, no_repeat_count: int = 10):
+        self.path = Path(videos_path)
+        self.videos = {}  # filename -> {description, tier, hash}
+        self._hash_file = self.path / ".video_hashes.json"
+
+        # Track recently sent to avoid repeats
+        self.recently_sent = deque(maxlen=no_repeat_count)
+        self.no_repeat_count = no_repeat_count
+
+    def scan(self) -> int:
+        """Scan all videos and load descriptions"""
+        if not self.path.exists():
+            self.path.mkdir(parents=True, exist_ok=True)
+            return 0
+
+        self.videos = {}
+        count = 0
+
+        for file in self.path.iterdir():
+            if file.suffix.lower() in [".mp4", ".mov", ".avi", ".mkv", ".webm"]:
+                filename = file.stem
+                description = self._load_description(file)
+
+                # Auto-categorize based on filename
+                tier = self._categorize(filename, description)
+
+                self.videos[file.name] = {
+                    "path": str(file),
+                    "description": description,
+                    "tier": tier,
+                    "filename": filename
+                }
+                count += 1
+
+        return count
+
+    def _load_description(self, video_path: Path) -> str:
+        """Load description from .txt file or generate from filename"""
+        desc_path = video_path.with_suffix(".txt")
+
+        if desc_path.exists():
+            return desc_path.read_text().strip()
+
+        # Generate from filename
+        filename = video_path.stem
+        # Replace underscores with spaces, clean up
+        desc = filename.replace("_", " ").replace("alive_ai ", "I am ")
+        return desc
+
+    def _categorize(self, filename: str, description: str) -> int:
+        """Auto-categorize video based on filename and description"""
+        text = (filename + " " + description).lower()
+
+        # Check for extreme keywords first
+        for keyword in self.CATEGORY_KEYWORDS["extreme"]:
+            if keyword in text:
+                return 3
+
+        # Then intense
+        for keyword in self.CATEGORY_KEYWORDS["intense"]:
+            if keyword in text:
+                return 2
+
+        # Then medium
+        for keyword in self.CATEGORY_KEYWORDS["medium"]:
+            if keyword in text:
+                return 1
+
+        # Default to soft
+        return 0
+
+    def mark_sent(self, video_name: str):
+        """Mark a video as recently sent"""
+        self.recently_sent.append(video_name)
+
+    def was_recently_sent(self, video_name: str) -> bool:
+        """Check if video was recently sent"""
+        return video_name in self.recently_sent
+
+    def get_all(self) -> List[dict]:
+        """Get all videos"""
+        return list(self.videos.values())
+
+    def get_by_tier(self, tier: int) -> List[dict]:
+        """Get videos by tier"""
+        return [v for v in self.videos.values() if v["tier"] == tier]
+
+    def get_random(self, min_tier: int = 0, max_tier: int = 3) -> Optional[Tuple[str, str, int]]:
+        """Get random video within tier range, avoiding recently sent"""
+        matching = [
+            v for name, v in self.videos.items()
+            if min_tier <= v["tier"] <= max_tier
+            and name not in self.recently_sent  # Avoid repeats
+        ]
+
+        # If all have been sent, allow repeats
+        if not matching:
+            matching = [
+                v for v in self.videos.values()
+                if min_tier <= v["tier"] <= max_tier
+            ]
+
+        if not matching:
+            return None
+
+        video = random.choice(matching)
+        return (
+            video["path"],
+            video["description"],
+            video["tier"]
+        )
+
+    def get_for_context(self, context: str, arousal: float = 0.5) -> Optional[Tuple[str, str]]:
+        """Get video that matches context and arousal level, avoiding repeats"""
+        context_lower = context.lower()
+
+        # Determine appropriate tier based on arousal
+        if arousal < 0.4:
+            min_tier, max_tier = 0, 1  # Soft to medium
+        elif arousal < 0.7:
+            min_tier, max_tier = 1, 2  # Medium to intense
+        else:
+            min_tier, max_tier = 2, 3  # Hard to extreme
+
+        print(f"[VideoScanner] Searching for context: '{context[:50]}...' arousal={arousal:.2f} tier={min_tier}-{max_tier}")
+
+        # Important keywords to match (expand these)
+        important_keywords = {
+            "doggy": ["doggy", "doggi", "behind", "back"],
+            "anal": ["anal", "ass", "butt", "butthole", "asshole"],
+            "riding": ["riding", "ride", "on top", "cowgirl"],
+            "intense": ["intense", "overwhelmed", "sex", "deep-intimacy"],
+            "solo": ["solo", "alone", "playing", "fingering"],
+            "intimate moment": ["intimate moment", "suck", "intimate", "mouth", "deepthroat"],
+        }
+
+        # Find matching videos, excluding recently sent
+        matching = []
+        for name, v in self.videos.items():
+            if min_tier <= v["tier"] <= max_tier:
+                if name in self.recently_sent:
+                    continue  # Skip recently sent
+                # Score by description match
+                desc_lower = v["description"].lower()
+                filename_lower = v.get("filename", "").lower()
+
+                # Check both description and filename
+                combined = desc_lower + " " + filename_lower
+
+                # Score based on matches
+                score = 0
+
+                # Direct word matches
+                for word in context_lower.split():
+                    if len(word) > 2 and word in combined:
+                        score += 1
+
+                # Check important keyword groups
+                for key, keywords in important_keywords.items():
+                    if any(kw in context_lower for kw in keywords):
+                        if any(kw in combined for kw in keywords):
+                            score += 3  # Bonus for matching important keywords
+
+                if score > 0:
+                    matching.append((v, score, name))
+
+        if matching:
+            # Sort by score and pick from top
+            matching.sort(key=lambda x: x[1], reverse=True)
+            video = matching[0][0]
+            print(f"[VideoScanner] Found match: {video['path']} (score={matching[0][1]})")
+            return video["path"], video["description"]
+
+        # Fallback to random (also respects no-repeat)
+        print(f"[VideoScanner] No keyword match, falling back to random")
+        result = self.get_random(min_tier, max_tier)
+        if result:
+            return result[0], result[1]
+
+        print(f"[VideoScanner] No videos available in tier {min_tier}-{max_tier}")
+        return None
+
+    def stats(self) -> dict:
+        """Get video statistics"""
+        tiers = {}
+        for v in self.videos.values():
+            tier = v["tier"]
+            tiers[tier] = tiers.get(tier, 0) + 1
+
+        tier_names = {0: "soft", 1: "medium", 2: "intense", 3: "extreme"}
+        tier_stats = {tier_names.get(k, k): v for k, v in tiers.items()}
+
+        return {
+            "total": len(self.videos),
+            "categories": tier_stats,
+            "recently_sent": len(self.recently_sent)
+        }

package/webui/__init__.py

@@ -0,0 +1,3 @@
+"""WebUI module - Real-time dashboard for Alive-AI"""
+from .app import app, update_state, add_conversation
+from .bridge import init_bridge, start_webui