abstractassistant 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

abstractassistant/ui/history_dialog.py

@@ -4,8 +4,9 @@ iPhone Messages-style history dialog for AbstractAssistant.
 This module provides an authentic iPhone Messages UI for displaying chat history.
 """
 import re
+import time
 from datetime import datetime
-from typing import Dict, List
+from typing import Dict, List, Callable, Optional
 import markdown
 from markdown.extensions.fenced_code import FencedCodeExtension
 from markdown.extensions.tables import TableExtension
@@ -33,62 +34,194 @@ except ImportError:
 
 
 class ClickableBubble(QFrame):
-    """Clickable message bubble that copies content to clipboard."""
+    """Clickable message bubble that copies content to clipboard and supports deletion."""
 
     clicked = pyqtSignal()
+    delete_requested = pyqtSignal(int)  # Signal with message index
+    selection_changed = pyqtSignal(int, bool)  # Signal with message index and selection state
 
-    def __init__(self, content: str, is_user: bool, parent=None):
+    def __init__(self, content: str, is_user: bool, message_index: int, parent=None):
         super().__init__(parent)
         self.content = content
         self.is_user = is_user
+        self.message_index = message_index
+        self.is_selected = False
+        self.selection_mode = False
         self.setCursor(QCursor(Qt.CursorShape.PointingHandCursor))
 
         # Store original colors for animation
         if is_user:
             self.normal_bg = "#007AFF"
             self.clicked_bg = "#0066CC"
+            self.selected_bg = "#FF3B30"  # Red for selection
         else:
             self.normal_bg = "#3a3a3c"
             self.clicked_bg = "#4a4a4c"
+            self.selected_bg = "#FF3B30"  # Red for selection
+        
+        # Long press timer for selection mode
+        self.long_press_timer = QTimer()
+        self.long_press_timer.setSingleShot(True)
+        self.long_press_timer.timeout.connect(self._start_selection_mode)
+        self.press_start_time = None
 
     def mousePressEvent(self, event):
-        """Handle mouse press with visual feedback."""
+        """Handle mouse press with visual feedback and long press detection."""
         if event.button() == Qt.MouseButton.LeftButton:
-            # Apply clicked style (darker)
-            self.setStyleSheet(f"""
-                QFrame {{
-                    background: {self.clicked_bg};
-                    border: none;
-                    border-radius: 18px;
-                    max-width: 400px;
-                }}
-            """)
+            self.press_start_time = time.time()
+            
+            if self.selection_mode:
+                # In selection mode, toggle selection
+                self.toggle_selection()
+            else:
+                # Normal mode - start long press timer and apply clicked style
+                self.long_press_timer.start(800)  # 800ms for long press
+                self.setStyleSheet(f"""
+                    QFrame {{
+                        background: {self.clicked_bg};
+                        border: none;
+                        border-radius: 18px;
+                        max-width: 400px;
+                    }}
+                """)
         super().mousePressEvent(event)
 
     def mouseReleaseEvent(self, event):
-        """Handle mouse release - copy to clipboard and restore style."""
+        """Handle mouse release - copy to clipboard, handle selection, and restore style."""
         if event.button() == Qt.MouseButton.LeftButton:
-            # Copy to clipboard
-            clipboard = QApplication.clipboard()
-            clipboard.setText(self.content)
-
-            # Visual feedback: glossy effect (lighter color briefly)
-            glossy_color = "#0080FF" if self.is_user else "#5a5a5c"
-            self.setStyleSheet(f"""
-                QFrame {{
-                    background: {glossy_color};
-                    border: none;
-                    border-radius: 18px;
-                    max-width: 400px;
-                }}
-            """)
-
-            # Restore normal color after brief delay
-            QTimer.singleShot(200, self._restore_normal_style)
-
-            self.clicked.emit()
+            # Stop long press timer
+            self.long_press_timer.stop()
+            
+            if self.selection_mode:
+                # In selection mode, just restore style
+                self._update_visual_state()
+            else:
+                # Check if this was a quick tap (not long press)
+                if self.press_start_time and (time.time() - self.press_start_time) < 0.5:
+                    # Copy to clipboard
+                    clipboard = QApplication.clipboard()
+                    clipboard.setText(self.content)
+
+                    # Visual feedback: glossy effect (lighter color briefly)
+                    glossy_color = "#0080FF" if self.is_user else "#5a5a5c"
+                    self.setStyleSheet(f"""
+                        QFrame {{
+                            background: {glossy_color};
+                            border: none;
+                            border-radius: 18px;
+                            max-width: 400px;
+                        }}
+                    """)
+
+                    # Restore normal color after brief delay
+                    QTimer.singleShot(200, self._restore_normal_style)
+
+                    self.clicked.emit()
+                else:
+                    # Long press - restore style immediately
+                    self._restore_normal_style()
         super().mouseReleaseEvent(event)
 
+    def _start_selection_mode(self):
+        """Start selection mode on long press."""
+        self.selection_mode = True
+        self.is_selected = True
+        self._update_visual_state()
+        self.selection_changed.emit(self.message_index, True)
+        
+        # Provide haptic-like feedback by briefly changing color
+        self.setStyleSheet(f"""
+            QFrame {{
+                background: {self.selected_bg};
+                border: 2px solid #FFFFFF;
+                border-radius: 18px;
+                max-width: 400px;
+            }}
+        """)
+        
+        # Add selection indicator
+        QTimer.singleShot(100, self._update_visual_state)
+
+    def toggle_selection(self):
+        """Toggle selection state in selection mode."""
+        self.is_selected = not self.is_selected
+        self._update_selection_circle()
+        self._update_visual_state()
+        self.selection_changed.emit(self.message_index, self.is_selected)
+
+    def set_selection_mode(self, enabled: bool):
+        """Set selection mode state."""
+        self.selection_mode = enabled
+        if not enabled:
+            self.is_selected = False
+        
+        # Show/hide selection circle
+        if hasattr(self, 'selection_circle'):
+            if enabled:
+                self.selection_circle.show()
+            else:
+                self.selection_circle.hide()
+        
+        self._update_selection_circle()
+        self._update_visual_state()
+
+    def set_selected(self, selected: bool):
+        """Set selection state."""
+        self.is_selected = selected
+        self._update_selection_circle()
+        self._update_visual_state()
+
+    def _update_selection_circle(self):
+        """Update selection circle appearance."""
+        if hasattr(self, 'selection_circle') and self.selection_mode:
+            if self.is_selected:
+                # Selected state - filled circle with checkmark
+                self.selection_circle.setStyleSheet("""
+                    QPushButton {
+                        background: #007AFF;
+                        border: 2px solid #007AFF;
+                        border-radius: 11px;
+                        margin: 0px;
+                        padding: 0px;
+                        color: white;
+                        font-size: 12px;
+                        font-weight: bold;
+                    }
+                    QPushButton:hover {
+                        background: #0066CC;
+                        border: 2px solid #0066CC;
+                    }
+                """)
+                self.selection_circle.setText("✓")
+            else:
+                # Unselected state - empty circle
+                self.selection_circle.setStyleSheet("""
+                    QPushButton {
+                        background: transparent;
+                        border: 2px solid rgba(255, 255, 255, 0.6);
+                        border-radius: 11px;
+                        margin: 0px;
+                        padding: 0px;
+                    }
+                    QPushButton:hover {
+                        border: 2px solid rgba(255, 255, 255, 0.8);
+                    }
+                """)
+                self.selection_circle.setText("")
+
+    def _update_visual_state(self):
+        """Update visual state based on selection - no visual changes to bubble itself."""
+        # In authentic iPhone Messages, the bubble appearance doesn't change
+        # Only the selection circle changes state - bubble stays the same
+        self.setStyleSheet(f"""
+            QFrame {{
+                background: {self.normal_bg};
+                border: none;
+                border-radius: 18px;
+                max-width: 400px;
+            }}
+        """)
+
     def _restore_normal_style(self):
         """Restore normal bubble style."""
         self.setStyleSheet(f"""
@@ -107,13 +240,322 @@ class SafeDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.hide_callback = None
+        self.delete_callback = None
+        self.selection_mode = False
+        self.selected_messages = set()
+        self.message_bubbles = []
+        self.trash_button = None
+        self.edit_button = None
 
     def set_hide_callback(self, callback):
         """Set callback to call when dialog is hidden."""
         self.hide_callback = callback
 
+    def set_delete_callback(self, callback):
+        """Set callback to call when messages are deleted."""
+        self.delete_callback = callback
+
+    def enter_selection_mode(self):
+        """Enter selection mode for message deletion."""
+        self.selection_mode = True
+        self.selected_messages.clear()
+        
+        # Update all bubbles to selection mode
+        for bubble in self.message_bubbles:
+            bubble.set_selection_mode(True)
+        
+        # Update navigation bar
+        self._update_navbar_for_selection_mode()
+
+    def exit_selection_mode(self):
+        """Exit selection mode."""
+        self.selection_mode = False
+        self.selected_messages.clear()
+        
+        # Update all bubbles to normal mode
+        for bubble in self.message_bubbles:
+            bubble.set_selection_mode(False)
+        
+        # Update navigation bar
+        self._update_navbar_for_normal_mode()
+
+    def _update_navbar_for_selection_mode(self):
+        """Update navbar for selection mode."""
+        if hasattr(self, 'edit_button'):
+            self.edit_button.setText("Cancel")
+            self.edit_button.clicked.disconnect()
+            self.edit_button.clicked.connect(self.exit_selection_mode)
+        
+        # Hide trash button initially (will show when messages are selected)
+        if hasattr(self, 'trash_button'):
+            self.trash_button.hide()
+
+    def _update_navbar_for_normal_mode(self):
+        """Update navbar for normal mode."""
+        if hasattr(self, 'edit_button'):
+            self.edit_button.setText("Edit")
+            self.edit_button.clicked.disconnect()
+            self.edit_button.clicked.connect(self.enter_selection_mode)
+        
+        # Hide trash button
+        if hasattr(self, 'trash_button'):
+            self.trash_button.hide()
+
+    def on_selection_changed(self, message_index: int, selected: bool):
+        """Handle selection change from a bubble."""
+        if selected:
+            self.selected_messages.add(message_index)
+        else:
+            self.selected_messages.discard(message_index)
+        
+        # Show/hide trash button based on selection
+        if hasattr(self, 'trash_button'):
+            if len(self.selected_messages) > 0:
+                self.trash_button.show()
+            else:
+                self.trash_button.hide()
+
+    def delete_selected_messages(self):
+        """Delete selected messages with iPhone-style bottom action sheet."""
+        try:
+            if not self.selected_messages or not self.delete_callback:
+                return
+
+            # Show iPhone-style bottom action sheet
+            count = len(self.selected_messages)
+            self._show_delete_action_sheet(count)
+
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+
+    def _show_delete_action_sheet(self, count: int):
+        """Show iPhone-style bottom action sheet for deletion confirmation."""
+        # Create overlay widget that covers the entire dialog
+        overlay = QWidget(self)
+        overlay.setStyleSheet("background: rgba(0, 0, 0, 0.4);")
+        overlay.resize(self.size())
+        overlay.move(0, 0)
+        
+        # Create action sheet container
+        action_sheet = QWidget(overlay)
+        action_sheet.setStyleSheet("""
+            QWidget {
+                background: #2C2C2E;
+                border-radius: 13px;
+                border: none;
+            }
+        """)
+        
+        # Layout for action sheet
+        layout = QVBoxLayout(action_sheet)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(1)
+        
+        # Delete button (red, destructive)
+        delete_btn = QPushButton(f"Delete {count} Message{'s' if count > 1 else ''}")
+        delete_btn.setStyleSheet("""
+            QPushButton {
+                background: #FF3B30;
+                color: white;
+                border: none;
+                padding: 16px;
+                font-size: 17px;
+                font-weight: 400;
+                text-align: center;
+            }
+            QPushButton:hover {
+                background: #D70015;
+            }
+        """)
+        delete_btn.clicked.connect(lambda: self._confirm_deletion(overlay))
+        
+        # Cancel button
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.setStyleSheet("""
+            QPushButton {
+                background: #48484A;
+                color: #007AFF;
+                border: none;
+                padding: 16px;
+                font-size: 17px;
+                font-weight: 600;
+                text-align: center;
+                border-radius: 13px;
+                margin-top: 8px;
+            }
+            QPushButton:hover {
+                background: #5A5A5C;
+            }
+        """)
+        cancel_btn.clicked.connect(lambda: self._cancel_deletion(overlay))
+        
+        layout.addWidget(delete_btn)
+        layout.addWidget(cancel_btn)
+        
+        # Position action sheet at bottom
+        action_sheet.setFixedWidth(self.width() - 40)
+        action_sheet.adjustSize()
+        action_sheet.move(20, self.height() - action_sheet.height() - 20)
+        
+        # Show overlay and action sheet
+        overlay.show()
+        overlay.raise_()
+        
+        # Store reference for cleanup
+        self.current_overlay = overlay
+
+    def _confirm_deletion(self, overlay):
+        """Confirm deletion and execute it."""
+        try:
+            # Hide overlay
+            overlay.hide()
+            overlay.deleteLater()
+            self.current_overlay = None
+            
+            # Convert to sorted list for consistent deletion
+            indices_to_delete = sorted(list(self.selected_messages), reverse=True)
+
+            # Call the delete callback with error handling
+            if self.delete_callback:
+                self.delete_callback(indices_to_delete)
+
+            # Exit selection mode after deletion
+            self.exit_selection_mode()
+
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            
+            # Try to exit selection mode even if deletion failed
+            try:
+                self.exit_selection_mode()
+            except:
+                pass
+
+    def _cancel_deletion(self, overlay):
+        """Cancel deletion and hide action sheet."""
+        overlay.hide()
+        overlay.deleteLater()
+        self.current_overlay = None
+
+    def update_message_history(self, new_message_history: List[Dict]):
+        """Update the dialog with new message history without closing it."""
+        try:
+            # Exit selection mode if active
+            if self.selection_mode:
+                self.exit_selection_mode()
+            
+            # Clear existing content completely using correct widget references
+            if hasattr(self, 'messages_layout'):
+                layout = self.messages_layout
+                
+                # Remove all widgets except the stretch at the end
+                while layout.count() > 0:
+                    child = layout.takeAt(0)
+                    if child.widget():
+                        widget = child.widget()
+                        widget.setParent(None)
+                        widget.deleteLater()
+                
+                # Force immediate processing of deleteLater calls
+                from PyQt5.QtCore import QCoreApplication
+                QCoreApplication.processEvents()
+                
+                # Recreate messages with new history
+                if new_message_history:
+                    # Re-add messages using the same method as original creation
+                    iPhoneMessagesDialog._add_authentic_iphone_messages(layout, new_message_history, self)
+                else:
+                    # Add placeholder for empty state
+                    placeholder = QLabel("No messages")
+                    placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+                    placeholder.setStyleSheet("""
+                        QLabel {
+                            color: rgba(255, 255, 255, 0.5);
+                            font-size: 16px;
+                            padding: 40px;
+                        }
+                    """)
+                    layout.addWidget(placeholder)
+                
+                # Re-add stretch to push messages to top
+                layout.addStretch()
+                
+                # Force complete UI update
+                if hasattr(self, 'messages_widget'):
+                    self.messages_widget.adjustSize()
+                    self.messages_widget.update()
+                    self.messages_widget.repaint()
+                
+                if hasattr(self, 'scroll_area'):
+                    self.scroll_area.update()
+                    self.scroll_area.repaint()
+                    # Scroll to bottom to show latest messages
+                    QTimer.singleShot(100, lambda: self.scroll_area.verticalScrollBar().setValue(
+                        self.scroll_area.verticalScrollBar().maximum()
+                    ))
+                
+                # Update the entire dialog
+                self.update()
+                self.repaint()
+                
+            else:
+                raise Exception("Dialog structure not found")
+            
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            raise  # Re-raise to trigger fallback in qt_bubble.py
+
+    def _populate_messages(self, message_history: List[Dict]):
+        """Populate the scroll area with message bubbles."""
+        if not hasattr(self, 'scroll_content'):
+            return
+            
+        layout = self.scroll_content.layout()
+        if not layout:
+            layout = QVBoxLayout(self.scroll_content)
+            layout.setContentsMargins(20, 20, 20, 20)
+            layout.setSpacing(8)
+        
+        # Add messages as bubbles (only if there are messages)
+        if message_history:
+            for i, message in enumerate(message_history):
+                if message.get('type') in ['user', 'assistant']:
+                    bubble = ClickableBubble(
+                        message.get('content', ''),
+                        message.get('type') == 'user',
+                        i,
+                        self
+                    )
+                    layout.addWidget(bubble)
+        else:
+            # If no messages, add a placeholder
+            placeholder = QLabel("No messages")
+            placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            placeholder.setStyleSheet("""
+                QLabel {
+                    color: rgba(255, 255, 255, 0.5);
+                    font-size: 16px;
+                    padding: 40px;
+                }
+            """)
+            layout.addWidget(placeholder)
+        
+        # Add stretch to push messages to top
+        layout.addStretch()
+        
+        # Force layout update
+        self.scroll_content.update()
+        if hasattr(self, 'scroll_area'):
+            self.scroll_area.update()
+
+
     def closeEvent(self, event):
         """Override close event to hide instead of close."""
+        if self.selection_mode:
+            self.exit_selection_mode()
         event.ignore()
         self.hide()
         if self.hide_callback:
@@ -121,6 +563,8 @@ class SafeDialog(QDialog):
 
     def reject(self):
         """Override reject to hide instead of close."""
+        if self.selection_mode:
+            self.exit_selection_mode()
         self.hide()
         if self.hide_callback:
             self.hide_callback()
@@ -130,14 +574,22 @@ class iPhoneMessagesDialog:
     """Create authentic iPhone Messages-style chat history dialog."""
 
     @staticmethod
-    def create_dialog(message_history: List[Dict], parent=None) -> QDialog:
-        """Create AUTHENTIC iPhone Messages dialog - EXACTLY like the real app."""
+    def create_dialog(message_history: List[Dict], parent=None, delete_callback: Optional[Callable] = None) -> QDialog:
+        """Create AUTHENTIC iPhone Messages dialog with deletion support."""
+        # Safety check for empty message history
+        if not message_history:
+            return None
+        
         dialog = SafeDialog(parent)
         dialog.setWindowTitle("Messages")
         dialog.setModal(False)
         dialog.setWindowFlags(Qt.WindowType.FramelessWindowHint | Qt.WindowType.Window | Qt.WindowType.WindowStaysOnTopHint)
         dialog.resize(504, 650)  # Increased width by 20% (420 * 1.2 = 504)
 
+        # Set delete callback
+        if delete_callback:
+            dialog.set_delete_callback(delete_callback)
+
         # Position dialog near right edge of screen like iPhone
         iPhoneMessagesDialog._position_dialog_right(dialog)
 
@@ -146,10 +598,10 @@ class iPhoneMessagesDialog:
         main_layout.setContentsMargins(0, 0, 0, 0)
         main_layout.setSpacing(0)
 
-        # iPhone navigation bar
+        # iPhone navigation bar with delete button
         navbar = iPhoneMessagesDialog._create_authentic_navbar(dialog)
         main_layout.addWidget(navbar)
-
+        
         # Messages container with pure white background
         scroll_area = QScrollArea()
         scroll_area.setWidgetResizable(True)
@@ -163,8 +615,13 @@ class iPhoneMessagesDialog:
         messages_layout.setContentsMargins(0, 16, 0, 16)  # iPhone spacing
         messages_layout.setSpacing(0)
 
-        # Add messages with authentic iPhone styling
-        iPhoneMessagesDialog._add_authentic_iphone_messages(messages_layout, message_history)
+        # Store references for updating
+        dialog.scroll_area = scroll_area
+        dialog.messages_widget = messages_widget
+        dialog.messages_layout = messages_layout
+
+        # Add messages with authentic iPhone styling and deletion support
+        iPhoneMessagesDialog._add_authentic_iphone_messages(messages_layout, message_history, dialog)
 
         messages_layout.addStretch()
         scroll_area.setWidget(messages_widget)
@@ -203,8 +660,8 @@ class iPhoneMessagesDialog:
         dialog.move(x, y)
 
     @staticmethod
-    def _create_authentic_navbar(dialog: QDialog) -> QFrame:
-        """Create AUTHENTIC iPhone Messages navigation bar."""
+    def _create_authentic_navbar(dialog: SafeDialog) -> QFrame:
+        """Create AUTHENTIC iPhone Messages navigation bar with delete functionality."""
         navbar = QFrame()
         navbar.setFixedHeight(94)  # iPhone status bar + nav bar
         navbar.setStyleSheet("""
@@ -261,18 +718,57 @@ class iPhoneMessagesDialog:
 
         nav_layout.addStretch()
 
+        # Trash icon (initially hidden, appears when messages are selected)
+        trash_btn = QPushButton("🗑️")
+        trash_btn.setFixedSize(30, 30)
+        trash_btn.clicked.connect(dialog.delete_selected_messages)
+        trash_btn.setStyleSheet("""
+            QPushButton {
+                color: #FF3B30;
+                font-size: 18px;
+                background: transparent;
+                border: none;
+                text-align: center;
+                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+            }
+            QPushButton:hover {
+                background: rgba(255, 59, 48, 0.1);
+                border-radius: 15px;
+            }
+        """)
+        trash_btn.hide()  # Initially hidden
+        dialog.trash_button = trash_btn  # Store reference
+        nav_layout.addWidget(trash_btn)
+
+        # Delete button (Edit in iPhone style)
+        edit_btn = QPushButton("Edit")
+        edit_btn.clicked.connect(dialog.enter_selection_mode)
+        edit_btn.setStyleSheet("""
+            QPushButton {
+                color: #007AFF;
+                font-size: 17px;
+                font-weight: 400;
+                background: transparent;
+                border: none;
+                text-align: right;
+                font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
+            }
+        """)
+        dialog.edit_button = edit_btn  # Store reference
+        nav_layout.addWidget(edit_btn)
+
         layout.addWidget(nav_frame)
         return navbar
 
     @staticmethod
-    def _add_authentic_iphone_messages(layout: QVBoxLayout, message_history: List[Dict]):
-        """Add messages with AUTHENTIC iPhone Messages styling."""
+    def _add_authentic_iphone_messages(layout: QVBoxLayout, message_history: List[Dict], dialog: SafeDialog):
+        """Add messages with AUTHENTIC iPhone Messages styling and deletion support."""
         for index, msg in enumerate(message_history):
             message_type = msg.get('type', msg.get('role', 'unknown'))
             is_user = message_type in ['user', 'human']
 
-            # Create authentic iPhone bubble
-            bubble_container = iPhoneMessagesDialog._create_authentic_iphone_bubble(msg, is_user, index, message_history)
+            # Create authentic iPhone bubble with deletion support
+            bubble_container = iPhoneMessagesDialog._create_authentic_iphone_bubble(msg, is_user, index, message_history, dialog)
             layout.addWidget(bubble_container)
 
             # Add spacing between messages (6px like iPhone)
@@ -283,8 +779,8 @@ class iPhoneMessagesDialog:
                 layout.addWidget(spacer)
 
     @staticmethod
-    def _create_authentic_iphone_bubble(msg: Dict, is_user: bool, index: int, message_history: List[Dict]) -> QFrame:
-        """Create AUTHENTIC iPhone Messages bubble - exactly like real iPhone."""
+    def _create_authentic_iphone_bubble(msg: Dict, is_user: bool, index: int, message_history: List[Dict], dialog: SafeDialog) -> QFrame:
+        """Create AUTHENTIC iPhone Messages bubble with deletion support."""
         main_container = QFrame()
         main_container.setStyleSheet("background: transparent; border: none;")
         main_layout = QVBoxLayout(main_container)
@@ -298,8 +794,32 @@ class iPhoneMessagesDialog:
         layout.setContentsMargins(12, 0, 12, 0)  # Tighter margins for more width
         layout.setSpacing(0)
 
-        # Create clickable bubble
-        bubble = ClickableBubble(msg['content'], is_user)
+        # Create selection circle (initially hidden)
+        selection_circle = QPushButton()
+        selection_circle.setFixedSize(22, 22)
+        selection_circle.setStyleSheet("""
+            QPushButton {
+                background: transparent;
+                border: 2px solid rgba(255, 255, 255, 0.6);
+                border-radius: 11px;
+                margin: 0px;
+                padding: 0px;
+            }
+            QPushButton:hover {
+                border: 2px solid rgba(255, 255, 255, 0.8);
+            }
+        """)
+        selection_circle.hide()  # Initially hidden
+        
+        # Create clickable bubble with deletion support
+        bubble = ClickableBubble(msg['content'], is_user, index)
+        bubble.selection_changed.connect(dialog.on_selection_changed)
+        bubble.selection_circle = selection_circle  # Store reference
+        dialog.message_bubbles.append(bubble)  # Track bubbles for selection mode
+        
+        # Connect selection circle click
+        selection_circle.clicked.connect(bubble.toggle_selection)
+        
         bubble_layout = QVBoxLayout(bubble)
         bubble_layout.setContentsMargins(12, 7, 12, 7)  # More compact padding
         bubble_layout.setSpacing(0)
@@ -331,8 +851,10 @@ class iPhoneMessagesDialog:
                     font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
                 }
             """)
-            # Right align
+            # Right align - selection circle on the left of bubble (towards center)
             layout.addStretch()
+            layout.addWidget(selection_circle, 0, Qt.AlignmentFlag.AlignCenter)
+            layout.addSpacing(8)  # Small gap between circle and bubble
             layout.addWidget(bubble)
         else:
             # Received bubble: Light gray with black text
@@ -354,8 +876,10 @@ class iPhoneMessagesDialog:
                     font-family: "Helvetica Neue", "Helvetica", Arial, sans-serif;
                 }
             """)
-            # Left align
+            # Left align - selection circle on the right of bubble (towards center)
             layout.addWidget(bubble)
+            layout.addSpacing(8)  # Small gap between bubble and circle
+            layout.addWidget(selection_circle, 0, Qt.AlignmentFlag.AlignCenter)
             layout.addStretch()
 
         bubble_layout.addWidget(content_label)

abstractassistant/ui/qt_bubble.py

@@ -405,6 +405,7 @@ class QtChatBubble(QWidget):
             ("Clear", self.clear_session),
             ("Load", self.load_session), 
             ("Save", self.save_session),
+            # ("Compact", self.compact_session),  # Hidden for now - functionality preserved
             ("History", self.show_history)
         ]
         
@@ -1971,6 +1972,268 @@ class QtChatBubble(QWidget):
                 if self.debug:
                     print("🧹 Session cleared (including attached files and file tracking)")
     
+    def compact_session(self):
+        """Compact the current session using AbstractCore's summarizer functionality."""
+        if not self.message_history:
+            QMessageBox.information(
+                self,
+                "No Session",
+                "No conversation history to compact. Start a conversation first."
+            )
+            return
+        
+        # Check if session is too short to compact
+        if len(self.message_history) < 4:  # Need at least 2 exchanges to be worth compacting
+            QMessageBox.information(
+                self,
+                "Session Too Short",
+                "Session is too short to compact. Need at least 2 exchanges (4 messages)."
+            )
+            return
+        
+        reply = QMessageBox.question(
+            self, 
+            "Compact Session", 
+            "This will summarize the conversation history into a concise system message, "
+            "keeping only the most recent 2 exchanges for context.\n\n"
+            "This action cannot be undone. Continue?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No
+        )
+        
+        if reply == QMessageBox.StandardButton.Yes:
+            try:
+                # Show progress
+                self.status_label.setText("compacting")
+                self.status_label.setStyleSheet("""
+                    QLabel {
+                        background: rgba(250, 179, 135, 0.2);
+                        border: 1px solid rgba(250, 179, 135, 0.3);
+                        border-radius: 12px;
+                        padding: 4px 12px;
+                        font-size: 11px;
+                        font-weight: 600;
+                        text-transform: uppercase;
+                        letter-spacing: 0.5px;
+                        color: #fab387;
+                    }
+                """)
+                
+                # Notify main app about status change
+                if self.status_callback:
+                    self.status_callback("compacting")
+                
+                # Create conversation text for summarization
+                conversation_text = self._format_conversation_for_summarization()
+                
+                # Use AbstractCore's summarizer functionality through LLMManager
+                summary = self._generate_conversation_summary(conversation_text)
+                
+                if summary:
+                    # Keep the last 2 exchanges (4 messages) for context
+                    recent_messages = self.message_history[-4:] if len(self.message_history) >= 4 else self.message_history[-2:]
+                    
+                    # Create new session with summary as system context
+                    self._create_compacted_session(summary, recent_messages)
+                    
+                    # Update UI
+                    self.token_count = 0  # Reset token count
+                    self.update_token_display()
+                    
+                    # Show success message
+                    QMessageBox.information(
+                        self,
+                        "Session Compacted",
+                        f"Session successfully compacted!\n\n"
+                        f"Original: {len(self.message_history)} messages\n"
+                        f"Compacted: Summary + {len(recent_messages)} recent messages"
+                    )
+                    
+                    if self.debug:
+                        print(f"🗜️ Session compacted: {len(self.message_history)} -> summary + {len(recent_messages)} recent")
+                else:
+                    raise Exception("Failed to generate summary")
+                    
+            except Exception as e:
+                QMessageBox.critical(
+                    self,
+                    "Compaction Error",
+                    f"Failed to compact session:\n{str(e)}"
+                )
+                if self.debug:
+                    print(f"❌ Failed to compact session: {e}")
+                    import traceback
+                    traceback.print_exc()
+            finally:
+                # Reset status
+                self.status_label.setText("ready")
+                self.status_label.setStyleSheet("""
+                    QLabel {
+                        background: rgba(166, 227, 161, 0.2);
+                        border: 1px solid rgba(166, 227, 161, 0.3);
+                        border-radius: 12px;
+                        padding: 4px 12px;
+                        font-size: 11px;
+                        font-weight: 600;
+                        text-transform: uppercase;
+                        letter-spacing: 0.5px;
+                        color: #a6e3a1;
+                    }
+                """)
+                if self.status_callback:
+                    self.status_callback("ready")
+    
+    def _format_conversation_for_summarization(self) -> str:
+        """Format the conversation history for summarization."""
+        lines = []
+        lines.append("=== CONVERSATION HISTORY ===\n")
+        
+        for i, msg in enumerate(self.message_history):
+            role = "USER" if msg.get('type') == 'user' else "ASSISTANT"
+            content = msg.get('content', '')
+            timestamp = msg.get('timestamp', '')
+            
+            # Add timestamp if available
+            if timestamp:
+                try:
+                    from datetime import datetime
+                    if isinstance(timestamp, str):
+                        dt = datetime.fromisoformat(timestamp)
+                        time_str = dt.strftime("%Y-%m-%d %H:%M")
+                        lines.append(f"[{time_str}] {role}:")
+                    else:
+                        lines.append(f"{role}:")
+                except:
+                    lines.append(f"{role}:")
+            else:
+                lines.append(f"{role}:")
+            
+            lines.append(content)
+            lines.append("")  # Empty line between messages
+        
+        return "\n".join(lines)
+    
+    def _generate_conversation_summary(self, conversation_text: str) -> str:
+        """Generate a conversation summary using AbstractCore's summarizer functionality."""
+        try:
+            # Use the current LLM to generate a summary
+            # This mimics what the AbstractCore summarizer CLI does
+            summary_prompt = f"""Please provide a comprehensive but concise summary of the following conversation. 
+Focus on:
+- Key topics discussed
+- Important decisions or conclusions reached
+- Relevant context that should be preserved
+- Any ongoing tasks or questions
+
+The summary should be detailed enough to provide context for continuing the conversation, but concise enough to save tokens.
+
+Conversation to summarize:
+{conversation_text}
+
+Please provide the summary in a clear, structured format:"""
+
+            if self.llm_manager and self.llm_manager.llm:
+                # Generate summary using current LLM
+                response = self.llm_manager.llm.generate(summary_prompt)
+                
+                if hasattr(response, 'content'):
+                    return response.content
+                else:
+                    return str(response)
+            else:
+                raise Exception("No LLM available for summarization")
+                
+        except Exception as e:
+            if self.debug:
+                print(f"❌ Error generating summary: {e}")
+            raise
+    
+    def _create_compacted_session(self, summary: str, recent_messages: list):
+        """Create a new session with the summary and recent messages."""
+        try:
+            # Create new session with summary as enhanced system prompt
+            enhanced_system_prompt = f"""You are a helpful AI assistant who has access to tools to help the user.
+Always be a critical and creative thinker who leverage constructive skepticism to progress and evolve its reasoning and answers.
+Always answer in nicely formatted markdown.
+
+=== CONVERSATION CONTEXT ===
+The following is a summary of our previous conversation:
+
+{summary}
+
+=== END CONTEXT ===
+
+Continue the conversation naturally, referring to the context above when relevant."""
+
+            # Create new session with enhanced system prompt
+            if self.llm_manager:
+                # Create new session with custom system prompt
+                from abstractcore import BasicSession
+                
+                # Prepare tools list (same as in LLMManager)
+                tools = []
+                try:
+                    from abstractcore.tools.common_tools import (
+                        list_files, search_files, read_file, edit_file, 
+                        write_file, execute_command, web_search
+                    )
+                    tools = [
+                        list_files, search_files, read_file, edit_file,
+                        write_file, execute_command, web_search
+                    ]
+                except ImportError:
+                    pass
+                
+                # Create new session with summary in system prompt
+                new_session = BasicSession(
+                    self.llm_manager.llm,
+                    system_prompt=enhanced_system_prompt,
+                    tools=tools
+                )
+                
+                # Add recent messages to the new session
+                for msg in recent_messages:
+                    if msg.get('type') == 'user':
+                        # Add user message without generating response
+                        from abstractcore.messages import UserMessage
+                        user_msg = UserMessage(content=msg.get('content', ''))
+                        new_session.messages.append(user_msg)
+                    elif msg.get('type') == 'assistant':
+                        # Add assistant message
+                        from abstractcore.messages import AssistantMessage
+                        assistant_msg = AssistantMessage(content=msg.get('content', ''))
+                        new_session.messages.append(assistant_msg)
+                
+                # Replace current session
+                self.llm_manager.current_session = new_session
+                
+                # Update local message history to reflect the compacted state
+                # Create a special "system" message to represent the summary
+                compacted_history = [
+                    {
+                        'timestamp': datetime.now().isoformat(),
+                        'type': 'system',
+                        'content': f"📋 **Session Compacted**\n\n{summary}",
+                        'provider': self.current_provider,
+                        'model': self.current_model,
+                        'attached_files': []
+                    }
+                ]
+                
+                # Add recent messages
+                compacted_history.extend(recent_messages)
+                
+                # Update message history
+                self.message_history = compacted_history
+                
+                if self.debug:
+                    print(f"✅ Created compacted session with enhanced system prompt")
+                    
+        except Exception as e:
+            if self.debug:
+                print(f"❌ Error creating compacted session: {e}")
+            raise
+    
     def load_session(self):
         """Load a session using AbstractCore via LLMManager."""
         file_path, _ = QFileDialog.getOpenFileName(
@@ -2192,8 +2455,12 @@ class QtChatBubble(QWidget):
         # Toggle behavior: create dialog if doesn't exist, toggle visibility if it does
         if iPhoneMessagesDialog:
             if self.history_dialog is None:
-                # Create dialog first time
-                self.history_dialog = iPhoneMessagesDialog.create_dialog(self.message_history, self)
+                # Create dialog first time with deletion support
+                self.history_dialog = iPhoneMessagesDialog.create_dialog(
+                    self.message_history, 
+                    self, 
+                    delete_callback=self._handle_message_deletion
+                )
                 # Set callback to update button when dialog is hidden via Back button
                 self.history_dialog.set_hide_callback(lambda: self._update_history_button_appearance(False))
                 self.history_dialog.show()
@@ -2205,7 +2472,11 @@ class QtChatBubble(QWidget):
                     self._update_history_button_appearance(False)
                 else:
                     # Update dialog with latest messages before showing
-                    self.history_dialog = iPhoneMessagesDialog.create_dialog(self.message_history, self)
+                    self.history_dialog = iPhoneMessagesDialog.create_dialog(
+                        self.message_history, 
+                        self, 
+                        delete_callback=self._handle_message_deletion
+                    )
                     # Set callback to update button when dialog is hidden via Back button
                     self.history_dialog.set_hide_callback(lambda: self._update_history_button_appearance(False))
                     self.history_dialog.show()
@@ -2256,6 +2527,159 @@ class QtChatBubble(QWidget):
                     }
                 """)
 
+    def _handle_message_deletion(self, indices_to_delete: List[int]):
+        """Handle deletion of messages from the history dialog."""
+        try:
+            if not indices_to_delete:
+                return
+
+            # Validate indices
+            for index in indices_to_delete:
+                if not (0 <= index < len(self.message_history)):
+                    QMessageBox.critical(
+                        self,
+                        "Invalid Selection",
+                        f"Invalid message index {index}. Please refresh and try again."
+                    )
+                    return
+            
+            # Delete messages from local history (indices are sorted in reverse order)
+            original_count = len(self.message_history)
+            
+            for index in indices_to_delete:
+                if 0 <= index < len(self.message_history):
+                    del self.message_history[index]
+            
+            # Update AbstractCore session to reflect deletions
+            self._update_abstractcore_session_after_deletion()
+            
+            # Update token count
+            self._update_token_count_from_session()
+            
+            # Update history dialog if it's open (keep it open!)
+            if self.history_dialog and self.history_dialog.isVisible():
+                try:
+                    # Update the dialog content without closing it
+                    self.history_dialog.update_message_history(self.message_history)
+                except Exception as dialog_error:
+                    import traceback
+                    traceback.print_exc()
+                    # Fallback: recreate dialog if update fails
+                    try:
+                        if len(self.message_history) == 0:
+                            self.history_dialog.hide()
+                            self._update_history_button_appearance(False)
+                        else:
+                            new_dialog = iPhoneMessagesDialog.create_dialog(
+                                self.message_history, 
+                                self, 
+                                delete_callback=self._handle_message_deletion
+                            )
+                            if new_dialog:
+                                old_pos = self.history_dialog.pos()
+                                self.history_dialog.hide()
+                                self.history_dialog = new_dialog
+                                self.history_dialog.move(old_pos)  # Keep same position
+                                self.history_dialog.set_hide_callback(lambda: self._update_history_button_appearance(False))
+                                self.history_dialog.show()
+                    except:
+                        try:
+                            self.history_dialog.hide()
+                            self._update_history_button_appearance(False)
+                        except:
+                            pass
+            
+            # Log success (no popup)
+            deleted_count = original_count - len(self.message_history)
+            
+            if self.debug:
+                print(f"🗑️ Deleted {deleted_count} messages from history")
+                
+        except Exception as e:
+            print(f"❌ Critical error in _handle_message_deletion: {e}")
+            import traceback
+            traceback.print_exc()
+            
+            try:
+                QMessageBox.critical(
+                    self,
+                    "Deletion Error",
+                    f"Failed to delete messages:\n{str(e)}\n\nCheck console for details."
+                )
+            except:
+                print("❌ Could not show error dialog")
+            
+            if self.debug:
+                print(f"❌ Failed to delete messages: {e}")
+                import traceback
+                traceback.print_exc()
+
+    def _update_abstractcore_session_after_deletion(self):
+        """Update AbstractCore session to reflect message deletions."""
+        try:
+            if not self.llm_manager or not self.llm_manager.current_session:
+                return
+            
+            # Get current system prompt
+            current_session = self.llm_manager.current_session
+            system_prompt = getattr(current_session, 'system_prompt', None) or """
+                You are a helpful AI assistant who has access to tools to help the user.
+                Always be a critical and creative thinker who leverage constructive skepticism to progress and evolve its reasoning and answers.
+                Always answer in nicely formatted markdown.
+            """
+            
+            # Prepare tools list (same as in LLMManager)
+            tools = []
+            try:
+                from abstractcore.tools.common_tools import (
+                    list_files, search_files, read_file, edit_file, 
+                    write_file, execute_command, web_search
+                )
+                tools = [
+                    list_files, search_files, read_file, edit_file,
+                    write_file, execute_command, web_search
+                ]
+            except ImportError as import_error:
+                pass
+                pass
+            
+            # Create new session with updated message history
+            from abstractcore import BasicSession
+            new_session = BasicSession(
+                self.llm_manager.llm,
+                system_prompt=system_prompt,
+                tools=tools
+            )
+            
+            # Add remaining messages to the new session
+            for i, msg in enumerate(self.message_history):
+                try:
+                    if msg.get('type') == 'user':
+                        from abstractcore.messages import UserMessage
+                        user_msg = UserMessage(content=msg.get('content', ''))
+                        new_session.messages.append(user_msg)
+                    elif msg.get('type') == 'assistant':
+                        from abstractcore.messages import AssistantMessage
+                        assistant_msg = AssistantMessage(content=msg.get('content', ''))
+                        new_session.messages.append(assistant_msg)
+                    elif msg.get('type') == 'system':
+                        # Skip system messages (handled by system_prompt)
+                        pass
+                    else:
+                        # Unknown message type
+                        pass
+                except Exception as msg_error:
+                    # Continue with other messages
+                    pass
+            
+            # Replace current session
+            self.llm_manager.current_session = new_session
+                
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            # Don't raise - this is not critical for the UI operation
+
     def close_app(self):
         """Close the entire application completely."""
         if self.debug:

{abstractassistant-0.3.3.dist-info → abstractassistant-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractassistant
-Version: 0.3.3
+Version: 0.3.4
 Summary: A sleek (macOS) system tray application providing instant access to LLMs
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 License-Expression: MIT

{abstractassistant-0.3.3.dist-info → abstractassistant-0.3.4.dist-info}/RECORD

@@ -9,9 +9,9 @@ abstractassistant/core/llm_manager.py,sha256=hJun-nDfRv9zxv_3tfrHAmVYSYT96E-0zDJ
 abstractassistant/core/tts_manager.py,sha256=Cxh302EgIycwkWxe7XntmLW-j_WusbJOYRCs3Jms3CU,9892
 abstractassistant/ui/__init__.py,sha256=aRNE2pS50nFAX6y--rSGMNYwhz905g14gRd6g4BolYU,13
 abstractassistant/ui/chat_bubble.py,sha256=bY48b4IeQzOrRN2_sJ5OazhZcJ8IMaBM6R3EexvU30Q,11885
-abstractassistant/ui/history_dialog.py,sha256=949l8fVgRpUfRGcoOVRutERVXrShYgpKkFJCxo2JG-4,19323
+abstractassistant/ui/history_dialog.py,sha256=lVyNrZVu73CZo593DvnuWU1iCpmZybTCFTjlu4RrqBM,39701
 abstractassistant/ui/provider_manager.py,sha256=9IM-BxIs6lUlk6cDCBi7oZFMXmn4CFMlxh0s-_vhzXY,8403
-abstractassistant/ui/qt_bubble.py,sha256=ujJtoDuVuXthxfXsvHX-YbqV4GuUgNp2FGy_wT3t4UY,96990
+abstractassistant/ui/qt_bubble.py,sha256=kCgj1zqWKxxvVFAroz8NDh1GtcobyhatlrcXT9PhYOI,115598
 abstractassistant/ui/toast_manager.py,sha256=1aU4DPo-J45bC61gTEctHq98ZrHIFxRfZa_9Q8KF588,13721
 abstractassistant/ui/toast_window.py,sha256=BRSwEBlaND5LLipn1HOX0ISWxVH-zOHsYplFkiPaj_g,21727
 abstractassistant/ui/tts_state_manager.py,sha256=UF_zrfl9wf0hNHBGxevcoKxW5Dh7zXibUSVoSSjGP4o,10565
@@ -19,9 +19,9 @@ abstractassistant/ui/ui_styles.py,sha256=FvE2CVUbHmHu1PKVTBBGyhbt781qh4WjLMrHvil
 abstractassistant/utils/__init__.py,sha256=7Q3BxyXETkt3tm5trhuLTyL8PoECOK0QiK-0KUVAR2Q,16
 abstractassistant/utils/icon_generator.py,sha256=SWPgi1V6_8544Zbc2vAfFXAy15H35neyUGCYt2eKoic,16475
 abstractassistant/utils/markdown_renderer.py,sha256=u5tVIhulSwRYADiqJcZNoHhU8e6pJVgzrwZRd61Bov0,12585
-abstractassistant-0.3.3.dist-info/licenses/LICENSE,sha256=QUjFNAE-0yOkW9-Rle2axkpkt9H7xiZ2VbN-VeONhxc,1106
-abstractassistant-0.3.3.dist-info/METADATA,sha256=gHXdK078vCVh3vMAdjAxEd32JPShNpV3DCkNWLlUjZ0,11564
-abstractassistant-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractassistant-0.3.3.dist-info/entry_points.txt,sha256=MIzeCh0XG6MbhIzBHtkdEjmjxYBsQrGFevq8Y1L8Jkc,118
-abstractassistant-0.3.3.dist-info/top_level.txt,sha256=qZc_LQH3CBxLq2P4B1aHayzkj8hn0euR31edkXQVzDA,18
-abstractassistant-0.3.3.dist-info/RECORD,,
+abstractassistant-0.3.4.dist-info/licenses/LICENSE,sha256=QUjFNAE-0yOkW9-Rle2axkpkt9H7xiZ2VbN-VeONhxc,1106
+abstractassistant-0.3.4.dist-info/METADATA,sha256=CXoP8mvao4NdI9qmyght-lTppQvuX3IgveQT7Ku0DVE,11564
+abstractassistant-0.3.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractassistant-0.3.4.dist-info/entry_points.txt,sha256=MIzeCh0XG6MbhIzBHtkdEjmjxYBsQrGFevq8Y1L8Jkc,118
+abstractassistant-0.3.4.dist-info/top_level.txt,sha256=qZc_LQH3CBxLq2P4B1aHayzkj8hn0euR31edkXQVzDA,18
+abstractassistant-0.3.4.dist-info/RECORD,,