abstractassistant 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

abstractassistant/app.py

@@ -33,7 +33,8 @@ class EnhancedClickableIcon(pystray.Icon):
         self.DOUBLE_CLICK_TIMEOUT = 300  # milliseconds
 
         if self.debug:
-            print(f"🔄 EnhancedClickableIcon created with single_click: {single_click_handler is not None}, double_click: {double_click_handler is not None}")
+            if hasattr(self, 'debug') and self.debug:
+                print(f"🔄 EnhancedClickableIcon created with single_click: {single_click_handler is not None}, double_click: {double_click_handler is not None}")
 
         # Create with no menu initially
         super().__init__(name, image, text, menu=None)
@@ -42,7 +43,8 @@ class EnhancedClickableIcon(pystray.Icon):
     def _menu(self):
         """Override _menu property to intercept access and handle click timing."""
         if self.debug:
-            print(f"🔍 _menu property accessed! Click count: {self.click_count}")
+            if hasattr(self, 'debug') and self.debug:
+                print(f"🔍 _menu property accessed! Click count: {self.click_count}")
 
         self._handle_click_timing()
         # Return None so no menu is displayed
@@ -66,7 +68,8 @@ class EnhancedClickableIcon(pystray.Icon):
             self.click_timer.start()
 
             if self.debug:
-                print("🔄 First click detected, starting timer...")
+                if hasattr(self, 'debug') and self.debug:
+                    print("🔄 First click detected, starting timer...")
 
         elif self.click_count == 2:
             # Second click - cancel timer and execute double click
@@ -78,7 +81,8 @@ class EnhancedClickableIcon(pystray.Icon):
             self._execute_double_click()
 
             if self.debug:
-                print("🔄 Double click detected!")
+                if hasattr(self, 'debug') and self.debug:
+                    print("🔄 Double click detected!")
 
     def _execute_single_click(self):
         """Execute single click handler after timeout."""
@@ -86,13 +90,15 @@ class EnhancedClickableIcon(pystray.Icon):
         self.click_timer = None
 
         if self.debug:
-            print("✅ Single click detected on system tray icon!")
+            if hasattr(self, 'debug') and self.debug:
+                print("✅ Single click detected on system tray icon!")
 
         if self.single_click_handler:
             try:
                 self.single_click_handler()
             except Exception as e:
-                print(f"❌ Single click handler error: {e}")
+                if hasattr(self, 'debug') and self.debug:
+                    print(f"❌ Single click handler error: {e}")
                 if self.debug:
                     import traceback
                     traceback.print_exc()
@@ -100,13 +106,15 @@ class EnhancedClickableIcon(pystray.Icon):
     def _execute_double_click(self):
         """Execute double click handler immediately."""
         if self.debug:
-            print("✅ Double click detected on system tray icon!")
+            if hasattr(self, 'debug') and self.debug:
+                print("✅ Double click detected on system tray icon!")
 
         if self.double_click_handler:
             try:
                 self.double_click_handler()
             except Exception as e:
-                print(f"❌ Double click handler error: {e}")
+                if hasattr(self, 'debug') and self.debug:
+                    print(f"❌ Double click handler error: {e}")
                 if self.debug:
                     import traceback
                     traceback.print_exc()
@@ -115,7 +123,8 @@ class EnhancedClickableIcon(pystray.Icon):
     def _menu(self, value):
         """Allow setting _menu during initialization."""
         if self.debug:
-            print(f"🔍 _menu property set to: {value}")
+            if hasattr(self, 'debug') and self.debug:
+                print(f"🔍 _menu property set to: {value}")
         self._stored_menu = value
 
 
@@ -136,7 +145,8 @@ class AbstractAssistantApp:
         
         # Validate configuration
         if not self.config.validate():
-            print("Warning: Configuration validation failed, using defaults")
+            if self.debug:
+                print("Warning: Configuration validation failed, using defaults")
             self.config = Config.default()
         
         # Initialize components
@@ -149,19 +159,31 @@ class AbstractAssistantApp:
         self.is_running: bool = False
         self.bubble_visible: bool = False
         
+        # Icon animation state
+        self.base_icon: Optional[Image.Image] = None
+        self.animation_timer: Optional[threading.Timer] = None
+        self.current_status: str = "ready"
+        
         if self.debug:
             print(f"AbstractAssistant initialized with config: {self.config.to_dict()}")
         
     def create_system_tray_icon(self) -> pystray.Icon:
         """Create and configure the system tray icon."""
-        # Generate a modern, clean icon - start with ready state (green, steady)
-        icon_image = self.icon_generator.create_app_icon(
-            color_scheme="green",  # Ready state: steady green
-            animated=False         # Ready state: no animation
-        )
+        # Try to use the app bundle icon first, fallback to generated icon
+        self.base_icon = self._load_app_bundle_icon()
+        if not self.base_icon:
+            # Generate a modern, clean icon - start with ready state (green, steady)
+            self.base_icon = self.icon_generator.create_app_icon(
+                color_scheme="green",  # Ready state: steady green
+                animated=False         # Ready state: no animation
+            )
+
+        # Apply initial heartbeat effect
+        icon_image = self.icon_generator.apply_heartbeat_effect(self.base_icon, "ready")
 
         if self.debug:
-            print("🔄 Creating enhanced system tray icon with single/double click detection")
+            if self.debug:
+                print("🔄 Creating enhanced system tray icon with single/double click detection")
 
         # Use our enhanced ClickableIcon for single/double click handling
         return EnhancedClickableIcon(
@@ -173,138 +195,189 @@ class AbstractAssistantApp:
             debug=self.debug
         )
     
+    def _load_app_bundle_icon(self) -> Optional[Image.Image]:
+        """Load the icon from the app bundle if available."""
+        try:
+            from pathlib import Path
+            # Try to find the app bundle icon
+            app_bundle_icon = Path("/Applications/AbstractAssistant.app/Contents/Resources/icon.png")
+            
+            if self.debug:
+                if self.debug:
+                    print(f"🔍 Looking for app bundle icon at: {app_bundle_icon}")
+                    print(f"   Exists: {app_bundle_icon.exists()}")
+            
+            if app_bundle_icon.exists():
+                base_icon = Image.open(app_bundle_icon)
+                
+                if self.debug:
+                    if self.debug:
+                        print(f"✅ Loaded app bundle icon: {base_icon.size} {base_icon.mode}")
+                
+                # Resize to system tray size if needed
+                target_size = (self.config.system_tray.icon_size, self.config.system_tray.icon_size)
+                if base_icon.size != target_size:
+                    if self.debug:
+                        if self.debug:
+                            print(f"🔄 Resizing from {base_icon.size} to {target_size}")
+                    base_icon = base_icon.resize(target_size, Image.Resampling.LANCZOS)
+                
+                return base_icon
+        except Exception as e:
+            if self.debug:
+                if self.debug:
+                    print(f"❌ Could not load app bundle icon: {e}")
+        return None
+    
     def update_icon_status(self, status: str):
         """Update the system tray icon based on application status.
         
         Args:
-            status: 'ready', 'generating', 'executing', 'thinking'
+            status: 'ready', 'generating', 'executing', 'thinking', 'speaking'
         """
-        if not self.icon:
+        if self.debug:
+            print(f"🔄 update_icon_status called with: {status}")
+            print(f"   Previous status: {self.current_status}")
+        
+        if not self.icon and not (hasattr(self, 'qt_tray_icon') and self.qt_tray_icon):
+            if self.debug:
+                print("⚠️  No icon available for status update")
             return
-            
+        
+        if not self.base_icon:
+            if self.debug:
+                print("⚠️  No base icon available for status update")
+            return
+        
         try:
-            if status == "ready":
-                # Ready: gentle heartbeat green
-                self._stop_working_animation()
-                self._start_ready_animation()
-            elif status in ["generating", "executing", "thinking"]:
-                # Working: start continuous animation with cycling colors
-                self._start_working_animation()
-                return  # Don't update icon here, let the timer handle it
+            # Stop any existing animation timer
+            self._stop_animation_timer()
+            
+            # Map status to animation type
+            animation_status = status
+            if status in ["thinking", "generating", "executing"]:
+                animation_status = "thinking"  # All working states use thinking animation
+            elif status == "speaking":
+                animation_status = "speaking"
             else:
-                # Default: steady green
-                icon_image = self.icon_generator.create_app_icon(
-                    color_scheme="green",
-                    animated=False
-                )
+                animation_status = "ready"  # Default to ready
             
-            # Update the icon
-            self.icon.icon = icon_image
+            # Update current status AFTER determining animation type
+            self.current_status = animation_status
+            
+            # Start appropriate animation
+            self._start_heartbeat_animation(animation_status)
             
             if self.debug:
-                print(f"🎨 Updated icon status to: {status}")
+                print(f"🎨 Updated icon status: {status} -> animation: {animation_status}")
                 
         except Exception as e:
             if self.debug:
                 print(f"❌ Error updating icon status: {e}")
     
-    def _start_working_animation(self):
-        """Start the working animation timer for continuous icon updates."""
+    def _start_heartbeat_animation(self, status: str):
+        """Start smooth heartbeat animation for the given status."""
+        if self.debug:
+            print(f"🎬 Starting smooth heartbeat animation for: {status}")
+            print(f"   pystray icon available: {self.icon is not None}")
+            print(f"   Qt icon available: {hasattr(self, 'qt_tray_icon') and self.qt_tray_icon is not None}")
+            print(f"   Base icon available: {self.base_icon is not None}")
+        
+        # Stop any existing animation
+        self._stop_animation_timer()
+        
+        # Use Qt timer if we're in Qt mode, otherwise use threading timer
+        if hasattr(self, 'qt_tray_icon') and self.qt_tray_icon is not None:
+            self._start_qt_animation(status)
+        else:
+            self._start_threading_animation(status)
+    
+    def _start_qt_animation(self, status: str):
+        """Start Qt-based animation using QTimer."""
         try:
-            import threading
-            import time
-            
-            # Stop any existing timer
-            self._stop_working_animation()
-            
-            # Create a heartbeat-like animation with dynamic timing
-            def update_working_icon():
-                if self.icon:
-                    try:
-                        icon_image = self.icon_generator.create_app_icon(
-                            color_scheme="working",
-                            animated=True
-                        )
-                        self.icon.icon = icon_image
-                    except Exception as e:
-                        if self.debug:
-                            print(f"❌ Error updating working icon: {e}")
+            from PyQt5.QtCore import QTimer
             
-            # Heartbeat-like timer with dynamic intervals
-            def heartbeat_timer_loop():
-                while hasattr(self, 'working_active') and self.working_active:
-                    # Fast heartbeat pattern: beat-beat-pause
-                    update_working_icon()
-                    time.sleep(0.1)  # First beat
-                    update_working_icon()
-                    time.sleep(0.1)  # Second beat
-                    update_working_icon()
-                    time.sleep(0.8)  # Longer pause between heartbeats
+            def update_icon():
+                try:
+                    if self.base_icon and self.current_status == status and hasattr(self, 'qt_tray_icon'):
+                        # Apply smooth heartbeat effect
+                        icon_image = self.icon_generator.apply_heartbeat_effect(self.base_icon, status)
+                        self._update_qt_icon(icon_image)
+                    elif self.debug:
+                        print(f"⚠️  Qt animation stopped - status_match:{self.current_status == status}")
+                        if hasattr(self, 'qt_animation_timer'):
+                            self.qt_animation_timer.stop()
+                except Exception as e:
+                    if self.debug:
+                        print(f"❌ Error in Qt animation: {e}")
             
-            self.working_active = True
-            self.working_timer = threading.Thread(target=heartbeat_timer_loop, daemon=True)
-            self.working_timer.start()
+            # Create Qt timer for smooth animation
+            self.qt_animation_timer = QTimer()
+            self.qt_animation_timer.timeout.connect(update_icon)
+            self.qt_animation_timer.start(50)  # 20 FPS (50ms intervals)
             
             if self.debug:
-                print("🎨 Started working animation")
+                print("✅ Qt animation timer started")
                 
         except Exception as e:
             if self.debug:
-                print(f"❌ Error starting working animation: {e}")
+                print(f"❌ Error starting Qt animation: {e}")
+    
+    def _start_threading_animation(self, status: str):
+        """Start threading-based animation using threading.Timer."""
+        def update_icon():
+            try:
+                if self.icon and self.base_icon and self.current_status == status:
+                    # Apply smooth heartbeat effect
+                    icon_image = self.icon_generator.apply_heartbeat_effect(self.base_icon, status)
+                    self.icon.icon = icon_image
+                    
+                    # Schedule next update at 20 FPS for smooth animation
+                    self.animation_timer = threading.Timer(0.05, update_icon)
+                    self.animation_timer.start()
+                elif self.debug:
+                    print(f"⚠️  Threading animation stopped - status_match:{self.current_status == status}")
+            except Exception as e:
+                if self.debug:
+                    print(f"❌ Error in threading animation: {e}")
+        
+        # Start the threading animation
+        update_icon()
     
-    def _start_ready_animation(self):
-        """Start the gentle ready state heartbeat animation."""
+    def _update_qt_icon(self, icon_image):
+        """Update Qt system tray icon with new image."""
         try:
-            import threading
-            import time
-            
-            # Stop any existing animations
-            self._stop_working_animation()
-            self._stop_ready_animation()
+            from PyQt5.QtGui import QIcon, QPixmap
+            import io
             
-            def update_ready_icon():
-                if self.icon:
-                    try:
-                        icon_image = self.icon_generator.create_app_icon(
-                            color_scheme="green",
-                            animated=True
-                        )
-                        self.icon.icon = icon_image
-                    except Exception as e:
-                        if self.debug:
-                            print(f"❌ Error updating ready icon: {e}")
+            # Convert PIL image to QPixmap
+            img_buffer = io.BytesIO()
+            icon_image.save(img_buffer, format='PNG')
+            img_buffer.seek(0)
             
-            # Gentle heartbeat timer - slower, more subtle
-            def ready_timer_loop():
-                while hasattr(self, 'ready_active') and self.ready_active:
-                    update_ready_icon()
-                    time.sleep(0.1)  # Update every 100ms for smooth animation
+            pixmap = QPixmap()
+            pixmap.loadFromData(img_buffer.getvalue())
+            qt_icon = QIcon(pixmap)
             
-            self.ready_active = True
-            self.ready_timer = threading.Thread(target=ready_timer_loop, daemon=True)
-            self.ready_timer.start()
+            # Update the Qt tray icon
+            self.qt_tray_icon.setIcon(qt_icon)
             
-            if self.debug:
-                print("🎨 Started ready heartbeat animation")
-                
         except Exception as e:
             if self.debug:
-                print(f"❌ Error starting ready animation: {e}")
+                print(f"❌ Error updating Qt icon: {e}")
     
-    def _stop_ready_animation(self):
-        """Stop the ready animation."""
-        if hasattr(self, 'ready_active'):
-            self.ready_active = False
-        if self.debug:
-            print("🎨 Stopped ready animation")
+    def _stop_animation_timer(self):
+        """Stop the current animation timer (both Qt and threading)."""
+        # Stop Qt timer if it exists
+        if hasattr(self, 'qt_animation_timer') and self.qt_animation_timer:
+            self.qt_animation_timer.stop()
+            self.qt_animation_timer = None
+        
+        # Stop threading timer if it exists
+        if hasattr(self, 'animation_timer') and self.animation_timer:
+            self.animation_timer.cancel()
+            self.animation_timer = None
     
-    def _stop_working_animation(self):
-        """Stop the working animation."""
-        if hasattr(self, 'working_active'):
-            self.working_active = False
-        self._stop_ready_animation()  # Also stop ready animation
-        if self.debug:
-            print("🎨 Stopped working animation")
 
     
     def show_chat_bubble(self, icon=None, item=None):
@@ -501,10 +574,12 @@ class AbstractAssistantApp:
     def show_toast_notification(self, message: str, type: str = "info"):
         """Show a toast notification."""
         icon = "✅" if type == "success" else "❌" if type == "error" else "ℹ️"
-        print(f"{icon} {message}")
+        if self.debug:
+            print(f"{icon} {message}")
         
         if self.debug:
-            print(f"Toast notification: {type} - {message}")
+            if self.debug:
+                print(f"Toast notification: {type} - {message}")
         
         # Show a proper macOS notification
         try:
@@ -538,22 +613,40 @@ class AbstractAssistantApp:
         """Update application status."""
         # Status is now handled by the web interface
         if self.debug:
-            print(f"Status update: {status}")
+            if self.debug:
+                print(f"Status update: {status}")
     
     def clear_session(self, icon=None, item=None):
-        """Clear the current session."""
+        """Clear the current session with user confirmation."""
         try:
             if self.debug:
-                print("🔄 Clearing session...")
+                print("🔄 System tray clear session requested...")
             
-            self.llm_manager.clear_session()
+            # CRITICAL: System tray actions MUST have user confirmation
+            # Use the bubble's clear_session method which includes confirmation dialog
+            if hasattr(self, 'bubble_manager') and self.bubble_manager:
+                # Delegate to bubble manager which has proper user confirmation
+                bubble = self.bubble_manager.get_current_bubble()
+                if bubble:
+                    bubble.clear_session()  # This includes user confirmation dialog
+                    return
             
+            # Fallback: Show notification that clearing requires UI interaction
+            try:
+                from .ui.toast_window import show_toast_notification
+                show_toast_notification(
+                    "To clear session, please use the Clear button in the chat interface", 
+                    debug=self.debug
+                )
+            except:
+                print("💬 To clear session, please use the Clear button in the chat interface")
+                
             if self.debug:
-                print("✅ Session cleared")
+                print("⚠️  System tray clear session requires user confirmation via UI")
                 
         except Exception as e:
             if self.debug:
-                print(f"❌ Error clearing session: {e}")
+                print(f"❌ Error in clear session request: {e}")
     
     def save_session(self, icon=None, item=None):
         """Save the current session to file."""
@@ -593,58 +686,36 @@ class AbstractAssistantApp:
                 print(f"❌ Error saving session: {e}")
     
     def load_session(self, icon=None, item=None):
-        """Load a session from file."""
+        """Load a session from file with user confirmation."""
         try:
             if self.debug:
-                print("🔄 Loading session...")
-            
-            # Get sessions directory
-            import os
-            sessions_dir = os.path.join(os.path.expanduser("~"), ".abstractassistant", "sessions")
-            
-            if not os.path.exists(sessions_dir):
-                if self.debug:
-                    print("❌ No sessions directory found")
-                return
-            
-            # Get list of session files
-            session_files = [f for f in os.listdir(sessions_dir) if f.endswith('.json')]
+                print("🔄 System tray load session requested...")
             
-            if not session_files:
-                if self.debug:
-                    print("❌ No session files found")
-                try:
-                    from .ui.toast_window import show_toast_notification
-                    show_toast_notification("No saved sessions found", debug=self.debug)
-                except:
-                    print("📂 No saved sessions found")
-                return
-            
-            # For now, load the most recent session
-            # TODO: Add proper file picker dialog
-            session_files.sort(reverse=True)  # Most recent first
-            latest_session = session_files[0]
-            filepath = os.path.join(sessions_dir, latest_session)
-            
-            # Load session
-            success = self.llm_manager.load_session(filepath)
+            # CRITICAL: System tray actions MUST NOT automatically replace sessions
+            # Use the bubble's load_session method which includes proper file picker
+            if hasattr(self, 'bubble_manager') and self.bubble_manager:
+                # Delegate to bubble manager which has proper user file selection
+                bubble = self.bubble_manager.get_current_bubble()
+                if bubble:
+                    bubble.load_session()  # This includes user file picker dialog
+                    return
             
-            if success:
-                if self.debug:
-                    print(f"✅ Session loaded from: {filepath}")
-                # Show notification
-                try:
-                    from .ui.toast_window import show_toast_notification
-                    show_toast_notification(f"Session loaded:\n{latest_session}", debug=self.debug)
-                except:
-                    print(f"📂 Session loaded: {latest_session}")
-            else:
-                if self.debug:
-                    print("❌ Failed to load session")
+            # Fallback: Show notification that loading requires UI interaction
+            try:
+                from .ui.toast_window import show_toast_notification
+                show_toast_notification(
+                    "To load session, please use the Load button in the chat interface", 
+                    debug=self.debug
+                )
+            except:
+                print("💬 To load session, please use the Load button in the chat interface")
+                
+            if self.debug:
+                print("⚠️  System tray load session requires user file selection via UI")
                 
         except Exception as e:
             if self.debug:
-                print(f"❌ Error loading session: {e}")
+                print(f"❌ Error in load session request: {e}")
 
     def _preflight_initialization(self):
         """Pre-initialize components for instant bubble display on first click."""
@@ -667,7 +738,7 @@ class AbstractAssistantApp:
                 # Set up callbacks
                 self.bubble_manager.set_response_callback(self.handle_bubble_response)
                 self.bubble_manager.set_error_callback(self.handle_bubble_error)
-                self.bubble_manager.set_status_callback(self.update_icon_status)
+                # Note: Status callback will be set after preflight initialization to avoid TTS init interference
                 self.bubble_manager.set_app_quit_callback(self.quit_application)
 
                 if self.debug:
@@ -680,6 +751,12 @@ class AbstractAssistantApp:
             # This creates the bubble without showing it
             self.bubble_manager._prepare_bubble()
 
+            # Now set the status callback after TTS initialization is complete
+            if self.bubble_manager:
+                self.bubble_manager.set_status_callback(self.update_icon_status)
+                if self.debug:
+                    print("✅ Status callback set after TTS initialization")
+
             if self.debug:
                 print("✅ Preflight initialization completed - bubble ready for instant display")
 
@@ -687,10 +764,21 @@ class AbstractAssistantApp:
             if self.debug:
                 print(f"⚠️  Preflight initialization failed: {e}")
                 print("   First click will still work but with delay")
+            
+            # Still set status callback even if preflight failed
+            if self.bubble_manager:
+                self.bubble_manager.set_status_callback(self.update_icon_status)
 
     def quit_application(self, icon=None, item=None):
         """Quit the application gracefully."""
+        if self.debug:
+            print("🔄 Quitting AbstractAssistant...")
+        
         self.is_running = False
+        
+        # Stop animation timer
+        self._stop_animation_timer()
+        
         if self.icon:
             self.icon.stop()
         
@@ -701,6 +789,9 @@ class AbstractAssistantApp:
             except Exception as e:
                 if self.debug:
                     print(f"Error destroying bubble manager: {e}")
+        
+        if self.debug:
+            print("✅ AbstractAssistant quit successfully")
     
     def run(self):
         """Start the application using Qt event loop for proper threading."""
@@ -721,7 +812,7 @@ class AbstractAssistantApp:
 
             # Check if system tray is available
             if not QSystemTrayIcon.isSystemTrayAvailable():
-                print("❌ System tray is not available on this system")
+                print("❌ System tray is not available on this system")  # Always show this error
                 return
 
             # Create Qt-based system tray icon
@@ -730,31 +821,42 @@ class AbstractAssistantApp:
             # Preflight initialization: Pre-load bubble manager for instant display
             self._preflight_initialization()
 
-            print("AbstractAssistant started. Check your menu bar!")
-            print("Click the icon to open the chat interface.")
+            if not self.debug:
+                print("AbstractAssistant started. Check your menu bar!")
+                print("Click the icon to open the chat interface.")
+            else:
+                print("AbstractAssistant started. Check your menu bar!")
+                print("Click the icon to open the chat interface.")
 
             # Run Qt event loop (this blocks until quit)
             self.qt_app.exec_()
 
         except ImportError:
-            print("❌ PyQt5 not available. Falling back to pystray...")
+            if self.debug:
+                print("❌ PyQt5 not available. Falling back to pystray...")
             # Fallback to original pystray implementation
             self.icon = self.create_system_tray_icon()
             self.icon.run()
 
     def _create_qt_system_tray_icon(self):
-        """Create Qt-based system tray icon with proper click detection."""
+        """Create Qt-based system tray icon with smooth animations."""
         from PyQt5.QtWidgets import QSystemTrayIcon, QMenu, QAction
         from PyQt5.QtCore import QTimer
         from PyQt5.QtGui import QIcon, QPixmap
         from PIL import Image
         import io
 
-        # Generate icon using our icon generator
-        icon_image = self.icon_generator.create_app_icon(
-            color_scheme="green",  # Ready state: steady green
-            animated=False         # Ready state: no animation
-        )
+        # Load base icon (same as pystray version)
+        self.base_icon = self._load_app_bundle_icon()
+        if not self.base_icon:
+            # Generate a base icon if app bundle icon not available
+            self.base_icon = self.icon_generator.create_app_icon(
+                color_scheme="green",  # Ready state: steady green
+                animated=False         # Ready state: no animation
+            )
+
+        # Apply initial smooth heartbeat effect
+        icon_image = self.icon_generator.apply_heartbeat_effect(self.base_icon, "ready")
 
         # Convert PIL image to QPixmap
         img_buffer = io.BytesIO()
@@ -794,11 +896,20 @@ class AbstractAssistantApp:
 
         tray_icon.setContextMenu(context_menu)
 
+        # Store reference for animations
+        self.qt_tray_icon = tray_icon
+        
         # Show the tray icon
         tray_icon.show()
 
+        # Start initial animation
+        if self.debug:
+            print(f"🎨 Starting initial animation with status: ready")
+            print(f"   Current status in app: {self.current_status}")
+        self._start_heartbeat_animation("ready")
+
         if self.debug:
-            print("✅ Qt-based system tray icon created successfully")
+            print("✅ Qt-based system tray icon created with smooth animations")
 
         return tray_icon