Initial commit: TUI Watson time tracker implementation

src/app.rs

@@ -0,0 +1,128 @@
+use std::process::Command;
+use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+use crate::state::{AppState, TimeItem};
+
+pub struct App {
+    pub state: AppState,
+}
+
+impl App {
+    pub fn new() -> anyhow::Result<Self> {
+        Ok(Self {
+            state: AppState::load()?,
+        })
+    }
+
+    pub fn handle_event(&mut self, event: Event) -> anyhow::Result<bool> {
+        match event {
+            Event::Key(KeyEvent {
+                code,
+                modifiers,
+                ..
+            }) => match (code, modifiers) {
+                (KeyCode::Char('q'), _) => return Ok(true),
+                (KeyCode::Char('j'), _) | (KeyCode::Down, _) => self.move_selection(1),
+                (KeyCode::Char('k'), _) | (KeyCode::Up, _) => self.move_selection(-1),
+                (KeyCode::Char('h'), _) | (KeyCode::Left, _) => self.change_pane(-1),
+                (KeyCode::Char('l'), _) | (KeyCode::Right, _) => self.change_pane(1),
+                (KeyCode::Enter, _) => self.toggle_current_item()?,
+                (KeyCode::Char('e'), KeyModifiers::CONTROL) => self.edit_config()?,
+                _ => {}
+            },
+            _ => {}
+        }
+        Ok(false)
+    }
+
+    fn move_selection(&mut self, delta: i32) {
+        let items_len = match self.state.current_pane {
+            0 => self.state.permanent_items.len(),
+            1 => self.state.recurring_items.len(),
+            2 => self.state.recent_items.len(),
+            _ => return,
+        };
+
+        if items_len == 0 {
+            return;
+        }
+
+        let current = self.state.selected_indices[self.state.current_pane] as i32;
+        let new_index = (current + delta).rem_euclid(items_len as i32) as usize;
+        self.state.selected_indices[self.state.current_pane] = new_index;
+    }
+
+    fn change_pane(&mut self, delta: i32) {
+        self.state.current_pane = ((self.state.current_pane as i32 + delta).rem_euclid(3)) as usize;
+    }
+
+    fn get_current_item(&self) -> Option<TimeItem> {
+        let items = match self.state.current_pane {
+            0 => &self.state.permanent_items,
+            1 => &self.state.recurring_items,
+            2 => &self.state.recent_items,
+            _ => return None,
+        };
+
+        let index = self.state.selected_indices[self.state.current_pane];
+        items.get(index).cloned()
+    }
+
+    fn toggle_current_item(&mut self) -> anyhow::Result<()> {
+        if let Some(item) = self.get_current_item() {
+            if self.state.active_timer.as_ref().map(|(active, _)| active.name == item.name).unwrap_or(false) {
+                self.state.stop_timer()?;
+            } else {
+                self.state.start_timer(item)?;
+            }
+            self.state.save()?;
+        }
+        Ok(())
+    }
+
+    fn edit_config(&self) -> anyhow::Result<()> {
+        let editor = std::env::var("EDITOR").unwrap_or_else(|_| "vi".to_string());
+        let config_path = AppState::config_file()?;
+        
+        if !config_path.exists() {
+            std::fs::write(&config_path, "# WAT Configuration\n# Add your permanent items here\n\npermanent_items:\n  - name: Daily Standup\n    tags: [daily, meeting]\n")?;
+        }
+
+        Command::new(editor)
+            .arg(&config_path)
+            .spawn()?
+            .wait()?;
+
+        // Reload configuration
+        if config_path.exists() {
+            let contents = std::fs::read_to_string(config_path)?;
+            let config: serde_yaml::Value = serde_yaml::from_str(&contents)?;
+            
+            if let Some(items) = config["permanent_items"].as_sequence() {
+                // Clear existing permanent items
+                self.state.permanent_items.clear();
+                
+                // Add new items from config
+                for item in items {
+                    if let (Some(name), Some(tags)) = (
+                        item["name"].as_str(),
+                        item["tags"].as_sequence()
+                    ) {
+                        let tags = tags
+                            .iter()
+                            .filter_map(|t| t.as_str())
+                            .map(String::from)
+                            .collect();
+                            
+                        self.state.permanent_items.push(TimeItem {
+                            name: name.to_string(),
+                            tags,
+                            last_used: None,
+                        });
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}