run_local.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Local startup script for מראות (Mirrors) application
Handles environment setup and provides fallback options
"""

import os
import sys
import socket
import subprocess
import logging

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def find_available_port(start_port=7861, max_tries=10):
    """Find an available port starting from start_port"""
    for port in range(start_port, start_port + max_tries):
        try:
            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
                s.bind(('127.0.0.1', port))
                return port
        except OSError:
            continue
    return start_port

def check_dependencies():
    """Check if required dependencies are installed"""
    required_packages = ['gradio', 'transformers', 'torch']
    missing_packages = []
    
    for package in required_packages:
        try:
            __import__(package)
            logger.info(f"✅ {package} is installed")
        except ImportError:
            missing_packages.append(package)
            logger.error(f"❌ {package} is missing")
    
    if missing_packages:
        logger.error("Missing packages. Please install them:")
        logger.error(f"pip install {' '.join(missing_packages)}")
        return False
    
    return True

def run_simple_app(port):
    """Run the simplified app version"""
    logger.info("🔄 Running simplified version...")
    
    try:
        # Import and run simple app directly
        import gradio as gr
        from conversation_manager import ConversationManager
        from prompt_engineering import DEFAULT_PARTS
        import random

        # Initialize components
        conv_manager = ConversationManager()

        def generate_persona_response(user_message: str, part_name: str, persona_name: str, user_context: str = None):
            """Generate persona-based response using templates"""
            part_info = DEFAULT_PARTS.get(part_name, {})
            display_name = persona_name or part_info.get("default_persona_name", "חלק פנימי")
            
            # Generate contextual responses based on part type
            if part_name == "הקול הביקורתי":
                responses = [
                    f"אני {display_name}, הקול הביקורתי שלך. שמעתי מה שאמרת על '{user_message}' - אני חושב שצריך לבחון את זה יותר לעומק.",
                    f"אני {display_name}. מה שאמרת מעורר בי שאלות. '{user_message}' - אבל האם זה באמת המצב המלא?",
                    f"זה {display_name} מדבר. אני שומע אותך אומר '{user_message}', אבל אני מרגיש שאנחנו צריכים להיות יותר ביקורתיים כאן."
                ]
            elif part_name == "הילד/ה הפנימית":
                responses = [
                    f"אני {display_name}, הילד/ה הפנימית שלך. מה שאמרת על '{user_message}' גורם לי להרגיש... קצת פגיע.",
                    f"זה {display_name}. '{user_message}' - זה מבהיל אותי קצת. אני צריך לדעת שהכל יהיה בסדר.",
                    f"אני {display_name}, החלק הצעיר שלך. מה שאמרת נוגע ללב שלי."
                ]
            elif part_name == "המרצה":
                responses = [
                    f"אני {display_name}, המרצה שלך. שמעתי את '{user_message}' ואני רוצה לוודא שכולם יהיו בסדר עם זה.",
                    f"זה {display_name}. מה שאמרת על '{user_message}' גורם לי לדאוג - האם זה יכול לפגוע במישהו?",
                    f"אני {display_name}, ואני רוצה שכולם יהיו מרוצים כאן."
                ]
            elif part_name == "המגן":
                responses = [
                    f"אני {display_name}, המגן שלך. '{user_message}' - אני מעריך את המצב. האם זה בטוח?",
                    f"זה {display_name}. שמעתי מה שאמרת על '{user_message}' ואני מיד בכוננות.",
                    f"אני {display_name}, השומר שלך. מה שאמרת מעורר בי את האינסטינקטים המגניים."
                ]
            elif part_name == "הנמנע/ת":
                responses = [
                    f"אני {display_name}, הנמנע/ת שלך. מה שאמרת על '{user_message}' גורם לי לרצות להיסוג קצת.",
                    f"זה {display_name}. '{user_message}' - זה נשמע מורכב ומפחיד. האם יש דרך להימנע מזה?",
                    f"אני {display_name}, ואני מרגיש קצת חרדה מ'{user_message}'."
                ]
            else:
                responses = [
                    f"אני {display_name}, חלק פנימי שלך. שמעתי את '{user_message}' ואני כאן כדי לשוחח איתך על זה.",
                    f"זה {display_name}. מה שאמרת מעניין אותי. '{user_message}' - בואנו נחקור את זה יחד."
                ]
            
            selected_response = random.choice(responses)
            
            if user_context:
                selected_response += f" זכור שאמרת בהתחלה: {user_context[:100]}..."
            
            return selected_response

        def create_session():
            return conv_manager.create_new_session()

        def set_context_and_part(user_context, part_choice, persona_name, state):
            state = conv_manager.set_initial_context(state, "general", user_context)
            state = conv_manager.set_selected_part(state, part_choice, persona_name, None, None)
            
            part_info = DEFAULT_PARTS.get(part_choice, {})
            display_name = persona_name if persona_name else part_info.get("default_persona_name", "חלק פנימי")
            
            return state, f"🗣️ כעת אתה מתשוחח עם: **{display_name}** ({part_choice})"

        def chat_with_part(message, history, state):
            if not message.strip():
                return "", history, state
            
            if not state.selected_part:
                response = "אנא בחר חלק פנימי תחילה"
            else:
                response = generate_persona_response(message, state.selected_part, state.persona_name, state.user_context)
                state = conv_manager.add_to_history(state, message, response)
            
            history.append([message, response])
            return "", history, state

        # Create simplified interface without API docs
        with gr.Blocks(title="מראות - מרחב אישי לשיח פנימי", theme=gr.themes.Soft()) as demo:
            
            conversation_state = gr.State(create_session())
            
            gr.HTML("""
            <div style="text-align: center; margin-bottom: 30px;">
                <h1>🪞 מראות: מרחב אישי לשיח פנימי</h1>
                <p>מקום בטוח לשוחח עם החלקים השונים של עצמך</p>
                <div style="background-color: #e8f5e8; border: 1px solid #4caf50; padding: 10px; margin: 10px 0; border-radius: 5px;">
                    <strong>🤖 מערכת תגובות מותאמת אישית פעילה</strong>
                </div>
            </div>
            """)
            
            with gr.Row():
                with gr.Column():
                    user_context = gr.Textbox(
                        label="ספר על עצמך או על המצב שלך:",
                        placeholder="למשל: אני מתמודד עם לחצים בעבודה...",
                        lines=3
                    )
                    
                    part_choice = gr.Dropdown(
                        label="בחר חלק פנימי לשיחה:",
                        choices=[
                            "הקול הביקורתי",
                            "הילד/ה הפנימית", 
                            "המרצה",
                            "המגן",
                            "הנמנע/ת"
                        ],
                        value="הקול הביקורתי"
                    )
                    
                    persona_name = gr.Textbox(
                        label="שם אישי לחלק (אופציונלי):",
                        placeholder="למשל: דנה, עדן, נועה..."
                    )
                    
                    setup_btn = gr.Button("התחל שיחה", variant="primary")
                    
                with gr.Column():
                    current_part = gr.Markdown("בחר הגדרות ולחץ על 'התחל שיחה'")
            
            # Chat interface
            with gr.Row():
                with gr.Column(scale=2):
                    chatbot = gr.Chatbot(height=400, label="השיחה שלך")
                    
                    with gr.Row():
                        msg_input = gr.Textbox(
                            label="ההודעה שלך:",
                            placeholder="כתוב את המחשבות שלך...",
                            lines=2,
                            scale=4
                        )
                        send_btn = gr.Button("שלח", scale=1)
                    
                    clear_btn = gr.Button("נקה שיחה")
            
            # Event handlers
            setup_btn.click(
                fn=set_context_and_part,
                inputs=[user_context, part_choice, persona_name, conversation_state],
                outputs=[conversation_state, current_part]
            )
            
            msg_input.submit(
                fn=chat_with_part,
                inputs=[msg_input, chatbot, conversation_state],
                outputs=[msg_input, chatbot, conversation_state]
            )
            
            send_btn.click(
                fn=chat_with_part,
                inputs=[msg_input, chatbot, conversation_state],
                outputs=[msg_input, chatbot, conversation_state]
            )
            
            clear_btn.click(
                fn=lambda state: ([], conv_manager.clear_conversation(state)),
                inputs=[conversation_state],
                outputs=[chatbot, conversation_state]
            )

        # Launch with minimal configuration to avoid schema issues
        logger.info("🚀 Launching simplified מראות app...")
        demo.launch(
            server_name="127.0.0.1",
            server_port=port,
            share=True,
            show_api=False,  # Disable API to prevent schema errors
            show_error=True,
            inbrowser=True,
            quiet=False
        )
        return True
        
    except Exception as e:
        logger.error(f"❌ Simplified app failed: {e}")
        return False

def run_app():
    """Run the מראות application"""
    
    logger.info("🪞 Starting מראות application...")
    
    # Check dependencies
    if not check_dependencies():
        logger.error("Dependencies check failed. Exiting.")
        return False
    
    # Find available port
    port = find_available_port()
    logger.info(f"🚀 Using port {port}")
    
    # Set environment variables for local development
    os.environ["GRADIO_SERVER_PORT"] = str(port)
    
    # Try simplified app first (more reliable)
    logger.info("🎯 Starting with simplified version for maximum reliability...")
    success = run_simple_app(port)
    
    if success:
        return True
    
    # If simplified app failed, try subprocess approach
    logger.info("🔄 Trying subprocess approach...")
    try:
        cmd = [sys.executable, "simple_app.py"]
        subprocess.run(cmd, check=True)
        return True
    except Exception as e:
        logger.error(f"❌ Subprocess approach failed: {e}")
        return False

if __name__ == "__main__":
    print("🪞 מראות - Hebrew Self-Reflective AI Agent")
    print("=" * 50)
    
    success = run_app()
    
    if not success:
        print("\n❌ Failed to start application")
        print("📋 Troubleshooting:")
        print("1. Make sure you're in a virtual environment")
        print("2. Install dependencies: pip install -r requirements.txt")
        print("3. Try running directly: python simple_app.py")
        print("4. Check Gradio version: pip install gradio==4.44.0")
        sys.exit(1)
    else:
        print("\n✅ Application started successfully!")