items deleted in paprika will now delete in skylight

aarons22 · aarons22 · commit ce058363d27f · 2026-01-31T12:49:24.000-05:00
diff --git a/whisk/multi_sync_engine.py b/whisk/multi_sync_engine.py
@@ -564,13 +564,55 @@ def _handle_deleted_items(self, pair: ListPairConfig,
                               skylight_items: List[ListItem],
                               changes: Dict[str, List[str]]) -> None:
         """Handle items that were deleted from one of the services"""
-        # For now, we'll implement a simplified version that focuses on core functionality
-        # This can be enhanced later to handle deletion detection more robustly
         try:
-            logger.debug("Deletion handling is simplified in this version")
-            # TODO: Implement robust deletion detection
-            # This would require tracking which items existed in previous sync
-            # and comparing with current state
+            logger.debug("Handling deleted items...")
+
+            # Get list UIDs for database queries
+            pair_id = f"{pair.paprika_list}___{pair.skylight_list}"
+            paprika_list_uid = pair_id.split('___')[0]  # Use paprika list name as UID
+            skylight_list_id = pair_id.split('___')[1]  # Use skylight list name as list_id
+
+            # Get all linked items for this pair from database
+            linked_items = self.state_manager.get_linked_items_for_pair(paprika_list_uid, skylight_list_id)
+
+            # Create sets of current item IDs for fast lookup
+            current_paprika_ids = {item.paprika_id for item in paprika_items if item.paprika_id}
+            current_skylight_ids = {item.skylight_id for item in skylight_items if item.skylight_id}
+
+            # Find items that were in database but missing from current API responses
+            deleted_skylight_ids = []
+            deleted_item_names = []
+
+            for link in linked_items:
+                paprika_item = link.paprika_item
+                skylight_item = link.skylight_item
+
+                # Check for Paprika → Skylight deletions
+                # If Paprika item is missing from current response, delete from Skylight
+                if paprika_item and paprika_item.paprika_id not in current_paprika_ids:
+                    if skylight_item and skylight_item.skylight_id:
+                        deleted_skylight_ids.append(skylight_item.skylight_id)
+                        deleted_item_names.append(paprika_item.name)
+                        logger.debug(f"Item '{paprika_item.name}' deleted from Paprika, will remove from Skylight")
+
+            # Bulk delete items from Skylight if any found
+            if deleted_skylight_ids:
+                logger.info(f"Found {len(deleted_skylight_ids)} items deleted from Paprika, removing from Skylight")
+                try:
+                    self.skylight_client.bulk_delete_items(deleted_skylight_ids, pair.skylight_list)
+                    changes['skylight_deleted'].extend(deleted_item_names)
+                    logger.info(f"Successfully deleted {len(deleted_skylight_ids)} items from Skylight")
+                except Exception as e:
+                    logger.error(f"Failed to bulk delete items from Skylight: {e}")
+                    # Continue processing - don't fail entire sync for deletion failures
+
+            # Note: We only handle Paprika → Skylight deletions because:
+            # 1. Paprika doesn't support true deletion (only marking as purchased)
+            # 2. The focus is on handling items deleted from Paprika appearing in Skylight
+            # 3. This matches the plan requirements
+
+            logger.debug(f"Deletion handling completed: {len(deleted_skylight_ids)} items removed from Skylight")
+
         except Exception as e:
             logger.error(f"Failed to handle deleted items: {e}")
             raise
diff --git a/whisk/skylight_client.py b/whisk/skylight_client.py
@@ -573,42 +573,69 @@ def update_item(self, skylight_id: str, checked: bool, name: Optional[str] = Non
             logger.error(f"Failed to update item in Skylight: {e}")
             raise
 
-    def remove_item(self, skylight_id: str, list_name: str = None) -> None:
+    def bulk_delete_items(self, skylight_ids: List[str], list_name: str) -> None:
         """
-        Remove item from list
+        Remove multiple items from list using bulk destroy endpoint
 
         Args:
-            skylight_id: Skylight ID of the item to remove
-            list_name: Optional list name to search in (REQUIRED for security)
+            skylight_ids: List of Skylight IDs of items to remove
+            list_name: Name of the list to remove items from (REQUIRED for security)
         """
         try:
-            logger.debug(f"Removing item from Skylight: {skylight_id}")
+            if not skylight_ids:
+                logger.debug("No items to delete")
+                return
+
+            logger.debug(f"Bulk removing {len(skylight_ids)} items from Skylight list '{list_name}': {skylight_ids}")
 
             if not list_name:
                 raise ValueError("list_name is required - will not search all lists for security")
 
-            list_id = None
+            # Get the list ID
+            list_id = self.get_list_id_by_name(list_name)
+            if not list_id:
+                raise Exception(f"List '{list_name}' not found")
 
-            # Only search in the specified list (NEVER search other lists)
-            try:
-                target_list_id = self.get_list_id_by_name(list_name)
-                if not target_list_id:
-                    raise Exception(f"List '{list_name}' not found")
-
-                # Check if item exists in this specific list
-                items = self.get_list_items(list_name)
-                if any(item.skylight_id == skylight_id for item in items):
-                    list_id = target_list_id
-                    logger.debug(f"Found item {skylight_id} in target list '{list_name}'")
+            # Verify all items exist in this specific list (optional validation)
+            existing_items = self.get_list_items(list_name)
+            existing_ids = {item.skylight_id for item in existing_items}
+
+            # Filter out items that don't exist (log warning but don't fail)
+            valid_ids = []
+            for skylight_id in skylight_ids:
+                if skylight_id in existing_ids:
+                    valid_ids.append(skylight_id)
                 else:
-                    raise Exception(f"Item {skylight_id} not found in list '{list_name}'")
+                    logger.warning(f"Item {skylight_id} not found in list '{list_name}' - skipping")
 
-            except Exception as e:
-                raise Exception(f"Cannot remove item {skylight_id}: {e}")
+            if not valid_ids:
+                logger.info("No valid items to delete after validation")
+                return
+
+            # Use bulk destroy endpoint - the only working deletion method
+            endpoint = f"/frames/{self.frame_id}/lists/{list_id}/list_items/bulk_destroy"
+            payload = {"ids": valid_ids}
+
+            self._make_request("DELETE", endpoint, payload)
+            logger.info(f"Bulk removed {len(valid_ids)} items from Skylight list '{list_name}': {valid_ids}")
+
+        except Exception as e:
+            logger.error(f"Failed to bulk remove items from Skylight: {e}")
+            raise
+
+    def remove_item(self, skylight_id: str, list_name: str = None) -> None:
+        """
+        Remove single item from list (wrapper around bulk delete)
+
+        Args:
+            skylight_id: Skylight ID of the item to remove
+            list_name: Name of the list to search in (REQUIRED for security)
+        """
+        try:
+            logger.debug(f"Removing single item from Skylight: {skylight_id}")
 
-            # DELETE request
-            self._make_request("DELETE", f"/frames/{self.frame_id}/lists/{list_id}/list_items/{skylight_id}")
-            logger.info(f"Removed item from Skylight list '{list_name}': {skylight_id}")
+            # Use bulk delete for single item (since individual delete doesn't work)
+            self.bulk_delete_items([skylight_id], list_name)
 
         except Exception as e:
             logger.error(f"Failed to remove item from Skylight: {e}")
diff --git a/whisk/state_manager.py b/whisk/state_manager.py
@@ -578,6 +578,69 @@ def create_item_link(self, paprika_item_id: int, skylight_item_id: int,
             logger.error(f"Failed to create item link: {e}")
             raise
 
+    def get_linked_items_for_pair(self, paprika_list_uid: str, skylight_list_id: str) -> List[ItemLink]:
+        """
+        Get all linked items for a specific list pair
+
+        Args:
+            paprika_list_uid: Paprika list UID
+            skylight_list_id: Skylight list ID
+
+        Returns:
+            List of ItemLink objects with full item details
+        """
+        try:
+            cursor = self.conn.cursor()
+            cursor.execute("""
+                SELECT l.*,
+                       p.paprika_id, p.list_uid, p.name as p_name, p.checked as p_checked,
+                       p.last_modified_at as p_modified, p.is_deleted as p_deleted,
+                       s.skylight_id, s.list_id, s.name as s_name, s.checked as s_checked,
+                       s.skylight_updated_at as s_updated
+                FROM item_links l
+                JOIN paprika_items p ON l.paprika_item_id = p.id
+                JOIN skylight_items s ON l.skylight_item_id = s.id
+                WHERE p.list_uid = ? AND s.list_id = ? AND p.is_deleted = 0
+            """, (paprika_list_uid, skylight_list_id))
+
+            links = []
+            for row in cursor.fetchall():
+                link = ItemLink(
+                    id=row['id'],
+                    paprika_item_id=row['paprika_item_id'],
+                    skylight_item_id=row['skylight_item_id'],
+                    linked_at=self._parse_datetime(row['linked_at']),
+                    confidence_score=row['confidence_score']
+                )
+
+                # Attach item details
+                link.paprika_item = PaprikaItem(
+                    id=row['paprika_item_id'],
+                    paprika_id=row['paprika_id'],
+                    list_uid=row['list_uid'],
+                    name=row['p_name'],
+                    checked=bool(row['p_checked']),
+                    last_modified_at=self._parse_datetime(row['p_modified']),
+                    is_deleted=bool(row['p_deleted'])
+                )
+
+                link.skylight_item = SkylightItem(
+                    id=row['skylight_item_id'],
+                    skylight_id=row['skylight_id'],
+                    list_id=row['list_id'],
+                    name=row['s_name'],
+                    checked=bool(row['s_checked']),
+                    skylight_updated_at=self._parse_datetime(row['s_updated'])
+                )
+
+                links.append(link)
+
+            return links
+
+        except Exception as e:
+            logger.error(f"Failed to get linked items for pair: {e}")
+            raise
+
     def get_linked_items_with_conflicts(self) -> List[ItemLink]:
         """Get linked items where Paprika and Skylight have different checked states"""
         try:
