aetherforge-platform 1.0.0__py3-none-any.whl

ai-life-assistant-copy/backups/backup_20260404_193836/main.py

@@ -0,0 +1,830 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import os
+from graph import run_chat
+from config import APP_NAME, APP_VERSION, DEBUG
+from personality import personality_analyzer
+from ai_agent import agent_system
+from speech import speech_recognition
+from mcp_tools import mcp_tool_manager
+from avatar_manager import avatar_manager
+from avatar_packer import avatar_packer, marketplace
+from tree_memory import tree_memory_system
+from database import avatar_database
+
+app = FastAPI(
+    title=APP_NAME,
+    version=APP_VERSION,
+    debug=DEBUG
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatRequest(BaseModel):
+    message: str
+    user_id: Optional[str] = "default"
+    conversation_history: Optional[List[Dict[str, str]]] = None
+
+class ChatResponse(BaseModel):
+    success: bool
+    results: List[Dict[str, Any]]
+    cards: List[Dict[str, Any]]
+    visualization: Optional[str]
+    intent: Optional[str]
+    status: str
+    limit_message: Optional[str] = None
+
+class PersonalityAnalysisRequest(BaseModel):
+    user_id: str
+    messages: List[Dict[str, str]]
+
+class MatchRequest(BaseModel):
+    user1_id: str
+    user2_id: str
+
+@app.get("/")
+async def root():
+    index_path = os.path.join(os.path.dirname(__file__), "static", "index.html")
+    if os.path.exists(index_path):
+        return FileResponse(index_path)
+    return {
+        "name": APP_NAME,
+        "version": APP_VERSION,
+        "status": "running"
+    }
+
+@app.get("/profile")
+async def profile_page():
+    profile_path = os.path.join(os.path.dirname(__file__), "static", "profile.html")
+    if os.path.exists(profile_path):
+        return FileResponse(profile_path)
+    raise HTTPException(status_code=404, detail="Profile page not found")
+
+@app.get("/test-products")
+async def test_products_page():
+    test_path = os.path.join(os.path.dirname(__file__), "static", "test_products.html")
+    if os.path.exists(test_path):
+        return FileResponse(test_path)
+    raise HTTPException(status_code=404, detail="Test products page not found")
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+# ============================================
+# Usage Tracking & Subscription System
+# ============================================
+
+# Usage tracking system
+usage_stats = {
+    "default": {
+        "messages_sent": 0,
+        "tokens_used": 0,
+        "last_reset": "2025-01-01"
+    }
+}
+
+# Demo subscription plans (for demonstration)
+subscription_plans = {
+    "free": {
+        "name": "Free",
+        "daily_limit": 10,
+        "monthly_limit": 100,
+        "features": ["Basic chat", "10 messages/day"]
+    },
+    "pro": {
+        "name": "Pro",
+        "daily_limit": 100,
+        "monthly_limit": 3000,
+        "features": ["Advanced chat", "100 messages/day", "Priority support"]
+    },
+    "unlimited": {
+        "name": "Unlimited",
+        "daily_limit": None,
+        "monthly_limit": None,
+        "features": ["Unlimited chat", "All features", "Premium support"]
+    }
+}
+
+current_plan = "free"  # Demo default plan
+
+@app.get("/api/usage")
+async def get_usage(user_id: str = "default"):
+    """Get usage statistics for a user"""
+    if user_id not in usage_stats:
+        usage_stats[user_id] = {
+            "messages_sent": 0,
+            "tokens_used": 0,
+            "last_reset": "2025-01-01"
+        }
+    
+    return {
+        "success": True,
+        "usage": usage_stats[user_id],
+        "plan": subscription_plans[current_plan],
+        "current_plan": current_plan
+    }
+
+@app.post("/api/usage/reset")
+async def reset_usage(user_id: str = "default"):
+    """Reset usage statistics (demo only)"""
+    if user_id in usage_stats:
+        usage_stats[user_id]["messages_sent"] = 0
+        usage_stats[user_id]["tokens_used"] = 0
+    
+    return {"success": True, "message": "Usage reset"}
+
+@app.get("/api/plans")
+async def get_plans():
+    """Get available subscription plans"""
+    return {
+        "success": True,
+        "plans": subscription_plans,
+        "current_plan": current_plan
+    }
+
+def check_limit(user_id: str) -> tuple[bool, str]:
+    """
+    Check if user has exceeded their usage limit
+    Returns (allowed, message)
+    """
+    if current_plan == "unlimited":
+        return (True, "")
+    
+    if user_id not in usage_stats:
+        usage_stats[user_id] = {
+            "messages_sent": 0,
+            "tokens_used": 0,
+            "last_reset": "2025-01-01"
+        }
+    
+    plan = subscription_plans[current_plan]
+    messages_sent = usage_stats[user_id]["messages_sent"]
+    
+    if plan["daily_limit"] and messages_sent >= plan["daily_limit"]:
+        return (False, f"Daily limit reached ({plan['daily_limit']} messages). Upgrade to Pro for more!")
+    
+    return (True, "")
+
+def increment_usage(user_id: str):
+    """Increment usage counter"""
+    if user_id not in usage_stats:
+        usage_stats[user_id] = {
+            "messages_sent": 0,
+            "tokens_used": 0,
+            "last_reset": "2025-01-01"
+        }
+    
+    usage_stats[user_id]["messages_sent"] += 1
+
+# ============================================
+# Chat Endpoint
+# ============================================
+
+@app.post("/api/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    try:
+        user_id = request.user_id or "default"
+        
+        # Check usage limit
+        allowed, limit_message = check_limit(user_id)
+        if not allowed:
+            return ChatResponse(
+                success=False,
+                results=[],
+                cards=[],
+                visualization=None,
+                intent=None,
+                status="limit_reached",
+                limit_message=limit_message
+            )
+        
+        # Increment usage counter
+        increment_usage(user_id)
+        
+        # Run chat
+        result = run_chat(
+            message=request.message,
+            user_id=user_id,
+            conversation_history=request.conversation_history
+        )
+        
+        return ChatResponse(
+            success=True,
+            results=result.get("results", []),
+            cards=result.get("cards", []),
+            visualization=result.get("visualization"),
+            intent=result.get("intent"),
+            status=result.get("status", "success")
+        )
+        
+    except Exception as e:
+        print(f"Chat error: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error"
+        )
+
+@app.get("/api/test")
+async def test_endpoint():
+    return {
+        "message": "Test endpoint working!",
+        "timestamp": "now"
+    }
+
+@app.post("/api/personality/analyze")
+async def analyze_personality(request: PersonalityAnalysisRequest):
+    try:
+        analysis = personality_analyzer.analyze_conversation(
+            user_id=request.user_id,
+            messages=request.messages
+        )
+        return {"success": True, "analysis": analysis}
+    except Exception as e:
+        print(f"Personality analysis error: {e}")
+        raise HTTPException(status_code=500, detail="Analysis failed")
+
+@app.get("/api/personality/{user_id}")
+async def get_personality(user_id: str):
+    analysis = personality_analyzer.get_analysis(user_id)
+    if analysis:
+        return {"success": True, "analysis": analysis}
+    return {"success": False, "message": "No analysis found"}
+
+@app.post("/api/ai-chat/start")
+async def start_ai_chat(request: MatchRequest):
+    try:
+        result = agent_system.start_ai_chat(
+            user1_id=request.user1_id,
+            user2_id=request.user2_id
+        )
+        return result
+    except Exception as e:
+        print(f"AI chat error: {e}")
+        raise HTTPException(status_code=500, detail="AI chat failed")
+
+@app.post("/api/speech/transcribe")
+async def transcribe_speech(file: UploadFile = File(...)):
+    try:
+        text = await speech_recognition.transcribe_audio(file)
+        if text:
+            return {"success": True, "text": text}
+        return {"success": False, "message": "Speech recognition not available"}
+    except Exception as e:
+        print(f"Speech transcription error: {e}")
+        raise HTTPException(status_code=500, detail="Transcription failed")
+
+@app.get("/api/tools/list")
+async def list_tools():
+    tools = mcp_tool_manager.list_tools()
+    return {
+        "success": True,
+        "tools": [
+            {
+                "name": t.name,
+                "description": t.description,
+                "type": t.type.value,
+                "parameters": [
+                    {"name": p.name, "type": p.type, "description": p.description, "required": p.required}
+                    for p in t.parameters
+                ]
+            }
+            for t in tools
+        ]
+    }
+
+class ToolExecuteRequest(BaseModel):
+    tool_name: str
+    params: Dict[str, Any]
+
+class TitleGenerateRequest(BaseModel):
+    message: str
+    conversation_history: Optional[List[Dict[str, str]]] = None
+
+@app.post("/api/tools/execute")
+async def execute_tool(request: ToolExecuteRequest):
+    try:
+        result = await mcp_tool_manager.execute_tool(
+            tool_name=request.tool_name,
+            params=request.params
+        )
+        return result
+    except Exception as e:
+        print(f"Tool execution error: {e}")
+        raise HTTPException(status_code=500, detail="Tool execution failed")
+
+@app.post("/api/chat/title")
+async def generate_chat_title(request: TitleGenerateRequest):
+    """
+    Generate a session title using AI (Claude/Haiku model).
+    
+    This is the single source of truth for AI-generated session titles.
+    Follows the same pattern as Claude Code's sessionTitle.ts
+    
+    Args:
+        request: TitleGenerateRequest with user's first message
+        
+    Returns:
+        JSON with generated title or fallback
+        
+    Example response:
+        {"success": true, "title": "Fix login button on mobile"}
+    """
+    try:
+        # Check if API key is configured
+        if not GROK_API_KEY:
+            print("[Title API] No API key configured, using fallback")
+            return {
+                "success": False,
+                "title": generate_fallback_title(request.message),
+                "method": "fallback"
+            }
+        
+        # Call AI model to generate title
+        try:
+            from langchain_groq import ChatGroq
+            from langchain.prompts import ChatPromptTemplate
+            import json
+            
+            # Use a lightweight model for title generation (like Haiku in Claude Code)
+            llm = ChatGroq(
+                api_key=GROK_API_KEY,
+                model="mixtral-8x7b-32768",  # Fast and cheap
+                temperature=0.3  # Low temperature for consistency
+            )
+            
+            # Professional prompt design (inspired by Claude Code)
+            prompt = ChatPromptTemplate.from_messages([
+                ("system", """Generate a concise, sentence-case title (3-7 words or 10-20 Chinese characters) that captures the main topic or goal of this conversation.
+
+Requirements:
+1. Be specific and descriptive
+2. Use sentence case (capitalize only first word and proper nouns)
+3. No quotes, colons, or punctuation in the title
+4. Avoid vague titles like "Chat" or "Question"
+5. Return ONLY the title text, no JSON, no explanations
+
+Good examples:
+- "Fix login button on mobile"
+- "Add OAuth authentication"
+- "推荐性价比高的笔记本电脑"
+- "查询北京明天天气"
+
+Bad examples:
+- "Code changes" (too vague)
+- "Investigate and fix the issue where..." (too long)
+- "Fix Login Button On Mobile" (wrong case)
+- "Chat about coding" (vague)"""),
+                ("human", "Generate a title for this conversation:\n\n{message}")
+            ])
+            
+            chain = prompt | llm
+            response = chain.invoke({"message": request.message})
+            
+            # Extract and clean title
+            title = response.content.strip()
+            
+            # Remove quotes and common prefixes
+            title = title.strip('"\'`。.')
+            if title.lower().startswith('title:'):
+                title = title[6:].strip()
+            
+            # Validate title
+            if not title or len(title) < 2:
+                raise ValueError("Title too short")
+            
+            print(f"[Title API] Successfully generated: '{title}'")
+            
+            return {
+                "success": True,
+                "title": title,
+                "method": "ai"
+            }
+            
+        except Exception as ai_error:
+            print(f"[Title API] AI generation failed: {ai_error}")
+            # Fallback to rule-based generation
+            fallback_title = generate_fallback_title(request.message)
+            return {
+                "success": False,
+                "title": fallback_title,
+                "method": "fallback",
+                "error": str(ai_error)
+            }
+        
+    except Exception as e:
+        print(f"[Title API] Unexpected error: {e}")
+        return {
+            "success": False,
+            "title": generate_fallback_title(request.message),
+            "method": "fallback",
+            "error": str(e)
+        }
+
+def generate_fallback_title(message: str) -> str:
+    """
+    备用标题生成方案（当 API 不可用时）
+    基于关键词匹配和文本提取
+    """
+    if not message or message.strip() == '':
+        return 'New conversation'
+    
+    message_lower = message.lower()
+    
+    # 基于关键词的语义匹配
+    topic_keywords = {
+        'Shopping': ['buy', 'product', 'shop', 'recommend', 'price', 'cheap', 'expensive', 'purchase', 'amazon', '商品', '购物', '买', '推荐'],
+        'Food Order': ['food', 'eat', 'restaurant', 'order', 'delivery', 'hungry', 'meal', 'lunch', 'dinner', '饿了', '吃', '餐厅', '外卖'],
+        'Travel Planning': ['travel', 'flight', 'trip', 'hotel', 'vacation', 'book', 'ticket', 'airport', '旅行', '机票', '酒店'],
+        'Ride Booking': ['taxi', 'ride', 'uber', 'grab', 'car', 'drive', 'pickup', '打车', '叫车'],
+        'Weather': ['weather', 'temperature', 'rain', 'sunny', 'forecast', 'cold', 'hot', '天气', '下雨', '温度'],
+        'Schedule': ['meeting', 'schedule', 'calendar', 'event', 'appointment', 'reminder', '会议', '日程', '提醒', '安排'],
+        'Tech': ['computer', 'laptop', 'phone', 'tech', 'electronic', 'device', 'cpu', 'gpu', '电脑', '手机', '电子'],
+        'Fashion': ['clothes', 'shirt', 'dress', 'shoes', 'wear', 'fashion', 'style', '衣服', '时尚', '鞋子'],
+        'Health': ['health', 'exercise', 'gym', 'workout', 'diet', 'fitness', 'medicine', '健康', '运动', '健身'],
+        'Entertainment': ['movie', 'music', 'game', 'book', 'show', 'play', 'watch', '电影', '音乐', '游戏', '书']
+    }
+    
+    # 检测主题
+    for topic, keywords in topic_keywords.items():
+        if any(keyword in message_lower for keyword in keywords):
+            return topic
+    
+    # 提取第一个完整子句（到逗号或标点）
+    first_clause = message.split(r'[,.;:!?]')[0].strip()
+    if first_clause and len(first_clause) <= 30:
+        return first_clause
+    
+    # 截取前 30 个字符
+    return message[:30] + ('...' if len(message) > 30 else '')
+
+# ============================================
+# Virtual Avatar System API Endpoints
+# ============================================
+
+class CreateAvatarRequest(BaseModel):
+    name: str
+    description: Optional[str] = ""
+    personality_traits: Optional[List[str]] = None
+    current_age: Optional[int] = 25
+    creator_id: Optional[str] = None
+
+class UpdateAvatarRequest(BaseModel):
+    name: Optional[str] = None
+    description: Optional[str] = None
+    personality_traits: Optional[List[str]] = None
+    current_age: Optional[int] = None
+    avatar_image: Optional[str] = None
+
+class SetAgeRequest(BaseModel):
+    age: int
+
+class AddMemoryRequest(BaseModel):
+    content: str
+    min_age: Optional[int] = 0
+    max_age: Optional[int] = 150
+    clarity: Optional[int] = 80
+    emotional_tone: Optional[str] = "neutral"
+    topic: Optional[str] = None
+
+class ExportAvatarRequest(BaseModel):
+    export_format: Optional[str] = "avatar"
+
+class ListForSaleRequest(BaseModel):
+    price: float
+    description: Optional[str] = None
+
+class PurchaseAvatarRequest(BaseModel):
+    buyer_id: str
+
+@app.get("/api/avatar")
+async def list_avatars(creator_id: Optional[str] = None):
+    """List all avatars, optionally filtered by creator"""
+    avatars = avatar_manager.list_avatars(creator_id)
+    return {"success": True, "avatars": avatars}
+
+@app.post("/api/avatar")
+async def create_avatar(request: CreateAvatarRequest):
+    """Create a new virtual avatar"""
+    try:
+        avatar = avatar_manager.create_avatar(
+            name=request.name,
+            description=request.description,
+            personality_traits=request.personality_traits,
+            current_age=request.current_age,
+            creator_id=request.creator_id
+        )
+        return {"success": True, "avatar": avatar.to_dict()}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/avatar/{avatar_id}")
+async def get_avatar(avatar_id: str):
+    """Get a specific avatar by ID"""
+    avatar = avatar_manager.load_avatar(avatar_id)
+    if avatar:
+        return {"success": True, "avatar": avatar.to_dict()}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.put("/api/avatar/{avatar_id}")
+async def update_avatar(avatar_id: str, request: UpdateAvatarRequest):
+    """Update avatar information"""
+    update_data = {k: v for k, v in request.dict().items() if v is not None}
+    avatar = avatar_manager.update_avatar(avatar_id, **update_data)
+    if avatar:
+        return {"success": True, "avatar": avatar.to_dict()}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.delete("/api/avatar/{avatar_id}")
+async def delete_avatar(avatar_id: str):
+    """Delete an avatar"""
+    deleted = avatar_manager.delete_avatar(avatar_id)
+    if deleted:
+        return {"success": True, "message": "Avatar deleted"}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.post("/api/avatar/{avatar_id}/age")
+async def set_avatar_age(avatar_id: str, request: SetAgeRequest):
+    """Set avatar's current age"""
+    avatar = avatar_manager.set_age(avatar_id, request.age)
+    if avatar:
+        return {"success": True, "avatar": avatar.to_dict()}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.get("/api/avatar/{avatar_id}/memories")
+async def get_avatar_memories(avatar_id: str, age: Optional[int] = None):
+    """Get avatar memories, optionally filtered by age"""
+    if age is not None:
+        memories = avatar_manager.get_memories_for_age(avatar_id, age)
+    else:
+        memories = tree_memory_system.get_all_memories(avatar_id)
+    return {"success": True, "memories": memories, "filter_age": age}
+
+@app.post("/api/avatar/{avatar_id}/memories")
+async def add_memory(avatar_id: str, request: AddMemoryRequest):
+    """Add a new memory to avatar"""
+    try:
+        memory_id = avatar_manager.add_memory(
+            avatar_id=avatar_id,
+            content=request.content,
+            min_age=request.min_age,
+            max_age=request.max_age,
+            clarity=request.clarity,
+            emotional_tone=request.emotional_tone,
+            topic=request.topic
+        )
+        return {"success": True, "memory_id": memory_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/api/avatar/{avatar_id}/memories/{memory_id}")
+async def delete_memory(avatar_id: str, memory_id: str):
+    """Delete a memory"""
+    deleted = tree_memory_system.delete_memory(avatar_id, memory_id)
+    if deleted:
+        return {"success": True, "message": "Memory deleted"}
+    raise HTTPException(status_code=404, detail="Memory not found")
+
+@app.get("/api/avatar/{avatar_id}/tree")
+async def get_memory_tree(avatar_id: str):
+    """Get the inverted tree memory structure"""
+    tree = avatar_manager.get_tree_structure(avatar_id)
+    if tree:
+        return {"success": True, "tree": tree}
+    raise HTTPException(status_code=404, detail="Tree not found")
+
+class TreeMemorySearchRequest(BaseModel):
+    query: str
+    min_relevance: Optional[float] = 0.3
+    max_results: Optional[int] = 10
+
+@app.post("/api/avatar/{avatar_id}/memories/search")
+async def search_tree_memories(avatar_id: str, request: TreeMemorySearchRequest):
+    """Search tree memories by relevance"""
+    memories = tree_memory_system.search_relevant_memories(
+        avatar_id,
+        request.query,
+        request.min_relevance,
+        request.max_results
+    )
+    return {"success": True, "memories": memories}
+
+@app.get("/api/avatar/{avatar_id}/memories/context")
+async def get_tree_context(avatar_id: str, query: str, min_relevance: Optional[float] = 0.3, max_results: Optional[int] = 5):
+    """Get formatted context from tree memories"""
+    context = tree_memory_system.get_relevant_context(
+        avatar_id,
+        query,
+        min_relevance,
+        max_results
+    )
+    return {"success": True, "context": context}
+
+@app.post("/api/avatar/{avatar_id}/developer-mode")
+async def toggle_developer_mode(avatar_id: str):
+    """Toggle developer mode for avatar"""
+    enabled = avatar_manager.toggle_developer_mode(avatar_id)
+    if enabled is not None:
+        return {"success": True, "developer_mode": enabled}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.post("/api/avatar/{avatar_id}/export")
+async def export_avatar(avatar_id: str, request: ExportAvatarRequest):
+    """Export avatar to file"""
+    filepath = avatar_packer.export_avatar(avatar_id, request.export_format)
+    if filepath:
+        return {"success": True, "filepath": filepath, "filename": os.path.basename(filepath)}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.get("/api/exports")
+async def list_exports():
+    """List all exported files"""
+    exports = avatar_packer.list_exports()
+    return {"success": True, "exports": exports}
+
+@app.delete("/api/exports/{filename}")
+async def delete_export(filename: str):
+    """Delete an exported file"""
+    deleted = avatar_packer.delete_export(filename)
+    if deleted:
+        return {"success": True, "message": "Export deleted"}
+    raise HTTPException(status_code=404, detail="Export not found")
+
+@app.post("/api/avatar/{avatar_id}/list-for-sale")
+async def list_for_sale(avatar_id: str, request: ListForSaleRequest):
+    """List avatar for sale on marketplace"""
+    success = marketplace.list_for_sale(avatar_id, request.price, request.description)
+    if success:
+        return {"success": True, "message": "Avatar listed for sale"}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.post("/api/avatar/{avatar_id}/remove-from-sale")
+async def remove_from_sale(avatar_id: str):
+    """Remove avatar from marketplace"""
+    success = marketplace.remove_from_sale(avatar_id)
+    if success:
+        return {"success": True, "message": "Avatar removed from sale"}
+    raise HTTPException(status_code=404, detail="Avatar not found")
+
+@app.get("/api/marketplace")
+async def get_marketplace():
+    """Get all avatars listed for sale"""
+    listings = marketplace.get_market_listings()
+    return {"success": True, "listings": listings}
+
+@app.post("/api/marketplace/{avatar_id}/purchase")
+async def purchase_avatar(avatar_id: str, request: PurchaseAvatarRequest):
+    """Purchase an avatar from marketplace"""
+    new_avatar_id = marketplace.purchase_avatar(avatar_id, request.buyer_id)
+    if new_avatar_id:
+        return {"success": True, "new_avatar_id": new_avatar_id, "message": "Avatar purchased successfully"}
+    raise HTTPException(status_code=404, detail="Avatar not available for purchase")
+
+class SelectAvatarRequest(BaseModel):
+    user_id: str
+    avatar_id: str
+
+@app.post("/api/user/select-avatar")
+async def select_user_avatar(request: SelectAvatarRequest):
+    """Select an avatar for the user"""
+    try:
+        user_settings_file = os.path.join("user_data", f"{request.user_id}_settings.json")
+        os.makedirs("user_data", exist_ok=True)
+        
+        settings = {}
+        if os.path.exists(user_settings_file):
+            with open(user_settings_file, "r", encoding="utf-8") as f:
+                settings = json.load(f)
+        
+        settings["selected_avatar_id"] = request.avatar_id
+        settings["selected_at"] = datetime.now().isoformat()
+        
+        with open(user_settings_file, "w", encoding="utf-8") as f:
+            json.dump(settings, f, ensure_ascii=False, indent=2)
+        
+        return {"success": True, "selected_avatar_id": request.avatar_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/user/selected-avatar")
+async def get_selected_avatar(user_id: str):
+    """Get user's selected avatar"""
+    try:
+        user_settings_file = os.path.join("user_data", f"{user_id}_settings.json")
+        
+        if os.path.exists(user_settings_file):
+            with open(user_settings_file, "r", encoding="utf-8") as f:
+                settings = json.load(f)
+                avatar_id = settings.get("selected_avatar_id")
+                if avatar_id:
+                    avatar = avatar_manager.load_avatar(avatar_id)
+                    if avatar:
+                        return {"success": True, "avatar": avatar.to_dict()}
+        
+        return {"success": True, "avatar": None}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/user/my-avatars")
+async def get_user_avatars(user_id: str):
+    """Get all avatars owned by user"""
+    try:
+        avatars = avatar_manager.list_avatars(user_id)
+        return {"success": True, "avatars": avatars}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/avatar-manager")
+async def avatar_manager():
+    """Virtual Avatar Manager Page"""
+    manager_path = os.path.join(os.path.dirname(__file__), "static", "avatar-manager.html")
+    if os.path.exists(manager_path):
+        return FileResponse(manager_path)
+    raise HTTPException(status_code=404, detail="Page not found")
+
+@app.get("/design-template")
+async def design_template():
+    """Design Template Preview Page"""
+    template_path = os.path.join(os.path.dirname(__file__), "static", "design-template.html")
+    if os.path.exists(template_path):
+        return FileResponse(template_path)
+    raise HTTPException(status_code=404, detail="Design template page not found")
+
+@app.get("/design-template-roblox")
+async def design_template_roblox():
+    """Roblox Style Design Template Preview Page"""
+    template_path = os.path.join(os.path.dirname(__file__), "static", "design-template-roblox.html")
+    if os.path.exists(template_path):
+        return FileResponse(template_path)
+    raise HTTPException(status_code=404, detail="Roblox design template page not found")
+
+@app.get("/roblox-interface")
+async def roblox_interface():
+    """Full Roblox Style Interface"""
+    interface_path = os.path.join(os.path.dirname(__file__), "static", "roblox-interface.html")
+    if os.path.exists(interface_path):
+        return FileResponse(interface_path)
+    raise HTTPException(status_code=404, detail="Roblox interface page not found")
+
+@app.get("/grok-roblox-combo")
+async def grok_roblox_combo():
+    """Grok Layout + Roblox Style Interface"""
+    interface_path = os.path.join(os.path.dirname(__file__), "static", "grok-roblox-combo.html")
+    if os.path.exists(interface_path):
+        return FileResponse(interface_path)
+    raise HTTPException(status_code=404, detail="Grok-Roblox combo page not found")
+
+@app.get("/template-main")
+async def template_main():
+    """Template - Main Chat Interface"""
+    template_path = os.path.join(os.path.dirname(__file__), "static", "template-main.html")
+    if os.path.exists(template_path):
+        return FileResponse(template_path)
+    raise HTTPException(status_code=404, detail="Template main page not found")
+
+@app.get("/template-profile")
+async def template_profile():
+    """Template - Profile Settings Page"""
+    template_path = os.path.join(os.path.dirname(__file__), "static", "template-profile.html")
+    if os.path.exists(template_path):
+        return FileResponse(template_path)
+    raise HTTPException(status_code=404, detail="Template profile page not found")
+
+@app.get("/template-roblox")
+async def template_roblox():
+    """Template - Roblox Avatar Manager"""
+    template_path = os.path.join(os.path.dirname(__file__), "static", "template-roblox.html")
+    if os.path.exists(template_path):
+        return FileResponse(template_path)
+    raise HTTPException(status_code=404, detail="Template Roblox page not found")
+
+@app.get("/avatar-manager-real")
+async def avatar_manager_real():
+    """Real Avatar Manager with Import/Export"""
+    manager_path = os.path.join(os.path.dirname(__file__), "static", "avatar-manager-real.html")
+    if os.path.exists(manager_path):
+        return FileResponse(manager_path)
+    raise HTTPException(status_code=404, detail="Avatar manager page not found")
+
+static_dir = os.path.join(os.path.dirname(__file__), "static")
+if os.path.exists(static_dir):
+    app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=DEBUG
+    )