Update app.py

app.py

@@ -1,144 +1,98 @@
-import gradio as gr
+import streamlit as st
+import sys
 import os
-import json
-import datetime
-from pathlib import Path
 
-# Import pages
-from pages.dashboard import create_dashboard_page
-from pages.tasks import create_tasks_page
-from pages.notes import create_notes_page
-from pages.goals import create_goals_page
-from pages.ai_assistant import create_ai_assistant_page
-from pages.search import create_search_page
-from pages.analytics import create_analytics_page
-from pages.focus import create_focus_page
-from pages.integrations_new import create_integrations_page  # Using the new integrations page
-from pages.settings import create_settings_page
-from pages.multimedia import create_multimedia_page
+# Add the current directory to the path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-# Import utilities
-from utils.storage import load_data, save_data
-from utils.state import initialize_state, record_activity
-from utils.config import DATA_DIR, LOGGING_CONFIG
-from utils.logging import get_logger
-from utils.error_handling import handle_exceptions
-
-# Initialize logger
-logger = get_logger(__name__)
-
-# Define sidebar items
-sidebar_items = [
-    "🏠 Dashboard",
-    "📋 Tasks & Projects",
-    "📝 Notes & Docs",
-    "🎯 Goals & Planning",
-    "🤖 AI Assistant Hub",
-    "🔍 Smart Search",
-    "📊 Analytics",
-    "🧘 Focus & Wellness",
-    "🖼️ Multimedia",
-    "🔄 Integrations",
-    "⚙️ Settings"
-]
-
-# Map sidebar items to page creation functions
-page_creators = {
-    "🏠 Dashboard": create_dashboard_page,
-    "📋 Tasks & Projects": create_tasks_page,
-    "📝 Notes & Docs": create_notes_page,
-    "🎯 Goals & Planning": create_goals_page,
-    "🤖 AI Assistant Hub": create_ai_assistant_page,
-    "🔍 Smart Search": create_search_page,
-    "📊 Analytics": create_analytics_page,
-    "🧘 Focus & Wellness": create_focus_page,
-    "🖼️ Multimedia": create_multimedia_page,
-    "🔄 Integrations": create_integrations_page,
-    "⚙️ Settings": create_settings_page
-}
-
-@handle_exceptions
-def create_app():
-    """Create and configure the Gradio application"""
-    logger.info("Initializing Mona application")
+# Import utilities first to test they work
+try:
+    from utils.logging import get_logger
+    from utils.error_handling import DataError, ValidationError
+    from utils.storage import load_data, save_data
+    
+    logger = get_logger(__name__)
+    logger.info("All utilities imported successfully")
     
-    # Initialize application state
-    state = initialize_state()
+except ImportError as e:
+    st.error(f"Import error: {e}")
+    st.stop()
+
+# Now import pages
+try:
+    from pages.dashboard import create_dashboard_page
+    from pages.tasks import create_tasks_page
+except ImportError as e:
+    st.error(f"Pages import error: {e}")
+    # Create fallback functions
+    def create_dashboard_page():
+        st.title("🤖 MONA Dashboard")
+        st.success("✅ All utilities loaded successfully!")
+        st.info("Dashboard is ready to be implemented")
     
-    # Create the Gradio Blocks app
-    with gr.Blocks(title="Mona - AI Productivity Platform", theme=gr.themes.Soft()) as app:
-        # Create header
-        with gr.Row(elem_id="header"):
-            gr.Markdown("# Mona - AI Productivity Platform")
-            
-        # Create main layout with sidebar and content area
-        with gr.Row():
-            # Sidebar navigation
-            with gr.Column(scale=1, elem_id="sidebar"):
-                # User profile section
-                with gr.Group(elem_id="user-profile"):
-                    gr.Markdown("### Welcome!")
-                
-                # Navigation menu
-                selected_page = gr.Radio(
-                    choices=sidebar_items,
-                    value=sidebar_items[0],
-                    label="Navigation",
-                    elem_id="nav-menu"
-                )
-                
-                # App info
-                with gr.Group(elem_id="app-info"):
-                    gr.Markdown("v0.1.0 | Using Free AI Models")
-            
-            # Main content area
-            with gr.Column(scale=4, elem_id="content-area"):
-                # Create a container for each page
-                for page_name, create_page in page_creators.items():
-                    with gr.Group(visible=(page_name == sidebar_items[0])) as page_container:
-                        create_page(state)
-                    # Store the container in state for navigation
-                    state[f"{page_name}_container"] = page_container
+    def create_tasks_page():
+        st.title("📋 MONA Tasks")
+        st.success("✅ All utilities loaded successfully!")
+        st.info("Tasks page is ready to be implemented")
         
-        # Handle navigation changes
-        @handle_exceptions
-        def change_page(page_name):
-            """Show the selected page and hide others"""
-            logger.debug(f"Navigating to page: {page_name}")
-            return [gr.update(visible=(name == page_name)) for name in sidebar_items]
+        # Test data operations
+        st.subheader("Testing Data Operations")
         
-        # Set up navigation event handler
-        page_containers = [state[f"{name}_container"] for name in sidebar_items]
-        selected_page.change(change_page, inputs=selected_page, outputs=page_containers)
+        if st.button("Test Save Data"):
+            test_data = {"message": "Hello MONA!", "status": "working"}
+            try:
+                success = save_data(test_data, "test.json", "json")
+                if success:
+                    st.success("Data saved successfully!")
+                else:
+                    st.error("Failed to save data")
+            except Exception as e:
+                st.error(f"Save error: {e}")
         
-        # Record app usage for analytics
-        @handle_exceptions
-        def record_app_usage():
-            """Record app usage for analytics"""
-            logger.info("Recording app usage")
-            
-            # Record activity using the centralized function
-            # Commented out due to incorrect parameters
-            # record_activity requires state, activity_type, and title
-            # record_activity({
-            #     "type": "app_opened",
-            #     "timestamp": datetime.datetime.now().isoformat()
-            # })
-            
-            # Correct implementation would be:
-            # record_activity(state, "app_opened", "Application Started")
+        if st.button("Test Load Data"):
+            try:
+                data = load_data("test.json", "json")
+                if data:
+                    st.success("Data loaded successfully!")
+                    st.json(data)
+                else:
+                    st.warning("No data found")
+            except Exception as e:
+                st.error(f"Load error: {e}")
+
+def main():
+    """Main application entry point"""
+    st.set_page_config(
+        page_title="MONA",
+        page_icon="🤖",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Initialize data directory
+    from utils.storage import ensure_data_directory
+    ensure_data_directory()
+    
+    # Initialize state
+    from utils.state import init_session_state
+    init_session_state()
+    
+    # Sidebar navigation
+    with st.sidebar:
+        st.title("🤖 MONA")
+        st.markdown("---")
         
-        # Record app usage on load
-        app.load(record_app_usage)
+        page = st.radio(
+            "Navigation",
+            ["Dashboard", "Tasks"],
+            index=0
+        )
     
-    logger.info("Mona application initialized successfully")
-    return app
+    # Route to appropriate page
+    if page == "Dashboard":
+        create_dashboard_page()
+    elif page == "Tasks":
+        create_tasks_page()
 
 if __name__ == "__main__":
-    try:
-        logger.info("Starting Mona application")
-        app = create_app()
-        app.launch()
-    except Exception as e:
-        logger.error(f"Failed to start application: {str(e)}")
-        raise
+    main()