streamlit_app.py

"""
FunctionMac - Streamlit Web App
Provides a web interface to interact with all macOS functions locally using natural language
"""

import streamlit as st
import json
import traceback
from datetime import datetime
from macos_functions import AVAILABLE_FUNCTIONS
from macos_ai_assistant import MacOSAIAssistant

# Configure page
st.set_page_config(
    page_title="FunctionMac",
    page_icon="🍎",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS for better styling
st.markdown("""
<style>
    .main-header {
        text-align: center;
        color: #1f77b4;
        padding: 20px 0;
    }
    .function-card {
        background-color: #f8f9fa;
        padding: 15px;
        border-radius: 10px;
        border: 1px solid #e9ecef;
        margin: 10px 0;
    }
    .success-box {
        background-color: #d4edda;
        border: 1px solid #c3e6cb;
        color: #155724;
        padding: 15px;
        border-radius: 5px;
        margin: 10px 0;
    }
    .error-box {
        background-color: #f8d7da;
        border: 1px solid #f5c6cb;
        color: #721c24;
        padding: 15px;
        border-radius: 5px;
        margin: 10px 0;
    }
</style>
""", unsafe_allow_html=True)

# Main title
st.markdown('<h1 class="main-header">🍎 FunctionMac</h1>', unsafe_allow_html=True)
st.markdown('<p style="text-align: center; color: #6c757d;">Natural language control for macOS - runs 100% locally</p>', unsafe_allow_html=True)

# Function categories
FUNCTION_CATEGORIES = {
    "📋 Basic System": [
        "take_screenshot", "copy_to_clipboard", "get_clipboard_content", "paste_from_clipboard"
    ],
    "🎨 Theme & Appearance": [
        "change_theme", "get_current_theme"
    ],
    "🔊 Audio Control": [
        "set_volume", "get_volume", "mute_volume", "unmute_volume"
    ],
    "💡 Display Control": [
        "set_brightness", "get_brightness"
    ],
    "🔕 Do Not Disturb": [
        "enable_do_not_disturb", "disable_do_not_disturb"
    ],
    "📂 File Operations": [
        "find_files", "open_file", "open_folder", "process_text_file"
    ],
    "📱 Applications": [
        "open_application", "quit_application", "list_running_applications"
    ],
    "📊 System Information": [
        "get_battery_info", "get_system_info", "get_cpu_usage", "get_memory_usage", "get_disk_usage"
    ],
    "🖱️ GUI Automation": [
        "click_at_coordinates", "drag_mouse", "type_text", "send_keyboard_shortcut", "scroll_screen", 
        "get_mouse_position", "get_screen_info"
    ],
    "📅 Productivity": [
        "create_reminder", "send_message", "get_calendar_events", "get_current_datetime"
    ],
    "🎵 Music Control": [
        "control_music"
    ],
    "🧮 Data & Analysis": [
        "calculate_expression", "analyze_data", "generate_qr_code"
    ],
    "🌐 Network": [
        "get_wifi_networks"
    ],
    "🔧 Utilities": [
        "run_applescript", "run_shell_command", "execute_function"
    ]
}

def execute_function(func_name: str, params: dict) -> dict:
    """Execute a function with given parameters and return result"""
    try:
        if func_name not in AVAILABLE_FUNCTIONS:
            return {"success": False, "error": f"Function '{func_name}' not found"}
        
        func = AVAILABLE_FUNCTIONS[func_name]
        result = func(**params)
        
        # Parse JSON result if it's a string
        if isinstance(result, str):
            try:
                result = json.loads(result)
            except:
                result = {"success": True, "message": result}
        
        return result
    except Exception as e:
        return {"success": False, "error": f"Error executing {func_name}: {str(e)}"}

def display_result(result: dict):
    """Display function execution result"""
    if result.get("success"):
        st.markdown('<div class="success-box">✅ Success!</div>', unsafe_allow_html=True)
        
        # Display message if available
        if "message" in result:
            st.info(f"**Message:** {result['message']}")
        
        # Display result data (excluding success and message)
        result_data = {k: v for k, v in result.items() if k not in ['success', 'message']}
        if result_data:
            st.json(result_data)
    else:
        st.markdown('<div class="error-box">❌ Error occurred!</div>', unsafe_allow_html=True)
        st.error(f"**Error:** {result.get('error', 'Unknown error')}")

# Sidebar for mode selection
st.sidebar.title("🚀 Interface Mode")
app_mode = st.sidebar.radio(
    "Choose how to interact:",
    ["🤖 AI Assistant", "🔧 Direct Functions"],
    help="AI Assistant uses natural language with Ollama, Direct Functions provides immediate access"
)

# Initialize AI Assistant if needed
if app_mode == "🤖 AI Assistant":
    if 'ai_assistant' not in st.session_state:
        try:
            st.session_state.ai_assistant = MacOSAIAssistant()
            st.session_state.ai_ready = True
        except Exception as e:
            st.session_state.ai_ready = False
            st.session_state.ai_error = str(e)

# Main content area based on selected mode
if app_mode == "🤖 AI Assistant":
    st.header("🤖 AI Assistant Mode")
    
    if not st.session_state.get('ai_ready', False):
        st.error("❌ AI Assistant not available")
        st.error(f"Error: {st.session_state.get('ai_error', 'Unknown error')}")
        st.info("Make sure Ollama is running and FunctionGemma model is installed:")
        st.code("ollama pull functiongemma:270m")
    else:
        st.success("✅ AI Assistant ready!")
        st.markdown("Type your requests in natural language and I'll help you control your Mac.")
        
        # Example queries
        with st.expander("💡 Example Queries"):
            st.markdown("""
            - "Take a screenshot and save it to desktop"
            - "Set volume to 50 percent"
            - "Turn on dark mode"
            - "Show me battery information"
            - "Find all PDF files in my Documents folder"
            - "Get my current system information"
            - "Set brightness to 70%"
            - "What's my CPU usage?"
            """)
        
        # Chat interface
        st.markdown("---")
        
        # Initialize chat history
        if 'chat_history' not in st.session_state:
            st.session_state.chat_history = []
        
        # Display chat history
        chat_container = st.container()
        with chat_container:
            for i, chat in enumerate(st.session_state.chat_history):
                with st.chat_message("user"):
                    st.write(chat['query'])
                
                with st.chat_message("assistant"):
                    if chat['success']:
                        st.write(chat['final_response'])
                        
                        # Show function calls if any
                        if chat.get('function_calls'):
                            with st.expander(f"🔧 Function Details ({len(chat['function_calls'])} called)"):
                                for func_call in chat['function_calls']:
                                    if func_call['success']:
                                        st.success(f"✅ {func_call['function']}")
                                        if func_call.get('arguments'):
                                            st.json(func_call['arguments'])
                                    else:
                                        st.error(f"❌ {func_call['function']}: {func_call.get('error', 'Unknown error')}")
                    else:
                        st.error(f"❌ {chat.get('error', 'Unknown error')}")
        
        # Query input
        user_query = st.chat_input("Ask me anything about your Mac...")
        
        if user_query:
            # Add user message to history immediately
            st.session_state.chat_history.append({
                'query': user_query,
                'success': False,
                'processing': True
            })
            
            # Process the query
            with st.spinner("🤖 Processing your request..."):
                try:
                    result = st.session_state.ai_assistant.process_query(user_query)
                    
                    # Update the last entry with results
                    st.session_state.chat_history[-1] = result
                    
                except Exception as e:
                    st.session_state.chat_history[-1] = {
                        'query': user_query,
                        'error': str(e),
                        'success': False
                    }
            
            # Rerun to show the new message
            st.rerun()

else:
    # Direct Functions Mode
    st.header("🔧 Direct Functions Mode")
    st.sidebar.title("🛠️ Function Categories")
    selected_category = st.sidebar.selectbox("Choose a category:", list(FUNCTION_CATEGORIES.keys()))

    # Get functions for selected category
    category_functions = FUNCTION_CATEGORIES[selected_category]

    for func_name in category_functions:
        with st.expander(f"🔧 {func_name.replace('_', ' ').title()}"):
            func = AVAILABLE_FUNCTIONS[func_name]
            
            # Display function documentation
            if func.__doc__:
                st.markdown(f"**Description:** {func.__doc__.strip()}")
            
            # Create input fields based on function signature
            import inspect
            sig = inspect.signature(func)
            params = {}
            
            for param_name, param in sig.parameters.items():
                param_type = param.annotation if param.annotation != inspect.Parameter.empty else str
                default_value = param.default if param.default != inspect.Parameter.empty else None
                
                # Create appropriate input widget based on parameter type
                if param_type == int:
                    if default_value is not None:
                        params[param_name] = st.number_input(f"{param_name}:", value=default_value, key=f"{func_name}_{param_name}")
                    else:
                        params[param_name] = st.number_input(f"{param_name}:", key=f"{func_name}_{param_name}")
                elif param_type == float:
                    if default_value is not None:
                        params[param_name] = st.number_input(f"{param_name}:", value=float(default_value), key=f"{func_name}_{param_name}")
                    else:
                        params[param_name] = st.number_input(f"{param_name}:", value=0.0, key=f"{func_name}_{param_name}")
                elif param_type == bool:
                    default_bool = default_value if default_value is not None else False
                    params[param_name] = st.checkbox(f"{param_name}:", value=default_bool, key=f"{func_name}_{param_name}")
                elif param_type == list or "List" in str(param_type):
                    list_input = st.text_area(f"{param_name} (comma-separated):", key=f"{func_name}_{param_name}")
                    if list_input.strip():
                        try:
                            # Try to parse as numbers if possible
                            params[param_name] = [float(x.strip()) for x in list_input.split(',')]
                        except ValueError:
                            params[param_name] = [x.strip() for x in list_input.split(',')]
                    else:
                        params[param_name] = []
                else:
                    # String or other types
                    if default_value is not None and default_value != "":
                        params[param_name] = st.text_input(f"{param_name}:", value=str(default_value), key=f"{func_name}_{param_name}")
                    else:
                        params[param_name] = st.text_input(f"{param_name}:", key=f"{func_name}_{param_name}")
                
                # Remove empty parameters if they have defaults
                if default_value is not None and params[param_name] == (0 if param_type in [int, float] else ""):
                    if param_name in params:
                        del params[param_name]
            
            # Execute button
            if st.button(f"Execute {func_name}", key=f"execute_{func_name}"):
                with st.spinner("Executing..."):
                    result = execute_function(func_name, params)
                    display_result(result)

# Footer
st.markdown("---")
st.markdown("**ℹ️ About:** This app provides direct access to all macOS functions without requiring the AI assistant or Ollama.")
st.markdown("**⚠️ Note:** Some functions may require special permissions on macOS. Please grant necessary permissions when prompted.")

# Add execution log in sidebar
if st.sidebar.checkbox("Show Execution Log"):
    st.sidebar.subheader("📝 Recent Executions")
    # This would store execution history if needed
    if 'execution_log' not in st.session_state:
        st.session_state.execution_log = []
    
    for i, log_entry in enumerate(reversed(st.session_state.execution_log[-5:])):
        st.sidebar.text(f"{log_entry['time']}: {log_entry['function']}")
        if log_entry['success']:
            st.sidebar.success("✅")
        else:
            st.sidebar.error("❌")

# Quick actions sidebar
st.sidebar.markdown("---")
st.sidebar.subheader("🚀 Quick Actions")

# Quick screenshot
if st.sidebar.button("📸 Take Screenshot"):
    result = execute_function("take_screenshot", {})
    st.sidebar.write("Screenshot result:")
    if result.get("success"):
        st.sidebar.success("✅ Screenshot taken!")
    else:
        st.sidebar.error("❌ Failed")

# Quick system info
if st.sidebar.button("📊 System Info"):
    result = execute_function("get_system_info", {})
    st.sidebar.write("System info retrieved")

# Quick battery info
if st.sidebar.button("🔋 Battery Info"):
    result = execute_function("get_battery_info", {})
    st.sidebar.write("Battery info retrieved")