Implement item deletion

src/app.rs

@@ -20,6 +20,7 @@ pub struct App {
     pub new_entry_project: String,
     pub new_entry_cursor: usize,
     pub new_entry_mode: NewEntryMode,  // Task or Project
+    pub status_message: Option<(String, std::time::Instant)>,
 }
 
 pub enum NewEntryMode {
@@ -38,10 +39,14 @@ impl App {
             new_entry_project: String::new(),
             new_entry_cursor: 0,
             new_entry_mode: NewEntryMode::Task,
+            status_message: None,
         })
     }
 
     pub fn handle_event(&mut self, event: Event) -> anyhow::Result<bool> {
+        // Update status message
+        self.update_status_message();
+        
         match self.current_screen {
             Screen::Main => self.handle_main_event(event),
             Screen::Help => self.handle_help_event(event),
@@ -69,6 +74,7 @@ impl App {
                 (KeyCode::Char('?'), _) => self.current_screen = Screen::Help,
                 (KeyCode::Char('c'), _) => self.edit_app_config()?,
                 (KeyCode::Char('n'), _) => self.start_new_entry(),
+                (KeyCode::Char('d'), _) => self.delete_current_item()?,
                 _ => {}
             },
             _ => {}
@@ -231,6 +237,73 @@ impl App {
         Ok(())
     }
 
+    fn delete_current_item(&mut self) -> anyhow::Result<()> {
+        // Check if this is the active timer
+        let should_stop = {
+            let items = match self.state.current_pane {
+                0 => &self.state.permanent_items,
+                1 => &self.state.recurring_items,
+                2 => &self.state.recent_items,
+                _ => return Ok(()),
+            };
+
+            let index = self.state.selected_indices[self.state.current_pane];
+            
+            if !items.is_empty() && index < items.len() {
+                if let Some((ref active, _)) = self.state.active_timer {
+                    items[index].name == active.name
+                } else {
+                    false
+                }
+            } else {
+                return Ok(());
+            }
+        };
+
+        // Stop timer if needed
+        if should_stop {
+            self.state.stop_timer()?;
+        }
+
+        // Now delete the item
+        let items = match self.state.current_pane {
+            0 => &mut self.state.permanent_items,
+            1 => &mut self.state.recurring_items,
+            2 => &mut self.state.recent_items,
+            _ => return Ok(()),
+        };
+
+        let index = self.state.selected_indices[self.state.current_pane];
+        
+        if !items.is_empty() && index < items.len() {
+            // Remove the item
+            items.remove(index);
+            
+            // Adjust index if we're at the end
+            if !items.is_empty() && index == items.len() {
+                self.state.selected_indices[self.state.current_pane] = items.len() - 1;
+            }
+            
+            // Save changes
+            self.state.save()?;
+        }
+        
+        Ok(())
+    }
+
+    fn set_status_message<S: Into<String>>(&mut self, message: S) {
+        self.status_message = Some((message.into(), std::time::Instant::now()));
+    }
+
+    fn update_status_message(&mut self) {
+        // Clear status message after 3 seconds
+        if let Some((_, instant)) = self.status_message {
+            if instant.elapsed().as_secs() >= 3 {
+                self.status_message = None;
+            }
+        }
+    }
+
     fn start_new_entry(&mut self) {
         self.current_screen = Screen::NewEntry;
         self.new_entry_buffer.clear();