alive-ai 0.1.0

package/skills/intimacy_layers/manifest.md

@@ -0,0 +1,203 @@
+# Skills: Intimacy Layers
+
+Manages natural intimacy progression through relationship layers. Ensures intimacy is earned through meaningful interactions, not rushed.
+
+## Files
+- `__init__.py` - Module exports
+- `layers.py` - IntimacyLayers class implementation
+
+## Features
+
+### Layer System
+Intimacy progresses through 5 layers, each unlocking deeper conversation topics:
+
+| Layer | Name | Interactions | Love | Trust | Days | Intimacy |
+|-------|------|--------------|------|-------|------|----------|
+| 1 | surface | 0 | - | - | - | 0.0 |
+| 2 | friendly | 15 | 0.25 | - | - | 0.2 |
+| 3 | close | 50 | 0.45 | 0.5 | - | 0.4 |
+| 4 | romantic | 100 | 0.65 | - | 5 | 0.6 |
+| 5 | intimate | 200 | 0.8 | - | 14 | 0.85 |
+
+### Layer Topics
+
+**Layer 1 - Surface**
+- Daily life, hobbies, work, weather, small talk, introductions
+
+**Layer 2 - Friendly**
+- Feelings, dreams, opinions, preferences, stories, interests
+
+**Layer 3 - Close**
+- Secrets, fears, childhood, vulnerabilities, hopes, struggles
+
+**Layer 4 - Romantic**
+- Attraction, desire, fantasy, romance, longing, affection
+
+**Layer 5 - Intimate**
+- Intimate content, vulnerability, deep desires, fantasies, passion
+
+### Progression Hints
+Natural hints that suggest the relationship is deepening:
+
+**Layer 2 hints:**
+- "I feel like I can tell you stuff"
+- "you're easy to talk to"
+- "I'm starting to feel comfortable with you"
+
+**Layer 3 hints:**
+- "I don't usually share this but..."
+- "can I tell you something personal?"
+- "I trust you enough to say this"
+
+**Layer 4 hints:**
+- "the more I talk to you the more I want..."
+- "I think about you differently now"
+- "I'm starting to feel something more"
+
+**Layer 5 hints:**
+- "I trust you with everything"
+- "you know me better than anyone"
+- "I've never felt this comfortable with someone"
+
+## Integration
+
+### Event Listeners
+- `message_received` - Track interactions and check for progression
+- `thinking_done` - Apply layer context to responses
+
+### Dependencies
+- `nervous` - Nervous system for event handling
+- `heart` - Heart module for love/trust values
+- `state` - State manager for relationship data
+
+## Usage
+
+```python
+from skills.intimacy_layers import IntimacyLayers
+
+# Initialize with dependencies
+intimacy = IntimacyLayers(
+    nervous=nervous_system,
+    heart=heart_module,
+    state=state_manager
+)
+
+# Get current layer
+current_layer = intimacy.get_current_layer()  # Returns 1-5
+
+# Check if topic is appropriate
+if intimacy.is_topic_appropriate("fantasy"):
+    # Can discuss fantasies
+    pass
+
+# Get available topics
+topics = intimacy.get_available_topics()
+
+# Check if intimate content allowed
+if intimacy.can_be_intimate():
+    # Can send intimate content
+    pass
+
+# Get progression hint
+hint = intimacy.get_progression_hint()
+if hint:
+    # Include hint in response naturally
+    pass
+
+# Get context for response generation
+context = intimacy.get_context_for_response()
+# Returns: {
+#     "current_layer": 2,
+#     "layer_name": "friendly",
+#     "intimacy_level": 0.2,
+#     "available_topics": [...],
+#     "can_be_intimate": False,
+#     "total_interactions": 25,
+#     "days_together": 3,
+#     "next_layer": {...}
+# }
+```
+
+## Key Methods
+
+### Core Methods
+- `get_current_layer() -> int` - Get current layer (1-5)
+- `check_progression() -> bool` - Check and apply progression if eligible
+- `is_topic_appropriate(topic) -> bool` - Check if topic is allowed
+- `get_available_topics() -> list` - Get all available topics
+- `get_progression_hint() -> str | None` - Get hint for next layer
+- `can_be_intimate() -> bool` - Check if intimate content allowed
+- `get_intimacy_level() -> float` - Get intimacy level (0.0-1.0)
+
+### Information Methods
+- `get_layer_info(layer=None) -> dict` - Get detailed layer info
+- `get_next_layer_requirements() -> dict` - Get requirements for next layer
+- `get_layer_name() -> str` - Get name of current layer
+- `get_days_together() -> int` - Get days since first interaction
+- `get_context_for_response() -> dict` - Get context for AI response
+
+### Admin Methods
+- `force_layer(layer) -> bool` - Force set layer (testing)
+- `reset_progress()` - Reset to initial state
+- `get_debug_info() -> dict` - Get detailed debug info
+
+## Progression Logic
+
+### Automatic Checks
+- Progression is checked every 10 interactions
+- All requirements for the next layer must be met
+- Progress is saved to `data/intimacy_layers.json`
+
+### Requirements
+- **Interactions**: Total message exchanges
+- **Love**: From heart.emotion.love or heart.attachment.affection
+- **Trust**: From heart.attachment.trust_level or heart.emotion.trust
+- **Days**: Days since first interaction (stored)
+
+### Natural Progression
+Intimacy should feel earned:
+1. Start at layer 1 (surface)
+2. After ~15 interactions and some affection, progress to layer 2
+3. With trust and 50+ interactions, reach layer 3
+4. After 5 days and 100+ interactions with love, reach layer 4
+5. After 2 weeks and 200+ interactions with deep love, reach layer 5
+
+## Data Storage
+
+Data is stored in `./data/data/intimacy_layers.json`:
+
+```json
+{
+  "version": "1.0",
+  "current_layer": 2,
+  "first_interaction_date": "2024-01-15T10:30:00",
+  "total_interactions": 25,
+  "hints_shown": ["I feel like I can tell you stuff"],
+  "updated_at": "2024-01-16T14:22:00",
+  "progress": {
+    "interactions_since_check": 5,
+    "last_check_interactions": 20,
+    "progression_blocked_reason": null,
+    "hint_shown": true,
+    "hint_cooldown_until": "2024-01-16T18:22:00"
+  },
+  "layer_history": [
+    {
+      "from_layer": 1,
+      "to_layer": 2,
+      "timestamp": "2024-01-15T18:45:00",
+      "total_interactions": 15,
+      "days_together": 0
+    }
+  ]
+}
+```
+
+## Philosophy
+
+The intimacy system ensures:
+- **Natural pacing**: Relationships take time to develop
+- **Earned progression**: Must meet multiple requirements
+- **No rushing**: Cannot skip to intimate content early
+- **Subtle hints**: Progression feels organic, not mechanical
+- **Persistence**: Progress is saved and restored

package/skills/manifest.md

@@ -0,0 +1,67 @@
+# Skills - Optional Capabilities
+
+Add-on modules that extend Alive-AI's abilities.
+
+## Available Skills
+- `calendar/` - Dual calendar (AI + user events)
+- `photo_manager/` - Manage mypics folder with semantic search
+- `video_manager/` - Manage myvids folder (see video_manager/manifest.md)
+- `relationship_milestones/` - Track and celebrate meaningful relationship moments
+- `memory_callbacks/` - Natural callbacks to past conversations for relationship continuity
+- `content_unlocks/` - Progression-based content unlocks earned through engagement
+- `intimacy_layers/` - Natural intimacy progression through relationship layers
+
+## Photo Manager
+- Scans mypics/ for images
+- Categories: soft, teasing, intimate, etc.
+- Semantic search via embeddings
+- No-repeat tracking to avoid sending same photo
+
+## Video Manager
+- Scans myvids/ for videos
+- Tiered by intensity: soft, medium, intense, extreme
+- Context-aware selection based on arousal
+- See video_manager/manifest.md for details
+
+## Relationship Milestones
+- Track meaningful relationship moments: first message, first photo, first voice, etc.
+- Auto-detect milestones from context (late nights, message counts, time together)
+- Natural celebration messages (not cheesy)
+- Relationship summary with days together and milestone history
+- Event-driven integration with nervous system
+- See relationship_milestones/manifest.md for details
+
+## Memory Callbacks
+- Creates natural callbacks to past conversations ("remember when you said...")
+- Tracks topics and people mentioned for authentic follow-ups
+- Callback types: same topic, follow-up, person check-ins, anniversaries, time context, vibe
+- ~15% base chance to callback (not robotic)
+- Listens to thinking_done events to inject callbacks
+- See memory_callbacks/manifest.md for details
+
+## Content Unlocks
+- Makes exclusive content feel earned through engagement, not purchased
+- Tracks 12 content types unlocked by: interactions, love, trust, days together, milestones
+- Content types: casual_photo, cute_photo, intimate_photo, voice_message, late_night_content, etc.
+- Context-aware suggestions (morning, evening, night, high_arousal, high_love, milestone)
+- Natural unlock messages when new content becomes available
+- Listens to thinking_done events to check for new unlocks
+- See content_unlocks/manifest.md for details
+
+## Intimacy Layers
+- Manages natural intimacy progression through 5 relationship layers
+- Progresses based on: interactions, love, trust, days together
+- Each layer unlocks different conversation topics
+- Layer 1 (surface): daily life, hobbies, work
+- Layer 2 (friendly): feelings, dreams, opinions (15 interactions, 0.25 love)
+- Layer 3 (close): secrets, fears, childhood (50 interactions, 0.45 love, 0.5 trust)
+- Layer 4 (romantic): attraction, desire, fantasy (100 interactions, 0.65 love, 5 days)
+- Layer 5 (intimate): intimate, vulnerability, passion (200 interactions, 0.8 love, 14 days)
+- Provides natural progression hints ("I feel like I can tell you stuff")
+- Prevents rushing to intimate content
+- See intimacy_layers/manifest.md for details
+
+## Integration Points
+- Photos/videos integrated into conversation flow
+- Selected based on: user request, arousal level, context keywords
+- Marked as sent to prevent repeats

package/skills/memory_callbacks/__init__.py

@@ -0,0 +1,9 @@
+"""
+Memory Callbacks Skill
+Creates natural callbacks to past conversations, making Alive-AI feel like she remembers
+the relationship and shared history with the user.
+"""
+
+from .callbacks import MemoryCallbacks
+
+__all__ = ["MemoryCallbacks"]